@nicia-ai/typegraph 0.33.0 → 0.35.0

package/dist/chunk-QNKSQTKQ.js

@@ -0,0 +1,1312 @@
+import { validateNodeProps } from './chunk-QWEUYILR.js';
+import { getDialect, compileNodeIndexFieldKeys, compileIndexWhere } from './chunk-FPIZFYHE.js';
+import { filterReservedKeys, RESERVED_NODE_KEYS, RESERVED_EDGE_KEYS } from './chunk-RGPG7EOJ.js';
+import { lockRecordedGraphWrite, uncapturedGraphWriteLock, advanceRevisionClock, checkCardinality, checkUniqueEdge, checkWherePredicate, computeUniqueKey, getKindsForUniquenessCheck, runInsertBatch, nodeInsertDispatch, runInsertBatchReturning, applyNodeSoftDelete, createNodeWriteContext, applyNodeHardDelete, createSqlSchema, DEFAULT_SQL_SCHEMA, getNodeRowsByIds, generateId, runInsertNoReturn, applyNodeInsertSideEffectsBatch, applyNodeUpdate, applyNodeInsertSideEffects, checkUniquenessConstraints, createUniquenessContext, checkDisjointness } from './chunk-CZQ3FO2Q.js';
+import { asCompiledRowsSql } from './chunk-UT3S4SEN.js';
+import { rowPropsToObject, runOptionallyInTransaction, createBackendOverlay, isLiveNodeRow } from './chunk-JBTOYDMN.js';
+import { validateOptionalCanonicalIsoDate } from './chunk-I7ZUZKFD.js';
+import { DatabaseOperationError, UniquenessError, ConfigurationError, ValidationError, NodeNotFoundError, KindNotFoundError, NodeConstraintNotFoundError, NodeIndexNotFoundError } from './chunk-MP2JQKSG.js';
+import { resolveJsonPointer } from './chunk-G6Q5UM7U.js';
+import { sql } from 'drizzle-orm';
+
+// src/store/row-mappers.ts
+function nullToUndefined(value) {
+  return value === null ? void 0 : value;
+}
+function rowToNode(row) {
+  const rawProps = rowPropsToObject(row.props);
+  const props = filterReservedKeys(rawProps, RESERVED_NODE_KEYS);
+  return {
+    kind: row.kind,
+    id: row.id,
+    meta: rowToNodeMeta(row),
+    ...props
+  };
+}
+function rowToNodeMeta(row) {
+  return {
+    version: row.version,
+    validFrom: nullToUndefined(row.valid_from),
+    validTo: nullToUndefined(row.valid_to),
+    createdAt: row.created_at,
+    updatedAt: row.updated_at,
+    deletedAt: nullToUndefined(row.deleted_at)
+  };
+}
+function rowToEdge(row) {
+  const rawProps = rowPropsToObject(row.props);
+  const props = filterReservedKeys(rawProps, RESERVED_EDGE_KEYS);
+  return {
+    id: row.id,
+    kind: row.kind,
+    fromKind: row.from_kind,
+    fromId: row.from_id,
+    toKind: row.to_kind,
+    toId: row.to_id,
+    meta: rowToEdgeMeta(row),
+    ...props
+  };
+}
+function rowToEdgeMeta(row) {
+  return {
+    validFrom: nullToUndefined(row.valid_from),
+    validTo: nullToUndefined(row.valid_to),
+    createdAt: row.created_at,
+    updatedAt: row.updated_at,
+    deletedAt: nullToUndefined(row.deleted_at)
+  };
+}
+
+// src/store/operations/write-transaction.ts
+function runInWriteTransaction(ctx, backend, fn) {
+  const ownsWriteLock = "transaction" in backend && backend.capabilities.transactions;
+  return runOptionallyInTransaction(backend, async (target) => {
+    const lock = ctx.historyEnabled || ctx.revisionTrackingEnabled ? await lockRecordedGraphWrite(target, ctx.graphId) : uncapturedGraphWriteLock();
+    const result = await fn(target, lock);
+    if (ctx.revisionTrackingEnabled && !ctx.historyEnabled) {
+      await advanceRevisionClock(
+        target,
+        ctx.revisionSchema,
+        ctx.graphId,
+        ownsWriteLock
+      );
+    }
+    return result;
+  });
+}
+function runHookedWriteOperation(ctx, opContext, backend, body) {
+  return ctx.withOperationHooks(
+    opContext,
+    () => runInWriteTransaction(ctx, backend, body)
+  );
+}
+
+// src/store/constraints.ts
+async function checkDisjointnessConstraint(ctx, kind, id) {
+  const disjointKinds = ctx.registry.getDisjointKinds(kind);
+  for (const disjointKind of disjointKinds) {
+    const existing = await ctx.backend.getNode(ctx.graphId, disjointKind, id);
+    if (existing && !existing.deleted_at) {
+      const error = checkDisjointness(id, kind, [disjointKind], ctx.registry);
+      if (error) throw error;
+    }
+  }
+}
+async function checkCardinalityConstraint(ctx, edgeKind, cardinality, fromKind, fromId, toKind, toId, validTo) {
+  switch (cardinality) {
+    case "many": {
+      return;
+    }
+    case "one": {
+      const count = await ctx.backend.countEdgesFrom({
+        graphId: ctx.graphId,
+        edgeKind,
+        fromKind,
+        fromId
+      });
+      const error = checkCardinality(
+        edgeKind,
+        fromKind,
+        fromId,
+        "one",
+        count,
+        false
+      );
+      if (error) throw error;
+      return;
+    }
+    case "unique": {
+      const exists = await ctx.backend.edgeExistsBetween({
+        graphId: ctx.graphId,
+        edgeKind,
+        fromKind,
+        fromId,
+        toKind,
+        toId
+      });
+      const error = checkUniqueEdge(
+        edgeKind,
+        fromKind,
+        fromId,
+        toKind,
+        toId,
+        exists ? 1 : 0
+      );
+      if (error) throw error;
+      return;
+    }
+    case "oneActive": {
+      if (validTo !== void 0) {
+        return;
+      }
+      const count = await ctx.backend.countEdgesFrom({
+        graphId: ctx.graphId,
+        edgeKind,
+        fromKind,
+        fromId,
+        activeOnly: true
+      });
+      const error = checkCardinality(
+        edgeKind,
+        fromKind,
+        fromId,
+        "oneActive",
+        count,
+        count > 0
+      );
+      if (error) throw error;
+      return;
+    }
+  }
+}
+
+// src/store/operations/node-operations.ts
+function getNodeRegistration(graph, kind) {
+  const registration = graph.nodes[kind];
+  if (registration === void 0) throw new KindNotFoundError(kind, "node");
+  return registration;
+}
+var CACHE_KEY_SEPARATOR = "\0";
+function buildNodeCacheKey(graphId, kind, id) {
+  return `${graphId}${CACHE_KEY_SEPARATOR}${kind}${CACHE_KEY_SEPARATOR}${id}`;
+}
+function buildUniqueCacheKey(graphId, nodeKind, constraintName, key) {
+  return `${graphId}${CACHE_KEY_SEPARATOR}${nodeKind}${CACHE_KEY_SEPARATOR}${constraintName}${CACHE_KEY_SEPARATOR}${key}`;
+}
+function createNodeAlreadyExistsError(kind, id) {
+  return new ValidationError(
+    `Node already exists: ${kind}/${id}`,
+    {
+      entityType: "node",
+      kind,
+      operation: "create",
+      id,
+      issues: [{ path: "id", message: "A node with this ID already exists" }]
+    },
+    { suggestion: `Use a different ID or update the existing node.` }
+  );
+}
+function buildInsertNodeParams(graphId, kind, id, props, validFrom, validTo) {
+  const insertParams = {
+    graphId,
+    kind,
+    id,
+    props
+  };
+  if (validFrom !== void 0) insertParams.validFrom = validFrom;
+  if (validTo !== void 0) insertParams.validTo = validTo;
+  return insertParams;
+}
+function createPendingUniqueRow(graphId, nodeKind, constraintName, key, nodeId) {
+  return {
+    graph_id: graphId,
+    node_kind: nodeKind,
+    constraint_name: constraintName,
+    key,
+    node_id: nodeId,
+    concrete_kind: nodeKind,
+    deleted_at: void 0
+  };
+}
+function resolveConstraint(graph, kind, constraintName) {
+  const registration = getNodeRegistration(graph, kind);
+  const constraints = registration.unique ?? [];
+  const constraint = constraints.find(
+    (candidate) => candidate.name === constraintName
+  );
+  if (constraint === void 0) {
+    throw new NodeConstraintNotFoundError(constraintName, kind);
+  }
+  return constraint;
+}
+function createNodeBatchValidationBackend(graphId, registry, backend) {
+  const nodeCache = /* @__PURE__ */ new Map();
+  const pendingNodes = /* @__PURE__ */ new Map();
+  const uniqueCache = /* @__PURE__ */ new Map();
+  const pendingUniqueOwners = /* @__PURE__ */ new Map();
+  async function getNodeCached(lookupGraphId, kind, id) {
+    const cacheKey = buildNodeCacheKey(lookupGraphId, kind, id);
+    const pendingNode = pendingNodes.get(cacheKey);
+    if (pendingNode !== void 0) return pendingNode;
+    if (nodeCache.has(cacheKey)) return nodeCache.get(cacheKey);
+    const existing = await backend.getNode(lookupGraphId, kind, id);
+    nodeCache.set(cacheKey, existing);
+    return existing;
+  }
+  async function checkUniqueCached(params) {
+    const cacheKey = buildUniqueCacheKey(
+      params.graphId,
+      params.nodeKind,
+      params.constraintName,
+      params.key
+    );
+    const pendingOwner = pendingUniqueOwners.get(cacheKey);
+    if (pendingOwner !== void 0) {
+      return createPendingUniqueRow(
+        params.graphId,
+        params.nodeKind,
+        params.constraintName,
+        params.key,
+        pendingOwner
+      );
+    }
+    if (uniqueCache.has(cacheKey)) return uniqueCache.get(cacheKey);
+    const existing = await backend.checkUnique(params);
+    uniqueCache.set(cacheKey, existing);
+    return existing;
+  }
+  function registerPendingNode(params) {
+    const cacheKey = buildNodeCacheKey(params.graphId, params.kind, params.id);
+    pendingNodes.set(cacheKey, {
+      graph_id: params.graphId,
+      kind: params.kind,
+      id: params.id,
+      props: JSON.stringify(params.props),
+      version: 1,
+      // The simulated cached row only needs a NodeRow-shaped valid_from
+      // (string | undefined, never null) for existence/uniqueness checks,
+      // which don't inspect its value — normalize import's explicit-NULL
+      // sentinel away rather than widen this cache's row shape.
+      valid_from: params.validFrom ?? void 0,
+      valid_to: params.validTo,
+      created_at: "",
+      updated_at: "",
+      deleted_at: void 0
+    });
+  }
+  function registerPendingUniqueEntries(kind, id, props, constraints) {
+    for (const constraint of constraints) {
+      if (!checkWherePredicate(constraint, props)) continue;
+      const key = computeUniqueKey(
+        props,
+        constraint.fields,
+        constraint.collation
+      );
+      const concreteEntryKey = buildUniqueCacheKey(
+        graphId,
+        kind,
+        constraint.name,
+        key
+      );
+      pendingUniqueOwners.set(concreteEntryKey, id);
+      if (constraint.scope !== "kind") {
+        const kindsToCheck = getKindsForUniquenessCheck(
+          kind,
+          constraint.scope,
+          registry
+        );
+        for (const kindToCheck of kindsToCheck) {
+          const inheritedEntryKey = buildUniqueCacheKey(
+            graphId,
+            kindToCheck,
+            constraint.name,
+            key
+          );
+          pendingUniqueOwners.set(inheritedEntryKey, id);
+        }
+      }
+    }
+  }
+  function registerAppliedNodeUpdate(kind, id, oldProps, newProps, constraints) {
+    for (const constraint of constraints) {
+      const oldApplies = checkWherePredicate(constraint, oldProps);
+      const newApplies = checkWherePredicate(constraint, newProps);
+      const oldKey = oldApplies ? computeUniqueKey(oldProps, constraint.fields, constraint.collation) : void 0;
+      const newKey = newApplies ? computeUniqueKey(newProps, constraint.fields, constraint.collation) : void 0;
+      if (oldKey === newKey) continue;
+      const kindsToCheck = getKindsForUniquenessCheck(
+        kind,
+        constraint.scope,
+        registry
+      );
+      if (oldKey !== void 0) {
+        for (const kindToCheck of kindsToCheck) {
+          const cacheKey = buildUniqueCacheKey(
+            graphId,
+            kindToCheck,
+            constraint.name,
+            oldKey
+          );
+          pendingUniqueOwners.delete(cacheKey);
+          uniqueCache.set(cacheKey, void 0);
+        }
+      }
+      if (newKey !== void 0) {
+        for (const kindToCheck of kindsToCheck) {
+          const cacheKey = buildUniqueCacheKey(
+            graphId,
+            kindToCheck,
+            constraint.name,
+            newKey
+          );
+          pendingUniqueOwners.set(cacheKey, id);
+        }
+      }
+    }
+  }
+  function seedNodeRow(kind, id, row) {
+    const cacheKey = buildNodeCacheKey(graphId, kind, id);
+    if (nodeCache.has(cacheKey)) return;
+    nodeCache.set(cacheKey, row);
+  }
+  function seedUniqueRow(kind, constraintName, key, row) {
+    const cacheKey = buildUniqueCacheKey(graphId, kind, constraintName, key);
+    if (uniqueCache.has(cacheKey)) return;
+    uniqueCache.set(cacheKey, row);
+  }
+  const validationBackend = createBackendOverlay(backend, {
+    getNode: getNodeCached,
+    checkUnique: checkUniqueCached
+  });
+  return {
+    backend: validationBackend,
+    registerPendingNode,
+    registerPendingUniqueEntries,
+    registerAppliedNodeUpdate,
+    seedNodeRow,
+    seedUniqueRow
+  };
+}
+function draftNodeCreate(ctx, input, id, options) {
+  const kind = input.kind;
+  const registration = getNodeRegistration(ctx.graph, kind);
+  const nodeKind = registration.type;
+  const validatedProps = options?.propsPreValidated === true ? input.props : validateNodeProps(nodeKind.schema, input.props, {
+    kind,
+    operation: "create"
+  });
+  return {
+    kind,
+    id,
+    nodeKind,
+    uniqueConstraints: registration.unique ?? [],
+    validatedProps,
+    validFrom: validateOptionalCanonicalIsoDate(input.validFrom, "validFrom"),
+    validTo: validateOptionalCanonicalIsoDate(input.validTo, "validTo")
+  };
+}
+async function finishNodeCreatePreparation(ctx, draft, backend) {
+  const { kind, id, validatedProps, uniqueConstraints } = draft;
+  const existingNode = await backend.getNode(ctx.graphId, kind, id);
+  if (existingNode && !existingNode.deleted_at) {
+    throw createNodeAlreadyExistsError(kind, id);
+  }
+  const constraintContext = {
+    graphId: ctx.graphId,
+    registry: ctx.registry,
+    backend
+  };
+  await checkDisjointnessConstraint(constraintContext, kind, id);
+  await checkUniquenessConstraints(
+    createUniquenessContext(ctx.graphId, ctx.registry, backend),
+    kind,
+    id,
+    validatedProps,
+    uniqueConstraints
+  );
+  return {
+    kind,
+    id,
+    nodeKind: draft.nodeKind,
+    validatedProps,
+    uniqueConstraints,
+    insertParams: buildInsertNodeParams(
+      ctx.graphId,
+      kind,
+      id,
+      validatedProps,
+      draft.validFrom,
+      draft.validTo
+    )
+  };
+}
+async function validateAndPrepareNodeCreate(ctx, input, id, backend, options) {
+  return finishNodeCreatePreparation(
+    ctx,
+    draftNodeCreate(ctx, input, id, options),
+    backend
+  );
+}
+async function finalizeNodeCreateBatch(ctx, preparedCreates, backend, lock) {
+  await applyNodeInsertSideEffectsBatch(
+    createNodeWriteContext(ctx.graphId, ctx.registry, lock),
+    preparedCreates.map((prepared) => ({
+      kind: prepared.kind,
+      id: prepared.id,
+      schema: prepared.nodeKind.schema,
+      props: prepared.validatedProps,
+      uniqueConstraints: prepared.uniqueConstraints
+    })),
+    backend
+  );
+}
+async function finalizeNodeCreate(ctx, prepared, backend, lock) {
+  await applyNodeInsertSideEffects(
+    createNodeWriteContext(ctx.graphId, ctx.registry, lock),
+    {
+      kind: prepared.kind,
+      id: prepared.id,
+      schema: prepared.nodeKind.schema,
+      props: prepared.validatedProps,
+      uniqueConstraints: prepared.uniqueConstraints
+    },
+    backend
+  );
+}
+async function performNodeUpdate(ctx, input, backend, lock, options) {
+  const { kind, id } = input;
+  const registration = getNodeRegistration(ctx.graph, kind);
+  const existing = await backend.getNode(ctx.graphId, kind, id);
+  if (!existing) throw new NodeNotFoundError(kind, id);
+  const existingProps = rowPropsToObject(existing.props);
+  const mergedProps = { ...existingProps, ...input.props };
+  const nodeKind = registration.type;
+  const validatedProps = validateNodeProps(nodeKind.schema, mergedProps, {
+    kind,
+    operation: "update",
+    id
+  });
+  const validTo = validateOptionalCanonicalIsoDate(input.validTo, "validTo");
+  const writeContext = createNodeWriteContext(ctx.graphId, ctx.registry, lock);
+  const shared = {
+    schema: nodeKind.schema,
+    validatedProps,
+    uniqueConstraints: registration.unique ?? [],
+    ...validTo !== void 0 && { validTo }
+  };
+  if (options?.clearDeleted) {
+    const row2 = await applyNodeUpdate(
+      writeContext,
+      { ...shared, existing, clearDeleted: true },
+      backend
+    );
+    return rowToNode(row2);
+  }
+  if (!isLiveNodeRow(existing)) throw new NodeNotFoundError(kind, id);
+  const row = await applyNodeUpdate(
+    writeContext,
+    { ...shared, existing },
+    backend
+  );
+  return rowToNode(row);
+}
+async function primeBatchValidationCaches(ctx, drafts, backend, seams) {
+  if (backend.getNodes !== void 0) {
+    const idsByKind = /* @__PURE__ */ new Map();
+    for (const draft of drafts) {
+      const ids = idsByKind.get(draft.kind) ?? /* @__PURE__ */ new Set();
+      ids.add(draft.id);
+      idsByKind.set(draft.kind, ids);
+    }
+    for (const [kind, ids] of idsByKind) {
+      const orderedIds = [...ids];
+      const rows = await backend.getNodes(ctx.graphId, kind, orderedIds);
+      const rowsById = new Map(rows.map((row) => [row.id, row]));
+      for (const id of orderedIds) {
+        seams.seedNodeRow(kind, id, rowsById.get(id));
+      }
+    }
+  }
+  if (backend.checkUniqueBatch !== void 0) {
+    const groups = /* @__PURE__ */ new Map();
+    for (const draft of drafts) {
+      for (const constraint of draft.uniqueConstraints) {
+        if (!checkWherePredicate(constraint, draft.validatedProps)) continue;
+        const key = computeUniqueKey(
+          draft.validatedProps,
+          constraint.fields,
+          constraint.collation
+        );
+        const kindsToCheck = getKindsForUniquenessCheck(
+          draft.kind,
+          constraint.scope,
+          ctx.registry
+        );
+        for (const kindToCheck of kindsToCheck) {
+          const groupKey = kindToCheck + CACHE_KEY_SEPARATOR + constraint.name;
+          const group = groups.get(groupKey) ?? {
+            nodeKind: kindToCheck,
+            constraintName: constraint.name,
+            keys: /* @__PURE__ */ new Set()
+          };
+          group.keys.add(key);
+          groups.set(groupKey, group);
+        }
+      }
+    }
+    for (const group of groups.values()) {
+      const orderedKeys = [...group.keys];
+      const rows = await backend.checkUniqueBatch({
+        graphId: ctx.graphId,
+        nodeKind: group.nodeKind,
+        constraintName: group.constraintName,
+        keys: orderedKeys
+      });
+      const rowsByKey = new Map(rows.map((row) => [row.key, row]));
+      for (const key of orderedKeys) {
+        seams.seedUniqueRow(
+          group.nodeKind,
+          group.constraintName,
+          key,
+          rowsByKey.get(key)
+        );
+      }
+    }
+  }
+}
+async function prepareBatchCreates(ctx, inputs, backend, options) {
+  const {
+    backend: validationBackend,
+    registerPendingNode,
+    registerPendingUniqueEntries,
+    seedNodeRow,
+    seedUniqueRow
+  } = createNodeBatchValidationBackend(ctx.graphId, ctx.registry, backend);
+  const drafts = inputs.map(
+    (input) => draftNodeCreate(ctx, input, input.id ?? generateId(), options)
+  );
+  await primeBatchValidationCaches(ctx, drafts, backend, {
+    seedNodeRow,
+    seedUniqueRow
+  });
+  const preparedCreates = [];
+  for (const draft of drafts) {
+    const prepared = await finishNodeCreatePreparation(
+      ctx,
+      draft,
+      validationBackend
+    );
+    preparedCreates.push(prepared);
+    registerPendingNode(prepared.insertParams);
+    registerPendingUniqueEntries(
+      prepared.kind,
+      prepared.id,
+      prepared.validatedProps,
+      prepared.uniqueConstraints
+    );
+  }
+  const batchInsertParams = preparedCreates.map(
+    (prepared) => prepared.insertParams
+  );
+  return { preparedCreates, batchInsertParams };
+}
+async function findUniqueRowAcrossKinds(backend, graphId, constraintName, key, kindsToCheck, includeDeleted) {
+  for (const kindToCheck of kindsToCheck) {
+    const row = await backend.checkUnique({
+      graphId,
+      nodeKind: kindToCheck,
+      constraintName,
+      key,
+      includeDeleted
+    });
+    if (row !== void 0) return row;
+  }
+  return void 0;
+}
+async function batchCheckUniqueAcrossKinds(backend, graphId, constraintName, uniqueKeys, kindsToCheck, includeDeleted) {
+  const existingByKey = /* @__PURE__ */ new Map();
+  for (const kindToCheck of kindsToCheck) {
+    if (backend.checkUniqueBatch === void 0) {
+      for (const key of uniqueKeys) {
+        if (existingByKey.has(key)) continue;
+        const row = await backend.checkUnique({
+          graphId,
+          nodeKind: kindToCheck,
+          constraintName,
+          key,
+          includeDeleted
+        });
+        if (row !== void 0) {
+          existingByKey.set(row.key, row);
+        }
+      }
+    } else {
+      const rows = await backend.checkUniqueBatch({
+        graphId,
+        nodeKind: kindToCheck,
+        constraintName,
+        keys: uniqueKeys,
+        includeDeleted
+      });
+      for (const row of rows) {
+        if (!existingByKey.has(row.key)) {
+          existingByKey.set(row.key, row);
+        }
+      }
+    }
+  }
+  return existingByKey;
+}
+async function executeNodeCreateInternal(ctx, input, backend, options) {
+  const kind = input.kind;
+  const id = input.id ?? generateId();
+  const opContext = ctx.createOperationContext("create", "node", kind, id);
+  const shouldReturnRow = options?.returnRow ?? true;
+  return runHookedWriteOperation(
+    ctx,
+    opContext,
+    backend,
+    async (target, lock) => {
+      const prepared = await validateAndPrepareNodeCreate(
+        ctx,
+        input,
+        id,
+        target,
+        options
+      );
+      let row;
+      if (shouldReturnRow) {
+        row = await target.insertNode(prepared.insertParams);
+      } else {
+        await runInsertNoReturn(
+          nodeInsertDispatch(target),
+          prepared.insertParams
+        );
+      }
+      await finalizeNodeCreate(ctx, prepared, target, lock);
+      if (row === void 0) return;
+      return rowToNode(row);
+    }
+  );
+}
+async function executeNodeCreate(ctx, input, backend, options) {
+  const result = await executeNodeCreateInternal(ctx, input, backend, {
+    returnRow: true,
+    ...options
+  });
+  if (!result) {
+    throw new DatabaseOperationError(
+      "Node create failed: expected created node row",
+      { operation: "insert", entity: "node" }
+    );
+  }
+  return result;
+}
+async function executeNodeCreateNoReturnBatch(ctx, inputs, backend) {
+  if (inputs.length === 0) return;
+  await runInWriteTransaction(ctx, backend, async (target, lock) => {
+    const { preparedCreates, batchInsertParams } = await prepareBatchCreates(
+      ctx,
+      inputs,
+      target
+    );
+    await runInsertBatch(nodeInsertDispatch(target), batchInsertParams);
+    await finalizeNodeCreateBatch(ctx, preparedCreates, target, lock);
+  });
+}
+async function executeNodeCreateBatch(ctx, inputs, backend, options) {
+  if (inputs.length === 0) return [];
+  return runInWriteTransaction(ctx, backend, async (target, lock) => {
+    const { preparedCreates, batchInsertParams } = await prepareBatchCreates(
+      ctx,
+      inputs,
+      target,
+      options
+    );
+    const rows = await runInsertBatchReturning(
+      nodeInsertDispatch(target),
+      batchInsertParams
+    );
+    await finalizeNodeCreateBatch(ctx, preparedCreates, target, lock);
+    return rows.map((row) => rowToNode(row));
+  });
+}
+async function executeNodeUpdate(ctx, input, backend, options) {
+  const opContext = ctx.createOperationContext(
+    "update",
+    "node",
+    input.kind,
+    input.id
+  );
+  return runHookedWriteOperation(
+    ctx,
+    opContext,
+    backend,
+    (target, lock) => performNodeUpdate(ctx, input, target, lock, options)
+  );
+}
+async function executeNodeUpsertUpdate(ctx, input, backend, options) {
+  return runInWriteTransaction(
+    ctx,
+    backend,
+    (target, lock) => performNodeUpdate(ctx, input, target, lock, options)
+  );
+}
+async function executeNodeDelete(ctx, kind, id, backend) {
+  const gate = await backend.getNode(ctx.graphId, kind, id);
+  if (!gate || gate.deleted_at) return;
+  const opContext = ctx.createOperationContext("delete", "node", kind, id);
+  return runHookedWriteOperation(
+    ctx,
+    opContext,
+    backend,
+    async (target, lock) => {
+      const registration = getNodeRegistration(ctx.graph, kind);
+      const preflight = await target.getNode(ctx.graphId, kind, id);
+      if (!preflight || !isLiveNodeRow(preflight)) return;
+      await applyNodeSoftDelete(
+        createNodeWriteContext(ctx.graphId, ctx.registry, lock),
+        {
+          existing: preflight,
+          schema: registration.type.schema,
+          uniqueConstraints: registration.unique ?? [],
+          onDelete: registration.onDelete
+        },
+        target
+      );
+    }
+  );
+}
+async function executeNodeHardDelete(ctx, kind, id, backend) {
+  const gate = await backend.getNode(ctx.graphId, kind, id);
+  if (!gate) return;
+  const opContext = ctx.createOperationContext("delete", "node", kind, id);
+  return runHookedWriteOperation(
+    ctx,
+    opContext,
+    backend,
+    async (target, lock) => {
+      const registration = getNodeRegistration(ctx.graph, kind);
+      await applyNodeHardDelete(
+        createNodeWriteContext(ctx.graphId, ctx.registry, lock),
+        {
+          kind,
+          id,
+          schema: registration.type.schema,
+          onDelete: registration.onDelete
+        },
+        target
+      );
+    }
+  );
+}
+async function executeNodeGetOrCreateByConstraint(ctx, kind, constraintName, props, backend, options) {
+  const ifExists = options?.ifExists ?? "return";
+  const registration = getNodeRegistration(ctx.graph, kind);
+  const nodeKind = registration.type;
+  const validatedProps = validateNodeProps(nodeKind.schema, props, {
+    kind,
+    operation: "create"
+  });
+  const constraint = resolveConstraint(ctx.graph, kind, constraintName);
+  if (!checkWherePredicate(constraint, validatedProps)) {
+    const node = await executeNodeCreate(
+      ctx,
+      { kind, props: validatedProps },
+      backend,
+      { propsPreValidated: true }
+    );
+    return { node, action: "created" };
+  }
+  const key = computeUniqueKey(
+    validatedProps,
+    constraint.fields,
+    constraint.collation
+  );
+  const kindsToCheck = getKindsForUniquenessCheck(
+    kind,
+    constraint.scope,
+    ctx.registry
+  );
+  async function attempt() {
+    const existingUniqueRow = await findUniqueRowAcrossKinds(
+      backend,
+      ctx.graphId,
+      constraint.name,
+      key,
+      kindsToCheck,
+      true
+    );
+    if (existingUniqueRow === void 0) {
+      const node = await executeNodeCreate(
+        ctx,
+        { kind, props: validatedProps },
+        backend,
+        { propsPreValidated: true }
+      );
+      return { node, action: "created" };
+    }
+    const existingRow = await backend.getNode(
+      ctx.graphId,
+      existingUniqueRow.concrete_kind,
+      existingUniqueRow.node_id
+    );
+    if (existingRow === void 0) {
+      const node = await executeNodeCreate(
+        ctx,
+        { kind, props: validatedProps },
+        backend,
+        { propsPreValidated: true }
+      );
+      return { node, action: "created" };
+    }
+    const isSoftDeleted = existingRow.deleted_at !== void 0;
+    if (isSoftDeleted || ifExists === "update") {
+      const concreteKind = existingUniqueRow.concrete_kind;
+      const node = await executeNodeUpsertUpdate(
+        ctx,
+        {
+          kind: concreteKind,
+          id: existingRow.id,
+          props: validatedProps
+        },
+        backend,
+        { clearDeleted: isSoftDeleted }
+      );
+      return { node, action: isSoftDeleted ? "resurrected" : "updated" };
+    }
+    return { node: rowToNode(existingRow), action: "found" };
+  }
+  try {
+    return await attempt();
+  } catch (error) {
+    if (!(error instanceof UniquenessError)) throw error;
+    return attempt();
+  }
+}
+async function executeNodeFindByConstraint(ctx, kind, constraintName, props, backend) {
+  const registration = getNodeRegistration(ctx.graph, kind);
+  const nodeKind = registration.type;
+  const validatedProps = validateNodeProps(nodeKind.schema, props, {
+    kind,
+    operation: "create"
+  });
+  const constraint = resolveConstraint(ctx.graph, kind, constraintName);
+  if (!checkWherePredicate(constraint, validatedProps)) return void 0;
+  const key = computeUniqueKey(
+    validatedProps,
+    constraint.fields,
+    constraint.collation
+  );
+  const kindsToCheck = getKindsForUniquenessCheck(
+    kind,
+    constraint.scope,
+    ctx.registry
+  );
+  const existingUniqueRow = await findUniqueRowAcrossKinds(
+    backend,
+    ctx.graphId,
+    constraint.name,
+    key,
+    kindsToCheck,
+    false
+  );
+  if (existingUniqueRow === void 0) return void 0;
+  const existingRow = await backend.getNode(
+    ctx.graphId,
+    existingUniqueRow.concrete_kind,
+    existingUniqueRow.node_id
+  );
+  if (existingRow === void 0 || existingRow.deleted_at !== void 0)
+    return void 0;
+  return rowToNode(existingRow);
+}
+function validateAndComputeKeys(nodeKind, kind, constraint, items) {
+  const validated = [];
+  for (const item of items) {
+    const validatedProps = validateNodeProps(nodeKind.schema, item.props, {
+      kind,
+      operation: "create"
+    });
+    const applies = checkWherePredicate(constraint, validatedProps);
+    const key = applies ? computeUniqueKey(
+      validatedProps,
+      constraint.fields,
+      constraint.collation
+    ) : void 0;
+    validated.push({ validatedProps, key });
+  }
+  return validated;
+}
+function collectUniqueKeys(validated) {
+  return [
+    ...new Set(
+      validated.map((entry) => entry.key).filter((key) => key !== void 0)
+    )
+  ];
+}
+async function executeNodeBulkFindByConstraint(ctx, kind, constraintName, items, backend) {
+  if (items.length === 0) return [];
+  const registration = getNodeRegistration(ctx.graph, kind);
+  const nodeKind = registration.type;
+  const constraint = resolveConstraint(ctx.graph, kind, constraintName);
+  const validated = validateAndComputeKeys(nodeKind, kind, constraint, items);
+  const uniqueKeys = collectUniqueKeys(validated);
+  const kindsToCheck = getKindsForUniquenessCheck(
+    kind,
+    constraint.scope,
+    ctx.registry
+  );
+  const existingByKey = uniqueKeys.length > 0 ? await batchCheckUniqueAcrossKinds(
+    backend,
+    ctx.graphId,
+    constraint.name,
+    uniqueKeys,
+    kindsToCheck,
+    false
+  ) : /* @__PURE__ */ new Map();
+  const results = Array.from({ length: items.length });
+  const seenKeys = /* @__PURE__ */ new Map();
+  for (const [index, { key }] of validated.entries()) {
+    if (key === void 0) {
+      results[index] = void 0;
+      continue;
+    }
+    const previousIndex = seenKeys.get(key);
+    if (previousIndex !== void 0) {
+      results[index] = results[previousIndex];
+      continue;
+    }
+    seenKeys.set(key, index);
+    const existing = existingByKey.get(key);
+    if (existing === void 0) {
+      results[index] = void 0;
+      continue;
+    }
+    const existingRow = await backend.getNode(
+      ctx.graphId,
+      existing.concrete_kind,
+      existing.node_id
+    );
+    if (existingRow === void 0 || existingRow.deleted_at !== void 0) {
+      results[index] = void 0;
+      continue;
+    }
+    results[index] = rowToNode(existingRow);
+  }
+  return results;
+}
+function resolveNodeIndex(graph, kind, indexName) {
+  getNodeRegistration(graph, kind);
+  const declaration = graph.indexes?.find(
+    (candidate) => candidate.entity === "node" && candidate.kind === kind && candidate.name === indexName
+  );
+  if (declaration?.entity !== "node") {
+    throw new NodeIndexNotFoundError(indexName, kind);
+  }
+  if (declaration.method !== void 0) {
+    throw new ConfigurationError(
+      `bulkFindByIndex cannot probe index "${indexName}" (method "${declaration.method}"): only btree indexes serve equality probes.`,
+      { indexName, kind, method: declaration.method }
+    );
+  }
+  return declaration;
+}
+var INDEX_PROBE_EXPECTED_TYPEOF = {
+  string: "string",
+  number: "number",
+  boolean: "boolean"
+};
+function validateIndexProbeValue(value, valueType, pointer, kind) {
+  if (value === void 0 || value === null) return;
+  if (typeof value !== "string" && typeof value !== "number" && typeof value !== "boolean" && !(value instanceof Date)) {
+    throw indexProbeTypeError(
+      pointer,
+      kind,
+      "a scalar (string, number, boolean, or Date)",
+      value
+    );
+  }
+  if (valueType === "date") {
+    if (value instanceof Date || typeof value === "string") return;
+    throw indexProbeTypeError(
+      pointer,
+      kind,
+      "date (Date or ISO string)",
+      value
+    );
+  }
+  const expected = INDEX_PROBE_EXPECTED_TYPEOF[valueType ?? "unknown"];
+  if (expected === void 0) return;
+  if (typeof value !== expected) {
+    throw indexProbeTypeError(pointer, kind, expected, value);
+  }
+}
+function indexProbeTypeError(pointer, kind, expected, value) {
+  return new ValidationError(
+    `Index probe value for "${pointer}" on node kind "${kind}" has an incompatible type`,
+    {
+      entityType: "node",
+      kind,
+      issues: [
+        {
+          path: pointer,
+          message: `Expected ${expected}, received ${typeof value}`,
+          code: "invalid_type"
+        }
+      ]
+    }
+  );
+}
+function coerceIndexProbeBind(value, adapter) {
+  return adapter.bindValue(normalizeProbeScalar(value));
+}
+function normalizeProbeScalar(value) {
+  return value instanceof Date ? value.toISOString() : value;
+}
+var PROBE_NULL_TAG = 0;
+var PROBE_VALUE_TAG = 1;
+function canonicalIndexProbeKey(probe) {
+  return JSON.stringify(
+    probe.map(
+      (value) => value === void 0 || value === null ? [PROBE_NULL_TAG] : [PROBE_VALUE_TAG, normalizeProbeScalar(value)]
+    )
+  );
+}
+async function executeNodeBulkFindByIndex(ctx, kind, indexName, items, backend, options) {
+  if (items.length === 0) return [];
+  const index = resolveNodeIndex(ctx.graph, kind, indexName);
+  if (index.fields.length === 0) {
+    throw new ConfigurationError(
+      `bulkFindByIndex requires an index with at least one prop-based field on index "${indexName}" (node kind "${kind}")`,
+      { indexName, kind },
+      {
+        suggestion: "bulkFindByIndex probes by prop values from each item; an index declared with only keySystemColumns/coveringFields (no fields) has nothing to probe by."
+      }
+    );
+  }
+  if (index.fieldValueTypes.includes("date")) {
+    throw new ConfigurationError(
+      `bulkFindByIndex does not support date-typed key fields on index "${indexName}" (node kind "${kind}")`,
+      { indexName, kind },
+      {
+        suggestion: "Date index keys compare differently across SQLite and PostgreSQL. Use a string-encoded key field, or query date predicates via store.query(...).where(...)."
+      }
+    );
+  }
+  const limitPerInput = options?.limitPerInput;
+  if (limitPerInput !== void 0 && (!Number.isInteger(limitPerInput) || limitPerInput <= 0)) {
+    throw new ValidationError(
+      "bulkFindByIndex limitPerInput must be a positive integer",
+      {
+        entityType: "node",
+        kind,
+        issues: [
+          {
+            path: "limitPerInput",
+            message: `Expected a positive integer, received ${String(limitPerInput)}`,
+            code: "invalid_value"
+          }
+        ]
+      }
+    );
+  }
+  const adapter = getDialect(backend.dialect);
+  const probes = items.map(
+    (item) => index.fields.map((pointer, position) => {
+      const value = resolveJsonPointer(item.props, pointer);
+      validateIndexProbeValue(
+        value,
+        index.fieldValueTypes[position],
+        pointer,
+        kind
+      );
+      return value;
+    })
+  );
+  const groupByKey = /* @__PURE__ */ new Map();
+  const groupProbes = [];
+  const groupToInputs = [];
+  for (const [inputIndex, probe] of probes.entries()) {
+    const key = canonicalIndexProbeKey(probe);
+    const existing = groupByKey.get(key);
+    if (existing === void 0) {
+      groupByKey.set(key, groupProbes.length);
+      groupProbes.push(probe);
+      groupToInputs.push([inputIndex]);
+      continue;
+    }
+    groupToInputs[existing]?.push(inputIndex);
+  }
+  const schema = backend.tableNames ? createSqlSchema(backend.tableNames) : DEFAULT_SQL_SCHEMA;
+  const compileContext = {
+    dialect: backend.dialect,
+    propsColumn: sql.raw(`"props"`),
+    systemColumn: (column) => sql.raw(`"${column}"`)
+  };
+  const fieldKeys = compileNodeIndexFieldKeys(index, compileContext);
+  const groupPredicates = groupProbes.map(
+    (probe) => sql`(${sql.join(
+      fieldKeys.map((fieldKey, position) => {
+        const value = probe[position];
+        if (value === void 0 || value === null) {
+          return sql`${fieldKey} IS NULL`;
+        }
+        return adapter.nullSafeEquals(
+          fieldKey,
+          sql`${coerceIndexProbeBind(value, adapter)}`
+        );
+      }),
+      sql` AND `
+    )})`
+  );
+  const caseBranches = groupPredicates.map(
+    (predicate, group) => sql`WHEN ${predicate} THEN ${sql.raw(String(group))}`
+  );
+  const probeIndexExpr = sql`CASE ${sql.join(caseBranches, sql` `)} ELSE NULL END`;
+  const conditions = [
+    sql`"graph_id" = ${ctx.graphId}`,
+    sql`"kind" = ${kind}`,
+    sql`"deleted_at" IS NULL`
+  ];
+  if (index.where !== void 0) {
+    conditions.push(compileIndexWhere(compileContext, index.where));
+  }
+  conditions.push(sql`(${sql.join(groupPredicates, sql` OR `)})`);
+  const whereClause = sql.join(conditions, sql` AND `);
+  const probedSelect = sql`SELECT "id", ${probeIndexExpr} AS probe_idx FROM ${schema.nodesTable} WHERE ${whereClause}`;
+  const capInSql = limitPerInput !== void 0 && backend.capabilities.windowFunctions;
+  const query = capInSql ? sql`SELECT "id", probe_idx FROM (SELECT "id", probe_idx, ROW_NUMBER() OVER (PARTITION BY probe_idx ORDER BY "id") AS probe_rank FROM (${probedSelect}) AS probed) AS ranked WHERE probe_rank <= ${limitPerInput} ORDER BY probe_idx, "id"` : sql`${probedSelect} ORDER BY probe_idx, "id"`;
+  const rawMatches = await backend.execute(
+    asCompiledRowsSql(query)
+  );
+  const matches = limitPerInput !== void 0 && !capInSql ? capMatchesPerGroup(rawMatches, limitPerInput) : rawMatches;
+  const nodesById = await hydrateNodesById(
+    backend,
+    ctx.graphId,
+    kind,
+    matches.map((match) => match.id)
+  );
+  const results = Array.from({ length: items.length }, () => []);
+  for (const match of matches) {
+    const node = nodesById.get(match.id);
+    if (node === void 0) continue;
+    const inputs = groupToInputs[match.probe_idx];
+    if (inputs === void 0) continue;
+    for (const inputIndex of inputs) {
+      results[inputIndex]?.push(node);
+    }
+  }
+  return results;
+}
+function capMatchesPerGroup(matches, limitPerInput) {
+  const perGroupCount = /* @__PURE__ */ new Map();
+  const capped = [];
+  for (const match of matches) {
+    const count = perGroupCount.get(match.probe_idx) ?? 0;
+    if (count >= limitPerInput) continue;
+    perGroupCount.set(match.probe_idx, count + 1);
+    capped.push(match);
+  }
+  return capped;
+}
+async function hydrateNodesById(backend, graphId, kind, ids) {
+  const rowsById = await getNodeRowsByIds(backend, graphId, kind, ids);
+  const nodesById = /* @__PURE__ */ new Map();
+  for (const [id, row] of rowsById) {
+    if (row.deleted_at !== void 0) continue;
+    nodesById.set(id, rowToNode(row));
+  }
+  return nodesById;
+}
+async function executeNodeBulkGetOrCreateByConstraint(ctx, kind, constraintName, items, backend, options) {
+  if (items.length === 0) return [];
+  const ifExists = options?.ifExists ?? "return";
+  const registration = getNodeRegistration(ctx.graph, kind);
+  const nodeKind = registration.type;
+  const constraint = resolveConstraint(ctx.graph, kind, constraintName);
+  const validated = validateAndComputeKeys(nodeKind, kind, constraint, items);
+  const uniqueKeys = collectUniqueKeys(validated);
+  const kindsToCheck = getKindsForUniquenessCheck(
+    kind,
+    constraint.scope,
+    ctx.registry
+  );
+  const existingByKey = uniqueKeys.length > 0 ? await batchCheckUniqueAcrossKinds(
+    backend,
+    ctx.graphId,
+    constraint.name,
+    uniqueKeys,
+    kindsToCheck,
+    true
+  ) : /* @__PURE__ */ new Map();
+  const toCreate = [];
+  const toFetch = [];
+  const duplicateOf = [];
+  const seenKeys = /* @__PURE__ */ new Map();
+  for (const [index, { validatedProps, key }] of validated.entries()) {
+    if (key === void 0) {
+      toCreate.push({ index, input: { kind, props: validatedProps } });
+      continue;
+    }
+    const previousIndex = seenKeys.get(key);
+    if (previousIndex !== void 0) {
+      duplicateOf.push({ index, sourceIndex: previousIndex });
+      continue;
+    }
+    seenKeys.set(key, index);
+    const existing = existingByKey.get(key);
+    if (existing === void 0) {
+      toCreate.push({ index, input: { kind, props: validatedProps } });
+    } else {
+      toFetch.push({
+        index,
+        nodeId: existing.node_id,
+        concreteKind: existing.concrete_kind,
+        validatedProps,
+        isSoftDeleted: existing.deleted_at !== void 0
+      });
+    }
+  }
+  const results = Array.from({ length: items.length });
+  if (toCreate.length > 0) {
+    const createInputs = toCreate.map((entry) => entry.input);
+    const createdNodes = await executeNodeCreateBatch(
+      ctx,
+      createInputs,
+      backend,
+      { propsPreValidated: true }
+    );
+    for (const [batchIndex, entry] of toCreate.entries()) {
+      results[entry.index] = {
+        node: createdNodes[batchIndex],
+        action: "created"
+      };
+    }
+  }
+  for (const entry of toFetch) {
+    const { index, concreteKind, validatedProps, isSoftDeleted, nodeId } = entry;
+    const existingRow = await backend.getNode(
+      ctx.graphId,
+      concreteKind,
+      nodeId
+    );
+    if (existingRow === void 0) {
+      const node = await executeNodeCreate(
+        ctx,
+        { kind, props: validatedProps },
+        backend,
+        { propsPreValidated: true }
+      );
+      results[index] = { node, action: "created" };
+      continue;
+    }
+    if (isSoftDeleted || ifExists === "update") {
+      const node = await executeNodeUpsertUpdate(
+        ctx,
+        {
+          kind: concreteKind,
+          id: existingRow.id,
+          props: validatedProps
+        },
+        backend,
+        { clearDeleted: isSoftDeleted }
+      );
+      results[index] = {
+        node,
+        action: isSoftDeleted ? "resurrected" : "updated"
+      };
+    } else {
+      results[index] = { node: rowToNode(existingRow), action: "found" };
+    }
+  }
+  for (const { index, sourceIndex } of duplicateOf) {
+    const sourceResult = results[sourceIndex];
+    results[index] = { node: sourceResult.node, action: "found" };
+  }
+  return results;
+}
+
+export { checkCardinalityConstraint, createNodeBatchValidationBackend, executeNodeBulkFindByConstraint, executeNodeBulkFindByIndex, executeNodeBulkGetOrCreateByConstraint, executeNodeCreate, executeNodeCreateBatch, executeNodeCreateNoReturnBatch, executeNodeDelete, executeNodeFindByConstraint, executeNodeGetOrCreateByConstraint, executeNodeHardDelete, executeNodeUpdate, executeNodeUpsertUpdate, primeBatchValidationCaches, rowToEdge, rowToEdgeMeta, rowToNode, rowToNodeMeta, runHookedWriteOperation, runInWriteTransaction };
+//# sourceMappingURL=chunk-QNKSQTKQ.js.map
+//# sourceMappingURL=chunk-QNKSQTKQ.js.map