@nicia-ai/typegraph 0.37.1 → 0.39.0

package/dist/{chunk-IXGYRP2P.js → chunk-IFRPHG7O.js}

@@ -1,12 +1,16 @@
-import { tables, createPostgresOperationStrategy, createCachedTableExistence, createContributionMaterializer, gateFulltextMethods, lockPostgresTrustedImportTables, assertTrustedImportDatabaseEmpty, suspendPostgresSecondaryIndexes, createPostgresTrustedImportSession, restoreSecondaryIndexes, analyzeImportedTables, EMBEDDING_UPSERT_PARAM_COUNT, createCommonOperationBackend, vectorSlotFromParams, hybridCandidatesRef, mapVectorWriteError, mapHybridSearchRow, generatePgCreateTableSQL, mapContributionMaterializationRow, POSTGRES_CONTRIBUTION_MAT_TIMESTAMPS, buildContributionInsertValues, buildContributionOnConflictSet, assertAdoptedDialect, buildKindRemovalInsertValues, POSTGRES_KIND_REMOVAL_TIMESTAMPS, buildKindRemovalOnConflictSet, mapKindRemovalRow, buildMaterializationInsertValues, POSTGRES_INDEX_MAT_TIMESTAMPS, buildMaterializationOnConflictSet, mapMaterializationRow, generatePostgresDDL, vectorSlotFromDropIndexParams, vectorSlotFromCreateIndexParams, gateFulltext, compileQueryWithDialect, getOrCreateLru } from './chunk-K3Q3LJY3.js';
-import { pgvectorStrategy, assertPgvectorEfSearch } from './chunk-5KPNWT6X.js';
-import { createNodeRowMapper, POSTGRES_ROW_MAPPER_CONFIG, createEdgeRowMapper, createUniqueRowMapper, createSchemaVersionRowMapper, quoteIdentifier, nowIso, coerceNumericScore } from './chunk-M6VES7V6.js';
-import { tsvectorStrategy, assertVectorSearchLimit, buildFulltextCapabilities, buildVectorCapabilities } from './chunk-EXU3RASM.js';
-import { normalizeGraphAnalyticsCapabilities, createBackendOverlay, POSTGRES_MAX_BIND_PARAMETERS, INTERNAL_TEMPORARY_WRITES, POSTGRES_CAPABILITIES, shouldForceCustomPlan, chunk, annIndexScanTypes } from './chunk-44TA22QT.js';
-import { isMissingTableError, isInsufficientResourcesError } from './chunk-XGPUQ56G.js';
-import { ConfigurationError, CompilerInvariantError, TransactionClosedError } from './chunk-5PNMDJ7J.js';
-import { getTableName, sql, eq, and, isNull, inArray } from 'drizzle-orm';
-import { PgDatabase, PgTransaction } from 'drizzle-orm/pg-core';
+import { tables, createPostgresOperationStrategy, createCachedTableExistence, createContributionMaterializer, gateFulltextMethods, lockPostgresTrustedImportTables, assertTrustedImportDatabaseEmpty, suspendPostgresSecondaryIndexes, createPostgresTrustedImportSession, restoreSecondaryIndexes, analyzeImportedTables, EMBEDDING_UPSERT_PARAM_COUNT, createCommonOperationBackend, vectorSlotFromParams, buildLiveNodeCandidates, mapVectorWriteError, mapHybridSearchRow, generatePgCreateTableSQL, mapContributionMaterializationRow, POSTGRES_CONTRIBUTION_MAT_TIMESTAMPS, buildContributionInsertValues, buildContributionOnConflictSet, assertAdoptedDialect, buildKindRemovalInsertValues, POSTGRES_KIND_REMOVAL_TIMESTAMPS, buildKindRemovalOnConflictSet, mapKindRemovalRow, buildMaterializationInsertValues, POSTGRES_INDEX_MAT_TIMESTAMPS, buildMaterializationOnConflictSet, mapMaterializationRow, generatePostgresDDL, vectorSlotFromDropIndexParams, vectorSlotFromCreateIndexParams, gateFulltext, getOrCreateLru } from './chunk-KXFUQNF2.js';
+import { pgvectorStrategy, assertPgvectorEfSearch } from './chunk-SDHV2MWU.js';
+import { createNodeRowMapper, POSTGRES_ROW_MAPPER_CONFIG, createEdgeRowMapper, createUniqueRowMapper, createSchemaVersionRowMapper, nowIso, coerceNumericScore } from './chunk-AOL64O4Z.js';
+import { toDrizzleSql, compileQueryWithDialect } from './chunk-Z2PPIVOO.js';
+import { chunk } from './chunk-35S6P5ZU.js';
+import { normalizeGraphAnalyticsCapabilities, createBackendOverlay, POSTGRES_MAX_BIND_PARAMETERS, INTERNAL_TEMPORARY_WRITES, POSTGRES_CAPABILITIES } from './chunk-PZHC5GCD.js';
+import { isMissingTableError, isInsufficientResourcesError } from './chunk-UUIBACKJ.js';
+import { tsvectorStrategy, assertVectorSearchLimit, buildFulltextCapabilities, buildVectorCapabilities } from './chunk-Y7M44XEK.js';
+import { sql, isSqlFragment, shouldForceCustomPlan, annIndexScanTypes } from './chunk-6XDBRDZE.js';
+import { requireDefined } from './chunk-QMQLUA66.js';
+import { ConfigurationError, CompilerInvariantError, TransactionClosedError } from './chunk-DPNA466P.js';
+import { getTableName, sql as sql$1, eq, and, isNull, inArray } from 'drizzle-orm';
+import { PgTransaction } from 'drizzle-orm/pg-core';
 
 // src/backend/drizzle/execution/postgres-execution.ts
 function hasFunctionProperty(value, property) {
@@ -95,15 +99,15 @@ function wrapNodePgClientUnnamed(client) {
     queryUnnamed
   };
 }
-function adaptPostgresJsClient(sql2) {
+function adaptPostgresJsClient(sql3) {
   async function query(sqlText, params) {
-    const rows = await sql2.unsafe(sqlText, params);
+    const rows = await sql3.unsafe(sqlText, params);
     return { rows };
   }
   return {
     query,
     async queryUnnamed(sqlText, params) {
-      const rows = await sql2.unsafe(sqlText, params, { prepare: false });
+      const rows = await sql3.unsafe(sqlText, params, { prepare: false });
       return { rows };
     }
   };
@@ -157,7 +161,10 @@ function createPostgresExecutionAdapter(db, options = {}) {
     return {
       compile,
       async execute(query) {
-        return executeDrizzleQuery(db, query);
+        return executeDrizzleQuery(
+          db,
+          isSqlFragment(query) ? toDrizzleSql(query, "postgres") : query
+        );
       }
     };
   }
@@ -173,7 +180,7 @@ function createPostgresExecutionAdapter(db, options = {}) {
     compile,
     async execute(query) {
       const compiled = compile(query);
-      if (shouldForceCustomPlan(query)) {
+      if (isSqlFragment(query) && shouldForceCustomPlan(query)) {
         const result = await pgQueryClient.queryUnnamed(
           compiled.sql,
           compiled.params
@@ -333,7 +340,12 @@ function createPostgresBackend(db, options = {}) {
     tableNames.edges,
     getTableName(tables2.uniques),
     tableNames.fulltext
-  ].map((name) => sql`ANALYZE (SKIP_LOCKED) ${quoteIdentifier(name)}`);
+  ].map(
+    (name) => toDrizzleSql(
+      sql`ANALYZE (SKIP_LOCKED) ${sql.identifier(name)}`,
+      "postgres"
+    )
+  );
   const recordedAnalyzeTables = [
     tableNames.recordedNodes,
     tableNames.recordedEdges,
@@ -354,7 +366,7 @@ function createPostgresBackend(db, options = {}) {
   );
   const matTable = tables2.contributionMaterializations;
   async function ensureContributionMaterializationsTableImpl() {
-    await db.execute(sql.raw(generatePgCreateTableSQL(matTable)));
+    await db.execute(sql$1.raw(generatePgCreateTableSQL(matTable)));
   }
   async function getContributionMaterializationRow(identity) {
     const rows = await db.select().from(matTable).where(
@@ -416,7 +428,7 @@ function createPostgresBackend(db, options = {}) {
     fulltextTableName: tables2.fulltextTableName,
     vectorStrategy,
     execDdl: async (statement) => {
-      await db.execute(sql.raw(statement));
+      await db.execute(sql$1.raw(statement));
     },
     ensureMarkerTable: ensureContributionMaterializationsTableImpl,
     getMarkers: getContributionMaterializationRows,
@@ -447,7 +459,7 @@ function createPostgresBackend(db, options = {}) {
       );
     }
     return db.transaction(async (tx) => {
-      await tx.execute(sql`SELECT pg_advisory_xact_lock(hashtext(${graphId}))`);
+      await tx.execute(sql$1`SELECT pg_advisory_xact_lock(hashtext(${graphId}))`);
       const { backend: txBackend, drainAndClose } = createTransactionBackend({
         db: tx,
         adapterOptions,
@@ -490,7 +502,7 @@ function createPostgresBackend(db, options = {}) {
     ...operations,
     ...capabilities.transactions && executionAdapter.executeCompiled !== void 0 ? {
       async trustedImport(fn) {
-        return backend.transaction(async (tx, rawSql) => {
+        return backend.transactionWithNative(async (tx, rawSql) => {
           const trustedExecutionAdapter = createPostgresExecutionAdapter(
             rawSql,
             { ...adapterOptions, useTransactionClient: true }
@@ -525,12 +537,12 @@ function createPostgresBackend(db, options = {}) {
     async bootstrapTables() {
       const statements = generatePostgresDDL(tables2, fulltextStrategy);
       for (const statement of statements) {
-        await db.execute(sql.raw(statement));
+        await db.execute(sql$1.raw(statement));
       }
     },
     async ensureRevisionOriginsTable() {
       await db.execute(
-        sql.raw(generatePgCreateTableSQL(tables2.revisionOrigins))
+        sql$1.raw(generatePgCreateTableSQL(tables2.revisionOrigins))
       );
     },
     // Every fulltext-touching method asserts the durable marker instead
@@ -543,27 +555,27 @@ function createPostgresBackend(db, options = {}) {
       contributionMaterializer.assertInitialized
     ),
     async executeDdl(ddl) {
-      await db.execute(sql.raw(ddl));
+      await db.execute(sql$1.raw(ddl));
     },
     async ensureIndexMaterializationsTable() {
       await db.execute(
-        sql.raw(generatePgCreateTableSQL(tables2.indexMaterializations))
+        sql$1.raw(generatePgCreateTableSQL(tables2.indexMaterializations))
       );
       const tableName = getTableName(tables2.indexMaterializations);
       await db.execute(
-        sql.raw(
+        sql$1.raw(
           `ALTER TABLE "${tableName}" ADD COLUMN IF NOT EXISTS "building_since" timestamptz;`
         )
       );
       await db.execute(
-        sql.raw(
+        sql$1.raw(
           `ALTER TABLE "${tableName}" ADD COLUMN IF NOT EXISTS "claim_token" text;`
         )
       );
     },
     async claimIndexMaterialization(params) {
       const t = tables2.indexMaterializations;
-      const rows = await db.execute(sql`
+      const rows = await db.execute(sql$1`
         INSERT INTO ${t} (
           "index_name", "graph_id", "entity", "kind", "signature",
           "schema_version", "last_attempted_at", "building_since",
@@ -587,7 +599,7 @@ function createPostgresBackend(db, options = {}) {
     },
     async releaseIndexMaterializationClaim(params) {
       const t = tables2.indexMaterializations;
-      await db.execute(sql`
+      await db.execute(sql$1`
         UPDATE ${t}
         SET "building_since" = NULL, "claim_token" = NULL
         WHERE "index_name" = ${params.indexName}
@@ -634,7 +646,7 @@ function createPostgresBackend(db, options = {}) {
       await contributionMaterializer.assertInitialized(graphId);
     },
     async ensureKindRemovalsTable() {
-      await db.execute(sql.raw(generatePgCreateTableSQL(tables2.kindRemovals)));
+      await db.execute(sql$1.raw(generatePgCreateTableSQL(tables2.kindRemovals)));
     },
     async getPendingKindRemovals(graphId) {
       const t = tables2.kindRemovals;
@@ -664,7 +676,7 @@ function createPostgresBackend(db, options = {}) {
     },
     async ensureReconciliationMarkersTable() {
       await db.execute(
-        sql.raw(generatePgCreateTableSQL(tables2.reconciliationMarkers))
+        sql$1.raw(generatePgCreateTableSQL(tables2.reconciliationMarkers))
       );
     },
     async ensureRuntimeContributions(graphId) {
@@ -724,7 +736,10 @@ function createPostgresBackend(db, options = {}) {
       const presentRecordedTables = tablePresence.filter((entry) => entry.exists).map((entry) => entry.tableName);
       for (const tableName of presentRecordedTables) {
         await db.execute(
-          sql`ANALYZE (SKIP_LOCKED) ${quoteIdentifier(tableName)}`
+          toDrizzleSql(
+            sql`ANALYZE (SKIP_LOCKED) ${sql.identifier(tableName)}`,
+            "postgres"
+          )
         );
       }
     },
@@ -741,6 +756,9 @@ function createPostgresBackend(db, options = {}) {
       );
     },
     async transaction(fn, options2) {
+      return backend.transactionWithNative((tx) => fn(tx), options2);
+    },
+    async transactionWithNative(fn, options2) {
       const temporaryWrites = options2?.temporaryWrites === INTERNAL_TEMPORARY_WRITES;
       if (temporaryWrites && options2.accessMode !== "read_only") {
         throw new ConfigurationError(
@@ -753,7 +771,7 @@ function createPostgresBackend(db, options = {}) {
           isolationLevel: options2.isolationLevel.replace("_", " ")
         },
         ...options2.accessMode === void 0 && !temporaryWrites ? {} : {
-          accessMode: temporaryWrites ? "read write" : options2.accessMode.replace("_", " ")
+          accessMode: temporaryWrites ? "read write" : requireDefined(options2.accessMode).replace("_", " ")
         }
       } : void 0;
       return db.transaction(async (tx) => {
@@ -776,7 +794,11 @@ function createPostgresBackend(db, options = {}) {
           }
         );
       }
-      assertAdoptedDialect(externalTx, PgDatabase, "postgres");
+      assertAdoptedDialect(
+        externalTx,
+        PgTransaction,
+        "postgres"
+      );
       return bindTransactionBackend(externalTx).backend;
     },
     async close() {
@@ -802,7 +824,7 @@ function createIterativeScanProbe() {
       probe ??= (async () => {
         try {
           const [row] = await execAll(
-            sql`SELECT extversion AS v FROM pg_extension WHERE extname = 'vector'`
+            sql$1`SELECT extversion AS v FROM pg_extension WHERE extname = 'vector'`
           );
           if (typeof row?.v !== "string") return false;
           const [major = 0, minor = 0] = row.v.split(".").map((part) => Number.parseInt(part, 10));
@@ -888,19 +910,19 @@ function createPostgresOperationBackend(options) {
       const snapshots = [];
       for (const override of overrides) {
         const [setting] = await connection.execute(
-          sql`SELECT current_setting(${override.name}) AS v`
+          sql$1`SELECT current_setting(${override.name}) AS v`
         );
         if (setting !== void 0) {
           snapshots.push({ name: override.name, value: setting.v });
         }
         await connection.execute(
-          sql`SELECT set_config(${override.name}, ${override.value}, true)`
+          sql$1`SELECT set_config(${override.name}, ${override.value}, true)`
         );
       }
       const rows = await connection.execute(query);
       for (const snapshot of snapshots) {
         await connection.execute(
-          sql`SELECT set_config(${snapshot.name}, ${snapshot.value}, true)`
+          sql$1`SELECT set_config(${snapshot.name}, ${snapshot.value}, true)`
         );
       }
       return rows;
@@ -917,7 +939,7 @@ function createPostgresOperationBackend(options) {
       const txAdapter = createPostgresExecutionAdapter(tx, adapterOptions);
       for (const override of overrides) {
         await txAdapter.execute(
-          sql`SELECT set_config(${override.name}, ${override.value}, true)`
+          sql$1`SELECT set_config(${override.name}, ${override.value}, true)`
         );
       }
       return txAdapter.execute(query);
@@ -1035,9 +1057,11 @@ function createPostgresOperationBackend(options) {
         params,
         // Store-compiled candidates (predicates + subclass + currency)
         // take precedence; the live-node default covers direct backend use.
-        params.candidates ?? operationStrategy.buildLiveNodeIds(
+        params.candidates ?? buildLiveNodeCandidates(
+          tableNames.nodes,
           params.graphId,
-          params.nodeKind
+          params.nodeKind,
+          nowIso()
         )
       );
       const gucOverrides = await vectorSearchGucOverrides(params);
@@ -1068,9 +1092,11 @@ function createPostgresOperationBackend(options) {
           metric: params.vector.metric,
           indexType: params.vector.indexType
         });
-        const candidates = params.candidates ?? operationStrategy.buildLiveNodeIds(
+        const candidates = params.candidates ?? buildLiveNodeCandidates(
+          tableNames.nodes,
           params.graphId,
-          params.nodeKind
+          params.nodeKind,
+          nowIso()
         );
         const vectorParams = {
           graphId: params.graphId,
@@ -1086,11 +1112,11 @@ function createPostgresOperationBackend(options) {
         const vectorSql = vectorStrategy.buildSearch(
           slot,
           vectorParams,
-          hybridCandidatesRef()
+          sql.raw("SELECT node_id FROM tg_hybrid_cand")
         );
         const statement = operationStrategy.buildHybridSearch(
           { ...params, candidates },
-          vectorSql,
+          toDrizzleSql(vectorSql, "postgres"),
           params.vector.metric === "cosine"
         );
         const gucOverrides = await vectorSearchGucOverrides({
@@ -1136,18 +1162,22 @@ function createPostgresOperationBackend(options) {
           if (dropStatement !== void 0) {
             await execRun(dropStatement);
           }
-          const table = quoteIdentifier(
+          const table = sql.identifier(
             vectorStrategy.tableName(
               slot.graphId,
               slot.nodeKind,
               slot.fieldPath
             )
           );
-          await execRun(sql`ALTER TABLE ${table} SET (parallel_workers = 0)`);
+          await execRun(
+            sql`ALTER TABLE ${table} SET (parallel_workers = 0)`
+          );
           try {
             await execRun(indexStatement);
           } finally {
-            await execRun(sql`ALTER TABLE ${table} RESET (parallel_workers)`);
+            await execRun(
+              sql`ALTER TABLE ${table} RESET (parallel_workers)`
+            );
           }
         }
       }
@@ -1223,7 +1253,7 @@ function createPostgresOperationBackend(options) {
     },
     // === Query Execution ===
     async execute(query) {
-      const annTypes = annIndexScanTypes(query);
+      const annTypes = isSqlFragment(query) ? annIndexScanTypes(query) : void 0;
       if (annTypes !== void 0 && vectorStrategy !== void 0) {
         const overrides = [];
         for (const indexType of annTypes) {
@@ -1262,5 +1292,5 @@ function createTransactionBackend(options) {
 }
 
 export { createPostgresBackend };
-//# sourceMappingURL=chunk-IXGYRP2P.js.map
-//# sourceMappingURL=chunk-IXGYRP2P.js.map
+//# sourceMappingURL=chunk-IFRPHG7O.js.map
+//# sourceMappingURL=chunk-IFRPHG7O.js.map