@nicia-ai/typegraph 0.46.2 → 0.48.0

package/dist/{chunk-WYFB7BN3.js → chunk-OD4SSY2U.js}

@@ -1,13 +1,13 @@
-import { contributionRebuildSupported, createPostgresOperationStrategy, createCachedTableExistence, createContributionMaterializer, gateFulltextMethods, lockPostgresTrustedImportTables, assertTrustedImportDatabaseEmpty, suspendPostgresSecondaryIndexes, createPostgresTrustedImportSession, restoreSecondaryIndexes, analyzeImportedTables, createCommonOperationBackend, vectorSlotFromParams, buildLiveNodeCandidates, mapVectorWriteError, mapHybridSearchRow, mapContributionMaterializationRow, POSTGRES_CONTRIBUTION_MAT_TIMESTAMPS, buildContributionInsertValues, buildContributionOnConflictSet, tableExistsFromRow, assertAdoptedDialect, commitSchemaVersionIfKindsEmpty, buildKindRemovalInsertValues, POSTGRES_KIND_REMOVAL_TIMESTAMPS, buildKindRemovalOnConflictSet, mapKindRemovalRow, buildMaterializationInsertValues, POSTGRES_INDEX_MAT_TIMESTAMPS, buildMaterializationOnConflictSet, mapMaterializationRow, vectorSlotFromDropIndexParams, vectorSlotFromCreateIndexParams, assertActiveSchemaVersion, FIND_EDGES_ENDPOINT_FIXED_PARAM_COUNT, EMBEDDING_UPSERT_PARAM_COUNT, gateFulltext, getOrCreateLru } from './chunk-KXSMF6PL.js';
-import { pgvectorStrategy, assertPgvectorEfSearch } from './chunk-JCNTKRAK.js';
-import { createNodeRowMapper, POSTGRES_ROW_MAPPER_CONFIG, createEdgeRowMapper, createUniqueRowMapper, createSchemaVersionRowMapper, nowIso, coerceNumericScore } from './chunk-IHRDX7K6.js';
-import { tables, generatePostgresDDL, generatePgCreateTableSQL, createPostgresTables, postgresContributions } from './chunk-WHS2Y43J.js';
-import { toDrizzleSql, compileQueryWithDialect } from './chunk-AU3IJNNP.js';
-import { isPostgresConcurrentDdlRaceError, chunk, isMissingTableError, isInsufficientResourcesError } from './chunk-DSAWGCMP.js';
-import { POSTGRES_MAX_BIND_PARAMETERS, normalizeGraphAnalyticsCapabilities, createBackendOverlay, markSerializedTransactionResource, INTERNAL_TEMPORARY_WRITES, POSTGRES_CAPABILITIES } from './chunk-FA6Z7B5L.js';
-import { tsvectorStrategy, assertVectorSearchLimit, buildFulltextCapabilities, buildVectorCapabilities, resolveEfSearchOverride, vectorSearchFrontierTuning } from './chunk-EAMVXR5B.js';
-import { sql, isSqlFragment, shouldForceCustomPlan, annIndexScanTypes } from './chunk-QOJ2L2AD.js';
-import { ConfigurationError, StaleVersionError, CompilerInvariantError, TransactionClosedError } from './chunk-62ZXBMSD.js';
+import { contributionRebuildSupported, createPostgresOperationStrategy, createCachedTableExistence, createContributionMaterializer, gateFulltextMethods, lockPostgresTrustedImportTables, assertTrustedImportDatabaseEmpty, suspendPostgresSecondaryIndexes, createPostgresTrustedImportSession, restoreSecondaryIndexes, analyzeImportedTables, createCommonOperationBackend, vectorSlotFromParams, buildLiveNodeCandidates, mapVectorWriteError, mapHybridSearchRow, mapContributionMaterializationRow, POSTGRES_CONTRIBUTION_MAT_TIMESTAMPS, buildContributionInsertValues, buildContributionOnConflictSet, tableExistsFromRow, assertAdoptedDialect, commitSchemaVersionIfKindsEmpty, buildKindRemovalInsertValues, POSTGRES_KIND_REMOVAL_TIMESTAMPS, buildKindRemovalOnConflictSet, mapKindRemovalRow, buildMaterializationInsertValues, POSTGRES_INDEX_MAT_TIMESTAMPS, buildMaterializationOnConflictSet, mapMaterializationRow, vectorSlotFromDropIndexParams, vectorSlotFromCreateIndexParams, assertActiveSchemaVersion, FIND_EDGES_ENDPOINT_FIXED_PARAM_COUNT, EMBEDDING_UPSERT_PARAM_COUNT, gateFulltext, getOrCreateLru } from './chunk-ACGSAMD3.js';
+import { pgvectorStrategy, assertPgvectorEfSearch } from './chunk-JONXFAPO.js';
+import { createNodeRowMapper, POSTGRES_ROW_MAPPER_CONFIG, createEdgeRowMapper, createUniqueRowMapper, createSchemaVersionRowMapper, nowIso, coerceNumericScore } from './chunk-YIURNGXI.js';
+import { tables, generatePostgresDDL, generatePgCreateTableSQL, createPostgresTables, postgresContributions } from './chunk-6SWPJEYN.js';
+import { toDrizzleSql, compileQueryWithDialect } from './chunk-OMZ37BM2.js';
+import { resolveDeclaredBackendResource, deriveBackend, auditBackendResource, isPostgresConcurrentDdlRaceError, chunk, isMissingTableError, isInsufficientResourcesError } from './chunk-UGHG7PGX.js';
+import { POSTGRES_MAX_BIND_PARAMETERS, normalizeGraphAnalyticsCapabilities, INTERNAL_TEMPORARY_WRITES, POSTGRES_CAPABILITIES } from './chunk-6LN7FIVU.js';
+import { tsvectorStrategy, assertVectorSearchLimit, buildFulltextCapabilities, buildVectorCapabilities, resolveEfSearchOverride, vectorSearchFrontierTuning } from './chunk-ZDKTPBGV.js';
+import { sql, isSqlFragment, shouldForceCustomPlan, annIndexScanTypes } from './chunk-3DMMGT6S.js';
+import { ConfigurationError, StaleVersionError, CompilerInvariantError, TransactionClosedError } from './chunk-ZLONH2UD.js';
 import { requireDefined } from './chunk-DYATYRY4.js';
 import { getTableName, sql as sql$1, eq, and, isNull, inArray } from 'drizzle-orm';
 import { PgTransaction } from 'drizzle-orm/pg-core';
@@ -350,6 +350,113 @@ var IDENTITY_TABLE_LOGICAL_NAMES = /* @__PURE__ */ new Set([
   "identityClosure",
   "identitySeparation"
 ]);
+var TRIGRAM_EXTENSION_DDL_LOCK_KEY = "typegraph:pg-trgm-ddl";
+var TRIGRAM_EXTENSION_DDL = "CREATE EXTENSION IF NOT EXISTS pg_trgm;";
+function parallelWorkerResetSql(tableName) {
+  return `ALTER TABLE "${tableName.replaceAll('"', '""')}" RESET (parallel_workers);`;
+}
+function parallelWorkerResetError(tableName, resetError) {
+  return new Error(
+    `PostgreSQL did not restore the durable parallel_workers setting on vector table ${JSON.stringify(tableName)}. Run ${parallelWorkerResetSql(tableName)} before retrying index materialization.`,
+    { cause: resetError }
+  );
+}
+function vectorSerialFallbackPreparationError(step, parallelBuildError, preparationError) {
+  const action = step === "drop-index" ? "drop the partial vector index" : "disable parallel workers for the serial retry";
+  return new AggregateError(
+    [preparationError],
+    `PostgreSQL could not ${action} after the parallel vector index build exhausted resources.`,
+    { cause: parallelBuildError }
+  );
+}
+function reportParallelWorkerResetFailure(tableName, resetError) {
+  try {
+    if (typeof console === "undefined" || typeof console.error !== "function") {
+      return;
+    }
+    const reported = console.error(
+      `[typegraph] The serial vector index rebuild failed and cleanup also failed. ${parallelWorkerResetError(tableName, resetError).message}`,
+      resetError
+    );
+    void Promise.resolve(reported).catch(() => {
+    });
+  } catch {
+  }
+}
+async function resetVectorParallelWorkers(execute, tableName) {
+  try {
+    await execute(
+      sql`ALTER TABLE ${sql.identifier(tableName)} RESET (parallel_workers)`
+    );
+  } catch (resetError) {
+    throw parallelWorkerResetError(tableName, resetError);
+  }
+}
+async function runVectorIndexBuildWithSerialFallback(execute, tableName, indexStatement, dropStatement) {
+  await resetVectorParallelWorkers(execute, tableName);
+  try {
+    await execute(indexStatement);
+  } catch (error) {
+    if (!isInsufficientResourcesError(error)) throw error;
+    if (dropStatement !== void 0) {
+      try {
+        await execute(dropStatement);
+      } catch (dropError) {
+        throw vectorSerialFallbackPreparationError(
+          "drop-index",
+          error,
+          dropError
+        );
+      }
+    }
+    await runSerialVectorIndexBuild(
+      execute,
+      tableName,
+      indexStatement,
+      error
+    );
+  }
+}
+async function runPostgresVectorIndexBuild(vectorStrategy, execute, tableName, indexStatement, dropStatement) {
+  if (vectorStrategy !== pgvectorStrategy) {
+    await execute(indexStatement);
+    return;
+  }
+  await runVectorIndexBuildWithSerialFallback(
+    execute,
+    tableName,
+    indexStatement,
+    dropStatement
+  );
+}
+async function runSerialVectorIndexBuild(execute, tableName, indexStatement, parallelBuildError) {
+  const table = sql.identifier(tableName);
+  try {
+    await execute(sql`ALTER TABLE ${table} SET (parallel_workers = 0)`);
+  } catch (setError) {
+    if (parallelBuildError === void 0) throw setError;
+    throw vectorSerialFallbackPreparationError(
+      "disable-parallel-workers",
+      parallelBuildError,
+      setError
+    );
+  }
+  let buildFailure;
+  try {
+    await execute(indexStatement);
+  } catch (error) {
+    buildFailure = { error };
+  }
+  try {
+    await execute(sql`ALTER TABLE ${table} RESET (parallel_workers)`);
+  } catch (resetError) {
+    if (buildFailure === void 0) {
+      throw parallelWorkerResetError(tableName, resetError);
+    }
+    reportParallelWorkerResetFailure(tableName, resetError);
+  }
+  if (buildFailure !== void 0) throw buildFailure.error;
+}
 var toNodeRow = createNodeRowMapper(POSTGRES_ROW_MAPPER_CONFIG);
 var toEdgeRow = createEdgeRowMapper(POSTGRES_ROW_MAPPER_CONFIG);
 var toUniqueRow = createUniqueRowMapper(POSTGRES_ROW_MAPPER_CONFIG);
@@ -364,7 +471,10 @@ function buildPostgresCapabilities(fulltextStrategy, vectorStrategy) {
   };
 }
 function createPostgresBackend(db, options = {}) {
-  const serializedClient = getSerializedPostgresClient(db);
+  const resourceAudit = resolveDeclaredBackendResource(
+    getSerializedPostgresClient(db),
+    options.serializedResource
+  );
   const tables2 = options.tables ?? tables;
   const fulltextStrategy = options.fulltext ?? tsvectorStrategy;
   const vectorStrategy = options.vector === false ? void 0 : options.vector ?? pgvectorStrategy;
@@ -666,7 +776,7 @@ function createPostgresBackend(db, options = {}) {
               { capability: "trustedImport", dialect: "postgres" }
             );
           }
-          const trustedTx = createBackendOverlay(tx, {
+          const trustedTx = deriveBackend(tx, {
             executeRaw(sqlText, params) {
               return executeCompiled({ params, sql: sqlText });
             }
@@ -740,6 +850,18 @@ function createPostgresBackend(db, options = {}) {
         `ALTER TABLE "${tableName}" ADD COLUMN IF NOT EXISTS "claim_token" text;`
       );
     },
+    async ensureTrigramExtension() {
+      if (!capabilities.transactions) {
+        await executeConcurrentCreateDdl(TRIGRAM_EXTENSION_DDL);
+        return;
+      }
+      await db.transaction(async (tx) => {
+        await tx.execute(
+          sql$1`SELECT pg_advisory_xact_lock(hashtext(${TRIGRAM_EXTENSION_DDL_LOCK_KEY}), 0)`
+        );
+        await tx.execute(sql$1.raw(TRIGRAM_EXTENSION_DDL));
+      });
+    },
     async claimIndexMaterialization(params) {
       const t = tables2.indexMaterializations;
       const rows = await db.execute(sql$1`
@@ -1000,9 +1122,7 @@ function createPostgresBackend(db, options = {}) {
     async close() {
     }
   };
-  if (serializedClient !== void 0) {
-    markSerializedTransactionResource(backend, serializedClient);
-  }
+  auditBackendResource(backend, resourceAudit);
   return backend;
 }
 function getSerializedPostgresClient(db) {
@@ -1021,14 +1141,24 @@ function getSerializedPostgresClient(db) {
 function isSingleConnectionPgPool(candidate) {
   const options = candidate["options"];
   if (typeof options !== "object" || options === null) return false;
-  return options["max"] === 1;
+  return isSingleConnectionPgPoolCap(
+    options["max"]
+  );
+}
+function isSingleConnectionPgPoolCap(value) {
+  return value === 1 || typeof value === "string" && Number(value) === 1;
 }
 function isSingleConnectionCallablePgClient(client) {
   if (client === void 0 || client === null) return false;
   const options = client["options"];
   if (!isPostgresJsClient(client)) return false;
   if (typeof options !== "object" || options === null) return false;
-  return options["max"] === 1;
+  return isSingleConnectionPostgresJsCap(
+    options["max"]
+  );
+}
+function isSingleConnectionPostgresJsCap(value) {
+  return value === 1 || typeof value === "string" && Number(value) === 1;
 }
 function isBarePgClient(candidate) {
   if (candidate["options"] !== void 0 || candidate["totalCount"] !== void 0 || candidate["idleCount"] !== void 0 || candidate["waitingCount"] !== void 0) {
@@ -1173,7 +1303,7 @@ function createPostgresOperationBackend(options) {
   const batchConfig = computePostgresBatchChunkSizes(
     capabilities.maxBindParameters ?? POSTGRES_MAX_BIND_PARAMETERS
   );
-  const commonBackend = createCommonOperationBackend({
+  const commonOperationMembers = createCommonOperationBackend({
     batchConfig,
     execution: {
       execAll,
@@ -1374,7 +1504,7 @@ function createPostgresOperationBackend(options) {
     return active?.version;
   }
   const operationBackend = {
-    ...commonBackend,
+    ...commonOperationMembers,
     ...executeRawMethod,
     ...vectorEmbeddingMethods,
     /**
@@ -1431,7 +1561,9 @@ function createPostgresOperationBackend(options) {
         );
         return;
       }
-      const settled = await commonBackend.getActiveSchema(params.graphId);
+      const settled = await commonOperationMembers.getActiveSchema(
+        params.graphId
+      );
       throw new StaleVersionError({
         graphId: params.graphId,
         expected: params.expectedVersion,
@@ -1447,32 +1579,18 @@ function createPostgresOperationBackend(options) {
         concurrent: params.concurrent === true
       });
       if (indexStatement !== void 0) {
-        try {
-          await execRun(indexStatement);
-        } catch (error) {
-          if (!isInsufficientResourcesError(error)) throw error;
-          const dropStatement = vectorStrategy.buildDropIndex?.(slot);
-          if (dropStatement !== void 0) {
-            await execRun(dropStatement);
-          }
-          const table = sql.identifier(
-            vectorStrategy.tableName(
-              slot.graphId,
-              slot.nodeKind,
-              slot.fieldPath
-            )
-          );
-          await execRun(
-            sql`ALTER TABLE ${table} SET (parallel_workers = 0)`
-          );
-          try {
-            await execRun(indexStatement);
-          } finally {
-            await execRun(
-              sql`ALTER TABLE ${table} RESET (parallel_workers)`
-            );
-          }
-        }
+        const strategyTableName = vectorStrategy.tableName(
+          slot.graphId,
+          slot.nodeKind,
+          slot.fieldPath
+        );
+        await runPostgresVectorIndexBuild(
+          vectorStrategy,
+          execRun,
+          strategyTableName,
+          indexStatement,
+          vectorStrategy.buildDropIndex?.(slot)
+        );
       }
     },
     // === Fulltext Operations ===
@@ -1587,5 +1705,5 @@ function createTransactionBackend(options) {
 }
 
 export { createPostgresBackend };
-//# sourceMappingURL=chunk-WYFB7BN3.js.map
-//# sourceMappingURL=chunk-WYFB7BN3.js.map
+//# sourceMappingURL=chunk-OD4SSY2U.js.map
+//# sourceMappingURL=chunk-OD4SSY2U.js.map