@nicia-ai/typegraph 0.43.0 → 0.45.0

package/dist/{chunk-YPVQYM3L.js → chunk-QRNYDV5Z.js}

@@ -1,15 +1,15 @@
-import { createPostgresOperationStrategy, createCachedTableExistence, createContributionMaterializer, gateFulltextMethods, lockPostgresTrustedImportTables, assertTrustedImportDatabaseEmpty, suspendPostgresSecondaryIndexes, createPostgresTrustedImportSession, restoreSecondaryIndexes, analyzeImportedTables, createCommonOperationBackend, vectorSlotFromParams, buildLiveNodeCandidates, mapVectorWriteError, mapHybridSearchRow, mapContributionMaterializationRow, POSTGRES_CONTRIBUTION_MAT_TIMESTAMPS, buildContributionInsertValues, buildContributionOnConflictSet, assertAdoptedDialect, buildKindRemovalInsertValues, POSTGRES_KIND_REMOVAL_TIMESTAMPS, buildKindRemovalOnConflictSet, mapKindRemovalRow, buildMaterializationInsertValues, POSTGRES_INDEX_MAT_TIMESTAMPS, buildMaterializationOnConflictSet, mapMaterializationRow, vectorSlotFromDropIndexParams, vectorSlotFromCreateIndexParams, EMBEDDING_UPSERT_PARAM_COUNT, gateFulltext, getOrCreateLru } from './chunk-HHBKGPEI.js';
-import { pgvectorStrategy, assertPgvectorEfSearch } from './chunk-ZGOUVMVS.js';
-import { createNodeRowMapper, POSTGRES_ROW_MAPPER_CONFIG, createEdgeRowMapper, createUniqueRowMapper, createSchemaVersionRowMapper, nowIso, coerceNumericScore } from './chunk-CVNGKTHO.js';
-import { tables, generatePgCreateTableSQL, generatePostgresDDL } from './chunk-Z3WIL6S3.js';
-import { toDrizzleSql, compileQueryWithDialect } from './chunk-UJRWOV5B.js';
+import { createPostgresOperationStrategy, createCachedTableExistence, createContributionMaterializer, gateFulltextMethods, lockPostgresTrustedImportTables, assertTrustedImportDatabaseEmpty, suspendPostgresSecondaryIndexes, createPostgresTrustedImportSession, restoreSecondaryIndexes, analyzeImportedTables, createCommonOperationBackend, vectorSlotFromParams, buildLiveNodeCandidates, mapVectorWriteError, mapHybridSearchRow, mapContributionMaterializationRow, POSTGRES_CONTRIBUTION_MAT_TIMESTAMPS, buildContributionInsertValues, buildContributionOnConflictSet, tableExistsFromRow, assertAdoptedDialect, buildKindRemovalInsertValues, POSTGRES_KIND_REMOVAL_TIMESTAMPS, buildKindRemovalOnConflictSet, mapKindRemovalRow, buildMaterializationInsertValues, POSTGRES_INDEX_MAT_TIMESTAMPS, buildMaterializationOnConflictSet, mapMaterializationRow, vectorSlotFromDropIndexParams, vectorSlotFromCreateIndexParams, FIND_EDGES_ENDPOINT_FIXED_PARAM_COUNT, EMBEDDING_UPSERT_PARAM_COUNT, gateFulltext, getOrCreateLru, commitSchemaVersionIfKindsEmpty, assertActiveSchemaVersion } from './chunk-DXEEHSGN.js';
+import { pgvectorStrategy, assertPgvectorEfSearch } from './chunk-ISLPNELU.js';
+import { createNodeRowMapper, POSTGRES_ROW_MAPPER_CONFIG, createEdgeRowMapper, createUniqueRowMapper, createSchemaVersionRowMapper, nowIso, coerceNumericScore } from './chunk-YMTXMPV6.js';
+import { tables, generatePostgresDDL, generatePgCreateTableSQL } from './chunk-BGYJW37L.js';
+import { toDrizzleSql, compileQueryWithDialect } from './chunk-EFEOOCJ3.js';
 import { chunk } from './chunk-35S6P5ZU.js';
-import { POSTGRES_MAX_BIND_PARAMETERS, normalizeGraphAnalyticsCapabilities, createBackendOverlay, INTERNAL_TEMPORARY_WRITES, POSTGRES_CAPABILITIES } from './chunk-UZLEQFTV.js';
-import { isMissingTableError, isInsufficientResourcesError } from './chunk-CUPJL6TS.js';
-import { tsvectorStrategy, assertVectorSearchLimit, buildFulltextCapabilities, buildVectorCapabilities } from './chunk-42XYPKZU.js';
-import { sql, isSqlFragment, shouldForceCustomPlan, annIndexScanTypes } from './chunk-M4GYQF2H.js';
+import { POSTGRES_MAX_BIND_PARAMETERS, normalizeGraphAnalyticsCapabilities, createBackendOverlay, INTERNAL_TEMPORARY_WRITES, POSTGRES_CAPABILITIES } from './chunk-55ITBQJI.js';
+import { isMissingTableError, isInsufficientResourcesError, isPostgresUniqueViolationError } from './chunk-V34A6R5V.js';
+import { tsvectorStrategy, assertVectorSearchLimit, buildFulltextCapabilities, buildVectorCapabilities } from './chunk-PVUI6KGR.js';
+import { sql, isSqlFragment, shouldForceCustomPlan, annIndexScanTypes } from './chunk-6DCB664D.js';
 import { requireDefined } from './chunk-QMQLUA66.js';
-import { ConfigurationError, CompilerInvariantError, TransactionClosedError } from './chunk-OYJSYDIH.js';
+import { ConfigurationError, CompilerInvariantError, TransactionClosedError } from './chunk-4MB3AQAQ.js';
 import { getTableName, sql as sql$1, eq, and, isNull, inArray } from 'drizzle-orm';
 import { PgTransaction } from 'drizzle-orm/pg-core';
 
@@ -291,6 +291,7 @@ var GET_EDGES_FIXED_PARAM_COUNT = 1;
 var FULLTEXT_UPSERT_PARAM_COUNT = 6;
 var FULLTEXT_DELETE_FIXED_PARAM_COUNT = 2;
 var CHECK_UNIQUE_BATCH_FIXED_PARAM_COUNT = 3;
+var UNIQUE_DELETE_FIXED_PARAM_COUNT = 2;
 var UNIQUE_INSERT_PARAM_COUNT = 6;
 function computePostgresBatchChunkSizes(maxBindParameters) {
   return {
@@ -306,6 +307,10 @@ function computePostgresBatchChunkSizes(maxBindParameters) {
       1,
       Math.floor(maxBindParameters / EMBEDDING_UPSERT_PARAM_COUNT)
     ),
+    findEdgesEndpointChunkSize: Math.max(
+      1,
+      maxBindParameters - FIND_EDGES_ENDPOINT_FIXED_PARAM_COUNT
+    ),
     fulltextDeleteChunkSize: Math.max(
       1,
       maxBindParameters - FULLTEXT_DELETE_FIXED_PARAM_COUNT
@@ -326,6 +331,10 @@ function computePostgresBatchChunkSizes(maxBindParameters) {
       1,
       Math.floor(maxBindParameters / NODE_INSERT_PARAM_COUNT)
     ),
+    uniqueDeleteChunkSize: Math.max(
+      1,
+      maxBindParameters - UNIQUE_DELETE_FIXED_PARAM_COUNT
+    ),
     uniqueInsertBatchSize: Math.max(
       1,
       Math.floor(maxBindParameters / UNIQUE_INSERT_PARAM_COUNT)
@@ -420,8 +429,17 @@ function createPostgresBackend(db, options = {}) {
     { cacheExisting: false }
   );
   const matTable = tables2.contributionMaterializations;
+  async function ensureTableWithConcurrentCreateRetry(table) {
+    const statement = sql$1.raw(generatePgCreateTableSQL(table));
+    try {
+      await db.execute(statement);
+    } catch (error) {
+      if (!isPostgresUniqueViolationError(error)) throw error;
+      await db.execute(statement);
+    }
+  }
   async function ensureContributionMaterializationsTableImpl() {
-    await db.execute(sql$1.raw(generatePgCreateTableSQL(matTable)));
+    await ensureTableWithConcurrentCreateRetry(matTable);
   }
   async function getContributionMaterializationRow(identity) {
     const rows = await db.select().from(matTable).where(
@@ -477,6 +495,12 @@ function createPostgresBackend(db, options = {}) {
       )
     );
   }
+  async function contributionTableExists(tableName) {
+    const rows = await executionAdapter.execute(
+      operationStrategy.buildTableExists(tableName)
+    );
+    return tableExistsFromRow(rows[0]);
+  }
   const contributionMaterializer = createContributionMaterializer({
     dialect: "postgres",
     fulltextStrategy,
@@ -488,7 +512,8 @@ function createPostgresBackend(db, options = {}) {
     ensureMarkerTable: ensureContributionMaterializationsTableImpl,
     getMarkers: getContributionMaterializationRows,
     recordMarker: recordContributionMaterializationRow,
-    deleteMarker: deleteContributionMaterializationRow
+    deleteMarker: deleteContributionMaterializationRow,
+    tableExists: contributionTableExists
   });
   const operations = createPostgresOperationBackend({
     db,
@@ -500,12 +525,14 @@ function createPostgresBackend(db, options = {}) {
     fulltextStrategy,
     vectorStrategy,
     contributionMaterializer,
-    iterativeScanProbe
+    iterativeScanProbe,
+    schemaVersionsTable: tables2.schemaVersions,
+    transactionScoped: false
   });
   function runSchemaWriteTransaction(graphId, fn) {
     if (!capabilities.transactions) {
       throw new ConfigurationError(
-        "commitSchemaVersion and setActiveVersion require atomic transactions, but this Postgres backend does not provide them. The drizzle-orm/neon-http driver communicates over HTTP and cannot hold a session across statements; use drizzle-orm/neon-serverless (websocket) for transactional writes.",
+        "Schema writes and removal cleanup require atomic transactions, but this Postgres backend does not provide them. The drizzle-orm/neon-http driver communicates over HTTP and cannot hold a session across statements; use drizzle-orm/neon-serverless (websocket) for transactional writes.",
         {
           backend: "postgres",
           capability: "transactions",
@@ -515,6 +542,13 @@ function createPostgresBackend(db, options = {}) {
     }
     return db.transaction(async (tx) => {
       await tx.execute(sql$1`SELECT pg_advisory_xact_lock(hashtext(${graphId}))`);
+      await tx.execute(sql$1`
+        SELECT ${tables2.schemaVersions.version}
+        FROM ${tables2.schemaVersions}
+        WHERE ${tables2.schemaVersions.graphId} = ${graphId}
+          AND ${tables2.schemaVersions.isActive} = TRUE
+        FOR UPDATE
+      `);
       const { backend: txBackend, drainAndClose } = createTransactionBackend({
         db: tx,
         adapterOptions,
@@ -524,7 +558,8 @@ function createPostgresBackend(db, options = {}) {
         fulltextStrategy,
         vectorStrategy,
         contributionMaterializer,
-        iterativeScanProbe
+        iterativeScanProbe,
+        schemaVersionsTable: tables2.schemaVersions
       });
       try {
         return await fn(txBackend);
@@ -543,7 +578,8 @@ function createPostgresBackend(db, options = {}) {
       fulltextStrategy,
       vectorStrategy,
       contributionMaterializer,
-      iterativeScanProbe
+      iterativeScanProbe,
+      schemaVersionsTable: tables2.schemaVersions
     });
     return {
       backend: gateFulltext(
@@ -556,8 +592,13 @@ function createPostgresBackend(db, options = {}) {
   const backend = {
     ...operations,
     ...capabilities.transactions && executionAdapter.executeCompiled !== void 0 ? {
-      async trustedImport(fn) {
+      async trustedImport(fn, options_) {
         return backend.transactionWithNative(async (tx, rawSql) => {
+          if (options_?.schemaWrite !== void 0) {
+            await requireDefined(tx.lockSchemaVersionForWrite)({
+              ...options_.schemaWrite
+            });
+          }
           const trustedExecutionAdapter = createPostgresExecutionAdapter(
             rawSql,
             { ...adapterOptions, useTransactionClient: true }
@@ -596,9 +637,7 @@ function createPostgresBackend(db, options = {}) {
       }
     },
     async ensureRevisionOriginsTable() {
-      await db.execute(
-        sql$1.raw(generatePgCreateTableSQL(tables2.revisionOrigins))
-      );
+      await ensureTableWithConcurrentCreateRetry(tables2.revisionOrigins);
     },
     // Every fulltext-touching method asserts the durable marker instead
     // of lazily emitting DDL. Steady state performs zero ensure; an
@@ -613,9 +652,7 @@ function createPostgresBackend(db, options = {}) {
       await db.execute(sql$1.raw(ddl));
     },
     async ensureIndexMaterializationsTable() {
-      await db.execute(
-        sql$1.raw(generatePgCreateTableSQL(tables2.indexMaterializations))
-      );
+      await ensureTableWithConcurrentCreateRetry(tables2.indexMaterializations);
       const tableName = getTableName(tables2.indexMaterializations);
       await db.execute(
         sql$1.raw(
@@ -701,7 +738,7 @@ function createPostgresBackend(db, options = {}) {
       await contributionMaterializer.assertInitialized(graphId);
     },
     async ensureKindRemovalsTable() {
-      await db.execute(sql$1.raw(generatePgCreateTableSQL(tables2.kindRemovals)));
+      await ensureTableWithConcurrentCreateRetry(tables2.kindRemovals);
     },
     async getPendingKindRemovals(graphId) {
       const t = tables2.kindRemovals;
@@ -730,9 +767,7 @@ function createPostgresBackend(db, options = {}) {
       });
     },
     async ensureReconciliationMarkersTable() {
-      await db.execute(
-        sql$1.raw(generatePgCreateTableSQL(tables2.reconciliationMarkers))
-      );
+      await ensureTableWithConcurrentCreateRetry(tables2.reconciliationMarkers);
     },
     async ensureRuntimeContributions(graphId) {
       await contributionMaterializer.ensureRuntimeContributions(graphId);
@@ -745,6 +780,12 @@ function createPostgresBackend(db, options = {}) {
     async ensureFulltextTable(graphId) {
       await contributionMaterializer.ensureRuntimeContributions(graphId);
     },
+    async verifyContributions(graphId, vectorSlots) {
+      return contributionMaterializer.verifyContributions(graphId, vectorSlots);
+    },
+    async repairContributions(graphId, vectorSlots) {
+      return contributionMaterializer.repairContributions(graphId, vectorSlots);
+    },
     // Vector counterparts of the runtime-contribution methods. Present
     // only when a vector strategy is wired (omitted under `vector: false`,
     // mirroring the embedding/search methods), so a no-vector backend
@@ -804,12 +845,21 @@ function createPostgresBackend(db, options = {}) {
         (target) => target.commitSchemaVersion(params)
       );
     },
+    async commitSchemaVersionIfKindsEmpty(params, probes) {
+      return runSchemaWriteTransaction(
+        params.graphId,
+        (target) => commitSchemaVersionIfKindsEmpty(target, params, probes)
+      );
+    },
     async setActiveVersion(params) {
       await runSchemaWriteTransaction(
         params.graphId,
         (target) => target.setActiveVersion(params)
       );
     },
+    async schemaWriteTransaction(graphId, fn) {
+      return runSchemaWriteTransaction(graphId, (target) => fn(target));
+    },
     async transaction(fn, options2) {
       return backend.transactionWithNative((tx) => fn(tx), options2);
     },
@@ -905,7 +955,9 @@ function createPostgresOperationBackend(options) {
     fulltextStrategy,
     vectorStrategy,
     contributionMaterializer,
-    iterativeScanProbe
+    iterativeScanProbe,
+    schemaVersionsTable,
+    transactionScoped
   } = options;
   async function execAll(query) {
     return executionAdapter.execute(query);
@@ -1011,6 +1063,7 @@ function createPostgresOperationBackend(options) {
       execRun
     },
     nowIso,
+    maxBindParameters: capabilities.maxBindParameters ?? POSTGRES_MAX_BIND_PARAMETERS,
     operationStrategy,
     rowMappers: {
       toEdgeRow,
@@ -1089,6 +1142,21 @@ function createPostgresOperationBackend(options) {
         await execRun(statement);
       }
     },
+    async deleteEmbeddingBatch(params) {
+      if (params.nodeIds.length === 0) return;
+      const slot = vectorSlotFromParams(params);
+      await contributionMaterializer.assertVectorSlot(slot);
+      for (const nodeIds of chunk(
+        [...new Set(params.nodeIds)],
+        batchConfig.embeddingUpsertBatchSize
+      )) {
+        const statements = vectorStrategy.buildDeleteBatch(slot, {
+          ...params,
+          nodeIds
+        });
+        for (const statement of statements) await execRun(statement);
+      }
+    },
     async vectorSearch(params) {
       assertVectorSearchLimit(params.limit);
       assertPgvectorEfSearch(params.efSearch);
@@ -1181,11 +1249,48 @@ function createPostgresOperationBackend(options) {
     ...commonBackend,
     ...executeRawMethod,
     ...vectorEmbeddingMethods,
+    async deleteSchemaVectorSlotContribution(slot) {
+      if (vectorStrategy === void 0) return;
+      for (const contribution of vectorStrategy.ownedTables(slot)) {
+        await execRun(
+          operationStrategy.buildDeleteContributionMaterialization({
+            graphId: slot.graphId,
+            logicalName: contribution.logicalName,
+            owner: contribution.owner,
+            tableName: contribution.tableName
+          })
+        );
+      }
+      contributionMaterializer.evictVectorSlot(slot);
+    },
     capabilities,
     fulltextStrategy,
     ...vectorStrategy === void 0 ? {} : { vectorStrategy },
     dialect: "postgres",
     tableNames,
+    async lockSchemaVersionForWrite(params) {
+      if (!transactionScoped) {
+        throw new ConfigurationError(
+          "The schema write fence requires an explicit PostgreSQL transaction.",
+          {
+            code: "SCHEMA_WRITE_FENCE_TRANSACTION_REQUIRED",
+            graphId: params.graphId
+          }
+        );
+      }
+      const active = await execGet(sql$1`
+        SELECT ${schemaVersionsTable.version} AS version
+        FROM ${schemaVersionsTable}
+        WHERE ${schemaVersionsTable.graphId} = ${params.graphId}
+          AND ${schemaVersionsTable.isActive} = TRUE
+        FOR SHARE
+      `);
+      assertActiveSchemaVersion(
+        params.graphId,
+        params.expectedVersion,
+        active?.version ?? 0
+      );
+    },
     // === Vector Index Operations ===
     async createVectorIndex(params) {
       if (vectorStrategy === void 0) return;
@@ -1327,11 +1432,13 @@ function createTransactionBackend(options) {
     contributionMaterializer: options.contributionMaterializer,
     // The probe is process-wide truth, so the outer instance's is reused
     // rather than a fresh one per transaction.
-    iterativeScanProbe: options.iterativeScanProbe
+    iterativeScanProbe: options.iterativeScanProbe,
+    schemaVersionsTable: options.schemaVersionsTable,
+    transactionScoped: true
   });
   return { backend, drainAndClose: txExecutionAdapter.drainAndClose };
 }
 
 export { createPostgresBackend };
-//# sourceMappingURL=chunk-YPVQYM3L.js.map
-//# sourceMappingURL=chunk-YPVQYM3L.js.map
+//# sourceMappingURL=chunk-QRNYDV5Z.js.map
+//# sourceMappingURL=chunk-QRNYDV5Z.js.map