@secondlayer/subgraphs 3.13.0 → 3.14.1

package/dist/src/runtime/reindex.js

@@ -1332,6 +1332,7 @@ function matchSources(sources, transactions, events, traitContracts = new Map) {
 // src/runtime/block-processor.ts
 import { getTargetDb } from "@secondlayer/shared/db";
 import { resolveTraitContractIds } from "@secondlayer/shared/db/queries/contracts";
+import { advanceOperationCursor } from "@secondlayer/shared/db/queries/subgraph-operations";
 import {
   isByoSubgraph,
   recordSubgraphProcessed,
@@ -1951,6 +1952,21 @@ async function resolveTraitContracts(subgraph, blockHeight, db) {
   }
   return resolved;
 }
+
+class CursorRaceLostError extends Error {
+  constructor(operationId, height) {
+    super(`op ${operationId} lost cursor race at block ${height}`);
+    this.name = "CursorRaceLostError";
+  }
+}
+function opCursorMode(opts) {
+  const ap = opts?.atomicProgress;
+  return ap && "operationId" in ap ? ap : undefined;
+}
+function statusMode(opts) {
+  const ap = opts?.atomicProgress;
+  return ap && "status" in ap ? ap : undefined;
+}
 var BLOCK_RETRY_DELAYS_MS = [500, 2000, 5000];
 function journalEnabled(opts) {
   return !opts?.skipProgressUpdate;
@@ -2044,12 +2060,19 @@ async function processBlock(subgraph, subgraphName, blockHeight, opts) {
     }
   };
   if (route.byo) {
-    if (opts?.atomicProgress) {
+    if (statusMode(opts)) {
       const row = await targetDb.selectFrom("subgraphs").select("last_processed_block").where("name", "=", subgraphName).executeTakeFirst();
       if (row && Number(row.last_processed_block) >= blockHeight) {
         result.skipped = true;
         return result;
       }
+    } else if (opCursorMode(opts)) {
+      const om = opCursorMode(opts);
+      const row = await targetDb.selectFrom("subgraph_operations").select("cursor_block").where("id", "=", om.operationId).executeTakeFirst();
+      if (row?.cursor_block != null && Number(row.cursor_block) >= blockHeight) {
+        result.skipped = true;
+        return result;
+      }
     }
     let runResult = { processed: 0, errors: 0 };
     let manifest;
@@ -2070,41 +2093,71 @@ async function processBlock(subgraph, subgraphName, blockHeight, opts) {
       if (manifest && manifest.count > 0) {
         await emitSubscriptionOutbox(tx, subgraphName, manifest, matcher, block.height);
       }
-      if (opts?.atomicProgress && manifest && manifest.count > 0) {
-        await updateSubgraphStatus(tx, subgraphName, opts.atomicProgress.status, blockHeight);
+      const byoSm = statusMode(opts);
+      const byoOm = opCursorMode(opts);
+      if (byoSm && manifest && manifest.count > 0) {
+        await updateSubgraphStatus(tx, subgraphName, byoSm.status, blockHeight);
+      } else if (byoOm && manifest && manifest.count > 0) {
+        await advanceOperationCursor(tx, byoOm.operationId, blockHeight);
       }
       await applyProgress(tx, runResult);
     });
   } else {
-    await targetDb.transaction().execute(async (tx) => {
-      if (opts?.atomicProgress) {
-        const row = await tx.selectFrom("subgraphs").select("last_processed_block").where("name", "=", subgraphName).executeTakeFirst();
-        if (row && Number(row.last_processed_block) >= blockHeight) {
-          result.skipped = true;
-          return;
+    try {
+      await targetDb.transaction().execute(async (tx) => {
+        const opMode = opCursorMode(opts);
+        if (statusMode(opts)) {
+          const row = await tx.selectFrom("subgraphs").select("last_processed_block").where("name", "=", subgraphName).executeTakeFirst();
+          if (row && Number(row.last_processed_block) >= blockHeight) {
+            result.skipped = true;
+            return;
+          }
+        } else if (opMode) {
+          const row = await tx.selectFrom("subgraph_operations").select("cursor_block").where("id", "=", opMode.operationId).executeTakeFirst();
+          if (row?.cursor_block != null && Number(row.cursor_block) >= blockHeight) {
+            result.skipped = true;
+            return;
+          }
         }
-      }
-      const ctx = new SubgraphContext(tx, schemaName, subgraph.schema, blockMeta, initialTx, false, journalEnabled(opts));
-      const handlerStart = performance.now();
-      const runResult = await runHandlers(subgraph, matched, ctx);
-      handlerMs = performance.now() - handlerStart;
-      result.processed = runResult.processed;
-      result.errors = runResult.errors;
-      let flushedWrites = false;
-      if (ctx.pendingOps > 0) {
-        const flushStart = performance.now();
-        const manifest = await ctx.flush();
-        flushedWrites = manifest.count > 0;
-        if (manifest.count > 0) {
-          await emitSubscriptionOutbox(tx, subgraphName, manifest, matcher, block.height);
+        const ctx = new SubgraphContext(tx, schemaName, subgraph.schema, blockMeta, initialTx, false, journalEnabled(opts));
+        const handlerStart = performance.now();
+        const runResult = await runHandlers(subgraph, matched, ctx);
+        handlerMs = performance.now() - handlerStart;
+        result.processed = runResult.processed;
+        result.errors = runResult.errors;
+        let flushedWrites = false;
+        if (ctx.pendingOps > 0) {
+          const flushStart = performance.now();
+          const manifest = await ctx.flush();
+          flushedWrites = manifest.count > 0;
+          if (manifest.count > 0) {
+            await emitSubscriptionOutbox(tx, subgraphName, manifest, matcher, block.height);
+          }
+          flushMs = performance.now() - flushStart;
         }
-        flushMs = performance.now() - flushStart;
-      }
-      if (opts?.atomicProgress && flushedWrites) {
-        await updateSubgraphStatus(tx, subgraphName, opts.atomicProgress.status, blockHeight);
+        const sm = statusMode(opts);
+        if (sm && flushedWrites) {
+          await updateSubgraphStatus(tx, subgraphName, sm.status, blockHeight);
+        } else if (opMode && flushedWrites) {
+          const advanced = await advanceOperationCursor(tx, opMode.operationId, blockHeight);
+          if (!advanced) {
+            throw new CursorRaceLostError(opMode.operationId, blockHeight);
+          }
+        }
+        await applyProgress(tx, runResult);
+      });
+    } catch (err) {
+      if (err instanceof CursorRaceLostError) {
+        logger5.warn("cursor race lost — block already covered", {
+          subgraph: subgraphName,
+          blockHeight,
+          error: err.message
+        });
+        result.skipped = true;
+        return result;
       }
-      await applyProgress(tx, runResult);
-    });
+      throw err;
+    }
   }
   const totalMs = performance.now() - blockStart;
   result.timing = {
@@ -2209,7 +2262,10 @@ import {
   recordGapBatch,
   resolveGaps
 } from "@secondlayer/shared/db/queries/subgraph-gaps";
-import { updateOperationProcessedEvents } from "@secondlayer/shared/db/queries/subgraph-operations";
+import {
+  advanceOperationCursor as advanceOperationCursor2,
+  updateOperationProcessedEvents
+} from "@secondlayer/shared/db/queries/subgraph-operations";
 import {
   recordSubgraphProcessed as recordSubgraphProcessed2,
   updateSubgraphStatus as updateSubgraphStatus2
@@ -2282,6 +2338,7 @@ async function processBlockRange(def, opts) {
   const totalBlocks = toBlock - fromBlock + 1;
   const stats = new StatsAccumulator(subgraphName, opts.isCatchup);
   let blocksProcessed = 0;
+  let blocksSkippedByCursor = 0;
   let totalEventsProcessed = 0;
   let totalErrors = 0;
   let pendingEventsProcessed = 0;
@@ -2342,7 +2399,8 @@ async function processBlockRange(def, opts) {
     }
     const batchFailedBlocks = [];
     let batchMatched = 0;
-    const atomicProgress = status === "reindexing" ? { status } : undefined;
+    const opCursor = status === "active" && opts.operationId ? { operationId: opts.operationId } : undefined;
+    const atomicProgress = status === "reindexing" ? { status } : opCursor;
     for (let height = currentHeight;height <= batchEnd; height++) {
       let blockData = batch.get(height);
       if (!blockData) {
@@ -2382,6 +2440,8 @@ async function processBlockRange(def, opts) {
         continue;
       }
       blocksProcessed++;
+      if (result.skipped)
+        blocksSkippedByCursor++;
       batchMatched += result.matched;
       totalEventsProcessed += result.processed;
       totalErrors += result.errors;
@@ -2399,7 +2459,11 @@ async function processBlockRange(def, opts) {
       const now = Date.now();
       const shouldFlushProgress = blocksProcessed % 100 === 0 || now - lastProgressFlushAt >= PROGRESS_FLUSH_INTERVAL_MS;
       if (shouldFlushProgress) {
-        await updateSubgraphStatus2(targetDb, subgraphName, status, height);
+        if (opCursor) {
+          await advanceOperationCursor2(targetDb, opCursor.operationId, height);
+        } else {
+          await updateSubgraphStatus2(targetDb, subgraphName, status, height);
+        }
         if (opts.operationId) {
           await updateOperationProcessedEvents(targetDb, opts.operationId, totalEventsProcessed).catch(() => {});
         }
@@ -2411,7 +2475,8 @@ async function processBlockRange(def, opts) {
           processed: blocksProcessed,
           total: totalBlocks,
           currentBlock: height,
-          pct: Math.round(blocksProcessed / totalBlocks * 100)
+          pct: Math.round(blocksProcessed / totalBlocks * 100),
+          ...blocksSkippedByCursor > 0 ? { skippedByCursor: blocksSkippedByCursor } : {}
         });
       }
     }
@@ -2437,7 +2502,11 @@ async function processBlockRange(def, opts) {
       if (jumpTo > batchEnd + 1) {
         const skipped = Math.min(jumpTo, toBlock + 1) - (batchEnd + 1);
         blocksProcessed += skipped;
-        await updateSubgraphStatus2(targetDb, subgraphName, status, jumpTo - 1);
+        if (opCursor) {
+          await advanceOperationCursor2(targetDb, opCursor.operationId, jumpTo - 1);
+        } else {
+          await updateSubgraphStatus2(targetDb, subgraphName, status, jumpTo - 1);
+        }
         logger6.info("Sparse skip", {
           subgraph: subgraphName,
           from: batchEnd + 1,
@@ -2495,7 +2564,11 @@ async function reindexSubgraph(def, opts) {
     for (const stmt of statements) {
       await client.unsafe(stmt);
     }
-    logger6.info("Schema recreated for reindex", { subgraph: subgraphName });
+    await updateSubgraphStatus2(targetDb, subgraphName, "reindexing", Math.max(0, fromBlock - 1));
+    logger6.info("Schema recreated for reindex", {
+      subgraph: subgraphName,
+      cursorResetTo: Math.max(0, fromBlock - 1)
+    });
     await targetDb.updateTable("subgraphs").set({
       last_processed_block: initialReindexProgressBlock(fromBlock),
       reindex_from_block: fromBlock,
@@ -2683,5 +2756,5 @@ export {
   backfillSubgraph
 };
 
-//# debugId=6F74BAD96C2E3BCE64756E2164756E21
+//# debugId=16E6F70B818734C264756E2164756E21
 //# sourceMappingURL=reindex.js.map