@secondlayer/subgraphs 4.4.1 → 5.0.1

package/dist/src/runtime/context.js

@@ -1,936 +0,0 @@
-import { createRequire } from "node:module";
-var __require = /* @__PURE__ */ createRequire(import.meta.url);
-
-// src/runtime/context.ts
-import { logger as logger2 } from "@secondlayer/shared/logger";
-import { formatUnits } from "@secondlayer/stacks/utils";
-import { sql } from "kysely";
-
-// src/schema/generator.ts
-import { createHash } from "node:crypto";
-
-// src/schema/utils.ts
-import { pgSchemaName } from "@secondlayer/shared/db/queries/subgraphs";
-function quotePgIdent(name) {
-  if (/^[a-z_][a-z0-9_]*$/i.test(name))
-    return name;
-  return `"${name.replace(/"/g, '""')}"`;
-}
-function snakeToCamel(name) {
-  return name.replace(/_([a-z0-9])/g, (_, c) => c.toUpperCase());
-}
-function pascalCase(name) {
-  const camel = snakeToCamel(name);
-  return camel.charAt(0).toUpperCase() + camel.slice(1);
-}
-
-// src/schema/generator.ts
-var TYPE_MAP = {
-  text: "TEXT",
-  uint: "NUMERIC",
-  int: "NUMERIC",
-  principal: "TEXT",
-  boolean: "BOOLEAN",
-  timestamp: "TIMESTAMPTZ",
-  jsonb: "JSONB"
-};
-var MAX_IDENT_BYTES = 63;
-function safeIndexName(name) {
-  if (name.length <= MAX_IDENT_BYTES)
-    return name;
-  const hash = createHash("sha256").update(name).digest("hex").slice(0, 8);
-  return `${name.slice(0, MAX_IDENT_BYTES - hash.length - 1)}_${hash}`;
-}
-function emitIndexedColumnIndexDDL(schemaName, tableName, colName, opts) {
-  const concurrently = opts?.concurrently ? " CONCURRENTLY" : "";
-  const qualified = `${quotePgIdent(schemaName)}.${quotePgIdent(tableName)}`;
-  const plain = `idx_${schemaName}_${tableName}_${colName}`;
-  const composite = safeIndexName(`idx_${schemaName}_${tableName}_${colName}_id`);
-  const col = quotePgIdent(colName);
-  const id = quotePgIdent("_id");
-  return {
-    create: [
-      `CREATE INDEX${concurrently} IF NOT EXISTS ${quotePgIdent(plain)} ON ${qualified} (${col})`,
-      `CREATE INDEX${concurrently} IF NOT EXISTS ${quotePgIdent(composite)} ON ${qualified} (${col}, ${id})`
-    ],
-    drop: [
-      `DROP INDEX${concurrently} IF EXISTS ${quotePgIdent(schemaName)}.${quotePgIdent(plain)}`,
-      `DROP INDEX${concurrently} IF EXISTS ${quotePgIdent(schemaName)}.${quotePgIdent(composite)}`
-    ]
-  };
-}
-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 tableNeedsTrgm(tableDef) {
-  return Object.values(tableDef.columns).some((col) => col.search);
-}
-function emitTableDDL(schemaName, tableName, tableDef) {
-  const qualifiedName = `${quotePgIdent(schemaName)}.${quotePgIdent(tableName)}`;
-  const statements = [];
-  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 = `${quotePgIdent(colName)} ${sqlType}${nullable}`;
-    if (col.default !== undefined) {
-      colDef += ` DEFAULT ${escapeLiteralDefault(col.default)}`;
-    }
-    if (col.type === "uint") {
-      colDef += ` CHECK (${quotePgIdent(colName)} >= 0)`;
-    }
-    columnDefs.push(colDef);
-  }
-  statements.push(`CREATE TABLE IF NOT EXISTS ${qualifiedName} (
-  ${columnDefs.join(`,
-  `)}
-)`);
-  statements.push(`CREATE INDEX IF NOT EXISTS ${quotePgIdent(`idx_${schemaName}_${tableName}_block_height`)} ON ${qualifiedName} (_block_height)`);
-  statements.push(`CREATE INDEX IF NOT EXISTS ${quotePgIdent(`idx_${schemaName}_${tableName}_tx_id`)} ON ${qualifiedName} (_tx_id)`);
-  for (const [colName, col] of Object.entries(tableDef.columns)) {
-    if (col.indexed) {
-      statements.push(...emitIndexedColumnIndexDDL(schemaName, tableName, colName).create);
-    }
-  }
-  for (const [colName, col] of Object.entries(tableDef.columns)) {
-    if (col.search) {
-      statements.push(`CREATE INDEX IF NOT EXISTS ${quotePgIdent(`idx_${schemaName}_${tableName}_${colName}_trgm`)} ON ${qualifiedName} USING gin (${quotePgIdent(colName)} gin_trgm_ops)`);
-    }
-  }
-  if (tableDef.indexes) {
-    for (let i = 0;i < tableDef.indexes.length; i++) {
-      const cols = tableDef.indexes[i];
-      const idxName = quotePgIdent(`idx_${schemaName}_${tableName}_composite_${i}`);
-      statements.push(`CREATE INDEX IF NOT EXISTS ${idxName} ON ${qualifiedName} (${cols.map(quotePgIdent).join(", ")})`);
-    }
-  }
-  if (tableDef.uniqueKeys) {
-    for (let i = 0;i < tableDef.uniqueKeys.length; i++) {
-      const cols = tableDef.uniqueKeys[i];
-      const constraintName = quotePgIdent(`uq_${schemaName}_${tableName}_${cols.join("_")}`);
-      statements.push(`ALTER TABLE ${qualifiedName} ADD CONSTRAINT ${constraintName} UNIQUE (${cols.map(quotePgIdent).join(", ")})`);
-    }
-  }
-  return statements;
-}
-function emitJournalDDL(schemaName) {
-  return [
-    `CREATE TABLE IF NOT EXISTS ${schemaName}._journal (
-  _jid BIGSERIAL PRIMARY KEY,
-  block_height BIGINT NOT NULL,
-  table_name TEXT NOT NULL,
-  row_key JSONB NOT NULL,
-  prev_row JSONB,
-  _created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
-)`,
-    `CREATE INDEX IF NOT EXISTS idx_${schemaName}_journal_height ON ${schemaName}._journal (block_height)`
-  ];
-}
-function emitFactoryDDL(schemaName) {
-  return [
-    `CREATE TABLE IF NOT EXISTS ${schemaName}._factory_addresses (
-  source_name TEXT NOT NULL,
-  address TEXT NOT NULL,
-  block_height BIGINT NOT NULL,
-  _created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
-  PRIMARY KEY (source_name, address)
-)`,
-    `CREATE INDEX IF NOT EXISTS idx_${schemaName}_factory_height ON ${schemaName}._factory_addresses (block_height)`
-  ];
-}
-function emitForeignKeyDDL(schemaName, tableName, tableDef) {
-  return (tableDef.relations ?? []).map((rel) => {
-    const constraintName = quotePgIdent(`fk_${schemaName}_${tableName}_${rel.name}`);
-    return `ALTER TABLE ${quotePgIdent(schemaName)}.${quotePgIdent(tableName)} ADD CONSTRAINT ${constraintName} ` + `FOREIGN KEY (${rel.fields.map(quotePgIdent).join(", ")}) ` + `REFERENCES ${quotePgIdent(schemaName)}.${quotePgIdent(rel.references)} (${rel.referencedColumns.map(quotePgIdent).join(", ")})`;
-  });
-}
-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)) {
-    statements.push(...emitTableDDL(schemaName, tableName, tableDef));
-  }
-  statements.push(...emitJournalDDL(schemaName));
-  if (Object.values(def.sources ?? {}).some((src) => src.factory !== undefined)) {
-    statements.push(...emitFactoryDDL(schemaName));
-  }
-  for (const [tableName, tableDef] of Object.entries(def.schema)) {
-    statements.push(...emitForeignKeyDDL(schemaName, tableName, tableDef));
-  }
-  const hashInput = JSON.stringify({
-    name: def.name,
-    schema: def.schema,
-    sources: def.sources
-  }, (_key, value) => typeof value === "bigint" ? value.toString() : value);
-  const hash = createHash("sha256").update(hashInput).digest("hex");
-  return { statements, hash };
-}
-
-// src/runtime/chain-read.ts
-import { getSourceDb } from "@secondlayer/shared/db";
-import { logger } from "@secondlayer/shared/logger";
-import { http, createPublicClient } from "@secondlayer/stacks";
-import {
-  ContractResponseError,
-  buildFunctionArgs,
-  isResponseOutput,
-  readContract
-} from "@secondlayer/stacks/actions";
-import {
-  clarityValueToJSUntyped,
-  deserializeCV,
-  normalizeAbi,
-  serializeCV,
-  toCamelCase
-} from "@secondlayer/stacks/clarity";
-function readContractAt(ctx, contractId, abi, options) {
-  return ctx.client.contract(contractId, abi, options);
-}
-
-class ChainReadError extends Error {
-  name = "ChainReadError";
-}
-function nodeClient(rpcUrl) {
-  return createPublicClient({
-    transport: http(rpcUrl, { retryCount: 0, timeout: 1e4 })
-  });
-}
-
-class ConcurrencyGate {
-  limit;
-  active = 0;
-  queue = [];
-  constructor(limit) {
-    this.limit = limit;
-  }
-  async run(fn) {
-    if (this.active >= this.limit) {
-      await new Promise((resolve) => this.queue.push(resolve));
-    }
-    this.active++;
-    try {
-      return await fn();
-    } finally {
-      this.active--;
-      this.queue.shift()?.();
-    }
-  }
-}
-var DEFAULT_MAX_CONCURRENT_READS = 4;
-function maxConcurrentReads() {
-  const raw = process.env.SUBGRAPH_CHAIN_READ_CONCURRENCY;
-  const parsed = raw ? Number.parseInt(raw, 10) : Number.NaN;
-  return Number.isFinite(parsed) && parsed > 0 ? parsed : DEFAULT_MAX_CONCURRENT_READS;
-}
-var gate = new ConcurrencyGate(maxConcurrentReads());
-function hashArgs(args) {
-  const serialized = args.map((arg) => serializeCV(arg)).join(",");
-  return Bun.hash(serialized).toString(16);
-}
-function findFunction(abi, name) {
-  const fn = abi.functions.find((f) => f.name === name);
-  if (!fn) {
-    throw new ChainReadError(`No function "${name}" in the supplied ABI.`);
-  }
-  if (fn.access !== "read-only") {
-    throw new ChainReadError(`"${name}" is ${fn.access}, not read-only — a handler cannot call it.`);
-  }
-  return fn;
-}
-function createChainReadClient(ctx) {
-  const readValue = async (contractId, abi, functionName, args, options) => {
-    const rpcUrl = ctx.rpcUrl ?? process.env.STACKS_NODE_RPC_URL;
-    if (!rpcUrl) {
-      throw new ChainReadError("ctx.client needs a Stacks node: set STACKS_NODE_RPC_URL on the subgraph processor.");
-    }
-    const constant = options.cache === "contract-constant";
-    if (!constant && !ctx.indexBlockHash) {
-      throw new ChainReadError(`Block ${ctx.blockHeight} has no index_block_hash, so a read cannot be pinned to it. Reading at the node's tip would make this handler non-deterministic (the same reindex would produce different rows). Re-ingest the block, or pass cache: "contract-constant" if the value genuinely cannot change.`);
-    }
-    const fn = findFunction(abi, functionName);
-    const clarityArgs = buildFunctionArgs(fn, args);
-    const db = ctx.db ?? getSourceDb();
-    const argsHash = hashArgs(clarityArgs);
-    const pinnedTo = constant ? null : ctx.indexBlockHash;
-    const cached = await db.selectFrom("chain_read_cache").select("result_hex").where("contract_id", "=", contractId).where("function_name", "=", fn.name).where("args_hash", "=", argsHash).where((eb) => pinnedTo === null ? eb("index_block_hash", "is", null) : eb("index_block_hash", "=", pinnedTo)).executeTakeFirst();
-    const resultHex = cached?.result_hex ?? await gate.run(async () => {
-      if (!ctx.indexBlockHash) {
-        logger.warn("Chain read is not pinned to a block (no index_block_hash)", {
-          contractId,
-          functionName: fn.name,
-          blockHeight: ctx.blockHeight,
-          note: 'cache: "contract-constant" asserts this value cannot change; the node answered at its own tip'
-        });
-      }
-      const value2 = await readContract(nodeClient(rpcUrl), {
-        contract: contractId,
-        functionName: fn.name,
-        args: clarityArgs,
-        tip: ctx.indexBlockHash ?? undefined
-      });
-      return serializeCV(value2);
-    });
-    if (!cached) {
-      await db.insertInto("chain_read_cache").values({
-        contract_id: contractId,
-        function_name: fn.name,
-        args_hash: argsHash,
-        index_block_hash: pinnedTo,
-        block_height: constant ? null : ctx.blockHeight,
-        result_hex: resultHex
-      }).onConflict((oc) => oc.doNothing()).execute();
-    }
-    const value = deserializeCV(resultHex);
-    const js = clarityValueToJSUntyped(fn.outputs, value);
-    if (isResponseOutput(fn.outputs)) {
-      const response = js;
-      if ("ok" in response)
-        return response.ok;
-      throw new ContractResponseError(`${contractId}::${fn.name} returned an err response.`, response.err);
-    }
-    return js;
-  };
-  return {
-    contract(contractId, rawAbi, options = {}) {
-      const abi = normalizeAbi(rawAbi);
-      const camelToKebab = new Map;
-      for (const fn of abi.functions) {
-        camelToKebab.set(toCamelCase(fn.name), fn.name);
-      }
-      const read = new Proxy({}, {
-        get(_target, prop) {
-          const fnName = camelToKebab.get(prop) ?? prop;
-          return (args = {}) => readValue(contractId, abi, fnName, args, options);
-        }
-      });
-      return { read };
-    }
-  };
-}
-
-// src/runtime/context.ts
-var JOURNAL_RETENTION_BLOCKS = 300;
-var journalEnsured = new Set;
-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 = [];
-  journal;
-  _client;
-  constructor(db, pgSchemaName2, subgraphSchema, block, tx, journal = false) {
-    this.db = db;
-    this.pgSchemaName = pgSchemaName2;
-    this.subgraphSchema = subgraphSchema;
-    this.block = block;
-    this._tx = tx;
-    this.journal = journal;
-  }
-  get client() {
-    this._client ??= createChainReadClient({
-      blockHeight: this.block.height,
-      indexBlockHash: this.block.indexBlockHash
-    });
-    return this._client;
-  }
-  get tx() {
-    return this._tx;
-  }
-  setTx(tx) {
-    this._tx = tx;
-  }
-  insert(table, row) {
-    this.validateTable(table);
-    this.ops.push({
-      kind: "insert",
-      table,
-      data: { ...row, _block_height: this.block.height, _tx_id: this._tx.txId }
-    });
-  }
-  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];
-    if (!tableDef)
-      return;
-    const keyColumns = Object.keys(key);
-    const hasUniqueConstraint = tableDef.uniqueKeys?.some((uk) => uk.length === keyColumns.length && uk.every((c) => keyColumns.includes(c)));
-    const meta = { _block_height: this.block.height, _tx_id: this._tx.txId };
-    if (hasUniqueConstraint) {
-      this.ops.push({
-        kind: "insert",
-        table,
-        data: { ...key, ...row, ...meta, _upsert_keys: keyColumns }
-      });
-    } else {
-      logger2.warn("upsert called without matching uniqueKeys constraint, using fallback", {
-        table,
-        keys: keyColumns
-      });
-      this.ops.push({
-        kind: "insert",
-        table,
-        data: {
-          ...key,
-          ...row,
-          ...meta,
-          _upsert_fallback_keys: keyColumns,
-          _upsert_fallback_set: row
-        }
-      });
-    }
-  }
-  delete(table, where) {
-    this.validateTable(table);
-    this.ops.push({ kind: "delete", table, data: where });
-  }
-  increment(table, key, deltas) {
-    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) {
-      throw new Error(`increment("${table}") requires a uniqueKeys constraint on [${keyColumns.join(", ")}]`);
-    }
-    for (const [col, v] of Object.entries(deltas)) {
-      validateColumnName(col);
-      if (keyColumns.includes(col)) {
-        throw new Error(`increment("${table}"): "${col}" is a key column`);
-      }
-      if (typeof v !== "bigint" && typeof v !== "number") {
-        throw new Error(`increment("${table}"): delta for "${col}" must be bigint or number`);
-      }
-    }
-    this.ops.push({
-      kind: "increment",
-      table,
-      data: {
-        ...key,
-        _block_height: this.block.height,
-        _tx_id: this._tx.txId,
-        _upsert_keys: keyColumns
-      },
-      set: { ...deltas }
-    });
-  }
-  opsCheckpoint() {
-    return this.ops.length;
-  }
-  rollbackTo(checkpoint) {
-    if (checkpoint < 0 || checkpoint > this.ops.length)
-      return;
-    this.ops.length = checkpoint;
-  }
-  patch(table, where, set) {
-    this.update(table, where, set);
-  }
-  async patchOrInsert(table, key, row) {
-    const existing = await this.findOne(table, key);
-    const resolved = {};
-    for (const [k, v] of Object.entries(row)) {
-      resolved[k] = typeof v === "function" ? v(existing) : v;
-    }
-    this.upsert(table, key, resolved);
-  }
-  formatUnits(value, decimals) {
-    return formatUnits(value, decimals);
-  }
-  async readRows(table, where, limit) {
-    const qualifiedTable = `"${this.pgSchemaName}"."${table}"`;
-    const { clause } = buildWhereClause(where);
-    const query = `SELECT * FROM ${qualifiedTable} WHERE ${clause}${limit !== undefined ? ` LIMIT ${limit}` : ""}`;
-    const { rows } = await sql.raw(query).execute(this.db);
-    return rows.map((r) => this.coerceRow(table, r));
-  }
-  async findOne(table, where) {
-    this.validateTable(table);
-    const row = (await this.readRows(table, where, 1))[0] ?? null;
-    return this.overlayOne(table, where, row);
-  }
-  async findMany(table, where) {
-    this.validateTable(table);
-    return this.overlayMany(table, where, await this.readRows(table, where));
-  }
-  overlayOne(table, where, dbRow) {
-    if (this.ops.length === 0)
-      return dbRow;
-    let row = dbRow;
-    for (const op of this.ops) {
-      if (op.table !== table)
-        continue;
-      row = this.applyOpToRow(op, row, where);
-    }
-    return row;
-  }
-  overlayMany(table, where, dbRows) {
-    if (this.ops.length === 0)
-      return [...dbRows];
-    let result = [...dbRows];
-    for (const op of this.ops) {
-      if (op.table !== table)
-        continue;
-      if (op.kind === "update") {
-        for (let i = 0;i < result.length; i++) {
-          if (rowMatches(result[i], op.data))
-            result[i] = { ...result[i], ...op.set ?? {} };
-        }
-      } else if (op.kind === "delete") {
-        result = result.filter((r) => !rowMatches(r, op.data));
-      } else {
-        const upsertKeys = op.data._upsert_keys;
-        const clean = stripControlKeys(op.data);
-        const idx = upsertKeys ? result.findIndex((r) => upsertKeys.every((k) => valEq(r[k], clean[k]))) : -1;
-        if (idx >= 0) {
-          const existing = result[idx];
-          result[idx] = this.applyOpToRow(op, existing, where) ?? existing;
-        } else {
-          const created = this.applyOpToRow(op, null, where);
-          if (created)
-            result.push(created);
-        }
-      }
-    }
-    return result;
-  }
-  applyOpToRow(op, row, where) {
-    const upsertKeys = op.data._upsert_keys;
-    const clean = stripControlKeys(op.data);
-    switch (op.kind) {
-      case "insert": {
-        if (row) {
-          if (upsertKeys?.every((k) => valEq(row[k], clean[k]))) {
-            const merged = { ...row };
-            for (const [k, v] of Object.entries(clean)) {
-              if (!upsertKeys.includes(k) && !k.startsWith("_"))
-                merged[k] = v;
-            }
-            return merged;
-          }
-          return row;
-        }
-        return rowMatches(clean, where) ? { ...clean } : null;
-      }
-      case "increment": {
-        const deltas = op.set ?? {};
-        if (row) {
-          if (upsertKeys.every((k) => valEq(row[k], clean[k]))) {
-            const merged = { ...row };
-            for (const [col, d] of Object.entries(deltas)) {
-              merged[col] = toBigIntOr0(merged[col]) + toBigIntOr0(d);
-            }
-            return merged;
-          }
-          return row;
-        }
-        if (!rowMatches(clean, where))
-          return null;
-        const created = { ...clean };
-        for (const [col, d] of Object.entries(deltas)) {
-          created[col] = toBigIntOr0(d);
-        }
-        return created;
-      }
-      case "update":
-        return row && rowMatches(row, op.data) ? { ...row, ...op.set ?? {} } : row;
-      case "delete":
-        return row && rowMatches(row, op.data) ? null : row;
-    }
-  }
-  async count(table, where) {
-    this.validateTable(table);
-    const qualifiedTable = `"${this.pgSchemaName}"."${table}"`;
-    const whereClause = where ? `WHERE ${buildWhereClause(where).clause}` : "";
-    const { rows } = await sql.raw(`SELECT COUNT(*)::int AS count FROM ${qualifiedTable} ${whereClause}`).execute(this.db);
-    return Number(rows[0]?.count ?? 0);
-  }
-  async sum(table, column, where) {
-    this.validateTable(table);
-    validateColumnName(column);
-    const qualifiedTable = `"${this.pgSchemaName}"."${table}"`;
-    const whereClause = where ? `WHERE ${buildWhereClause(where).clause}` : "";
-    const { rows } = await sql.raw(`SELECT COALESCE(SUM("${column}"), 0) AS total FROM ${qualifiedTable} ${whereClause}`).execute(this.db);
-    return BigInt(rows[0]?.total?.toString() ?? "0");
-  }
-  async min(table, column, where) {
-    this.validateTable(table);
-    validateColumnName(column);
-    const qualifiedTable = `"${this.pgSchemaName}"."${table}"`;
-    const whereClause = where ? `WHERE ${buildWhereClause(where).clause}` : "";
-    const { rows } = await sql.raw(`SELECT MIN("${column}") AS val FROM ${qualifiedTable} ${whereClause}`).execute(this.db);
-    const val = rows[0]?.val;
-    return val != null ? BigInt(val.toString()) : null;
-  }
-  async max(table, column, where) {
-    this.validateTable(table);
-    validateColumnName(column);
-    const qualifiedTable = `"${this.pgSchemaName}"."${table}"`;
-    const whereClause = where ? `WHERE ${buildWhereClause(where).clause}` : "";
-    const { rows } = await sql.raw(`SELECT MAX("${column}") AS val FROM ${qualifiedTable} ${whereClause}`).execute(this.db);
-    const val = rows[0]?.val;
-    return val != null ? BigInt(val.toString()) : null;
-  }
-  async countDistinct(table, column, where) {
-    this.validateTable(table);
-    validateColumnName(column);
-    const qualifiedTable = `"${this.pgSchemaName}"."${table}"`;
-    const whereClause = where ? `WHERE ${buildWhereClause(where).clause}` : "";
-    const { rows } = await sql.raw(`SELECT COUNT(DISTINCT "${column}")::int AS count FROM ${qualifiedTable} ${whereClause}`).execute(this.db);
-    return Number(rows[0]?.count ?? 0);
-  }
-  coerceRow(table, row) {
-    const tableDef = this.subgraphSchema[table];
-    if (!tableDef)
-      return row;
-    const result = { ...row };
-    for (const [col, def] of Object.entries(tableDef.columns)) {
-      if ((def.type === "uint" || def.type === "int") && typeof result[col] === "string") {
-        result[col] = BigInt(result[col]);
-      }
-    }
-    return result;
-  }
-  get pendingOps() {
-    return this.ops.length;
-  }
-  async flush() {
-    if (this.ops.length === 0)
-      return { count: 0, writes: [] };
-    await this.ensureJournalTable();
-    const opsToFlush = [...this.ops];
-    this.ops.length = 0;
-    const statements = this.buildStatements(opsToFlush);
-    if ("isTransaction" in this.db) {
-      await this.execStatements(this.db, statements);
-    } else {
-      await this.db.transaction().execute(async (tx) => {
-        await this.execStatements(tx, statements);
-      });
-    }
-    const writes = opsToFlush.map((op, rowIndex) => {
-      const blockHeight = op.data._block_height ?? this.block.height;
-      const txId = op.data._tx_id ?? this._tx.txId;
-      const baseRow = op.kind === "update" || op.kind === "increment" ? { ...op.data, ...op.set ?? {} } : { ...op.data };
-      baseRow._upsert_keys = undefined;
-      baseRow._upsert_fallback_keys = undefined;
-      baseRow._upsert_fallback_set = undefined;
-      return {
-        op: op.kind === "increment" ? "update" : op.kind,
-        table: op.table,
-        row: jsonSafe(baseRow),
-        pk: { blockHeight, txId, rowIndex }
-      };
-    });
-    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 };
-    delete data._upsert_keys;
-    delete data._upsert_fallback_keys;
-    delete data._upsert_fallback_set;
-    if (!data._block_height)
-      data._block_height = this.block.height;
-    if (!data._tx_id)
-      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]));
-    const batchKey = `${op.table}:${[...cols].sort().join(",")}:${upsertKeys ? [...upsertKeys].sort().join(",") : ""}`;
-    return { data, cols, vals, upsertKeys, batchKey };
-  }
-  async ensureJournalTable() {
-    if (!this.journal || journalEnsured.has(this.pgSchemaName))
-      return;
-    const { rows } = await sql.raw(`SELECT to_regclass('"${this.pgSchemaName}"."_journal"') AS r`).execute(this.db);
-    if (rows[0]?.r) {
-      journalEnsured.add(this.pgSchemaName);
-      return;
-    }
-    for (const stmt of emitJournalDDL(this.pgSchemaName)) {
-      await sql.raw(stmt).execute(this.db);
-    }
-  }
-  columnSqlType(table, col) {
-    const def = this.subgraphSchema[table]?.columns?.[col];
-    return def ? TYPE_MAP[def.type] : undefined;
-  }
-  journalCaptureSQL(table, keyCols, keyLiteralRows) {
-    const cast = (col, expr) => {
-      const t = this.columnSqlType(table, col);
-      return t ? `CAST(${expr} AS ${t})` : expr;
-    };
-    const keyObj = keyCols.map((k) => `'${k}', ${cast(k, `v."${k}"`)}`).join(", ");
-    const joinCond = keyCols.map((k) => `t."${k}" = ${cast(k, `v."${k}"`)}`).join(" AND ");
-    const valuesList = keyLiteralRows.map((r) => `(${r.join(", ")})`).join(", ");
-    return `INSERT INTO "${this.pgSchemaName}"."_journal" ("block_height", "table_name", "row_key", "prev_row") ` + `SELECT ${this.block.height}, '${table}', jsonb_build_object(${keyObj}), to_jsonb(t.*) ` + `FROM (VALUES ${valuesList}) AS v(${keyCols.map((k) => `"${k}"`).join(", ")}) ` + `LEFT JOIN "${this.pgSchemaName}"."${table}" t ON ${joinCond}`;
-  }
-  journalCaptureByWhereSQL(table, clause) {
-    return `INSERT INTO "${this.pgSchemaName}"."_journal" ("block_height", "table_name", "row_key", "prev_row") ` + `SELECT ${this.block.height}, '${table}', jsonb_build_object('_id', t."_id"), to_jsonb(t.*) ` + `FROM "${this.pgSchemaName}"."${table}" t WHERE ${clause}`;
-  }
-  buildStatements(ops) {
-    const statements = [];
-    let currentBatch = null;
-    let currentBatchKey = "";
-    let incBatch = null;
-    let incBatchKey = "";
-    const flushIncrementBatch = () => {
-      if (!incBatch)
-        return;
-      const batch = incBatch;
-      const qualifiedTable = `"${this.pgSchemaName}"."${batch.table}"`;
-      const cols = [
-        ...batch.keyCols,
-        ...batch.deltaCols,
-        "_block_height",
-        "_tx_id",
-        "_created_at"
-      ];
-      if (this.journal) {
-        statements.push(this.journalCaptureSQL(batch.table, batch.keyCols, Array.from(batch.rows.values()).map((r) => batch.keyCols.map((k) => escapeLiteral(r.keys[k])))));
-      }
-      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(", ");
-        const insertVals = [
-          ...batch.keyCols.map((k) => escapeLiteral(r.keys[k])),
-          ...batch.deltaCols.map((c) => String(r.deltas[c] ?? 0n)),
-          escapeLiteral(r.meta.blockHeight),
-          escapeLiteral(r.meta.txId),
-          "NOW()"
-        ];
-        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 = "";
-    };
-    const flushInsertBatch = () => {
-      if (!currentBatch)
-        return;
-      const batch = currentBatch;
-      const qualifiedTable = `"${this.pgSchemaName}"."${batch.table}"`;
-      const colList = batch.cols.map((c) => `"${c}"`).join(", ");
-      let rows = batch.rows;
-      if (batch.upsertKeys && batch.upsertKeys.length > 0) {
-        const uKeys = batch.upsertKeys;
-        const keyIndices = uKeys.map((k) => batch.cols.indexOf(k));
-        const seen = new Map;
-        for (let i = 0;i < rows.length; i++) {
-          const key = keyIndices.map((ki) => rows[i][ki]).join("\x00");
-          seen.set(key, i);
-        }
-        if (seen.size < rows.length) {
-          rows = Array.from(seen.values()).map((i) => rows[i]);
-        }
-      }
-      const valuesList = rows.map((r) => `(${r.join(", ")})`).join(", ");
-      let stmt = `INSERT INTO ${qualifiedTable} (${colList}) VALUES ${valuesList}`;
-      if (this.journal && batch.upsertKeys && batch.upsertKeys.length > 0) {
-        const uKeys = batch.upsertKeys;
-        const keyIndices = uKeys.map((k) => batch.cols.indexOf(k));
-        statements.push(this.journalCaptureSQL(batch.table, uKeys, rows.map((r) => keyIndices.map((ki) => r[ki]))));
-      }
-      if (batch.upsertKeys && batch.upsertKeys.length > 0) {
-        const batchKeys = batch.upsertKeys;
-        const updateCols = batch.cols.filter((c) => !batchKeys.includes(c) && !c.startsWith("_"));
-        if (updateCols.length > 0) {
-          const setClauses = updateCols.map((c) => `"${c}" = EXCLUDED."${c}"`);
-          stmt += ` ON CONFLICT (${batchKeys.map((k) => `"${k}"`).join(", ")}) DO UPDATE SET ${setClauses.join(", ")}`;
-        } else {
-          stmt += ` ON CONFLICT (${batchKeys.map((k) => `"${k}"`).join(", ")}) DO NOTHING`;
-        }
-      }
-      statements.push(stmt);
-      currentBatch = null;
-      currentBatchKey = "";
-    };
-    for (const op of ops) {
-      const qualifiedTable = `"${this.pgSchemaName}"."${op.table}"`;
-      if (op.kind === "insert") {
-        flushIncrementBatch();
-        const { cols, vals, upsertKeys, batchKey } = this.prepareInsert(op);
-        if (batchKey === currentBatchKey && currentBatch) {
-          currentBatch.rows.push(vals);
-        } else {
-          flushInsertBatch();
-          currentBatch = { table: op.table, cols, rows: [vals], upsertKeys };
-          currentBatchKey = batchKey;
-        }
-      } else if (op.kind === "increment") {
-        flushInsertBatch();
-        const keyCols = [...op.data._upsert_keys].sort();
-        const deltaCols = Object.keys(op.set ?? {}).sort();
-        const batchKey = `inc:${op.table}:${keyCols.join(",")}:${deltaCols.join(",")}`;
-        if (batchKey !== incBatchKey || !incBatch) {
-          flushIncrementBatch();
-          incBatch = { table: op.table, keyCols, deltaCols, rows: new Map };
-          incBatchKey = batchKey;
-        }
-        const clean = stripControlKeys(op.data);
-        const keySig = keyCols.map((k) => escapeLiteral(clean[k])).join("\x00");
-        const existing = incBatch.rows.get(keySig);
-        if (existing) {
-          for (const c of deltaCols) {
-            existing.deltas[c] = (existing.deltas[c] ?? 0n) + toBigIntOr0(op.set?.[c]);
-          }
-        } else {
-          const deltas = {};
-          for (const c of deltaCols)
-            deltas[c] = toBigIntOr0(op.set?.[c]);
-          incBatch.rows.set(keySig, {
-            keys: clean,
-            deltas,
-            meta: {
-              blockHeight: op.data._block_height ?? this.block.height,
-              txId: op.data._tx_id ?? this._tx.txId
-            }
-          });
-        }
-      } else {
-        flushInsertBatch();
-        flushIncrementBatch();
-        if (op.kind === "update") {
-          const setEntries = Object.entries(op.set ?? {});
-          for (const [k] of setEntries)
-            validateColumnName(k);
-          const setClauses = setEntries.map(([k, v]) => `"${k}" = ${escapeLiteral(v)}`);
-          const { clause } = buildWhereClause(op.data);
-          if (this.journal) {
-            statements.push(this.journalCaptureByWhereSQL(op.table, clause));
-          }
-          statements.push(`UPDATE ${qualifiedTable} SET ${setClauses.join(", ")} WHERE ${clause}`);
-        } else if (op.kind === "delete") {
-          const { clause } = buildWhereClause(op.data);
-          if (this.journal) {
-            statements.push(this.journalCaptureByWhereSQL(op.table, clause));
-          }
-          statements.push(`DELETE FROM ${qualifiedTable} WHERE ${clause}`);
-        }
-      }
-    }
-    flushInsertBatch();
-    flushIncrementBatch();
-    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 stripControlKeys(data) {
-  const {
-    _upsert_keys: _a,
-    _upsert_fallback_keys: _b,
-    _upsert_fallback_set: _c,
-    ...clean
-  } = data;
-  return clean;
-}
-function valEq(a, b) {
-  if (a === b)
-    return true;
-  if (a == null || b == null)
-    return false;
-  return String(a) === String(b);
-}
-function rowMatches(row, where) {
-  return Object.entries(where).every(([k, v]) => valEq(row[k], v));
-}
-function toBigIntOr0(v) {
-  if (typeof v === "bigint")
-    return v;
-  if (v == null)
-    return 0n;
-  try {
-    return BigInt(String(v));
-  } catch {
-    return 0n;
-  }
-}
-function jsonSafe(row) {
-  const out = {};
-  for (const [k, v] of Object.entries(row)) {
-    out[k] = typeof v === "bigint" ? v.toString() : v;
-  }
-  return out;
-}
-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, (_k, v) => typeof v === "bigint" ? v.toString() : v).replace(/'/g, "''")}'::jsonb`;
-  return `'${String(value).replace(/'/g, "''")}'`;
-}
-function buildWhereClause(where) {
-  const entries = Object.entries(where);
-  if (entries.length === 0)
-    return { clause: "TRUE", values: [] };
-  for (const [k] of entries)
-    validateColumnName(k);
-  const parts = entries.map(([k, v]) => `"${k}" = ${escapeLiteral(v)}`);
-  return { clause: parts.join(" AND "), values: [] };
-}
-export {
-  SubgraphContext,
-  JOURNAL_RETENTION_BLOCKS
-};
-
-//# debugId=92CDE25F6A98E6BA64756E2164756E21
-//# sourceMappingURL=context.js.map