@secondlayer/subgraphs 3.26.4 → 4.0.1

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

@@ -366,21 +366,10 @@ type EventRecord = {
 };
 import { Database as Database2 } from "@secondlayer/shared/db";
 import { Kysely as Kysely2, Transaction } from "kysely";
-/** f072: thrown by `resolveRoute` when a BYO subgraph needs its user-DB
-*  connection decrypted but this process holds no `SECONDLAYER_SECRETS_KEY`
-*  — the subgraph processor deliberately does not hold the master key (it
-*  runs untrusted handler code in-process, every block; see f049 site 3 /
-*  the sandbox spike doc's D3). Deny by default, fail loud: this must NEVER
-*  be caught and silently rerouted to the managed target DB, since that
-*  would write a tenant's rows into ours — far worse than halting the
-*  block. */
-declare class ByoKeyUnavailableError extends Error {
-	constructor(subgraphName: string);
-}
 /** Drop a subgraph's cached route — call on redeploy/delete (conn may
 *  change). Also evicts any warm sandbox subprocess for this subgraph
 *  (f071 Stage A `host.ts`) on the same edge: a redeploy can change
-*  `handler_code`/`version`/the BYO connection together, and a stale warm
+*  `handler_code`/`version` together, and a stale warm
 *  subprocess must not survive past this invalidation any more than the
 *  cached route does. A no-op today since nothing sets `sandbox_workers`,
 *  but keeps the pool's documented invalidation contract honest for when it
@@ -491,4 +480,4 @@ declare const BLOCK_RETRY_DELAYS_MS: number[];
 */
 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 { resolveFactoryContracts, processBlockWithRetry, processBlock, invalidateSubgraphRoute, ProcessBlockTiming, ProcessBlockResult, ProcessBlockOptions, PreloadedBlockData, ByoKeyUnavailableError, BLOCK_RETRY_DELAYS_MS };
+export { resolveFactoryContracts, processBlockWithRetry, processBlock, invalidateSubgraphRoute, ProcessBlockTiming, ProcessBlockResult, ProcessBlockOptions, PreloadedBlockData, BLOCK_RETRY_DELAYS_MS };

package/dist/src/runtime/block-processor.js

@@ -323,16 +323,14 @@ class SubgraphContext {
   pgSchemaName;
   subgraphSchema;
   ops = [];
-  byo;
   journal;
   _client;
-  constructor(db, pgSchemaName2, subgraphSchema, block, tx, byo = false, journal = false) {
+  constructor(db, pgSchemaName2, subgraphSchema, block, tx, journal = false) {
     this.db = db;
     this.pgSchemaName = pgSchemaName2;
     this.subgraphSchema = subgraphSchema;
     this.block = block;
     this._tx = tx;
-    this.byo = byo;
     this.journal = journal;
   }
   get client() {
@@ -701,15 +699,6 @@ class SubgraphContext {
   }
   buildStatements(ops) {
     const statements = [];
-    if (this.byo) {
-      const insertTables = new Set;
-      for (const op of ops)
-        if (op.kind === "insert")
-          insertTables.add(op.table);
-      for (const table of insertTables) {
-        statements.push(`DELETE FROM "${this.pgSchemaName}"."${table}" WHERE "_block_height" = ${this.block.height}`);
-      }
-    }
     let currentBatch = null;
     let currentBatchKey = "";
     let incBatch = null;
@@ -1662,16 +1651,13 @@ function matchSources(sources, transactions, events, traitContracts = new Map, f
 }
 
 // src/runtime/block-processor.ts
-import { secretsKeyAvailable } from "@secondlayer/shared/crypto/secrets";
 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,
   recordLiveError,
   recordLiveProgress,
   recordSubgraphProcessed,
-  resolveSubgraphDb,
   rewindLiveProgress,
   updateSubgraphStatus
 } from "@secondlayer/shared/db/queries/subgraphs";
@@ -2600,26 +2586,14 @@ async function refreshMatcher(db) {
 
 // src/runtime/block-processor.ts
 var routeCache = new Map;
-
-class ByoKeyUnavailableError extends Error {
-  constructor(subgraphName) {
-    super(`subgraph ${subgraphName} is BYO (database_url_enc set) but this process has no SECONDLAYER_SECRETS_KEY — the subgraph processor deliberately does not hold it (f072). Route BYO subgraphs to a process that does, or unset BYO.`);
-    this.name = "ByoKeyUnavailableError";
-  }
-}
 async function resolveRoute(subgraphName, targetDb) {
   const cached = routeCache.get(subgraphName);
   if (cached)
     return cached;
   const row = await targetDb.selectFrom("subgraphs").selectAll().where("name", "=", subgraphName).executeTakeFirst();
-  const byo = row ? isByoSubgraph(row) : false;
-  if (row && byo && !secretsKeyAvailable()) {
-    throw new ByoKeyUnavailableError(subgraphName);
-  }
   const route = {
     schemaName: row?.schema_name ?? pgSchemaName(subgraphName),
-    dataDb: row && byo ? resolveSubgraphDb(row) : targetDb,
-    byo,
+    dataDb: targetDb,
     sandboxWorkers: row?.sandbox_workers === true,
     handlerCode: row?.handler_code ?? null,
     version: row?.version ?? ""
@@ -2827,7 +2801,7 @@ async function processBlock(subgraph, subgraphName, blockHeight, opts) {
       await rewindLiveProgress(tx, subgraphName, blockHeight);
     } else {
       const advanced = await recordLiveProgress(tx, subgraphName, blockHeight);
-      if (!advanced && flushedWrites && !route.byo) {
+      if (!advanced && flushedWrites) {
         throw new LiveCursorRaceLostError(subgraphName, blockHeight);
       }
     }
@@ -2836,122 +2810,79 @@ async function processBlock(subgraph, subgraphName, blockHeight, opts) {
       await recordSubgraphProcessed(tx, subgraphName, rr.processed, rr.errors, lastError);
     }
   };
-  if (route.byo) {
-    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;
+  try {
+    await targetDb.transaction().execute(async (tx) => {
+      const opMode = opCursorMode(opts);
+      const sm = statusMode(opts);
+      const rewind = isReorgRewind(opts);
+      if (sm) {
+        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;
+        }
+      } else if (!rewind) {
+        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;
+        }
       }
-    }
-    let runResult = { processed: 0, errors: 0 };
-    let manifest;
-    await route.dataDb.transaction().execute(async (tx) => {
-      const ctx = new SubgraphContext(tx, schemaName, subgraph.schema, blockMeta, initialTx, true, journalEnabled(opts));
+      const ctx = new SubgraphContext(tx, schemaName, subgraph.schema, blockMeta, initialTx, journalEnabled(opts));
       const handlerStart = performance.now();
-      runResult = await runHandlers(subgraph, matched, ctx);
+      const runResult = sandboxEnabled({
+        sandbox_workers: route.sandboxWorkers
+      }) ? await runHandlersSandboxed({
+        subgraphName,
+        version: route.version,
+        handlerCode: route.handlerCode,
+        hostCtx: ctx,
+        block: blockMeta,
+        matched
+      }) : 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();
-        manifest = await ctx.flush();
+        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;
       }
-    });
-    result.processed = runResult.processed;
-    result.errors = runResult.errors;
-    await persistFactoryDiscoveries(schemaName, route.dataDb, blockHeight, discovered);
-    await targetDb.transaction().execute(async (tx) => {
-      if (manifest && manifest.count > 0) {
-        await emitSubscriptionOutbox(tx, subgraphName, manifest, matcher, block.height);
-      }
-      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);
+      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, manifest ? manifest.count > 0 : false);
+      await applyProgress(tx, runResult, flushedWrites);
     });
-  } else {
-    try {
-      await targetDb.transaction().execute(async (tx) => {
-        const opMode = opCursorMode(opts);
-        const sm = statusMode(opts);
-        const rewind = isReorgRewind(opts);
-        if (sm) {
-          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;
-          }
-        } else if (!rewind) {
-          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;
-          }
-        }
-        const ctx = new SubgraphContext(tx, schemaName, subgraph.schema, blockMeta, initialTx, false, journalEnabled(opts));
-        const handlerStart = performance.now();
-        const runResult = sandboxEnabled({
-          sandbox_workers: route.sandboxWorkers
-        }) ? await runHandlersSandboxed({
-          subgraphName,
-          version: route.version,
-          handlerCode: route.handlerCode,
-          hostCtx: ctx,
-          block: blockMeta,
-          matched
-        }) : 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;
-        }
-        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, flushedWrites);
+  } catch (err) {
+    if (err instanceof CursorRaceLostError || err instanceof LiveCursorRaceLostError) {
+      logger7.warn("cursor race lost — block already covered", {
+        subgraph: subgraphName,
+        blockHeight,
+        error: err.message
       });
-    } catch (err) {
-      if (err instanceof CursorRaceLostError || err instanceof LiveCursorRaceLostError) {
-        logger7.warn("cursor race lost — block already covered", {
-          subgraph: subgraphName,
-          blockHeight,
-          error: err.message
-        });
-        result.skipped = true;
-        return result;
-      }
-      throw err;
+      result.skipped = true;
+      return result;
     }
+    throw err;
+  }
+  if (!result.skipped) {
+    await persistFactoryDiscoveries(schemaName, route.dataDb, blockHeight, discovered);
   }
   const totalMs = performance.now() - blockStart;
   if (!result.skipped) {
@@ -2992,9 +2923,8 @@ export {
   processBlockWithRetry,
   processBlock,
   invalidateSubgraphRoute,
-  ByoKeyUnavailableError,
   BLOCK_RETRY_DELAYS_MS
 };
 
-//# debugId=12259A1169CD0EF964756E2164756E21
+//# debugId=94D930A6B3A998FE64756E2164756E21
 //# sourceMappingURL=block-processor.js.map