@powerhousedao/switchboard 6.1.0-staging.0 → 6.2.0-dev.0

package/test/attachments/routes.test.ts

@@ -701,7 +701,428 @@ describe("attachment routes", () => {
     expect(h1).toBe(h2);
   });
 
+  describe("hash-first reserve: 409 already_exists", () => {
+    it("returns 409 { error: already_exists, ref } when hash is already available", async () => {
+      // Upload a file first using the legacy flow to populate the store.
+      const reserveHandler = makeReserveHandler(attachments);
+      const uploadHandler = makeUploadHandler(attachments);
+
+      const legacyReserveReq = makeReq({
+        method: "POST",
+        body: JSON.stringify({ mimeType: "text/plain", fileName: "dup.txt" }),
+      });
+      const legacyReserveRes = makeRes();
+      await reserveHandler(legacyReserveReq, legacyReserveRes);
+      await waitFor(legacyReserveRes);
+      const { reservationId: legacyId } = JSON.parse(
+        legacyReserveRes._body.toString("utf8"),
+      ) as { reservationId: string };
+
+      const payload = "deduplicated content";
+      const uploadReq = makeReq({
+        method: "PUT",
+        params: { reservationId: legacyId },
+        body: payload,
+      });
+      const uploadRes = makeRes();
+      await uploadHandler(uploadReq, uploadRes);
+      await waitFor(uploadRes);
+      const { hash: existingHash, ref: existingRef } = JSON.parse(
+        uploadRes._body.toString("utf8"),
+      ) as { hash: string; ref: string };
+
+      // Now reserve with clientHash pointing at the existing content.
+      const hashFirstReq = makeReq({
+        method: "POST",
+        body: JSON.stringify({
+          mimeType: "text/plain",
+          fileName: "dup.txt",
+          clientHash: existingHash,
+          sizeBytes: Buffer.byteLength(payload, "utf8"),
+        }),
+      });
+      const hashFirstRes = makeRes();
+      await reserveHandler(hashFirstReq, hashFirstRes);
+      await waitFor(hashFirstRes);
+
+      expect(hashFirstRes.statusCode).toBe(409);
+      const body = JSON.parse(hashFirstRes._body.toString("utf8")) as {
+        error: string;
+        ref: string;
+        reservationId?: string;
+      };
+      expect(body.error).toBe("already_exists");
+      expect(body.ref).toBe(existingRef);
+      // The 409 body must not expose another reservation's ID.
+      expect("reservationId" in body).toBe(false);
+    });
+
+    it("reserve 201 body includes reservationId, ref, and expiresAtUtc in hash-first mode", async () => {
+      const { createHash } = await import("node:crypto");
+      const payload = "some content for hash-first";
+      const hash = createHash("sha256").update(payload, "utf8").digest("hex");
+
+      const handler = makeReserveHandler(attachments);
+      const req = makeReq({
+        method: "POST",
+        body: JSON.stringify({
+          mimeType: "text/plain",
+          fileName: "hashfirst.txt",
+          clientHash: hash,
+          sizeBytes: Buffer.byteLength(payload, "utf8"),
+        }),
+      });
+      const res = makeRes();
+      await handler(req, res);
+      await waitFor(res);
+
+      expect(res.statusCode).toBe(201);
+      const body = JSON.parse(res._body.toString("utf8")) as {
+        reservationId: string;
+        ref: string | null;
+        expiresAtUtc: string;
+      };
+      expect(typeof body.reservationId).toBe("string");
+      expect(body.ref).toBe(`attachment://v1:${hash}`);
+      expect(typeof body.expiresAtUtc).toBe("string");
+      expect(new Date(body.expiresAtUtc).toString()).not.toBe("Invalid Date");
+    });
+  });
+
+  describe("hash-first upload: 422 responses", () => {
+    it("returns 422 { error: hash_mismatch, claimed, actual } when uploaded bytes hash differently", async () => {
+      const { createHash } = await import("node:crypto");
+
+      // claimedContent and wrongContent must be the same byte length so that
+      // sizeBytes matches and the server reaches the hash check (not size check).
+      const claimedContent = "AAAAAAAAAAAAAAAA"; // 16 bytes
+      const wrongContent = "BBBBBBBBBBBBBBBB"; // 16 bytes, different hash
+      expect(Buffer.byteLength(claimedContent, "utf8")).toBe(
+        Buffer.byteLength(wrongContent, "utf8"),
+      );
+
+      const claimedHash = createHash("sha256")
+        .update(claimedContent, "utf8")
+        .digest("hex");
+      const sizeBytes = Buffer.byteLength(claimedContent, "utf8");
+
+      // Reserve with the claimed hash.
+      const reserveHandler = makeReserveHandler(attachments);
+      const reserveReq = makeReq({
+        method: "POST",
+        body: JSON.stringify({
+          mimeType: "text/plain",
+          fileName: "mismatch.txt",
+          clientHash: claimedHash,
+          sizeBytes,
+        }),
+      });
+      const reserveRes = makeRes();
+      await reserveHandler(reserveReq, reserveRes);
+      await waitFor(reserveRes);
+      expect(reserveRes.statusCode).toBe(201);
+      const { reservationId } = JSON.parse(
+        reserveRes._body.toString("utf8"),
+      ) as { reservationId: string };
+
+      // Upload wrongContent (same length, different hash).
+      const uploadHandler = makeUploadHandler(attachments);
+      const uploadReq = makeReq({
+        method: "PUT",
+        params: { reservationId },
+        body: wrongContent,
+      });
+      const uploadRes = makeRes();
+      await uploadHandler(uploadReq, uploadRes);
+      await waitFor(uploadRes);
+
+      expect(uploadRes.statusCode).toBe(422);
+      const body = JSON.parse(uploadRes._body.toString("utf8")) as {
+        error: string;
+        claimed: string;
+        actual: string;
+      };
+      expect(body.error).toBe("hash_mismatch");
+      expect(body.claimed).toBe(claimedHash);
+      expect(typeof body.actual).toBe("string");
+      expect(body.actual).not.toBe(claimedHash);
+    });
+
+    it("returns 422 { error: size_mismatch, declared, actual } when byte count differs from declared sizeBytes", async () => {
+      const { createHash } = await import("node:crypto");
+      const actualContent = "short";
+      const declaredSize = 9999;
+      const claimedHash = createHash("sha256")
+        .update(actualContent, "utf8")
+        .digest("hex");
+
+      const reserveHandler = makeReserveHandler(attachments);
+      const reserveReq = makeReq({
+        method: "POST",
+        body: JSON.stringify({
+          mimeType: "text/plain",
+          fileName: "sizemismatch.txt",
+          clientHash: claimedHash,
+          sizeBytes: declaredSize,
+        }),
+      });
+      const reserveRes = makeRes();
+      await reserveHandler(reserveReq, reserveRes);
+      await waitFor(reserveRes);
+      expect(reserveRes.statusCode).toBe(201);
+      const { reservationId } = JSON.parse(
+        reserveRes._body.toString("utf8"),
+      ) as { reservationId: string };
+
+      const uploadHandler = makeUploadHandler(attachments);
+      const uploadReq = makeReq({
+        method: "PUT",
+        params: { reservationId },
+        body: actualContent,
+      });
+      const uploadRes = makeRes();
+      await uploadHandler(uploadReq, uploadRes);
+      await waitFor(uploadRes);
+
+      expect(uploadRes.statusCode).toBe(422);
+      const body = JSON.parse(uploadRes._body.toString("utf8")) as {
+        error: string;
+        declared: number;
+        actual: number;
+      };
+      expect(body.error).toBe("size_mismatch");
+      expect(body.declared).toBe(declaredSize);
+      expect(typeof body.actual).toBe("number");
+    });
+  });
+
+  describe("pending state: stat and download 202 responses", () => {
+    async function createPendingReservation(
+      content: string,
+    ): Promise<{ hash: string }> {
+      const { createHash } = await import("node:crypto");
+      const hash = createHash("sha256").update(content, "utf8").digest("hex");
+
+      const reserveHandler = makeReserveHandler(attachments);
+      const req = makeReq({
+        method: "POST",
+        body: JSON.stringify({
+          mimeType: "text/plain",
+          fileName: "pending.txt",
+          clientHash: hash,
+          sizeBytes: Buffer.byteLength(content, "utf8"),
+        }),
+      });
+      const res = makeRes();
+      await reserveHandler(req, res);
+      await waitFor(res);
+      expect(res.statusCode).toBe(201);
+      return { hash };
+    }
+
+    it("HEAD stat returns 202 with Retry-After and Attachment-Pending for pending hash", async () => {
+      const { hash } = await createPendingReservation("pending content data");
+
+      const handler = makeStatHandler(attachments);
+      const req = makeReq({ method: "HEAD", params: { hash } });
+      const res = makeRes();
+      await handler(req, res);
+      await waitFor(res);
+
+      expect(res.statusCode).toBe(202);
+      expect(res.getHeader("retry-after")).toBeTruthy();
+      const pendingHeader = res.getHeader("attachment-pending") as string;
+      expect(pendingHeader).toBeTruthy();
+      const parsed = JSON.parse(pendingHeader) as {
+        expiresAtUtc: string;
+        mimeType: string;
+        fileName: string;
+        sizeBytes: number;
+      };
+      expect(typeof parsed.expiresAtUtc).toBe("string");
+      expect(parsed.mimeType).toBe("text/plain");
+      expect(parsed.fileName).toBe("pending.txt");
+      expect(typeof parsed.sizeBytes).toBe("number");
+    });
+
+    it("HEAD stat 202 for pending hash does not set Content-Disposition or Attachment-Metadata", async () => {
+      const { hash } = await createPendingReservation("no metadata content");
+
+      const handler = makeStatHandler(attachments);
+      const req = makeReq({ method: "HEAD", params: { hash } });
+      const res = makeRes();
+      await handler(req, res);
+      await waitFor(res);
+
+      expect(res.statusCode).toBe(202);
+      expect(res.getHeader("content-disposition")).toBeFalsy();
+      expect(res.getHeader("attachment-metadata")).toBeFalsy();
+    });
+
+    it("GET download returns 202 with Retry-After and Attachment-Pending for pending hash", async () => {
+      const { hash } = await createPendingReservation("download pending data");
+
+      const handler = makeDownloadHandler(attachments);
+      const req = makeReq({ method: "GET", params: { hash } });
+      const res = makeRes();
+      await handler(req, res);
+      await waitFor(res);
+
+      expect(res.statusCode).toBe(202);
+      expect(res.getHeader("retry-after")).toBeTruthy();
+      const pendingHeader = res.getHeader("attachment-pending") as string;
+      expect(pendingHeader).toBeTruthy();
+      const parsed = JSON.parse(pendingHeader) as {
+        expiresAtUtc: string;
+      };
+      expect(typeof parsed.expiresAtUtc).toBe("string");
+    });
+
+    it("GET download 202 for pending hash must NOT set Content-Disposition or Attachment-Metadata (prevents zero-byte corruption)", async () => {
+      // Critical pin: if 202 accidentally set Content-Disposition and
+      // Attachment-Metadata, a receiving RemoteAttachmentStore would interpret
+      // the response as a successful zero-byte attachment.
+      const { hash } = await createPendingReservation("check-headers content");
+
+      const handler = makeDownloadHandler(attachments);
+      const req = makeReq({ method: "GET", params: { hash } });
+      const res = makeRes();
+      await handler(req, res);
+      await waitFor(res);
+
+      expect(res.statusCode).toBe(202);
+      expect(res.getHeader("content-disposition")).toBeFalsy();
+      expect(res.getHeader("attachment-metadata")).toBeFalsy();
+    });
+
+    it("GET download 202 body is empty (not a zero-byte attachment)", async () => {
+      const { hash } = await createPendingReservation("empty body assertion");
+
+      const handler = makeDownloadHandler(attachments);
+      const req = makeReq({ method: "GET", params: { hash } });
+      const res = makeRes();
+      await handler(req, res);
+      await waitFor(res);
+
+      expect(res.statusCode).toBe(202);
+      expect(res._body.length).toBe(0);
+    });
+  });
+
   describe("validation and header encoding", () => {
+    it("parseReserveOptions accepts valid clientHash and sizeBytes", () => {
+      const opts = parseReserveOptions({
+        mimeType: "text/plain",
+        fileName: "file.txt",
+        clientHash: "a".repeat(64),
+        sizeBytes: 1024,
+      });
+      expect(opts).not.toBeNull();
+      expect(opts!.clientHash).toBe("a".repeat(64));
+      expect(opts!.sizeBytes).toBe(1024);
+    });
+
+    it("parseReserveOptions rejects clientHash with wrong length", () => {
+      expect(
+        parseReserveOptions({
+          mimeType: "text/plain",
+          fileName: "file.txt",
+          clientHash: "abc",
+          sizeBytes: 100,
+        }),
+      ).toBeNull();
+    });
+
+    it("parseReserveOptions rejects clientHash with non-hex characters", () => {
+      expect(
+        parseReserveOptions({
+          mimeType: "text/plain",
+          fileName: "file.txt",
+          clientHash: "z".repeat(64),
+          sizeBytes: 100,
+        }),
+      ).toBeNull();
+    });
+
+    it("parseReserveOptions rejects when clientHash is present but sizeBytes is absent", () => {
+      expect(
+        parseReserveOptions({
+          mimeType: "text/plain",
+          fileName: "file.txt",
+          clientHash: "a".repeat(64),
+        }),
+      ).toBeNull();
+    });
+
+    it("parseReserveOptions ignores sizeBytes when clientHash is absent (legacy compat)", () => {
+      expect(
+        parseReserveOptions({
+          mimeType: "text/plain",
+          fileName: "file.txt",
+          sizeBytes: 100,
+        }),
+      ).toEqual({
+        mimeType: "text/plain",
+        fileName: "file.txt",
+        extension: null,
+      });
+    });
+
+    it("parseReserveOptions rejects sizeBytes of zero", () => {
+      expect(
+        parseReserveOptions({
+          mimeType: "text/plain",
+          fileName: "file.txt",
+          clientHash: "a".repeat(64),
+          sizeBytes: 0,
+        }),
+      ).toBeNull();
+    });
+
+    it("parseReserveOptions rejects negative sizeBytes", () => {
+      expect(
+        parseReserveOptions({
+          mimeType: "text/plain",
+          fileName: "file.txt",
+          clientHash: "a".repeat(64),
+          sizeBytes: -1,
+        }),
+      ).toBeNull();
+    });
+
+    it("parseReserveOptions rejects non-integer sizeBytes", () => {
+      expect(
+        parseReserveOptions({
+          mimeType: "text/plain",
+          fileName: "file.txt",
+          clientHash: "a".repeat(64),
+          sizeBytes: 1.5,
+        }),
+      ).toBeNull();
+    });
+
+    it("parseReserveOptions rejects string sizeBytes", () => {
+      expect(
+        parseReserveOptions({
+          mimeType: "text/plain",
+          fileName: "file.txt",
+          clientHash: "a".repeat(64),
+          sizeBytes: "1024",
+        }),
+      ).toBeNull();
+    });
+
+    it("parseReserveOptions normalizes uppercase clientHash to lowercase", () => {
+      const opts = parseReserveOptions({
+        mimeType: "text/plain",
+        fileName: "file.txt",
+        clientHash: "A".repeat(64),
+        sizeBytes: 1,
+      });
+      expect(opts).not.toBeNull();
+      expect(opts!.clientHash).toBe("a".repeat(64));
+    });
+
     it("parseReserveOptions rejects fileName with CR/LF", () => {
       expect(
         parseReserveOptions({

package/test/attachments/service-config.test.ts

@@ -0,0 +1,170 @@
+import { PGlite } from "@electric-sql/pglite";
+import type { API } from "@powerhousedao/reactor-api";
+import { createHttpAdapter } from "@powerhousedao/reactor-api";
+import {
+  AttachmentBuilder,
+  type AttachmentBuildResult,
+  createRemoteAttachmentService,
+} from "@powerhousedao/reactor-attachments";
+import type { IRenown } from "@renown/sdk/node";
+import { Kysely } from "kysely";
+import { PGliteDialect } from "kysely-pglite-dialect";
+import { mkdtemp, rm } from "node:fs/promises";
+import type { Server } from "node:http";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterAll, afterEach, beforeAll, describe, expect, it } from "vitest";
+import { registerAttachmentRoutes } from "../../src/attachments/index.js";
+import { deriveAttachmentServiceConfig } from "../../src/server.mjs";
+
+describe("deriveAttachmentServiceConfig", () => {
+  const ORIGINAL_PUBLIC_URL = process.env.PH_SWITCHBOARD_PUBLIC_URL;
+
+  afterEach(() => {
+    if (ORIGINAL_PUBLIC_URL === undefined) {
+      delete process.env.PH_SWITCHBOARD_PUBLIC_URL;
+    } else {
+      process.env.PH_SWITCHBOARD_PUBLIC_URL = ORIGINAL_PUBLIC_URL;
+    }
+  });
+
+  it("defaults to http://localhost:${port} with no auth when renown is null", () => {
+    delete process.env.PH_SWITCHBOARD_PUBLIC_URL;
+    const config = deriveAttachmentServiceConfig({}, 4001, null);
+    expect(config.remoteUrl).toBe("http://localhost:4001");
+    expect(config.jwtHandler).toBeUndefined();
+  });
+
+  it("uses https when options.https is set", () => {
+    delete process.env.PH_SWITCHBOARD_PUBLIC_URL;
+    const config = deriveAttachmentServiceConfig({ https: true }, 4443, null);
+    expect(config.remoteUrl).toBe("https://localhost:4443");
+  });
+
+  it("prefers PH_SWITCHBOARD_PUBLIC_URL over the localhost default", () => {
+    process.env.PH_SWITCHBOARD_PUBLIC_URL = "https://sb.example.com";
+    const config = deriveAttachmentServiceConfig({}, 4001, null);
+    expect(config.remoteUrl).toBe("https://sb.example.com");
+  });
+
+  it("prefers the explicit attachmentServiceUrl option above all else", () => {
+    process.env.PH_SWITCHBOARD_PUBLIC_URL = "https://sb.example.com";
+    const config = deriveAttachmentServiceConfig(
+      { attachmentServiceUrl: "https://override.example.com" },
+      4001,
+      null,
+    );
+    expect(config.remoteUrl).toBe("https://override.example.com");
+  });
+
+  it("builds a jwtHandler from renown that scopes the token to the request url", async () => {
+    const calls: Array<{ expiresIn: number; aud: string }> = [];
+    const renown = {
+      user: { address: "0xabc" },
+      getBearerToken: (opts: { expiresIn: number; aud: string }) => {
+        calls.push(opts);
+        return Promise.resolve("tok-for-" + opts.aud);
+      },
+    } as unknown as IRenown;
+
+    const { jwtHandler } = deriveAttachmentServiceConfig({}, 4001, renown);
+    expect(jwtHandler).toBeDefined();
+    const token = await jwtHandler!("http://localhost:4001/attachments/x");
+    expect(token).toBe("tok-for-http://localhost:4001/attachments/x");
+    expect(calls[0]).toEqual({
+      expiresIn: 10,
+      aud: "http://localhost:4001/attachments/x",
+    });
+  });
+
+  it("returns undefined token when renown has no user identity", async () => {
+    const renown = {
+      user: null,
+      getBearerToken: () => Promise.resolve("should-not-be-called"),
+    } as unknown as IRenown;
+
+    const { jwtHandler } = deriveAttachmentServiceConfig({}, 4001, renown);
+    expect(jwtHandler).toBeDefined();
+    await expect(
+      jwtHandler!("http://localhost:4001/x"),
+    ).resolves.toBeUndefined();
+  });
+});
+
+describe("attachment service built from deriveAttachmentServiceConfig round-trips", () => {
+  let attachments: AttachmentBuildResult;
+  let kysely: Kysely<unknown>;
+  let storagePath: string;
+  let server: Server;
+  let port: number;
+
+  beforeAll(async () => {
+    const pglite = new PGlite();
+    kysely = new Kysely<unknown>({ dialect: new PGliteDialect(pglite) });
+    storagePath = await mkdtemp(join(tmpdir(), "switchboard-attach-cfg-"));
+    attachments = await new AttachmentBuilder(kysely, storagePath).build();
+
+    const { adapter } = await createHttpAdapter("express");
+    adapter.setupMiddleware({});
+    registerAttachmentRoutes({
+      httpAdapter: adapter,
+      attachments,
+      authService: undefined,
+    } as unknown as API);
+
+    server = await adapter.listen(0);
+    const addr = server.address();
+    if (!addr || typeof addr === "string") throw new Error("no addr");
+    port = addr.port;
+  });
+
+  afterAll(async () => {
+    await new Promise<void>((resolve) => server.close(() => resolve()));
+    await kysely.destroy();
+    await rm(storagePath, { recursive: true, force: true });
+  });
+
+  it("reserve -> upload -> get works against the live routes", async () => {
+    const config = deriveAttachmentServiceConfig(
+      { attachmentServiceUrl: `http://127.0.0.1:${port}` },
+      port,
+      null,
+    );
+    const service = createRemoteAttachmentService(config);
+
+    const upload = await service.reserve({
+      mimeType: "text/plain",
+      fileName: "hello.txt",
+      extension: "txt",
+    });
+
+    const payload = "switchboard attachment service";
+    const bytes = new TextEncoder().encode(payload);
+    const stream = new ReadableStream<Uint8Array>({
+      start(controller) {
+        controller.enqueue(bytes);
+        controller.close();
+      },
+    });
+    const result = await upload.send(stream);
+    expect(result.header.sizeBytes).toBe(bytes.byteLength);
+
+    const got = await service.get(result.ref);
+    expect(got.header.mimeType).toBe("text/plain");
+    const reader = got.body.getReader();
+    const chunks: Uint8Array[] = [];
+    for (;;) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      chunks.push(value);
+    }
+    const total = chunks.reduce((n, c) => n + c.byteLength, 0);
+    const merged = new Uint8Array(total);
+    let off = 0;
+    for (const c of chunks) {
+      merged.set(c, off);
+      off += c.byteLength;
+    }
+    expect(new TextDecoder().decode(merged)).toBe(payload);
+  });
+});