@secondlayer/subgraphs 3.25.1 → 3.26.1

package/dist/src/index.d.ts

@@ -459,9 +459,28 @@ declare function filterFieldsByType(): Array<{
 	type: string
 	fields: string[]
 }>;
+/** A (decoded event type, optional contract scope) pair the sparse probe
+*  checks. Contract scoping is what makes token-subgraph reindexes leap over
+*  everything that isn't their token. */
+type SparseProbeTarget = {
+	eventType: string
+	contractId?: string
+};
+/** Sparse scanning is sound only when EVERY source is an event-type filter —
+*  a contract_call/contract_deploy source matches transactions, which the
+*  event probe can't see. */
+declare function canSparseScan(subgraph: SubgraphDefinition): boolean;
+/** Probe targets for a subgraph's filters: decoded type + contract scope when\\n*  the filter pins one (assetIdentifier "SP….contract::asset" or contractId). */
+declare function sparseProbeTargets(subgraph: SubgraphDefinition): SparseProbeTarget[];
 interface ReindexOptions {
-	fromBlock?: number;
-	toBlock?: number;
+	/**
+	* Policy floor on the walk's first block — NOT a caller-supplied range.
+	* Free-tier accounts may not reindex below their registered `start_block`
+	* (see `resolveGenesisPolicy` on the API side); this raises the walk start
+	* and can never lower it. There is deliberately no `toBlock` counterpart:
+	* a reindex always runs to chain tip. See {@link resolveBlockRange}.
+	*/
+	startBlockFloor?: number;
 	schemaName?: string;
 	/** Op row to receive processed_events on each progress flush. */
 	operationId?: string;
@@ -470,6 +489,13 @@ interface ReindexOptions {
 /**
 * Reindex a subgraph by dropping its tables, recreating them, and reprocessing
 * all historical blocks through the handler pipeline.
+*
+* Always whole-subgraph: `[start_block, chain tip]`. There is no ranged
+* reindex — the drop cannot be scoped to a range without re-running delta
+* handlers (`ctx.increment` / `ctx.update` / `ctx.patchOrInsert`) over rows
+* that were never removed, which is the exact double-count hazard `backfill`
+* already refuses. Use `backfillSubgraph` for ranged, additive work.
+*
 * Supports cancellation via AbortSignal — on shutdown abort, status stays
 * "reindexing" for auto-resume; on user cancel, status resets to "active".
 */
@@ -1076,10 +1102,10 @@ declare function generateIndexSchema(target: IndexCodegenTarget, opts?: IndexCod
 /** Index tables available to codegen, for help text and validation. */
 declare const INDEX_CODEGEN_TABLES: readonly string[];
 import { pgSchemaName } from "@secondlayer/shared/db/queries/subgraphs";
-import { Database as Database2 } from "@secondlayer/shared/db";
+import { Database as Database3 } from "@secondlayer/shared/db";
 import { ByoBreakingChangeDetails } from "@secondlayer/shared/errors";
-import { Kysely as Kysely2 } from "kysely";
-type AnyDb = Kysely2<Database2>;
+import { Kysely as Kysely3 } from "kysely";
+type AnyDb = Kysely3<Database3>;
 interface TableDiff {
 	/** Tables added to the schema */
 	addedTables: string[];
@@ -1200,17 +1226,4 @@ declare function deploySchema(db: AnyDb, def: SubgraphDefinition, handlerPath: s
 	/** Non-fatal caveats the caller should surface (e.g. handler grafts at tip). */
 	warnings?: string[]
 }>;
-/** A (decoded event type, optional contract scope) pair the sparse probe
-*  checks. Contract scoping is what makes token-subgraph reindexes leap over
-*  everything that isn't their token. */
-type SparseProbeTarget = {
-	eventType: string
-	contractId?: string
-};
-/** Sparse scanning is sound only when EVERY source is an event-type filter —
-*  a contract_call/contract_deploy source matches transactions, which the
-*  event probe can't see. */
-declare function canSparseScan(subgraph: SubgraphDefinition): boolean;
-/** Probe targets for a subgraph's filters: decoded type + contract scope when\\n*  the filter pins one (assetIdentifier "SP….contract::asset" or contractId). */
-declare function sparseProbeTargets(subgraph: SubgraphDefinition): SparseProbeTarget[];
 export { validateSubgraphDefinition, validatePrintPayload, sparseProbeTargets, resumeReindex, renderDeployPlan, reindexSubgraph, readContractAt, pgSchemaName, inferPrintTopics, hasBreakingChanges, generateSubgraphSQL, generatePrismaSchema, generateKyselySchema, generateIndexSchema, generateDrizzleSchema, filterFieldsByType, diffSchema, deploySchema, defineSubgraph, defineSchema, canSparseScan, camelizeDataKey, backfillSubgraph, WriteRow, WhereInput, TypedSubgraphDefinition, TypedSubgraphContext, TypedHandlers, TxMeta, TableDiff, SystemRow, SubscribeOptions, SubgraphTableClient, SubgraphTable, SubgraphSchema, SubgraphHandler, SubgraphFilter, SubgraphDefinition, SubgraphContext, SubgraphColumn, StxTransferPayload, StxTransferFilter, StxMintPayload, StxMintFilter, StxLockPayload, StxLockFilter, StxBurnPayload, StxBurnFilter, SparseProbeTarget, RowValue, ReindexOptions, PrismaGenOptions, PrintValidationResult, PrintSample, PrintFieldToTS, PrintField, PrintEventPayload, PrintEventFor, PrintEventFilter, PrintDataOf, NftTransferPayload, NftTransferFilter, NftMintPayload, NftMintFilter, NftBurnPayload, NftBurnFilter, KyselyGenOptions, InferredTopicSchema, InferredPrintField, InferTableRow, InferSubgraphClient, InferContext, InferColumnType, IndexCodegenTarget, IndexCodegenOptions, INDEX_CODEGEN_TABLES, GeneratedSQL, FtTransferPayload, FtTransferFilter, FtMintPayload, FtMintFilter, FtBurnPayload, FtBurnFilter, FindManyOptions, FactoryScope, EventForFilter, ErasedChainReadClient, DrizzleGenOptions, DeployPlan, DeployDiff, ContractDeployPayload, ContractDeployFilter, ContractCallPayload, ContractCallFilter, ContractCallEvent, ComputedValue, ComparisonFilter, ColumnType, ColumnToTS, ColumnDiff, ChainReadOptions, ChainReadMethods, ChainReadError, ChainReadClient, ChainReadCacheMode, ByoMigrationPlan, ByoBreakingChangeError, AnyEvent, AggregateSpec, AggregateResult };

package/dist/src/index.js

@@ -820,14 +820,10 @@ class SubgraphContext {
     this.ops.length = 0;
     const statements = this.buildStatements(opsToFlush);
     if ("isTransaction" in this.db) {
-      for (const stmt of statements) {
-        await sql.raw(stmt).execute(this.db);
-      }
+      await this.execStatements(this.db, statements);
     } else {
       await this.db.transaction().execute(async (tx) => {
-        for (const stmt of statements) {
-          await sql.raw(stmt).execute(tx);
-        }
+        await this.execStatements(tx, statements);
       });
     }
     const writes = opsToFlush.map((op, rowIndex) => {
@@ -846,6 +842,25 @@ class SubgraphContext {
     });
     return { count: opsToFlush.length, writes };
   }
+  async execStatements(executor, statements) {
+    const affected = (r) => r.numAffectedRows ?? 0n;
+    for (const stmt of statements) {
+      if (typeof stmt === "string") {
+        await sql.raw(stmt).execute(executor);
+        continue;
+      }
+      const updated = await sql.raw(stmt.update).execute(executor);
+      if (affected(updated) > 0n)
+        continue;
+      const inserted = await sql.raw(stmt.insert).execute(executor);
+      if (affected(inserted) > 0n)
+        continue;
+      const retried = await sql.raw(stmt.update).execute(executor);
+      if (affected(retried) === 0n) {
+        throw new Error(`increment could not be applied to ${this.pgSchemaName}.${stmt.table} where ${stmt.keyPred}: row neither updated nor inserted`);
+      }
+    }
+  }
   prepareInsert(op) {
     const upsertKeys = op.data._upsert_keys;
     const data = { ...op.data };
@@ -925,7 +940,6 @@ class SubgraphContext {
       for (const r of batch.rows.values()) {
         const keyPred = batch.keyCols.map((k) => `"${k}" = ${escapeLiteral(r.keys[k])}`).join(" AND ");
         const updSet = batch.deltaCols.map((c) => `"${c}" = COALESCE("${c}", 0) + (${String(r.deltas[c] ?? 0n)})`).join(", ");
-        statements.push(`UPDATE ${qualifiedTable} SET ${updSet} WHERE ${keyPred}`);
         const insertVals = [
           ...batch.keyCols.map((k) => escapeLiteral(r.keys[k])),
           ...batch.deltaCols.map((c) => String(r.deltas[c] ?? 0n)),
@@ -933,7 +947,13 @@ class SubgraphContext {
           escapeLiteral(r.meta.txId),
           "NOW()"
         ];
-        statements.push(`INSERT INTO ${qualifiedTable} (${cols.map((c) => `"${c}"`).join(", ")}) ` + `SELECT ${insertVals.join(", ")} ` + `WHERE NOT EXISTS (SELECT 1 FROM ${qualifiedTable} WHERE ${keyPred})`);
+        statements.push({
+          kind: "increment",
+          table: batch.table,
+          keyPred,
+          update: `UPDATE ${qualifiedTable} SET ${updSet} WHERE ${keyPred}`,
+          insert: `INSERT INTO ${qualifiedTable} (${cols.map((c) => `"${c}"`).join(", ")}) ` + `SELECT ${insertVals.join(", ")} ` + `WHERE NOT EXISTS (SELECT 1 FROM ${qualifiedTable} WHERE ${keyPred})`
+        });
       }
       incBatch = null;
       incBatchKey = "";
@@ -3568,9 +3588,9 @@ async function processBlockRange(def, opts) {
   return { blocksProcessed, totalEventsProcessed, totalErrors, aborted };
 }
 async function resolveBlockRange(source, def, opts) {
-  const fromBlock = opts?.fromBlock ?? def.startBlock ?? 1;
-  const toBlock = opts?.toBlock != null ? opts.toBlock : await source.getTip();
-  return { fromBlock, toBlock };
+  const definitionStart = def.startBlock ?? 1;
+  const fromBlock = opts?.startBlockFloor != null ? Math.max(definitionStart, opts.startBlockFloor) : definitionStart;
+  return { fromBlock, toBlock: await source.getTip() };
 }
 async function clearReindexMetadata(db, subgraphName) {
   await db.updateTable("subgraphs").set({ reindex_from_block: null, reindex_to_block: null }).where("name", "=", subgraphName).execute();
@@ -5086,5 +5106,5 @@ export {
   ByoBreakingChangeError
 };
 
-//# debugId=8CAA9C7AD1208F2564756E2164756E21
+//# debugId=7F2918CDE1AF5BC064756E2164756E21
 //# sourceMappingURL=index.js.map