@powerhousedao/switchboard 6.2.3-dev.43 → 6.2.3-dev.45

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/snapshot-writer.ts

@@ -0,0 +1,94 @@
+// Test-only v1 snapshot.bin writer over a loose on-disk tree.
+import { promises as fs } from "node:fs";
+import type { FileHandle } from "node:fs/promises";
+import path from "node:path";
+
+const MAGIC = new Uint8Array([0x50, 0x47, 0x4c, 0x41]);
+const FORMAT_VERSION = 1;
+const HEADER_SIZE = 12;
+const ENTRY_PREFIX_SIZE = 9;
+const DEFAULT_SKIP = ["snapshot.bin", "snapshot.bin.tmp"];
+
+export interface SnapshotEntry {
+  type: 0 | 1;
+  mode: number;
+  relPath: string;
+  data?: Buffer;
+}
+
+export interface WriteSnapshotOptions {
+  /** Root-level names to leave out. Defaults to the snapshot files. */
+  skip?: string[];
+}
+
+export async function collectDiskEntries(
+  dataDir: string,
+  options: WriteSnapshotOptions = {},
+): Promise<SnapshotEntry[]> {
+  const skip = new Set(options.skip ?? DEFAULT_SKIP);
+  const entries: SnapshotEntry[] = [];
+  const walk = async (dir: string, rel: string) => {
+    const names = (await fs.readdir(dir)).sort();
+    for (const name of names) {
+      if (rel === "" && skip.has(name)) continue;
+      const full = path.join(dir, name);
+      const relPath = rel === "" ? name : `${rel}/${name}`;
+      const stat = await fs.lstat(full);
+      if (stat.isDirectory()) {
+        entries.push({ type: 0, mode: stat.mode & 0o7777, relPath });
+        await walk(full, relPath);
+      } else if (stat.isFile()) {
+        entries.push({
+          type: 1,
+          mode: stat.mode & 0o7777,
+          relPath,
+          data: await fs.readFile(full),
+        });
+      }
+    }
+  };
+  await walk(dataDir, "");
+  return entries;
+}
+
+export function encodeSnapshot(entries: SnapshotEntry[]): Buffer {
+  const encoder = new TextEncoder();
+  const parts: Buffer[] = [];
+  const header = Buffer.alloc(HEADER_SIZE);
+  header.set(MAGIC, 0);
+  header.writeUInt32LE(FORMAT_VERSION, 4);
+  header.writeUInt32LE(entries.length, 8);
+  parts.push(header);
+  for (const entry of entries) {
+    const pathBytes = encoder.encode(entry.relPath);
+    const dataLen = entry.data?.byteLength ?? 0;
+    const prefix = Buffer.alloc(ENTRY_PREFIX_SIZE + pathBytes.byteLength + 4);
+    prefix.writeUInt8(entry.type, 0);
+    prefix.writeUInt32LE(entry.mode, 1);
+    prefix.writeUInt32LE(pathBytes.byteLength, 5);
+    prefix.set(pathBytes, ENTRY_PREFIX_SIZE);
+    prefix.writeUInt32LE(dataLen, ENTRY_PREFIX_SIZE + pathBytes.byteLength);
+    parts.push(prefix);
+    if (entry.data && dataLen > 0) parts.push(entry.data);
+  }
+  return Buffer.concat(parts);
+}
+
+/** Serializes `dataDir` into `snapshotPath`. Returns the entry count and size. */
+export async function writeSnapshotFromDir(
+  dataDir: string,
+  snapshotPath: string,
+  options: WriteSnapshotOptions = {},
+): Promise<{ entries: number; bytes: number }> {
+  const entries = await collectDiskEntries(dataDir, options);
+  const bytes = encodeSnapshot(entries);
+  let fh: FileHandle | undefined;
+  try {
+    fh = await fs.open(snapshotPath, "w");
+    await fh.writeFile(bytes);
+    await fh.sync();
+  } finally {
+    await fh?.close();
+  }
+  return { entries: entries.length, bytes: bytes.byteLength };
+}

package/test/worker-pool.test.ts

@@ -1,9 +1,12 @@
 import type { ILogger } from "document-model";
-import { existsSync } from "node:fs";
+import { existsSync, mkdtempSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
 import { describe, expect, it, vi } from "vitest";
 import {
   autoWorkerCount,
   buildWorkerDbConfig,
+  keepImportableSources,
   resolveHostPoolSize,
   resolveWorkerModelSources,
   resolveWorkerPoolOptions,
@@ -264,3 +267,26 @@ describe("resolveWorkerModelSources", () => {
     expect(logger.warn).toHaveBeenCalledTimes(1);
   });
 });
+
+describe("keepImportableSources", () => {
+  it("keeps sources that export a model and drops one that throws or has none", async () => {
+    const dir = mkdtempSync(path.join(tmpdir(), "ph-model-sources-"));
+    const good = path.join(dir, "good.mjs");
+    const broken = path.join(dir, "broken.mjs");
+    const empty = path.join(dir, "empty.mjs");
+    writeFileSync(
+      good,
+      'export const Model = { reducer: () => ({}), documentModel: { global: { id: "test/model" } } };',
+    );
+    writeFileSync(broken, 'throw new Error("stale dist");');
+    // What `ph init` builds for a project with no models yet.
+    writeFileSync(empty, "export {};");
+
+    const kept = await keepImportableSources(
+      [{ filePath: broken }, { filePath: good }, { filePath: empty }],
+      stubLogger(),
+    );
+
+    expect(kept).toEqual([{ filePath: good }]);
+  });
+});

package/test/workflow/resolvers.test.ts

@@ -48,6 +48,7 @@ function fakeRuntime() {
     testStep: vi.fn(() => Promise.resolve({})),
     stepOutputTree: vi.fn(() => Promise.resolve({})),
     blockResolutions: vi.fn(() => Promise.resolve([])),
+    reactorAccessDenial: vi.fn((): string | undefined => undefined),
     testTrigger: vi.fn(() => Promise.resolve(null)),
     cancelTriggerTestFor: vi.fn(() => Promise.resolve(true)),
     secrets: vi.fn(() =>
@@ -68,6 +69,12 @@ function build(isAdmin: boolean) {
   const resolvers = getResolvers(
     runtime as unknown as WorkflowRuntimeService,
     authorizationService,
+    undefined,
+    undefined,
+    (documentId) =>
+      documentId === "wf-hidden"
+        ? Promise.reject(new Error("You may not read this workflow"))
+        : Promise.resolve(),
   ) as Record<string, Record<string, Resolver>>;
   return {
     runtime,
@@ -167,6 +174,25 @@ describe("the workflow resolvers and the caller", () => {
     expect(runtime.secrets).toHaveBeenCalledTimes(1);
   });
 
+  it("serves why a workflow got no reactor access, naming the publisher", async () => {
+    const { runtime, queries } = build(false);
+    runtime.reactorAccessDenial.mockReturnValueOnce(
+      'The publisher 0xabc cannot read reactor connection "conn-1"',
+    );
+
+    await expect(
+      queries.reactorAccessDenial({}, { workflowId: "wf-1" }, CTX),
+    ).resolves.toBe(
+      'The publisher 0xabc cannot read reactor connection "conn-1"',
+    );
+    await expect(
+      queries.reactorAccessDenial({}, { workflowId: "wf-1" }, CTX),
+    ).resolves.toBeNull();
+    await expect(
+      queries.reactorAccessDenial({}, { workflowId: "wf-hidden" }, CTX),
+    ).rejects.toThrow("You may not read this workflow");
+  });
+
   it("serves the piece version a run's steps ran", async () => {
     const { runtime, queries } = build(true);
     runtime.run.mockResolvedValueOnce({