@secondlayer/subgraphs 3.12.0 → 3.14.0

package/dist/src/runtime/block-processor.d.ts

@@ -165,6 +165,13 @@ interface SubgraphContext {
 	update(table: string, where: Record<string, unknown>, set: Record<string, unknown>): void;
 	upsert(table: string, key: Record<string, unknown>, row: Record<string, unknown>): void;
 	delete(table: string, where: Record<string, unknown>): void;
+	/**
+	* Atomic counter update — the blessed accumulator primitive. Applies
+	* `col = COALESCE(col, 0) + delta` per column (insert-or-add); deltas may
+	* be negative. Requires a uniqueKeys constraint matching `key`. Prefer
+	* this over patchOrInsert with functional updaters for running totals.
+	*/
+	increment(table: string, key: Record<string, unknown>, deltas: Record<string, bigint | number>): void;
 	/** Partial update — sets only specified fields, preserves others */
 	patch(table: string, where: Record<string, unknown>, set: Record<string, unknown>): void;
 	/** Find-then-merge-or-insert. Values can be functions: (existing) => newValue */
@@ -242,6 +249,34 @@ interface ProcessBlockOptions {
 	skipProgressUpdate?: boolean;
 	/** Pre-loaded block data — skips DB reads when provided (used by batch catch-up). */
 	preloaded?: PreloadedBlockData;
+	/**
+	* Crash-safe sequential processing. Two checkpoint scopes:
+	* - `{ status }` (reindex): a written block commits
+	*   `subgraphs.last_processed_block = blockHeight` in the SAME transaction
+	*   as its writes; replays skip at/below the cursor. Only for strictly
+	*   ascending walks over the subgraph's own cursor.
+	* - `{ operationId }` (backfill): same guarantee against the OPERATION's
+	*   own `cursor_block` — backfills legitimately revisit heights below the
+	*   live cursor, so they must never checkpoint (or read) the subgraph
+	*   cursor. The advance is a CONDITIONAL monotonic UPDATE: concurrent
+	*   writers serialize on it, and the loser's whole block tx rolls back
+	*   (surfaced as `skipped`, never an error/gap).
+	* Either way: a crash can never leave committed deltas ahead of the
+	* relevant checkpoint.
+	*/
+	atomicProgress?: {
+		status: string
+	} | {
+		operationId: string
+	};
 }
+/** Default per-block retry schedule before a failure counts as persistent. */
+declare const BLOCK_RETRY_DELAYS_MS: number[];
+/**
+* processBlock with bounded retries. Throws the last error once the schedule
+* is exhausted — callers decide whether that halts the walk (strict paths) or
+* records a gap (backfill). Never advances any cursor on failure.
+*/
+declare function processBlockWithRetry(subgraph: SubgraphDefinition, subgraphName: string, blockHeight: number, opts?: ProcessBlockOptions, retryDelaysMs?: number[]): Promise<ProcessBlockResult>;
 declare function processBlock(subgraph: SubgraphDefinition, subgraphName: string, blockHeight: number, opts?: ProcessBlockOptions): Promise<ProcessBlockResult>;
-export { processBlock, invalidateSubgraphRoute, ProcessBlockTiming, ProcessBlockResult, ProcessBlockOptions, PreloadedBlockData };
+export { processBlockWithRetry, processBlock, invalidateSubgraphRoute, ProcessBlockTiming, ProcessBlockResult, ProcessBlockOptions, PreloadedBlockData, BLOCK_RETRY_DELAYS_MS };