@nicia-ai/typegraph 0.46.1 → 0.47.0

package/dist/{chunk-7VQXLT5O.js → chunk-KH7XW7VV.js}

@@ -1,13 +1,13 @@
-import { formatPostgresTimestamp, coerceNumericScore, nowIso } from './chunk-NMWDXFPH.js';
-import { runtimeStrategyContributions } from './chunk-5UVRGXD3.js';
-import { toDrizzleSql } from './chunk-UV3SN74I.js';
+import { formatPostgresTimestamp, coerceNumericScore, nowIso } from './chunk-LEWHMOUY.js';
+import { runtimeStrategyContributions } from './chunk-6SWPJEYN.js';
+import { toDrizzleSql } from './chunk-OMZ37BM2.js';
 import { sortedReplacer } from './chunk-JBQQ7THH.js';
-import { parseDimensionMismatch, chunk, isDuplicatePrimaryKeyError, isMissingTableError } from './chunk-JZUR7ZWE.js';
-import { createBackendOverlay } from './chunk-AKLS3BYZ.js';
+import { parseDimensionMismatch, chunk, isMissingTableError, isDuplicatePrimaryKeyError, errorChain } from './chunk-NAZ2RA4L.js';
+import { createBackendOverlay } from './chunk-SHSSRCFR.js';
 import { sha256Hex } from './chunk-K34OPSJK.js';
-import { buildFulltextGraphDelete, buildForeignFulltextGraphProbe, getDialect } from './chunk-YDFDBE6D.js';
-import { sql as sql$1, asCompiledStatementSql, asCompiledRowsSql, isSqlFragment } from './chunk-PQBQG7IM.js';
-import { EmbeddingDimensionChangedError, ConfigurationError, StaleVersionError, MigrationError, SchemaContentConflictError, DatabaseOperationError, UniquenessError, TrustedImportError, ContributionRebuildUnsupportedError, StoreNotInitializedError } from './chunk-J3WZ3FA2.js';
+import { buildFulltextGraphDelete, buildForeignFulltextGraphProbe, getDialect } from './chunk-ZDKTPBGV.js';
+import { sql as sql$1, asCompiledStatementSql, asCompiledRowsSql, isSqlFragment } from './chunk-3DMMGT6S.js';
+import { EmbeddingDimensionChangedError, ConfigurationError, StaleVersionError, MigrationError, SchemaContentConflictError, DatabaseOperationError, UniquenessError, TrustedImportError, ContributionUnavailableError, ContributionRebuildUnsupportedError, StoreNotInitializedError } from './chunk-ZLONH2UD.js';
 import { isPresent } from './chunk-DYATYRY4.js';
 import { sql, is, getTableName } from 'drizzle-orm';
 
@@ -246,56 +246,116 @@ function identityOf(graphId, contribution) {
     tableName: contribution.tableName
   };
 }
-function gateFulltextMethods(source, assert) {
+function missingTableErrorNames(error, tableName) {
+  const quotedTableName2 = `"${tableName.replaceAll('"', '""')}"`;
+  for (const link of errorChain(error)) {
+    const message = errorMessage(link);
+    if (typeof message !== "string") continue;
+    const sqliteMatch = /\bno such table:\s*([^\s;]+)/i.exec(message);
+    const sqliteName = unquoteSqliteIdentifier(sqliteMatch?.[1]);
+    if (sqliteName === tableName) return true;
+    const namesPostgresTable = message.includes(`relation ${quotedTableName2} does not exist`) || message.includes(`table ${quotedTableName2} does not exist`);
+    if (namesPostgresTable) return true;
+  }
+  return false;
+}
+function errorMessage(error) {
+  if (typeof error === "string") return error;
+  if (error instanceof Error) return error.message;
+  if (typeof error !== "object" || error === null || !("message" in error)) {
+    return void 0;
+  }
+  return typeof error.message === "string" ? error.message : void 0;
+}
+function unquoteSqliteIdentifier(identifier) {
+  if (identifier === void 0) return void 0;
+  const first = identifier.at(0);
+  const last = identifier.at(-1);
+  const isQuoted = first === '"' && last === '"' || first === "'" && last === "'" || first === "`" && last === "`" || first === "[" && last === "]";
+  return isQuoted ? identifier.slice(1, -1) : identifier;
+}
+async function executeGatedFulltext(graphId, assert, refuseUnavailable, execute) {
+  await assert(graphId);
+  try {
+    return await execute();
+  } catch (error) {
+    return refuseUnavailable(graphId, error);
+  }
+}
+function gateFulltextMethods(source, assert, refuseUnavailable) {
   const gated = {};
   if (source.upsertFulltext) {
     const raw = source.upsertFulltext;
     gated.upsertFulltext = async (params) => {
-      await assert(params.graphId);
-      await raw(params);
+      await executeGatedFulltext(
+        params.graphId,
+        assert,
+        refuseUnavailable,
+        () => raw(params)
+      );
     };
   }
   if (source.deleteFulltext) {
     const raw = source.deleteFulltext;
     gated.deleteFulltext = async (params) => {
-      await assert(params.graphId);
-      await raw(params);
+      await executeGatedFulltext(
+        params.graphId,
+        assert,
+        refuseUnavailable,
+        () => raw(params)
+      );
     };
   }
   if (source.upsertFulltextBatch) {
     const raw = source.upsertFulltextBatch;
     gated.upsertFulltextBatch = async (params) => {
       if (params.rows.length === 0) return;
-      await assert(params.graphId);
-      await raw(params);
+      await executeGatedFulltext(
+        params.graphId,
+        assert,
+        refuseUnavailable,
+        () => raw(params)
+      );
     };
   }
   if (source.deleteFulltextBatch) {
     const raw = source.deleteFulltextBatch;
     gated.deleteFulltextBatch = async (params) => {
       if (params.nodeIds.length === 0) return;
-      await assert(params.graphId);
-      await raw(params);
+      await executeGatedFulltext(
+        params.graphId,
+        assert,
+        refuseUnavailable,
+        () => raw(params)
+      );
     };
   }
   if (source.fulltextSearch) {
     const raw = source.fulltextSearch;
     gated.fulltextSearch = async (params) => {
-      await assert(params.graphId);
-      return raw(params);
+      return executeGatedFulltext(
+        params.graphId,
+        assert,
+        refuseUnavailable,
+        () => raw(params)
+      );
     };
   }
   const rawHardDelete = source.hardDeleteNode;
   gated.hardDeleteNode = async (params) => {
-    await assert(params.graphId);
-    await rawHardDelete(params);
+    await executeGatedFulltext(
+      params.graphId,
+      assert,
+      refuseUnavailable,
+      () => rawHardDelete(params)
+    );
   };
   return gated;
 }
-function gateFulltext(tx, assert) {
+function gateFulltext(tx, assert, refuseUnavailable) {
   return createBackendOverlay(
     tx,
-    gateFulltextMethods(tx, assert)
+    gateFulltextMethods(tx, assert, refuseUnavailable)
   );
 }
 function contributionRebuildSupported(fulltextStrategy, fulltextTableName, transactional) {
@@ -518,6 +578,21 @@ function createContributionMaterializer(deps) {
   async function assertInitialized(graphId) {
     await assertContributions(graphId, runtimeContributions());
   }
+  async function refuseUnavailableFulltext(graphId, error) {
+    await Promise.resolve();
+    if (!isMissingTableError(error)) throw error;
+    const missingContribution = runtimeContributions().find(
+      (contribution) => contribution.logicalName === "fulltext" && missingTableErrorNames(error, contribution.tableName)
+    );
+    if (missingContribution !== void 0) {
+      throw new ContributionUnavailableError(
+        graphId,
+        missingContribution.tableName,
+        { cause: error }
+      );
+    }
+    throw error;
+  }
   async function ensureVectorSlot(slot, options) {
     await ensureVectorSlots([slot], options);
   }
@@ -848,6 +923,7 @@ function createContributionMaterializer(deps) {
   return {
     ensureRuntimeContributions,
     assertInitialized,
+    refuseUnavailableFulltext,
     ensureVectorSlot,
     ensureVectorSlots,
     assertVectorSlot,
@@ -1531,6 +1607,8 @@ function buildUpdateEdge(tables, params, timestamp) {
       sql`${quotedColumn(edges.validFrom)} = ${sqlNull(resolveValidFrom(params.validFrom, timestamp))}`,
       sql`${quotedColumn(edges.validTo)} = ${sqlNull(params.validTo)}`
     );
+  } else if (params.clearValidTo === true) {
+    setParts.push(sql`${quotedColumn(edges.validTo)} = NULL`);
   } else if (params.validTo !== void 0) {
     setParts.push(sql`${quotedColumn(edges.validTo)} = ${params.validTo}`);
   }
@@ -1543,12 +1621,16 @@ function buildUpdateEdge(tables, params, timestamp) {
     edges.validFrom,
     params.expectedValidFrom
   );
+  const expectedValidTo = expectedValidFromPredicate(
+    edges.validTo,
+    params.expectedValidTo
+  );
   if (params.clearDeleted) {
     return sql`
       UPDATE ${edges}
       SET ${setClause}
       WHERE ${edges.graphId} = ${params.graphId}
-        AND ${edges.id} = ${params.id}${expectedIdentity}${expectedValidFrom}
+        AND ${edges.id} = ${params.id}${expectedIdentity}${expectedValidFrom}${expectedValidTo}
       RETURNING *
     `;
   }
@@ -1556,7 +1638,7 @@ function buildUpdateEdge(tables, params, timestamp) {
     UPDATE ${edges}
     SET ${setClause}
     WHERE ${edges.graphId} = ${params.graphId}
-      AND ${edges.id} = ${params.id}${expectedIdentity}${expectedValidFrom}
+      AND ${edges.id} = ${params.id}${expectedIdentity}${expectedValidFrom}${expectedValidTo}
       AND ${edges.deletedAt} IS NULL
     RETURNING *
   `;
@@ -1818,6 +1900,8 @@ function buildUpdateNode(tables, params, timestamp) {
       sql`${quotedColumn(nodes.validFrom)} = ${sqlNull(resolveValidFrom(params.validFrom, timestamp))}`,
       sql`${quotedColumn(nodes.validTo)} = ${sqlNull(params.validTo)}`
     );
+  } else if (params.clearValidTo === true) {
+    setParts.push(sql`${quotedColumn(nodes.validTo)} = NULL`);
   } else if (params.validTo !== void 0) {
     setParts.push(sql`${quotedColumn(nodes.validTo)} = ${params.validTo}`);
   }
@@ -3372,5 +3456,5 @@ function getOrCreateLru(cache, key, cacheMax, create) {
 }
 
 export { EMBEDDING_UPSERT_PARAM_COUNT, FIND_EDGES_ENDPOINT_FIXED_PARAM_COUNT, POSTGRES_CONTRIBUTION_MAT_TIMESTAMPS, POSTGRES_INDEX_MAT_TIMESTAMPS, POSTGRES_KIND_REMOVAL_TIMESTAMPS, SQLITE_CONTRIBUTION_MAT_TIMESTAMPS, SQLITE_INDEX_MAT_TIMESTAMPS, SQLITE_KIND_REMOVAL_TIMESTAMPS, analyzeImportedTables, assertActiveSchemaVersion, assertAdoptedDialect, assertTrustedImportDatabaseEmpty, buildContributionInsertValues, buildContributionOnConflictSet, buildKindRemovalInsertValues, buildKindRemovalOnConflictSet, buildLiveNodeCandidates, buildMaterializationInsertValues, buildMaterializationOnConflictSet, commitSchemaVersionIfKindsEmpty, contributionRebuildSupported, createCachedTableExistence, createCommonOperationBackend, createContributionMaterializer, createPostgresOperationStrategy, createPostgresTrustedImportSession, createSqliteOperationStrategy, createSqliteTrustedImportSession, gateFulltext, gateFulltextMethods, getOrCreateLru, lockPostgresTrustedImportTables, mapContributionMaterializationRow, mapHybridSearchRow, mapKindRemovalRow, mapMaterializationRow, mapVectorWriteError, restoreSecondaryIndexes, suspendPostgresSecondaryIndexes, suspendSqliteSecondaryIndexes, tableExistsFromRow, vectorSlotFromCreateIndexParams, vectorSlotFromDropIndexParams, vectorSlotFromParams };
-//# sourceMappingURL=chunk-7VQXLT5O.js.map
-//# sourceMappingURL=chunk-7VQXLT5O.js.map
+//# sourceMappingURL=chunk-KH7XW7VV.js.map
+//# sourceMappingURL=chunk-KH7XW7VV.js.map