Files
outline/server/storage/files/BaseStorage.test.ts
Yinhao HuangandClaude Opus 4.8 6286d08171 feat: support presigned PUT uploads for S3-compatible storage (#12748)
* feat: support presigned PUT uploads for S3-compatible storage

Add `AWS_S3_UPLOAD_METHOD` config ("post" default / "put") so providers
that do not implement presigned POST (e.g. Cloudflare R2) can use
presigned PUT instead.

- BaseStorage.getPresignedPut() returns undefined by default; S3Storage
  overrides with PutObjectCommand + getSignedUrl.
- Content-Length is signed into the presigned PUT URL so S3 rejects
  uploads that do not match the declared size.
- API route and MCP tool branch on the config: only one upload method
  is returned per request.
- Frontend uses existing presignedPutUrl presence check — unchanged.
- When put is configured but unsupported (e.g. LocalStorage), a clear
  InvalidRequestError is returned.

Defaults to "post" — zero behavior change for existing deployments.

* refactor: return explicit upload mode instead of inferring from fields

Address review feedback from @tommoor: the client should not need to
infer the upload method from the presence of presigned-PUT-specific
fields. The API now returns an explicit `mode` ("put" | "post"), and the
PUT branch uses generic `url` / `headers` fields so the client has no
special knowledge of "presigned puts".

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

* refactor: use this.getBucket() in presigned post/put methods

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.8 <noreply@anthropic.com>
2026-06-24 21:05:16 -04:00

202 lines
5.2 KiB
TypeScript

import BaseStorage from "./BaseStorage";
import env from "@server/env";
/**
* Mock implementation of BaseStorage for testing purposes.
*/
class MockStorage extends BaseStorage {
public storedFiles: Array<{
key: string;
body: Buffer;
contentType?: string;
acl?: string;
}> = [];
async getPresignedPost() {
return {};
}
async getFileStream() {
return null;
}
getUploadUrl() {
return "https://storage.example.com";
}
getUrlForKey(key: string) {
return `https://storage.example.com/${key}`;
}
async getSignedUrl() {
return "https://storage.example.com/signed";
}
async store({
body,
contentType,
key,
acl,
}: {
body: Buffer;
contentType?: string;
key: string;
acl?: string;
}) {
this.storedFiles.push({
key,
body: body as Buffer,
contentType,
acl,
});
return this.getUrlForKey(key);
}
async getFileHandle() {
return { path: "/tmp/test", cleanup: async () => {} };
}
async getFileExists() {
return false;
}
async moveFile() {}
async deleteFile() {}
}
describe("BaseStorage", () => {
describe("getPresignedPut", () => {
it("should return undefined from default implementation", async () => {
const storage = new MockStorage();
const result = await storage.getPresignedPut(
"uploads/test/key",
"private",
1000000,
"image/png"
);
expect(result).toBeUndefined();
});
});
describe("storeFromUrl", () => {
let storage: MockStorage;
beforeEach(() => {
storage = new MockStorage();
storage.storedFiles = [];
env.FILE_STORAGE_UPLOAD_MAX_SIZE = 500;
});
describe("base64 URL size validation", () => {
it("should enforce maxUploadSize option for base64 URLs", async () => {
const largeDataSize = 1000;
const maxUploadSize = 500;
const largeBuffer = Buffer.alloc(largeDataSize, "a");
const base64Data = largeBuffer.toString("base64");
const base64Url = `data:image/png;base64,${base64Data}`;
const result = await storage.storeFromUrl(
base64Url,
"test-key",
"public-read",
undefined,
{ maxUploadSize }
);
expect(result).toBeUndefined();
expect(storage.storedFiles).toHaveLength(0);
});
it("should enforce FILE_STORAGE_UPLOAD_MAX_SIZE for base64 URLs", async () => {
const largeDataSize = 1000; // Exceeds our test limit of 500
const largeBuffer = Buffer.alloc(largeDataSize, "a");
const base64Data = largeBuffer.toString("base64");
const base64Url = `data:image/png;base64,${base64Data}`;
const result = await storage.storeFromUrl(
base64Url,
"test-key",
"public-read"
);
expect(result).toBeUndefined();
expect(storage.storedFiles).toHaveLength(0);
});
it("should allow base64 URLs within size limits", async () => {
const dataSize = 100;
const maxUploadSize = 500;
const buffer = Buffer.alloc(dataSize, "a");
const base64Data = buffer.toString("base64");
const base64Url = `data:image/png;base64,${base64Data}`;
const result = await storage.storeFromUrl(
base64Url,
"test-key",
"public-read",
undefined,
{ maxUploadSize }
);
expect(result).toBeDefined();
expect(result?.contentLength).toBe(dataSize);
expect(result?.contentType).toBe("image/png");
expect(storage.storedFiles).toHaveLength(1);
expect(storage.storedFiles[0].body.byteLength).toBe(dataSize);
});
it("should use the minimum of maxUploadSize and FILE_STORAGE_UPLOAD_MAX_SIZE", async () => {
// Create data that's larger than maxUploadSize but smaller than FILE_STORAGE_UPLOAD_MAX_SIZE
const maxUploadSize = 200;
const dataSize = 300;
const buffer = Buffer.alloc(dataSize, "a");
const base64Data = buffer.toString("base64");
const base64Url = `data:image/png;base64,${base64Data}`;
const result = await storage.storeFromUrl(
base64Url,
"test-key",
"public-read",
undefined,
{ maxUploadSize }
);
// Should be rejected because it exceeds maxUploadSize even though it's under FILE_STORAGE_UPLOAD_MAX_SIZE
expect(result).toBeUndefined();
expect(storage.storedFiles).toHaveLength(0);
});
it("should return undefined for empty base64 data", async () => {
const base64Url = "data:image/png;base64,";
const result = await storage.storeFromUrl(
base64Url,
"test-key",
"public-read"
);
expect(result).toBeUndefined();
expect(storage.storedFiles).toHaveLength(0);
});
});
describe("internal URL handling", () => {
it("should return undefined for URLs already on the storage provider", async () => {
const result = await storage.storeFromUrl(
"https://storage.example.com/existing-file.png",
"test-key",
"public-read"
);
expect(result).toBeUndefined();
expect(storage.storedFiles).toHaveLength(0);
});
});
});
});