@powerhousedao/switchboard 6.2.3-dev.5 → 6.2.3-dev.51

package/test/pglite-preflight.test.ts

@@ -0,0 +1,313 @@
+import { createDurableNodeFs } from "@powerhousedao/reactor-api/pglite-node";
+import type { ILogger } from "document-model";
+import { promises as fs } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import {
+  afterAll,
+  afterEach,
+  beforeAll,
+  beforeEach,
+  describe,
+  expect,
+  it,
+  vi,
+} from "vitest";
+import { runPglitePreflight } from "../src/pglite-preflight.js";
+import { loadNodeFsClass, loadPGliteModule } from "../src/pglite-version.js";
+import { writeSnapshotFromDir } from "./snapshot-writer.js";
+
+// PGlite initdb and pg_dump are several times slower on the Windows runner.
+const BOOT_TIMEOUT = 120_000;
+const RM = { recursive: true, force: true, maxRetries: 10 } as const;
+const ROWS = 10;
+const CONVERTED_LINE =
+  /^Converted PGlite snapshot at (.+): snapshot (\d+) bytes -> (\d+) bytes on disk, (\d+) entries, (\d+) ms$/;
+
+type StubLogger = ILogger & {
+  debug: ReturnType<typeof vi.fn>;
+  info: ReturnType<typeof vi.fn>;
+  warn: ReturnType<typeof vi.fn>;
+};
+
+function stubLogger(): StubLogger {
+  const logger = {
+    verbose: vi.fn(),
+    debug: vi.fn(),
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+    child: vi.fn(),
+  };
+  logger.child.mockReturnValue(logger);
+  return logger as unknown as StubLogger;
+}
+
+async function exists(p: string): Promise<boolean> {
+  try {
+    await fs.lstat(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function pgVersion(dir: string): Promise<string> {
+  return (await fs.readFile(path.join(dir, "PG_VERSION"), "utf8")).trim();
+}
+
+/** Opens `dir` the way the server does and counts the seeded rows. */
+async function countRows(dir: string, major: 16 | 17): Promise<number> {
+  const [{ PGlite: Pg }, Base] = await Promise.all([
+    loadPGliteModule(major),
+    loadNodeFsClass(major),
+  ]);
+  const pg = new Pg({
+    fs: createDurableNodeFs(Base, dir, {
+      fsync: false,
+      maintenanceIntervalMs: 0,
+    }),
+  });
+  try {
+    await pg.waitReady;
+    const { rows } = await pg.query<{ n: number }>(
+      'SELECT count(*)::int AS n FROM "Rows"',
+    );
+    return rows[0].n;
+  } finally {
+    await pg.close();
+  }
+}
+
+function convertedLines(logger: StubLogger): string[] {
+  return logger.info.mock.calls
+    .map((call) => String(call[0]))
+    .filter((line) => CONVERTED_LINE.test(line));
+}
+
+describe("runPglitePreflight", () => {
+  // A pure-snapshot PG16 store: snapshot.bin and nothing else, the layout
+  // AtomicNodeFs left for a store it created itself.
+  let template: string;
+  let root: string;
+  let logger: StubLogger;
+
+  beforeAll(async () => {
+    template = await fs.mkdtemp(path.join(os.tmpdir(), "preflight-template-"));
+    const loose = path.join(template, "loose");
+    const { PGlite: LegacyPGlite } = await loadPGliteModule(16);
+    const LegacyNodeFS = await loadNodeFsClass(16);
+    const pg = new LegacyPGlite({ fs: new LegacyNodeFS(loose) });
+    await pg.waitReady;
+    await pg.exec('CREATE TABLE "Rows" (id int PRIMARY KEY, payload text)');
+    await pg.exec(
+      `INSERT INTO "Rows" SELECT g, repeat('x', 100) FROM generate_series(1, ${ROWS}) g`,
+    );
+    await pg.close();
+    await fs.rm(path.join(loose, "postmaster.pid"), { force: true });
+    expect(await pgVersion(loose)).toBe("16");
+
+    const store = path.join(template, "store");
+    await fs.mkdir(store);
+    await writeSnapshotFromDir(loose, path.join(store, "snapshot.bin"));
+    await fs.rm(loose, RM);
+  }, BOOT_TIMEOUT);
+
+  afterAll(async () => {
+    await fs.rm(template, RM);
+  }, BOOT_TIMEOUT);
+
+  beforeEach(async () => {
+    root = await fs.mkdtemp(path.join(os.tmpdir(), "preflight-"));
+    logger = stubLogger();
+  });
+
+  afterEach(async () => {
+    await fs.rm(root, RM);
+  }, BOOT_TIMEOUT);
+
+  async function snapshotDir(name: string): Promise<string> {
+    const dir = path.join(root, name);
+    await fs.cp(path.join(template, "store"), dir, { recursive: true });
+    return dir;
+  }
+
+  async function looseDir(name: string, major = 17): Promise<string> {
+    const dir = path.join(root, name);
+    await fs.mkdir(path.join(dir, "pg_wal"), { recursive: true });
+    await fs.writeFile(path.join(dir, "PG_VERSION"), `${major}\n`);
+    return dir;
+  }
+
+  it(
+    "converts before detecting the major, so a PG16 snapshot is migrated",
+    async () => {
+      const dir = await snapshotDir("reactor-storage");
+
+      const detected = await runPglitePreflight({
+        dirs: [dir],
+        migratePglite: true,
+        inMemory: false,
+        logger,
+      });
+
+      expect(detected.get(dir)).toBe(17);
+      expect(await pgVersion(dir)).toBe("17");
+      expect(await exists(path.join(dir, "snapshot.bin"))).toBe(false);
+      expect(await exists(`${dir}.converting`)).toBe(false);
+      expect(await exists(`${dir}.old`)).toBe(false);
+      expect(convertedLines(logger)).toHaveLength(1);
+      expect(logger.info).toHaveBeenCalledWith(
+        expect.stringContaining("Migrating"),
+      );
+      expect(await countRows(dir, 17)).toBe(ROWS);
+    },
+    BOOT_TIMEOUT,
+  );
+
+  // Pins the order alone: before this change a pure-snapshot dir had no loose
+  // PG_VERSION and the migration logged "No PG_VERSION; skipping". The case
+  // above also needs the legacy pg_dump to work.
+  it(
+    "attempts the migration of a PG16 snapshot instead of skipping it",
+    async () => {
+      const dir = await snapshotDir("reactor-storage");
+
+      await runPglitePreflight({
+        dirs: [dir],
+        migratePglite: true,
+        inMemory: false,
+        logger,
+      }).catch(() => undefined);
+
+      expect(convertedLines(logger)).toHaveLength(1);
+      expect(logger.info).not.toHaveBeenCalledWith(
+        expect.stringContaining("No PG_VERSION"),
+      );
+      expect(logger.info).toHaveBeenCalledWith(
+        expect.stringContaining(`Migrating ${dir} from PG16 to PG17`),
+      );
+    },
+    BOOT_TIMEOUT,
+  );
+
+  it(
+    "boots a converted dir on the second start without converting",
+    async () => {
+      const dir = await snapshotDir("reactor-storage");
+      const first = { dirs: [dir], inMemory: false, logger };
+      await runPglitePreflight(first);
+      expect(convertedLines(logger)).toHaveLength(1);
+      expect(await pgVersion(dir)).toBe("16");
+
+      const second = stubLogger();
+      const detected = await runPglitePreflight({ ...first, logger: second });
+
+      expect(detected.get(dir)).toBe(16);
+      expect(convertedLines(second)).toHaveLength(0);
+      expect(await exists(`${dir}.converting`)).toBe(false);
+      expect(await exists(`${dir}.old`)).toBe(false);
+      expect(await countRows(dir, 16)).toBe(ROWS);
+    },
+    BOOT_TIMEOUT,
+  );
+
+  it("removes pg_wal/xlogtemp.*", async () => {
+    const dir = await looseDir("read-storage");
+    const segment = path.join(dir, "pg_wal", "000000010000000000000001");
+    await fs.writeFile(segment, "wal");
+    await fs.writeFile(path.join(dir, "pg_wal", "xlogtemp.42"), "");
+    await fs.writeFile(path.join(dir, "pg_wal", "xlogtemp.7"), "");
+
+    const detected = await runPglitePreflight({
+      dirs: [dir],
+      inMemory: false,
+      logger,
+    });
+
+    expect(detected.get(dir)).toBe(17);
+    expect(await fs.readdir(path.join(dir, "pg_wal"))).toEqual([
+      "000000010000000000000001",
+    ]);
+    expect(await exists(segment)).toBe(true);
+  });
+
+  it("removes postmaster.pid without a warn call", async () => {
+    const dir = await looseDir("read-storage");
+    const lockfile = path.join(dir, "postmaster.pid");
+    await fs.writeFile(lockfile, "42\n");
+
+    await runPglitePreflight({ dirs: [dir], inMemory: false, logger });
+
+    expect(await exists(lockfile)).toBe(false);
+    expect(logger.warn).not.toHaveBeenCalled();
+    expect(logger.debug).toHaveBeenCalledWith(
+      expect.stringContaining(lockfile),
+    );
+  });
+
+  it(
+    "logs one info line per converted dir with sizes and duration",
+    async () => {
+      const reactor = await snapshotDir("reactor-storage");
+      const readModel = await snapshotDir("read-storage");
+
+      await runPglitePreflight({
+        dirs: [reactor, readModel],
+        inMemory: false,
+        logger,
+      });
+
+      const lines = convertedLines(logger);
+      expect(lines).toHaveLength(2);
+      const byDir = new Map(
+        lines.map((line) => {
+          const match = CONVERTED_LINE.exec(line)!;
+          return [match[1], match.slice(2).map(Number)] as const;
+        }),
+      );
+      for (const dir of [reactor, readModel]) {
+        const [snapshotBytes, convertedBytes, entries] = byDir.get(dir)!;
+        expect(snapshotBytes).toBeGreaterThan(0);
+        expect(convertedBytes).toBeGreaterThan(0);
+        expect(entries).toBeGreaterThan(0);
+      }
+    },
+    BOOT_TIMEOUT,
+  );
+
+  it("touches nothing in memory", async () => {
+    const dir = await snapshotDir("reactor-storage");
+
+    const detected = await runPglitePreflight({
+      dirs: [dir],
+      inMemory: true,
+      logger,
+    });
+
+    expect(detected.size).toBe(0);
+    expect(await exists(path.join(dir, "snapshot.bin"))).toBe(true);
+  });
+
+  it("wipes the dirs and their conversion siblings under forcePgVersion", async () => {
+    const dir = await snapshotDir("reactor-storage");
+    await fs.mkdir(`${dir}.old`);
+    await fs.mkdir(`${dir}.converting`);
+
+    const detected = await runPglitePreflight({
+      dirs: [dir],
+      forcePgVersion: 17,
+      migratePglite: true,
+      inMemory: false,
+      logger,
+    });
+
+    expect(detected.size).toBe(0);
+    expect(await exists(dir)).toBe(false);
+    expect(await exists(`${dir}.old`)).toBe(false);
+    expect(await exists(`${dir}.converting`)).toBe(false);
+    expect(logger.warn).toHaveBeenCalledWith(
+      expect.stringContaining("ignoring --migrate-pglite"),
+    );
+  });
+});

package/test/pglite-version.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from "vitest";
-import { parseForcePgVersion } from "../src/pglite-version.js";
+import { openForVerify, parseForcePgVersion } from "../src/pglite-version.js";
 
 describe("parseForcePgVersion", () => {
   it("returns null for undefined", () => {
@@ -35,3 +35,11 @@ describe("parseForcePgVersion", () => {
     expect(() => parseForcePgVersion("16.5")).toThrow(/PH_FORCE_PG_VERSION/);
   });
 });
+
+describe("openForVerify", () => {
+  it("throws on an unsupported major before touching disk", async () => {
+    await expect(openForVerify(15, "/nonexistent/pglite-dir")).rejects.toThrow(
+      /PG_VERSION=15 is not supported/,
+    );
+  });
+});

package/test/renown-trust-policy.test.ts

@@ -0,0 +1,315 @@
+import type {
+  ActionSigner,
+  ISigner,
+} from "@powerhousedao/shared/document-model";
+import {
+  ReactorBuilder,
+  ReactorClientBuilder,
+  type SignatureTrustPolicy,
+} from "@powerhousedao/reactor";
+import type { IRenown } from "@renown/sdk/node";
+import { existsSync } from "node:fs";
+import { pathToFileURL } from "node:url";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { applySwitchboardReactorDefaults } from "../src/builder-defaults.mjs";
+import {
+  assertWorkerTrustPolicy,
+  getRenownTrustPolicyConfig,
+} from "../src/renown.js";
+
+const WALLET = "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266";
+const CONNECT_KEY = "did:key:zDnaeConnectKey";
+const SWITCHBOARD_KEY = "did:key:zDnaeSwitchboardKey";
+const SWITCHBOARD_USER = {
+  address: "0x70997970C51812dc3A010C7d01b50e0d17dc79C8",
+  networkId: "eip155",
+  chainId: 1,
+};
+const GRAPHQL = "http://renown.test/graphql";
+
+// Signed by WALLET's Anvil dev key; its expiry is ignored by the policy.
+const CREDENTIAL_ROW = {
+  documentId: "doc-cred",
+  credentialId: "urn:uuid:c7882913-68ef-48e5-9e89-f2948d2ca22c",
+  context: ["https://www.w3.org/2018/credentials/v1"],
+  type: ["VerifiableCredential", "RenownCredential"],
+  issuerId: "did:pkh:eip155:1:0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266",
+  issuerEthereumAddress: WALLET,
+  issuanceDate: "2026-09-24T00:48:25.566Z",
+  expirationDate: "2026-10-01T00:48:25.566Z",
+  credentialSubjectId: CONNECT_KEY,
+  credentialSubjectApp: "connect",
+  credentialStatusId: null,
+  credentialStatusType: null,
+  credentialSchemaId: "https://renown.id/schemas/renown-credential/v1",
+  credentialSchemaType: "JsonSchemaValidator2018",
+  proofVerificationMethod:
+    "did:pkh:eip155:1:0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266",
+  proofEthereumAddress: WALLET,
+  proofCreated: "2026-09-24T00:48:25.566Z",
+  proofPurpose: "assertionMethod",
+  proofType: "EthereumEip712Signature2021",
+  proofValue:
+    "0xe8d7a2468b9eb21286483fd88601d350ac7a8ed908506e51a34c6b119f93a7d75c6284a3f231698f6fcc8a3ad0ec5096a34811c7b6adef2d1e4146ddb22826a91c",
+  proofEip712Domain: JSON.stringify({ version: "1", chainId: 1 }),
+  proofEip712PrimaryType: "VerifiableCredential",
+  revoked: false,
+};
+
+function stubRenown(user: ActionSigner["user"] = SWITCHBOARD_USER): IRenown {
+  const signer = {
+    user,
+    app: { name: "switchboard", key: SWITCHBOARD_KEY },
+  } as unknown as ISigner;
+  return { signer } as unknown as IRenown;
+}
+
+function claim(address: string, key: string): ActionSigner {
+  return {
+    user: { address, networkId: "eip155", chainId: 1 },
+    app: { name: "connect", key },
+    signatures: [],
+  };
+}
+
+/** Answers the renown read model with `rows`; counts the requests. */
+function mockReadModel(rows: unknown[] = [CREDENTIAL_ROW]) {
+  return vi.spyOn(globalThis, "fetch").mockImplementation(() =>
+    Promise.resolve(
+      new Response(JSON.stringify({ data: { renownCredentials: rows } }), {
+        status: 200,
+      }),
+    ),
+  );
+}
+
+async function remotePolicy(
+  renown = stubRenown(),
+): Promise<SignatureTrustPolicy> {
+  const { trustPolicy } = await getRenownTrustPolicyConfig(
+    { source: "remote", switchboardUrl: GRAPHQL },
+    renown,
+  );
+  return trustPolicy!;
+}
+
+describe("getRenownTrustPolicyConfig", () => {
+  afterEach(() => vi.restoreAllMocks());
+
+  it("accepts a key a credential binds to the claimed wallet", async () => {
+    const fetchMock = mockReadModel();
+    const policy = await remotePolicy();
+
+    await expect(
+      policy.authorizeSigner(claim(WALLET, CONNECT_KEY), CONNECT_KEY, "doc"),
+    ).resolves.toBe(true);
+    expect(fetchMock.mock.calls[0][0]).toBe(GRAPHQL);
+  });
+
+  it("refuses a mismatched address or key", async () => {
+    mockReadModel();
+    const policy = await remotePolicy();
+
+    await expect(
+      policy.authorizeSigner(
+        claim(SWITCHBOARD_USER.address, CONNECT_KEY),
+        CONNECT_KEY,
+        "doc",
+      ),
+    ).resolves.toBe(false);
+    await expect(
+      policy.authorizeSigner(
+        claim(WALLET, "did:key:zDnaeOther"),
+        "did:key:zDnaeOther",
+        "doc",
+      ),
+    ).resolves.toBe(false);
+  });
+
+  it("refuses a key no credential binds yet", async () => {
+    const fetchMock = mockReadModel([]);
+    const policy = await remotePolicy();
+
+    await expect(
+      policy.authorizeSigner(claim(WALLET, CONNECT_KEY), CONNECT_KEY, "doc"),
+    ).resolves.toBe(false);
+    await expect(
+      policy.authorizeSigner(claim(WALLET, CONNECT_KEY), CONNECT_KEY, "doc"),
+    ).resolves.toBe(false);
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+  });
+
+  it("caches an acceptance per (address, key)", async () => {
+    const fetchMock = mockReadModel();
+    const policy = await remotePolicy();
+    const signer = claim(WALLET, CONNECT_KEY);
+
+    await policy.authorizeSigner(signer, CONNECT_KEY, "doc-1");
+    fetchMock.mockRejectedValue(new TypeError("offline"));
+
+    await expect(
+      policy.authorizeSigner(signer, CONNECT_KEY, "doc-2"),
+    ).resolves.toBe(true);
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+  });
+
+  it("throws on a network failure rather than refusing", async () => {
+    vi.spyOn(globalThis, "fetch").mockRejectedValue(new TypeError("offline"));
+    const policy = await remotePolicy();
+
+    await expect(
+      policy.authorizeSigner(claim(WALLET, CONNECT_KEY), CONNECT_KEY, "doc"),
+    ).rejects.toThrow("offline");
+  });
+
+  it("accepts the switchboard's own key for its own user without a lookup", async () => {
+    const fetchMock = mockReadModel([]);
+    const policy = await remotePolicy();
+
+    await expect(
+      policy.authorizeSigner(
+        claim(SWITCHBOARD_USER.address, SWITCHBOARD_KEY),
+        SWITCHBOARD_KEY,
+        "doc",
+      ),
+    ).resolves.toBe(true);
+    expect(fetchMock).not.toHaveBeenCalled();
+  });
+
+  it("matches the switchboard's own key against its current user", async () => {
+    const fetchMock = mockReadModel([]);
+    const renown = stubRenown();
+    const policy = await remotePolicy(renown);
+
+    renown.signer.user = { address: WALLET, networkId: "eip155", chainId: 1 };
+
+    await expect(
+      policy.authorizeSigner(
+        claim(WALLET, SWITCHBOARD_KEY),
+        SWITCHBOARD_KEY,
+        "doc",
+      ),
+    ).resolves.toBe(true);
+    expect(fetchMock).not.toHaveBeenCalled();
+    await expect(
+      policy.authorizeSigner(
+        claim(SWITCHBOARD_USER.address, SWITCHBOARD_KEY),
+        SWITCHBOARD_KEY,
+        "doc",
+      ),
+    ).resolves.toBe(false);
+  });
+
+  it("gives pooled workers a spec that builds the same policy", async () => {
+    const fetchMock = mockReadModel();
+    const { workerTrustPolicy } = await getRenownTrustPolicyConfig(
+      { source: "remote", switchboardUrl: GRAPHQL },
+      stubRenown(),
+    );
+
+    const module = workerTrustPolicy!.module;
+    expect(module.exportName).toBe("createRenownTrustPolicy");
+    const filePath = "filePath" in module ? module.filePath : "";
+    expect(existsSync(filePath)).toBe(true);
+    expect(workerTrustPolicy!.initArgs).toEqual({
+      switchboard: GRAPHQL,
+      self: { key: SWITCHBOARD_KEY, user: SWITCHBOARD_USER },
+    });
+
+    const imported = (await import(pathToFileURL(filePath).href)) as Record<
+      string,
+      (args: unknown) => SignatureTrustPolicy
+    >;
+    const policy = imported[module.exportName](workerTrustPolicy!.initArgs);
+    await expect(
+      policy.authorizeSigner(claim(WALLET, CONNECT_KEY), CONNECT_KEY, "doc"),
+    ).resolves.toBe(true);
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+  });
+
+  it("reads a self source in process and gives workers no spec", async () => {
+    const request = vi.fn(() =>
+      Promise.resolve({ renownCredentials: [CREDENTIAL_ROW] }),
+    );
+    const config = await getRenownTrustPolicyConfig(
+      { source: "self", request },
+      null,
+    );
+
+    expect(config.workerTrustPolicy).toBeUndefined();
+    await expect(
+      config.trustPolicy!.authorizeSigner(
+        claim(WALLET, CONNECT_KEY),
+        CONNECT_KEY,
+        "doc",
+      ),
+    ).resolves.toBe(true);
+    expect(request).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe("assertWorkerTrustPolicy", () => {
+  it("fails with workers, authEnforcement and a self source", () => {
+    expect(() =>
+      assertWorkerTrustPolicy({
+        workers: 2,
+        authEnforcement: true,
+        renownSource: "self",
+      }),
+    ).toThrow(
+      /REACTOR_WORKERS[\s\S]*REACTOR_AUTH_ENFORCEMENT[\s\S]*RENOWN_SOURCE/,
+    );
+  });
+
+  it.each([
+    { workers: 0, authEnforcement: true, renownSource: "self" as const },
+    { workers: 2, authEnforcement: false, renownSource: "self" as const },
+    { workers: 2, authEnforcement: true, renownSource: "remote" as const },
+  ])("passes %o", (config) => {
+    expect(() => assertWorkerTrustPolicy(config)).not.toThrow();
+  });
+});
+
+describe("applySwitchboardReactorDefaults with a trust policy", () => {
+  it("gives the reactor the policy and its worker spec", () => {
+    const reactorBuilder = new ReactorBuilder();
+    const withTrustPolicy = vi.spyOn(reactorBuilder, "withTrustPolicy");
+    const trustPolicy: SignatureTrustPolicy = {
+      authorizeSigner: () => Promise.resolve(true),
+    };
+    const workerTrustPolicy = {
+      module: { filePath: "/trust.js", exportName: "createTrustPolicy" },
+    };
+
+    applySwitchboardReactorDefaults(
+      reactorBuilder,
+      new ReactorClientBuilder(),
+      {
+        includeBaseModels: false,
+        signalHandlers: false,
+        trustPolicy: { trustPolicy, workerTrustPolicy },
+      },
+    );
+
+    expect(withTrustPolicy).toHaveBeenCalledWith(
+      trustPolicy,
+      workerTrustPolicy,
+    );
+    expect(reactorBuilder.hasTrustPolicy()).toBe(true);
+  });
+
+  it("leaves the reactor on the default without one", () => {
+    const reactorBuilder = new ReactorBuilder();
+
+    applySwitchboardReactorDefaults(
+      reactorBuilder,
+      new ReactorClientBuilder(),
+      {
+        includeBaseModels: false,
+        signalHandlers: false,
+      },
+    );
+
+    expect(reactorBuilder.hasTrustPolicy()).toBe(false);
+  });
+});