@nicia-ai/typegraph 0.49.0 → 0.50.0

package/dist/{chunk-JPD2CTC3.js → chunk-S33YQEL7.js}

@@ -1,8 +1,8 @@
-import { createPostgresBackend } from './chunk-7LZJNLA5.js';
-import { tables, generatePostgresMigrationSQL, generatePostgresDDL } from './chunk-6SWPJEYN.js';
-import { wrapWithManagedClose } from './chunk-UGHG7PGX.js';
-import { closeAfterFailure } from './chunk-6LN7FIVU.js';
-import { ConfigurationError } from './chunk-ZLONH2UD.js';
+import { createPostgresBackend } from './chunk-JG5XIJDY.js';
+import { tables, generatePostgresMigrationSQL, generatePostgresDDL } from './chunk-6LEOAIIB.js';
+import { wrapWithManagedClose } from './chunk-IRPYOHRC.js';
+import { closeAfterFailure } from './chunk-PALYTHGM.js';
+import { ConfigurationError } from './chunk-YDEJQWOL.js';
 import { PGlite } from '@electric-sql/pglite';
 import { drizzle } from 'drizzle-orm/pglite';
 
@@ -44,5 +44,5 @@ async function createLocalPgliteBackend(options = {}) {
 }
 
 export { createLocalPgliteBackend };
-//# sourceMappingURL=chunk-JPD2CTC3.js.map
-//# sourceMappingURL=chunk-JPD2CTC3.js.map
+//# sourceMappingURL=chunk-S33YQEL7.js.map
+//# sourceMappingURL=chunk-S33YQEL7.js.map

package/dist/{chunk-JPD2CTC3.js.map → chunk-S33YQEL7.js.map}

@@ -1 +1 @@
-{"version":3,"sources":["../src/backend/postgres/pglite.ts"],"names":["tables"],"mappings":";;;;;;;;AAqIA,eAAe,4BAAA,GAAmD;AAChE,EAAA,IAAI;AACF,IAAA,MAAM,OAAA,GAAU,MAAM,OAAO,+BAA+B,CAAA;AAC5D,IAAA,OAAO,OAAA,CAAQ,MAAA;AAAA,EACjB,SAAS,KAAA,EAAO;AACd,IAAA,MAAM,IAAI,kBAAA;AAAA,MACR,2PAAA;AAAA,MAIA,EAAE,OAAA,EAAS,QAAA,EAAU,UAAA,EAAY,+BAAA,EAAgC;AAAA,MACjE,EAAE,OAAO,KAAA;AAAM,KACjB;AAAA,EACF;AACF;AAoBA,eAAsB,wBAAA,CACpB,OAAA,GAAqC,EAAC,EACH;AACnC,EAAA,MAAMA,OAAAA,GAAS,QAAQ,MAAA,IAAU,MAAA;AAMjC,EAAA,MAAM,eAAA,GACJ,QAAQ,MAAA,KAAW,KAAA,GACjB,SACC,OAAA,CAAQ,MAAA,IAAW,MAAM,4BAAA,EAA6B;AAC3D,EAAA,MAAM,gBAAgB,eAAA,KAAoB,MAAA;AAO1C,EAAA,MAAM,MAAA,GAAS,MAAM,MAAA,CAAO,MAAA,CAAO;AAAA,IACjC,GAAI,QAAQ,OAAA,KAAY,MAAA,GAAY,EAAC,GAAI,EAAE,OAAA,EAAS,OAAA,CAAQ,OAAA,EAAQ;AAAA,IACpE,GAAI,eAAA,KAAoB,MAAA,GACtB,EAAC,GACD,EAAE,UAAA,EAAY,EAAE,MAAA,EAAQ,eAAA,EAAgB;AAAE,GAC7C,CAAA;AAED,EAAA,IAAI;AAGF,IAAA,MAAM,YAAA,GACJ,gBACE,4BAAA,CAA6BA,OAAM,IACnC,mBAAA,CAAoBA,OAAM,CAAA,CAAE,IAAA,CAAK,MAAM,CAAA;AAC3C,IAAA,MAAM,MAAA,CAAO,KAAK,YAAY,CAAA;AAE9B,IAAA,MAAM,EAAA,GAAK,QAAQ,MAAM,CAAA;AACzB,IAAA,MAAM,OAAA,GAAU,sBAAsB,EAAA,EAAI;AAAA,MACxC,MAAA,EAAAA,OAAAA;AAAA,MACA,GAAI,aAAA,GAAgB,EAAC,GAAI,EAAE,QAAQ,KAAA;AAAM,KAC1C,CAAA;AACD,IAAA,MAAM,cAAA,GAAiB,oBAAA,CAAqB,OAAA,EAAS,YAAY;AAC/D,MAAA,MAAM,OAAO,KAAA,EAAM;AAAA,IACrB,CAAC,CAAA;AAED,IAAA,OAAO,EAAE,OAAA,EAAS,cAAA,EAAgB,EAAA,EAAI,MAAA,EAAO;AAAA,EAC/C,SAAS,KAAA,EAAO;AACd,IAAA,OAAO,iBAAA,CAAkB,QAAQ,KAAK,CAAA;AAAA,EACxC;AACF","file":"chunk-JPD2CTC3.js","sourcesContent":["/**\n * Local PGlite backend — Postgres-in-WASM, running in-process.\n *\n * [PGlite](https://pglite.dev/) is a full Postgres compiled to WebAssembly\n * that runs inside the Node/Bun/Deno/browser process with no server and no\n * native addon. This is the batteries-included Postgres analog of\n * `createLocalSqliteBackend`: it constructs a PGlite instance, loads the\n * pgvector extension, runs the schema DDL, and returns a ready\n * `{ backend, db }` pair whose `close()` disposes the engine.\n *\n * `@electric-sql/pglite` is an optional peer dependency. Vector support\n * additionally needs `@electric-sql/pglite-pgvector` (PGlite ≥ 0.5 ships\n * pgvector as a separate package). Install what you need:\n *\n * ```bash\n * pnpm add @electric-sql/pglite @electric-sql/pglite-pgvector\n * ```\n *\n * @example In-memory database (default, vector enabled)\n * ```typescript\n * import { createLocalPgliteBackend } from \"@nicia-ai/typegraph/adapters/drizzle/postgres/pglite\";\n *\n * const { backend } = await createLocalPgliteBackend();\n * const store = createStore(graph, backend);\n * ```\n *\n * @example Persistent on-disk database\n * ```typescript\n * const { backend, db } = await createLocalPgliteBackend({ dataDir: \"./pgdata\" });\n * ```\n *\n * @example No vector support (skip the pgvector extension)\n * ```typescript\n * const { backend } = await createLocalPgliteBackend({ vector: false });\n * ```\n *\n * PGlite is single-connection and serial: there is no pooling, so concurrent\n * `store.transaction()` calls queue rather than run in parallel.\n */\nimport { type Extension, PGlite } from \"@electric-sql/pglite\";\nimport { drizzle, type PgliteDatabase } from \"drizzle-orm/pglite\";\n\nimport { ConfigurationError } from \"../../errors\";\nimport { wrapWithManagedClose } from \"../derive-backend\";\nexport type { GraphIdentityConfig } from \"../../core/define-graph\";\nimport {\n  generatePostgresDDL,\n  generatePostgresMigrationSQL,\n} from \"../drizzle/ddl\";\nimport { type AnyPgTransaction } from \"../drizzle/execution\";\nexport type { AnyPgDatabase, AnyPgTransaction } from \"../drizzle/execution\";\nimport {\n  createPostgresBackend,\n  type PostgresTables,\n  tables as defaultTables,\n} from \"../drizzle/postgres\";\nimport { type AdapterBackend, closeAfterFailure } from \"../types\";\nexport type {\n  ContributionDiagnostic,\n  ContributionDiagnosticState,\n  ContributionRepairEntry,\n  ContributionRepairResult,\n} from \"../types\";\n\n// ============================================================\n// Types\n// ============================================================\n\n/**\n * Options for creating a local PGlite backend.\n */\nexport type LocalPgliteBackendOptions = Readonly<{\n  /**\n   * PGlite data directory. Omit for an in-memory database (the default).\n   * Accepts any PGlite data-dir spec: a filesystem path (`\"./pgdata\"`),\n   * `\"memory://\"`, or a browser/runtime-specific scheme such as\n   * `\"idb://my-db\"`.\n   */\n  dataDir?: string;\n\n  /**\n   * Custom table definitions. Defaults to standard TypeGraph table names.\n   */\n  tables?: PostgresTables;\n\n  /**\n   * Controls the pgvector stack:\n   *\n   * - **omitted (default)** — load pgvector from `@electric-sql/pglite-pgvector`\n   *   and run `CREATE EXTENSION vector`, so embedding fields work out of the\n   *   box. Throws a {@link ConfigurationError} if the package isn't installed.\n   * - **`false`** — skip the extension entirely; the backend advertises no\n   *   vector capability (mirroring a SQLite connection without sqlite-vec).\n   *   Use when a graph carries no embeddings, or to avoid the extension dep.\n   * - **a PGlite `Extension`** — bring your own pgvector build or custom\n   *   extension packaging. Decouples this helper from a specific pgvector\n   *   package version.\n   */\n  vector?: false | Extension;\n}>;\n\n/**\n * Result of creating a local PGlite backend.\n */\nexport type LocalPgliteBackendResult = Readonly<{\n  /**\n   * The GraphBackend instance for use with createStore. Its `close()`\n   * disposes the underlying PGlite engine.\n   */\n  backend: AdapterBackend<AnyPgTransaction>;\n\n  /**\n   * The underlying Drizzle database instance. Useful for direct SQL access.\n   */\n  db: PgliteDatabase;\n\n  /**\n   * The raw PGlite instance, for engine-specific operations such as\n   * `dumpDataDir()` / `clone()` not surfaced through Drizzle.\n   */\n  client: PGlite;\n}>;\n\n// ============================================================\n// Vector extension loading\n// ============================================================\n\n/**\n * Dynamically loads the default pgvector extension from\n * `@electric-sql/pglite-pgvector`. Kept as a runtime import so the package\n * stays an optional peer dependency — callers using `vector: false` or\n * supplying their own extension never need it installed.\n */\nasync function loadDefaultPgvectorExtension(): Promise<Extension> {\n  try {\n    const module_ = await import(\"@electric-sql/pglite-pgvector\");\n    return module_.vector;\n  } catch (error) {\n    throw new ConfigurationError(\n      \"createLocalPgliteBackend needs the pgvector extension but \" +\n        \"`@electric-sql/pglite-pgvector` could not be loaded. Install it \" +\n        \"(`pnpm add @electric-sql/pglite-pgvector`), pass your own `vector` \" +\n        \"extension, or set `vector: false` to disable vector support.\",\n      { backend: \"pglite\", dependency: \"@electric-sql/pglite-pgvector\" },\n      { cause: error },\n    );\n  }\n}\n\n// ============================================================\n// Factory Function\n// ============================================================\n\n/**\n * Creates a TypeGraph backend backed by an in-process PGlite database.\n *\n * Constructs the PGlite engine (loading pgvector unless disabled), executes\n * the schema DDL, and wires the standard Postgres backend. The returned\n * backend owns the engine: call `backend.close()` to dispose it.\n *\n * For production Postgres, or a PGlite instance you construct yourself,\n * use `createPostgresBackend` directly with your own Drizzle database — the\n * execution fast path detects PGlite and routes it correctly.\n *\n * @param options - Configuration options\n * @returns Backend, Drizzle database, and raw PGlite client\n */\nexport async function createLocalPgliteBackend(\n  options: LocalPgliteBackendOptions = {},\n): Promise<LocalPgliteBackendResult> {\n  const tables = options.tables ?? defaultTables;\n\n  // pgvector lives in the WASM instance, so the extension must be passed at\n  // construction — `CREATE EXTENSION vector` alone can't pull it in. An\n  // explicitly supplied extension wins; `false` disables; otherwise load the\n  // default package.\n  const vectorExtension =\n    options.vector === false ?\n      undefined\n    : (options.vector ?? (await loadDefaultPgvectorExtension()));\n  const vectorEnabled = vectorExtension !== undefined;\n\n  // Construct via the single options-object form (passing `dataDir` as a\n  // field), not the positional `create(dataDir, options)` overload: with a\n  // leading `undefined` dataDir, that overload silently drops `extensions`\n  // (\"extension vector is not available\"). The options form loads them for\n  // both the in-memory and on-disk cases.\n  const client = await PGlite.create({\n    ...(options.dataDir === undefined ? {} : { dataDir: options.dataDir }),\n    ...(vectorExtension === undefined ?\n      {}\n    : { extensions: { vector: vectorExtension } }),\n  });\n\n  try {\n    // `exec` runs a multi-statement batch (DDL + the pgvector `CREATE\n    // EXTENSION` when enabled) in one round trip.\n    const migrationSql =\n      vectorEnabled ?\n        generatePostgresMigrationSQL(tables)\n      : generatePostgresDDL(tables).join(\"\\n\\n\");\n    await client.exec(migrationSql);\n\n    const db = drizzle(client);\n    const backend = createPostgresBackend(db, {\n      tables,\n      ...(vectorEnabled ? {} : { vector: false }),\n    });\n    const managedBackend = wrapWithManagedClose(backend, async () => {\n      await client.close();\n    });\n\n    return { backend: managedBackend, db, client };\n  } catch (error) {\n    return closeAfterFailure(client, error);\n  }\n}\n"]}
+{"version":3,"sources":["../src/backend/postgres/pglite.ts"],"names":["tables"],"mappings":";;;;;;;;AAqIA,eAAe,4BAAA,GAAmD;AAChE,EAAA,IAAI;AACF,IAAA,MAAM,OAAA,GAAU,MAAM,OAAO,+BAA+B,CAAA;AAC5D,IAAA,OAAO,OAAA,CAAQ,MAAA;AAAA,EACjB,SAAS,KAAA,EAAO;AACd,IAAA,MAAM,IAAI,kBAAA;AAAA,MACR,2PAAA;AAAA,MAIA,EAAE,OAAA,EAAS,QAAA,EAAU,UAAA,EAAY,+BAAA,EAAgC;AAAA,MACjE,EAAE,OAAO,KAAA;AAAM,KACjB;AAAA,EACF;AACF;AAoBA,eAAsB,wBAAA,CACpB,OAAA,GAAqC,EAAC,EACH;AACnC,EAAA,MAAMA,OAAAA,GAAS,QAAQ,MAAA,IAAU,MAAA;AAMjC,EAAA,MAAM,eAAA,GACJ,QAAQ,MAAA,KAAW,KAAA,GACjB,SACC,OAAA,CAAQ,MAAA,IAAW,MAAM,4BAAA,EAA6B;AAC3D,EAAA,MAAM,gBAAgB,eAAA,KAAoB,MAAA;AAO1C,EAAA,MAAM,MAAA,GAAS,MAAM,MAAA,CAAO,MAAA,CAAO;AAAA,IACjC,GAAI,QAAQ,OAAA,KAAY,MAAA,GAAY,EAAC,GAAI,EAAE,OAAA,EAAS,OAAA,CAAQ,OAAA,EAAQ;AAAA,IACpE,GAAI,eAAA,KAAoB,MAAA,GACtB,EAAC,GACD,EAAE,UAAA,EAAY,EAAE,MAAA,EAAQ,eAAA,EAAgB;AAAE,GAC7C,CAAA;AAED,EAAA,IAAI;AAGF,IAAA,MAAM,YAAA,GACJ,gBACE,4BAAA,CAA6BA,OAAM,IACnC,mBAAA,CAAoBA,OAAM,CAAA,CAAE,IAAA,CAAK,MAAM,CAAA;AAC3C,IAAA,MAAM,MAAA,CAAO,KAAK,YAAY,CAAA;AAE9B,IAAA,MAAM,EAAA,GAAK,QAAQ,MAAM,CAAA;AACzB,IAAA,MAAM,OAAA,GAAU,sBAAsB,EAAA,EAAI;AAAA,MACxC,MAAA,EAAAA,OAAAA;AAAA,MACA,GAAI,aAAA,GAAgB,EAAC,GAAI,EAAE,QAAQ,KAAA;AAAM,KAC1C,CAAA;AACD,IAAA,MAAM,cAAA,GAAiB,oBAAA,CAAqB,OAAA,EAAS,YAAY;AAC/D,MAAA,MAAM,OAAO,KAAA,EAAM;AAAA,IACrB,CAAC,CAAA;AAED,IAAA,OAAO,EAAE,OAAA,EAAS,cAAA,EAAgB,EAAA,EAAI,MAAA,EAAO;AAAA,EAC/C,SAAS,KAAA,EAAO;AACd,IAAA,OAAO,iBAAA,CAAkB,QAAQ,KAAK,CAAA;AAAA,EACxC;AACF","file":"chunk-S33YQEL7.js","sourcesContent":["/**\n * Local PGlite backend — Postgres-in-WASM, running in-process.\n *\n * [PGlite](https://pglite.dev/) is a full Postgres compiled to WebAssembly\n * that runs inside the Node/Bun/Deno/browser process with no server and no\n * native addon. This is the batteries-included Postgres analog of\n * `createLocalSqliteBackend`: it constructs a PGlite instance, loads the\n * pgvector extension, runs the schema DDL, and returns a ready\n * `{ backend, db }` pair whose `close()` disposes the engine.\n *\n * `@electric-sql/pglite` is an optional peer dependency. Vector support\n * additionally needs `@electric-sql/pglite-pgvector` (PGlite ≥ 0.5 ships\n * pgvector as a separate package). Install what you need:\n *\n * ```bash\n * pnpm add @electric-sql/pglite @electric-sql/pglite-pgvector\n * ```\n *\n * @example In-memory database (default, vector enabled)\n * ```typescript\n * import { createLocalPgliteBackend } from \"@nicia-ai/typegraph/adapters/drizzle/postgres/pglite\";\n *\n * const { backend } = await createLocalPgliteBackend();\n * const store = createStore(graph, backend);\n * ```\n *\n * @example Persistent on-disk database\n * ```typescript\n * const { backend, db } = await createLocalPgliteBackend({ dataDir: \"./pgdata\" });\n * ```\n *\n * @example No vector support (skip the pgvector extension)\n * ```typescript\n * const { backend } = await createLocalPgliteBackend({ vector: false });\n * ```\n *\n * PGlite is single-connection and serial: there is no pooling, so concurrent\n * `store.transaction()` calls queue rather than run in parallel.\n */\nimport { type Extension, PGlite } from \"@electric-sql/pglite\";\nimport { drizzle, type PgliteDatabase } from \"drizzle-orm/pglite\";\n\nimport { ConfigurationError } from \"../../errors\";\nimport { wrapWithManagedClose } from \"../derive-backend\";\nexport type { GraphIdentityConfig } from \"../../core/define-graph\";\nimport {\n  generatePostgresDDL,\n  generatePostgresMigrationSQL,\n} from \"../drizzle/ddl\";\nimport { type AnyPgTransaction } from \"../drizzle/execution\";\nexport type { AnyPgDatabase, AnyPgTransaction } from \"../drizzle/execution\";\nimport {\n  createPostgresBackend,\n  type PostgresTables,\n  tables as defaultTables,\n} from \"../drizzle/postgres\";\nimport { type AdapterBackend, closeAfterFailure } from \"../types\";\nexport type {\n  ContributionDiagnostic,\n  ContributionDiagnosticState,\n  ContributionRepairEntry,\n  ContributionRepairResult,\n} from \"../types\";\n\n// ============================================================\n// Types\n// ============================================================\n\n/**\n * Options for creating a local PGlite backend.\n */\nexport type LocalPgliteBackendOptions = Readonly<{\n  /**\n   * PGlite data directory. Omit for an in-memory database (the default).\n   * Accepts any PGlite data-dir spec: a filesystem path (`\"./pgdata\"`),\n   * `\"memory://\"`, or a browser/runtime-specific scheme such as\n   * `\"idb://my-db\"`.\n   */\n  dataDir?: string;\n\n  /**\n   * Custom table definitions. Defaults to standard TypeGraph table names.\n   */\n  tables?: PostgresTables;\n\n  /**\n   * Controls the pgvector stack:\n   *\n   * - **omitted (default)** — load pgvector from `@electric-sql/pglite-pgvector`\n   *   and run `CREATE EXTENSION vector`, so embedding fields work out of the\n   *   box. Throws a {@link ConfigurationError} if the package isn't installed.\n   * - **`false`** — skip the extension entirely; the backend advertises no\n   *   vector capability (mirroring a SQLite connection without sqlite-vec).\n   *   Use when a graph carries no embeddings, or to avoid the extension dep.\n   * - **a PGlite `Extension`** — bring your own pgvector build or custom\n   *   extension packaging. Decouples this helper from a specific pgvector\n   *   package version.\n   */\n  vector?: false | Extension;\n}>;\n\n/**\n * Result of creating a local PGlite backend.\n */\nexport type LocalPgliteBackendResult = Readonly<{\n  /**\n   * The GraphBackend instance for use with createStore. Its `close()`\n   * disposes the underlying PGlite engine.\n   */\n  backend: AdapterBackend<AnyPgTransaction>;\n\n  /**\n   * The underlying Drizzle database instance. Useful for direct SQL access.\n   */\n  db: PgliteDatabase;\n\n  /**\n   * The raw PGlite instance, for engine-specific operations such as\n   * `dumpDataDir()` / `clone()` not surfaced through Drizzle.\n   */\n  client: PGlite;\n}>;\n\n// ============================================================\n// Vector extension loading\n// ============================================================\n\n/**\n * Dynamically loads the default pgvector extension from\n * `@electric-sql/pglite-pgvector`. Kept as a runtime import so the package\n * stays an optional peer dependency — callers using `vector: false` or\n * supplying their own extension never need it installed.\n */\nasync function loadDefaultPgvectorExtension(): Promise<Extension> {\n  try {\n    const module_ = await import(\"@electric-sql/pglite-pgvector\");\n    return module_.vector;\n  } catch (error) {\n    throw new ConfigurationError(\n      \"createLocalPgliteBackend needs the pgvector extension but \" +\n        \"`@electric-sql/pglite-pgvector` could not be loaded. Install it \" +\n        \"(`pnpm add @electric-sql/pglite-pgvector`), pass your own `vector` \" +\n        \"extension, or set `vector: false` to disable vector support.\",\n      { backend: \"pglite\", dependency: \"@electric-sql/pglite-pgvector\" },\n      { cause: error },\n    );\n  }\n}\n\n// ============================================================\n// Factory Function\n// ============================================================\n\n/**\n * Creates a TypeGraph backend backed by an in-process PGlite database.\n *\n * Constructs the PGlite engine (loading pgvector unless disabled), executes\n * the schema DDL, and wires the standard Postgres backend. The returned\n * backend owns the engine: call `backend.close()` to dispose it.\n *\n * For production Postgres, or a PGlite instance you construct yourself,\n * use `createPostgresBackend` directly with your own Drizzle database — the\n * execution fast path detects PGlite and routes it correctly.\n *\n * @param options - Configuration options\n * @returns Backend, Drizzle database, and raw PGlite client\n */\nexport async function createLocalPgliteBackend(\n  options: LocalPgliteBackendOptions = {},\n): Promise<LocalPgliteBackendResult> {\n  const tables = options.tables ?? defaultTables;\n\n  // pgvector lives in the WASM instance, so the extension must be passed at\n  // construction — `CREATE EXTENSION vector` alone can't pull it in. An\n  // explicitly supplied extension wins; `false` disables; otherwise load the\n  // default package.\n  const vectorExtension =\n    options.vector === false ?\n      undefined\n    : (options.vector ?? (await loadDefaultPgvectorExtension()));\n  const vectorEnabled = vectorExtension !== undefined;\n\n  // Construct via the single options-object form (passing `dataDir` as a\n  // field), not the positional `create(dataDir, options)` overload: with a\n  // leading `undefined` dataDir, that overload silently drops `extensions`\n  // (\"extension vector is not available\"). The options form loads them for\n  // both the in-memory and on-disk cases.\n  const client = await PGlite.create({\n    ...(options.dataDir === undefined ? {} : { dataDir: options.dataDir }),\n    ...(vectorExtension === undefined ?\n      {}\n    : { extensions: { vector: vectorExtension } }),\n  });\n\n  try {\n    // `exec` runs a multi-statement batch (DDL + the pgvector `CREATE\n    // EXTENSION` when enabled) in one round trip.\n    const migrationSql =\n      vectorEnabled ?\n        generatePostgresMigrationSQL(tables)\n      : generatePostgresDDL(tables).join(\"\\n\\n\");\n    await client.exec(migrationSql);\n\n    const db = drizzle(client);\n    const backend = createPostgresBackend(db, {\n      tables,\n      ...(vectorEnabled ? {} : { vector: false }),\n    });\n    const managedBackend = wrapWithManagedClose(backend, async () => {\n      await client.close();\n    });\n\n    return { backend: managedBackend, db, client };\n  } catch (error) {\n    return closeAfterFailure(client, error);\n  }\n}\n"]}

package/dist/chunk-S3SDEQMC.js

@@ -0,0 +1,532 @@
+import { edgeCardinalityClaimTarget, EDGE_CARDINALITY_SPECS, edgeCardinalityAxesForKind } from './chunk-YA36ABIL.js';
+import { rowPropsToJsonText } from './chunk-PALYTHGM.js';
+import { claimOwnerMatchesSql } from './chunk-5LKOVCPP.js';
+import { canonicalizeDatabaseTimestamp } from './chunk-K46SDNQD.js';
+import { sql as sql$1 } from './chunk-46UGOVRW.js';
+import { DatabaseOperationError } from './chunk-YDEJQWOL.js';
+import { getTableName, sql } from 'drizzle-orm';
+
+// src/backend/row-mappers.ts
+function asString(value, field) {
+  if (typeof value !== "string") {
+    throw new DatabaseOperationError(
+      `Expected ${field} to be string, got ${typeof value}`,
+      { operation: "select", entity: "row" }
+    );
+  }
+  return value;
+}
+function asNumber(value, field) {
+  if (typeof value !== "number") {
+    throw new DatabaseOperationError(
+      `Expected ${field} to be number, got ${typeof value}`,
+      { operation: "select", entity: "row" }
+    );
+  }
+  return value;
+}
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function formatPostgresTimestamp(value) {
+  if (value === null || value === void 0) return void 0;
+  if (value instanceof Date) return value.toISOString();
+  if (typeof value === "string") {
+    if (value.includes("T")) return value;
+    const date = new Date(value);
+    if (!Number.isNaN(date.getTime())) return date.toISOString();
+    return value;
+  }
+  return void 0;
+}
+function normalizeRowTimestamp(value, field) {
+  if (value === null || value === void 0) return void 0;
+  const canonical = canonicalizeDatabaseTimestamp(value);
+  if (canonical === void 0) {
+    throw new DatabaseOperationError(
+      `Expected ${field} to be a database timestamp, got ${typeof value}`,
+      { operation: "select", entity: "row" }
+    );
+  }
+  return canonical;
+}
+function normalizeRequiredRowTimestamp(value, field) {
+  const timestamp = normalizeRowTimestamp(value, field);
+  if (timestamp === void 0) {
+    throw new DatabaseOperationError(`Expected non-null ${field} timestamp`, {
+      operation: "select",
+      entity: "row"
+    });
+  }
+  return timestamp;
+}
+function coerceNumericScore(value) {
+  if (typeof value === "number") return value;
+  const parsed = Number.parseFloat(value);
+  if (Number.isNaN(parsed)) {
+    throw new TypeError(
+      `Backend returned non-numeric fulltext score: ${JSON.stringify(value)}`
+    );
+  }
+  return parsed;
+}
+function normalizeJsonColumn(value) {
+  if (typeof value === "string") return value;
+  if (value !== null && typeof value === "object") {
+    return value;
+  }
+  return JSON.stringify(value ?? {});
+}
+var SQLITE_ROW_MAPPER_CONFIG = {
+  normalizeJson: (value) => {
+    if (typeof value !== "string") {
+      throw new DatabaseOperationError(
+        `Expected JSON column to be string, got ${typeof value}`,
+        { operation: "select", entity: "row" }
+      );
+    }
+    return value;
+  }
+};
+var POSTGRES_ROW_MAPPER_CONFIG = {
+  normalizeJson: normalizeJsonColumn
+};
+function createNodeRowMapper(config) {
+  return (row) => ({
+    graph_id: asString(row["graph_id"], "graph_id"),
+    kind: asString(row["kind"], "kind"),
+    id: asString(row["id"], "id"),
+    props: config.normalizeJson(row["props"]),
+    version: asNumber(row["version"], "version"),
+    valid_from: normalizeRowTimestamp(row["valid_from"], "valid_from"),
+    valid_to: normalizeRowTimestamp(row["valid_to"], "valid_to"),
+    created_at: normalizeRequiredRowTimestamp(row["created_at"], "created_at"),
+    updated_at: normalizeRequiredRowTimestamp(row["updated_at"], "updated_at"),
+    deleted_at: normalizeRowTimestamp(row["deleted_at"], "deleted_at")
+  });
+}
+function createEdgeRowMapper(config) {
+  return (row) => ({
+    graph_id: asString(row["graph_id"], "graph_id"),
+    id: asString(row["id"], "id"),
+    kind: asString(row["kind"], "kind"),
+    from_kind: asString(row["from_kind"], "from_kind"),
+    from_id: asString(row["from_id"], "from_id"),
+    to_kind: asString(row["to_kind"], "to_kind"),
+    to_id: asString(row["to_id"], "to_id"),
+    props: config.normalizeJson(row["props"]),
+    valid_from: normalizeRowTimestamp(row["valid_from"], "valid_from"),
+    valid_to: normalizeRowTimestamp(row["valid_to"], "valid_to"),
+    created_at: normalizeRequiredRowTimestamp(row["created_at"], "created_at"),
+    updated_at: normalizeRequiredRowTimestamp(row["updated_at"], "updated_at"),
+    deleted_at: normalizeRowTimestamp(row["deleted_at"], "deleted_at")
+  });
+}
+function mapUniqueRow(row) {
+  return {
+    graph_id: asString(row["graph_id"], "graph_id"),
+    node_kind: asString(row["node_kind"], "node_kind"),
+    constraint_name: asString(row["constraint_name"], "constraint_name"),
+    key: asString(row["key"], "key"),
+    node_id: asString(row["node_id"], "node_id"),
+    concrete_kind: asString(row["concrete_kind"], "concrete_kind"),
+    deleted_at: normalizeRowTimestamp(row["deleted_at"], "deleted_at")
+  };
+}
+function createUniqueRowMapper(_config) {
+  return mapUniqueRow;
+}
+function createSchemaVersionRowMapper(config) {
+  return (row) => {
+    const isActiveValue = row["is_active"];
+    const isActive = isActiveValue === true || isActiveValue === 1 || isActiveValue === "1";
+    return {
+      graph_id: asString(row["graph_id"], "graph_id"),
+      version: asNumber(row["version"], "version"),
+      schema_hash: asString(row["schema_hash"], "schema_hash"),
+      schema_doc: rowPropsToJsonText(config.normalizeJson(row["schema_doc"])),
+      created_at: normalizeRequiredRowTimestamp(
+        row["created_at"],
+        "created_at"
+      ),
+      is_active: isActive
+    };
+  };
+}
+function primaryKeyConstraintNames(relation, keyColumns) {
+  return [`${relation}_pkey`, `${relation}_${keyColumns.join("_")}_pk`];
+}
+function nodePrimaryKeyConstraint(nodes) {
+  const relation = getTableName(nodes);
+  return {
+    table: relation,
+    constraintNames: primaryKeyConstraintNames(relation, [
+      nodes.graphId.name,
+      nodes.kind.name,
+      nodes.id.name
+    ])
+  };
+}
+function edgePrimaryKeyConstraint(edges) {
+  const relation = getTableName(edges);
+  return {
+    table: relation,
+    constraintNames: primaryKeyConstraintNames(relation, [
+      edges.graphId.name,
+      edges.id.name
+    ])
+  };
+}
+function sqlNull(value) {
+  return value ?? sql.raw("NULL");
+}
+function expectedValidFromPredicate(column, expected) {
+  if (expected === void 0) return sql.empty();
+  if (expected === null) return sql` AND ${column} IS NULL`;
+  return sql` AND ${column} = ${expected}`;
+}
+function quotedColumn(column) {
+  return sql.raw(`"${column.name.replaceAll('"', '""')}"`);
+}
+function quotedTableName(tableName) {
+  return sql.raw(`"${tableName.replaceAll('"', '""')}"`);
+}
+var CODE_POINT_ORDER_BUILDERS = {
+  postgres: (value) => sql`${value} COLLATE "C"`,
+  sqlite: (value) => value
+};
+function codePointOrderKey(column, dialect) {
+  return CODE_POINT_ORDER_BUILDERS[dialect](column);
+}
+function liveNodeIdsSubquery(nodes, graphId, nodeKind, nowIso2) {
+  return sql`SELECT ${nodes.id} AS node_id FROM ${nodes} WHERE ${nodes.graphId} = ${graphId} AND ${nodes.kind} = ${nodeKind} AND ${nodes.deletedAt} IS NULL AND (${nodes.validFrom} IS NULL OR ${nodes.validFrom} <= ${nowIso2}) AND (${nodes.validTo} IS NULL OR ${nodes.validTo} > ${nowIso2})`;
+}
+function nodeColumnList(nodes) {
+  return sql.raw(
+    `"${nodes.graphId.name}", "${nodes.kind.name}", "${nodes.id.name}", "${nodes.props.name}", "${nodes.version.name}", "${nodes.validFrom.name}", "${nodes.validTo.name}", "${nodes.createdAt.name}", "${nodes.updatedAt.name}"`
+  );
+}
+function edgeColumnList(edges) {
+  return sql.raw(
+    `"${edges.graphId.name}", "${edges.id.name}", "${edges.kind.name}", "${edges.fromKind.name}", "${edges.fromId.name}", "${edges.toKind.name}", "${edges.toId.name}", "${edges.props.name}", "${edges.validFrom.name}", "${edges.validTo.name}", "${edges.createdAt.name}", "${edges.updatedAt.name}"`
+  );
+}
+function qualified(tableName, column) {
+  return sql.raw(`"${tableName}"."${column.name}"`);
+}
+function buildLockEdgeClaims(tables, entries, timestamp) {
+  const { edgeClaims } = tables;
+  const claimsName = getTableName(edgeClaims);
+  const columns = sql.raw(
+    `"${edgeClaims.graphId.name}", "${edgeClaims.axis.name}", "${edgeClaims.key.name}", "${edgeClaims.edgeId.name}", "${edgeClaims.updatedAt.name}"`
+  );
+  const conflictColumns = sql.raw(
+    `"${edgeClaims.graphId.name}", "${edgeClaims.axis.name}", "${edgeClaims.key.name}"`
+  );
+  const valueRows = sql.join(
+    entries.map((entry) => {
+      const target = edgeCardinalityClaimTarget(entry);
+      return sql`(${entry.graphId}, ${target.axis}, ${target.key}, ${entry.edgeId}, ${timestamp})`;
+    }),
+    sql`, `
+  );
+  return sql`
+    INSERT INTO ${edgeClaims} (${columns})
+    VALUES ${valueRows}
+    ON CONFLICT (${conflictColumns})
+    DO UPDATE SET ${quotedColumn(edgeClaims.updatedAt)} = ${qualified(claimsName, edgeClaims.updatedAt)}
+    RETURNING
+      ${quotedColumn(edgeClaims.axis)} as axis,
+      ${quotedColumn(edgeClaims.key)} as key,
+      ${quotedColumn(edgeClaims.edgeId)} as holder_edge_id
+  `;
+}
+function buildTakeOverEdgeClaim(tables, params, timestamp) {
+  const { edgeClaims, edges } = tables;
+  const claimsName = getTableName(edgeClaims);
+  const edgesName = getTableName(edges);
+  const spec = EDGE_CARDINALITY_SPECS[params.cardinality];
+  const target = edgeCardinalityClaimTarget(params);
+  const toEndpointTerms = spec.keyShape === "fromAndTo" ? sql` AND ${qualified(edgesName, edges.toKind)} = ${params.toKind} AND ${qualified(edgesName, edges.toId)} = ${params.toId}` : sql``;
+  const activeTerm = spec.holderLiveness === "liveAndActive" ? sql` AND ${qualified(edgesName, edges.validTo)} IS NULL` : sql``;
+  return sql`
+    UPDATE ${edgeClaims}
+    SET ${quotedColumn(edgeClaims.edgeId)} = ${params.edgeId},
+        ${quotedColumn(edgeClaims.updatedAt)} = ${timestamp}
+    WHERE ${qualified(claimsName, edgeClaims.graphId)} = ${params.graphId}
+      AND ${qualified(claimsName, edgeClaims.axis)} = ${target.axis}
+      AND ${qualified(claimsName, edgeClaims.key)} = ${target.key}
+      AND ${qualified(claimsName, edgeClaims.edgeId)} <> ${params.edgeId}
+      AND NOT EXISTS (
+        SELECT 1 FROM ${edges}
+        WHERE ${qualified(edgesName, edges.graphId)} = ${qualified(claimsName, edgeClaims.graphId)}
+          AND ${qualified(edgesName, edges.id)} = ${qualified(claimsName, edgeClaims.edgeId)}
+          AND ${qualified(edgesName, edges.deletedAt)} IS NULL
+          AND ${qualified(edgesName, edges.kind)} = ${params.edgeKind}
+          AND ${qualified(edgesName, edges.fromKind)} = ${params.fromKind}
+          AND ${qualified(edgesName, edges.fromId)} = ${params.fromId}${toEndpointTerms}${activeTerm}
+      )
+    RETURNING ${quotedColumn(edgeClaims.edgeId)} as holder_edge_id
+  `;
+}
+function buildPurgeEdgeClaims(tables, params) {
+  const { edgeClaims } = tables;
+  return sql`
+    DELETE FROM ${edgeClaims}
+    WHERE ${edgeClaims.graphId} = ${params.graphId}
+      AND ${edgeClaims.edgeId} IN (${sql.join(
+    params.edgeIds.map((edgeId) => sql`${edgeId}`),
+    sql`, `
+  )})
+  `;
+}
+function buildHardDeleteEdgeClaimsByEdgeKind(edgeClaimsTableName, params) {
+  const axes = edgeCardinalityAxesForKind(params.edgeKind).map(
+    (axis) => sql$1`${axis}`
+  );
+  return sql$1`DELETE FROM ${sql$1.identifier(edgeClaimsTableName)} WHERE ${sql$1.identifier("graph_id")} = ${params.graphId} AND ${sql$1.identifier("axis")} IN (${sql$1.join(axes, sql$1`, `)})`;
+}
+function buildHardDeleteEdgeClaimsByNodeKind(edgeClaimsTableName, edgesTableName, params) {
+  return sql$1`DELETE FROM ${sql$1.identifier(edgeClaimsTableName)} WHERE ${sql$1.identifier("graph_id")} = ${params.graphId} AND ${sql$1.identifier("edge_id")} IN (SELECT ${sql$1.identifier("id")} FROM ${sql$1.identifier(edgesTableName)} WHERE ${sql$1.identifier("graph_id")} = ${params.graphId} AND (${sql$1.identifier("from_kind")} = ${params.nodeKind} OR ${sql$1.identifier("to_kind")} = ${params.nodeKind}))`;
+}
+function boundOwnerColumn(uniques, params) {
+  return (column) => column.name === uniques.nodeId.name ? sql`${params.nodeId}` : sql`${params.concreteKind}`;
+}
+function buildInsertUniqueSqlite(tables, params) {
+  const { uniques } = tables;
+  const columns = sql.raw(
+    `"${uniques.graphId.name}", "${uniques.nodeKind.name}", "${uniques.constraintName.name}", "${uniques.key.name}", "${uniques.nodeId.name}", "${uniques.concreteKind.name}", "${uniques.deletedAt.name}"`
+  );
+  const conflictColumns = sql.raw(
+    `"${uniques.graphId.name}", "${uniques.nodeKind.name}", "${uniques.constraintName.name}", "${uniques.key.name}"`
+  );
+  const ownerMatches = claimOwnerMatchesSql(
+    (column) => quotedColumn(column),
+    boundOwnerColumn(uniques, params),
+    uniques
+  );
+  return sql`
+    INSERT INTO ${uniques} (${columns})
+    VALUES (
+      ${params.graphId}, ${params.nodeKind}, ${params.constraintName},
+      ${params.key}, ${params.nodeId}, ${params.concreteKind}, ${sql.raw("NULL")}
+    )
+    ON CONFLICT (${conflictColumns})
+    DO UPDATE SET
+      ${quotedColumn(uniques.nodeId)} = CASE
+        WHEN ${ownerMatches} THEN ${params.nodeId}
+        WHEN ${quotedColumn(uniques.deletedAt)} IS NOT NULL THEN ${params.nodeId}
+        ELSE ${quotedColumn(uniques.nodeId)}
+      END,
+      ${quotedColumn(uniques.concreteKind)} = CASE
+        WHEN ${ownerMatches} THEN ${params.concreteKind}
+        WHEN ${quotedColumn(uniques.deletedAt)} IS NOT NULL THEN ${params.concreteKind}
+        ELSE ${quotedColumn(uniques.concreteKind)}
+      END,
+      ${quotedColumn(uniques.deletedAt)} = CASE
+        WHEN ${ownerMatches} THEN NULL
+        WHEN ${quotedColumn(uniques.deletedAt)} IS NOT NULL THEN NULL
+        ELSE ${quotedColumn(uniques.deletedAt)}
+      END
+    RETURNING
+      ${quotedColumn(uniques.nodeId)} as node_id,
+      ${quotedColumn(uniques.concreteKind)} as concrete_kind
+  `;
+}
+function buildInsertUniquePostgres(tables, params) {
+  const { uniques } = tables;
+  const columns = sql.raw(
+    `"${uniques.graphId.name}", "${uniques.nodeKind.name}", "${uniques.constraintName.name}", "${uniques.key.name}", "${uniques.nodeId.name}", "${uniques.concreteKind.name}", "${uniques.deletedAt.name}"`
+  );
+  const conflictColumns = sql.raw(
+    `"${uniques.graphId.name}", "${uniques.nodeKind.name}", "${uniques.constraintName.name}", "${uniques.key.name}"`
+  );
+  const tableName = getTableName(uniques);
+  const existingColumn = (column) => sql.raw(`"${tableName}"."${column.name}"`);
+  const ownerMatches = claimOwnerMatchesSql(
+    (column) => existingColumn(column),
+    boundOwnerColumn(uniques, params),
+    uniques
+  );
+  return sql`
+    INSERT INTO ${uniques} (${columns})
+    VALUES (
+      ${params.graphId}, ${params.nodeKind}, ${params.constraintName},
+      ${params.key}, ${params.nodeId}, ${params.concreteKind}, ${sql.raw("NULL")}
+    )
+    ON CONFLICT (${conflictColumns})
+    DO UPDATE SET
+      ${quotedColumn(uniques.nodeId)} = CASE
+        WHEN ${ownerMatches} THEN ${params.nodeId}
+        WHEN ${existingColumn(uniques.deletedAt)} IS NOT NULL THEN ${params.nodeId}
+        ELSE ${existingColumn(uniques.nodeId)}
+      END,
+      ${quotedColumn(uniques.concreteKind)} = CASE
+        WHEN ${ownerMatches} THEN ${params.concreteKind}
+        WHEN ${existingColumn(uniques.deletedAt)} IS NOT NULL THEN ${params.concreteKind}
+        ELSE ${existingColumn(uniques.concreteKind)}
+      END,
+      ${quotedColumn(uniques.deletedAt)} = CASE
+        WHEN ${ownerMatches} THEN NULL
+        WHEN ${existingColumn(uniques.deletedAt)} IS NOT NULL THEN NULL
+        ELSE ${existingColumn(uniques.deletedAt)}
+      END
+    RETURNING
+      ${quotedColumn(uniques.nodeId)} as node_id,
+      ${quotedColumn(uniques.concreteKind)} as concrete_kind
+  `;
+}
+var UNIQUE_INSERT_BUILDERS = {
+  postgres: buildInsertUniquePostgres,
+  sqlite: buildInsertUniqueSqlite
+};
+function buildInsertUnique(tables, dialect, params) {
+  const builder = UNIQUE_INSERT_BUILDERS[dialect];
+  return builder(tables, params);
+}
+function buildInsertUniqueBatch(tables, dialect, entries) {
+  const { uniques } = tables;
+  const columns = sql.raw(
+    `"${uniques.graphId.name}", "${uniques.nodeKind.name}", "${uniques.constraintName.name}", "${uniques.key.name}", "${uniques.nodeId.name}", "${uniques.concreteKind.name}", "${uniques.deletedAt.name}"`
+  );
+  const conflictColumns = sql.raw(
+    `"${uniques.graphId.name}", "${uniques.nodeKind.name}", "${uniques.constraintName.name}", "${uniques.key.name}"`
+  );
+  const tableName = getTableName(uniques);
+  const existingColumn = (column) => {
+    switch (dialect) {
+      case "postgres": {
+        return sql.raw(`"${tableName}"."${column.name}"`);
+      }
+      case "sqlite": {
+        return sql.raw(`"${column.name}"`);
+      }
+      default: {
+        return dialect;
+      }
+    }
+  };
+  const excludedColumn = (column) => sql.raw(`excluded."${column.name}"`);
+  const ownerMatches = claimOwnerMatchesSql(
+    (column) => existingColumn(column),
+    (column) => excludedColumn(column),
+    uniques
+  );
+  const valueRows = sql.join(
+    entries.map(
+      (params) => sql`(${params.graphId}, ${params.nodeKind}, ${params.constraintName}, ${params.key}, ${params.nodeId}, ${params.concreteKind}, ${sql.raw("NULL")})`
+    ),
+    sql`, `
+  );
+  return sql`
+    INSERT INTO ${uniques} (${columns})
+    VALUES ${valueRows}
+    ON CONFLICT (${conflictColumns})
+    DO UPDATE SET
+      ${quotedColumn(uniques.nodeId)} = CASE
+        WHEN ${ownerMatches} THEN ${excludedColumn(uniques.nodeId)}
+        WHEN ${existingColumn(uniques.deletedAt)} IS NOT NULL THEN ${excludedColumn(uniques.nodeId)}
+        ELSE ${existingColumn(uniques.nodeId)}
+      END,
+      ${quotedColumn(uniques.concreteKind)} = CASE
+        WHEN ${ownerMatches} THEN ${excludedColumn(uniques.concreteKind)}
+        WHEN ${existingColumn(uniques.deletedAt)} IS NOT NULL THEN ${excludedColumn(uniques.concreteKind)}
+        ELSE ${existingColumn(uniques.concreteKind)}
+      END,
+      ${quotedColumn(uniques.deletedAt)} = CASE
+        WHEN ${ownerMatches} THEN NULL
+        WHEN ${existingColumn(uniques.deletedAt)} IS NOT NULL THEN NULL
+        ELSE ${existingColumn(uniques.deletedAt)}
+      END
+    RETURNING
+      ${quotedColumn(uniques.nodeKind)} as node_kind,
+      ${quotedColumn(uniques.constraintName)} as constraint_name,
+      ${quotedColumn(uniques.key)} as key,
+      ${quotedColumn(uniques.nodeId)} as node_id,
+      ${quotedColumn(uniques.concreteKind)} as concrete_kind
+  `;
+}
+function buildDeleteUnique(tables, params, timestamp) {
+  const { uniques } = tables;
+  const axisTerm = params.nodeKind === void 0 ? sql`` : sql` AND ${uniques.nodeKind} = ${params.nodeKind}`;
+  return sql`
+    UPDATE ${uniques}
+    SET ${quotedColumn(uniques.deletedAt)} = ${timestamp}
+    WHERE ${uniques.graphId} = ${params.graphId}
+      AND ${uniques.concreteKind} = ${params.concreteKind}
+      AND ${uniques.nodeId} = ${params.nodeId}
+      AND ${uniques.constraintName} = ${params.constraintName}
+      AND ${uniques.key} = ${params.key}${axisTerm}
+      AND ${uniques.deletedAt} IS NULL
+  `;
+}
+function buildHardDeleteUniquesByNode(tables, graphId, concreteKind, nodeId) {
+  return buildHardDeleteUniquesByNodeIds(tables, {
+    graphId,
+    concreteKind,
+    nodeIds: [nodeId]
+  });
+}
+function buildHardDeleteUniquesByNodeIds(tables, params) {
+  const { uniques } = tables;
+  return sql`
+    DELETE FROM ${uniques}
+    WHERE ${uniques.graphId} = ${params.graphId}
+      AND ${uniques.concreteKind} = ${params.concreteKind}
+      AND ${uniques.nodeId} IN (${sql.join(
+    params.nodeIds.map((nodeId) => sql`${nodeId}`),
+    sql`, `
+  )})
+  `;
+}
+function buildHardDeleteUniquesByConcreteKind(uniquesTableName, params) {
+  return sql$1`DELETE FROM ${sql$1.identifier(uniquesTableName)} WHERE ${sql$1.identifier("graph_id")} = ${params.graphId} AND ${sql$1.identifier("concrete_kind")} = ${params.concreteKind}`;
+}
+function buildCheckUnique(tables, params) {
+  const { uniques } = tables;
+  if (params.includeDeleted) {
+    return sql`
+      SELECT * FROM ${uniques}
+      WHERE ${uniques.graphId} = ${params.graphId}
+        AND ${uniques.nodeKind} = ${params.nodeKind}
+        AND ${uniques.constraintName} = ${params.constraintName}
+        AND ${uniques.key} = ${params.key}
+    `;
+  }
+  return sql`
+    SELECT * FROM ${uniques}
+    WHERE ${uniques.graphId} = ${params.graphId}
+      AND ${uniques.nodeKind} = ${params.nodeKind}
+      AND ${uniques.constraintName} = ${params.constraintName}
+      AND ${uniques.key} = ${params.key}
+      AND ${uniques.deletedAt} IS NULL
+  `;
+}
+function buildCheckUniqueBatch(tables, params) {
+  const { uniques } = tables;
+  const keyPlaceholders = sql.join(
+    params.keys.map((key) => sql`${key}`),
+    sql`, `
+  );
+  if (params.includeDeleted) {
+    return sql`
+      SELECT * FROM ${uniques}
+      WHERE ${uniques.graphId} = ${params.graphId}
+        AND ${uniques.nodeKind} = ${params.nodeKind}
+        AND ${uniques.constraintName} = ${params.constraintName}
+        AND ${uniques.key} IN (${keyPlaceholders})
+    `;
+  }
+  return sql`
+    SELECT * FROM ${uniques}
+    WHERE ${uniques.graphId} = ${params.graphId}
+      AND ${uniques.nodeKind} = ${params.nodeKind}
+      AND ${uniques.constraintName} = ${params.constraintName}
+      AND ${uniques.key} IN (${keyPlaceholders})
+      AND ${uniques.deletedAt} IS NULL
+  `;
+}
+
+export { POSTGRES_ROW_MAPPER_CONFIG, SQLITE_ROW_MAPPER_CONFIG, buildCheckUnique, buildCheckUniqueBatch, buildDeleteUnique, buildHardDeleteEdgeClaimsByEdgeKind, buildHardDeleteEdgeClaimsByNodeKind, buildHardDeleteUniquesByConcreteKind, buildHardDeleteUniquesByNode, buildHardDeleteUniquesByNodeIds, buildInsertUnique, buildInsertUniqueBatch, buildLockEdgeClaims, buildPurgeEdgeClaims, buildTakeOverEdgeClaim, codePointOrderKey, coerceNumericScore, createEdgeRowMapper, createNodeRowMapper, createSchemaVersionRowMapper, createUniqueRowMapper, edgeColumnList, edgePrimaryKeyConstraint, expectedValidFromPredicate, formatPostgresTimestamp, liveNodeIdsSubquery, nodeColumnList, nodePrimaryKeyConstraint, normalizeRequiredRowTimestamp, normalizeRowTimestamp, nowIso, quotedColumn, quotedTableName, sqlNull };
+//# sourceMappingURL=chunk-S3SDEQMC.js.map
+//# sourceMappingURL=chunk-S3SDEQMC.js.map