@cosmicdrift/kumiko-framework 0.304.0 → 0.306.0

package/src/stack/test-stack.ts

@@ -110,6 +110,10 @@ export type TestStackOptions = {
    *  MUST go through here (real HTTP via `stack.http`/`stack.app.fetch`),
    *  never `createTestDispatcher`. */
   extraRoutes?: import("../api/server").ServerOptions["extraRoutes"];
+  /** Forwarded to buildServer like runProdApp. Without a PrometheusMeter-backed
+   *  `observability` the route answers 503, so spread `resolveObservabilityWiring(token)`
+   *  rather than setting `metrics` alone. */
+  metrics?: import("../api/server").ServerOptions["metrics"];
   /** Inject a MasterKeyProvider for secrets-backed tests. Lands typed in
    *  AppContext — set/delete/get + rotation job pick it up. Omit for
    *  suites that don't touch secrets. */
@@ -410,6 +414,7 @@ export async function setupTestStack(options: TestStackOptions): Promise<TestSta
       eventDedup,
       sseBroker,
       ...(options.extraRoutes && { extraRoutes: options.extraRoutes }),
+      ...(options.metrics && { metrics: options.metrics }),
       // Tests drive the dispatcher via stack.eventDispatcher.runOnce() for
       // deterministic drains — no timer-induced flakiness. pollIntervalMs
       // stays short anyway in case a test opts into `.start()`. pgClient

package/src/testing/closed-connection-error.ts

@@ -0,0 +1,62 @@
+// Captures a real closed-connection error instead of a hand-built fake —
+// the production matcher checks driver-specific codes a fake can't reproduce.
+
+import postgres from "postgres";
+import { isClosedConnectionError } from "../bun-db/query";
+
+export function testDatabaseUrl(): string {
+  return (
+    process.env["TEST_DATABASE_URL"] ??
+    process.env["DATABASE_URL"] ??
+    "postgresql://kumiko:kumiko@localhost:15432/kumiko_test"
+  );
+}
+
+const MAX_WARMUP_ROUNDS = 10;
+const READS_PER_ROUND = 5;
+
+type AdminClient = { unsafe(sql: string, params?: readonly unknown[]): Promise<unknown> };
+
+// A per-round admin client hits a postgres-js reconnect timing bug (the first
+// retry after terminate hangs); a single long-lived admin client avoids it.
+export async function terminateBackendsByApplicationName(
+  admin: AdminClient,
+  applicationName: string,
+): Promise<void> {
+  await admin.unsafe(
+    "select pg_terminate_backend(pid) from pg_stat_activity where application_name = $1",
+    [applicationName],
+  );
+}
+
+// Terminates a throwaway pool's backends and races reads right after — the
+// dead-connection window is only a few ms wide, so this retries rounds until one lands.
+export async function captureClosedConnectionError(
+  url: string = testDatabaseUrl(),
+): Promise<unknown> {
+  const admin = postgres(url, { max: 1 });
+  try {
+    for (let round = 0; round < MAX_WARMUP_ROUNDS; round++) {
+      const applicationName = `kumiko-closed-conn-test-${crypto.randomUUID()}`;
+      const pool = postgres(url, { max: 1, connection: { application_name: applicationName } });
+      try {
+        await pool.unsafe("select 1");
+        await terminateBackendsByApplicationName(admin, applicationName);
+        for (let read = 0; read < READS_PER_ROUND; read++) {
+          try {
+            await pool.unsafe("select 1");
+          } catch (err) {
+            if (isClosedConnectionError(err)) return err;
+          }
+        }
+      } finally {
+        await pool.end({ timeout: 0 });
+      }
+    }
+    throw new Error(
+      `captureClosedConnectionError: no closed-connection error observed after ${MAX_WARMUP_ROUNDS} rounds.`,
+    );
+  } finally {
+    await admin.end({ timeout: 0 });
+  }
+}

package/src/testing/index.ts

@@ -15,6 +15,7 @@ export { resetEntityFieldEncryptionCacheForTests } from "../db/entity-field-encr
 export { rolesOf } from "./access-assertions";
 export { expectError, expectSuccess } from "./assertions";
 export { withBootValidatorFixture } from "./boot-validator-fixture";
+export { captureClosedConnectionError } from "./closed-connection-error";
 export { type ClearableTable, clearTables, resetTestTables } from "./db-cleanup";
 export {
   type E2EGeneratorOptions,

package/src/bun-db/__tests__/select-many-retry.test.ts

@@ -1,79 +0,0 @@
-// #1163: Bun.SQL can hand out a closed connection under load (AbortError
-// "The connection was closed."). Pure reads retry exactly once on a fresh
-// pool checkout; tx handles, non-matching errors, and genuine user aborts
-// must NOT retry.
-
-import { describe, expect, test } from "bun:test";
-import { buildEntityTable } from "../../db/table-builder";
-import { selectMany } from "../query";
-
-function closedConnectionError(): Error {
-  return Object.assign(new Error("The connection was closed."), { name: "AbortError" });
-}
-
-type FakeClient = {
-  unsafe: (sql: string, params?: readonly unknown[]) => Promise<readonly unknown[]>;
-  begin?: () => never;
-  calls: number;
-};
-
-function fakeClient(failures: Error[], opts: { tx?: boolean } = {}): FakeClient {
-  const remaining = [...failures];
-  const client: FakeClient = {
-    calls: 0,
-    unsafe: async () => {
-      client.calls++;
-      const err = remaining.shift();
-      if (err) throw err;
-      return [{ id: "r1", title: "ok", tenant_id: "t1", inserted_at: null, updated_at: null }];
-    },
-  };
-  // A top-level pool client has begin(); a transaction handle does not.
-  if (!opts.tx)
-    client.begin = () => {
-      throw new Error("not used in test");
-    };
-  return client;
-}
-
-const table = buildEntityTable("note", {
-  fields: { title: { type: "text", required: true } },
-});
-
-describe("selectMany — closed-connection retry (#1163)", () => {
-  test("retries once on AbortError 'connection was closed' and returns rows", async () => {
-    const db = fakeClient([closedConnectionError()]);
-    const rows = await selectMany(db, table);
-    expect(rows).toHaveLength(1);
-    expect(rows[0]?.title).toBe("ok");
-    expect(db.calls).toBe(2);
-  });
-
-  test("gives up after the single retry when the connection stays closed", async () => {
-    const db = fakeClient([closedConnectionError(), closedConnectionError()]);
-    await expect(selectMany(db, table)).rejects.toThrow("connection was closed");
-    expect(db.calls).toBe(2);
-  });
-
-  test("never retries on a transaction handle (no begin)", async () => {
-    const db = fakeClient([closedConnectionError()], { tx: true });
-    await expect(selectMany(db, table)).rejects.toThrow("connection was closed");
-    expect(db.calls).toBe(1);
-  });
-
-  test("does not retry a genuine user abort (different message)", async () => {
-    const userAbort = Object.assign(new Error("The operation was aborted."), {
-      name: "AbortError",
-    });
-    const db = fakeClient([userAbort]);
-    await expect(selectMany(db, table)).rejects.toThrow("operation was aborted");
-    expect(db.calls).toBe(1);
-  });
-
-  test("does not retry generic query errors", async () => {
-    const syntax = Object.assign(new Error("syntax error at or near"), { name: "PostgresError" });
-    const db = fakeClient([syntax]);
-    await expect(selectMany(db, table)).rejects.toThrow("syntax error");
-    expect(db.calls).toBe(1);
-  });
-});