@thru/indexer 0.2.21 → 0.2.23

package/README.md

@@ -14,7 +14,7 @@ A reusable blockchain indexing framework for building backends that index Thru c
 ## Installation
 
 ```bash
-pnpm add @thru/indexer @thru/replay @thru/helpers postgres drizzle-orm hono @hono/zod-openapi
+pnpm add @thru/indexer @thru/replay @thru/sdk/helpers postgres drizzle-orm hono @hono/zod-openapi
 pnpm add -D drizzle-kit tsx typescript
 ```
 
@@ -25,7 +25,7 @@ pnpm add -D drizzle-kit tsx typescript
 ```typescript
 // src/streams/transfers.ts
 import { create } from "@bufbuild/protobuf";
-import { decodeAddress, encodeAddress, encodeSignature } from "@thru/helpers";
+import { decodeAddress, encodeAddress, encodeSignature } from "@thru/sdk/helpers";
 import { defineEventStream, t } from "@thru/indexer";
 import { FilterSchema, FilterParamValueSchema, type Event } from "@thru/replay";
 import { TokenEvent } from "../abi/token";
@@ -91,7 +91,7 @@ export default transfers;
 
 ```typescript
 // src/account-streams/token-accounts.ts
-import { decodeAddress, encodeAddress } from "@thru/helpers";
+import { decodeAddress, encodeAddress } from "@thru/sdk/helpers";
 import { defineAccountStream, t } from "@thru/indexer";
 import { TokenAccount } from "../abi/token";
 

package/dist/index.cjs

@@ -4,9 +4,7 @@ var pgCore = require('drizzle-orm/pg-core');
 var zod = require('zod');
 var replay = require('@thru/replay');
 var drizzleOrm = require('drizzle-orm');
-var helpers = require('@thru/helpers');
-var zodOpenapi = require('@hono/zod-openapi');
-var drizzleZod = require('drizzle-zod');
+var helpers = require('@thru/sdk/helpers');
 
 // src/schema/builder.ts
 function createBuilder(state) {
@@ -194,7 +192,7 @@ function validateParsedData(schema, data, streamName) {
   if (result.success) {
     return { success: true, data: result.data };
   }
-  const errorMessages = result.error.errors.map((e) => `  - ${e.path.join(".")}: ${e.message}`).join("\n");
+  const errorMessages = result.error.issues.map((e) => `  - ${e.path.join(".")}: ${e.message}`).join("\n");
   return {
     success: false,
     error: `Stream "${streamName}" parse returned invalid data:
@@ -289,18 +287,18 @@ async function getAllCheckpoints(db) {
 // src/checkpoint/index.ts
 function getSchemaExports(config) {
   const { eventStreams = [], accountStreams = [], tableNames = {} } = config;
-  const exports$1 = {
+  const exports = {
     checkpointTable
   };
   for (const stream of eventStreams) {
     const exportName = tableNames[stream.name] ?? `${stream.name}Table`;
-    exports$1[exportName] = stream.table;
+    exports[exportName] = stream.table;
   }
   for (const stream of accountStreams) {
     const exportName = tableNames[stream.name] ?? `${stream.name.replace(/-/g, "")}Table`;
-    exports$1[exportName] = stream.table;
+    exports[exportName] = stream.table;
   }
-  return exports$1;
+  return exports;
 }
 
 // src/streams/processor.ts
@@ -744,297 +742,6 @@ async function runAccountStreamProcessor(stream, options, abortSignal) {
   );
   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;
@@ -1228,22 +935,13 @@ var Indexer = class {
 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;