@secondlayer/subgraphs 3.26.1 → 3.26.3

package/dist/src/runtime/catchup.d.ts

@@ -348,6 +348,39 @@ interface SubgraphDefinition {
 /** Run `fn` (a single block's write, or a reorg's whole rewind) holding the
 *  per-subgraph block lock. Exported for reorg.ts. */
 declare function withSubgraphBlockLock<T>(name: string, fn: () => Promise<T>): Promise<T>;
+/**
+* Cross-process half of the block lock: a transaction-scoped Postgres advisory
+* lock keyed `subgraph-block:<name>`, held for the duration of `fn`.
+*
+* Held, not merely acquired: each block's own write transaction is opened
+* INSIDE `processBlock` (block-processor.ts — `targetDb.transaction()` for
+* managed subgraphs, `route.dataDb.transaction()` for BYO), and that boundary
+* is load-bearing for the f069 replay guard, so the lock cannot be taken on
+* the writing connection. Instead this wraps the write in a separate
+* lock-holding transaction on the target DB, exactly as the reorg lock does
+* (reorg.ts): `pg_advisory_xact_lock` releases only when THIS transaction
+* commits, regardless of which other connections `fn` awaits meanwhile.
+* Transaction-scoped rather than session-scoped so a crashed walk can never
+* strand the lock.
+*
+* The lock lives on the target DB even for BYO subgraphs — same as the reorg
+* lock — because it coordinates control-plane walkers, not data-plane rows.
+*
+* Connection budget: this holds one pooled target-DB connection while `fn`
+* takes another for the write, so an in-flight block costs 2 of
+* `DATABASE_POOL_MAX` (default 20). Concurrent block writes are bounded by
+* catch-up fan-out (5 subgraphs) plus operation concurrency (1) = 6 blocks =
+* 12 connections. Raising either concurrency knob must be checked against the
+* pool, or the wrapping transactions can starve the writes they wrap.
+*/
+declare function withSubgraphBlockAdvisoryLock<T>(name: string, fn: () => Promise<T>): Promise<T>;
+/**
+* One block's write, holding BOTH halves of the block lock in the documented
+* order: the in-process mutex, then the cross-process advisory lock. Every
+* walk that writes a subgraph's schema — live catch-up, reindex, backfill —
+* must go through this, or it serializes against nothing.
+*/
+declare function withSubgraphBlockWriteLock<T>(name: string, fn: () => Promise<T>): Promise<T>;
 /** Bump a subgraph's reorg epoch. Call BEFORE acquiring the block lock so the
 *  bump is visible to any concurrent catch-up immediately. Exported for
 *  reorg.ts. */
@@ -371,4 +404,4 @@ declare function resolveCatchupBatchConfig(env?: CatchupBatchEnv): CatchupBatchC
 * plan-aware pipeline prefetching.
 */
 declare function catchUpSubgraph(subgraph: SubgraphDefinition, subgraphName: string): Promise<number>;
-export { withSubgraphBlockLock, resolveCatchupBatchConfig, catchUpSubgraph, bumpReorgEpoch };
+export { withSubgraphBlockWriteLock, withSubgraphBlockLock, withSubgraphBlockAdvisoryLock, resolveCatchupBatchConfig, catchUpSubgraph, bumpReorgEpoch };

package/dist/src/runtime/catchup.js

@@ -16,6 +16,13 @@ function quotePgIdent(name) {
     return name;
   return `"${name.replace(/"/g, '""')}"`;
 }
+function snakeToCamel(name) {
+  return name.replace(/_([a-z0-9])/g, (_, c) => c.toUpperCase());
+}
+function pascalCase(name) {
+  const camel = snakeToCamel(name);
+  return camel.charAt(0).toUpperCase() + camel.slice(1);
+}
 
 // src/schema/generator.ts
 var TYPE_MAP = {
@@ -3045,7 +3052,7 @@ class StatsAccumulator {
 }
 
 // src/runtime/catchup.ts
-import { getTargetDb as getTargetDb2 } from "@secondlayer/shared/db";
+import { getTargetDb as getTargetDb2, sql as sql4 } from "@secondlayer/shared/db";
 import { getSubgraph } from "@secondlayer/shared/db/queries/subgraphs";
 import { logger as logger8 } from "@secondlayer/shared/logger";
 
@@ -3116,6 +3123,15 @@ async function withSubgraphBlockLock(name, fn) {
     release();
   }
 }
+async function withSubgraphBlockAdvisoryLock(name, fn) {
+  return getTargetDb2().transaction().execute(async (lockTx) => {
+    await sql4`SELECT pg_advisory_xact_lock(hashtext(${`subgraph-block:${name}`}))`.execute(lockTx);
+    return fn();
+  });
+}
+async function withSubgraphBlockWriteLock(name, fn) {
+  return withSubgraphBlockLock(name, () => withSubgraphBlockAdvisoryLock(name, fn));
+}
 function bumpReorgEpoch(name) {
   reorgEpoch.set(name, (reorgEpoch.get(name) ?? 0) + 1);
 }
@@ -3244,7 +3260,7 @@ async function catchUpSubgraph(subgraph, subgraphName) {
         const preloaded = blockData;
         let result;
         try {
-          result = await withSubgraphBlockLock(subgraphName, async () => {
+          result = await withSubgraphBlockWriteLock(subgraphName, async () => {
             if (getReorgEpoch(subgraphName) !== walkEpoch) {
               throw new ReorgEpochChangedError(subgraphName);
             }
@@ -3304,11 +3320,13 @@ async function catchUpSubgraph(subgraph, subgraphName) {
   }
 }
 export {
+  withSubgraphBlockWriteLock,
   withSubgraphBlockLock,
+  withSubgraphBlockAdvisoryLock,
   resolveCatchupBatchConfig,
   catchUpSubgraph,
   bumpReorgEpoch
 };
 
-//# debugId=1544B1119237E68264756E2164756E21
+//# debugId=90994D80368BB6A264756E2164756E21
 //# sourceMappingURL=catchup.js.map