Update hivegrid-cloud reference to latest main

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
This commit is contained in:
davidandClaude Fable 5 committed 2026-07-08 16:15:37 +02:00
1 parent e98d38e716
commit 7b21524c86
3781 files changed
+373484 -225607

No files matched your search

@@ -0,0 +1,108 @@
import { describe, expect, it, vi } from "vitest";
import { StorageAdapterError, createS3SignedUrlAdapter } from "../index.js";
function createAdapter(overrides: Partial<Parameters<typeof createS3SignedUrlAdapter>[0]> = {}) {
return createS3SignedUrlAdapter({
bucket: "uploads",
now: () => new Date("2026-01-01T00:00:00.000Z"),
uploadSigner: vi.fn().mockResolvedValue("https://signed.example.test/upload"),
downloadSigner: vi.fn().mockResolvedValue("https://signed.example.test/download"),
...overrides,
});
}
describe("createS3SignedUrlAdapter upload header assembly", () => {
it("omits content-type, content-length, and checksum headers when none were supplied", async () => {
const adapter = createAdapter();
const result = await adapter.createSignedUploadUrl({
key: "avatars/user.png",
expiresInSeconds: 60,
headers: { "x-amz-acl": "private" },
});
// Only the caller-provided header should survive; the conditional spreads
// must contribute nothing when the inputs are absent.
expect(result.headers).toEqual({ "x-amz-acl": "private" });
expect(result.headers).not.toHaveProperty("content-type");
expect(result.headers).not.toHaveProperty("content-length");
expect(result.headers).not.toHaveProperty("x-amz-checksum-sha256");
expect(result.metadata).toEqual({});
});
it("emits a content-length header for a zero-byte upload (typeof number, not truthiness)", async () => {
const adapter = createAdapter();
const result = await adapter.createSignedUploadUrl({
key: "avatars/empty.bin",
expiresInSeconds: 60,
contentLength: 0,
});
// contentLength is gated on `typeof === "number"`, so 0 must still appear.
expect(result.headers["content-length"]).toBe("0");
expect(result.headers).not.toHaveProperty("content-type");
});
it("drops blank metadata and header keys during normalization", async () => {
const adapter = createAdapter();
const result = await adapter.createSignedUploadUrl({
key: "avatars/user.png",
expiresInSeconds: 60,
metadata: { tenant: "acme", " ": "blank-key" },
headers: { "x-keep": "yes", "": "blank-header" },
});
expect(result.metadata).toEqual({ tenant: "acme" });
expect(result.headers).toEqual({ "x-keep": "yes" });
});
});
describe("createS3SignedUrlAdapter upstream redaction edge cases", () => {
it("returns all-undefined upstream fields when the cause is a record without diagnostics", async () => {
const adapter = createAdapter({
uploadSigner: vi.fn().mockRejectedValue({ internalSecret: "do-not-leak" }),
});
try {
await adapter.createSignedUploadUrl({ key: "a.png", expiresInSeconds: 60 });
throw new Error("expected signer to fail");
} catch (error) {
expect(error).toBeInstanceOf(StorageAdapterError);
const adapterError = error as StorageAdapterError;
expect(adapterError.code).toBe("signed_upload_failed");
expect(adapterError.details.upstream?.name).toBeUndefined();
expect(adapterError.details.upstream?.message).toBeUndefined();
expect(adapterError.details.upstream?.status).toBeUndefined();
expect(adapterError.details.upstream?.requestId).toBeUndefined();
// Arbitrary thrown fields are never copied into the diagnostic.
expect(JSON.stringify(adapterError.details)).not.toContain("do-not-leak");
}
});
it("ignores a non-record $metadata and non-string name/message on the cause", async () => {
const adapter = createAdapter({
downloadSigner: vi.fn().mockRejectedValue({
$metadata: "not-a-record",
name: 123,
message: { nested: true },
}),
});
try {
await adapter.createSignedDownloadUrl({ key: "a.png", expiresInSeconds: 60 });
throw new Error("expected signer to fail");
} catch (error) {
expect(error).toBeInstanceOf(StorageAdapterError);
const adapterError = error as StorageAdapterError;
expect(adapterError.code).toBe("signed_download_failed");
const upstream = adapterError.details.upstream;
expect(upstream?.status).toBeUndefined();
expect(upstream?.requestId).toBeUndefined();
expect(upstream?.name).toBeUndefined();
expect(upstream?.message).toBeUndefined();
}
});
});