@nicia-ai/typegraph 0.49.0 → 0.51.0

package/dist/{chunk-ZFMCDJGB.js → chunk-WFSYYU4W.js}

@@ -1,84 +1,15 @@
-import { encodeTupleKey, advanceRevisionClock, lockRecordedGraphWrite, uncapturedGraphWriteLock, identityAssertionSnapshotSource, identitySqlCoordinate, IDENTITY_ASSERTION_COLUMNS, compareCodePoints, withRecordedIdentityMutationTarget, recordedBindParamBudget, identityNodeVisibilitySql, historicalIdentityReconstructionCtes, generateId, identityNodeSnapshotSource } from './chunk-S5TERQVW.js';
-import { chunk, isSqliteStaleSnapshotError, isMissingTableError } from './chunk-UGHG7PGX.js';
-import { runOptionallyInTransaction } from './chunk-6LN7FIVU.js';
-import { nowIso, canonicalizeDatabaseTimestamp, validateOptionalCanonicalIsoDate } from './chunk-5K2BKEBD.js';
-import { getDialect } from './chunk-ZDKTPBGV.js';
-import { asCompiledRowsSql, sql, asCompiledStatementSql } from './chunk-3DMMGT6S.js';
-import { ValidationError, ConfigurationError, IdentityEndpointValidityError, NodeNotFoundError, KindNotFoundError, IdentityValidityWindowError, IdentityContradictionError, IdentitySeparationViolationError } from './chunk-ZLONH2UD.js';
+import { identityAssertionSnapshotSource, identitySqlCoordinate, IDENTITY_ASSERTION_COLUMNS, withRecordedIdentityMutationTarget, recordedBindParamBudget, identityNodeVisibilitySql, historicalIdentityReconstructionCtes, runInWriteTransaction, generateId, identityNodeSnapshotSource } from './chunk-VAAC7L57.js';
+import { chunk, isSqliteStaleSnapshotError, isMissingTableError } from './chunk-QG5VEOKX.js';
+import { resolveRecursiveTraversal, assertRecursiveTraversal } from './chunk-XORONCV3.js';
+import { resolveWriteFencePlan, requireWriteFence } from './chunk-LKZDQ2B4.js';
+import { encodeTupleKey } from './chunk-RVUL2HXY.js';
+import { nowIso, canonicalizeDatabaseTimestamp, validateOptionalCanonicalIsoDate } from './chunk-K46SDNQD.js';
+import { getDialect } from './chunk-7G5IYROL.js';
+import { asCompiledRowsSql, sql, asCompiledStatementSql } from './chunk-7QFRK6PU.js';
+import { compareCodePoints } from './chunk-HZUB5CON.js';
+import { ConfigurationError, IdentityEndpointValidityError, NodeNotFoundError, KindNotFoundError, IdentityValidityWindowError, IdentityContradictionError, ValidationError, IdentitySeparationViolationError } from './chunk-YDEJQWOL.js';
 import { requireDefined } from './chunk-DYATYRY4.js';
 
-// src/errors/validation.ts
-function zodIssuesToValidationIssues(error) {
-  return error.issues.map((issue) => ({
-    path: issue.path.join("."),
-    message: issue.message,
-    code: issue.code
-  }));
-}
-function buildLocationString(context) {
-  if (context.id) {
-    return `${context.kind}/${context.id}`;
-  }
-  return `new ${context.kind}`;
-}
-function validateProps(schema, props, context) {
-  const result = schema.safeParse(props);
-  if (result.success) {
-    return result.data;
-  }
-  const issues = zodIssuesToValidationIssues(result.error);
-  const location = buildLocationString(context);
-  throw new ValidationError(
-    `Invalid ${context.entityType} props for ${location}: ${result.error.message}`,
-    {
-      entityType: context.entityType,
-      kind: context.kind,
-      operation: context.operation,
-      ...context.id !== void 0 && { id: context.id },
-      issues
-    },
-    { cause: result.error }
-  );
-}
-function validateNodeProps(schema, props, context) {
-  return validateProps(schema, props, {
-    entityType: "node",
-    ...context
-  });
-}
-function validateEdgeProps(schema, props, context) {
-  return validateProps(schema, props, {
-    entityType: "edge",
-    ...context
-  });
-}
-function wrapZodError(error, context) {
-  const issues = zodIssuesToValidationIssues(error);
-  const location = buildLocationString(context);
-  return new ValidationError(
-    `Validation failed for ${context.entityType} ${location}: ${error.message}`,
-    {
-      entityType: context.entityType,
-      kind: context.kind,
-      operation: context.operation,
-      ...context.id !== void 0 && { id: context.id },
-      issues
-    },
-    { cause: error }
-  );
-}
-function createValidationError(message, issues, context) {
-  return new ValidationError(message, {
-    ...context?.entityType !== void 0 && {
-      entityType: context.entityType
-    },
-    ...context?.kind !== void 0 && { kind: context.kind },
-    ...context?.operation !== void 0 && { operation: context.operation },
-    ...context?.id !== void 0 && { id: context.id },
-    issues
-  });
-}
-
 // src/identity/row-codec.ts
 function toCanonicalIdentityTimestamp(value) {
   const canonical = canonicalizeDatabaseTimestamp(value);
@@ -265,22 +196,44 @@ function publicNodeRef(ref) {
   return ref;
 }
 async function lockIdentityGraph(target, graphId) {
-  if (target.dialect !== "postgres") return;
-  await target.execute(
-    asCompiledRowsSql(sql`
-      SELECT pg_advisory_xact_lock(
-        hashtext('typegraph:identity'),
-        hashtext(${graphId})
-      )
-    `)
-  );
+  const plan = resolveWriteFencePlan(target);
+  const fence = requireWriteFence(plan, "identity graph lock", "advisory-lock");
+  switch (fence.kind) {
+    case "lock": {
+      await target.execute(
+        asCompiledRowsSql(sql`
+          SELECT pg_advisory_xact_lock(
+            hashtext('typegraph:identity'),
+            hashtext(${graphId})
+          )
+        `)
+      );
+      return;
+    }
+    case "engine-serialized": {
+      return;
+    }
+  }
 }
 async function lockIdentityEnablementNodes(target, schema) {
-  if (target.dialect !== "postgres") return;
-  await executeIdentityStatement(
-    target,
-    sql`LOCK TABLE ${schema.nodesTable} IN SHARE MODE`
-  );
+  const plan = resolveWriteFencePlan(target);
+  const fence = requireWriteFence(
+    plan,
+    "identity enablement drain",
+    "table-lock"
+  );
+  switch (fence.kind) {
+    case "lock": {
+      await executeIdentityStatement(
+        target,
+        sql`LOCK TABLE ${schema.nodesTable} IN SHARE MODE`
+      );
+      return;
+    }
+    case "engine-serialized": {
+      return;
+    }
+  }
 }
 async function loadNodeSnapshot(target, schema, graphId, coordinate) {
   const sqlCoordinate = identitySqlCoordinate(coordinate, nowIso());
@@ -452,7 +405,8 @@ async function loadHistoricalClasses(target, schema, graphId, references, coordi
     graphId,
     coordinate: sqlCoordinate,
     seedSource: sql`VALUES ${seeds}`,
-    sameIdAcrossKinds
+    sameIdAcrossKinds,
+    recursiveTraversal: resolveRecursiveTraversal(target.capabilities)
   });
   const rows = await target.execute(
     asCompiledRowsSql(sql`
@@ -677,123 +631,6 @@ async function readIdentityAssertionsForInterchange(ctx, mode, options) {
   return page.assertions;
 }
 
-// src/store/operations/write-transaction.ts
-var writeTransactionSessions = /* @__PURE__ */ new WeakMap();
-function forceWriteTransactionRevision(target) {
-  const session = writeTransactionSessions.get(target);
-  if (session === void 0) return false;
-  session.wrote = true;
-  return true;
-}
-var heldGraphWriteLocks = /* @__PURE__ */ new WeakMap();
-async function withWriteTransactionSession(target, ctx, fn) {
-  const session = {
-    lock: void 0,
-    wrote: false
-  };
-  writeTransactionSessions.set(target, session);
-  try {
-    const result = await fn();
-    if (session.wrote && ctx.revisionTrackingEnabled && !ctx.historyEnabled) {
-      await advanceRevisionClock(target, ctx.revisionSchema, ctx.graphId, true);
-    }
-    return result;
-  } finally {
-    writeTransactionSessions.delete(target);
-  }
-}
-async function lockSchemaVersionForStoreWrite(ctx, backend) {
-  const expectedVersion = ctx.schemaVersion;
-  if (expectedVersion === void 0) return;
-  if ("transaction" in backend && !backend.capabilities.transactions) {
-    throw new ConfigurationError(
-      "Schema-managed Store writes require a transactional backend so schema changes and entity writes can share one fence.",
-      {
-        code: "SCHEMA_WRITE_FENCE_UNSUPPORTED",
-        graphId: ctx.graphId
-      }
-    );
-  }
-  const lockSchemaVersionForWrite = backend.lockSchemaVersionForWrite;
-  if (lockSchemaVersionForWrite === void 0) {
-    throw new ConfigurationError(
-      "This backend cannot fence schema-managed Store writes against a concurrent schema change.",
-      {
-        code: "SCHEMA_WRITE_FENCE_UNSUPPORTED",
-        graphId: ctx.graphId
-      }
-    );
-  }
-  await lockSchemaVersionForWrite({
-    graphId: ctx.graphId,
-    expectedVersion
-  });
-}
-var CONSTRAINT_FENCE_ADVICE = {
-  edgeCardinality: 'declare the edge `cardinality: "many"` and enforce the limit in application code',
-  edgeMatchKeyConvergence: "use `create` with a caller-chosen id, whose uniqueness the edges primary key enforces, instead of `getOrCreateByEndpoints`",
-  nodeDisjointness: "drop the `disjointWith` axiom and keep ids distinct across those kinds yourself",
-  nodeUniquenessScope: 'scope the unique constraint to `"kind"`, which the uniques primary key enforces on its own'
-};
-function graphWriteFenceRefusal(ctx, backend, reason) {
-  if (!("transaction" in backend) || backend.capabilities.transactions) {
-    return void 0;
-  }
-  return new ConfigurationError(
-    "This backend cannot fence a constrained write: enforcing a declared constraint requires a transaction to scope the per-graph write lock to, and this backend has no transactions.",
-    {
-      code: "CONSTRAINT_WRITE_FENCE_UNSUPPORTED",
-      graphId: ctx.graphId,
-      constraint: reason
-    },
-    {
-      suggestion: `Use a transactional backend, or ${CONSTRAINT_FENCE_ADVICE[reason]}. Unconstrained writes need no fence and keep working on this backend.`
-    }
-  );
-}
-function runInWriteTransaction(ctx, backend, fn, options) {
-  const ownsWriteLock = "transaction" in backend && backend.capabilities.transactions;
-  const fenceReason = options?.fencesConstraintProbe;
-  const refusal = fenceReason === void 0 ? void 0 : graphWriteFenceRefusal(ctx, backend, fenceReason);
-  if (refusal !== void 0) return Promise.reject(refusal);
-  const needsGraphWriteLock = ctx.historyEnabled || ctx.revisionTrackingEnabled || fenceReason !== void 0;
-  return runOptionallyInTransaction(backend, async (target) => {
-    await lockSchemaVersionForStoreWrite(ctx, target);
-    const session = needsGraphWriteLock ? writeTransactionSessions.get(target) : void 0;
-    const held = heldGraphWriteLocks.get(target) ?? /* @__PURE__ */ new Set();
-    heldGraphWriteLocks.set(target, held);
-    const acquiresLock = needsGraphWriteLock && session?.lock === void 0 && !held.has(ctx.graphId);
-    if (acquiresLock) held.add(ctx.graphId);
-    const lock = acquiresLock ? await lockRecordedGraphWrite(target, ctx.graphId).catch(
-      (error) => {
-        held.delete(ctx.graphId);
-        throw error;
-      }
-    ) : session?.lock ?? uncapturedGraphWriteLock();
-    if (session !== void 0) session.lock = lock;
-    const result = await (acquiresLock ? fn(target, lock).finally(() => held.delete(ctx.graphId)) : fn(target, lock));
-    if (session !== void 0) {
-      session.wrote ||= options?.didWrite?.(result) ?? true;
-      return result;
-    }
-    if (ctx.revisionTrackingEnabled && !ctx.historyEnabled && (options?.didWrite?.(result) ?? true)) {
-      await advanceRevisionClock(
-        target,
-        ctx.revisionSchema,
-        ctx.graphId,
-        ownsWriteLock
-      );
-    }
-    return result;
-  });
-}
-function runHookedWriteOperation(ctx, opContext, backend, body, options) {
-  return ctx.withOperationHooks(
-    opContext,
-    () => runInWriteTransaction(ctx, backend, body, options)
-  );
-}
-
 // src/identity/service-components.ts
 var UnionFind = class {
   #parents = /* @__PURE__ */ new Map();
@@ -1693,7 +1530,19 @@ function windowOverlapSql(alias, lowerBoundary, upperBoundary) {
     AND (${column("valid_to")} IS NULL OR ${column("valid_to")} > ${lowerBoundary})
   `;
 }
-async function loadIdentityWindowLedger(target, schema, graphId, requests, operationInstant, sameIdAcrossKinds) {
+async function loadIdentityWindowLedger(input) {
+  assertRecursiveTraversal(
+    input.recursiveTraversal,
+    "identity window ledger read"
+  );
+  const {
+    target,
+    schema,
+    graphId,
+    requests,
+    operationInstant,
+    sameIdAcrossKinds
+  } = input;
   const activeRequests = requests.filter(
     (request) => request.window.effective !== "empty"
   );
@@ -1935,14 +1784,15 @@ function validateRelationAgainstLedger(ctx, nodes, assertions, relation, operati
   }
 }
 async function createIdentityWindowValidator(ctx, target, requests, operationInstant, ignoredAssertionIds = /* @__PURE__ */ new Set()) {
-  const ledger = await loadIdentityWindowLedger(
+  const ledger = await loadIdentityWindowLedger({
     target,
-    ctx.schema,
-    ctx.graphId,
+    schema: ctx.schema,
+    graphId: ctx.graphId,
     requests,
     operationInstant,
-    ctx.sameIdAcrossKinds
-  );
+    sameIdAcrossKinds: ctx.sameIdAcrossKinds,
+    recursiveTraversal: resolveRecursiveTraversal(target.capabilities)
+  });
   if (ignoredAssertionIds.size > 0) {
     const retained = ledger.assertions.filter(
       (assertion) => !ignoredAssertionIds.has(assertion.id)
@@ -4043,6 +3893,6 @@ async function detachIdentityForNode(ctx, target, ref, mode) {
   });
 }
 
-export { IDENTITY_IMPORT_FAILED_ASSERTION, IDENTITY_IMPORT_PROGRESS, applyIdentityChangesForContext, assertAffectedIdentityClassesConsistent, createIdentityFacade, createIdentityReadFacade, createValidationError, deleteAssertionsTouchingKinds, detachIdentityForNode, foldIdentityForCreatedNodes, forceWriteTransactionRevision, hasAssertionsTouchingKinds, identityAssertionSemanticKey, identityReferenceKey, identityValidityWindowsOverlap, importIdentityAssertionsIntoTarget, liveNodeKindsSharingIds, loadAssertionsByIds, loadCurrentStructuralClasses, lockIdentityEnablementNodes, lockIdentityGraph, lockSchemaVersionForStoreWrite, normalizeIdentityPair, purgeAssertionsWithUnregisteredKinds, readIdentityAssertionPageAtTarget, readIdentityAssertionsForInterchange, rebuildIdentityClosureForContext, refKey, removeIdentityKindsForContext, requireNodeValidityEndCompatible, runHookedWriteOperation, runInWriteTransaction, separationRebuildRequired, toTransferAssertion, validateEdgeProps, validateIdentityForContext, validateNodeProps, validateProps, withWriteTransactionSession, wrapZodError };
-//# sourceMappingURL=chunk-ZFMCDJGB.js.map
-//# sourceMappingURL=chunk-ZFMCDJGB.js.map
+export { IDENTITY_IMPORT_FAILED_ASSERTION, IDENTITY_IMPORT_PROGRESS, applyIdentityChangesForContext, assertAffectedIdentityClassesConsistent, createIdentityFacade, createIdentityReadFacade, deleteAssertionsTouchingKinds, detachIdentityForNode, foldIdentityForCreatedNodes, hasAssertionsTouchingKinds, identityAssertionSemanticKey, identityReferenceKey, identityValidityWindowsOverlap, importIdentityAssertionsIntoTarget, liveNodeKindsSharingIds, loadAssertionsByIds, loadCurrentStructuralClasses, lockIdentityEnablementNodes, lockIdentityGraph, normalizeIdentityPair, purgeAssertionsWithUnregisteredKinds, readIdentityAssertionPageAtTarget, readIdentityAssertionsForInterchange, rebuildIdentityClosureForContext, refKey, removeIdentityKindsForContext, requireNodeValidityEndCompatible, separationRebuildRequired, toTransferAssertion, validateIdentityForContext };
+//# sourceMappingURL=chunk-WFSYYU4W.js.map
+//# sourceMappingURL=chunk-WFSYYU4W.js.map