mirror of
https://github.com/outline/outline.git
synced 2026-11-22 14:01:41 +03:00
* 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>
202 lines
5.2 KiB
TypeScript
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);
|
|
});
|
|
});
|
|
});
|
|
});
|