@nicia-ai/typegraph 0.35.0 → 0.36.0

package/dist/{chunk-CZQ3FO2Q.js → chunk-5VTR2F2K.js}

@@ -1,9 +1,9 @@
 import { asCompiledRowsSql, asCompiledStatementSql } from './chunk-UT3S4SEN.js';
-import { createBackendOverlay, isPresent, rowPropsToObject, groupBy, chunk, sqlValueList, rowPropsToJsonText } from './chunk-JBTOYDMN.js';
-import { validateCanonicalIsoDate, withRecordedRelationsPrecondition, nowIso } from './chunk-I7ZUZKFD.js';
+import { createBackendOverlay, isPresent, rowPropsToObject, groupBy, chunk, sqlValueList, rowPropsToJsonText } from './chunk-IU46OHVW.js';
+import { validateCanonicalIsoDate, withRecordedRelationsPrecondition, nowIso } from './chunk-JFUPDJXD.js';
 import { MAX_PG_IDENTIFIER_LENGTH, sqlNull } from './chunk-OHMP6N2J.js';
 import { resolveEmbeddingFields, getSearchableFields, DEFAULT_SEARCHABLE_LANGUAGE } from './chunk-KBGQIPRQ.js';
-import { ConfigurationError, ValidationError, CardinalityError, EndpointError, DisjointError, UniquenessError, RestrictedDeleteError } from './chunk-MP2JQKSG.js';
+import { ConfigurationError, ValidationError, CardinalityError, EndpointError, DisjointError, UniquenessError, RestrictedDeleteError } from './chunk-WI7ISNQF.js';
 import { sql } from 'drizzle-orm';
 import { nanoid } from 'nanoid';
 
@@ -355,10 +355,13 @@ async function assertRecordedCaptureTransactionIsolation(target) {
   if (isSupportedRecordedIsolationLevel(isolationLevel)) return;
   throw unsupportedPostgresIsolationError(isolationLevel);
 }
-function recordedCaptureRequiresCallbackTransactionError(details) {
+function recordedCaptureRequiresCallbackTransactionError(details = {}) {
   return new ConfigurationError(
     "withTransaction() has no recorded-time capture flush point when history is enabled.",
-    details,
+    {
+      ...details,
+      code: "RECORDED_CAPTURE_REQUIRES_CALLBACK_TRANSACTION"
+    },
     {
       suggestion: "Use store.withRecordedTransaction(externalTx, async (tx) => ...) so TypeGraph can flush capture before the caller commits."
     }
@@ -367,7 +370,9 @@ function recordedCaptureRequiresCallbackTransactionError(details) {
 function historyUnsafeRawWriteError(surface) {
   return new ConfigurationError(
     `${surface} is not available when history capture is enabled because raw SQL writes bypass recorded-time capture.`,
-    { code: "RECORDED_CAPTURE_RAW_SQL_DISABLED" },
+    {
+      code: "RECORDED_CAPTURE_RAW_SQL_DISABLED"
+    },
     {
       suggestion: "Run graph writes through store.nodes/store.edges (or tx.nodes/tx.edges inside a transaction), or perform raw relational writes outside a history-enabled TypeGraph store."
     }
@@ -376,7 +381,9 @@ function historyUnsafeRawWriteError(surface) {
 function revisionTrackingUnsafeRawWriteError(surface) {
   return new ConfigurationError(
     `${surface} is not available when revision tracking is enabled because raw SQL writes bypass the revision anchor.`,
-    { code: "REVISION_TRACKING_RAW_SQL_DISABLED" },
+    {
+      code: "REVISION_TRACKING_RAW_SQL_DISABLED"
+    },
     {
       suggestion: "Run graph writes through store.nodes/store.edges (or tx.nodes/tx.edges inside a transaction), so TypeGraph can advance the revision anchor."
     }
@@ -1186,22 +1193,32 @@ function edgeParamsIdentityKey(params) {
 function edgeRowIdentityKey(row) {
   return edgeIdentityKey(row.graph_id, row.id);
 }
+function recordedCaptureSealedError(details) {
+  return new ConfigurationError(
+    "Recorded-time capture session is sealed: a graph write happened after the transaction's capture was flushed.",
+    details,
+    {
+      suggestion: "Perform all writes inside the withRecordedTransaction callback; do not reuse the transaction context after it returns."
+    }
+  );
+}
 function createRecordedCaptureSession() {
   const touched = /* @__PURE__ */ new Map();
   let sealed = false;
   function touch(entity) {
     if (sealed) {
-      throw new ConfigurationError(
-        "Recorded-time capture session is sealed: a graph write happened after the transaction's capture was flushed.",
-        { entity: entity.entity, graphId: entity.graphId, id: entity.id },
-        {
-          suggestion: "Perform all writes inside the withRecordedTransaction callback; do not reuse the transaction context after it returns."
-        }
-      );
+      throw recordedCaptureSealedError({
+        entity: entity.entity,
+        graphId: entity.graphId,
+        id: entity.id
+      });
     }
     touched.set(entityKey(entity), entity);
   }
   return {
+    assertOpen() {
+      if (sealed) throw recordedCaptureSealedError({});
+    },
     touchNode(graphId, kind, id, afterImage) {
       touch({ entity: "node", graphId, kind, id, afterImage });
     },
@@ -1262,6 +1279,7 @@ function createRecordedTransactionBackend(target, session, schema) {
   const overlay = createBackendOverlay(target, {
     ...rawWriteGuards(target, "tx.backend"),
     async insertNode(params) {
+      session.assertOpen();
       await lockGraph(params.graphId);
       const row = await target.insertNode(params);
       session.touchNode(params.graphId, params.kind, params.id, row);
@@ -1269,6 +1287,7 @@ function createRecordedTransactionBackend(target, session, schema) {
     },
     ...target.insertNodeNoReturn === void 0 ? {} : {
       async insertNodeNoReturn(params) {
+        session.assertOpen();
         await lockGraph(params.graphId);
         await runInsertNoReturn(nodeDispatch, params);
         session.touchNode(params.graphId, params.kind, params.id);
@@ -1276,6 +1295,7 @@ function createRecordedTransactionBackend(target, session, schema) {
     },
     ...target.insertNodesBatch === void 0 ? {} : {
       async insertNodesBatch(params) {
+        session.assertOpen();
         await lockGraphs(params);
         await runInsertBatch(nodeDispatch, params);
         for (const node of params) {
@@ -1285,6 +1305,7 @@ function createRecordedTransactionBackend(target, session, schema) {
     },
     ...target.insertNodesBatchReturning === void 0 ? {} : {
       async insertNodesBatchReturning(params) {
+        session.assertOpen();
         await lockGraphs(params);
         const rows = await runInsertBatchReturning(nodeDispatch, params);
         const rowsByIdentity = new Map(
@@ -1302,17 +1323,20 @@ function createRecordedTransactionBackend(target, session, schema) {
       }
     },
     async updateNode(params) {
+      session.assertOpen();
       await lockGraph(params.graphId);
       const row = await target.updateNode(params);
       session.touchNode(params.graphId, params.kind, params.id, row);
       return row;
     },
     async deleteNode(params) {
+      session.assertOpen();
       await lockGraph(params.graphId);
       await target.deleteNode(params);
       session.touchNode(params.graphId, params.kind, params.id);
     },
     async hardDeleteNode(params) {
+      session.assertOpen();
       await lockGraph(params.graphId);
       const connectedEdgeIds = await queryConnectedEdgeIds(
         target,
@@ -1326,6 +1350,7 @@ function createRecordedTransactionBackend(target, session, schema) {
       }
     },
     async insertEdge(params) {
+      session.assertOpen();
       await lockGraph(params.graphId);
       const row = await target.insertEdge(params);
       session.touchEdge(params.graphId, params.id, row);
@@ -1333,6 +1358,7 @@ function createRecordedTransactionBackend(target, session, schema) {
     },
     ...target.insertEdgeNoReturn === void 0 ? {} : {
       async insertEdgeNoReturn(params) {
+        session.assertOpen();
         await lockGraph(params.graphId);
         await runInsertNoReturn(edgeDispatch, params);
         session.touchEdge(params.graphId, params.id);
@@ -1340,6 +1366,7 @@ function createRecordedTransactionBackend(target, session, schema) {
     },
     ...target.insertEdgesBatch === void 0 ? {} : {
       async insertEdgesBatch(params) {
+        session.assertOpen();
         await lockGraphs(params);
         await runInsertBatch(edgeDispatch, params);
         for (const edge of params) {
@@ -1349,6 +1376,7 @@ function createRecordedTransactionBackend(target, session, schema) {
     },
     ...target.insertEdgesBatchReturning === void 0 ? {} : {
       async insertEdgesBatchReturning(params) {
+        session.assertOpen();
         await lockGraphs(params);
         const rows = await runInsertBatchReturning(edgeDispatch, params);
         const rowsByIdentity = new Map(
@@ -1365,23 +1393,27 @@ function createRecordedTransactionBackend(target, session, schema) {
       }
     },
     async updateEdge(params) {
+      session.assertOpen();
       await lockGraph(params.graphId);
       const row = await target.updateEdge(params);
       session.touchEdge(params.graphId, params.id, row);
       return row;
     },
     async deleteEdge(params) {
+      session.assertOpen();
       await lockGraph(params.graphId);
       await target.deleteEdge(params);
       session.touchEdge(params.graphId, params.id);
     },
     async hardDeleteEdge(params) {
+      session.assertOpen();
       await lockGraph(params.graphId);
       await target.hardDeleteEdge(params);
       session.touchEdge(params.graphId, params.id);
     },
     ...target.deleteEdgesBatch === void 0 ? {} : {
       async deleteEdgesBatch(params) {
+        session.assertOpen();
         await lockGraph(params.graphId);
         await target.deleteEdgesBatch(params);
         for (const id of params.ids) {
@@ -1391,6 +1423,7 @@ function createRecordedTransactionBackend(target, session, schema) {
     },
     ...target.hardDeleteEdgesBatch === void 0 ? {} : {
       async hardDeleteEdgesBatch(params) {
+        session.assertOpen();
         await lockGraph(params.graphId);
         await target.hardDeleteEdgesBatch(params);
         for (const id of params.ids) {
@@ -2316,5 +2349,5 @@ async function applyNodeResurrect(ctx, args, backend) {
 }
 
 export { ALIAS_CTE_PREFIX, DEFAULT_SQL_SCHEMA, EMBEDDINGS_CTE_ALIAS, FULLTEXT_CTE_ALIAS, HYBRID_CANDIDATES_CTE_ALIAS, advanceRevisionClock, applyNodeHardDelete, applyNodeInsertSideEffects, applyNodeInsertSideEffectsBatch, applyNodeResurrect, applyNodeSoftDelete, applyNodeUpdate, asRecordedInstant, assertRecordedCaptureTransactionIsolation, assertRevisionTrackableBackend, assertValidRecordedInstant, checkCardinality, checkDisjointness, checkUniqueEdge, checkUniquenessConstraints, checkWherePredicate, closeRecordedHardDeletedKind, computeFulltextContent, computeUniqueKey, coordinateContext, createHistoryUnsafeSqlRef, createNodeWriteContext, createRecordedBackend, createRecordedReadBinding, createRecordedTransactionScope, createRevisionTrackingUnsafeSqlRef, createSqlSchema, createUniquenessContext, describeCoordinate, edgeInsertDispatch, ensureRevisionOrigin, generateId, getEdgeRowsByIds, getEmbeddingFields, getKindsForUniquenessCheck, getNodeRowsByIds, lockRecordedGraphWrite, nodeInsertDispatch, readRecordedClock, readRevisionOrigin, recordedBindParamBudget, recordedCaptureRequiresCallbackTransactionError, recordedReadSchemaFor, recordedReadSqlSchema, recordedRelation, requireExternalRecordedReadSource, requireRecordedReadBinding, requireSqlSchema, resolveReadCoordinate, runInsertBatch, runInsertBatchReturning, runInsertNoReturn, uncapturedGraphWriteLock, validateEdgeEndpoints, vectorSlotKey, withRecordedCoordinate, withRecordedFlushObserver };
-//# sourceMappingURL=chunk-CZQ3FO2Q.js.map
-//# sourceMappingURL=chunk-CZQ3FO2Q.js.map
+//# sourceMappingURL=chunk-5VTR2F2K.js.map
+//# sourceMappingURL=chunk-5VTR2F2K.js.map