@effectstream/db 0.104.1 → 0.200.2

package/test/fixtures/pglite-close/02-live-client.test.ts

@@ -0,0 +1,27 @@
+import { afterAll, expect, test } from "bun:test";
+import { Client } from "pg";
+import { startPglite } from "../../../scripts/start-pglite.ts";
+
+const enabled = process.env.EFFECTSTREAM_PGLITE_MULTIFILE_FIXTURE === "1";
+
+if (!enabled) {
+  test.skip("multi-file retained-client fixture runs only through its parent", () => {});
+} else {
+  const handle = await startPglite(0);
+  const client = new Client({
+    host: "127.0.0.1",
+    port: handle.port,
+    user: "postgres",
+    database: "postgres",
+  });
+
+  test("leaves a raw client connected during default close", async () => {
+    await client.connect();
+    expect((await client.query("SELECT 1 AS value")).rows).toEqual([{ value: 1 }]);
+  });
+
+  afterAll(async () => {
+    await handle.close();
+    console.info("PGLITE_LIVE_CLIENT_CLOSED_DEFAULT");
+  });
+}

package/test/fixtures/pglite-close/process-exit.ts

@@ -0,0 +1,10 @@
+import { startPglite } from "../../../scripts/start-pglite.ts";
+
+const handle = await startPglite(0);
+console.info(`PGLITE_PROCESS_EXIT_PORT:${handle.port}`);
+
+await new Promise<void>((resolve) => {
+  handle.server.once("connection", () => resolve());
+});
+await handle.close();
+console.info("PGLITE_PROCESS_EXIT_DEFAULT_CLOSED");

package/test/fixtures/pgtyped/failure.mjs

@@ -0,0 +1,17 @@
+import { readFileSync } from "node:fs";
+
+const configIndex = process.argv.indexOf("-c");
+const configPath = configIndex === -1 ? undefined : process.argv[configIndex + 1];
+const config = JSON.parse(readFileSync(configPath, "utf8"));
+if (config.db.host !== "127.0.0.1") {
+  console.error(`unexpected pgtyped host: ${String(config.db.host)}`);
+  process.exit(2);
+}
+const port = Number(config.db.port);
+if (!Number.isInteger(port) || port <= 0 || port === 5432) {
+  console.error(`pgtyped did not receive the reported ephemeral port: ${port}`);
+  process.exit(3);
+}
+console.log(`PGTYPED_CONFIG_PATH:${configPath}`);
+console.error("PGTYPED_INJECTED_FAILURE");
+process.exit(23);

package/test/fixtures/pgtyped/hang.mjs

@@ -0,0 +1,12 @@
+import { readFileSync } from "node:fs";
+
+const configIndex = process.argv.indexOf("-c");
+const configPath = configIndex === -1 ? undefined : process.argv[configIndex + 1];
+const config = JSON.parse(readFileSync(configPath, "utf8"));
+if (config.db.host !== "127.0.0.1" || !Number.isInteger(config.db.port)) {
+  console.error("unexpected pgtyped connection config");
+  process.exit(2);
+}
+console.log(`PGTYPED_CONFIG_PATH:${configPath}`);
+console.log("PGTYPED_INJECTED_HANG");
+setInterval(() => {}, 1_000);

package/test/fixtures/pgtyped/success.mjs

@@ -0,0 +1,30 @@
+import { readFileSync } from "node:fs";
+
+const configIndex = process.argv.indexOf("-c");
+const configPath = configIndex === -1 ? undefined : process.argv[configIndex + 1];
+const config = JSON.parse(readFileSync(configPath, "utf8"));
+if (config.db.host !== "127.0.0.1") {
+  console.error(`unexpected pgtyped host: ${String(config.db.host)}`);
+  process.exit(2);
+}
+const port = Number(config.db.port);
+if (!Number.isInteger(port) || port <= 0 || port === 5432) {
+  console.error(`pgtyped did not receive the reported ephemeral port: ${port}`);
+  process.exit(3);
+}
+if (config.db.user !== "postgres" || config.db.dbName !== "postgres") {
+  console.error("unexpected pgtyped user or database");
+  process.exit(4);
+}
+if (
+  config.customMarker !== "quoted \"value\" with newline\nand unicode ✓" ||
+  config.db.password !== "special ✓ password" ||
+  config.db.ssl !== false ||
+  "dbUrl" in config
+) {
+  console.error("derived pgtyped config did not preserve its shape safely");
+  process.exit(5);
+}
+console.log(`PGTYPED_CONNECTION_OK:${port}`);
+console.log("PGTYPED_CONFIG_SHAPE_OK");
+console.log(`PGTYPED_CONFIG_PATH:${configPath}`);

package/test/pgtyped-update.test.ts

@@ -0,0 +1,132 @@
+import { expect, test } from "bun:test";
+import { PGlite } from "@electric-sql/pglite";
+import { existsSync } from "node:fs";
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import net from "node:net";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { main } from "../scripts/pgtyped-update.ts";
+
+const configMarker = "quoted \"value\" with newline\nand unicode ✓";
+
+async function expectPortClosed(port: number): Promise<void> {
+  await expect(new Promise<void>((resolve, reject) => {
+    const socket = net.connect({ host: "127.0.0.1", port });
+    socket.once("connect", () => {
+      socket.destroy();
+      resolve();
+    });
+    socket.once("error", reject);
+  })).rejects.toMatchObject({ code: "ECONNREFUSED" });
+}
+
+async function runAndCapture(
+  pgtypedBin: URL,
+  pgtypedTimeoutMs = 30_000,
+): Promise<{
+  closeCount: number;
+  derivedConfigPath: string;
+  output: string;
+  port: number;
+  error?: unknown;
+}> {
+  const configDirectory = await mkdtemp(join(tmpdir(), "effectstream-pgtyped-test-"));
+  const configPath = join(configDirectory, "pgtypedconfig.json");
+  await writeFile(configPath, JSON.stringify({
+    customMarker: configMarker,
+    db: {
+      dbName: "wrong-db",
+      host: "wrong-host",
+      password: "special ✓ password",
+      port: 1,
+      ssl: false,
+      user: "wrong-user",
+    },
+    dbUrl: "postgresql://must-not-be-used",
+    failOnError: false,
+    maxWorkerThreads: 1,
+    srcDir: "./sql",
+    transforms: [],
+  }));
+
+  const originalClose = PGlite.prototype.close;
+  const originalInfo = console.info;
+  const originalLog = console.log;
+  const originalError = console.error;
+  let closeCount = 0;
+  const output: string[] = [];
+
+  PGlite.prototype.close = async function () {
+    closeCount += 1;
+    return await originalClose.call(this);
+  };
+  console.info = (...args: unknown[]) => output.push(args.join(" "));
+  console.log = (...args: unknown[]) => output.push(args.join(" "));
+  console.error = (...args: unknown[]) => output.push(args.join(" "));
+
+  let error: unknown;
+  try {
+    await main({
+      userMigrations: [],
+      pgtypedConfigPath: configPath,
+      pgtypedBin: pgtypedBin.pathname,
+      pgtypedTimeoutMs,
+    });
+  } catch (caught) {
+    error = caught;
+  } finally {
+    PGlite.prototype.close = originalClose;
+    console.info = originalInfo;
+    console.log = originalLog;
+    console.error = originalError;
+    await rm(configDirectory, { force: true, recursive: true });
+  }
+
+  const text = output.join("\n");
+  const match = text.match(/database: server listening on port (\d+)/);
+  if (!match) throw new Error(`No reported PGlite port in output:\n${text}`);
+  const configMatch = text.match(/PGTYPED_CONFIG_PATH:(.+)/);
+  if (!configMatch) throw new Error(`No derived pgtyped config path in output:\n${text}`);
+  return {
+    closeCount,
+    derivedConfigPath: configMatch[1],
+    output: text,
+    port: Number(match[1]),
+    error,
+  };
+}
+
+test("pgtyped update uses the reported IPv4 connection and closes every resource on success", async () => {
+  const result = await runAndCapture(new URL("./fixtures/pgtyped/success.mjs", import.meta.url));
+
+  expect(result.error).toBeUndefined();
+  expect(result.output).toContain(`PGTYPED_CONNECTION_OK:${result.port}`);
+  expect(result.output).toContain("PGTYPED_CONFIG_SHAPE_OK");
+  expect(result.port).not.toBe(5432);
+  expect(result.closeCount).toBe(1);
+  expect(existsSync(result.derivedConfigPath)).toBe(false);
+  await expectPortClosed(result.port);
+}, 30_000);
+
+test("pgtyped update closes every resource when its child fails", async () => {
+  const result = await runAndCapture(new URL("./fixtures/pgtyped/failure.mjs", import.meta.url));
+
+  expect(result.error).toEqual(new Error("pgtyped failed with exit code 23"));
+  expect(result.output).toContain("PGTYPED_INJECTED_FAILURE");
+  expect(result.closeCount).toBe(1);
+  expect(existsSync(result.derivedConfigPath)).toBe(false);
+  await expectPortClosed(result.port);
+}, 30_000);
+
+test("pgtyped update times out its child and removes the derived config", async () => {
+  const result = await runAndCapture(
+    new URL("./fixtures/pgtyped/hang.mjs", import.meta.url),
+    100,
+  );
+
+  expect(result.error).toEqual(new Error("pgtyped timed out after 100ms"));
+  expect(result.output).toContain("PGTYPED_INJECTED_HANG");
+  expect(result.closeCount).toBe(1);
+  expect(existsSync(result.derivedConfigPath)).toBe(false);
+  await expectPortClosed(result.port);
+}, 30_000);

package/test/start-pglite-multifile.test.ts

@@ -0,0 +1,33 @@
+import { expect, test } from "bun:test";
+
+test("default close with a retained raw client does not poison the next test file", async () => {
+  const fixtures = new URL("./fixtures/pglite-close/", import.meta.url);
+  const child = Bun.spawn([
+    process.execPath,
+    "test",
+    "--max-concurrency=1",
+    new URL("01-sentinel.test.ts", fixtures).pathname,
+    new URL("02-live-client.test.ts", fixtures).pathname,
+  ], {
+    cwd: new URL("../../../..", import.meta.url).pathname,
+    env: {
+      ...process.env,
+      EFFECTSTREAM_PGLITE_MULTIFILE_FIXTURE: "1",
+    },
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+
+  const [stdout, stderr, exitCode] = await Promise.all([
+    new Response(child.stdout).text(),
+    new Response(child.stderr).text(),
+    child.exited,
+  ]);
+  const output = `${stdout}\n${stderr}`;
+
+  expect(exitCode, output).toBe(0);
+  expect(output).toContain("PGLITE_LIVE_CLIENT_CLOSED_DEFAULT");
+  expect(output).toContain("PGLITE_SENTINEL_REGISTERED");
+  expect(output).not.toContain("Unhandled error between tests");
+  expect(output).not.toContain("Connection terminated unexpectedly");
+}, 30_000);