okengine 0.2.5 → 0.2.8

package/src/elements/store/domain-ddl.test.ts

@@ -0,0 +1,86 @@
+/**
+ * Domain DDL policy — ensure vs migrate; missing schema → OKE1101.
+ */
+
+import { describe, expect, test } from "bun:test";
+import { Database } from "bun:sqlite";
+import { OkeError, OKE_ERRORS } from "../../kernel/errors.ts";
+import { sqliteDriver } from "../../drivers/sqlite.ts";
+import { defineTable } from "./table.ts";
+import { createSqlStoreHandle } from "./sql-session.ts";
+
+const notes = defineTable("notes", { id: true, title: true });
+
+describe("domain DDL policy", () => {
+  test("ensure mode creates tables on first touch", async () => {
+    const db = new Database(":memory:");
+    const conn = await sqliteDriver.connect({ client: db, role: "primary" });
+    const handle = createSqlStoreHandle("sql:app", {
+      connection: conn,
+      classifications: new Map(),
+      routedRole: "primary",
+      domainDdl: "ensure",
+    });
+    await handle.insert(notes).values({ id: "1", title: "hi" });
+    const rows = await handle.select().from(notes);
+    expect(rows).toHaveLength(1);
+    await conn.close();
+  });
+
+  test("prod/off mode never CREATE TABLE IF NOT EXISTS", async () => {
+    const db = new Database(":memory:");
+    const execSql: string[] = [];
+    const base = await sqliteDriver.connect({ client: db, role: "primary" });
+    const conn = {
+      ...base,
+      driverId: "sqlite" as const,
+      role: "primary" as const,
+      async query(sql: string, params?: readonly unknown[]) {
+        execSql.push(sql);
+        return base.query(sql, params);
+      },
+      async exec(sql: string, params?: readonly unknown[]) {
+        execSql.push(sql);
+        return base.exec(sql, params);
+      },
+      close: () => base.close(),
+    };
+    const handle = createSqlStoreHandle("sql:app", {
+      connection: conn,
+      classifications: new Map(),
+      routedRole: "primary",
+      domainDdl: "off",
+    });
+    try {
+      await handle.select().from(notes);
+    } catch {
+      /* expected — table missing */
+    }
+    expect(execSql.some((s) => /CREATE TABLE IF NOT EXISTS/i.test(s))).toBe(false);
+    await conn.close();
+  });
+
+  test("off mode remaps missing table to DOMAIN_SCHEMA_MISSING", async () => {
+    const db = new Database(":memory:");
+    const conn = await sqliteDriver.connect({ client: db, role: "primary" });
+    const handle = createSqlStoreHandle("sql:app", {
+      connection: conn,
+      classifications: new Map(),
+      routedRole: "primary",
+      domainDdl: "off",
+    });
+    let err: unknown;
+    try {
+      await handle.select().from(notes);
+    } catch (e) {
+      err = e;
+    }
+    expect(err).toBeInstanceOf(OkeError);
+    const oke = err as OkeError;
+    expect(oke.code).toBe(OKE_ERRORS.DOMAIN_SCHEMA_MISSING.code);
+    expect(oke.causeText).toContain("migrations have not been applied");
+    expect(oke.fix).toContain("oke db migrate");
+    expect(oke.docsUrl).toContain(`/e/${OKE_ERRORS.DOMAIN_SCHEMA_MISSING.code}`);
+    await conn.close();
+  });
+});

package/src/elements/store/emit-drizzle.ts

@@ -0,0 +1,363 @@
+/**
+ * Emit dialect-specific Drizzle schema TypeScript from abstract declarations.
+ *
+ * Consumed as a pre-step inside `oke db push|generate|migrate` (and `oke dev`
+ * watch) when abstract decls exist — not a third schema CLI.
+ */
+
+import { mkdir, writeFile } from "node:fs/promises";
+import { dirname, join, resolve } from "node:path";
+import type { TableContribution } from "../../kernel/plugin.ts";
+import {
+  isFieldBuilder,
+  isSchemaColumnDecl,
+  isSchemaTableDecl,
+  relationsFromExports,
+  schemaTable,
+  tablesFromExports,
+  type RelationColumnRef,
+  type SchemaColumnDecl,
+  type SchemaColumnInput,
+  type SchemaRelationEntry,
+  type SchemaRelationsDecl,
+  type SchemaTableDecl,
+} from "./schema-decl.ts";
+
+/** Supported Drizzle dialects for domain schema emit. */
+export type SqlDialect = "sqlite" | "postgres";
+
+/** Header written at the top of generated files. */
+export const GENERATED_SCHEMA_HEADER = "// generated by oke — do not edit";
+
+/** Default output path (relative to project root). */
+export const DEFAULT_GENERATED_SCHEMA_REL = "src/schema.generated.ts";
+
+/** Default declaration module path (relative to project root). */
+export const DEFAULT_DECLARE_SCHEMA_REL = "src/schema.decl.ts";
+
+/**
+ * Map a store.sql driver id to an emit dialect.
+ *
+ * @param driverId - Protocol driver id (`sqlite` · `postgres` · `memory` · …)
+ */
+export function dialectFromDriverId(driverId: string | undefined): SqlDialect {
+  if (driverId === "postgres") return "postgres";
+  return "sqlite";
+}
+
+/**
+ * Serialize one column to a Drizzle builder chain.
+ *
+ * @param col - Column decl
+ * @param dialect - Target dialect (affects import names only at file level)
+ */
+export function emitColumnSource(col: SchemaColumnDecl, _dialect: SqlDialect): string {
+  const fn = col.sqlType === "integer" ? "integer" : "text";
+  let expr = `${fn}(${JSON.stringify(col.sqlName)})`;
+  if (col.primaryKey) expr += ".primaryKey()";
+  else if (col.notNull) expr += ".notNull()";
+  if (col.unique) expr += ".unique()";
+  if (col.defaultValue !== undefined) {
+    expr += `.default(${literalSource(col.defaultValue)})`;
+  }
+  if (col.defaultFnKind === "id") expr += ".$defaultFn(id)";
+  else if (col.defaultFnKind === "now") expr += ".$defaultFn(now)";
+  if (col.references) {
+    const target = col.references.ref();
+    const targetTable = exportNameForTable(target.tableName ?? "unknown");
+    const targetCol = target.key;
+    expr += `.references(() => ${targetTable}.${targetCol}`;
+    const actions = col.references.actions;
+    if (actions && (actions.onDelete || actions.onUpdate)) {
+      const parts: string[] = [];
+      if (actions.onDelete) parts.push(`onDelete: ${JSON.stringify(actions.onDelete)}`);
+      if (actions.onUpdate) parts.push(`onUpdate: ${JSON.stringify(actions.onUpdate)}`);
+      expr += `, { ${parts.join(", ")} }`;
+    }
+    expr += ")";
+  }
+  return expr;
+}
+
+function literalSource(value: string | number | boolean | null): string {
+  if (value === null) return "null";
+  if (typeof value === "string") return JSON.stringify(value);
+  if (typeof value === "boolean") return value ? "true" : "false";
+  return String(value);
+}
+
+function emitColRef(ref: RelationColumnRef): string {
+  return `r.${ref.table}.${ref.column}`;
+}
+
+function emitColRefs(
+  value: RelationColumnRef | readonly RelationColumnRef[] | undefined,
+): string | undefined {
+  if (value === undefined) return undefined;
+  if (Array.isArray(value)) {
+    const refs = value as readonly RelationColumnRef[];
+    if (refs.length === 1) return emitColRef(refs[0]!);
+    return `[${refs.map(emitColRef).join(", ")}]`;
+  }
+  return emitColRef(value as RelationColumnRef);
+}
+
+function emitRelationEntry(entry: SchemaRelationEntry): string {
+  const helper = entry.kind === "one" ? "one" : "many";
+  const parts: string[] = [];
+  const from = emitColRefs(entry.from);
+  const to = emitColRefs(entry.to);
+  if (from !== undefined) parts.push(`from: ${from}`);
+  if (to !== undefined) parts.push(`to: ${to}`);
+  if (entry.kind === "one" && entry.optional !== undefined) {
+    parts.push(`optional: ${entry.optional ? "true" : "false"}`);
+  }
+  if (entry.alias !== undefined) parts.push(`alias: ${JSON.stringify(entry.alias)}`);
+  const config = parts.length > 0 ? `{ ${parts.join(", ")} }` : "";
+  return `r.${helper}.${entry.target}(${config})`;
+}
+
+/**
+ * Emit a `defineRelations(...)` block from abstract relations decls.
+ *
+ * @param relations - Relations declarations (typically one)
+ */
+export function emitRelationsSource(relations: readonly SchemaRelationsDecl[]): string {
+  if (relations.length === 0) return "";
+  const blocks: string[] = [];
+  for (const rel of relations) {
+    const schemaKeys = rel.tableKeys.join(", ");
+    const tableBlocks: string[] = [];
+    for (const [tableKey, tableRels] of Object.entries(rel.config)) {
+      const relLines = Object.entries(tableRels).map(
+        ([relName, entry]) => `    ${relName}: ${emitRelationEntry(entry)},`,
+      );
+      tableBlocks.push(`  ${tableKey}: {\n${relLines.join("\n")}\n  },`);
+    }
+    blocks.push(
+      `export const relations = defineRelations({ ${schemaKeys} }, (r) => ({\n${tableBlocks.join("\n")}\n}));`,
+    );
+  }
+  return blocks.join("\n\n");
+}
+
+/** Options for {@link emitDrizzleSource}. */
+export interface EmitDrizzleSourceOptions {
+  readonly relations?: readonly SchemaRelationsDecl[];
+}
+
+/**
+ * Emit a full Drizzle schema module from abstract table decls.
+ *
+ * @param tables - App + plugin tables (already merged)
+ * @param dialect - sqlite → sqliteTable · postgres → pgTable
+ * @param options - Optional relations to emit as `defineRelations`
+ */
+export function emitDrizzleSource(
+  tables: readonly SchemaTableDecl[],
+  dialect: SqlDialect,
+  options: EmitDrizzleSourceOptions = {},
+): string {
+  const tableFn = dialect === "postgres" ? "pgTable" : "sqliteTable";
+  const coreImport =
+    dialect === "postgres"
+      ? `import { pgTable, text, integer } from "drizzle-orm/pg-core";`
+      : `import { sqliteTable, text, integer } from "drizzle-orm/sqlite-core";`;
+
+  const needsId = tables.some((t) =>
+    Object.values(t.columns).some((c) => c.defaultFnKind === "id"),
+  );
+  const needsNow = tables.some((t) =>
+    Object.values(t.columns).some((c) => c.defaultFnKind === "now"),
+  );
+  const helperNames = [needsId ? "id" : null, needsNow ? "now" : null].filter(
+    (x): x is string => x !== null,
+  );
+  const helperImport =
+    helperNames.length > 0 ? `import { ${helperNames.join(", ")} } from "okengine/store";\n` : "";
+
+  const relations = options.relations ?? [];
+  const relationsImport =
+    relations.length > 0 ? `import { defineRelations } from "drizzle-orm";\n` : "";
+
+  const blocks = tables.map((table) => {
+    const lines = Object.values(table.columns).map(
+      (col) => `  ${col.key}: ${emitColumnSource(col, dialect)},`,
+    );
+    return `export const ${exportNameForTable(table.name)} = ${tableFn}(${JSON.stringify(table.name)}, {\n${lines.join("\n")}\n});`;
+  });
+
+  const relationsBlock = emitRelationsSource(relations);
+
+  return [
+    GENERATED_SCHEMA_HEADER,
+    coreImport,
+    relationsImport.trimEnd(),
+    helperImport.trimEnd(),
+    "",
+    blocks.join("\n\n"),
+    relationsBlock ? `\n${relationsBlock}` : "",
+    "",
+  ]
+    .filter((line, i, arr) => !(line === "" && arr[i - 1] === ""))
+    .join("\n");
+}
+
+function exportNameForTable(name: string): string {
+  // Keep simple SQL names as-is; camelCase odd names.
+  if (/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(name)) return name;
+  return name.replace(/[^a-zA-Z0-9_]+/g, "_");
+}
+
+/**
+ * Build a {@link SchemaTableDecl} from a plugin column map (builders or decls).
+ *
+ * @param name - Table name
+ * @param columns - Column map
+ */
+export function schemaTableFromPluginColumns(
+  name: string,
+  columns: Readonly<Record<string, SchemaColumnInput>>,
+): SchemaTableDecl {
+  return schemaTable(name, columns);
+}
+
+/**
+ * Whether a record looks like an abstract column map (not `{ plane }` metadata).
+ *
+ * @param value - Unknown second arg to plugin.table
+ */
+export function isAbstractColumnMap(
+  value: unknown,
+): value is Readonly<Record<string, SchemaColumnInput>> {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const entries = Object.entries(value);
+  if (entries.length === 0) return true;
+  // Legacy `{ plane: "operator" }` — not columns.
+  if (entries.length === 1 && entries[0]![0] === "plane" && typeof entries[0]![1] === "string") {
+    return false;
+  }
+  return entries.every(([, v]) => isFieldBuilder(v) || isSchemaColumnDecl(v));
+}
+
+/**
+ * Extract schema tables from plugin contributions that supply `field.*` columns.
+ *
+ * Contributions without columns (name + plane only) are skipped — auth/console
+ * still use hand-written SQL for those tables.
+ *
+ * @param contributions - Plugin table list
+ */
+export function tablesFromPluginContributions(
+  contributions: readonly TableContribution[],
+): SchemaTableDecl[] {
+  const out: SchemaTableDecl[] = [];
+  for (const c of contributions) {
+    const columns = c.columns;
+    if (!columns || Object.keys(columns).length === 0) continue;
+    if (!isAbstractColumnMap(columns)) continue;
+    out.push(schemaTableFromPluginColumns(c.name, columns));
+  }
+  return out;
+}
+
+/**
+ * Merge app + plugin abstract tables. Duplicate names throw.
+ *
+ * @param appTables - App declarations
+ * @param pluginTables - Plugin contributions with columns
+ */
+export function mergeSchemaTables(
+  appTables: readonly SchemaTableDecl[],
+  pluginTables: readonly SchemaTableDecl[] = [],
+): SchemaTableDecl[] {
+  const byName = new Map<string, SchemaTableDecl>();
+  for (const t of [...appTables, ...pluginTables]) {
+    if (byName.has(t.name)) {
+      throw new Error(
+        `store schema: duplicate table "${t.name}" (plugins may add whole tables only — no column injection into app-owned tables)`,
+      );
+    }
+    byName.set(t.name, t);
+  }
+  return [...byName.values()];
+}
+
+/** Options for {@link maybeEmitDomainSchema}. */
+export interface EmitDomainSchemaOptions {
+  readonly cwd: string;
+  readonly dialect: SqlDialect;
+  /** Declaration module path (absolute or cwd-relative). */
+  readonly declarePath?: string;
+  /** Output path (absolute or cwd-relative). */
+  readonly outPath?: string;
+  /** Live plugin registry table contributions (from a plugged `oke()` app). */
+  readonly pluginTables?: readonly TableContribution[];
+  readonly write?: (text: string) => void;
+}
+
+/**
+ * When abstract decls and/or plugin `field.*` tables exist, write the generated
+ * Drizzle schema. Returns whether a file was written.
+ *
+ * @param options - Paths / dialect / plugins
+ */
+export async function maybeEmitDomainSchema(
+  options: EmitDomainSchemaOptions,
+): Promise<{ readonly emitted: boolean; readonly path?: string; readonly tableCount?: number }> {
+  const cwd = options.cwd;
+  const declareRel = options.declarePath ?? DEFAULT_DECLARE_SCHEMA_REL;
+  const declareAbs = resolve(cwd, declareRel);
+  const declareFile = Bun.file(declareAbs);
+
+  let appTables: SchemaTableDecl[] = [];
+  let appRelations: SchemaRelationsDecl[] = [];
+  if (await declareFile.exists()) {
+    let mod: Record<string, unknown>;
+    try {
+      mod = (await import(declareAbs)) as Record<string, unknown>;
+    } catch (err) {
+      options.write?.(
+        `oke db: failed to load schema declare module ${declareRel}: ${err instanceof Error ? err.message : String(err)}\n`,
+      );
+      throw err;
+    }
+    appTables = tablesFromExports(mod);
+    appRelations = relationsFromExports(mod);
+  }
+
+  const fromPlugins = tablesFromPluginContributions(options.pluginTables ?? []);
+  if (appTables.length === 0 && fromPlugins.length === 0) {
+    return { emitted: false };
+  }
+
+  const tables = mergeSchemaTables(appTables, fromPlugins);
+  const outRel = options.outPath ?? DEFAULT_GENERATED_SCHEMA_REL;
+  const outAbs = resolve(cwd, outRel);
+  const source = emitDrizzleSource(tables, options.dialect, { relations: appRelations });
+  await mkdir(dirname(outAbs), { recursive: true });
+  await writeFile(outAbs, source, "utf8");
+  options.write?.(
+    `oke db: emitted ${outRel} (${tables.length} table${tables.length === 1 ? "" : "s"}, ${options.dialect})\n`,
+  );
+  return { emitted: true, path: outAbs, tableCount: tables.length };
+}
+
+/**
+ * Resolve declare/out paths from an optional db config slice.
+ *
+ * @param cwd - Project root
+ * @param db - Config `db` block
+ */
+export function resolveEmitPaths(
+  cwd: string,
+  db?: { readonly declare?: string; readonly generated?: string },
+): { readonly declarePath: string; readonly outPath: string } {
+  return {
+    declarePath: join(cwd, db?.declare ?? DEFAULT_DECLARE_SCHEMA_REL),
+    outPath: join(cwd, db?.generated ?? DEFAULT_GENERATED_SCHEMA_REL),
+  };
+}
+
+/** Re-export for callers that only import the emitter. */
+export { isSchemaTableDecl, tablesFromExports, relationsFromExports };

package/src/elements/store/files-policy.test.ts

@@ -1,9 +1,5 @@
 import { describe, expect, test } from "bun:test";
-import {
-  contentAddressedKey,
-  fileKeyWarnings,
-  projectFileKeys,
-} from "./files-policy.ts";
+import { contentAddressedKey, fileKeyWarnings, projectFileKeys } from "./files-policy.ts";
 
 describe("files-policy", () => {
   test("flags non-ASCII keys for signed-URL risk", () => {

package/src/elements/store/files-policy.ts

@@ -28,8 +28,7 @@ export function fileKeyWarnings(key: string): readonly FileKeyWarning[] {
   if (/[^\x00-\x7F]/.test(key)) {
     warnings.push({
       code: "non_ascii_key",
-      message:
-        "Non-ASCII object key — signed URL encoding may break on S3-compatible stores.",
+      message: "Non-ASCII object key — signed URL encoding may break on S3-compatible stores.",
       key,
     });
   }
@@ -41,17 +40,10 @@ export function fileKeyWarnings(key: string): readonly FileKeyWarning[] {
  *
  * @param data - Object bytes or UTF-8 string
  */
-export async function contentAddressedKey(
-  data: Uint8Array | string,
-): Promise<string> {
-  const bytes =
-    typeof data === "string"
-      ? new TextEncoder().encode(data)
-      : new Uint8Array(data);
+export async function contentAddressedKey(data: Uint8Array | string): Promise<string> {
+  const bytes = typeof data === "string" ? new TextEncoder().encode(data) : new Uint8Array(data);
   const digest = await crypto.subtle.digest("SHA-256", bytes);
-  return [...new Uint8Array(digest)]
-    .map((b) => b.toString(16).padStart(2, "0"))
-    .join("");
+  return [...new Uint8Array(digest)].map((b) => b.toString(16).padStart(2, "0")).join("");
 }
 
 /**

package/src/elements/store/load-plugin-tables.ts

@@ -0,0 +1,103 @@
+/**
+ * Load plugin table contributions from a live `oke()` app entry.
+ *
+ * Used by `oke db` emit so `.plug()`-registered `field.*` tables merge into
+ * `schema.generated.ts` — not only at unit-test merge call sites.
+ */
+
+import { resolve } from "node:path";
+import type { TableContribution } from "../../kernel/plugin.ts";
+import type { PluginRegistry } from "../../kernel/registry.ts";
+
+/** Duck-type for an app that exposes a plugin registry. */
+export interface AppWithPlugins {
+  readonly plugins: PluginRegistry;
+}
+
+/**
+ * Whether `value` looks like an {@link AppWithPlugins}.
+ *
+ * @param value - Candidate export
+ */
+export function isAppWithPlugins(value: unknown): value is AppWithPlugins {
+  if (!value || typeof value !== "object") return false;
+  const plugins = (value as { plugins?: unknown }).plugins;
+  if (!plugins || typeof plugins !== "object") return false;
+  return typeof (plugins as PluginRegistry).tableContributions === "function";
+}
+
+/**
+ * Find an `oke()` app export on a module (`app`, `default`, or first match).
+ *
+ * @param mod - Imported module namespace
+ */
+export function findAppWithPlugins(mod: Record<string, unknown>): AppWithPlugins | undefined {
+  for (const key of ["app", "default", ...Object.keys(mod)]) {
+    const value = mod[key];
+    if (isAppWithPlugins(value)) return value;
+  }
+  return undefined;
+}
+
+/**
+ * Resolve the app entry used to collect plugged plugin tables.
+ *
+ * @param cwd - Project root
+ * @param explicit - Optional relative/absolute entry override
+ */
+export async function resolveAppEntryForPluginTables(
+  cwd: string,
+  explicit?: string,
+): Promise<string | undefined> {
+  if (explicit) return resolve(cwd, explicit);
+  const pkgPath = resolve(cwd, "package.json");
+  if (await Bun.file(pkgPath).exists()) {
+    const pkg = (await Bun.file(pkgPath).json()) as {
+      main?: string;
+      okengine?: { entry?: string };
+    };
+    if (pkg.okengine?.entry) return resolve(cwd, pkg.okengine.entry);
+    if (pkg.main) return resolve(cwd, pkg.main);
+  }
+  for (const candidate of ["src/app.ts", "src/index.ts", "index.ts", "app.ts"]) {
+    const path = resolve(cwd, candidate);
+    if (await Bun.file(path).exists()) return path;
+  }
+  return undefined;
+}
+
+/**
+ * Import the app entry and return table contributions from its live registry.
+ *
+ * Does not boot the app — `.plug()` at module load is enough for capture.
+ *
+ * @param cwd - Project root
+ * @param options - Entry override / write for diagnostics
+ */
+export async function loadPluginTablesFromAppEntry(
+  cwd: string,
+  options: {
+    readonly entry?: string;
+    readonly write?: (text: string) => void;
+  } = {},
+): Promise<readonly TableContribution[]> {
+  const entryAbs = await resolveAppEntryForPluginTables(cwd, options.entry);
+  if (!entryAbs) return [];
+  if (!(await Bun.file(entryAbs).exists())) return [];
+
+  let mod: Record<string, unknown>;
+  try {
+    mod = (await import(entryAbs)) as Record<string, unknown>;
+  } catch (err) {
+    options.write?.(
+      `oke db: failed to load app entry for plugin tables (${entryAbs}): ${
+        err instanceof Error ? err.message : String(err)
+      }\n`,
+    );
+    throw err;
+  }
+
+  const app = findAppWithPlugins(mod);
+  if (!app) return [];
+  return app.plugins.tableContributions();
+}

package/src/elements/store/missing-relation.test.ts

@@ -0,0 +1,83 @@
+/**
+ * Per-driver missing table/column signature matcher.
+ */
+
+import { describe, expect, test } from "bun:test";
+import { isMissingDomainRelationError } from "./missing-relation.ts";
+
+describe("isMissingDomainRelationError", () => {
+  test("postgres SQLSTATE 42P01 / 42703", () => {
+    expect(
+      isMissingDomainRelationError({
+        name: "PostgresError",
+        code: "42P01",
+        message: 'relation "notes" does not exist',
+      }),
+    ).toBe(true);
+    expect(
+      isMissingDomainRelationError({
+        name: "PostgresError",
+        code: "42703",
+        message: 'column "body" does not exist',
+      }),
+    ).toBe(true);
+  });
+
+  test("does not match Bun connection ERR_POSTGRES_* codes", () => {
+    expect(
+      isMissingDomainRelationError({
+        name: "PostgresError",
+        code: "ERR_POSTGRES_CONNECTION_CLOSED",
+        message: "Connection closed",
+      }),
+    ).toBe(false);
+  });
+
+  test("pglite SQLSTATE shapes", () => {
+    expect(
+      isMissingDomainRelationError({
+        name: "error",
+        code: "42P01",
+        message: 'relation "definitely_missing" does not exist',
+      }),
+    ).toBe(true);
+    expect(
+      isMissingDomainRelationError({
+        name: "error",
+        code: "42703",
+        message: 'column "nope" does not exist',
+      }),
+    ).toBe(true);
+  });
+
+  test("sqlite SQLiteError message prefixes", () => {
+    expect(
+      isMissingDomainRelationError({
+        name: "SQLiteError",
+        message: "no such table: definitely_missing",
+        errno: 1,
+      }),
+    ).toBe(true);
+    expect(
+      isMissingDomainRelationError({
+        name: "SQLiteError",
+        message: "no such column: nope",
+        errno: 1,
+      }),
+    ).toBe(true);
+  });
+
+  test("sqlite errno alone is not enough", () => {
+    expect(
+      isMissingDomainRelationError({
+        name: "SQLiteError",
+        message: "constraint failed",
+        errno: 1,
+      }),
+    ).toBe(false);
+  });
+
+  test("memory driver no such table", () => {
+    expect(isMissingDomainRelationError(new Error("no such table: notes"))).toBe(true);
+  });
+});