@thru/indexer 0.2.20 → 0.2.22

package/dist/index.mjs

@@ -1,10 +1,8 @@
 import { pgTable, timestamp, text, bigint, boolean, integer, index } from 'drizzle-orm/pg-core';
-import { z as z$1 } from 'zod';
+import { z } from 'zod';
 import { createConsoleLogger, createEventReplay, createAccountsByOwnerReplay, AccountView } from '@thru/replay';
-import { eq, getTableColumns, sql, gte, lte, desc, and } from 'drizzle-orm';
-import { encodeAddress } from '@thru/helpers';
-import { z, OpenAPIHono, createRoute } from '@hono/zod-openapi';
-import { createSelectSchema, createInsertSchema } from 'drizzle-zod';
+import { eq, sql } from 'drizzle-orm';
+import { encodeAddress } from '@thru/sdk/helpers';
 
 // src/schema/builder.ts
 function createBuilder(state) {
@@ -162,29 +160,29 @@ function generateZodSchema(schema) {
     let zodType;
     switch (colDef._columnType) {
       case "text":
-        zodType = z$1.string();
+        zodType = z.string();
         break;
       case "bigint":
-        zodType = z$1.bigint();
+        zodType = z.bigint();
         break;
       case "integer":
-        zodType = z$1.number().int();
+        zodType = z.number().int();
         break;
       case "boolean":
-        zodType = z$1.boolean();
+        zodType = z.boolean();
         break;
       case "timestamp":
-        zodType = z$1.date();
+        zodType = z.date();
         break;
       default:
-        zodType = z$1.unknown();
+        zodType = z.unknown();
     }
     if (colDef._nullable) {
       zodType = zodType.nullable();
     }
     shape[key] = zodType;
   }
-  return z$1.object(shape);
+  return z.object(shape);
 }
 function validateParsedData(schema, data, streamName) {
   const zodSchema = generateZodSchema(schema);
@@ -192,7 +190,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:
@@ -287,18 +285,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
@@ -742,297 +740,6 @@ async function runAccountStreamProcessor(stream, options, abortSignal) {
   );
   return stats;
 }
-var paginationQuerySchema = z.object({
-  limit: z.coerce.number().int().min(1).max(100).default(20).openapi({
-    description: "Number of results to return (1-100)",
-    example: 20
-  }),
-  offset: z.coerce.number().int().min(0).default(0).openapi({
-    description: "Number of results to skip",
-    example: 0
-  }),
-  cursor: z.string().optional().openapi({
-    description: "Cursor for pagination (format: slot:id)",
-    example: "3181195:abc123"
-  })
-});
-var paginationResponseSchema = z.object({
-  limit: z.number().openapi({ example: 20 }),
-  offset: z.number().openapi({ example: 0 }),
-  hasMore: z.boolean().openapi({ example: true }),
-  nextCursor: z.string().nullable().openapi({ example: "3181195:abc123" })
-});
-function dataResponse(schema) {
-  return z.object({ data: schema });
-}
-function listResponse(schema) {
-  return z.object({
-    data: z.array(schema),
-    pagination: paginationResponseSchema
-  });
-}
-var errorSchema = z.object({
-  error: z.string().openapi({ example: "Not found" }),
-  code: 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 = createSelectSchema(table);
-  const insertSchema = createInsertSchema(table);
-  const apiFields = {};
-  const columns = 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 = z.string().openapi({ description: `${colName} (bigint)` });
-        break;
-      case "date":
-        fieldSchema = z.string().openapi({ description: `${colName} (ISO timestamp)` });
-        break;
-      case "string":
-        fieldSchema = z.string();
-        break;
-      case "number":
-        fieldSchema = z.number();
-        break;
-      case "boolean":
-        fieldSchema = z.boolean();
-        break;
-      default:
-        fieldSchema = z.any();
-    }
-    if (!notNull) {
-      fieldSchema = fieldSchema.nullable();
-    }
-    apiFields[colName] = fieldSchema;
-  }
-  const schemaName = suffix ? `${pascalCase3(name)}${suffix}` : pascalCase3(name);
-  const apiSchema = 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 OpenAPIHono();
-  const tag = pascalCase4(name);
-  const filterFields = {};
-  for (const field of filters) {
-    filterFields[field] = z.string().optional().openapi({
-      description: `Filter by ${field}`
-    });
-  }
-  if (includeSlotFilters) {
-    filterFields.fromSlot = z.string().optional().openapi({
-      description: "Minimum slot number"
-    });
-    filterFields.toSlot = z.string().optional().openapi({
-      description: "Maximum slot number"
-    });
-  }
-  const listQuerySchema = paginationQuerySchema.extend(filterFields);
-  const listRoute = 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(eq(table[field], value));
-      }
-    }
-    if (includeSlotFilters) {
-      if (query.fromSlot) {
-        conditions.push(gte(table.slot, BigInt(query.fromSlot)));
-      }
-      if (query.toSlot) {
-        conditions.push(lte(table.slot, BigInt(query.toSlot)));
-      }
-    }
-    if (query.cursor && secondarySortField) {
-      const parsed = parseCursor(query.cursor);
-      if (parsed) {
-        conditions.push(
-          sql`(${table.slot} < ${parsed.slot} OR (${table.slot} = ${parsed.slot} AND ${table[secondarySortField]} < ${parsed.id}))`
-        );
-      }
-    }
-    const orderBy = secondarySortField ? [desc(table[sortField]), desc(table[secondarySortField])] : [desc(table[sortField])];
-    const rows = await db.select().from(table).where(conditions.length > 0 ? 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 = createRoute({
-    method: "get",
-    path: `/{${idField}}`,
-    tags: [tag],
-    summary: `Get ${name} ${resourceType} by ${idField}`,
-    description: `Returns a single ${name} ${resourceType} by its ${idField}.`,
-    request: {
-      params: z.object({
-        [idField]: 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(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;
@@ -1223,6 +930,6 @@ var Indexer = class {
   }
 };
 
-export { Indexer, checkpointTable, columnBuilder, dataResponse, defineAccountStream, defineEventStream, deleteCheckpoint, errorSchema, generateSchemas, generateZodSchema, getAllCheckpoints, getCheckpoint, getSchemaExports, listResponse, mountStreamRoutes, paginate, paginationQuerySchema, paginationResponseSchema, parseCursor, t, updateCheckpoint, validateParsedData };
+export { Indexer, checkpointTable, columnBuilder, defineAccountStream, defineEventStream, deleteCheckpoint, generateZodSchema, getAllCheckpoints, getCheckpoint, getSchemaExports, t, updateCheckpoint, validateParsedData };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map