@nicia-ai/typegraph 0.46.1 → 0.47.0

package/dist/{chunk-5763DULU.js → chunk-M35DF33T.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-7VQXLT5O.js';
-import { pgvectorStrategy, assertPgvectorEfSearch } from './chunk-VGTJPTIC.js';
-import { createNodeRowMapper, POSTGRES_ROW_MAPPER_CONFIG, createEdgeRowMapper, createUniqueRowMapper, createSchemaVersionRowMapper, nowIso, coerceNumericScore } from './chunk-NMWDXFPH.js';
-import { tables, generatePostgresDDL, generatePgCreateTableSQL, createPostgresTables, postgresContributions } from './chunk-5UVRGXD3.js';
-import { toDrizzleSql, compileQueryWithDialect } from './chunk-UV3SN74I.js';
-import { isPostgresConcurrentDdlRaceError, chunk, isMissingTableError, isInsufficientResourcesError } from './chunk-JZUR7ZWE.js';
-import { POSTGRES_MAX_BIND_PARAMETERS, normalizeGraphAnalyticsCapabilities, createBackendOverlay, markSerializedTransactionResource, INTERNAL_TEMPORARY_WRITES, POSTGRES_CAPABILITIES } from './chunk-AKLS3BYZ.js';
-import { tsvectorStrategy, assertVectorSearchLimit, buildFulltextCapabilities, buildVectorCapabilities, resolveEfSearchOverride, vectorSearchFrontierTuning } from './chunk-YDFDBE6D.js';
-import { sql, isSqlFragment, shouldForceCustomPlan, annIndexScanTypes } from './chunk-PQBQG7IM.js';
-import { ConfigurationError, StaleVersionError, CompilerInvariantError, TransactionClosedError } from './chunk-J3WZ3FA2.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-KH7XW7VV.js';
+import { pgvectorStrategy, assertPgvectorEfSearch } from './chunk-JONXFAPO.js';
+import { createNodeRowMapper, POSTGRES_ROW_MAPPER_CONFIG, createEdgeRowMapper, createUniqueRowMapper, createSchemaVersionRowMapper, nowIso, coerceNumericScore } from './chunk-LEWHMOUY.js';
+import { tables, generatePostgresDDL, generatePgCreateTableSQL, createPostgresTables, postgresContributions } from './chunk-6SWPJEYN.js';
+import { toDrizzleSql, compileQueryWithDialect } from './chunk-OMZ37BM2.js';
+import { isPostgresConcurrentDdlRaceError, chunk, isMissingTableError, isInsufficientResourcesError } from './chunk-NAZ2RA4L.js';
+import { POSTGRES_MAX_BIND_PARAMETERS, normalizeGraphAnalyticsCapabilities, createBackendOverlay, markSerializedTransactionResource, INTERNAL_TEMPORARY_WRITES, POSTGRES_CAPABILITIES } from './chunk-SHSSRCFR.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);
@@ -639,7 +746,8 @@ function createPostgresBackend(db, options = {}) {
     return {
       backend: gateFulltext(
         backend2,
-        contributionMaterializer.assertInitialized
+        contributionMaterializer.assertInitialized,
+        contributionMaterializer.refuseUnavailableFulltext
       ),
       drainAndClose
     };
@@ -723,7 +831,8 @@ function createPostgresBackend(db, options = {}) {
     // verbatim with the tx-scoped gate via `gateFulltextMethods`.
     ...gateFulltextMethods(
       operations,
-      contributionMaterializer.assertInitialized
+      contributionMaterializer.assertInitialized,
+      contributionMaterializer.refuseUnavailableFulltext
     ),
     async executeDdl(ddl) {
       await db.execute(sql$1.raw(ddl));
@@ -738,6 +847,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`
@@ -1445,32 +1566,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 ===
@@ -1585,5 +1692,5 @@ function createTransactionBackend(options) {
 }
 
 export { createPostgresBackend };
-//# sourceMappingURL=chunk-5763DULU.js.map
-//# sourceMappingURL=chunk-5763DULU.js.map
+//# sourceMappingURL=chunk-M35DF33T.js.map
+//# sourceMappingURL=chunk-M35DF33T.js.map