@nicia-ai/typegraph 0.32.0 → 0.34.0

package/dist/chunk-6SCVW4AS.js

@@ -0,0 +1,20 @@
+import { lockRecordedGraphWrite, uncapturedGraphWriteLock } from './chunk-A7SZZFAG.js';
+import { runOptionallyInTransaction } from './chunk-V3QNTB7Z.js';
+
+// src/store/operations/write-transaction.ts
+function runInWriteTransaction(ctx, backend, fn) {
+  return runOptionallyInTransaction(backend, async (target) => {
+    const lock = ctx.historyEnabled ? await lockRecordedGraphWrite(target, ctx.graphId) : uncapturedGraphWriteLock();
+    return fn(target, lock);
+  });
+}
+function runHookedWriteOperation(ctx, opContext, backend, body) {
+  return ctx.withOperationHooks(
+    opContext,
+    () => runInWriteTransaction(ctx, backend, body)
+  );
+}
+
+export { runHookedWriteOperation, runInWriteTransaction };
+//# sourceMappingURL=chunk-6SCVW4AS.js.map
+//# sourceMappingURL=chunk-6SCVW4AS.js.map

package/dist/chunk-6SCVW4AS.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/store/operations/write-transaction.ts"],"names":[],"mappings":";;;;AAuDO,SAAS,qBAAA,CACd,GAAA,EACA,OAAA,EACA,EAAA,EAIY;AACZ,EAAA,OAAO,0BAAA,CAA2B,OAAA,EAAS,OAAO,MAAA,KAAW;AAC3D,IAAA,MAAM,IAAA,GACJ,IAAI,cAAA,GACF,MAAM,uBAAuB,MAAA,EAAQ,GAAA,CAAI,OAAO,CAAA,GAChD,wBAAA,EAAyB;AAC7B,IAAA,OAAO,EAAA,CAAG,QAAQ,IAAI,CAAA;AAAA,EACxB,CAAC,CAAA;AACH;AA0BO,SAAS,uBAAA,CACd,GAAA,EACA,SAAA,EACA,OAAA,EACA,IAAA,EAIY;AACZ,EAAA,OAAO,GAAA,CAAI,kBAAA;AAAA,IAAmB,SAAA;AAAA,IAAW,MACvC,qBAAA,CAAsB,GAAA,EAAK,OAAA,EAAS,IAAI;AAAA,GAC1C;AACF","file":"chunk-6SCVW4AS.js","sourcesContent":["/**\n * Shared transaction boundary for graph-entity mutations.\n *\n * A node/edge mutation is a cascade of steps — the core row write plus its\n * integrity side effects (uniqueness, embeddings, fulltext) or its delete\n * behavior (restrict / cascade / disconnect). Those steps are individually\n * atomic but not collectively atomic, so the cascade runs inside one top-level\n * transaction whether or not recorded-time capture is enabled: a mid-cascade\n * failure then rolls back the whole operation instead of leaving a half-applied\n * write (e.g. an inserted node whose uniqueness/embedding/fulltext rows were\n * never written, or a uniqueness conflict that leaves an orphaned node row).\n * Under history capture the per-graph write lock is additionally taken inside\n * that transaction so recorded capture serializes.\n *\n * Both {@link NodeOperationContext} and {@link EdgeOperationContext} route their\n * mutations through this one helper, replacing the byte-identical per-file\n * copies that previously drifted independently.\n */\nimport {\n  type GraphBackend,\n  runOptionallyInTransaction,\n  type TransactionBackend,\n} from \"../../backend/types\";\nimport { lockRecordedGraphWrite } from \"../recorded-capture\";\nimport {\n  type GraphWriteLock,\n  uncapturedGraphWriteLock,\n} from \"../recorded-capture/clock\";\nimport { type OperationHookContext } from \"../types\";\n\n/**\n * The slice of an operation context {@link runInWriteTransaction} needs: the\n * graph id (for the capture lock) and whether recorded-time capture is on.\n * Both {@link NodeOperationContext} and {@link EdgeOperationContext} satisfy it.\n */\nexport type WriteTransactionContext = Readonly<{\n  graphId: string;\n  historyEnabled: boolean;\n}>;\n\n/**\n * Runs a graph-entity mutation cascade inside a single top-level transaction.\n *\n * On a transactional backend the cascade shares one transaction so it commits\n * or rolls back atomically. A nested {@link TransactionBackend} (already inside\n * `store.transaction(...)`) omits `.transaction`, so\n * {@link runOptionallyInTransaction} runs `fn` directly against it rather than\n * opening a nested transaction. Non-transactional backends (Cloudflare D1,\n * `drizzle-orm/neon-http`) also run `fn` directly — they cannot offer\n * atomicity, which is documented on the store's write surface.\n *\n * Under history capture the per-graph write lock is taken inside the\n * transaction before any row work, matching the acquire order the recorded\n * clock lock depends on to avoid a circular wait.\n */\nexport function runInWriteTransaction<T>(\n  ctx: WriteTransactionContext,\n  backend: GraphBackend | TransactionBackend,\n  fn: (\n    target: GraphBackend | TransactionBackend,\n    lock: GraphWriteLock,\n  ) => Promise<T>,\n): Promise<T> {\n  return runOptionallyInTransaction(backend, async (target) => {\n    const lock =\n      ctx.historyEnabled ?\n        await lockRecordedGraphWrite(target, ctx.graphId)\n      : uncapturedGraphWriteLock();\n    return fn(target, lock);\n  });\n}\n\n/**\n * The slice of an operation context {@link runHookedWriteOperation} needs:\n * the {@link WriteTransactionContext} plus the hook wrapper. Both\n * `NodeOperationContext` and `EdgeOperationContext` satisfy it.\n */\nexport type HookedWriteOperationContext = WriteTransactionContext &\n  Readonly<{\n    withOperationHooks: <T>(\n      ctx: OperationHookContext,\n      fn: () => Promise<T>,\n    ) => Promise<T>;\n  }>;\n\n/**\n * The one sanctioned composition for a hooked, non-batch write operation:\n * operation hooks WRAP the write transaction, so `onOperationEnd` observes a\n * durably committed result and a failed COMMIT surfaces through `onError` —\n * a hook that fired inside the transaction would report success for a write\n * the rollback then discards. Every hooked node/edge mutation routes through\n * this helper; composing `withOperationHooks` and `runInWriteTransaction` by\n * hand invites exactly the inverted nesting this exists to prevent.\n * (Batch operations skip hooks deliberately and call\n * {@link runInWriteTransaction} directly.)\n */\nexport function runHookedWriteOperation<T>(\n  ctx: HookedWriteOperationContext,\n  opContext: OperationHookContext,\n  backend: GraphBackend | TransactionBackend,\n  body: (\n    target: GraphBackend | TransactionBackend,\n    lock: GraphWriteLock,\n  ) => Promise<T>,\n): Promise<T> {\n  return ctx.withOperationHooks(opContext, () =>\n    runInWriteTransaction(ctx, backend, body),\n  );\n}\n"]}