@thru/indexer 0.1.38

package/dist/index.cjs

@@ -0,0 +1,1208 @@
+'use strict';
+
+var pgCore = require('drizzle-orm/pg-core');
+var zod = require('zod');
+var replay = require('@thru/replay');
+var drizzleOrm = require('drizzle-orm');
+var zodOpenapi = require('@hono/zod-openapi');
+var drizzleZod = require('drizzle-zod');
+
+// src/schema/builder.ts
+function createBuilder(state) {
+  const builder = {
+    get _type() {
+      return state._type;
+    },
+    get _columnType() {
+      return state._columnType;
+    },
+    get _nullable() {
+      return state._nullable;
+    },
+    get _indexed() {
+      return state._indexed;
+    },
+    get _unique() {
+      return state._unique;
+    },
+    get _primary() {
+      return state._primary;
+    },
+    get _default() {
+      return state._default;
+    },
+    get _defaultNow() {
+      return state._defaultNow;
+    },
+    get _references() {
+      return state._references;
+    },
+    notNull() {
+      state._nullable = false;
+      return createBuilder(state);
+    },
+    index() {
+      state._indexed = true;
+      return builder;
+    },
+    unique() {
+      state._unique = true;
+      return builder;
+    },
+    primaryKey() {
+      state._primary = true;
+      state._nullable = false;
+      return createBuilder(state);
+    },
+    default(value) {
+      state._default = value;
+      return builder;
+    },
+    defaultNow() {
+      state._defaultNow = true;
+      return builder;
+    },
+    references(table, column) {
+      const resolvedTable = typeof table === "function" ? table() : table;
+      state._references = { table: resolvedTable, column };
+      return builder;
+    }
+  };
+  return builder;
+}
+function createColumnDef(type) {
+  const state = {
+    _type: void 0,
+    _columnType: type,
+    _nullable: true,
+    _indexed: false,
+    _unique: false,
+    _primary: false,
+    _default: void 0,
+    _defaultNow: false,
+    _references: void 0
+  };
+  return createBuilder(state);
+}
+var t = {
+  text: () => createColumnDef("text"),
+  bigint: () => createColumnDef("bigint"),
+  integer: () => createColumnDef("integer"),
+  boolean: () => createColumnDef("boolean"),
+  timestamp: () => createColumnDef("timestamp")
+};
+var columnBuilder = t;
+function camelToSnake(str) {
+  return str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+}
+function buildDrizzleTable(tableName, schema) {
+  const columns = {};
+  const indices = [];
+  for (const [name, def] of Object.entries(schema)) {
+    const internal = def;
+    const snakeName = camelToSnake(name);
+    let col;
+    switch (internal._columnType) {
+      case "text":
+        col = pgCore.text(snakeName);
+        break;
+      case "bigint":
+        col = pgCore.bigint(snakeName, { mode: "bigint" });
+        break;
+      case "integer":
+        col = pgCore.integer(snakeName);
+        break;
+      case "boolean":
+        col = pgCore.boolean(snakeName);
+        break;
+      case "timestamp":
+        col = pgCore.timestamp(snakeName, { withTimezone: true });
+        break;
+      default:
+        throw new Error(`Unknown column type: ${internal._columnType}`);
+    }
+    if (internal._primary) {
+      col = col.primaryKey();
+    }
+    if (internal._unique) {
+      col = col.unique();
+    }
+    if (!internal._nullable) {
+      col = col.notNull();
+    }
+    if (internal._defaultNow && internal._columnType === "timestamp") {
+      col = col.defaultNow();
+    } else if (internal._default !== void 0) {
+      col = col.default(internal._default);
+    }
+    if (internal._references) {
+      const refTable = internal._references.table;
+      const refColumn = internal._references.column;
+      col = col.references(() => refTable[refColumn]);
+    }
+    columns[name] = col;
+    if (internal._indexed) {
+      indices.push(
+        (table) => pgCore.index(`${tableName}_${snakeName}_idx`).on(table[name])
+      );
+    }
+  }
+  if (indices.length > 0) {
+    return pgCore.pgTable(
+      tableName,
+      columns,
+      (table) => indices.map((fn) => fn(table))
+    );
+  }
+  return pgCore.pgTable(tableName, columns);
+}
+function generateZodSchema(schema) {
+  const shape = {};
+  for (const [key, col] of Object.entries(schema)) {
+    const colDef = col;
+    let zodType;
+    switch (colDef._columnType) {
+      case "text":
+        zodType = zod.z.string();
+        break;
+      case "bigint":
+        zodType = zod.z.bigint();
+        break;
+      case "integer":
+        zodType = zod.z.number().int();
+        break;
+      case "boolean":
+        zodType = zod.z.boolean();
+        break;
+      case "timestamp":
+        zodType = zod.z.date();
+        break;
+      default:
+        zodType = zod.z.unknown();
+    }
+    if (colDef._nullable) {
+      zodType = zodType.nullable();
+    }
+    shape[key] = zodType;
+  }
+  return zod.z.object(shape);
+}
+function validateParsedData(schema, data, streamName) {
+  const zodSchema = generateZodSchema(schema);
+  const result = zodSchema.safeParse(data);
+  if (result.success) {
+    return { success: true, data: result.data };
+  }
+  const errorMessages = result.error.errors.map((e) => `  - ${e.path.join(".")}: ${e.message}`).join("\n");
+  return {
+    success: false,
+    error: `Stream "${streamName}" parse returned invalid data:
+${errorMessages}`
+  };
+}
+
+// src/streams/define.ts
+function pascalCase(str) {
+  return str.split(/[-_\s]+/).map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join("");
+}
+function defineEventStream(definition) {
+  if (!definition.filter && !definition.filterFactory) {
+    throw new Error(`Stream "${definition.name}" must provide either filter or filterFactory`);
+  }
+  const tableName = `${definition.name.replace(/s$/, "")}_events`;
+  const table = buildDrizzleTable(tableName, definition.schema);
+  let cachedFilter = definition.filter ?? null;
+  const getFilter = () => {
+    if (!cachedFilter) {
+      if (definition.filterFactory) {
+        cachedFilter = definition.filterFactory();
+      } else {
+        throw new Error(`Stream "${definition.name}" has no filter configured`);
+      }
+    }
+    return cachedFilter;
+  };
+  return {
+    name: definition.name,
+    description: definition.description ?? `${pascalCase(definition.name)} events`,
+    schema: definition.schema,
+    table,
+    // Column accessors for Drizzle operators
+    c: table,
+    getFilter,
+    parse: definition.parse,
+    api: definition.api,
+    filterBatch: definition.filterBatch,
+    onCommit: definition.onCommit
+  };
+}
+var checkpointTable = pgCore.pgTable("indexer_checkpoints", {
+  /** Stream name (primary key) */
+  streamName: pgCore.text("stream_name").primaryKey(),
+  /** Last indexed slot number */
+  lastIndexedSlot: pgCore.bigint("last_indexed_slot", { mode: "bigint" }).notNull(),
+  /** Last event ID (for cursor-based resume) */
+  lastEventId: pgCore.text("last_event_id"),
+  /** When the checkpoint was last updated */
+  updatedAt: pgCore.timestamp("updated_at", { withTimezone: true }).defaultNow().notNull()
+});
+async function getCheckpoint(db, streamName) {
+  const [row] = await db.select().from(checkpointTable).where(drizzleOrm.eq(checkpointTable.streamName, streamName)).limit(1);
+  if (!row) {
+    return null;
+  }
+  return {
+    slot: row.lastIndexedSlot,
+    eventId: row.lastEventId
+  };
+}
+async function updateCheckpoint(db, streamName, slot, eventId = null) {
+  await db.insert(checkpointTable).values({
+    streamName,
+    lastIndexedSlot: slot,
+    lastEventId: eventId,
+    updatedAt: /* @__PURE__ */ new Date()
+  }).onConflictDoUpdate({
+    target: checkpointTable.streamName,
+    set: {
+      lastIndexedSlot: slot,
+      lastEventId: eventId,
+      updatedAt: /* @__PURE__ */ new Date()
+    }
+  });
+}
+async function deleteCheckpoint(db, streamName) {
+  await db.delete(checkpointTable).where(drizzleOrm.eq(checkpointTable.streamName, streamName));
+}
+async function getAllCheckpoints(db) {
+  const rows = await db.select().from(checkpointTable);
+  return rows.map((row) => ({
+    streamName: row.streamName,
+    checkpoint: {
+      slot: row.lastIndexedSlot,
+      eventId: row.lastEventId
+    }
+  }));
+}
+
+// src/checkpoint/index.ts
+function getSchemaExports(config) {
+  const { eventStreams = [], accountStreams = [], tableNames = {} } = config;
+  const exports$1 = {
+    checkpointTable
+  };
+  for (const stream of eventStreams) {
+    const exportName = tableNames[stream.name] ?? `${stream.name}Table`;
+    exports$1[exportName] = stream.table;
+  }
+  for (const stream of accountStreams) {
+    const exportName = tableNames[stream.name] ?? `${stream.name.replace(/-/g, "")}Table`;
+    exports$1[exportName] = stream.table;
+  }
+  return exports$1;
+}
+
+// src/streams/processor.ts
+var StreamBatcher = class {
+  currentSlot = null;
+  pendingEvents = [];
+  lastFlushTime = Date.now();
+  maxPendingCount = 100;
+  maxPendingMs = 5e3;
+  addEvent(event, slot) {
+    if (this.shouldFlush(slot)) {
+      const batch = this.flush();
+      this.currentSlot = slot;
+      this.pendingEvents = [event];
+      return batch;
+    }
+    this.currentSlot = slot;
+    this.pendingEvents.push(event);
+    return null;
+  }
+  shouldFlush(newSlot) {
+    if (this.pendingEvents.length === 0) return false;
+    if (this.currentSlot !== null && newSlot !== this.currentSlot) return true;
+    if (this.pendingEvents.length >= this.maxPendingCount) return true;
+    if (Date.now() - this.lastFlushTime >= this.maxPendingMs) return true;
+    return false;
+  }
+  flush() {
+    if (this.pendingEvents.length === 0 || this.currentSlot === null) {
+      return null;
+    }
+    const batch = {
+      slot: this.currentSlot,
+      events: this.pendingEvents
+    };
+    this.pendingEvents = [];
+    this.lastFlushTime = Date.now();
+    return batch;
+  }
+  getPendingCount() {
+    return this.pendingEvents.length;
+  }
+  /**
+   * Flush if the timeout has elapsed since last flush.
+   * Called by background timer to ensure events don't sit in buffer indefinitely.
+   */
+  flushIfStale() {
+    if (this.pendingEvents.length > 0 && Date.now() - this.lastFlushTime >= this.maxPendingMs) {
+      return this.flush();
+    }
+    return null;
+  }
+};
+async function runEventStreamProcessor(stream, options, abortSignal) {
+  const {
+    clientFactory,
+    db,
+    defaultStartSlot,
+    safetyMargin = 64,
+    pageSize = 512,
+    logLevel = "info",
+    validateParse = false
+  } = options;
+  const log = (level, msg) => {
+    if (logLevel === "debug" || level !== "debug") {
+      console.log(`[${stream.name}] ${msg}`);
+    }
+  };
+  log("info", `Starting stream processor: ${stream.description}`);
+  const checkpoint = await getCheckpoint(db, stream.name);
+  const startSlot = checkpoint ? checkpoint.slot + 1n : defaultStartSlot;
+  log(
+    "info",
+    `Starting from slot ${startSlot}${checkpoint ? " (resuming)" : " (fresh start)"}`
+  );
+  const logger = logLevel === "debug" ? replay.createConsoleLogger(stream.name) : {
+    debug: () => {
+    },
+    info: (msg) => log("info", msg),
+    warn: (msg) => log("warn", msg),
+    error: (msg) => log("error", msg)
+  };
+  const replay$1 = replay.createEventReplay({
+    clientFactory,
+    startSlot,
+    safetyMargin: BigInt(safetyMargin),
+    pageSize,
+    filter: stream.getFilter(),
+    logger,
+    resubscribeOnEnd: true
+  });
+  const batcher = new StreamBatcher();
+  const stats = {
+    eventsProcessed: 0,
+    batchesCommitted: 0,
+    lastSlot: null
+  };
+  let lastLogTime = Date.now();
+  let eventsReceivedSinceLastLog = 0;
+  const commitBatch = async (batch) => {
+    let eventsToCommit = batch.events;
+    if (stream.filterBatch) {
+      try {
+        eventsToCommit = await stream.filterBatch(
+          eventsToCommit,
+          { db }
+        );
+        if (eventsToCommit.length === 0) {
+          log(
+            "debug",
+            `All ${batch.events.length} events filtered out at slot ${batch.slot}`
+          );
+          return;
+        }
+        if (eventsToCommit.length < batch.events.length) {
+          log(
+            "debug",
+            `Filtered ${batch.events.length - eventsToCommit.length} of ${batch.events.length} events at slot ${batch.slot}`
+          );
+        }
+      } catch (filterErr) {
+        log(
+          "error",
+          `filterBatch hook failed: ${filterErr instanceof Error ? filterErr.message : String(filterErr)}`
+        );
+        return;
+      }
+    }
+    await db.transaction(async (tx) => {
+      await tx.insert(stream.table).values(eventsToCommit).onConflictDoNothing();
+      const lastEvent = eventsToCommit[eventsToCommit.length - 1];
+      await updateCheckpoint(
+        tx,
+        stream.name,
+        batch.slot,
+        lastEvent.id
+      );
+    });
+    stats.batchesCommitted++;
+    stats.lastSlot = batch.slot;
+    if (stream.onCommit) {
+      try {
+        await stream.onCommit({ ...batch, events: eventsToCommit }, { db });
+      } catch (hookErr) {
+        log(
+          "error",
+          `onCommit hook failed: ${hookErr instanceof Error ? hookErr.message : String(hookErr)}`
+        );
+      }
+    }
+  };
+  const flushInterval = setInterval(async () => {
+    const batch = batcher.flushIfStale();
+    if (batch) {
+      try {
+        await commitBatch(batch);
+        log(
+          "debug",
+          `Timeout flush: ${batch.events.length} event(s) at slot ${batch.slot}`
+        );
+      } catch (err) {
+        log(
+          "error",
+          `Timeout flush failed: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+    }
+  }, 1e3);
+  try {
+    for await (const event of replay$1) {
+      if (abortSignal?.aborted) {
+        log("info", "Abort signal received, stopping...");
+        break;
+      }
+      eventsReceivedSinceLastLog++;
+      const parsed = stream.parse(event);
+      if (!parsed) continue;
+      if (validateParse) {
+        const validation = validateParsedData(stream.schema, parsed, stream.name);
+        if (!validation.success) {
+          log("error", validation.error);
+          continue;
+        }
+      }
+      stats.eventsProcessed++;
+      const batch = batcher.addEvent(parsed, event.slot);
+      if (batch) {
+        await commitBatch(batch);
+        log(
+          "info",
+          `Committed ${batch.events.length} event(s) at slot ${batch.slot} (total: ${stats.eventsProcessed})`
+        );
+      }
+      const now = Date.now();
+      if (now - lastLogTime >= 3e4) {
+        log(
+          "info",
+          `Heartbeat: ${eventsReceivedSinceLastLog} events received, ${batcher.getPendingCount()} pending`
+        );
+        eventsReceivedSinceLastLog = 0;
+        lastLogTime = now;
+      }
+    }
+    const finalBatch = batcher.flush();
+    if (finalBatch) {
+      await commitBatch(finalBatch);
+      log(
+        "info",
+        `Final flush: ${finalBatch.events.length} event(s) at slot ${finalBatch.slot}`
+      );
+    }
+  } catch (err) {
+    log(
+      "error",
+      `Stream error: ${err instanceof Error ? err.message : String(err)}`
+    );
+    throw err;
+  } finally {
+    clearInterval(flushInterval);
+  }
+  log(
+    "info",
+    `Stream stopped. Processed ${stats.eventsProcessed} events in ${stats.batchesCommitted} batches.`
+  );
+  return stats;
+}
+
+// src/accounts/define.ts
+function pascalCase2(str) {
+  return str.split(/[-_\s]+/).map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join("");
+}
+function defineAccountStream(definition) {
+  if (!definition.ownerProgram && !definition.ownerProgramFactory) {
+    throw new Error(`Stream "${definition.name}" must provide either ownerProgram or ownerProgramFactory`);
+  }
+  const tableName = definition.name.replace(/-/g, "_");
+  const table = buildDrizzleTable(tableName, definition.schema);
+  let cachedOwnerProgram = definition.ownerProgram ?? null;
+  const getOwnerProgram = () => {
+    if (!cachedOwnerProgram) {
+      if (definition.ownerProgramFactory) {
+        cachedOwnerProgram = definition.ownerProgramFactory();
+      } else {
+        throw new Error(`Stream "${definition.name}" has no ownerProgram configured`);
+      }
+    }
+    return cachedOwnerProgram;
+  };
+  return {
+    name: definition.name,
+    description: definition.description ?? `${pascalCase2(definition.name)} accounts`,
+    schema: definition.schema,
+    getOwnerProgram,
+    expectedSize: definition.expectedSize,
+    dataSizes: definition.dataSizes,
+    table,
+    // Column accessors for Drizzle operators
+    c: table,
+    parse: definition.parse,
+    api: definition.api
+  };
+}
+function shouldLog(level, minLevel) {
+  const levels = ["debug", "info", "warn", "error"];
+  return levels.indexOf(level) >= levels.indexOf(minLevel);
+}
+async function runAccountStreamProcessor(stream, options, abortSignal) {
+  const { clientFactory, db, logLevel = "info", validateParse = false } = options;
+  const checkpointName = `account:${stream.name}`;
+  const log = (level, msg, meta) => {
+    if (shouldLog(level, logLevel)) {
+      console.log(
+        `[account-stream:${stream.name}] ${msg}`,
+        ""
+      );
+    }
+  };
+  const stats = {
+    accountsProcessed: 0,
+    accountsUpdated: 0,
+    accountsDeleted: 0
+  };
+  const checkpoint = await getCheckpoint(db, checkpointName);
+  const minUpdatedSlot = checkpoint?.slot ?? void 0;
+  if (minUpdatedSlot) {
+    log("info", `Resuming from checkpoint: slot ${minUpdatedSlot}`);
+  }
+  log("info", `Starting account stream: ${stream.description}`);
+  if (stream.expectedSize) {
+    log("info", `Expected data size: ${stream.expectedSize} bytes`);
+  }
+  let lastProcessedSlot = minUpdatedSlot ?? 0n;
+  try {
+    const replay$1 = replay.createAccountsByOwnerReplay({
+      clientFactory,
+      owner: stream.getOwnerProgram(),
+      view: replay.AccountView.FULL,
+      dataSizes: stream.dataSizes ?? (stream.expectedSize ? [stream.expectedSize] : void 0),
+      minUpdatedSlot,
+      onBackfillComplete: (highestSlot) => {
+        log(
+          "info",
+          `Backfill complete. Highest slot: ${highestSlot}, accounts processed: ${stats.accountsProcessed}`
+        );
+        lastProcessedSlot = highestSlot;
+      }
+    });
+    for await (const event of replay$1) {
+      if (abortSignal?.aborted) {
+        log("info", "Abort signal received, stopping");
+        break;
+      }
+      if (event.type === "account") {
+        const account = event.account;
+        stats.accountsProcessed++;
+        if (stats.accountsProcessed <= 3) {
+          log(
+            "info",
+            `Account ${stats.accountsProcessed}: ${account.addressHex}, slot=${account.slot}, dataLen=${account.data.length}`
+          );
+        }
+        const parsed = stream.parse(account);
+        if (!parsed) {
+          log(
+            "debug",
+            `Skipped account ${account.addressHex} - parser returned null (dataLen=${account.data.length})`
+          );
+          continue;
+        }
+        if (validateParse) {
+          const validation = validateParsedData(stream.schema, parsed, stream.name);
+          if (!validation.success) {
+            log("error", validation.error);
+            continue;
+          }
+        }
+        if (account.isDelete) {
+          log("debug", `Account deleted: ${account.addressHex}`);
+          stats.accountsDeleted++;
+          continue;
+        }
+        const table = stream.table;
+        const idField = stream.api?.idField ?? "address";
+        try {
+          await db.insert(stream.table).values(parsed).onConflictDoUpdate({
+            target: table[idField],
+            set: parsed,
+            where: drizzleOrm.sql`${table.slot} <= ${parsed.slot}`
+          });
+          stats.accountsUpdated++;
+          if (stats.accountsUpdated <= 3) {
+            log(
+              "info",
+              `Successfully inserted account ${stats.accountsUpdated}`
+            );
+          }
+        } catch (err) {
+          log(
+            "error",
+            `Failed to upsert account ${account.addressHex}: ${err}`
+          );
+        }
+        if (account.slot > lastProcessedSlot) {
+          lastProcessedSlot = account.slot;
+        }
+        if (stats.accountsProcessed % 100 === 0) {
+          log(
+            "info",
+            `Processed ${stats.accountsProcessed} accounts, updated ${stats.accountsUpdated}`
+          );
+        }
+      } else if (event.type === "blockFinished") {
+        const slot = event.block.slot;
+        if (slot > lastProcessedSlot) {
+          lastProcessedSlot = slot;
+        }
+        await updateCheckpoint(db, checkpointName, lastProcessedSlot, null);
+        log("debug", `Block finished: slot ${slot}, checkpoint saved`);
+      }
+    }
+    if (lastProcessedSlot > 0n) {
+      await updateCheckpoint(db, checkpointName, lastProcessedSlot, null);
+      log("info", `Final checkpoint saved: slot ${lastProcessedSlot}`);
+    }
+  } catch (err) {
+    if (abortSignal?.aborted) {
+      log("info", "Stream aborted");
+    } else {
+      log(
+        "error",
+        `Stream error: ${err instanceof Error ? err.message : String(err)}`
+      );
+      throw err;
+    }
+  }
+  log(
+    "info",
+    `Finished. Processed: ${stats.accountsProcessed}, Updated: ${stats.accountsUpdated}, Deleted: ${stats.accountsDeleted}`
+  );
+  return stats;
+}
+var paginationQuerySchema = zodOpenapi.z.object({
+  limit: zodOpenapi.z.coerce.number().int().min(1).max(100).default(20).openapi({
+    description: "Number of results to return (1-100)",
+    example: 20
+  }),
+  offset: zodOpenapi.z.coerce.number().int().min(0).default(0).openapi({
+    description: "Number of results to skip",
+    example: 0
+  }),
+  cursor: zodOpenapi.z.string().optional().openapi({
+    description: "Cursor for pagination (format: slot:id)",
+    example: "3181195:abc123"
+  })
+});
+var paginationResponseSchema = zodOpenapi.z.object({
+  limit: zodOpenapi.z.number().openapi({ example: 20 }),
+  offset: zodOpenapi.z.number().openapi({ example: 0 }),
+  hasMore: zodOpenapi.z.boolean().openapi({ example: true }),
+  nextCursor: zodOpenapi.z.string().nullable().openapi({ example: "3181195:abc123" })
+});
+function dataResponse(schema) {
+  return zodOpenapi.z.object({ data: schema });
+}
+function listResponse(schema) {
+  return zodOpenapi.z.object({
+    data: zodOpenapi.z.array(schema),
+    pagination: paginationResponseSchema
+  });
+}
+var errorSchema = zodOpenapi.z.object({
+  error: zodOpenapi.z.string().openapi({ example: "Not found" }),
+  code: zodOpenapi.z.string().optional().openapi({ example: "NOT_FOUND" })
+}).openapi("Error");
+function paginate(rows, query, getCursor) {
+  const hasMore = rows.length > query.limit;
+  const data = hasMore ? rows.slice(0, -1) : rows;
+  const lastItem = data[data.length - 1];
+  let nextCursor = null;
+  if (hasMore && lastItem) {
+    if (getCursor) {
+      nextCursor = getCursor(lastItem);
+    } else {
+      const item = lastItem;
+      if (item.slot !== void 0 && item.id !== void 0) {
+        nextCursor = `${item.slot}:${item.id}`;
+      }
+    }
+  }
+  return {
+    data,
+    pagination: {
+      limit: query.limit,
+      offset: query.offset,
+      hasMore,
+      nextCursor
+    }
+  };
+}
+function parseCursor(cursor) {
+  const colonIndex = cursor.indexOf(":");
+  if (colonIndex === -1) return null;
+  try {
+    const slot = BigInt(cursor.slice(0, colonIndex));
+    const id = cursor.slice(colonIndex + 1);
+    return { slot, id };
+  } catch {
+    return null;
+  }
+}
+function pascalCase3(str) {
+  return str.split(/[-_\s]+/).map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join("");
+}
+function generateSchemas(table, name, suffix = "") {
+  const rowSchema = drizzleZod.createSelectSchema(table);
+  const insertSchema = drizzleZod.createInsertSchema(table);
+  const apiFields = {};
+  const columns = drizzleOrm.getTableColumns(table);
+  for (const [colName, col] of Object.entries(columns)) {
+    const dataType = col.dataType;
+    const notNull = col.notNull;
+    let fieldSchema;
+    switch (dataType) {
+      case "bigint":
+        fieldSchema = zodOpenapi.z.string().openapi({ description: `${colName} (bigint)` });
+        break;
+      case "date":
+        fieldSchema = zodOpenapi.z.string().openapi({ description: `${colName} (ISO timestamp)` });
+        break;
+      case "string":
+        fieldSchema = zodOpenapi.z.string();
+        break;
+      case "number":
+        fieldSchema = zodOpenapi.z.number();
+        break;
+      case "boolean":
+        fieldSchema = zodOpenapi.z.boolean();
+        break;
+      default:
+        fieldSchema = zodOpenapi.z.any();
+    }
+    if (!notNull) {
+      fieldSchema = fieldSchema.nullable();
+    }
+    apiFields[colName] = fieldSchema;
+  }
+  const schemaName = suffix ? `${pascalCase3(name)}${suffix}` : pascalCase3(name);
+  const apiSchema = zodOpenapi.z.object(apiFields).openapi(schemaName);
+  const serialize = (row) => {
+    const result = {};
+    for (const [key, value] of Object.entries(row)) {
+      if (typeof value === "bigint") {
+        result[key] = value.toString();
+      } else if (value instanceof Date) {
+        result[key] = value.toISOString();
+      } else {
+        result[key] = value;
+      }
+    }
+    return result;
+  };
+  return {
+    row: rowSchema,
+    insert: insertSchema,
+    api: apiSchema,
+    serialize
+  };
+}
+
+// src/api/routes.ts
+function pascalCase4(str) {
+  return str.split(/[-_\s]+/).map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join("");
+}
+function buildRoutes(config) {
+  const {
+    db,
+    name,
+    table,
+    schemas,
+    filters,
+    idField,
+    resourceType,
+    includeSlotFilters,
+    sortField,
+    secondarySortField
+  } = config;
+  const router = new zodOpenapi.OpenAPIHono();
+  const tag = pascalCase4(name);
+  const filterFields = {};
+  for (const field of filters) {
+    filterFields[field] = zodOpenapi.z.string().optional().openapi({
+      description: `Filter by ${field}`
+    });
+  }
+  if (includeSlotFilters) {
+    filterFields.fromSlot = zodOpenapi.z.string().optional().openapi({
+      description: "Minimum slot number"
+    });
+    filterFields.toSlot = zodOpenapi.z.string().optional().openapi({
+      description: "Maximum slot number"
+    });
+  }
+  const listQuerySchema = paginationQuerySchema.extend(filterFields);
+  const listRoute = zodOpenapi.createRoute({
+    method: "get",
+    path: "/",
+    tags: [tag],
+    summary: `List ${name} ${resourceType}s`,
+    description: `Returns a paginated list of ${name} ${resourceType}s with optional filtering.`,
+    request: { query: listQuerySchema },
+    responses: {
+      200: {
+        description: `List of ${name} ${resourceType}s`,
+        content: { "application/json": { schema: listResponse(schemas.api) } }
+      }
+    }
+  });
+  router.openapi(listRoute, async (c) => {
+    const query = c.req.valid("query");
+    const conditions = [];
+    for (const field of filters) {
+      const value = query[field];
+      if (value !== void 0 && value !== "") {
+        conditions.push(drizzleOrm.eq(table[field], value));
+      }
+    }
+    if (includeSlotFilters) {
+      if (query.fromSlot) {
+        conditions.push(drizzleOrm.gte(table.slot, BigInt(query.fromSlot)));
+      }
+      if (query.toSlot) {
+        conditions.push(drizzleOrm.lte(table.slot, BigInt(query.toSlot)));
+      }
+    }
+    if (query.cursor && secondarySortField) {
+      const parsed = parseCursor(query.cursor);
+      if (parsed) {
+        conditions.push(
+          drizzleOrm.sql`(${table.slot} < ${parsed.slot} OR (${table.slot} = ${parsed.slot} AND ${table[secondarySortField]} < ${parsed.id}))`
+        );
+      }
+    }
+    const orderBy = secondarySortField ? [drizzleOrm.desc(table[sortField]), drizzleOrm.desc(table[secondarySortField])] : [drizzleOrm.desc(table[sortField])];
+    const rows = await db.select().from(table).where(conditions.length > 0 ? drizzleOrm.and(...conditions) : void 0).orderBy(...orderBy).limit(query.limit + 1).offset(query.cursor ? 0 : query.offset);
+    const result = paginate(rows, query);
+    return c.json({
+      data: result.data.map(
+        (row) => schemas.serialize(row)
+      ),
+      pagination: result.pagination
+    });
+  });
+  const getRoute = zodOpenapi.createRoute({
+    method: "get",
+    path: `/{${idField}}`,
+    tags: [tag],
+    summary: `Get ${name} ${resourceType} by ${idField}`,
+    description: `Returns a single ${name} ${resourceType} by its ${idField}.`,
+    request: {
+      params: zodOpenapi.z.object({
+        [idField]: zodOpenapi.z.string().openapi({ description: `${pascalCase4(resourceType)} ${idField}` })
+      })
+    },
+    responses: {
+      200: {
+        description: `${pascalCase4(name)} ${resourceType} found`,
+        content: { "application/json": { schema: dataResponse(schemas.api) } }
+      },
+      404: {
+        description: `${pascalCase4(resourceType)} not found`,
+        content: { "application/json": { schema: errorSchema } }
+      }
+    }
+  });
+  router.openapi(getRoute, async (c) => {
+    const id = c.req.param(idField);
+    const [row] = await db.select().from(table).where(drizzleOrm.eq(table[idField], id)).limit(1);
+    if (!row) {
+      return c.json({ error: "Not found" }, 404);
+    }
+    return c.json({
+      data: schemas.serialize(row)
+    });
+  });
+  return router;
+}
+function mountStreamRoutes(app, options) {
+  const {
+    db,
+    eventStreams = [],
+    accountStreams = [],
+    pathPrefix = "/api/v1"
+  } = options;
+  for (const stream of eventStreams) {
+    if (stream.api?.enabled === false) continue;
+    const schemas = generateSchemas(stream.table, stream.name, "Event");
+    const filters = stream.api?.filters ?? [];
+    const idField = stream.api?.idField ?? "id";
+    const router = buildRoutes({
+      db,
+      name: stream.name,
+      table: stream.table,
+      schemas,
+      filters,
+      idField,
+      resourceType: "event",
+      includeSlotFilters: true,
+      sortField: "slot",
+      secondarySortField: "id"
+    });
+    app.route(`${pathPrefix}/${stream.name}`, router);
+  }
+  for (const stream of accountStreams) {
+    if (stream.api?.enabled === false) continue;
+    const schemas = generateSchemas(stream.table, stream.name, "Account");
+    const filters = stream.api?.filters ?? [];
+    const idField = stream.api?.idField ?? "address";
+    const router = buildRoutes({
+      db,
+      name: stream.name,
+      table: stream.table,
+      schemas,
+      filters,
+      idField,
+      resourceType: "account",
+      includeSlotFilters: false,
+      sortField: "updatedAt",
+      secondarySortField: void 0
+    });
+    app.route(`${pathPrefix}/${stream.name}`, router);
+  }
+}
+var Indexer = class {
+  config;
+  abortController = null;
+  running = false;
+  shutdownRequested = false;
+  constructor(config) {
+    this.config = {
+      defaultStartSlot: 0n,
+      safetyMargin: 64,
+      pageSize: 512,
+      logLevel: "info",
+      ...config
+    };
+  }
+  /**
+   * Check if the checkpoint table exists in the database.
+   * Logs a warning if it doesn't exist (user may have forgotten to export it in schema).
+   */
+  async checkCheckpointTable() {
+    try {
+      await this.config.db.execute(
+        drizzleOrm.sql`SELECT 1 FROM indexer_checkpoints LIMIT 1`
+      );
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      if (message.includes("does not exist") || message.includes("relation")) {
+        console.warn(
+          `[indexer] WARNING: Checkpoint table "indexer_checkpoints" not found.
+[indexer] Make sure to export checkpointTable from your Drizzle schema:
+
+  // db/schema.ts
+  export { checkpointTable } from "@thru/indexer";
+
+[indexer] Then run: pnpm drizzle-kit push (or generate + migrate)
+`
+        );
+      }
+      throw err;
+    }
+  }
+  /**
+   * Start the indexer.
+   *
+   * Runs all configured event and account streams concurrently.
+   * Returns when all streams complete or when stop() is called.
+   *
+   * @returns Results from all stream processors
+   */
+  async start() {
+    if (this.running) {
+      throw new Error("Indexer is already running");
+    }
+    await this.checkCheckpointTable();
+    this.running = true;
+    this.shutdownRequested = false;
+    this.abortController = new AbortController();
+    const {
+      db,
+      clientFactory,
+      eventStreams = [],
+      accountStreams = [],
+      defaultStartSlot,
+      safetyMargin,
+      pageSize,
+      logLevel,
+      validateParse
+    } = this.config;
+    console.log("[indexer] Starting indexer...");
+    console.log(
+      `[indexer] Running ${eventStreams.length} event stream(s): ${eventStreams.map((s) => s.name).join(", ") || "none"}`
+    );
+    console.log(
+      `[indexer] Running ${accountStreams.length} account stream(s): ${accountStreams.map((s) => s.name).join(", ") || "none"}`
+    );
+    try {
+      const eventProcessorOptions = {
+        clientFactory,
+        db,
+        defaultStartSlot,
+        safetyMargin,
+        pageSize,
+        logLevel,
+        validateParse
+      };
+      const accountProcessorOptions = {
+        clientFactory,
+        db,
+        logLevel,
+        validateParse
+      };
+      const eventStreamPromises = eventStreams.map(
+        (stream) => runEventStreamProcessor(
+          stream,
+          eventProcessorOptions,
+          this.abortController.signal
+        )
+      );
+      const accountStreamPromises = accountStreams.map(
+        (stream) => runAccountStreamProcessor(
+          stream,
+          accountProcessorOptions,
+          this.abortController.signal
+        )
+      );
+      const [eventResults, accountResults] = await Promise.all([
+        Promise.allSettled(eventStreamPromises),
+        Promise.allSettled(accountStreamPromises)
+      ]);
+      const result = {
+        eventStreams: eventStreams.map((stream, i) => {
+          const r = eventResults[i];
+          if (r.status === "fulfilled") {
+            console.log(
+              `[indexer] Event stream "${stream.name}" completed: ${r.value.eventsProcessed} events in ${r.value.batchesCommitted} batches`
+            );
+            return {
+              name: stream.name,
+              status: "fulfilled",
+              result: r.value
+            };
+          } else {
+            console.error(
+              `[indexer] Event stream "${stream.name}" failed:`,
+              r.reason
+            );
+            return {
+              name: stream.name,
+              status: "rejected",
+              error: r.reason
+            };
+          }
+        }),
+        accountStreams: accountStreams.map((stream, i) => {
+          const r = accountResults[i];
+          if (r.status === "fulfilled") {
+            console.log(
+              `[indexer] Account stream "${stream.name}" completed: ${r.value.accountsUpdated} accounts updated, ${r.value.accountsDeleted} deleted`
+            );
+            return {
+              name: stream.name,
+              status: "fulfilled",
+              result: r.value
+            };
+          } else {
+            console.error(
+              `[indexer] Account stream "${stream.name}" failed:`,
+              r.reason
+            );
+            return {
+              name: stream.name,
+              status: "rejected",
+              error: r.reason
+            };
+          }
+        })
+      };
+      console.log("[indexer] All streams stopped.");
+      return result;
+    } finally {
+      this.running = false;
+      this.abortController = null;
+    }
+  }
+  /**
+   * Stop the indexer gracefully.
+   *
+   * Signals all streams to finish their current batch and stop.
+   * The start() promise will resolve once all streams have stopped.
+   */
+  stop() {
+    if (!this.running || !this.abortController) {
+      console.log("[indexer] Not running");
+      return;
+    }
+    if (this.shutdownRequested) {
+      console.log("[indexer] Force shutdown...");
+      process.exit(1);
+    }
+    console.log("[indexer] Shutdown requested, finishing current batches...");
+    this.shutdownRequested = true;
+    this.abortController.abort();
+  }
+  /**
+   * Check if the indexer is currently running.
+   */
+  isRunning() {
+    return this.running;
+  }
+};
+
+exports.Indexer = Indexer;
+exports.checkpointTable = checkpointTable;
+exports.columnBuilder = columnBuilder;
+exports.dataResponse = dataResponse;
+exports.defineAccountStream = defineAccountStream;
+exports.defineEventStream = defineEventStream;
+exports.deleteCheckpoint = deleteCheckpoint;
+exports.errorSchema = errorSchema;
+exports.generateSchemas = generateSchemas;
+exports.generateZodSchema = generateZodSchema;
+exports.getAllCheckpoints = getAllCheckpoints;
+exports.getCheckpoint = getCheckpoint;
+exports.getSchemaExports = getSchemaExports;
+exports.listResponse = listResponse;
+exports.mountStreamRoutes = mountStreamRoutes;
+exports.paginate = paginate;
+exports.paginationQuerySchema = paginationQuerySchema;
+exports.paginationResponseSchema = paginationResponseSchema;
+exports.parseCursor = parseCursor;
+exports.t = t;
+exports.updateCheckpoint = updateCheckpoint;
+exports.validateParsedData = validateParsedData;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map