@nicia-ai/typegraph 0.45.0 → 0.46.1

package/dist/{chunk-QRNYDV5Z.js → chunk-5763DULU.js}

@@ -1,15 +1,14 @@
-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-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-4MB3AQAQ.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-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 { 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';
 
@@ -28,8 +27,12 @@ function isPgliteClient(candidate) {
   return typeof candidate === "object" && hasFunctionProperty(candidate, "query") && hasFunctionProperty(candidate, "dumpDataDir");
 }
 var PGLITE_MAX_BIND_PARAMETERS = 32767;
+function getPgliteClient(db) {
+  const client = db.$client;
+  return isPgliteClient(client) ? client : void 0;
+}
 function isPgliteDatabase(db) {
-  return isPgliteClient(db.$client);
+  return getPgliteClient(db) !== void 0;
 }
 function transactionSession(carrier) {
   return carrier.session ?? carrier._?.session;
@@ -341,6 +344,12 @@ function computePostgresBatchChunkSizes(maxBindParameters) {
     )
   };
 }
+var IDENTITY_TABLE_LOGICAL_NAMES = /* @__PURE__ */ new Set([
+  "identityAssertions",
+  "recordedIdentityAssertions",
+  "identityClosure",
+  "identitySeparation"
+]);
 var toNodeRow = createNodeRowMapper(POSTGRES_ROW_MAPPER_CONFIG);
 var toEdgeRow = createEdgeRowMapper(POSTGRES_ROW_MAPPER_CONFIG);
 var toUniqueRow = createUniqueRowMapper(POSTGRES_ROW_MAPPER_CONFIG);
@@ -355,6 +364,7 @@ function buildPostgresCapabilities(fulltextStrategy, vectorStrategy) {
   };
 }
 function createPostgresBackend(db, options = {}) {
+  const serializedClient = getSerializedPostgresClient(db);
   const tables2 = options.tables ?? tables;
   const fulltextStrategy = options.fulltext ?? tsvectorStrategy;
   const vectorStrategy = options.vector === false ? void 0 : options.vector ?? pgvectorStrategy;
@@ -377,12 +387,24 @@ function createPostgresBackend(db, options = {}) {
       PGLITE_MAX_BIND_PARAMETERS
     )
   } : {};
-  const capabilities = normalizeGraphAnalyticsCapabilities({
+  const declaredCapabilities = normalizeGraphAnalyticsCapabilities({
     ...baseCapabilities,
     ...httpOnlyOverrides,
     ...options.capabilities,
     ...driverBindParameterOverrides
   });
+  const capabilities = {
+    ...declaredCapabilities,
+    contributions: {
+      supported: true,
+      probe: true,
+      rebuild: contributionRebuildSupported(
+        fulltextStrategy,
+        tables2.fulltextTableName,
+        declaredCapabilities.transactions
+      )
+    }
+  };
   const adapterOptions = {
     ...options.prepareStatements === void 0 ? {} : { prepareStatements: options.prepareStatements },
     ...options.preparedStatementCacheMax === void 0 ? {} : { preparedStatementCacheMax: options.preparedStatementCacheMax },
@@ -396,6 +418,10 @@ function createPostgresBackend(db, options = {}) {
     recordedEdges: getTableName(tables2.recordedEdges),
     recordedClock: getTableName(tables2.recordedClock),
     revisionOrigins: getTableName(tables2.revisionOrigins),
+    identityAssertions: getTableName(tables2.identityAssertions),
+    recordedIdentityAssertions: getTableName(tables2.recordedIdentityAssertions),
+    identityClosure: getTableName(tables2.identityClosure),
+    identitySeparation: getTableName(tables2.identitySeparation),
     fulltext: tables2.fulltextTableName,
     uniques: getTableName(tables2.uniques)
   };
@@ -410,16 +436,20 @@ function createPostgresBackend(db, options = {}) {
       "postgres"
     )
   );
-  const recordedAnalyzeTables = [
+  const guardedAnalyzeTables = [
     tableNames.recordedNodes,
     tableNames.recordedEdges,
-    tableNames.recordedClock
+    tableNames.recordedClock,
+    tableNames.recordedIdentityAssertions,
+    tableNames.identityAssertions,
+    tableNames.identityClosure,
+    tableNames.identitySeparation
   ];
   const operationStrategy = createPostgresOperationStrategy(
     tables2,
     fulltextStrategy
   );
-  const recordedTableExists = createCachedTableExistence(
+  const guardedTableExists = createCachedTableExistence(
     async (tableName) => {
       const rows = await executionAdapter.execute(
         operationStrategy.buildTableExists(tableName)
@@ -429,18 +459,32 @@ function createPostgresBackend(db, options = {}) {
     { cacheExisting: false }
   );
   const matTable = tables2.contributionMaterializations;
-  async function ensureTableWithConcurrentCreateRetry(table) {
-    const statement = sql$1.raw(generatePgCreateTableSQL(table));
+  async function executeConcurrentCreateDdl(ddl) {
+    const statement = sql$1.raw(ddl);
     try {
       await db.execute(statement);
     } catch (error) {
-      if (!isPostgresUniqueViolationError(error)) throw error;
+      if (!isPostgresConcurrentDdlRaceError(error)) throw error;
       await db.execute(statement);
     }
   }
+  async function ensureTableWithConcurrentCreateRetry(table) {
+    await executeConcurrentCreateDdl(generatePgCreateTableSQL(table));
+  }
   async function ensureContributionMaterializationsTableImpl() {
     await ensureTableWithConcurrentCreateRetry(matTable);
   }
+  function identityContributionsFor(identityTableNames) {
+    const identityTables = createPostgresTables({
+      identityAssertions: identityTableNames.identityAssertions,
+      recordedIdentityAssertions: identityTableNames.recordedIdentityAssertions,
+      identityClosure: identityTableNames.identityClosure,
+      identitySeparation: identityTableNames.identitySeparation
+    });
+    return postgresContributions(identityTables, fulltextStrategy).filter(
+      (contribution) => IDENTITY_TABLE_LOGICAL_NAMES.has(contribution.logicalName)
+    );
+  }
   async function getContributionMaterializationRow(identity) {
     const rows = await db.select().from(matTable).where(
       and(
@@ -506,14 +550,25 @@ function createPostgresBackend(db, options = {}) {
     fulltextStrategy,
     fulltextTableName: tables2.fulltextTableName,
     vectorStrategy,
+    // Contribution DDL is `CREATE ... IF NOT EXISTS` reached from every
+    // booting replica, so it carries the same concurrent-create retry the
+    // other create sites use. Without it the loser's 23505 is recorded as
+    // `lastError` on the marker row and reported as a failed materialization,
+    // when the table it wanted is in fact present.
     execDdl: async (statement) => {
-      await db.execute(sql$1.raw(statement));
+      await executeConcurrentCreateDdl(statement);
     },
     ensureMarkerTable: ensureContributionMaterializationsTableImpl,
     getMarkers: getContributionMaterializationRows,
     recordMarker: recordContributionMaterializationRow,
     deleteMarker: deleteContributionMaterializationRow,
-    tableExists: contributionTableExists
+    tableExists: contributionTableExists,
+    // Withheld rather than wired-and-throwing when the driver cannot hold
+    // a session: the rebuild must refuse with its own typed error naming
+    // the absent fence, matching `capabilities.contributions.rebuild`.
+    ...capabilities.transactions ? {
+      schemaWriteTransaction: (graphId, fn) => runSchemaWriteTransaction(graphId, (target) => fn(target))
+    } : {}
   });
   const operations = createPostgresOperationBackend({
     db,
@@ -633,12 +688,34 @@ function createPostgresBackend(db, options = {}) {
     async bootstrapTables() {
       const statements = generatePostgresDDL(tables2, fulltextStrategy);
       for (const statement of statements) {
-        await db.execute(sql$1.raw(statement));
+        await executeConcurrentCreateDdl(statement);
       }
     },
     async ensureRevisionOriginsTable() {
       await ensureTableWithConcurrentCreateRetry(tables2.revisionOrigins);
     },
+    async ensureIdentityTables(identityTableNames, options2) {
+      const identityContributions = identityContributionsFor(identityTableNames);
+      const missing = [];
+      for (const contribution of identityContributions) {
+        if (!await contributionTableExists(contribution.tableName)) {
+          missing.push(contribution.logicalName);
+        }
+      }
+      if (missing.length === 0 || options2.provisionMissing) {
+        for (const contribution of identityContributions) {
+          for (const ddl of contribution.createDdl) {
+            await executeConcurrentCreateDdl(ddl);
+          }
+        }
+      }
+      return missing;
+    },
+    identityTableDdl(identityTableNames) {
+      return identityContributionsFor(identityTableNames).flatMap(
+        (contribution) => [...contribution.createDdl]
+      );
+    },
     // Every fulltext-touching method asserts the durable marker instead
     // of lazily emitting DDL. Steady state performs zero ensure; an
     // uninitialized database throws `StoreNotInitializedError` loudly
@@ -654,15 +731,11 @@ function createPostgresBackend(db, options = {}) {
     async ensureIndexMaterializationsTable() {
       await ensureTableWithConcurrentCreateRetry(tables2.indexMaterializations);
       const tableName = getTableName(tables2.indexMaterializations);
-      await db.execute(
-        sql$1.raw(
-          `ALTER TABLE "${tableName}" ADD COLUMN IF NOT EXISTS "building_since" timestamptz;`
-        )
+      await executeConcurrentCreateDdl(
+        `ALTER TABLE "${tableName}" ADD COLUMN IF NOT EXISTS "building_since" timestamptz;`
       );
-      await db.execute(
-        sql$1.raw(
-          `ALTER TABLE "${tableName}" ADD COLUMN IF NOT EXISTS "claim_token" text;`
-        )
+      await executeConcurrentCreateDdl(
+        `ALTER TABLE "${tableName}" ADD COLUMN IF NOT EXISTS "claim_token" text;`
       );
     },
     async claimIndexMaterialization(params) {
@@ -786,6 +859,16 @@ function createPostgresBackend(db, options = {}) {
     async repairContributions(graphId, vectorSlots) {
       return contributionMaterializer.repairContributions(graphId, vectorSlots);
     },
+    async probeContributions(graphId, vectorSlots) {
+      return contributionMaterializer.probeContributions(graphId, vectorSlots);
+    },
+    async rebuildContribution(graphId, scope, repopulate) {
+      return contributionMaterializer.rebuildContribution(
+        graphId,
+        scope,
+        repopulate
+      );
+    },
     // 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
@@ -824,13 +907,13 @@ function createPostgresBackend(db, options = {}) {
         await db.execute(statement);
       }
       const tablePresence = await Promise.all(
-        recordedAnalyzeTables.map(async (tableName) => ({
+        guardedAnalyzeTables.map(async (tableName) => ({
           tableName,
-          exists: await recordedTableExists(tableName)
+          exists: await guardedTableExists(tableName)
         }))
       );
-      const presentRecordedTables = tablePresence.filter((entry) => entry.exists).map((entry) => entry.tableName);
-      for (const tableName of presentRecordedTables) {
+      const presentGuardedTables = tablePresence.filter((entry) => entry.exists).map((entry) => entry.tableName);
+      for (const tableName of presentGuardedTables) {
         await db.execute(
           toDrizzleSql(
             sql`ANALYZE (SKIP_LOCKED) ${sql.identifier(tableName)}`,
@@ -851,6 +934,12 @@ function createPostgresBackend(db, options = {}) {
         (target) => commitSchemaVersionIfKindsEmpty(target, params, probes)
       );
     },
+    async commitSchemaVersionWithPreflight(params, preflight) {
+      return runSchemaWriteTransaction(params.graphId, async (target) => {
+        await preflight(target);
+        return target.commitSchemaVersion(params);
+      });
+    },
     async setActiveVersion(params) {
       await runSchemaWriteTransaction(
         params.graphId,
@@ -909,8 +998,42 @@ function createPostgresBackend(db, options = {}) {
     async close() {
     }
   };
+  if (serializedClient !== void 0) {
+    markSerializedTransactionResource(backend, serializedClient);
+  }
   return backend;
 }
+function getSerializedPostgresClient(db) {
+  const pgliteClient = getPgliteClient(db);
+  if (pgliteClient !== void 0) return pgliteClient;
+  const client = db.$client;
+  if (typeof client === "function") {
+    return isSingleConnectionCallablePgClient(client) ? client : void 0;
+  }
+  if (typeof client !== "object" || client === null) return void 0;
+  const candidate = client;
+  if (!hasFunctionProperty(candidate, "query")) return void 0;
+  if (isSingleConnectionPgPool(candidate)) return client;
+  return isBarePgClient(candidate) ? client : void 0;
+}
+function isSingleConnectionPgPool(candidate) {
+  const options = candidate["options"];
+  if (typeof options !== "object" || options === null) return false;
+  return options["max"] === 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;
+}
+function isBarePgClient(candidate) {
+  if (candidate["options"] !== void 0 || candidate["totalCount"] !== void 0 || candidate["idleCount"] !== void 0 || candidate["waitingCount"] !== void 0) {
+    return false;
+  }
+  return hasFunctionProperty(candidate, "connect") && hasFunctionProperty(candidate, "end") && hasFunctionProperty(candidate, "escapeIdentifier");
+}
 function createIterativeScanProbe() {
   let probe;
   let warned = false;
@@ -969,31 +1092,24 @@ function createPostgresOperationBackend(options) {
   async function execRun(query) {
     await executionAdapter.execute(query);
   }
-  let efSearchUnsupportedWarned = false;
-  function warnEfSearchUnsupported() {
-    if (efSearchUnsupportedWarned) return;
-    efSearchUnsupportedWarned = true;
-    if (typeof console === "undefined" || typeof console.warn !== "function") {
-      return;
-    }
-    console.warn(
-      "[typegraph] efSearch (hnsw.ef_search override) was ignored: this Postgres backend has transactions disabled (e.g. drizzle-orm/neon-http), and SET LOCAL needs a transaction to scope the override. Use a transactional driver (node-postgres / neon-serverless / postgres-js) to apply efSearch."
-    );
-  }
   function pgvectorIterativeScanSupported() {
     return iterativeScanProbe.isSupported(execAll);
   }
   async function vectorSearchGucOverrides(params) {
     const overrides = [];
-    if (params.efSearch !== void 0) {
-      if (capabilities.transactions) {
-        overrides.push({
-          name: "hnsw.ef_search",
-          value: String(params.efSearch)
-        });
-      } else {
-        warnEfSearchUnsupported();
-      }
+    const efSearchParameter = resolveEfSearchOverride({
+      efSearch: params.efSearch,
+      indexType: params.indexType,
+      tuning: vectorSearchFrontierTuning(vectorStrategy),
+      transactions: capabilities.transactions,
+      dialect: "PostgreSQL",
+      engine: vectorStrategy?.name ?? "this backend"
+    });
+    if (efSearchParameter !== void 0) {
+      overrides.push({
+        name: efSearchParameter,
+        value: String(params.efSearch)
+      });
     }
     if (params.indexType === "hnsw" && capabilities.transactions && await pgvectorIterativeScanSupported()) {
       overrides.push({ name: "hnsw.iterative_scan", value: "strict_order" });
@@ -1245,10 +1361,36 @@ function createPostgresOperationBackend(options) {
       }
     } : {}
   };
+  async function lockActiveSchemaVersion(graphId) {
+    const active = await execGet(sql$1`
+      SELECT ${schemaVersionsTable.version} AS version
+      FROM ${schemaVersionsTable}
+      WHERE ${schemaVersionsTable.graphId} = ${graphId}
+        AND ${schemaVersionsTable.isActive} = TRUE
+      FOR SHARE
+    `);
+    return active?.version;
+  }
   const operationBackend = {
     ...commonBackend,
     ...executeRawMethod,
     ...vectorEmbeddingMethods,
+    /**
+     * Transaction-scoped contribution marker stamp. Present so the
+     * destructive rebuild can commit its marker with the DDL that
+     * produced it; without it the stamp would land outside the
+     * transaction and could survive a rolled-back drop.
+     *
+     * States the row outright rather than reusing the top-level upsert,
+     * whose `materialized_at` COALESCE preserves an earlier success so a
+     * failed re-attempt cannot erase it. A completed rebuild replaced the
+     * storage, so the recorded timestamp must be the rebuild's.
+     */
+    async recordContributionMaterialization(params) {
+      await execRun(
+        operationStrategy.buildInsertContributionMaterialization(params)
+      );
+    },
     async deleteSchemaVectorSlotContribution(slot) {
       if (vectorStrategy === void 0) return;
       for (const contribution of vectorStrategy.ownedTables(slot)) {
@@ -1278,18 +1420,21 @@ function createPostgresOperationBackend(options) {
           }
         );
       }
-      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
-      );
+      const locked = await lockActiveSchemaVersion(params.graphId);
+      if (locked !== void 0) {
+        assertActiveSchemaVersion(
+          params.graphId,
+          params.expectedVersion,
+          locked
+        );
+        return;
+      }
+      const settled = await commonBackend.getActiveSchema(params.graphId);
+      throw new StaleVersionError({
+        graphId: params.graphId,
+        expected: params.expectedVersion,
+        actual: settled?.version ?? 0
+      });
     },
     // === Vector Index Operations ===
     async createVectorIndex(params) {
@@ -1440,5 +1585,5 @@ function createTransactionBackend(options) {
 }
 
 export { createPostgresBackend };
-//# sourceMappingURL=chunk-QRNYDV5Z.js.map
-//# sourceMappingURL=chunk-QRNYDV5Z.js.map
+//# sourceMappingURL=chunk-5763DULU.js.map
+//# sourceMappingURL=chunk-5763DULU.js.map