@secondlayer/subgraphs 3.26.1 → 3.26.2

package/dist/src/index.js

@@ -3259,9 +3259,278 @@ class StatsAccumulator {
   }
 }
 
+// src/runtime/catchup.ts
+import { getTargetDb as getTargetDb2, sql as sql4 } from "@secondlayer/shared/db";
+import { getSubgraph } from "@secondlayer/shared/db/queries/subgraphs";
+import { logger as logger8 } from "@secondlayer/shared/logger";
+
+// src/runtime/catchup-leader.ts
+import {
+  SUBGRAPH_CATCHUP_LOCK_KEY,
+  createPostgresLeaderBackend,
+  withLeaderLock
+} from "@secondlayer/shared/leader";
+import { targetListenerUrl } from "@secondlayer/shared/queue/listener";
+var catchUpLeader = false;
+function isCatchUpLeader() {
+  return catchUpLeader;
+}
+function startCatchUpLeader(opts = {}) {
+  return withLeaderLock(SUBGRAPH_CATCHUP_LOCK_KEY, async () => {
+    catchUpLeader = true;
+    await opts.onAcquire?.();
+    return () => {
+      catchUpLeader = false;
+    };
+  }, {
+    pollMs: opts.pollMs,
+    heartbeatMs: opts.heartbeatMs,
+    createBackend: opts.createBackend ?? (() => createPostgresLeaderBackend(targetListenerUrl()))
+  });
+}
+
+// src/runtime/catchup.ts
+var LOG_INTERVAL = 1000;
+var STANDARD_CATCHUP_BATCH_CONFIG = {
+  defaultBatchSize: 500,
+  minBatchSize: 100,
+  maxBatchSize: 1000,
+  prefetch: true
+};
+var catchingUp = new Set;
+var subgraphBlockLockHeld = new Set;
+var subgraphBlockLockWaiters = new Map;
+var reorgEpoch = new Map;
+async function acquireSubgraphBlockLock(name) {
+  if (!subgraphBlockLockHeld.has(name)) {
+    subgraphBlockLockHeld.add(name);
+    return () => releaseSubgraphBlockLock(name);
+  }
+  return new Promise((resolve) => {
+    const waiters = subgraphBlockLockWaiters.get(name) ?? [];
+    waiters.push(() => resolve(() => releaseSubgraphBlockLock(name)));
+    subgraphBlockLockWaiters.set(name, waiters);
+  });
+}
+function releaseSubgraphBlockLock(name) {
+  const waiters = subgraphBlockLockWaiters.get(name);
+  if (waiters && waiters.length > 0) {
+    const next = waiters.shift();
+    if (waiters.length === 0)
+      subgraphBlockLockWaiters.delete(name);
+    next();
+    return;
+  }
+  subgraphBlockLockHeld.delete(name);
+}
+async function withSubgraphBlockLock(name, fn) {
+  const release = await acquireSubgraphBlockLock(name);
+  try {
+    return await fn();
+  } finally {
+    release();
+  }
+}
+async function withSubgraphBlockAdvisoryLock(name, fn) {
+  return getTargetDb2().transaction().execute(async (lockTx) => {
+    await sql4`SELECT pg_advisory_xact_lock(hashtext(${`subgraph-block:${name}`}))`.execute(lockTx);
+    return fn();
+  });
+}
+async function withSubgraphBlockWriteLock(name, fn) {
+  return withSubgraphBlockLock(name, () => withSubgraphBlockAdvisoryLock(name, fn));
+}
+function bumpReorgEpoch(name) {
+  reorgEpoch.set(name, (reorgEpoch.get(name) ?? 0) + 1);
+}
+function getReorgEpoch(name) {
+  return reorgEpoch.get(name) ?? 0;
+}
+
+class ReorgEpochChangedError extends Error {
+  constructor(name) {
+    super(`reorg epoch changed for ${name} mid catch-up`);
+    this.name = "ReorgEpochChangedError";
+  }
+}
+function parsePositiveInt(value) {
+  if (value == null || value.trim() === "")
+    return;
+  const parsed = Number.parseInt(value, 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : undefined;
+}
+function parseBoolean(value) {
+  if (value == null || value.trim() === "")
+    return;
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "true")
+    return true;
+  if (normalized === "false")
+    return false;
+  return;
+}
+function resolveCatchupBatchConfig(env = process.env) {
+  const base = STANDARD_CATCHUP_BATCH_CONFIG;
+  const minBatchSize = parsePositiveInt(env.SUBGRAPH_CATCHUP_MIN_BATCH_SIZE) ?? base.minBatchSize;
+  const maxBatchSize = parsePositiveInt(env.SUBGRAPH_CATCHUP_MAX_BATCH_SIZE) ?? base.maxBatchSize;
+  const defaultBatchSize = parsePositiveInt(env.SUBGRAPH_CATCHUP_BATCH_SIZE) ?? base.defaultBatchSize;
+  return {
+    minBatchSize,
+    maxBatchSize,
+    defaultBatchSize: Math.min(Math.max(defaultBatchSize, minBatchSize), maxBatchSize),
+    prefetch: parseBoolean(env.SUBGRAPH_CATCHUP_PREFETCH) ?? base.prefetch
+  };
+}
+function adjustBatchSize(current, avgEvents, config) {
+  if (avgEvents > 50)
+    return Math.max(Math.round(current * 0.5), config.minBatchSize);
+  if (avgEvents < 10)
+    return Math.min(Math.round(current * 1.5), config.maxBatchSize);
+  return current;
+}
+async function catchUpSubgraph(subgraph, subgraphName) {
+  if (catchingUp.has(subgraphName))
+    return 0;
+  catchingUp.add(subgraphName);
+  try {
+    const source = resolveBlockSource(subgraph);
+    const targetDb = getTargetDb2();
+    const subgraphRow = await getSubgraph(targetDb, subgraphName);
+    if (!subgraphRow)
+      return 0;
+    const lastProcessedBlock = Number(subgraphRow.last_processed_block);
+    const chainTip = await source.getTip();
+    if (chainTip <= 0 || lastProcessedBlock >= chainTip)
+      return 0;
+    const subgraphStart = Number(subgraphRow.start_block) || 1;
+    const startBlock = Math.max(lastProcessedBlock + 1, subgraphStart);
+    const totalBlocks = chainTip - lastProcessedBlock;
+    logger8.info("Subgraph catch-up starting", {
+      subgraph: subgraphName,
+      from: startBlock,
+      to: chainTip,
+      blocks: totalBlocks
+    });
+    const stats = new StatsAccumulator(subgraphName, true);
+    let processed = 0;
+    const batchConfig = resolveCatchupBatchConfig();
+    let batchSize = batchConfig.defaultBatchSize;
+    let currentHeight = startBlock;
+    const walkEpoch = getReorgEpoch(subgraphName);
+    let prefetchedBatchEnd = Math.min(currentHeight + batchSize - 1, chainTip);
+    let nextBatchPromise = batchConfig.prefetch ? source.loadBlockRange(currentHeight, prefetchedBatchEnd) : undefined;
+    while (currentHeight <= chainTip) {
+      if (!isCatchUpLeader()) {
+        logger8.info("Lost catch-up leadership, stopping catch-up", {
+          subgraph: subgraphName,
+          processed
+        });
+        break;
+      }
+      const currentRow = await getSubgraph(targetDb, subgraphName);
+      if (!currentRow || currentRow.status !== "active") {
+        logger8.info("Subgraph status changed, stopping catch-up", {
+          subgraph: subgraphName,
+          status: currentRow?.status ?? "deleted"
+        });
+        break;
+      }
+      let batchEnd;
+      let batch;
+      if (nextBatchPromise) {
+        batch = await nextBatchPromise;
+        batchEnd = prefetchedBatchEnd;
+        const nextStart = batchEnd + 1;
+        if (nextStart <= chainTip) {
+          prefetchedBatchEnd = Math.min(nextStart + batchSize - 1, chainTip);
+          nextBatchPromise = source.loadBlockRange(nextStart, prefetchedBatchEnd);
+        } else {
+          nextBatchPromise = undefined;
+        }
+      } else {
+        batchEnd = Math.min(currentHeight + batchSize - 1, chainTip);
+        batch = await source.loadBlockRange(currentHeight, batchEnd);
+      }
+      let stopCatchup = false;
+      for (let height = currentHeight;height <= batchEnd; height++) {
+        let blockData = batch.get(height);
+        if (!blockData) {
+          blockData = (await source.loadBlockRange(height, height)).get(height);
+        }
+        if (!blockData) {
+          logger8.warn("Block missing during catch-up, deferring to next tick", {
+            subgraph: subgraphName,
+            blockHeight: height
+          });
+          stopCatchup = true;
+          break;
+        }
+        const preloaded = blockData;
+        let result;
+        try {
+          result = await withSubgraphBlockWriteLock(subgraphName, async () => {
+            if (getReorgEpoch(subgraphName) !== walkEpoch) {
+              throw new ReorgEpochChangedError(subgraphName);
+            }
+            return processBlockWithRetry(subgraph, subgraphName, height, {
+              preloaded
+            });
+          });
+        } catch (err) {
+          if (err instanceof ReorgEpochChangedError) {
+            logger8.info("Reorg detected mid catch-up, aborting walk without writing further progress", { subgraph: subgraphName, blockHeight: height });
+            stopCatchup = true;
+            break;
+          }
+          const errorMsg = err instanceof Error ? err.message : String(err);
+          logger8.error("Block processing failed persistently during catch-up", {
+            subgraph: subgraphName,
+            blockHeight: height,
+            error: errorMsg
+          });
+          const { updateSubgraphStatus: updateSubgraphStatus2, recordSubgraphProcessed: recordSubgraphProcessed2 } = await import("@secondlayer/shared/db/queries/subgraphs");
+          await recordSubgraphProcessed2(targetDb, subgraphName, 0, 1, `catch-up halted at block ${height}: ${errorMsg}`).catch(() => {});
+          await updateSubgraphStatus2(targetDb, subgraphName, "error").catch(() => {});
+          stopCatchup = true;
+          break;
+        }
+        processed++;
+        if (result.timing) {
+          stats.record(result.timing, result.processed);
+          if (stats.shouldFlush()) {
+            await stats.flush(targetDb);
+          }
+        }
+        if (processed % LOG_INTERVAL === 0) {
+          logger8.info("Subgraph catch-up progress", {
+            subgraph: subgraphName,
+            processed,
+            total: totalBlocks,
+            currentBlock: height,
+            pct: Math.round(processed / totalBlocks * 100)
+          });
+        }
+      }
+      if (stopCatchup)
+        break;
+      const avg = avgEventsPerBlock(batch);
+      batchSize = adjustBatchSize(batchSize, avg, batchConfig);
+      currentHeight = batchEnd + 1;
+    }
+    await stats.flush(targetDb);
+    logger8.info("Subgraph catch-up complete", {
+      subgraph: subgraphName,
+      processed
+    });
+    return processed;
+  } finally {
+    catchingUp.delete(subgraphName);
+  }
+}
+
 // src/runtime/reindex.ts
 import { getErrorMessage as getErrorMessage3 } from "@secondlayer/shared";
-import { getRawClient, getTargetDb as getTargetDb2 } from "@secondlayer/shared/db";
+import { getRawClient, getTargetDb as getTargetDb3 } from "@secondlayer/shared/db";
 import {
   recordGapBatch,
   resolveGaps
@@ -3274,11 +3543,11 @@ import {
   recordSubgraphProcessed as recordSubgraphProcessed2,
   updateSubgraphStatus as updateSubgraphStatus2
 } from "@secondlayer/shared/db/queries/subgraphs";
-import { logger as logger9 } from "@secondlayer/shared/logger";
+import { logger as logger10 } from "@secondlayer/shared/logger";
 
 // src/runtime/reindex-notify.ts
 import { getErrorMessage as getErrorMessage2 } from "@secondlayer/shared";
-import { logger as logger8 } from "@secondlayer/shared/logger";
+import { logger as logger9 } from "@secondlayer/shared/logger";
 async function notifyReindexComplete(db, subgraphName, stats) {
   try {
     const subgraph = await db.selectFrom("subgraphs").select(["account_id"]).where("name", "=", subgraphName).executeTakeFirst();
@@ -3289,7 +3558,7 @@ async function notifyReindexComplete(db, subgraphName, stats) {
       return;
     const resendKey = process.env.RESEND_API_KEY;
     if (!resendKey) {
-      logger8.warn("RESEND_API_KEY unset — skipping reindex-complete email", {
+      logger9.warn("RESEND_API_KEY unset — skipping reindex-complete email", {
         subgraph: subgraphName
       });
       return;
@@ -3311,14 +3580,14 @@ async function notifyReindexComplete(db, subgraphName, stats) {
     });
     if (!res.ok) {
       const text = await res.text().catch(() => "");
-      logger8.warn("reindex-complete email failed", {
+      logger9.warn("reindex-complete email failed", {
         subgraph: subgraphName,
         status: res.status,
         body: text.slice(0, 200)
       });
     }
   } catch (err) {
-    logger8.warn("reindex-complete email threw", {
+    logger9.warn("reindex-complete email threw", {
       subgraph: subgraphName,
       error: getErrorMessage2(err)
     });
@@ -3326,7 +3595,7 @@ async function notifyReindexComplete(db, subgraphName, stats) {
 }
 
 // src/runtime/reindex.ts
-var LOG_INTERVAL = 1000;
+var LOG_INTERVAL2 = 1000;
 var HEALTH_FLUSH_INTERVAL = 1000;
 var PROGRESS_FLUSH_INTERVAL_MS = 5000;
 var EMPTY_BATCH_HALT_THRESHOLD = 3;
@@ -3346,7 +3615,7 @@ function resolveReindexResumeBlock(row) {
   const reindexFromBlock = Number(row.reindex_from_block);
   return Math.max(lastProcessedBlock + 1, reindexFromBlock);
 }
-function parsePositiveInt(value) {
+function parsePositiveInt2(value) {
   if (value == null || value.trim() === "")
     return;
   const parsed = Number.parseInt(value, 10);
@@ -3354,9 +3623,9 @@ function parsePositiveInt(value) {
 }
 function resolveReindexBatchConfig(env = process.env) {
   const base = STANDARD_REINDEX_BATCH_CONFIG;
-  const minBatchSize = parsePositiveInt(env.SUBGRAPH_REINDEX_MIN_BATCH_SIZE) ?? base.minBatchSize;
-  const maxBatchSize = parsePositiveInt(env.SUBGRAPH_REINDEX_MAX_BATCH_SIZE) ?? base.maxBatchSize;
-  const defaultBatchSize = parsePositiveInt(env.SUBGRAPH_REINDEX_BATCH_SIZE) ?? base.defaultBatchSize;
+  const minBatchSize = parsePositiveInt2(env.SUBGRAPH_REINDEX_MIN_BATCH_SIZE) ?? base.minBatchSize;
+  const maxBatchSize = parsePositiveInt2(env.SUBGRAPH_REINDEX_MAX_BATCH_SIZE) ?? base.maxBatchSize;
+  const defaultBatchSize = parsePositiveInt2(env.SUBGRAPH_REINDEX_BATCH_SIZE) ?? base.defaultBatchSize;
   return {
     minBatchSize,
     maxBatchSize,
@@ -3387,7 +3656,7 @@ function coalesceFailedBlocks(blocks) {
 }
 async function processBlockRange(def, opts) {
   const source = resolveBlockSource(def);
-  const targetDb = getTargetDb2();
+  const targetDb = getTargetDb3();
   const subgraphName = def.name;
   const { fromBlock, toBlock, status } = opts;
   const totalBlocks = toBlock - fromBlock + 1;
@@ -3430,7 +3699,7 @@ async function processBlockRange(def, opts) {
   while (currentHeight <= toBlock) {
     if (opts.signal?.aborted) {
       aborted = true;
-      logger9.info("Block processing aborted", {
+      logger10.info("Block processing aborted", {
         subgraph: subgraphName,
         currentBlock: currentHeight,
         reason: String(opts.signal.reason ?? "unknown")
@@ -3472,14 +3741,16 @@ async function processBlockRange(def, opts) {
       }
       let result;
       try {
-        result = await processBlockWithRetry(def, subgraphName, height, {
+        const mayWrite = blockData.txs.length > 0 || blockData.events.length > 0;
+        const runBlock = () => processBlockWithRetry(def, subgraphName, height, {
           skipProgressUpdate: true,
           atomicProgress,
           preloaded: blockData
         });
+        result = mayWrite ? await withSubgraphBlockWriteLock(subgraphName, runBlock) : await runBlock();
       } catch (err) {
         const errorMsg = getErrorMessage3(err);
-        logger9.error("Block processing failed persistently", {
+        logger10.error("Block processing failed persistently", {
           subgraph: subgraphName,
           blockHeight: height,
           error: errorMsg
@@ -3524,8 +3795,8 @@ async function processBlockRange(def, opts) {
         }
         lastProgressFlushAt = now;
       }
-      if (blocksProcessed % LOG_INTERVAL === 0) {
-        logger9.info(`${status === "reindexing" ? "Reindex" : "Backfill"} progress`, {
+      if (blocksProcessed % LOG_INTERVAL2 === 0) {
+        logger10.info(`${status === "reindexing" ? "Reindex" : "Backfill"} progress`, {
           subgraph: subgraphName,
           processed: blocksProcessed,
           total: totalBlocks,
@@ -3545,7 +3816,7 @@ async function processBlockRange(def, opts) {
     if (batchFailedBlocks.length > 0 && opts.subgraphId) {
       const gaps = coalesceFailedBlocks(batchFailedBlocks);
       await recordGapBatch(targetDb, opts.subgraphId, subgraphName, gaps).catch((err) => {
-        logger9.warn("Failed to record subgraph gaps", {
+        logger10.warn("Failed to record subgraph gaps", {
           subgraph: subgraphName,
           error: err instanceof Error ? err.message : String(err)
         });
@@ -3562,7 +3833,7 @@ async function processBlockRange(def, opts) {
         } else {
           await updateSubgraphStatus2(targetDb, subgraphName, status, jumpTo - 1);
         }
-        logger9.info("Sparse skip", {
+        logger10.info("Sparse skip", {
           subgraph: subgraphName,
           from: batchEnd + 1,
           to: jumpTo - 1,
@@ -3597,16 +3868,16 @@ async function clearReindexMetadata(db, subgraphName) {
 }
 async function reindexSubgraph(def, opts) {
   const source = resolveBlockSource(def);
-  const targetDb = getTargetDb2();
+  const targetDb = getTargetDb3();
   const client = getRawClient("target");
   const subgraphName = def.name;
   const schemaName = opts?.schemaName ?? pgSchemaName(subgraphName);
   await updateSubgraphStatus2(targetDb, subgraphName, "reindexing");
-  logger9.info("Reindex starting", { subgraph: subgraphName });
+  logger10.info("Reindex starting", { subgraph: subgraphName });
   try {
     const { fromBlock, toBlock } = await resolveBlockRange(source, def, opts);
     if (fromBlock > toBlock) {
-      logger9.info("No blocks to reindex", {
+      logger10.info("No blocks to reindex", {
         subgraph: subgraphName,
         fromBlock,
         toBlock
@@ -3620,7 +3891,7 @@ async function reindexSubgraph(def, opts) {
       await client.unsafe(stmt);
     }
     await updateSubgraphStatus2(targetDb, subgraphName, "reindexing", Math.max(0, fromBlock - 1));
-    logger9.info("Schema recreated for reindex", {
+    logger10.info("Schema recreated for reindex", {
       subgraph: subgraphName,
       cursorResetTo: Math.max(0, fromBlock - 1)
     });
@@ -3634,7 +3905,7 @@ async function reindexSubgraph(def, opts) {
       last_error_at: null,
       updated_at: new Date
     }).where("name", "=", subgraphName).execute();
-    logger9.info("Reindexing blocks", {
+    logger10.info("Reindexing blocks", {
       subgraph: subgraphName,
       fromBlock,
       toBlock,
@@ -3656,9 +3927,9 @@ async function reindexSubgraph(def, opts) {
       if (reason === "user-cancelled") {
         await updateSubgraphStatus2(targetDb, subgraphName, "active");
         await clearReindexMetadata(targetDb, subgraphName);
-        logger9.info("Reindex cancelled by user", { subgraph: subgraphName });
+        logger10.info("Reindex cancelled by user", { subgraph: subgraphName });
       } else {
-        logger9.info("Reindex interrupted by shutdown, will resume", {
+        logger10.info("Reindex interrupted by shutdown, will resume", {
           subgraph: subgraphName
         });
       }
@@ -3666,7 +3937,7 @@ async function reindexSubgraph(def, opts) {
     }
     await updateSubgraphStatus2(targetDb, subgraphName, "active", toBlock);
     await clearReindexMetadata(targetDb, subgraphName);
-    logger9.info("Reindex complete", {
+    logger10.info("Reindex complete", {
       subgraph: subgraphName,
       blocks: result.blocksProcessed,
       events: result.totalEventsProcessed,
@@ -3679,7 +3950,7 @@ async function reindexSubgraph(def, opts) {
     });
     return { processed: result.blocksProcessed };
   } catch (err) {
-    logger9.error("Reindex failed", {
+    logger10.error("Reindex failed", {
       subgraph: subgraphName,
       error: getErrorMessage3(err)
     });
@@ -3688,7 +3959,7 @@ async function reindexSubgraph(def, opts) {
   }
 }
 async function resumeReindex(def, opts) {
-  const targetDb = getTargetDb2();
+  const targetDb = getTargetDb3();
   const subgraphName = def.name;
   const row = await targetDb.selectFrom("subgraphs").select([
     "id",
@@ -3701,7 +3972,7 @@ async function resumeReindex(def, opts) {
   const fromBlock = resolveReindexResumeBlock(row);
   const toBlock = Number(row.reindex_to_block);
   if (fromBlock == null) {
-    logger9.info("No reindex metadata, starting fresh reindex", {
+    logger10.info("No reindex metadata, starting fresh reindex", {
       subgraph: subgraphName
     });
     return reindexSubgraph(def, {
@@ -3710,12 +3981,12 @@ async function resumeReindex(def, opts) {
     });
   }
   if (fromBlock > toBlock) {
-    logger9.info("Resume: no remaining blocks", { subgraph: subgraphName });
+    logger10.info("Resume: no remaining blocks", { subgraph: subgraphName });
     await updateSubgraphStatus2(targetDb, subgraphName, "active", toBlock);
     await clearReindexMetadata(targetDb, subgraphName);
     return { processed: 0 };
   }
-  logger9.info("Resuming reindex", {
+  logger10.info("Resuming reindex", {
     subgraph: subgraphName,
     fromBlock,
     toBlock,
@@ -3737,9 +4008,9 @@ async function resumeReindex(def, opts) {
       if (reason === "user-cancelled") {
         await updateSubgraphStatus2(targetDb, subgraphName, "active");
         await clearReindexMetadata(targetDb, subgraphName);
-        logger9.info("Resume cancelled by user", { subgraph: subgraphName });
+        logger10.info("Resume cancelled by user", { subgraph: subgraphName });
       } else {
-        logger9.info("Resume interrupted by shutdown, will resume again", {
+        logger10.info("Resume interrupted by shutdown, will resume again", {
           subgraph: subgraphName
         });
       }
@@ -3747,13 +4018,13 @@ async function resumeReindex(def, opts) {
     }
     await updateSubgraphStatus2(targetDb, subgraphName, "active", toBlock);
     await clearReindexMetadata(targetDb, subgraphName);
-    logger9.info("Resumed reindex complete", {
+    logger10.info("Resumed reindex complete", {
       subgraph: subgraphName,
       blocks: result.blocksProcessed
     });
     return { processed: result.blocksProcessed };
   } catch (err) {
-    logger9.error("Resumed reindex failed", {
+    logger10.error("Resumed reindex failed", {
       subgraph: subgraphName,
       error: getErrorMessage3(err)
     });
@@ -3762,9 +4033,9 @@ async function resumeReindex(def, opts) {
   }
 }
 async function backfillSubgraph(def, opts) {
-  const targetDb = getTargetDb2();
+  const targetDb = getTargetDb3();
   const subgraphName = def.name;
-  logger9.info("Backfill starting", {
+  logger10.info("Backfill starting", {
     subgraph: subgraphName,
     from: opts.fromBlock,
     to: opts.toBlock
@@ -3782,17 +4053,17 @@ async function backfillSubgraph(def, opts) {
       signal: opts.signal
     });
     if (result.aborted) {
-      logger9.info("Backfill aborted", { subgraph: subgraphName });
+      logger10.info("Backfill aborted", { subgraph: subgraphName });
       return { processed: result.blocksProcessed };
     }
     const resolved = await resolveGaps(targetDb, subgraphName, opts.fromBlock, opts.toBlock).catch(() => 0);
     if (resolved > 0) {
-      logger9.info("Resolved subgraph gaps via backfill", {
+      logger10.info("Resolved subgraph gaps via backfill", {
         subgraph: subgraphName,
         resolved
       });
     }
-    logger9.info("Backfill complete", {
+    logger10.info("Backfill complete", {
       subgraph: subgraphName,
       blocks: result.blocksProcessed,
       events: result.totalEventsProcessed,
@@ -3800,7 +4071,7 @@ async function backfillSubgraph(def, opts) {
     });
     return { processed: result.blocksProcessed };
   } catch (err) {
-    logger9.error("Backfill failed", {
+    logger10.error("Backfill failed", {
       subgraph: subgraphName,
       error: getErrorMessage3(err)
     });
@@ -4721,7 +4992,7 @@ function generateIndexSchema(target, opts = {}) {
 }
 var INDEX_CODEGEN_TABLES = Object.keys(SOURCE_READ_TYPES);
 // src/schema/deployer.ts
-import { sql as sql4 } from "kysely";
+import { sql as sql5 } from "kysely";
 function toJsonSafe(obj) {
   return JSON.parse(JSON.stringify(obj, (_key, value) => typeof value === "bigint" ? value.toString() : value));
 }
@@ -4836,7 +5107,7 @@ function renderDeployPlan(def, schemaName) {
 async function deploySchema(db, def, handlerPath, opts) {
   validateSubgraphDefinition(def);
   const { statements, hash } = generateSubgraphSQL(def, opts?.schemaName);
-  const { getSubgraph, registerSubgraph } = await import("@secondlayer/shared/db/queries/subgraphs");
+  const { getSubgraph: getSubgraph2, registerSubgraph } = await import("@secondlayer/shared/db/queries/subgraphs");
   const ddlDb = opts?.dataDb ?? db;
   const byo = opts?.dataDb != null;
   const refuseDestructiveOnByo = (reasons, diff) => {
@@ -4848,7 +5119,7 @@ async function deploySchema(db, def, handlerPath, opts) {
       grantScript: plan.grantScript
     });
   };
-  const existing = await getSubgraph(db, def.name, opts?.accountId);
+  const existing = await getSubgraph2(db, def.name, opts?.accountId);
   const schemaName = opts?.schemaName ?? pgSchemaName(def.name);
   const newVersion = opts?.version ?? (existing ? bumpPatch(existing.version) : "1.0.0");
   const regData = {
@@ -4873,7 +5144,7 @@ async function deploySchema(db, def, handlerPath, opts) {
     databaseUrlEnc: opts?.databaseUrlEnc ?? null
   };
   if (existing) {
-    const schemaExists = await sql4`
+    const schemaExists = await sql5`
 			SELECT EXISTS (
 				SELECT 1 FROM information_schema.schemata
 				WHERE schema_name = ${schemaName}
@@ -4881,7 +5152,7 @@ async function deploySchema(db, def, handlerPath, opts) {
 		`.execute(ddlDb).then((r) => r.rows[0]?.exists ?? false);
     if (!schemaExists) {
       for (const stmt of statements) {
-        await sql4.raw(stmt).execute(ddlDb);
+        await sql5.raw(stmt).execute(ddlDb);
       }
       const sg2 = await registerSubgraph(db, regData);
       return { action: "reindexed", subgraphId: sg2.id, version: newVersion };
@@ -4907,9 +5178,9 @@ async function deploySchema(db, def, handlerPath, opts) {
     if (existing.schema_hash === hash && opts?.forceReindex) {
       if (byo)
         refuseDestructiveOnByo(["force reindex"], null);
-      await sql4.raw(`DROP SCHEMA IF EXISTS "${schemaName}" CASCADE`).execute(ddlDb);
+      await sql5.raw(`DROP SCHEMA IF EXISTS "${schemaName}" CASCADE`).execute(ddlDb);
       for (const stmt of statements) {
-        await sql4.raw(stmt).execute(ddlDb);
+        await sql5.raw(stmt).execute(ddlDb);
       }
       const sg2 = await registerSubgraph(db, regData);
       return { action: "reindexed", subgraphId: sg2.id, version: newVersion };
@@ -4921,9 +5192,9 @@ async function deploySchema(db, def, handlerPath, opts) {
         if (byo) {
           refuseDestructiveOnByo(reasons.length > 0 ? reasons : ["force reindex"], diff);
         }
-        await sql4.raw(`DROP SCHEMA IF EXISTS "${schemaName}" CASCADE`).execute(ddlDb);
+        await sql5.raw(`DROP SCHEMA IF EXISTS "${schemaName}" CASCADE`).execute(ddlDb);
         for (const stmt of statements) {
-          await sql4.raw(stmt).execute(ddlDb);
+          await sql5.raw(stmt).execute(ddlDb);
         }
         const sg3 = await registerSubgraph(db, regData);
         const deployDiff2 = toDeployDiff(diff, reasons);
@@ -4936,16 +5207,16 @@ async function deploySchema(db, def, handlerPath, opts) {
       }
       const addedDefs = diff.addedTables.map((tableName) => ({ tableName, tableDef: def.schema[tableName] })).filter((t) => t.tableDef !== undefined);
       if (addedDefs.some(({ tableDef }) => tableNeedsTrgm(tableDef))) {
-        await sql4.raw("CREATE EXTENSION IF NOT EXISTS pg_trgm").execute(ddlDb);
+        await sql5.raw("CREATE EXTENSION IF NOT EXISTS pg_trgm").execute(ddlDb);
       }
       for (const { tableName, tableDef } of addedDefs) {
         for (const stmt of emitTableDDL(schemaName, tableName, tableDef)) {
-          await sql4.raw(stmt).execute(ddlDb);
+          await sql5.raw(stmt).execute(ddlDb);
         }
       }
       for (const { tableName, tableDef } of addedDefs) {
         for (const stmt of emitForeignKeyDDL(schemaName, tableName, tableDef)) {
-          await sql4.raw(stmt).execute(ddlDb);
+          await sql5.raw(stmt).execute(ddlDb);
         }
       }
       for (const [tableName, colDiff] of Object.entries(diff.tables)) {
@@ -4963,12 +5234,12 @@ async function deploySchema(db, def, handlerPath, opts) {
           if (!sqlType)
             continue;
           const nullable = col.nullable ? "" : ` NOT NULL DEFAULT ${getDefault(col.type)}`;
-          await sql4.raw(`ALTER TABLE ${qualifiedName} ADD COLUMN ${colName} ${sqlType}${nullable}`).execute(ddlDb);
+          await sql5.raw(`ALTER TABLE ${qualifiedName} ADD COLUMN ${colName} ${sqlType}${nullable}`).execute(ddlDb);
           if (col.indexed) {
-            await sql4.raw(`CREATE INDEX IF NOT EXISTS idx_${schemaName}_${tableName}_${colName} ON ${qualifiedName} (${colName})`).execute(ddlDb);
+            await sql5.raw(`CREATE INDEX IF NOT EXISTS idx_${schemaName}_${tableName}_${colName} ON ${qualifiedName} (${colName})`).execute(ddlDb);
           }
           if (col.search) {
-            await sql4.raw(`CREATE INDEX IF NOT EXISTS idx_${schemaName}_${tableName}_${colName}_trgm ON ${qualifiedName} USING gin (${colName} gin_trgm_ops)`).execute(ddlDb);
+            await sql5.raw(`CREATE INDEX IF NOT EXISTS idx_${schemaName}_${tableName}_${colName}_trgm ON ${qualifiedName} USING gin (${colName} gin_trgm_ops)`).execute(ddlDb);
           }
         }
       }
@@ -4976,7 +5247,7 @@ async function deploySchema(db, def, handlerPath, opts) {
       const flagFlips = {};
       const needsTrgmForFlips = Object.entries(diff.tables).some(([tableName, colDiff]) => colDiff.indexChanged.some((colName) => def.schema[tableName]?.columns[colName]?.search && !existingSchema[tableName]?.columns[colName]?.search));
       if (needsTrgmForFlips) {
-        await sql4.raw("CREATE EXTENSION IF NOT EXISTS pg_trgm").execute(ddlDb);
+        await sql5.raw("CREATE EXTENSION IF NOT EXISTS pg_trgm").execute(ddlDb);
       }
       for (const [tableName, colDiff] of Object.entries(diff.tables)) {
         if (colDiff.indexChanged.length === 0)
@@ -4991,14 +5262,14 @@ async function deploySchema(db, def, handlerPath, opts) {
           const plainIdx = `idx_${schemaName}_${tableName}_${colName}`;
           const trgmIdx = `idx_${schemaName}_${tableName}_${colName}_trgm`;
           if (now.indexed && !was?.indexed) {
-            await sql4.raw(`CREATE INDEX CONCURRENTLY IF NOT EXISTS ${plainIdx} ON ${qualifiedName} (${colName})`).execute(ddlDb);
+            await sql5.raw(`CREATE INDEX CONCURRENTLY IF NOT EXISTS ${plainIdx} ON ${qualifiedName} (${colName})`).execute(ddlDb);
           } else if (!now.indexed && was?.indexed) {
-            await sql4.raw(`DROP INDEX CONCURRENTLY IF EXISTS ${schemaName}.${plainIdx}`).execute(ddlDb);
+            await sql5.raw(`DROP INDEX CONCURRENTLY IF EXISTS ${schemaName}.${plainIdx}`).execute(ddlDb);
           }
           if (now.search && !was?.search) {
-            await sql4.raw(`CREATE INDEX CONCURRENTLY IF NOT EXISTS ${trgmIdx} ON ${qualifiedName} USING gin (${colName} gin_trgm_ops)`).execute(ddlDb);
+            await sql5.raw(`CREATE INDEX CONCURRENTLY IF NOT EXISTS ${trgmIdx} ON ${qualifiedName} USING gin (${colName} gin_trgm_ops)`).execute(ddlDb);
           } else if (!now.search && was?.search) {
-            await sql4.raw(`DROP INDEX CONCURRENTLY IF EXISTS ${schemaName}.${trgmIdx}`).execute(ddlDb);
+            await sql5.raw(`DROP INDEX CONCURRENTLY IF EXISTS ${schemaName}.${trgmIdx}`).execute(ddlDb);
           }
         }
       }
@@ -5007,28 +5278,28 @@ async function deploySchema(db, def, handlerPath, opts) {
         const qualifiedName = `${schemaName}.${tableName}`;
         for (const cols of conDiff.addedUniqueKeys) {
           const constraintName = `uq_${schemaName}_${tableName}_${cols.join("_")}`;
-          const exists = await sql4`
+          const exists = await sql5`
 						SELECT EXISTS (
 							SELECT 1 FROM pg_constraint
 							WHERE conname = ${constraintName}
 						) AS "exists"
 					`.execute(ddlDb).then((r) => r.rows[0]?.exists ?? false);
           if (!exists) {
-            await sql4.raw(`ALTER TABLE ${qualifiedName} ADD CONSTRAINT ${constraintName} UNIQUE (${cols.join(", ")})`).execute(ddlDb);
+            await sql5.raw(`ALTER TABLE ${qualifiedName} ADD CONSTRAINT ${constraintName} UNIQUE (${cols.join(", ")})`).execute(ddlDb);
           }
           addedUq[tableName] = [...addedUq[tableName] ?? [], cols];
         }
         for (const cols of conDiff.addedIndexes) {
           const i = (def.schema[tableName]?.indexes ?? []).findIndex((entry) => JSON.stringify(entry) === JSON.stringify(cols));
           const idxName = `idx_${schemaName}_${tableName}_composite_${i}`;
-          await sql4.raw(`CREATE INDEX CONCURRENTLY IF NOT EXISTS ${idxName} ON ${qualifiedName} (${cols.join(", ")})`).execute(ddlDb);
+          await sql5.raw(`CREATE INDEX CONCURRENTLY IF NOT EXISTS ${idxName} ON ${qualifiedName} (${cols.join(", ")})`).execute(ddlDb);
         }
         for (const cols of conDiff.removedIndexes) {
           const i = (existingSchema[tableName]?.indexes ?? []).findIndex((entry) => JSON.stringify(entry) === JSON.stringify(cols));
           if (i < 0)
             continue;
           const idxName = `idx_${schemaName}_${tableName}_composite_${i}`;
-          await sql4.raw(`DROP INDEX CONCURRENTLY IF EXISTS ${schemaName}.${idxName}`).execute(ddlDb);
+          await sql5.raw(`DROP INDEX CONCURRENTLY IF EXISTS ${schemaName}.${idxName}`).execute(ddlDb);
         }
       }
       const sg2 = await registerSubgraph(db, regData);
@@ -5054,7 +5325,7 @@ async function deploySchema(db, def, handlerPath, opts) {
     }
   }
   for (const stmt of statements) {
-    await sql4.raw(stmt).execute(ddlDb);
+    await sql5.raw(stmt).execute(ddlDb);
   }
   const sg = await registerSubgraph(db, regData);
   return { action: "created", subgraphId: sg.id, version: newVersion };
@@ -5106,5 +5377,5 @@ export {
   ByoBreakingChangeError
 };
 
-//# debugId=7F2918CDE1AF5BC064756E2164756E21
+//# debugId=99416B000428839064756E2164756E21
 //# sourceMappingURL=index.js.map