okengine 0.19.9 → 0.21.0

package/src/elements/store/resource.ts

@@ -14,7 +14,7 @@
 
 import { flow, type AnyFlowDef, type FlowDef, type FlowErrorMap } from "../../kernel/flow.ts";
 import { applyBoundaryContract, stampBoundaryContract } from "../../kernel/boundary-contract.ts";
-import { fail } from "../../kernel/errors.ts";
+import { fail } from "../../kernel/fail-helpers.ts";
 import type { Fx } from "../../kernel/fx.ts";
 import {
   openLiveStream,
@@ -53,7 +53,11 @@ export interface ResourceOptions {
    * used to extend `update` with the path id (wire sends `{ id, ...patch }`).
    */
   readonly idSchema?: unknown;
-  /** Typed errors for get / update / remove (default `{ NotFound }`). */
+  /**
+   * Extra typed errors for get / update / remove.
+   *
+   * Built-in `NotFound` is always on — omit unless tightening the payload.
+   */
   readonly errors?: FlowErrorMap;
   /** `:id` column; defaults to the table primary key. */
   readonly id?: unknown;
@@ -191,7 +195,7 @@ export function resource(db: SqlStoreDecl, table: unknown, options: ResourceOpti
   const { mode, limit, maxLimit, cursorColumns: resolvedCursor } = scope;
   const countMode = scope.count;
 
-  const errors = options.errors ?? ({ NotFound: {} as never } as FlowErrorMap);
+  const errors = options.errors;
   const breaking = options.breaking === true;
 
   /** Run the list query and shape rows + meta. */
@@ -309,7 +313,7 @@ export function resource(db: SqlStoreDecl, table: unknown, options: ResourceOpti
         findById(t: unknown, id: string): Promise<SqlRow | null>;
       };
       const row = await store.findById(table, String(id));
-      if (!row) return fail("NotFound", {});
+      if (!row) return fail.notFound();
       return row;
     },
   });
@@ -341,7 +345,7 @@ export function resource(db: SqlStoreDecl, table: unknown, options: ResourceOpti
         update(t: unknown): { set(row: SqlRow): { where(w: unknown): Promise<number> } };
       };
       const existing = await store.findById(table, String(id));
-      if (!existing) return fail("NotFound", {});
+      if (!existing) return fail.notFound();
       if (Object.keys(patch).length > 0) {
         await store
           .update(table)
@@ -349,7 +353,7 @@ export function resource(db: SqlStoreDecl, table: unknown, options: ResourceOpti
           .where(leafOp(idDrizzleCol, "=", String(id)));
       }
       const row = await store.findById(table, String(id));
-      if (!row) return fail("NotFound", {});
+      if (!row) return fail.notFound();
       return row;
     },
   });
@@ -371,7 +375,7 @@ export function resource(db: SqlStoreDecl, table: unknown, options: ResourceOpti
         delete(t: unknown, id: string): Promise<boolean>;
       };
       const deleted = await store.delete(table, String(id));
-      if (!deleted) return fail("NotFound", {});
+      if (!deleted) return fail.notFound();
       return fx.json.empty();
     },
   });

package/src/elements/store/runtime.ts

@@ -44,6 +44,7 @@ import type {
   StoreDecl,
 } from "./declare.ts";
 import { openSqlKvNamespace } from "./kv-sql.ts";
+import { withStoreErrorMap } from "./store-errors.ts";
 import { createGatedFilesStoreHandle, type GatedFilesFxBridge } from "./files-fx.ts";
 import {
   createFilesImagePipeline,
@@ -434,14 +435,15 @@ export function createStoreRuntime(options: CreateStoreRuntimeOptions): StoreRun
       kvNs.set(decl.name, ns);
     }
     const driverId = ns.driverId;
+    const handle = ns;
     return {
       ref: `kv:${decl.name}`,
       driverId,
-      get: (key) => ns!.get(key),
-      set: (key, value, ttl) => ns!.set(key, value, ttl),
-      delete: (key) => ns!.delete(key),
-      list: (prefix) => ns!.list(prefix),
-      ttlMs: (key) => ns!.ttlMs(key),
+      get: (key) => withStoreErrorMap(() => handle.get(key)),
+      set: (key, value, ttl) => withStoreErrorMap(() => handle.set(key, value, ttl)),
+      delete: (key) => withStoreErrorMap(() => handle.delete(key)),
+      list: (prefix) => withStoreErrorMap(() => handle.list(prefix)),
+      ttlMs: (key) => withStoreErrorMap(() => handle.ttlMs(key)),
     };
   }
 
@@ -458,19 +460,22 @@ export function createStoreRuntime(options: CreateStoreRuntimeOptions): StoreRun
       });
       fileBuckets.set(decl.name, bucket);
     }
+    const handle = bucket;
     const access = {
-      get: (key: string) => bucket!.get(key),
-      put: (key: string, data: Uint8Array | string) => bucket!.put(key, data),
+      get: (key: string) => withStoreErrorMap(() => handle.get(key)),
+      put: (key: string, data: Uint8Array | string) =>
+        withStoreErrorMap(() => handle.put(key, data)),
     };
     return {
       ref: `files:${decl.name}`,
-      driverId: bucket.driverId,
-      put: (key, data) => bucket!.put(key, data),
-      get: (key) => bucket!.get(key),
-      delete: (key) => bucket!.delete(key),
-      list: (prefix) => bucket!.list(prefix),
+      driverId: handle.driverId,
+      put: (key, data) => withStoreErrorMap(() => handle.put(key, data)),
+      get: (key) => withStoreErrorMap(() => handle.get(key)),
+      delete: (key) => withStoreErrorMap(() => handle.delete(key)),
+      list: (prefix) => withStoreErrorMap(() => handle.list(prefix)),
       image: (source, imageOpts) => createFilesImagePipeline(access, source, imageOpts),
-      putImage: (key, data, putOpts) => putImageToBucket(access, key, data, putOpts),
+      putImage: (key, data, putOpts) =>
+        withStoreErrorMap(() => putImageToBucket(access, key, data, putOpts)),
     };
   }
 

package/src/elements/store/schema-decl.test.ts

@@ -3,6 +3,9 @@
  */
 
 import { describe, expect, test } from "bun:test";
+import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
 import { plugin } from "../../kernel/plugin.ts";
 import { createRecordingApi } from "../../kernel/registry.ts";
 import {
@@ -18,9 +21,13 @@ import {
   type SqlStoreHandle,
 } from "../store.ts";
 import {
+  discoverDeclareRel,
+  discoverGeneratedRel,
   emitDrizzleSource,
   GENERATED_SCHEMA_HEADER,
+  maybeEmitDomainSchema,
   mergeSchemaTables,
+  resolveEmitPaths,
   tablesFromPluginContributions,
 } from "./emit-drizzle.ts";
 
@@ -297,3 +304,174 @@ describe("store.schema RLS extras", () => {
     expect(emitDrizzleSource([notes], "postgres")).toContain("pgTable.withRLS");
   });
 });
+
+describe("declare path discovery", () => {
+  test("schema.ts wins over schema/index.ts", async () => {
+    const dir = await mkdtemp(join(tmpdir(), "oke-decl-priority-"));
+    await mkdir(join(dir, "src", "db", "schema"), { recursive: true });
+    await writeFile(join(dir, "src", "db", "schema.ts"), "export {}\n");
+    await writeFile(join(dir, "src", "db", "schema", "index.ts"), "export {}\n");
+    expect(discoverDeclareRel(dir)).toBe("src/db/schema.ts");
+    expect(resolveEmitPaths(dir).declarePath).toBe(join(dir, "src/db/schema.ts"));
+    await rm(dir, { recursive: true, force: true });
+  });
+
+  test("schema.decl.ts when schema.ts is absent", async () => {
+    const dir = await mkdtemp(join(tmpdir(), "oke-decl-prev-"));
+    await mkdir(join(dir, "src", "db", "schema"), { recursive: true });
+    await writeFile(join(dir, "src", "db", "schema.decl.ts"), "export {}\n");
+    await writeFile(join(dir, "src", "db", "schema", "index.ts"), "export {}\n");
+    expect(discoverDeclareRel(dir)).toBe("src/db/schema.decl.ts");
+    await rm(dir, { recursive: true, force: true });
+  });
+
+  test("schema/index.ts when single-file declare is absent", async () => {
+    const dir = await mkdtemp(join(tmpdir(), "oke-decl-folder-"));
+    await mkdir(join(dir, "src", "db", "schema"), { recursive: true });
+    await writeFile(join(dir, "src", "db", "schema", "index.ts"), "export {}\n");
+    expect(discoverDeclareRel(dir)).toBe("src/db/schema/index.ts");
+    await rm(dir, { recursive: true, force: true });
+  });
+
+  test("db.declare overrides discovery", async () => {
+    const dir = await mkdtemp(join(tmpdir(), "oke-decl-override-"));
+    await mkdir(join(dir, "src", "db", "schema"), { recursive: true });
+    await writeFile(join(dir, "src", "db", "schema.ts"), "export {}\n");
+    const resolved = resolveEmitPaths(dir, { declare: "src/db/schema/index.ts" });
+    expect(resolved.declarePath).toBe(join(dir, "src/db/schema/index.ts"));
+    await rm(dir, { recursive: true, force: true });
+  });
+
+  test("drizzle/index.ts wins over drizzle.ts", async () => {
+    const dir = await mkdtemp(join(tmpdir(), "oke-gen-folder-"));
+    await mkdir(join(dir, "src", "db", "drizzle"), { recursive: true });
+    await writeFile(join(dir, "src", "db", "drizzle", "index.ts"), "export {}\n");
+    await writeFile(join(dir, "src", "db", "drizzle.ts"), "export {}\n");
+    expect(discoverGeneratedRel(dir, "src/db/schema.ts")).toBe("src/db/drizzle/index.ts");
+    await rm(dir, { recursive: true, force: true });
+  });
+
+  test("omitted generated is drizzle/index.ts even if older files exist", async () => {
+    const dir = await mkdtemp(join(tmpdir(), "oke-gen-default-"));
+    await mkdir(join(dir, "src", "db"), { recursive: true });
+    await writeFile(join(dir, "src", "db", "drizzle.ts"), "export {}\n");
+    await writeFile(join(dir, "src", "db", "schema.drizzle.ts"), "export {}\n");
+    expect(discoverGeneratedRel(dir, "src/db/schema.ts")).toBe("src/db/drizzle/index.ts");
+    await rm(dir, { recursive: true, force: true });
+  });
+});
+
+describe("maybeEmitDomainSchema — barrel declare", () => {
+  test("emits from schema/index.ts without schema.ts", async () => {
+    const dir = await mkdtemp(join(tmpdir(), "oke-schema-folder-"));
+    const schemaDir = join(dir, "src", "db", "schema");
+    await mkdir(schemaDir, { recursive: true });
+    const oke = resolve(import.meta.dir, "../../index.ts");
+    await writeFile(
+      join(schemaDir, "posts.ts"),
+      `import { store, field } from ${JSON.stringify(oke)};
+export const posts = store.schema.table("posts", {
+  id: field.id().primaryKey(),
+  title: field.text().notNull(),
+});
+`,
+    );
+    await writeFile(join(schemaDir, "index.ts"), `export * from "./posts.ts";\n`);
+    const result = await maybeEmitDomainSchema({
+      cwd: dir,
+      dialect: "postgres",
+    });
+    expect(result.emitted).toBe(true);
+    expect(result.tableCount).toBe(1);
+    const generated = await readFile(join(dir, "src", "db", "drizzle", "posts.ts"), "utf8");
+    expect(generated).toContain('pgTable("posts"');
+    const barrel = await readFile(join(dir, "src", "db", "drizzle", "index.ts"), "utf8");
+    expect(barrel).toContain('export * from "./posts.ts"');
+    await rm(dir, { recursive: true, force: true });
+  });
+
+  test("writes one file per table with FK import + relations", async () => {
+    const dir = await mkdtemp(join(tmpdir(), "oke-drizzle-split-"));
+    const schemaDir = join(dir, "src", "db", "schema");
+    await mkdir(schemaDir, { recursive: true });
+    const oke = resolve(import.meta.dir, "../../index.ts");
+    await writeFile(
+      join(schemaDir, "links.ts"),
+      `import { store, field } from ${JSON.stringify(oke)};
+export const links = store.schema.table("links", {
+  id: field.id().primaryKey(),
+  code: field.text().notNull().unique(),
+});
+`,
+    );
+    await writeFile(
+      join(schemaDir, "daily.ts"),
+      `import { store, field } from ${JSON.stringify(oke)};
+import { links } from "./links.ts";
+export const daily = store.schema.table("daily", {
+  id: field.id().primaryKey(),
+  code: field.text().notNull().references(() => links.code, { onDelete: "cascade" }),
+});
+`,
+    );
+    await writeFile(
+      join(schemaDir, "relations.ts"),
+      `import { store } from ${JSON.stringify(oke)};
+import { daily } from "./daily.ts";
+import { links } from "./links.ts";
+export const relations = store.schema.relations({ links, daily }, (r) => ({
+  links: { daily: r.many.daily({ from: r.links.code, to: r.daily.code }) },
+  daily: { link: r.one.links({ from: r.daily.code, to: r.links.code, optional: false }) },
+}));
+`,
+    );
+    await writeFile(
+      join(schemaDir, "index.ts"),
+      `export * from "./links.ts";
+export * from "./daily.ts";
+export * from "./relations.ts";
+`,
+    );
+    const result = await maybeEmitDomainSchema({ cwd: dir, dialect: "postgres" });
+    expect(result.emitted).toBe(true);
+    expect(result.tableCount).toBe(2);
+    const daily = await readFile(join(dir, "src", "db", "drizzle", "daily.ts"), "utf8");
+    expect(daily).toContain('import { links } from "./links.ts"');
+    expect(daily).toContain(".references(() => links.code");
+    const rel = await readFile(join(dir, "src", "db", "drizzle", "relations.ts"), "utf8");
+    expect(rel).toContain("defineRelations({ links, daily }");
+    const barrel = await readFile(join(dir, "src", "db", "drizzle", "index.ts"), "utf8");
+    expect(barrel).toContain('export * from "./relations.ts"');
+    await rm(dir, { recursive: true, force: true });
+  });
+
+  test("prunes stale generated files and drops sibling drizzle.ts", async () => {
+    const dir = await mkdtemp(join(tmpdir(), "oke-drizzle-prune-"));
+    const schemaDir = join(dir, "src", "db", "schema");
+    await mkdir(schemaDir, { recursive: true });
+    await mkdir(join(dir, "src", "db", "drizzle"), { recursive: true });
+    const oke = resolve(import.meta.dir, "../../index.ts");
+    await writeFile(
+      join(schemaDir, "posts.ts"),
+      `import { store, field } from ${JSON.stringify(oke)};
+export const posts = store.schema.table("posts", {
+  id: field.id().primaryKey(),
+});
+`,
+    );
+    await writeFile(join(schemaDir, "index.ts"), `export * from "./posts.ts";\n`);
+    await writeFile(
+      join(dir, "src", "db", "drizzle.ts"),
+      `// generated by oke — do not edit\nexport const stale = true;\n`,
+    );
+    await writeFile(
+      join(dir, "src", "db", "drizzle", "gone.ts"),
+      `// generated by oke — do not edit\nexport const gone = true;\n`,
+    );
+    await maybeEmitDomainSchema({ cwd: dir, dialect: "postgres" });
+    expect(await Bun.file(join(dir, "src", "db", "drizzle.ts")).exists()).toBe(false);
+    expect(await Bun.file(join(dir, "src", "db", "drizzle", "gone.ts")).exists()).toBe(false);
+    expect(await Bun.file(join(dir, "src", "db", "drizzle", "posts.ts")).exists()).toBe(true);
+    await rm(dir, { recursive: true, force: true });
+  });
+});

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

@@ -0,0 +1,197 @@
+/**
+ * SQLSTATE / SQLite constraint → typed FlowFailure.
+ */
+
+import { describe, expect, test } from "bun:test";
+import { isFlowFailure } from "../../kernel/hooks.ts";
+import { isRetryableSqlError, sqlErrorToFailure } from "./sql-errors.ts";
+
+describe("sqlErrorToFailure", () => {
+  test("unique / exclusion → Conflict  without copying message", () => {
+    const unique = sqlErrorToFailure({
+      code: "23505",
+      message: 'duplicate key value violates unique constraint "users_email_key"',
+      detail: "Key (email)=(a@b.c) already exists.",
+      constraint: "users_email_key",
+      table: "users",
+      column: "email",
+    });
+    expect(unique?.error.code).toBe("Conflict");
+    expect(unique?.error.data).toEqual({
+      sqlstate: "23505",
+      constraint: "users_email_key",
+      table: "users",
+      column: "email",
+    });
+    expect(JSON.stringify(unique)).not.toContain("already exists");
+    expect(JSON.stringify(unique)).not.toContain("a@b.c");
+
+    const exclusion = sqlErrorToFailure({ code: "23P01", constraint: "no_overlap" });
+    expect(exclusion?.error.code).toBe("Conflict");
+  });
+
+  test("restrict / restrict_violation → ForeignKey", () => {
+    expect(sqlErrorToFailure({ code: "23001", table: "notes" })?.error.code).toBe("ForeignKey");
+  });
+
+  test("invalid / too_long / out_of_range → DatabaseError 422 reasons", () => {
+    expect(sqlErrorToFailure({ code: "22P02" })?.error.data).toMatchObject({
+      reason: "invalid",
+      sqlstate: "22P02",
+    });
+    expect(sqlErrorToFailure({ code: "22007" })?.error.data).toMatchObject({ reason: "invalid" });
+    expect(sqlErrorToFailure({ code: "22023" })?.error.data).toMatchObject({ reason: "invalid" });
+    expect(sqlErrorToFailure({ code: "42804" })?.error.data).toMatchObject({ reason: "invalid" });
+    expect(sqlErrorToFailure({ code: "22001", column: "title" })?.error.data).toMatchObject({
+      reason: "too_long",
+      column: "title",
+    });
+    expect(sqlErrorToFailure({ code: "22003" })?.error.data).toMatchObject({
+      reason: "out_of_range",
+    });
+    expect(sqlErrorToFailure({ code: "22008" })?.error.data).toMatchObject({
+      reason: "out_of_range",
+    });
+  });
+
+  test("walks Drizzle .cause for unique SQLSTATE", () => {
+    const wrapped = {
+      message: "Failed query: insert into users constraint users_email_key",
+      cause: {
+        code: "23505",
+        constraint: "users_email_key",
+        message: 'duplicate key value violates unique constraint "users_email_key"',
+      },
+    };
+    const mapped = sqlErrorToFailure(wrapped);
+    expect(mapped?.error.code).toBe("Conflict");
+    expect(mapped?.error.data).toMatchObject({ constraint: "users_email_key", sqlstate: "23505" });
+    expect(JSON.stringify(mapped)).not.toContain("duplicate key");
+  });
+
+  test("foreign key → ForeignKey", () => {
+    const fk = sqlErrorToFailure({
+      code: "23503",
+      table: "notes",
+      constraint: "notes_user_id_fkey",
+      message: 'insert or update on table "notes" violates foreign key constraint',
+    });
+    expect(fk?.error.code).toBe("ForeignKey");
+    expect(fk?.error.data).toMatchObject({
+      sqlstate: "23503",
+      table: "notes",
+      constraint: "notes_user_id_fkey",
+    });
+    expect(JSON.stringify(fk)).not.toContain("violates");
+  });
+
+  test("not_null / check → DatabaseError reasons", () => {
+    const notNull = sqlErrorToFailure({ code: "23502", column: "title", table: "posts" });
+    expect(notNull?.error.code).toBe("DatabaseError");
+    expect(notNull?.error.data).toMatchObject({ reason: "not_null", column: "title" });
+
+    const check = sqlErrorToFailure({ code: "23514", constraint: "positive_clicks" });
+    expect(check?.error.code).toBe("DatabaseError");
+    expect(check?.error.data).toMatchObject({ reason: "check", constraint: "positive_clicks" });
+  });
+
+  test("40001 / 40P01 left thrown until retryable: unavailable", () => {
+    const ser = { code: "40001", message: "could not serialize access" };
+    expect(isRetryableSqlError(ser)).toBe(true);
+    expect(sqlErrorToFailure(ser, { retryable: "leave" })).toBeUndefined();
+    const exhausted = sqlErrorToFailure(ser, { retryable: "unavailable" });
+    expect(exhausted?.error.code).toBe("ServiceUnavailable");
+    expect(JSON.stringify(exhausted)).not.toContain("serialize");
+
+    expect(sqlErrorToFailure({ code: "40P01" }, { retryable: "leave" })).toBeUndefined();
+    expect(sqlErrorToFailure({ code: "40P01" }, { retryable: "unavailable" })?.error.code).toBe(
+      "ServiceUnavailable",
+    );
+    expect(isRetryableSqlError({ code: "55P03" })).toBe(true);
+    expect(sqlErrorToFailure({ code: "55P03" }, { retryable: "leave" })).toBeUndefined();
+    expect(sqlErrorToFailure({ code: "55P03" }, { retryable: "unavailable" })?.error.code).toBe(
+      "ServiceUnavailable",
+    );
+  });
+
+  test("connection / paused → ServiceUnavailable", () => {
+    expect(sqlErrorToFailure({ code: "08006" })?.error.code).toBe("ServiceUnavailable");
+    expect(sqlErrorToFailure({ code: "53300" })?.error.code).toBe("ServiceUnavailable");
+    expect(sqlErrorToFailure({ code: "53100" })?.error.code).toBe("ServiceUnavailable");
+    expect(sqlErrorToFailure({ code: "57P01" })?.error.code).toBe("ServiceUnavailable");
+    expect(sqlErrorToFailure({ code: "57014" })?.error.code).toBe("ServiceUnavailable");
+    expect(sqlErrorToFailure({ code: "25P03" })?.error.code).toBe("ServiceUnavailable");
+    expect(sqlErrorToFailure({ code: "ERR_POSTGRES_CONNECTION_CLOSED" })?.error.code).toBe(
+      "ServiceUnavailable",
+    );
+    expect(
+      sqlErrorToFailure({ name: "SharedPostgresPausedError", code: "ERR_OKE_POSTGRES_PAUSED" })
+        ?.error.code,
+    ).toBe("ServiceUnavailable");
+  });
+
+  test("sqlite UNIQUE / FK / NOT NULL / CHECK", () => {
+    const unique = sqlErrorToFailure({
+      name: "SQLiteError",
+      message: "UNIQUE constraint failed: users.email",
+      errno: 2067,
+    });
+    expect(unique?.error.code).toBe("Conflict");
+    expect(unique?.error.data).toMatchObject({ table: "users", column: "email" });
+
+    const fk = sqlErrorToFailure({
+      name: "SQLiteError",
+      message: "FOREIGN KEY constraint failed",
+      errno: 787,
+    });
+    expect(fk?.error.code).toBe("ForeignKey");
+
+    const notNull = sqlErrorToFailure({
+      name: "SQLiteError",
+      message: "NOT NULL constraint failed: posts.title",
+    });
+    expect(notNull?.error.data).toMatchObject({
+      reason: "not_null",
+      table: "posts",
+      column: "title",
+    });
+
+    const check = sqlErrorToFailure({
+      name: "SQLiteError",
+      message: "CHECK constraint failed: positive_clicks",
+    });
+    expect(check?.error.data).toMatchObject({ reason: "check", constraint: "positive_clicks" });
+
+    const pk = sqlErrorToFailure({
+      name: "SQLiteError",
+      message: "PRIMARY KEY constraint failed: users.id",
+      errno: 1555,
+    });
+    expect(pk?.error.code).toBe("Conflict");
+    expect(pk?.error.data).toMatchObject({ table: "users", column: "id" });
+  });
+
+  test("sqlite busy left thrown until retryable: unavailable", () => {
+    const busy = {
+      name: "SQLiteError",
+      code: "SQLITE_BUSY",
+      errno: 5,
+      message: "database is locked",
+    };
+    expect(isRetryableSqlError(busy)).toBe(true);
+    expect(sqlErrorToFailure(busy, { retryable: "leave" })).toBeUndefined();
+    expect(sqlErrorToFailure(busy, { retryable: "unavailable" })?.error.code).toBe(
+      "ServiceUnavailable",
+    );
+  });
+
+  test("unknown SQLSTATE → DatabaseError unknown; non-SQL stays undefined", () => {
+    const other = sqlErrorToFailure({ code: "22012", message: "division by zero" });
+    expect(other?.error.code).toBe("DatabaseError");
+    expect(other?.error.data).toMatchObject({ reason: "unknown", sqlstate: "22012" });
+    expect(JSON.stringify(other)).not.toContain("division");
+
+    expect(sqlErrorToFailure(new Error("boom"))).toBeUndefined();
+    expect(isFlowFailure(sqlErrorToFailure({ code: "23505" }))).toBe(true);
+  });
+});