import { describe, expect, it, vi } from "vitest"; import { mkdtemp, readFile } from "node:fs/promises"; import { tmpdir } from "node:os"; import { join } from "node:path"; import { DeleteObjectCommand, PutObjectCommand, StorageAdapterError, createLocalStorageAdapter, createS3StorageAdapter, type S3StorageAdapterConfig, } from "./index.js"; const baseConfig: S3StorageAdapterConfig = { endpoint: "https://s3.example.test", region: "us-east-1", bucket: "uploads", accessKeyId: "access-key", secretAccessKey: "secret-key", }; describe("createS3StorageAdapter", () => { it("sends PutObjectCommand input and returns object identity", async () => { const send = vi.fn().mockResolvedValue({}); const adapter = createS3StorageAdapter({ ...baseConfig, client: { send } }); await expect( adapter.putObject({ key: "avatars/user.png", body: "file contents", contentType: "image/png", cacheControl: "public, max-age=3600", metadata: { tenant: "acme" }, }), ).resolves.toEqual({ bucket: "uploads", key: "avatars/user.png", publicUrl: null, }); expect(send).toHaveBeenCalledOnce(); const command = send.mock.calls[0]?.[0]; expect(command).toBeInstanceOf(PutObjectCommand); expect(command.input).toEqual({ Bucket: "uploads", Key: "avatars/user.png", Body: "file contents", ContentType: "image/png", CacheControl: "public, max-age=3600", Metadata: { tenant: "acme" }, }); }); it("constructs public URLs by encoding key segments", async () => { const adapter = createS3StorageAdapter({ ...baseConfig, publicBaseUrl: "https://cdn.example.test/assets/", client: { send: vi.fn().mockResolvedValue({}) }, }); await expect( adapter.putObject({ key: "tenant one/folder/avatar #1.png", body: new Uint8Array([1, 2, 3]), }), ).resolves.toMatchObject({ publicUrl: "https://cdn.example.test/assets/tenant%20one/folder/avatar%20%231.png", }); }); it("throws redacted diagnostics for missing required config", () => { const config = { endpoint: "", region: "us-east-1", bucket: "", accessKeyId: "provided-access-key", secretAccessKey: "provided-secret-key", } satisfies S3StorageAdapterConfig; expect(() => createS3StorageAdapter(config)).toThrow(StorageAdapterError); try { createS3StorageAdapter(config); } catch (error) { expect(error).toBeInstanceOf(StorageAdapterError); const adapterError = error as StorageAdapterError; expect(adapterError.code).toBe("config_missing"); expect(adapterError.details).toEqual({ operation: "createS3StorageAdapter", missingFields: ["endpoint", "bucket"], }); expect(JSON.stringify(adapterError)).not.toContain("provided-access-key"); expect(JSON.stringify(adapterError)).not.toContain("provided-secret-key"); } }); it("wraps upstream send failures with redacted request metadata", async () => { const upstreamError = Object.assign( new Error("signature mismatch for credential secret-key"), { name: "SignatureDoesNotMatch", $metadata: { httpStatusCode: 403, requestId: "req-123" }, responseBody: "full upstream response should not be copied", }, ); const adapter = createS3StorageAdapter({ ...baseConfig, client: { send: vi.fn().mockRejectedValue(upstreamError) }, }); await expect( adapter.putObject({ key: "private/report.pdf", body: "body-secret" }), ).rejects.toMatchObject({ name: "StorageAdapterError", code: "put_failed", details: { operation: "putObject", bucket: "uploads", key: "private/report.pdf", upstream: { name: "SignatureDoesNotMatch", message: "signature mismatch for credential [redacted]", status: 403, requestId: "req-123", }, }, }); }); it("does not copy credentials, session tokens, or request bodies into structured diagnostics", async () => { const upstreamError = Object.assign(new Error("upstream failed"), { accessKeyId: "access-key", secretAccessKey: "secret-key", sessionToken: "session-token", body: "request-body", $metadata: { httpStatusCode: 500, requestId: "req-500" }, }); const adapter = createS3StorageAdapter({ ...baseConfig, sessionToken: "session-token", client: { send: vi.fn().mockRejectedValue(upstreamError) }, }); try { await adapter.putObject({ key: "upload.txt", body: "request-body" }); throw new Error("expected putObject to fail"); } catch (error) { expect(error).toBeInstanceOf(StorageAdapterError); const serializedDetails = JSON.stringify((error as StorageAdapterError).details); expect(serializedDetails).not.toContain("access-key"); expect(serializedDetails).not.toContain("secret-key"); expect(serializedDetails).not.toContain("session-token"); expect(serializedDetails).not.toContain("request-body"); expect(serializedDetails).not.toContain("responseBody"); } }); it("sends DeleteObjectCommand input and defaults to the configured bucket", async () => { const send = vi.fn().mockResolvedValue({}); const adapter = createS3StorageAdapter({ ...baseConfig, client: { send } }); await expect( adapter.deleteObject({ key: "exports/job-123.csv" }), ).resolves.toEqual({ bucket: "uploads", key: "exports/job-123.csv", }); expect(send).toHaveBeenCalledOnce(); const command = send.mock.calls[0]?.[0]; expect(command).toBeInstanceOf(DeleteObjectCommand); expect(command.input).toEqual({ Bucket: "uploads", Key: "exports/job-123.csv", }); }); it("allows deleteObject to target an explicit bucket", async () => { const send = vi.fn().mockResolvedValue({}); const adapter = createS3StorageAdapter({ ...baseConfig, client: { send } }); await expect( adapter.deleteObject({ bucket: "archive", key: "exports/job-123.csv" }), ).resolves.toEqual({ bucket: "archive", key: "exports/job-123.csv", }); expect(send.mock.calls[0]?.[0].input).toEqual({ Bucket: "archive", Key: "exports/job-123.csv", }); }); it("forwards an abort signal to bounded S3 deletions", async () => { const send = vi.fn().mockResolvedValue({}); const adapter = createS3StorageAdapter({ ...baseConfig, client: { send } }); const controller = new AbortController(); await adapter.deleteObject({ key: "exports/job-123.csv", signal: controller.signal }); expect(send).toHaveBeenCalledWith(expect.any(DeleteObjectCommand), { abortSignal: controller.signal }); }); it("rejects invalid delete keys and buckets before sending to S3", async () => { const send = vi.fn().mockResolvedValue({}); const adapter = createS3StorageAdapter({ ...baseConfig, client: { send } }); await expect(adapter.deleteObject({ key: " " })).rejects.toMatchObject({ code: "invalid_key", details: { operation: "deleteObject", bucket: "uploads", key: " " }, }); await expect( adapter.deleteObject({ bucket: " ", key: "exports/job-123.csv" }), ).rejects.toMatchObject({ code: "invalid_bucket", details: { operation: "deleteObject", bucket: " ", key: "exports/job-123.csv", }, }); expect(send).not.toHaveBeenCalled(); }); it("wraps deleteObject failures with redacted upstream diagnostics", async () => { const upstreamError = Object.assign( new Error("delete failed token abc123 credential secret-key"), { name: "AccessDenied", $metadata: { httpStatusCode: 403, requestId: "req-delete" }, body: "delete-request-body", }, ); const adapter = createS3StorageAdapter({ ...baseConfig, client: { send: vi.fn().mockRejectedValue(upstreamError) }, }); try { await adapter.deleteObject({ key: "exports/job-123.csv" }); throw new Error("expected deleteObject to fail"); } catch (error) { expect(error).toBeInstanceOf(StorageAdapterError); const adapterError = error as StorageAdapterError; expect(adapterError).toMatchObject({ code: "delete_failed", details: { operation: "deleteObject", bucket: "uploads", key: "exports/job-123.csv", upstream: { name: "AccessDenied", message: "delete failed token [redacted] credential [redacted]", status: 403, requestId: "req-delete", }, }, }); expect(JSON.stringify(adapterError.details)).not.toContain("abc123"); expect(JSON.stringify(adapterError.details)).not.toContain("secret-key"); expect(JSON.stringify(adapterError.details)).not.toContain("delete-request-body"); } }); }); describe("createLocalStorageAdapter", () => { it("stores objects under the configured bucket root and returns a public URL", async () => { const rootDir = await mkdtemp(join(tmpdir(), "hivegrid-storage-")); const adapter = createLocalStorageAdapter({ rootDir, bucket: "uploads", publicBaseUrl: "http://localhost:3000/storage", }); await expect(adapter.putObject({ key: "tenants/acme/avatar.png", body: "image" })).resolves.toEqual({ bucket: "uploads", key: "tenants/acme/avatar.png", publicUrl: "http://localhost:3000/storage/uploads/tenants/acme/avatar.png", }); await expect(readFile(join(rootDir, "uploads", "tenants", "acme", "avatar.png"), "utf8")).resolves.toBe("image"); }); it("rejects local object keys that escape the storage root", async () => { const rootDir = await mkdtemp(join(tmpdir(), "hivegrid-storage-")); const adapter = createLocalStorageAdapter({ rootDir, bucket: "uploads" }); await expect(adapter.putObject({ key: "../secret.txt", body: "secret" })).rejects.toMatchObject({ code: "invalid_key", details: { operation: "normalizeLocalObjectKey", key: "../secret.txt", }, }); }); });