@nicia-ai/typegraph 0.47.0 → 0.48.0

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

@@ -1,6 +1,7 @@
 'use strict';
 
-var chunk3HGRTCDU_cjs = require('./chunk-3HGRTCDU.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');
@@ -301,6 +302,180 @@ 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 = chunkFQPEMEWX_cjs.getKindsForUniquenessCheck(
     kind,
@@ -591,7 +766,7 @@ async function applyNodeInsertSideEffectsBatch(ctx, items, backend) {
   );
 }
 function parseRowProps(row) {
-  return chunk3HGRTCDU_cjs.rowPropsToObject(row.props);
+  return chunk5PRKMB24_cjs.rowPropsToObject(row.props);
 }
 async function planNodeUpdateUniqueness(ctx, args, backend) {
   const { kind, id } = args.existing;
@@ -744,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;
@@ -753,5 +929,6 @@ exports.storeBackend = storeBackend;
 exports.storeRuntime = storeRuntime;
 exports.transactionBackend = transactionBackend;
 exports.transactionNodeOperationHookRunner = transactionNodeOperationHookRunner;
-//# sourceMappingURL=chunk-MFZR4QKM.cjs.map
-//# sourceMappingURL=chunk-MFZR4QKM.cjs.map
+exports.validateResolvedNodeUniqueness = validateResolvedNodeUniqueness;
+//# sourceMappingURL=chunk-3KOY4FH3.cjs.map
+//# sourceMappingURL=chunk-3KOY4FH3.cjs.map