@secondlayer/subgraphs 3.25.1 → 3.26.1

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

@@ -574,6 +574,26 @@ declare class SubgraphContext2 {
 	* with the flush itself.
 	*/
 	flush(): Promise<FlushManifest>;
+	/**
+	* Run a built statement list on an open transaction.
+	*
+	* Plain statements run in order. An increment runs UPDATE-first and then,
+	* ONLY if that matched nothing, the guarded INSERT — and if the INSERT also
+	* wrote nothing, the UPDATE again.
+	*
+	* That last step is the whole point. Under READ COMMITTED, two block
+	* transactions flushing the same key while the row is absent both see
+	* `UPDATE → 0 rows`; the first commits its INSERT, and the second's
+	* `WHERE NOT EXISTS` then sees that committed row and inserts nothing. No
+	* error, no constraint violation — the second delta was simply dropped.
+	* Re-running the UPDATE takes a fresh snapshot that DOES see the winner's
+	* row and applies the delta onto it.
+	*
+	* It cannot double-apply: the retry is reached only when the first UPDATE
+	* matched no row AND the INSERT wrote no row, so the delta has not been
+	* applied by either.
+	*/
+	private execStatements;
 	/** Prepare a single insert row, returning its data, columns, upsert key for batching. */
 	private prepareInsert;
 	/**

package/dist/src/service.js

@@ -605,14 +605,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) => {
@@ -631,6 +627,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 };
@@ -710,7 +725,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)),
@@ -718,7 +732,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 = "";
@@ -3353,9 +3373,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();
@@ -4203,8 +4223,7 @@ async function runSubgraphOperation(operation, signal) {
     return result2.processed;
   }
   const result = await reindexSubgraph(def, {
-    fromBlock: operation.from_block == null ? undefined : Number(operation.from_block),
-    toBlock: operation.to_block == null ? undefined : Number(operation.to_block),
+    startBlockFloor: operation.from_block == null ? undefined : Number(operation.from_block),
     schemaName,
     operationId: operation.id,
     signal
@@ -4442,5 +4461,5 @@ var shutdown = async () => {
 process.on("SIGINT", shutdown);
 process.on("SIGTERM", shutdown);
 
-//# debugId=957751E5CE73209364756E2164756E21
+//# debugId=80FE8B3630A7D83D64756E2164756E21
 //# sourceMappingURL=service.js.map