@secondlayer/subgraphs 0.5.0

package/dist/src/runtime/reindex.js

@@ -0,0 +1,738 @@
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/types.ts
+function sourceKey(source) {
+  if (source.contract) {
+    if (source.function)
+      return `${source.contract}::${source.function}`;
+    if (source.event)
+      return `${source.contract}::${source.event}`;
+    return source.contract;
+  }
+  if (source.type)
+    return source.type;
+  return "*";
+}
+
+// src/runtime/context.ts
+import { sql } from "kysely";
+import { logger } from "@secondlayer/shared/logger";
+function validateColumnName(name) {
+  if (!/^[a-z_][a-z0-9_]*$/i.test(name)) {
+    throw new Error(`Invalid column name: ${name}`);
+  }
+}
+
+class SubgraphContext {
+  block;
+  _tx;
+  db;
+  pgSchemaName;
+  subgraphSchema;
+  ops = [];
+  constructor(db, pgSchemaName, subgraphSchema, block, tx) {
+    this.db = db;
+    this.pgSchemaName = pgSchemaName;
+    this.subgraphSchema = subgraphSchema;
+    this.block = block;
+    this._tx = tx;
+  }
+  get tx() {
+    return this._tx;
+  }
+  setTx(tx) {
+    this._tx = tx;
+  }
+  insert(table, row) {
+    this.validateTable(table);
+    this.ops.push({ kind: "insert", table, data: row });
+  }
+  update(table, where, set) {
+    this.validateTable(table);
+    this.ops.push({ kind: "update", table, data: where, set });
+  }
+  upsert(table, key, row) {
+    this.validateTable(table);
+    const tableDef = this.subgraphSchema[table];
+    const keyColumns = Object.keys(key);
+    const hasUniqueConstraint = tableDef.uniqueKeys?.some((uk) => uk.length === keyColumns.length && uk.every((c) => keyColumns.includes(c)));
+    if (hasUniqueConstraint) {
+      this.ops.push({ kind: "insert", table, data: { ...key, ...row, _upsert_keys: keyColumns } });
+    } else {
+      logger.warn("upsert called without matching uniqueKeys constraint, using fallback", {
+        table,
+        keys: keyColumns
+      });
+      this.ops.push({ kind: "insert", table, data: { ...key, ...row, _upsert_fallback_keys: keyColumns, _upsert_fallback_set: row } });
+    }
+  }
+  delete(table, where) {
+    this.validateTable(table);
+    this.ops.push({ kind: "delete", table, data: where });
+  }
+  async findOne(table, where) {
+    this.validateTable(table);
+    const qualifiedTable = `"${this.pgSchemaName}"."${table}"`;
+    const { clause } = buildWhereClause(where);
+    const query = `SELECT * FROM ${qualifiedTable} WHERE ${clause} LIMIT 1`;
+    const { rows } = await sql.raw(query).execute(this.db);
+    return rows[0] ?? null;
+  }
+  async findMany(table, where) {
+    this.validateTable(table);
+    const qualifiedTable = `"${this.pgSchemaName}"."${table}"`;
+    const { clause } = buildWhereClause(where);
+    const query = `SELECT * FROM ${qualifiedTable} WHERE ${clause}`;
+    const { rows } = await sql.raw(query).execute(this.db);
+    return rows;
+  }
+  get pendingOps() {
+    return this.ops.length;
+  }
+  async flush() {
+    if (this.ops.length === 0)
+      return 0;
+    const opsToFlush = [...this.ops];
+    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);
+      }
+    } else {
+      await this.db.transaction().execute(async (tx) => {
+        for (const stmt of statements) {
+          await sql.raw(stmt).execute(tx);
+        }
+      });
+    }
+    return opsToFlush.length;
+  }
+  buildStatements(ops) {
+    const statements = [];
+    for (const op of ops) {
+      const qualifiedTable = `"${this.pgSchemaName}"."${op.table}"`;
+      switch (op.kind) {
+        case "insert": {
+          const upsertKeys = op.data._upsert_keys;
+          const fallbackKeys = op.data._upsert_fallback_keys;
+          const fallbackSet = op.data._upsert_fallback_set;
+          const data = { ...op.data };
+          delete data._upsert_keys;
+          delete data._upsert_fallback_keys;
+          delete data._upsert_fallback_set;
+          data._block_height = this.block.height;
+          data._tx_id = this._tx.txId;
+          data._created_at = "NOW()";
+          const cols = Object.keys(data);
+          cols.forEach(validateColumnName);
+          const vals = cols.map((c) => data[c] === "NOW()" ? "NOW()" : escapeLiteral(data[c]));
+          let stmt = `INSERT INTO ${qualifiedTable} (${cols.map((c) => `"${c}"`).join(", ")}) VALUES (${vals.join(", ")})`;
+          if (upsertKeys && upsertKeys.length > 0) {
+            const updateCols = cols.filter((c) => !upsertKeys.includes(c) && !c.startsWith("_"));
+            if (updateCols.length > 0) {
+              const setClauses = updateCols.map((c) => `"${c}" = EXCLUDED."${c}"`);
+              stmt += ` ON CONFLICT (${upsertKeys.map((k) => `"${k}"`).join(", ")}) DO UPDATE SET ${setClauses.join(", ")}`;
+            } else {
+              stmt += ` ON CONFLICT (${upsertKeys.map((k) => `"${k}"`).join(", ")}) DO NOTHING`;
+            }
+          } else if (fallbackKeys && fallbackSet) {}
+          statements.push(stmt);
+          break;
+        }
+        case "update": {
+          const setEntries = Object.entries(op.set);
+          setEntries.forEach(([k]) => validateColumnName(k));
+          const setClauses = setEntries.map(([k, v]) => `"${k}" = ${escapeLiteral(v)}`);
+          const { clause } = buildWhereClause(op.data);
+          statements.push(`UPDATE ${qualifiedTable} SET ${setClauses.join(", ")} WHERE ${clause}`);
+          break;
+        }
+        case "delete": {
+          const { clause } = buildWhereClause(op.data);
+          statements.push(`DELETE FROM ${qualifiedTable} WHERE ${clause}`);
+          break;
+        }
+      }
+    }
+    return statements;
+  }
+  validateTable(table) {
+    if (!this.subgraphSchema[table]) {
+      throw new Error(`Table "${table}" not found in subgraph schema. Available: [${Object.keys(this.subgraphSchema).join(", ")}]`);
+    }
+  }
+}
+function escapeLiteral(value) {
+  if (value === null || value === undefined)
+    return "NULL";
+  if (typeof value === "number" || typeof value === "bigint")
+    return String(value);
+  if (typeof value === "boolean")
+    return value ? "TRUE" : "FALSE";
+  if (typeof value === "object")
+    return `'${JSON.stringify(value).replace(/'/g, "''")}'::jsonb`;
+  return `'${String(value).replace(/'/g, "''")}'`;
+}
+function buildWhereClause(where) {
+  const entries = Object.entries(where);
+  if (entries.length === 0)
+    return { clause: "TRUE", values: [] };
+  entries.forEach(([k]) => validateColumnName(k));
+  const parts = entries.map(([k, v]) => `"${k}" = ${escapeLiteral(v)}`);
+  return { clause: parts.join(" AND "), values: [] };
+}
+
+// src/runtime/source-matcher.ts
+function matchPattern(value, pattern) {
+  if (!pattern.includes("*"))
+    return value === pattern;
+  const regex = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+  return new RegExp(`^${regex}$`).test(value);
+}
+function matchSource(source, transactions, eventsByTx) {
+  const results = [];
+  const key = sourceKey(source);
+  for (const tx of transactions) {
+    if (source.type) {
+      if (!matchPattern(tx.type, source.type))
+        continue;
+      const txEvents = eventsByTx.get(tx.tx_id) ?? [];
+      let matchedEvents = txEvents;
+      if (source.minAmount !== undefined) {
+        const amountEvents = matchedEvents.filter((e) => {
+          const data = e.data;
+          const rawAmount = data?.amount;
+          if (rawAmount === undefined)
+            return false;
+          const amount = BigInt(rawAmount);
+          return amount >= source.minAmount;
+        });
+        if (amountEvents.length === 0)
+          continue;
+        matchedEvents = amountEvents;
+      }
+      results.push({ tx, events: matchedEvents, sourceKey: key });
+      continue;
+    }
+    if (source.contract) {
+      const txContractMatch = tx.contract_id && matchPattern(tx.contract_id, source.contract);
+      if (source.function && tx.function_name) {
+        if (!matchPattern(tx.function_name, source.function))
+          continue;
+      } else if (source.function && !tx.function_name) {
+        continue;
+      }
+      const txEvents = eventsByTx.get(tx.tx_id) ?? [];
+      let matchedEvents = txEvents;
+      if (!txContractMatch) {
+        matchedEvents = txEvents.filter((e) => {
+          const data = e.data;
+          const contractIdentifier = data?.contract_identifier;
+          return contractIdentifier && matchPattern(contractIdentifier, source.contract);
+        });
+        if (matchedEvents.length === 0)
+          continue;
+      }
+      if (source.event) {
+        matchedEvents = matchedEvents.filter((e) => {
+          if (matchPattern(e.type, source.event))
+            return true;
+          const data = e.data;
+          const topic = data?.topic;
+          return topic ? matchPattern(topic, source.event) : false;
+        });
+      }
+      if (txContractMatch || matchedEvents.length > 0) {
+        results.push({ tx, events: matchedEvents, sourceKey: key });
+      }
+    }
+  }
+  return results;
+}
+function matchSources(sources, transactions, events) {
+  const eventsByTx = new Map;
+  for (const event of events) {
+    const list = eventsByTx.get(event.tx_id) ?? [];
+    list.push(event);
+    eventsByTx.set(event.tx_id, list);
+  }
+  const seen = new Set;
+  const results = [];
+  for (const source of sources) {
+    const matches = matchSource(source, transactions, eventsByTx);
+    for (const match of matches) {
+      const dedupeKey = `${match.tx.tx_id}:${match.sourceKey}`;
+      if (!seen.has(dedupeKey)) {
+        seen.add(dedupeKey);
+        results.push(match);
+      }
+    }
+  }
+  return results;
+}
+
+// src/runtime/clarity.ts
+import { cvToJSON, deserializeCV } from "@secondlayer/stacks/clarity";
+function decodeClarityValue(hex) {
+  try {
+    const cleanHex = hex.startsWith("0x") ? hex.slice(2) : hex;
+    const cv = deserializeCV(cleanHex);
+    return cvToJSON(cv);
+  } catch {
+    return hex;
+  }
+}
+function decodeEventData(data) {
+  if (typeof data === "string" && data.startsWith("0x") && data.length > 10) {
+    return decodeClarityValue(data);
+  }
+  if (Array.isArray(data)) {
+    return data.map(decodeEventData);
+  }
+  if (typeof data === "object" && data !== null) {
+    const decoded = {};
+    for (const [key, value] of Object.entries(data)) {
+      decoded[key] = decodeEventData(value);
+    }
+    return decoded;
+  }
+  return data;
+}
+function decodeFunctionArgs(args) {
+  return args.map(decodeClarityValue);
+}
+
+// src/runtime/runner.ts
+import { logger as logger2 } from "@secondlayer/shared/logger";
+import { getErrorMessage } from "@secondlayer/shared";
+var DEFAULT_ERROR_THRESHOLD = 50;
+function resolveHandler(handlers, key) {
+  return handlers[key] ?? handlers["*"] ?? null;
+}
+async function runHandlers(subgraph, matched, ctx, opts) {
+  let processed = 0;
+  let errors = 0;
+  const threshold = opts?.errorThreshold ?? DEFAULT_ERROR_THRESHOLD;
+  for (const { tx, events, sourceKey: sourceKey2 } of matched) {
+    const handler = resolveHandler(subgraph.handlers, sourceKey2);
+    if (!handler) {
+      logger2.warn("No handler found for source key", { subgraph: subgraph.name, sourceKey: sourceKey2, txId: tx.tx_id });
+      continue;
+    }
+    ctx.setTx({
+      txId: tx.tx_id,
+      sender: tx.sender,
+      type: tx.type,
+      status: tx.status
+    });
+    if (events.length === 0) {
+      try {
+        const txPayload = {
+          tx: {
+            txId: tx.tx_id,
+            sender: tx.sender,
+            type: tx.type,
+            status: tx.status,
+            contractId: tx.contract_id,
+            functionName: tx.function_name
+          }
+        };
+        await handler(txPayload, ctx);
+        processed++;
+      } catch (err) {
+        errors++;
+        logger2.error("Subgraph handler error", {
+          subgraph: subgraph.name,
+          sourceKey: sourceKey2,
+          txId: tx.tx_id,
+          error: getErrorMessage(err)
+        });
+      }
+      continue;
+    }
+    for (const event of events) {
+      if (errors >= threshold) {
+        logger2.error("Subgraph error threshold reached, skipping remaining events", {
+          subgraph: subgraph.name,
+          errors,
+          threshold
+        });
+        return { processed, errors };
+      }
+      try {
+        const decoded = decodeEventData(event.data);
+        const eventPayload = {
+          ...decoded,
+          _eventId: event.id,
+          _eventType: event.type,
+          _eventIndex: event.event_index,
+          tx: {
+            txId: tx.tx_id,
+            sender: tx.sender,
+            type: tx.type,
+            status: tx.status,
+            contractId: tx.contract_id,
+            functionName: tx.function_name
+          }
+        };
+        await handler(eventPayload, ctx);
+        processed++;
+      } catch (err) {
+        errors++;
+        logger2.error("Subgraph handler error", {
+          subgraph: subgraph.name,
+          sourceKey: sourceKey2,
+          txId: tx.tx_id,
+          eventId: event.id,
+          eventType: event.type,
+          error: getErrorMessage(err)
+        });
+      }
+    }
+  }
+  return { processed, errors };
+}
+
+// src/runtime/block-processor.ts
+import { sql as sql2 } from "kysely";
+import { getDb } from "@secondlayer/shared/db";
+import { logger as logger3 } from "@secondlayer/shared/logger";
+import { updateSubgraphStatus, recordSubgraphProcessed } from "@secondlayer/shared/db/queries/subgraphs";
+
+// src/schema/utils.ts
+import { pgSchemaName } from "@secondlayer/shared/db/queries/subgraphs";
+
+// src/runtime/block-processor.ts
+async function processBlock(subgraph, subgraphName, blockHeight, opts) {
+  const db = getDb();
+  const blockStart = performance.now();
+  const result = {
+    blockHeight,
+    matched: 0,
+    processed: 0,
+    errors: 0,
+    skipped: false
+  };
+  const block = await db.selectFrom("blocks").selectAll().where("height", "=", blockHeight).executeTakeFirst();
+  if (!block) {
+    logger3.warn("Block not found for subgraph processing", { subgraph: subgraphName, blockHeight });
+    result.skipped = true;
+    return result;
+  }
+  if (!block.canonical) {
+    logger3.debug("Skipping non-canonical block", { subgraph: subgraphName, blockHeight });
+    result.skipped = true;
+    return result;
+  }
+  const txs = await db.selectFrom("transactions").selectAll().where("block_height", "=", blockHeight).execute();
+  const evts = await db.selectFrom("events").selectAll().where("block_height", "=", blockHeight).execute();
+  const matched = matchSources(subgraph.sources, txs, evts);
+  result.matched = matched.length;
+  if (matched.length === 0) {
+    if (!opts?.skipProgressUpdate) {
+      await updateSubgraphStatus(db, subgraphName, "active", blockHeight);
+    }
+    return result;
+  }
+  const subgraphRecord = await db.selectFrom("subgraphs").select("schema_name").where("name", "=", subgraphName).executeTakeFirst();
+  const schemaName = subgraphRecord?.schema_name ?? pgSchemaName(subgraphName);
+  const blockMeta = {
+    height: block.height,
+    hash: block.hash,
+    timestamp: block.timestamp,
+    burnBlockHeight: block.burn_block_height
+  };
+  const initialTx = {
+    txId: "",
+    sender: "",
+    type: "",
+    status: ""
+  };
+  let handlerMs = 0;
+  let flushMs = 0;
+  await db.transaction().execute(async (tx) => {
+    const ctx = new SubgraphContext(tx, schemaName, subgraph.schema, blockMeta, initialTx);
+    const handlerStart = performance.now();
+    const runResult = await runHandlers(subgraph, matched, ctx);
+    handlerMs = performance.now() - handlerStart;
+    result.processed = runResult.processed;
+    result.errors = runResult.errors;
+    if (ctx.pendingOps > 0) {
+      const flushStart = performance.now();
+      await ctx.flush();
+      flushMs = performance.now() - flushStart;
+    }
+    if (!opts?.skipProgressUpdate) {
+      const status = runResult.errors > 0 && runResult.processed === 0 ? "error" : "active";
+      await updateSubgraphStatus(tx, subgraphName, status, blockHeight);
+    }
+    if (!opts?.skipProgressUpdate && (runResult.processed > 0 || runResult.errors > 0)) {
+      const lastError = runResult.errors > 0 ? `${runResult.errors} error(s) at block ${blockHeight}` : undefined;
+      await recordSubgraphProcessed(tx, subgraphName, runResult.processed, runResult.errors, lastError);
+    }
+  });
+  const totalMs = performance.now() - blockStart;
+  result.timing = {
+    totalMs: Math.round(totalMs),
+    handlerMs: Math.round(handlerMs),
+    flushMs: Math.round(flushMs)
+  };
+  if (blockHeight % 1000 === 0) {
+    try {
+      const tables = Object.keys(subgraph.schema);
+      for (const table of tables) {
+        const { rows } = await sql2.raw(`SELECT COUNT(*) as count FROM "${schemaName}"."${table}"`).execute(db);
+        const count = Number(rows[0].count);
+        if (count >= 1e7) {
+          logger3.warn("Subgraph table exceeds 10M rows", { subgraph: subgraphName, table, count });
+        }
+      }
+    } catch {}
+  }
+  return result;
+}
+
+// src/runtime/stats.ts
+var FLUSH_INTERVAL_BLOCKS = 100;
+var FLUSH_INTERVAL_MS = 60000;
+
+class StatsAccumulator {
+  subgraphName;
+  apiKeyId;
+  isCatchup;
+  current;
+  lastFlush = Date.now();
+  constructor(subgraphName, apiKeyId, isCatchup) {
+    this.subgraphName = subgraphName;
+    this.apiKeyId = apiKeyId;
+    this.isCatchup = isCatchup;
+    this.current = this.newEntry();
+  }
+  record(timing, opsCount) {
+    this.current.blocksProcessed++;
+    this.current.totalTimeMs += timing.totalMs;
+    this.current.handlerTimeMs += timing.handlerMs;
+    this.current.flushTimeMs += timing.flushMs;
+    this.current.maxBlockTimeMs = Math.max(this.current.maxBlockTimeMs, timing.totalMs);
+    this.current.maxHandlerTimeMs = Math.max(this.current.maxHandlerTimeMs, timing.handlerMs);
+    this.current.totalOps += opsCount;
+  }
+  shouldFlush() {
+    return this.current.blocksProcessed >= FLUSH_INTERVAL_BLOCKS || Date.now() - this.lastFlush >= FLUSH_INTERVAL_MS;
+  }
+  async flush(db) {
+    if (this.current.blocksProcessed === 0)
+      return;
+    const entry = this.current;
+    this.current = this.newEntry();
+    this.lastFlush = Date.now();
+    const avgOpsPerBlock = entry.blocksProcessed > 0 ? entry.totalOps / entry.blocksProcessed : 0;
+    await db.insertInto("subgraph_processing_stats").values({
+      subgraph_name: entry.subgraphName,
+      api_key_id: entry.apiKeyId,
+      bucket_start: entry.bucketStart,
+      bucket_end: new Date,
+      blocks_processed: entry.blocksProcessed,
+      total_time_ms: Math.round(entry.totalTimeMs),
+      handler_time_ms: Math.round(entry.handlerTimeMs),
+      flush_time_ms: Math.round(entry.flushTimeMs),
+      max_block_time_ms: Math.round(entry.maxBlockTimeMs),
+      max_handler_time_ms: Math.round(entry.maxHandlerTimeMs),
+      avg_ops_per_block: parseFloat(avgOpsPerBlock.toFixed(2)),
+      is_catchup: entry.isCatchup
+    }).execute();
+  }
+  newEntry() {
+    return {
+      subgraphName: this.subgraphName,
+      apiKeyId: this.apiKeyId,
+      bucketStart: new Date,
+      blocksProcessed: 0,
+      totalTimeMs: 0,
+      handlerTimeMs: 0,
+      flushTimeMs: 0,
+      maxBlockTimeMs: 0,
+      maxHandlerTimeMs: 0,
+      totalOps: 0,
+      isCatchup: this.isCatchup
+    };
+  }
+}
+
+// src/runtime/reindex.ts
+import { getDb as getDb2, getRawClient } from "@secondlayer/shared/db";
+import { updateSubgraphStatus as updateSubgraphStatus2 } from "@secondlayer/shared/db/queries/subgraphs";
+import { logger as logger4 } from "@secondlayer/shared/logger";
+import { getErrorMessage as getErrorMessage2 } from "@secondlayer/shared";
+
+// src/schema/generator.ts
+var TYPE_MAP = {
+  text: "TEXT",
+  uint: "BIGINT",
+  int: "INTEGER",
+  principal: "TEXT",
+  boolean: "BOOLEAN",
+  timestamp: "TIMESTAMPTZ",
+  jsonb: "JSONB"
+};
+function escapeLiteralDefault(value) {
+  if (value === null || value === undefined)
+    return "NULL";
+  if (typeof value === "number" || typeof value === "bigint")
+    return String(value);
+  if (typeof value === "boolean")
+    return value ? "TRUE" : "FALSE";
+  return `'${String(value).replace(/'/g, "''")}'`;
+}
+function generateSubgraphSQL(def, schemaNameOverride) {
+  const schemaName = schemaNameOverride ?? pgSchemaName(def.name);
+  const statements = [];
+  const needsTrgm = Object.values(def.schema).some((table) => Object.values(table.columns).some((col) => col.search));
+  if (needsTrgm) {
+    statements.push(`CREATE EXTENSION IF NOT EXISTS pg_trgm`);
+  }
+  statements.push(`CREATE SCHEMA IF NOT EXISTS ${schemaName}`);
+  for (const [tableName, tableDef] of Object.entries(def.schema)) {
+    const qualifiedName = `${schemaName}.${tableName}`;
+    const columnDefs = [
+      `_id BIGSERIAL PRIMARY KEY`,
+      `_block_height BIGINT NOT NULL`,
+      `_tx_id TEXT NOT NULL`,
+      `_created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()`
+    ];
+    for (const [colName, col] of Object.entries(tableDef.columns)) {
+      const sqlType = TYPE_MAP[col.type];
+      const nullable = col.nullable ? "" : " NOT NULL";
+      let colDef = `${colName} ${sqlType}${nullable}`;
+      if (col.default !== undefined) {
+        colDef += ` DEFAULT ${escapeLiteralDefault(col.default)}`;
+      }
+      columnDefs.push(colDef);
+    }
+    statements.push(`CREATE TABLE IF NOT EXISTS ${qualifiedName} (
+  ${columnDefs.join(`,
+  `)}
+)`);
+    statements.push(`CREATE INDEX IF NOT EXISTS idx_${schemaName}_${tableName}_block_height ON ${qualifiedName} (_block_height)`);
+    statements.push(`CREATE INDEX IF NOT EXISTS idx_${schemaName}_${tableName}_tx_id ON ${qualifiedName} (_tx_id)`);
+    for (const [colName, col] of Object.entries(tableDef.columns)) {
+      if (col.indexed) {
+        statements.push(`CREATE INDEX IF NOT EXISTS idx_${schemaName}_${tableName}_${colName} ON ${qualifiedName} (${colName})`);
+      }
+    }
+    for (const [colName, col] of Object.entries(tableDef.columns)) {
+      if (col.search) {
+        statements.push(`CREATE INDEX IF NOT EXISTS idx_${schemaName}_${tableName}_${colName}_trgm ON ${qualifiedName} USING gin (${colName} gin_trgm_ops)`);
+      }
+    }
+    if (tableDef.indexes) {
+      for (let i = 0;i < tableDef.indexes.length; i++) {
+        const cols = tableDef.indexes[i];
+        const idxName = `idx_${schemaName}_${tableName}_composite_${i}`;
+        statements.push(`CREATE INDEX IF NOT EXISTS ${idxName} ON ${qualifiedName} (${cols.join(", ")})`);
+      }
+    }
+    if (tableDef.uniqueKeys) {
+      for (let i = 0;i < tableDef.uniqueKeys.length; i++) {
+        const cols = tableDef.uniqueKeys[i];
+        const constraintName = `uq_${schemaName}_${tableName}_${cols.join("_")}`;
+        statements.push(`ALTER TABLE ${qualifiedName} ADD CONSTRAINT ${constraintName} UNIQUE (${cols.join(", ")})`);
+      }
+    }
+  }
+  const hashInput = JSON.stringify({
+    name: def.name,
+    version: def.version,
+    schema: def.schema,
+    sources: def.sources
+  }, (_key, value) => typeof value === "bigint" ? value.toString() : value);
+  const hash = String(Bun.hash(hashInput));
+  return { statements, hash };
+}
+
+// src/runtime/reindex.ts
+var LOG_INTERVAL = 1000;
+async function reindexSubgraph(def, opts) {
+  const db = getDb2();
+  const client = getRawClient();
+  const subgraphName = def.name;
+  const schemaName = opts?.schemaName ?? pgSchemaName(subgraphName);
+  await updateSubgraphStatus2(db, subgraphName, "reindexing");
+  logger4.info("Reindex starting", { subgraph: subgraphName });
+  try {
+    await client.unsafe(`DROP SCHEMA IF EXISTS "${schemaName}" CASCADE`);
+    const { statements } = generateSubgraphSQL(def, schemaName);
+    for (const stmt of statements) {
+      await client.unsafe(stmt);
+    }
+    logger4.info("Schema recreated for reindex", { subgraph: subgraphName });
+    const fromBlock = opts?.fromBlock ?? 1;
+    let toBlock;
+    if (opts?.toBlock != null) {
+      toBlock = opts.toBlock;
+    } else {
+      const progress = await db.selectFrom("index_progress").selectAll().where("network", "=", process.env.NETWORK ?? "mainnet").executeTakeFirst();
+      toBlock = progress?.last_indexed_block ?? progress?.last_contiguous_block ?? 0;
+    }
+    if (fromBlock > toBlock) {
+      logger4.info("No blocks to reindex", { subgraph: subgraphName, fromBlock, toBlock });
+      await updateSubgraphStatus2(db, subgraphName, "active", 0);
+      return { processed: 0 };
+    }
+    const totalBlocks = toBlock - fromBlock + 1;
+    logger4.info("Reindexing blocks", { subgraph: subgraphName, fromBlock, toBlock, totalBlocks });
+    const subgraphRow = await db.selectFrom("subgraphs").select("api_key_id").where("name", "=", subgraphName).executeTakeFirst();
+    const stats = new StatsAccumulator(subgraphName, subgraphRow?.api_key_id ?? null, false);
+    let blocksProcessed = 0;
+    let totalEventsProcessed = 0;
+    let totalErrors = 0;
+    const PROGRESS_INTERVAL = 100;
+    for (let height = fromBlock;height <= toBlock; height++) {
+      const result = await processBlock(def, subgraphName, height, { skipProgressUpdate: true });
+      blocksProcessed++;
+      totalEventsProcessed += result.processed;
+      totalErrors += result.errors;
+      if (result.timing) {
+        stats.record(result.timing, result.processed);
+        if (stats.shouldFlush()) {
+          await stats.flush(db);
+        }
+      }
+      if (blocksProcessed % PROGRESS_INTERVAL === 0) {
+        await updateSubgraphStatus2(db, subgraphName, "reindexing", height);
+      }
+      if (blocksProcessed % LOG_INTERVAL === 0) {
+        logger4.info("Reindex progress", {
+          subgraph: subgraphName,
+          processed: blocksProcessed,
+          total: totalBlocks,
+          currentBlock: height,
+          pct: Math.round(blocksProcessed / totalBlocks * 100)
+        });
+      }
+    }
+    await stats.flush(db);
+    const { recordSubgraphProcessed: recordSubgraphProcessed2 } = await import("@secondlayer/shared/db/queries/subgraphs");
+    if (totalEventsProcessed > 0 || totalErrors > 0) {
+      await recordSubgraphProcessed2(db, subgraphName, totalEventsProcessed, totalErrors, totalErrors > 0 ? `${totalErrors} error(s) during reindex` : undefined);
+    }
+    await updateSubgraphStatus2(db, subgraphName, "active", toBlock);
+    logger4.info("Reindex complete", { subgraph: subgraphName, blocks: blocksProcessed, events: totalEventsProcessed, errors: totalErrors });
+    return { processed: blocksProcessed };
+  } catch (err) {
+    logger4.error("Reindex failed", {
+      subgraph: subgraphName,
+      error: getErrorMessage2(err)
+    });
+    await updateSubgraphStatus2(db, subgraphName, "error");
+    throw err;
+  }
+}
+export {
+  reindexSubgraph
+};
+
+//# debugId=1C1BF85F61D4F46664756E2164756E21
+//# sourceMappingURL=reindex.js.map