@nicia-ai/typegraph 0.46.2 → 0.48.0

package/dist/{chunk-32UETY6S.cjs → chunk-3KOY4FH3.cjs}

@@ -1,20 +1,21 @@
 'use strict';
 
-var chunkANKOXPCC_cjs = require('./chunk-ANKOXPCC.cjs');
-var chunkZBVZ7HXD_cjs = require('./chunk-ZBVZ7HXD.cjs');
-var chunk2ZWM2RFH_cjs = require('./chunk-2ZWM2RFH.cjs');
+var chunkEZEEWCFJ_cjs = require('./chunk-EZEEWCFJ.cjs');
+var chunk5PRKMB24_cjs = require('./chunk-5PRKMB24.cjs');
+var chunkFQPEMEWX_cjs = require('./chunk-FQPEMEWX.cjs');
+var chunkEDN4Y4ZG_cjs = require('./chunk-EDN4Y4ZG.cjs');
 var chunkHAHNRASW_cjs = require('./chunk-HAHNRASW.cjs');
-var chunkKCH7WQA5_cjs = require('./chunk-KCH7WQA5.cjs');
+var chunkMRDBBHIZ_cjs = require('./chunk-MRDBBHIZ.cjs');
 var chunkN66HCGCY_cjs = require('./chunk-N66HCGCY.cjs');
 
 // src/store/types.ts
 var AUTO_REFRESH_STATISTICS_ROW_THRESHOLD = 1e3;
-var TRANSACTION_RUNTIME = chunk2ZWM2RFH_cjs.typeGraphGlobalSymbol(
+var TRANSACTION_RUNTIME = chunkEDN4Y4ZG_cjs.typeGraphGlobalSymbol(
   "transaction-runtime-v1"
 );
 
 // src/store/runtime-port.ts
-var STORE_RUNTIME = chunk2ZWM2RFH_cjs.typeGraphGlobalSymbol("store-runtime-v1");
+var STORE_RUNTIME = chunkEDN4Y4ZG_cjs.typeGraphGlobalSymbol("store-runtime-v1");
 function storeRuntime(store) {
   const runtime = store[STORE_RUNTIME];
   if (runtime === void 0) {
@@ -301,8 +302,182 @@ async function deleteNodeFulltext(ctx, schema) {
 function createUniquenessContext(graphId, registry, backend) {
   return { graphId, registry, backend };
 }
+function nodeIdentityKey(reference) {
+  return chunkEZEEWCFJ_cjs.encodeTupleKey([reference.kind, reference.id]);
+}
+function proposedUniqueClaims(ctx, upserts) {
+  const claims = [];
+  const claimsByCheckedKind = /* @__PURE__ */ new Map();
+  const claimsByOwnKind = /* @__PURE__ */ new Map();
+  const orderedConstraints = [];
+  const seenConstraints = /* @__PURE__ */ new Set();
+  for (const upsert of upserts) {
+    for (const constraint of upsert.constraints) {
+      if (seenConstraints.has(constraint)) continue;
+      seenConstraints.add(constraint);
+      orderedConstraints.push(constraint);
+    }
+  }
+  for (const constraint of orderedConstraints) {
+    for (const upsert of upserts) {
+      if (!upsert.constraints.includes(constraint)) continue;
+      if (!chunkFQPEMEWX_cjs.checkWherePredicate(constraint, upsert.props)) continue;
+      const claim = {
+        kind: upsert.kind,
+        id: upsert.id,
+        constraint,
+        key: chunkFQPEMEWX_cjs.computeUniqueKey(
+          upsert.props,
+          constraint.fields,
+          constraint.collation
+        ),
+        kindsToCheck: chunkFQPEMEWX_cjs.getKindsForUniquenessCheck(
+          upsert.kind,
+          constraint.scope,
+          ctx.registry
+        )
+      };
+      const identity = nodeIdentityKey(claim);
+      const candidateGroups = [
+        claimsByCheckedKind.get(
+          chunkEZEEWCFJ_cjs.encodeTupleKey([constraint.name, claim.key, claim.kind])
+        ) ?? [],
+        ...claim.kindsToCheck.map(
+          (kind) => claimsByOwnKind.get(
+            chunkEZEEWCFJ_cjs.encodeTupleKey([constraint.name, claim.key, kind])
+          ) ?? []
+        )
+      ];
+      const collision = candidateGroups.flat().find((existing) => nodeIdentityKey(existing) !== identity);
+      if (collision !== void 0) {
+        throw new chunkMRDBBHIZ_cjs.UniquenessError({
+          constraintName: constraint.name,
+          kind: collision.kind,
+          existingId: collision.id,
+          newId: upsert.id,
+          fields: constraint.fields
+        });
+      }
+      claims.push(claim);
+      const ownKindKey = chunkEZEEWCFJ_cjs.encodeTupleKey([
+        constraint.name,
+        claim.key,
+        claim.kind
+      ]);
+      const sameKindClaims = claimsByOwnKind.get(ownKindKey);
+      if (sameKindClaims === void 0) {
+        claimsByOwnKind.set(ownKindKey, [claim]);
+      } else {
+        sameKindClaims.push(claim);
+      }
+      for (const kind of claim.kindsToCheck) {
+        const checkedKindKey = chunkEZEEWCFJ_cjs.encodeTupleKey([
+          constraint.name,
+          claim.key,
+          kind
+        ]);
+        const sameDomainClaims = claimsByCheckedKind.get(checkedKindKey);
+        if (sameDomainClaims === void 0) {
+          claimsByCheckedKind.set(checkedKindKey, [claim]);
+        } else {
+          sameDomainClaims.push(claim);
+        }
+      }
+    }
+  }
+  return claims;
+}
+function groupUniqueClaimsForBatchProbe(claims) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const claim of claims) {
+    for (const nodeKind of claim.kindsToCheck) {
+      const groupKey = chunkEZEEWCFJ_cjs.encodeTupleKey([nodeKind, claim.constraint.name]);
+      const existing = groups.get(groupKey);
+      if (existing === void 0) {
+        groups.set(groupKey, {
+          nodeKind,
+          constraintName: claim.constraint.name,
+          claimsByKey: /* @__PURE__ */ new Map([[claim.key, claim]])
+        });
+        continue;
+      }
+      existing.claimsByKey.set(claim.key, claim);
+    }
+  }
+  return [...groups.values()];
+}
+async function validateResolvedNodeUniqueness(ctx, upserts, releases = []) {
+  const checkUniqueBatch = ctx.backend.checkUniqueBatch;
+  if (checkUniqueBatch === void 0) {
+    throw new chunkMRDBBHIZ_cjs.ConfigurationError(
+      "Resolved node writes require batched uniqueness probes",
+      { code: "RESOLVED_NODE_UNIQUENESS_UNSUPPORTED" }
+    );
+  }
+  const claims = proposedUniqueClaims(ctx, upserts);
+  if (claims.length === 0) return;
+  const affectedOwners = new Set(
+    [...upserts, ...releases].map((reference) => nodeIdentityKey(reference))
+  );
+  for (const group of groupUniqueClaimsForBatchProbe(claims)) {
+    const existingRows = await checkUniqueBatch({
+      graphId: ctx.graphId,
+      nodeKind: group.nodeKind,
+      constraintName: group.constraintName,
+      keys: [...group.claimsByKey.keys()]
+    });
+    for (const existing of existingRows) {
+      if (affectedOwners.has(
+        nodeIdentityKey({
+          kind: existing.concrete_kind,
+          id: existing.node_id
+        })
+      )) {
+        continue;
+      }
+      const claim = group.claimsByKey.get(existing.key);
+      if (claim === void 0) continue;
+      throw new chunkMRDBBHIZ_cjs.UniquenessError({
+        constraintName: group.constraintName,
+        kind: group.nodeKind,
+        existingId: existing.node_id,
+        newId: claim.id,
+        fields: claim.constraint.fields
+      });
+    }
+  }
+}
+async function prepareResolvedNodeUniqueness(ctx, upserts, releases) {
+  const hardDeleteUniquesByNodeIds = ctx.backend.hardDeleteUniquesByNodeIds;
+  if (ctx.backend.checkUniqueBatch === void 0 || ctx.backend.insertUniqueBatch === void 0 || hardDeleteUniquesByNodeIds === void 0) {
+    throw new chunkMRDBBHIZ_cjs.ConfigurationError(
+      "Resolved node writes require batched uniqueness operations",
+      { code: "RESOLVED_NODE_UNIQUENESS_UNSUPPORTED" }
+    );
+  }
+  await validateResolvedNodeUniqueness(ctx, upserts, releases);
+  const idsByKind = /* @__PURE__ */ new Map();
+  for (const reference of [...upserts, ...releases]) {
+    const ids = idsByKind.get(reference.kind) ?? /* @__PURE__ */ new Set();
+    ids.add(reference.id);
+    idsByKind.set(reference.kind, ids);
+  }
+  for (const [concreteKind, nodeIds] of idsByKind) {
+    await hardDeleteUniquesByNodeIds({
+      graphId: ctx.graphId,
+      concreteKind,
+      nodeIds: [...nodeIds]
+    });
+  }
+}
+async function applyResolvedNodeUniqueness(ctx, upserts, releases, apply) {
+  await prepareResolvedNodeUniqueness(ctx, upserts, releases);
+  const result = await apply();
+  await insertUniquenessEntriesBatch(ctx, upserts);
+  return result;
+}
 async function probeUniqueKey(ctx, kind, id, constraint, key) {
-  const kindsToCheck = chunkZBVZ7HXD_cjs.getKindsForUniquenessCheck(
+  const kindsToCheck = chunkFQPEMEWX_cjs.getKindsForUniquenessCheck(
     kind,
     constraint.scope,
     ctx.registry
@@ -317,7 +492,7 @@ async function probeUniqueKey(ctx, kind, id, constraint, key) {
     });
     if (existing === void 0) continue;
     if (existing.node_id !== id) {
-      throw new chunkKCH7WQA5_cjs.UniquenessError({
+      throw new chunkMRDBBHIZ_cjs.UniquenessError({
         constraintName: constraint.name,
         kind: kindToCheck,
         existingId: existing.node_id,
@@ -331,7 +506,7 @@ async function probeUniqueKey(ctx, kind, id, constraint, key) {
 }
 async function checkUniquenessConstraints(ctx, kind, id, props, constraints) {
   for (const constraint of constraints) {
-    if (!chunkZBVZ7HXD_cjs.checkWherePredicate(constraint, props)) {
+    if (!chunkFQPEMEWX_cjs.checkWherePredicate(constraint, props)) {
       continue;
     }
     await probeUniqueKey(
@@ -339,16 +514,16 @@ async function checkUniquenessConstraints(ctx, kind, id, props, constraints) {
       kind,
       id,
       constraint,
-      chunkZBVZ7HXD_cjs.computeUniqueKey(props, constraint.fields, constraint.collation)
+      chunkFQPEMEWX_cjs.computeUniqueKey(props, constraint.fields, constraint.collation)
     );
   }
 }
 async function insertUniquenessEntries(ctx, kind, id, props, constraints) {
   for (const constraint of constraints) {
-    if (!chunkZBVZ7HXD_cjs.checkWherePredicate(constraint, props)) {
+    if (!chunkFQPEMEWX_cjs.checkWherePredicate(constraint, props)) {
       continue;
     }
-    const key = chunkZBVZ7HXD_cjs.computeUniqueKey(
+    const key = chunkFQPEMEWX_cjs.computeUniqueKey(
       props,
       constraint.fields,
       constraint.collation
@@ -367,14 +542,14 @@ async function insertUniquenessEntriesBatch(ctx, items) {
   const entries = [];
   for (const item of items) {
     for (const constraint of item.constraints) {
-      if (!chunkZBVZ7HXD_cjs.checkWherePredicate(constraint, item.props)) {
+      if (!chunkFQPEMEWX_cjs.checkWherePredicate(constraint, item.props)) {
         continue;
       }
       entries.push({
         graphId: ctx.graphId,
         nodeKind: item.kind,
         constraintName: constraint.name,
-        key: chunkZBVZ7HXD_cjs.computeUniqueKey(
+        key: chunkFQPEMEWX_cjs.computeUniqueKey(
           item.props,
           constraint.fields,
           constraint.collation
@@ -395,10 +570,10 @@ async function insertUniquenessEntriesBatch(ctx, items) {
 }
 async function deleteUniquenessEntries(ctx, kind, props, constraints) {
   for (const constraint of constraints) {
-    if (!chunkZBVZ7HXD_cjs.checkWherePredicate(constraint, props)) {
+    if (!chunkFQPEMEWX_cjs.checkWherePredicate(constraint, props)) {
       continue;
     }
-    const key = chunkZBVZ7HXD_cjs.computeUniqueKey(
+    const key = chunkFQPEMEWX_cjs.computeUniqueKey(
       props,
       constraint.fields,
       constraint.collation
@@ -414,10 +589,10 @@ async function deleteUniquenessEntries(ctx, kind, props, constraints) {
 async function planUniquenessUpdate(ctx, kind, id, oldProps, newProps, constraints) {
   const pending = [];
   for (const constraint of constraints) {
-    const oldApplies = chunkZBVZ7HXD_cjs.checkWherePredicate(constraint, oldProps);
-    const newApplies = chunkZBVZ7HXD_cjs.checkWherePredicate(constraint, newProps);
-    const oldKey = oldApplies ? chunkZBVZ7HXD_cjs.computeUniqueKey(oldProps, constraint.fields, constraint.collation) : void 0;
-    const newKey = newApplies ? chunkZBVZ7HXD_cjs.computeUniqueKey(newProps, constraint.fields, constraint.collation) : void 0;
+    const oldApplies = chunkFQPEMEWX_cjs.checkWherePredicate(constraint, oldProps);
+    const newApplies = chunkFQPEMEWX_cjs.checkWherePredicate(constraint, newProps);
+    const oldKey = oldApplies ? chunkFQPEMEWX_cjs.computeUniqueKey(oldProps, constraint.fields, constraint.collation) : void 0;
+    const newKey = newApplies ? chunkFQPEMEWX_cjs.computeUniqueKey(newProps, constraint.fields, constraint.collation) : void 0;
     if (!oldApplies && !newApplies) {
       continue;
     }
@@ -436,8 +611,8 @@ async function planUniquenessUpdate(ctx, kind, id, oldProps, newProps, constrain
 async function planUniquenessReinsert(ctx, kind, id, props, constraints) {
   const pending = [];
   for (const constraint of constraints) {
-    if (!chunkZBVZ7HXD_cjs.checkWherePredicate(constraint, props)) continue;
-    const key = chunkZBVZ7HXD_cjs.computeUniqueKey(
+    if (!chunkFQPEMEWX_cjs.checkWherePredicate(constraint, props)) continue;
+    const key = chunkFQPEMEWX_cjs.computeUniqueKey(
       props,
       constraint.fields,
       constraint.collation
@@ -518,7 +693,7 @@ async function enforceNodeDeleteBehavior(ctx, args, backend, policy) {
   if (connectedEdges.length === 0) return;
   switch (behavior) {
     case "restrict": {
-      throw new chunkKCH7WQA5_cjs.RestrictedDeleteError({
+      throw new chunkMRDBBHIZ_cjs.RestrictedDeleteError({
         nodeKind: args.kind,
         nodeId: args.id,
         edgeCount: connectedEdges.length,
@@ -591,7 +766,7 @@ async function applyNodeInsertSideEffectsBatch(ctx, items, backend) {
   );
 }
 function parseRowProps(row) {
-  return chunkANKOXPCC_cjs.rowPropsToObject(row.props);
+  return chunk5PRKMB24_cjs.rowPropsToObject(row.props);
 }
 async function planNodeUpdateUniqueness(ctx, args, backend) {
   const { kind, id } = args.existing;
@@ -632,7 +807,6 @@ async function applyNodeUpdate(ctx, args, backend) {
     incrementVersion: true
   };
   if (args.validFrom !== void 0) updateParams.validFrom = args.validFrom;
-  if (args.validTo !== void 0) updateParams.validTo = args.validTo;
   if (args.expectedValidFrom !== void 0) {
     updateParams.expectedValidFrom = args.expectedValidFrom;
   }
@@ -642,7 +816,10 @@ async function applyNodeUpdate(ctx, args, backend) {
     kind,
     id,
     plan,
-    () => backend.updateNode(updateParams)
+    () => backend.updateNode({
+      ...updateParams,
+      ...args.clearValidTo === true ? { clearValidTo: true } : args.validTo === void 0 ? {} : { validTo: args.validTo }
+    })
   );
   await Promise.all([
     syncEmbeddings(
@@ -742,6 +919,7 @@ exports.applyNodeInsertSideEffectsBatch = applyNodeInsertSideEffectsBatch;
 exports.applyNodeResurrect = applyNodeResurrect;
 exports.applyNodeSoftDelete = applyNodeSoftDelete;
 exports.applyNodeUpdate = applyNodeUpdate;
+exports.applyResolvedNodeUniqueness = applyResolvedNodeUniqueness;
 exports.checkUniquenessConstraints = checkUniquenessConstraints;
 exports.computeFulltextContent = computeFulltextContent;
 exports.createNodeWriteContext = createNodeWriteContext;
@@ -751,5 +929,6 @@ exports.storeBackend = storeBackend;
 exports.storeRuntime = storeRuntime;
 exports.transactionBackend = transactionBackend;
 exports.transactionNodeOperationHookRunner = transactionNodeOperationHookRunner;
-//# sourceMappingURL=chunk-32UETY6S.cjs.map
-//# sourceMappingURL=chunk-32UETY6S.cjs.map
+exports.validateResolvedNodeUniqueness = validateResolvedNodeUniqueness;
+//# sourceMappingURL=chunk-3KOY4FH3.cjs.map
+//# sourceMappingURL=chunk-3KOY4FH3.cjs.map