okengine 0.23.1 → 0.23.2

package/src/elements/store/sql-errors.test.ts

@@ -3,9 +3,23 @@
  */
 
 import { describe, expect, test } from "bun:test";
+import { encodeExecuteResult } from "../../compiler/response.ts";
+import { connectPostgres } from "../../drivers/postgres.ts";
 import { isFlowFailure } from "../../kernel/hooks.ts";
 import { isRetryableSqlError, sqlErrorToFailure } from "./sql-errors.ts";
 
+const LIVE_POSTGRES_URL =
+  process.env.OKE_TEST_POSTGRES_URL?.trim() ||
+  (process.env.OKE_TEST_POSTGRES === "1"
+    ? (process.env.DATABASE_URL ?? process.env.OKE_STORE_SQL_URL)?.trim()
+    : undefined);
+
+if (!LIVE_POSTGRES_URL) {
+  console.log(
+    "skip: bun duplicate-key SQLSTATE (set OKE_TEST_POSTGRES_URL or OKE_TEST_POSTGRES=1 + DATABASE_URL/OKE_STORE_SQL_URL)",
+  );
+}
+
 describe("sqlErrorToFailure", () => {
   test("unique / exclusion → Conflict  without copying message", () => {
     const unique = sqlErrorToFailure({
@@ -194,4 +208,121 @@ describe("sqlErrorToFailure", () => {
     expect(sqlErrorToFailure(new Error("boom"))).toBeUndefined();
     expect(isFlowFailure(sqlErrorToFailure({ code: "23505" }))).toBe(true);
   });
+
+  test("Bun ERR_POSTGRES_SERVER_ERROR + string errno 23505 → Conflict 409", async () => {
+    const driver = {
+      code: "ERR_POSTGRES_SERVER_ERROR",
+      errno: "23505",
+      constraint: "users_email_key",
+      table: "users",
+      message: 'duplicate key value violates unique constraint "users_email_key"',
+    };
+    const mapped = sqlErrorToFailure(driver);
+    expect(mapped?.error.code).toBe("Conflict");
+    expect(mapped?.error.data).toMatchObject({
+      sqlstate: "23505",
+      constraint: "users_email_key",
+      table: "users",
+    });
+
+    const res = await encodeExecuteResult({ error: driver });
+    expect(res.status).toBe(409);
+    const body = (await res.json()) as { error: { code: string } };
+    expect(body.error.code).toBe("Conflict");
+    expect(JSON.stringify(body)).not.toContain("duplicate key");
+  });
+
+  test("string errno 40P01 is retryable; exhausted 40001 stays ServiceUnavailable", async () => {
+    expect(isRetryableSqlError({ errno: "40P01" })).toBe(true);
+    expect(
+      sqlErrorToFailure(
+        { code: "ERR_POSTGRES_SERVER_ERROR", errno: "40P01" },
+        { retryable: "leave" },
+      ),
+    ).toBeUndefined();
+    expect(
+      sqlErrorToFailure(
+        { code: "ERR_POSTGRES_SERVER_ERROR", errno: "40001" },
+        { retryable: "unavailable" },
+      )?.error.code,
+    ).toBe("ServiceUnavailable");
+
+    const exhausted = await encodeExecuteResult({
+      error: {
+        code: "ERR_POSTGRES_SERVER_ERROR",
+        errno: "40001",
+        message: "could not serialize access",
+      },
+    });
+    expect(exhausted.status).toBe(503);
+    const body = (await exhausted.json()) as { error: { code: string } };
+    expect(body.error.code).toBe("ServiceUnavailable");
+    expect(JSON.stringify(body)).not.toContain("serialize");
+  });
+
+  test("42804 stays 422; other 42xxx are DatabaseError unknown", async () => {
+    const datatype = await encodeExecuteResult({ error: { code: "42804" } });
+    expect(datatype.status).toBe(422);
+
+    const syntax = await encodeExecuteResult({
+      error: { code: "42601", message: "syntax error at or near" },
+    });
+    expect(syntax.status).toBe(500);
+    const body = (await syntax.json()) as {
+      error: { code: string; data?: { reason?: string; sqlstate?: string } };
+    };
+    expect(body.error.code).toBe("DatabaseError");
+    expect(body.error.data).toMatchObject({ reason: "unknown", sqlstate: "42601" });
+    expect(JSON.stringify(body)).not.toContain("syntax error");
+  });
+
+  test("ERR_POSTGRES_SERVER_ERROR without a SQLSTATE is not unavailable", () => {
+    const mapped = sqlErrorToFailure({
+      code: "ERR_POSTGRES_SERVER_ERROR",
+      message: "syntax error at or near select",
+    });
+    expect(mapped?.error.code).toBe("DatabaseError");
+    expect(mapped?.error.code).not.toBe("ServiceUnavailable");
+    expect(sqlErrorToFailure({ code: "ERR_POSTGRES_CONNECTION_CLOSED" })?.error.code).toBe(
+      "ServiceUnavailable",
+    );
+    expect(
+      sqlErrorToFailure({ code: "ERR_POSTGRES_SERVER_ERROR", errno: "53300" })?.error.code,
+    ).toBe("ServiceUnavailable");
+  });
+});
+
+describe.skipIf(!LIVE_POSTGRES_URL)("bun postgres duplicate key", () => {
+  test("a real duplicate-key error is HTTP 409", async () => {
+    const url = LIVE_POSTGRES_URL;
+    if (!url) throw new Error("postgres url missing");
+    const conn = await connectPostgres({ url, pool: { max: 1 } });
+    const table = `oke_sqlstate_${crypto.randomUUID().replaceAll("-", "")}`;
+    try {
+      await conn.exec(`CREATE TABLE "${table}" (id text PRIMARY KEY)`);
+      await conn.exec(`INSERT INTO "${table}" (id) VALUES ('a')`);
+      let caught: unknown;
+      try {
+        await conn.exec(`INSERT INTO "${table}" (id) VALUES ('a')`);
+      } catch (err) {
+        caught = err;
+      }
+      expect(caught).toBeDefined();
+      const shape =
+        caught !== null && typeof caught === "object"
+          ? {
+              name: "name" in caught ? caught.name : undefined,
+              code: "code" in caught ? caught.code : undefined,
+              errno: "errno" in caught ? caught.errno : undefined,
+            }
+          : { caught };
+      const res = await encodeExecuteResult({ error: caught });
+      const body = (await res.json()) as { error: { code: string } };
+      expect(res.status, JSON.stringify(shape)).toBe(409);
+      expect(body.error.code).toBe("Conflict");
+    } finally {
+      await conn.exec(`DROP TABLE IF EXISTS "${table}"`);
+      await conn.close();
+    }
+  });
 });

package/src/elements/store/sql-errors.ts

@@ -113,16 +113,16 @@ export function sqlErrorToFailure(
 }
 
 function mapConstraint(err: unknown): SqlFailure | undefined {
-  const code = sqlCode(err);
+  const state = sqlState(err);
   const names = publicNames(err);
 
-  if (CONFLICT_STATE.has(code)) return fail.conflict(names);
-  if (FOREIGN_KEY_STATE.has(code)) return fail.foreignKey(names);
-  if (NOT_NULL_STATE.has(code)) return fail.database({ reason: "not_null", ...names });
-  if (CHECK_STATE.has(code)) return fail.database({ reason: "check", ...names });
-  if (TOO_LONG_STATE.has(code)) return fail.database({ reason: "too_long", ...names });
-  if (OUT_OF_RANGE_STATE.has(code)) return fail.database({ reason: "out_of_range", ...names });
-  if (INVALID_STATE.has(code)) return fail.database({ reason: "invalid", ...names });
+  if (CONFLICT_STATE.has(state)) return fail.conflict(names);
+  if (FOREIGN_KEY_STATE.has(state)) return fail.foreignKey(names);
+  if (NOT_NULL_STATE.has(state)) return fail.database({ reason: "not_null", ...names });
+  if (CHECK_STATE.has(state)) return fail.database({ reason: "check", ...names });
+  if (TOO_LONG_STATE.has(state)) return fail.database({ reason: "too_long", ...names });
+  if (OUT_OF_RANGE_STATE.has(state)) return fail.database({ reason: "out_of_range", ...names });
+  if (INVALID_STATE.has(state)) return fail.database({ reason: "invalid", ...names });
 
   const sqlite = sqliteConstraint(err);
   if (sqlite === "unique") return fail.conflict(names);
@@ -134,8 +134,8 @@ function mapConstraint(err: unknown): SqlFailure | undefined {
 }
 
 function retrySignal(err: unknown): boolean {
-  const code = sqlCode(err);
-  if (RETRY_STATE.has(code)) return true;
+  const state = sqlState(err);
+  if (RETRY_STATE.has(state)) return true;
   const errno = sqlErrno(err);
   if (errno !== undefined && SQLITE_RETRY_ERRNO.has(errno)) return true;
   const named = sqlCode(err);
@@ -147,11 +147,14 @@ function retrySignal(err: unknown): boolean {
 
 function isConnectionUnavailable(err: unknown): boolean {
   const e = err as SqlErrShape;
+  const state = sqlState(err);
+  if (state.length > 0) {
+    // A SQLSTATE decides. `ERR_POSTGRES_SERVER_ERROR` is not unavailable on its own.
+    if (state.startsWith("08") || state.startsWith("53")) return true;
+    return UNAVAILABLE_STATE.has(state);
+  }
   const code = sqlCode(err);
-  if (code.startsWith("08")) return true;
-  if (code.startsWith("53")) return true;
-  if (UNAVAILABLE_STATE.has(code)) return true;
-  if (code.startsWith("ERR_POSTGRES_")) return true;
+  if (code.startsWith("ERR_POSTGRES_CONNECTION_")) return true;
   if (code === "ERR_OKE_POSTGRES_PAUSED") return true;
   if (typeof e.name === "string" && e.name === "SharedPostgresPausedError") return true;
   const errno = sqlErrno(err);
@@ -166,20 +169,40 @@ function isConnectionUnavailable(err: unknown): boolean {
 
 function looksLikeSqlError(err: unknown): boolean {
   const e = err as SqlErrShape;
+  if (sqlState(err).length > 0) return true;
   const code = sqlCode(err);
-  if (/^[0-9A-Z]{5}$/.test(code)) return true;
   if (code.startsWith("SQLITE_")) return true;
   if (typeof e.name === "string" && /postgres|sqlite|pglite|libsql/i.test(e.name)) return true;
   const message = typeof e.message === "string" ? e.message : "";
   return /sqlstate|constraint|syntax error/i.test(message);
 }
 
+/** Five-character Postgres SQLSTATE (`23505`). */
+const SQLSTATE_RE = /^[0-9A-Z]{5}$/;
+
+/**
+ * Postgres SQLSTATE on a driver error.
+ *
+ * A five-character `code` wins. Otherwise a five-character string `errno`
+ * (Bun puts `ERR_POSTGRES_SERVER_ERROR` on `code` and the SQLSTATE on `errno`).
+ *
+ * @param err - Caught driver value
+ */
+function sqlState(err: unknown): string {
+  if (!err || typeof err !== "object") return "";
+  const e = err as SqlErrShape;
+  if (typeof e.code === "string" && SQLSTATE_RE.test(e.code)) return e.code;
+  if (typeof e.errno === "string" && SQLSTATE_RE.test(e.errno)) return e.errno;
+  return "";
+}
+
 function sqlCode(err: unknown): string {
   if (!err || typeof err !== "object") return "";
   const code = (err as SqlErrShape).code;
   return typeof code === "string" ? code : "";
 }
 
+/** Numeric errno only (bun:sqlite). String errno is a SQLSTATE — see {@link sqlState}. */
 function sqlErrno(err: unknown): number | undefined {
   if (!err || typeof err !== "object") return undefined;
   const errno = (err as SqlErrShape).errno;
@@ -193,7 +216,7 @@ function publicNames(err: unknown): {
   readonly column?: string;
 } {
   const e = err as SqlErrShape;
-  const sqlstate = sqlCode(err);
+  const sqlstate = sqlState(err);
   const constraint = firstString(e.constraint, e.constraint_name);
   const table = firstString(e.table, e.table_name);
   const column = firstString(e.column, e.column_name);

package/src/elements/store/sql-nested-tx.test.ts

@@ -0,0 +1,344 @@
+/**
+ * Nested `transaction()` uses SAVEPOINT on the pinned connection.
+ * Live Postgres cases need `OKE_TEST_POSTGRES_URL` or `OKE_TEST_POSTGRES=1`
+ * plus `DATABASE_URL` / `OKE_STORE_SQL_URL`.
+ */
+
+import { describe, expect, test } from "bun:test";
+import type { SignalBus } from "../../drivers/signal-types.ts";
+import { memorySignalDriver } from "../../drivers/signal-memory.ts";
+import { connectPostgres } from "../../drivers/postgres.ts";
+import type { SqlConnection, SqlRow } from "../../drivers/types.ts";
+import { createFxContext } from "../../kernel/fx.ts";
+import type { SignalRuntime } from "../signal/runtime.ts";
+import { signal } from "../signal.ts";
+import type { StoreRuntime } from "./runtime.ts";
+import { createSqlStoreHandle, type SqlStoreHandle } from "./sql-session.ts";
+import { store } from "./declare.ts";
+
+const LIVE_POSTGRES_URL =
+  process.env.OKE_TEST_POSTGRES_URL?.trim() ||
+  (process.env.OKE_TEST_POSTGRES === "1"
+    ? (process.env.DATABASE_URL ?? process.env.OKE_STORE_SQL_URL)?.trim()
+    : undefined);
+
+if (!LIVE_POSTGRES_URL) {
+  console.log(
+    "skip: nested transaction live postgres (set OKE_TEST_POSTGRES_URL or OKE_TEST_POSTGRES=1 + DATABASE_URL/OKE_STORE_SQL_URL)",
+  );
+}
+
+function scriptedConnection(): { readonly connection: SqlConnection; readonly log: string[] } {
+  const log: string[] = [];
+  const pinned: SqlConnection = {
+    driverId: "postgres",
+    role: "primary",
+    async query() {
+      return [];
+    },
+    async exec(sql) {
+      log.push(sql);
+      return { changes: 0 };
+    },
+    async transaction() {
+      throw new Error("nested transaction reserved a second connection");
+    },
+    async close() {},
+  };
+  const connection: SqlConnection = {
+    driverId: "postgres",
+    role: "primary",
+    async query() {
+      return [];
+    },
+    async exec(sql) {
+      log.push(sql);
+      return { changes: 0 };
+    },
+    async transaction(fn) {
+      log.push("BEGIN");
+      try {
+        const result = await fn(pinned);
+        log.push("COMMIT");
+        return result;
+      } catch (err) {
+        log.push("ROLLBACK");
+        throw err;
+      }
+    },
+    async close() {},
+  };
+  return { connection, log };
+}
+
+function handleFor(connection: SqlConnection): SqlStoreHandle {
+  return createSqlStoreHandle("sql:db", {
+    connection,
+    classifications: new Map(),
+    routedRole: "primary",
+    domainDdl: "off",
+  });
+}
+
+describe("nested transaction (fake connection)", () => {
+  test("nested calls SAVEPOINT and RELEASE on the pinned connection", async () => {
+    const { connection, log } = scriptedConnection();
+    const handle = handleFor(connection);
+    await handle.transaction(async (tx) => {
+      await tx.transaction(async (inner) => {
+        await inner.transaction(async () => undefined);
+      });
+    });
+    expect(log).toEqual([
+      "BEGIN",
+      'SAVEPOINT "oke_sp_1_1"',
+      'SAVEPOINT "oke_sp_2_2"',
+      'RELEASE SAVEPOINT "oke_sp_2_2"',
+      'RELEASE SAVEPOINT "oke_sp_1_1"',
+      "COMMIT",
+    ]);
+  });
+
+  test("sibling savepoints get distinct names", async () => {
+    const { connection, log } = scriptedConnection();
+    const handle = handleFor(connection);
+    await handle.transaction(async (tx) => {
+      await tx.transaction(async () => undefined);
+      await tx.transaction(async () => undefined);
+    });
+    expect(log).toEqual([
+      "BEGIN",
+      'SAVEPOINT "oke_sp_1_1"',
+      'RELEASE SAVEPOINT "oke_sp_1_1"',
+      'SAVEPOINT "oke_sp_1_2"',
+      'RELEASE SAVEPOINT "oke_sp_1_2"',
+      "COMMIT",
+    ]);
+  });
+
+  test("inner throw rolls back to the savepoint even when the outer catch swallows it", async () => {
+    const { connection, log } = scriptedConnection();
+    const handle = handleFor(connection);
+    await handle.transaction(async (tx) => {
+      await tx.raw("INSERT INTO notes (id) VALUES ('outer')");
+      try {
+        await tx.transaction(async (inner) => {
+          await inner.raw("INSERT INTO notes (id) VALUES ('inner')");
+          throw new Error("inner");
+        });
+      } catch (err) {
+        expect(err).toBeInstanceOf(Error);
+        expect((err as Error).message).toBe("inner");
+      }
+      await tx.raw("INSERT INTO notes (id) VALUES ('after')");
+    });
+    expect(log).toEqual([
+      "BEGIN",
+      "INSERT INTO notes (id) VALUES ('outer')",
+      'SAVEPOINT "oke_sp_1_1"',
+      "INSERT INTO notes (id) VALUES ('inner')",
+      'ROLLBACK TO SAVEPOINT "oke_sp_1_1"',
+      "INSERT INTO notes (id) VALUES ('after')",
+      "COMMIT",
+    ]);
+  });
+
+  test("concurrent inner transactions on one connection do not interleave", async () => {
+    const { connection } = scriptedConnection();
+    const handle = handleFor(connection);
+    const order: string[] = [];
+    await handle.transaction(async (tx) => {
+      await Promise.all([
+        tx.transaction(async () => {
+          order.push("a1");
+          await Bun.sleep(30);
+          order.push("a2");
+        }),
+        tx.transaction(async () => {
+          order.push("b1");
+          await Bun.sleep(30);
+          order.push("b2");
+        }),
+      ]);
+    });
+    expect(order).toEqual(order[0] === "a1" ? ["a1", "a2", "b1", "b2"] : ["b1", "b2", "a1", "a2"]);
+  });
+});
+
+describe("nested transaction signals", () => {
+  async function openFx(connection: SqlConnection): Promise<{
+    readonly fx: ReturnType<typeof createFxContext>["fx"];
+    readonly bus: SignalBus;
+    readonly ping: ReturnType<typeof signal.once>;
+    readonly close: () => Promise<void>;
+  }> {
+    const ping = signal.once("ping");
+    const signals = new Map([[ping.name, ping]]);
+    const bus = await memorySignalDriver.open({ signals });
+    const signalRuntime: SignalRuntime = {
+      driverId: "memory",
+      get bus() {
+        return bus;
+      },
+      declarations: signals,
+      register(decl) {
+        signals.set(decl.name, decl);
+      },
+      async start() {
+        return bus;
+      },
+      emit: (name, payload, options) => bus.emit(name, payload, options),
+      deadLetters: (name) => bus.deadLetters(name),
+      live: (name, opts) => bus.live(name, opts),
+      checkLiveResume: (name, afterId) => bus.checkLiveResume(name, afterId),
+      async close() {
+        await bus.close();
+      },
+    };
+    const storeRuntime = {
+      async open() {
+        return handleFor(connection);
+      },
+    } as unknown as StoreRuntime;
+    const { fx } = createFxContext({
+      flow: "notes.write",
+      effects: { writes: ["sql:db"], emits: ["ping"] },
+      storeRuntime,
+      signalRuntime,
+    });
+    return {
+      fx,
+      bus,
+      ping,
+      async close() {
+        await bus.close();
+      },
+    };
+  }
+
+  test("nested emits merge and publish only on the outermost commit", async () => {
+    const { connection } = scriptedConnection();
+    const { fx, bus, ping, close } = await openFx(connection);
+    const got: unknown[] = [];
+    await bus.subscribe("ping", "c", async (message) => {
+      got.push(message.payload);
+    });
+    const db = store.sql("db");
+    try {
+      await fx.store(db).transaction(async (tx) => {
+        await fx.emit(ping, { id: "outer" });
+        await tx.transaction(async () => {
+          await fx.emit(ping, { id: "inner" });
+        });
+        await bus.drain();
+        expect(got).toEqual([]);
+      });
+      await bus.drain();
+      expect(got).toEqual([{ id: "outer" }, { id: "inner" }]);
+    } finally {
+      await close();
+    }
+  });
+
+  test("a thrown nested transaction discards its emits", async () => {
+    const { connection } = scriptedConnection();
+    const { fx, bus, ping, close } = await openFx(connection);
+    const got: unknown[] = [];
+    await bus.subscribe("ping", "c", async (message) => {
+      got.push(message.payload);
+    });
+    const db = store.sql("db");
+    try {
+      await fx.store(db).transaction(async (tx) => {
+        await fx.emit(ping, { id: "outer" });
+        try {
+          await tx.transaction(async () => {
+            await fx.emit(ping, { id: "no" });
+            throw new Error("nope");
+          });
+        } catch (err) {
+          expect((err as Error).message).toBe("nope");
+        }
+      });
+      await bus.drain();
+      expect(got).toEqual([{ id: "outer" }]);
+    } finally {
+      await close();
+    }
+  });
+});
+
+function scratchTable(prefix: string): string {
+  const name = `${prefix}_${crypto.randomUUID().replaceAll("-", "")}`;
+  if (!/^[a-z][a-z0-9_]*$/.test(name)) {
+    throw new Error(`unsafe table name: ${name}`);
+  }
+  return name;
+}
+
+describe.skipIf(!LIVE_POSTGRES_URL)("nested transaction (postgres)", () => {
+  test("inner throw rolls back only the inner write; outer commit keeps the outer write", async () => {
+    const url = LIVE_POSTGRES_URL;
+    if (!url) throw new Error("postgres url missing");
+    const conn = await connectPostgres({ url, pool: { max: 1 } });
+    const table = scratchTable("oke_nested");
+    const handle = handleFor(conn);
+    try {
+      await conn.exec(`CREATE TABLE "${table}" (id text PRIMARY KEY, note text)`);
+      await handle.transaction(async (tx) => {
+        await tx.raw(`INSERT INTO "${table}" (id, note) VALUES (?, ?)`, ["outer", "keep"]);
+        try {
+          await tx.transaction(async (inner) => {
+            await inner.raw(`INSERT INTO "${table}" (id, note) VALUES (?, ?)`, ["inner", "drop"]);
+            throw new Error("inner");
+          });
+        } catch (err) {
+          expect((err as Error).message).toBe("inner");
+        }
+      });
+      const rows = await conn.query(`SELECT id FROM "${table}" ORDER BY id`);
+      expect(rows.map((row) => row.id)).toEqual(["outer"]);
+    } finally {
+      await conn.exec(`DROP TABLE IF EXISTS "${table}"`);
+      await conn.close();
+    }
+  });
+
+  test("two concurrent inner transactions on one connection do not interleave", async () => {
+    const url = LIVE_POSTGRES_URL;
+    if (!url) throw new Error("postgres url missing");
+    const conn = await connectPostgres({ url, pool: { max: 1 } });
+    const table = scratchTable("oke_nested_race");
+    const handle = handleFor(conn);
+    const order: string[] = [];
+    try {
+      await conn.exec(`CREATE TABLE "${table}" (id text PRIMARY KEY)`);
+      await handle.transaction(async (tx) => {
+        await Promise.all([
+          tx.transaction(async (inner) => {
+            await inner.raw(`INSERT INTO "${table}" (id) VALUES (?)`, ["a1"]);
+            order.push("a1");
+            await Bun.sleep(40);
+            await inner.raw(`INSERT INTO "${table}" (id) VALUES (?)`, ["a2"]);
+            order.push("a2");
+          }),
+          tx.transaction(async (inner) => {
+            await inner.raw(`INSERT INTO "${table}" (id) VALUES (?)`, ["b1"]);
+            order.push("b1");
+            await Bun.sleep(40);
+            await inner.raw(`INSERT INTO "${table}" (id) VALUES (?)`, ["b2"]);
+            order.push("b2");
+          }),
+        ]);
+      });
+      expect(order).toEqual(
+        order[0] === "a1" ? ["a1", "a2", "b1", "b2"] : ["b1", "b2", "a1", "a2"],
+      );
+      const rows = await conn.query(`SELECT id FROM "${table}" ORDER BY id`);
+      expect(rows.map((row: SqlRow) => row.id)).toEqual(["a1", "a2", "b1", "b2"]);
+    } finally {
+      await conn.exec(`DROP TABLE IF EXISTS "${table}"`);
+      await conn.close();
+    }
+  });
+});