@latticexyz/store-indexer 2.0.0-next.13 → 2.0.0-next.15

package/src/postgres/apiRoutes.ts

@@ -0,0 +1,58 @@
+import { Sql } from "postgres";
+import { Middleware } from "koa";
+import Router from "@koa/router";
+import compose from "koa-compose";
+import { input } from "@latticexyz/store-sync/indexer-client";
+import { storeTables } from "@latticexyz/store-sync";
+import { queryLogs } from "./queryLogs";
+import { recordToLog } from "./recordToLog";
+import { debug, error } from "../debug";
+import { createBenchmark } from "@latticexyz/common";
+import { compress } from "../compress";
+
+export function apiRoutes(database: Sql): Middleware {
+  const router = new Router();
+
+  router.get("/api/logs", compress(), async (ctx) => {
+    const benchmark = createBenchmark("postgres:logs");
+    let options: ReturnType<typeof input.parse>;
+
+    try {
+      options = input.parse(typeof ctx.query.input === "string" ? JSON.parse(ctx.query.input) : {});
+    } catch (e) {
+      ctx.status = 400;
+      ctx.body = JSON.stringify(e);
+      debug(e);
+      return;
+    }
+
+    try {
+      options.filters = options.filters.length > 0 ? [...options.filters, { tableId: storeTables.Tables.tableId }] : [];
+      const records = await queryLogs(database, options ?? {}).execute();
+      benchmark("query records");
+      const logs = records.map(recordToLog);
+      benchmark("map records to logs");
+
+      if (records.length === 0) {
+        ctx.status = 404;
+        ctx.body = "no logs found";
+        error(
+          `no logs found for chainId ${options.chainId}, address ${options.address}, filters ${JSON.stringify(
+            options.filters
+          )}`
+        );
+        return;
+      }
+
+      const blockNumber = records[0].chainBlockNumber;
+      ctx.body = JSON.stringify({ blockNumber, logs });
+      ctx.status = 200;
+    } catch (e) {
+      ctx.status = 500;
+      ctx.body = JSON.stringify(e);
+      error(e);
+    }
+  });
+
+  return compose([router.routes(), router.allowedMethods()]) as Middleware;
+}

package/src/postgres/common.ts

@@ -0,0 +1,21 @@
+import { Hex } from "viem";
+
+export type RecordData = {
+  address: Hex;
+  tableId: Hex;
+  keyBytes: Hex;
+  staticData: Hex | null;
+  encodedLengths: Hex | null;
+  dynamicData: Hex | null;
+  recordBlockNumber: string;
+  logIndex: number;
+};
+
+export type RecordMetadata = {
+  indexerVersion: string;
+  chainId: string;
+  chainBlockNumber: string;
+  totalRows: number;
+};
+
+export type Record = RecordData & RecordMetadata;

package/src/postgres/deprecated/createQueryAdapter.ts

@@ -0,0 +1,56 @@
+import { getAddress } from "viem";
+import { PgDatabase } from "drizzle-orm/pg-core";
+import { TableWithRecords, isTableRegistrationLog, logToTable, storeTables } from "@latticexyz/store-sync";
+import { decodeKey, decodeValueArgs } from "@latticexyz/protocol-parser";
+import { QueryAdapter } from "@latticexyz/store-sync/trpc-indexer";
+import { debug } from "../../debug";
+import { getLogs } from "./getLogs";
+import { groupBy } from "@latticexyz/common/utils";
+
+/**
+ * Creates a query adapter for the tRPC server/client to query data from Postgres.
+ *
+ * @param {PgDatabase<any>} database Postgres database object from Drizzle
+ * @returns {Promise<QueryAdapter>} A set of methods used by tRPC endpoints.
+ * @deprecated
+ */
+export async function createQueryAdapter(database: PgDatabase<any>): Promise<QueryAdapter> {
+  const adapter: QueryAdapter = {
+    async getLogs(opts) {
+      return getLogs(database, opts);
+    },
+    async findAll(opts) {
+      const filters = opts.filters ?? [];
+      const { blockNumber, logs } = await getLogs(database, {
+        ...opts,
+        // make sure we're always retrieving `store.Tables` table, so we can decode table values
+        filters: filters.length > 0 ? [...filters, { tableId: storeTables.Tables.tableId }] : [],
+      });
+
+      const tables = logs.filter(isTableRegistrationLog).map(logToTable);
+
+      const logsByTable = groupBy(logs, (log) => `${getAddress(log.address)}:${log.args.tableId}`);
+
+      const tablesWithRecords: TableWithRecords[] = tables.map((table) => {
+        const tableLogs = logsByTable.get(`${getAddress(table.address)}:${table.tableId}`) ?? [];
+        const records = tableLogs.map((log) => ({
+          key: decodeKey(table.keySchema, log.args.keyTuple),
+          value: decodeValueArgs(table.valueSchema, log.args),
+        }));
+
+        return {
+          ...table,
+          records,
+        };
+      });
+
+      debug("findAll: decoded %d logs across %d tables", logs.length, tables.length);
+
+      return {
+        blockNumber,
+        tables: tablesWithRecords,
+      };
+    },
+  };
+  return adapter;
+}

package/src/postgres/deprecated/getLogs.ts

@@ -0,0 +1,81 @@
+import { PgDatabase } from "drizzle-orm/pg-core";
+import { Hex } from "viem";
+import { StorageAdapterLog, SyncFilter } from "@latticexyz/store-sync";
+import { tables } from "@latticexyz/store-sync/postgres";
+import { and, asc, eq, or } from "drizzle-orm";
+import { bigIntMax } from "@latticexyz/common/utils";
+import { recordToLog } from "../recordToLog";
+import { createBenchmark } from "@latticexyz/common";
+
+/**
+ * @deprecated
+ */
+export async function getLogs(
+  database: PgDatabase<any>,
+  {
+    chainId,
+    address,
+    filters = [],
+  }: {
+    readonly chainId: number;
+    readonly address?: Hex;
+    readonly filters?: readonly SyncFilter[];
+  }
+): Promise<{ blockNumber: bigint; logs: (StorageAdapterLog & { eventName: "Store_SetRecord" })[] }> {
+  const benchmark = createBenchmark("drizzleGetLogs");
+
+  const conditions = filters.length
+    ? filters.map((filter) =>
+        and(
+          address != null ? eq(tables.recordsTable.address, address) : undefined,
+          eq(tables.recordsTable.tableId, filter.tableId),
+          filter.key0 != null ? eq(tables.recordsTable.key0, filter.key0) : undefined,
+          filter.key1 != null ? eq(tables.recordsTable.key1, filter.key1) : undefined
+        )
+      )
+    : address != null
+    ? [eq(tables.recordsTable.address, address)]
+    : [];
+  benchmark("parse config");
+
+  // Query for the block number that the indexer (i.e. chain) is at, in case the
+  // indexer is further along in the chain than a given store/table's last updated
+  // block number. We'll then take the highest block number between the indexer's
+  // chain state and all the records in the query (in case the records updated
+  // between these queries). Using just the highest block number from the queries
+  // could potentially signal to the client an older-than-necessary block number,
+  // for stores/tables that haven't seen recent activity.
+  // TODO: move the block number query into the records query for atomicity so we don't have to merge them here
+  const chainState = await database
+    .select()
+    .from(tables.configTable)
+    .where(eq(tables.configTable.chainId, chainId))
+    .limit(1)
+    .execute()
+    // Get the first record in a way that returns a possible `undefined`
+    // TODO: move this to `.findFirst` after upgrading drizzle or `rows[0]` after enabling `noUncheckedIndexedAccess: true`
+    .then((rows) => rows.find(() => true));
+  const indexerBlockNumber = chainState?.blockNumber ?? 0n;
+  benchmark("query chainState");
+
+  const records = await database
+    .select()
+    .from(tables.recordsTable)
+    .where(or(...conditions))
+    .orderBy(
+      asc(tables.recordsTable.blockNumber)
+      // TODO: add logIndex (https://github.com/latticexyz/mud/issues/1979)
+    );
+  benchmark("query records");
+
+  const blockNumber = records.reduce((max, record) => bigIntMax(max, record.blockNumber ?? 0n), indexerBlockNumber);
+  benchmark("find block number");
+
+  const logs = records
+    // TODO: add this to the query, assuming we can optimize with an index
+    .filter((record) => !record.isDeleted)
+    .map(recordToLog);
+  benchmark("map records to logs");
+
+  return { blockNumber, logs };
+}

package/src/postgres/queryLogs.ts

@@ -0,0 +1,72 @@
+import { isNotNull } from "@latticexyz/common/utils";
+import { PendingQuery, Row, Sql } from "postgres";
+import { hexToBytes } from "viem";
+import { z } from "zod";
+import { input } from "@latticexyz/store-sync/indexer-client";
+import { transformSchemaName } from "@latticexyz/store-sync/postgres";
+import { Record } from "./common";
+
+const schemaName = transformSchemaName("mud");
+
+function and(sql: Sql, conditions: PendingQuery<Row[]>[]): PendingQuery<Row[]> {
+  return sql`(${conditions.reduce((query, condition) => sql`${query} AND ${condition}`)})`;
+}
+
+function or(sql: Sql, conditions: PendingQuery<Row[]>[]): PendingQuery<Row[]> {
+  return sql`(${conditions.reduce((query, condition) => sql`${query} OR ${condition}`)})`;
+}
+
+export function queryLogs(sql: Sql, opts: z.infer<typeof input>): PendingQuery<Record[]> {
+  const conditions = opts.filters.length
+    ? opts.filters.map((filter) =>
+        and(
+          sql,
+          [
+            opts.address != null ? sql`address = ${hexToBytes(opts.address)}` : null,
+            sql`table_id = ${hexToBytes(filter.tableId)}`,
+            filter.key0 != null ? sql`key0 = ${hexToBytes(filter.key0)}` : null,
+            filter.key1 != null ? sql`key1 = ${hexToBytes(filter.key1)}` : null,
+          ].filter(isNotNull)
+        )
+      )
+    : opts.address != null
+    ? [sql`address = ${hexToBytes(opts.address)}`]
+    : [];
+
+  const where = sql`WHERE ${and(
+    sql,
+    [sql`is_deleted != true`, conditions.length ? or(sql, conditions) : null].filter(isNotNull)
+  )}`;
+
+  // TODO: implement bytea <> hex columns via custom types: https://github.com/porsager/postgres#custom-types
+  // TODO: sort by logIndex (https://github.com/latticexyz/mud/issues/1979)
+  return sql<Record[]>`
+    WITH
+      config AS (
+        SELECT
+          version AS "indexerVersion",
+          chain_id AS "chainId",
+          block_number AS "chainBlockNumber"
+        FROM ${sql(`${schemaName}.config`)}
+        LIMIT 1
+      ),
+      records AS (
+        SELECT
+          '0x' || encode(address, 'hex') AS address,
+          '0x' || encode(table_id, 'hex') AS "tableId",
+          '0x' || encode(key_bytes, 'hex') AS "keyBytes",
+          '0x' || encode(static_data, 'hex') AS "staticData",
+          '0x' || encode(encoded_lengths, 'hex') AS "encodedLengths",
+          '0x' || encode(dynamic_data, 'hex') AS "dynamicData",
+          block_number AS "recordBlockNumber",
+          log_index AS "logIndex"
+        FROM ${sql(`${schemaName}.records`)}
+        ${where}
+        ORDER BY block_number, log_index ASC
+      )
+    SELECT
+      (SELECT COUNT(*) FROM records) AS "totalRows",
+      *
+    FROM config, records
+  `;
+}

package/src/postgres/recordToLog.ts

@@ -0,0 +1,19 @@
+import { StorageAdapterLog } from "@latticexyz/store-sync";
+import { decodeDynamicField } from "@latticexyz/protocol-parser";
+import { RecordData } from "./common";
+
+export function recordToLog(
+  record: Omit<RecordData, "recordBlockNumber">
+): StorageAdapterLog & { eventName: "Store_SetRecord" } {
+  return {
+    address: record.address,
+    eventName: "Store_SetRecord",
+    args: {
+      tableId: record.tableId,
+      keyTuple: decodeDynamicField("bytes32[]", record.keyBytes),
+      staticData: record.staticData ?? "0x",
+      encodedLengths: record.encodedLengths ?? "0x",
+      dynamicData: record.dynamicData ?? "0x",
+    },
+  } as const;
+}

package/src/sentry.ts

@@ -0,0 +1,105 @@
+import * as Sentry from "@sentry/node";
+import { ProfilingIntegration } from "@sentry/profiling-node";
+import { stripUrlQueryAndFragment } from "@sentry/utils";
+import { debug } from "./debug";
+import Koa from "koa";
+
+Sentry.init({
+  dsn: process.env.SENTRY_DSN,
+  integrations: [
+    // Automatically instrument Node.js libraries and frameworks
+    ...Sentry.autoDiscoverNodePerformanceMonitoringIntegrations(),
+    new ProfilingIntegration(),
+  ],
+  // Performance Monitoring
+  tracesSampleRate: 1.0,
+  // Set sampling rate for profiling - this is relative to tracesSampleRate
+  profilesSampleRate: 1.0,
+});
+
+const requestHandler: Koa.Middleware = (ctx, next) => {
+  return new Promise<void>((resolve, reject) => {
+    Sentry.runWithAsyncContext(async () => {
+      const hub = Sentry.getCurrentHub();
+      hub.configureScope((scope) =>
+        scope.addEventProcessor((event) =>
+          Sentry.addRequestDataToEvent(event, ctx.request, {
+            include: {
+              user: false,
+            },
+          })
+        )
+      );
+
+      try {
+        await next();
+      } catch (err) {
+        reject(err);
+      }
+      resolve();
+    });
+  });
+};
+
+// This tracing middleware creates a transaction per request
+const tracingMiddleWare: Koa.Middleware = async (ctx, next) => {
+  const reqMethod = (ctx.method || "").toUpperCase();
+  const reqUrl = ctx.url && stripUrlQueryAndFragment(ctx.url);
+
+  // Connect to trace of upstream app
+  let traceparentData;
+  if (ctx.request.get("sentry-trace")) {
+    traceparentData = Sentry.extractTraceparentData(ctx.request.get("sentry-trace"));
+  }
+
+  const transaction = Sentry.startTransaction({
+    name: `${reqMethod} ${reqUrl}`,
+    op: "http.server",
+    ...traceparentData,
+  });
+
+  ctx.__sentry_transaction = transaction;
+
+  // We put the transaction on the scope so users can attach children to it
+  Sentry.getCurrentHub().configureScope((scope) => {
+    scope.setSpan(transaction);
+  });
+
+  ctx.res.on("finish", () => {
+    // Push `transaction.finish` to the next event loop so open spans have a chance to finish before the transaction closes
+    setImmediate(() => {
+      // If you're using koa router, set the matched route as transaction name
+      if (ctx._matchedRoute) {
+        const mountPath = ctx.mountPath || "";
+        transaction.setName(`${reqMethod} ${mountPath}${ctx._matchedRoute}`);
+      }
+
+      transaction.setHttpStatus(ctx.status);
+      transaction.finish();
+    });
+  });
+
+  await next();
+};
+
+const errorHandler: Koa.Middleware = async (ctx, next) => {
+  try {
+    await next();
+  } catch (err) {
+    Sentry.withScope((scope) => {
+      scope.addEventProcessor((event) => {
+        return Sentry.addRequestDataToEvent(event, ctx.request);
+      });
+      Sentry.captureException(err);
+    });
+    throw err;
+  }
+};
+
+export const registerSentryMiddlewares = (server: Koa): void => {
+  debug("Registering Sentry middlewares");
+
+  server.use(errorHandler);
+  server.use(requestHandler);
+  server.use(tracingMiddleWare);
+};

package/src/sqlite/apiRoutes.ts

@@ -0,0 +1,47 @@
+import { Middleware } from "koa";
+import Router from "@koa/router";
+import compose from "koa-compose";
+import { input } from "@latticexyz/store-sync/indexer-client";
+import { storeTables, tablesWithRecordsToLogs } from "@latticexyz/store-sync";
+import { debug } from "../debug";
+import { createBenchmark } from "@latticexyz/common";
+import { compress } from "../compress";
+import { getTablesWithRecords } from "./getTablesWithRecords";
+import { BaseSQLiteDatabase } from "drizzle-orm/sqlite-core";
+
+export function apiRoutes(database: BaseSQLiteDatabase<"sync", any>): Middleware {
+  const router = new Router();
+
+  router.get("/api/logs", compress(), async (ctx) => {
+    const benchmark = createBenchmark("sqlite:logs");
+
+    let options: ReturnType<typeof input.parse>;
+
+    try {
+      options = input.parse(typeof ctx.query.input === "string" ? JSON.parse(ctx.query.input) : {});
+    } catch (error) {
+      ctx.status = 400;
+      ctx.body = JSON.stringify(error);
+      debug(error);
+      return;
+    }
+
+    try {
+      options.filters = options.filters.length > 0 ? [...options.filters, { tableId: storeTables.Tables.tableId }] : [];
+      benchmark("parse config");
+      const { blockNumber, tables } = getTablesWithRecords(database, options);
+      benchmark("query tables with records");
+      const logs = tablesWithRecordsToLogs(tables);
+      benchmark("convert records to logs");
+
+      ctx.body = JSON.stringify({ blockNumber: blockNumber?.toString() ?? "-1", logs });
+      ctx.status = 200;
+    } catch (error) {
+      ctx.status = 500;
+      ctx.body = JSON.stringify(error);
+      debug(error);
+    }
+  });
+
+  return compose([router.routes(), router.allowedMethods()]) as Middleware;
+}

package/src/sqlite/createQueryAdapter.ts

@@ -1,10 +1,7 @@
-import { eq } from "drizzle-orm";
 import { BaseSQLiteDatabase } from "drizzle-orm/sqlite-core";
-import { buildTable, chainState, getTables } from "@latticexyz/store-sync/sqlite";
 import { QueryAdapter } from "@latticexyz/store-sync/trpc-indexer";
-import { debug } from "../debug";
-import { getAddress } from "viem";
-import { decodeDynamicField } from "@latticexyz/protocol-parser";
+import { getTablesWithRecords } from "./getTablesWithRecords";
+import { tablesWithRecordsToLogs } from "@latticexyz/store-sync";
 
 /**
  * Creates a storage adapter for the tRPC server/client to query data from SQLite.
@@ -14,48 +11,13 @@ import { decodeDynamicField } from "@latticexyz/protocol-parser";
  */
 export async function createQueryAdapter(database: BaseSQLiteDatabase<"sync", any>): Promise<QueryAdapter> {
   const adapter: QueryAdapter = {
-    async findAll({ chainId, address, filters = [] }) {
-      // If _any_ filter has a table ID, this will filter down all data to just those tables. Which mean we can't yet mix table filters with key-only filters.
-      // TODO: improve this so we can express this in the query (need to be able to query data across tables more easily)
-      const tableIds = Array.from(new Set(filters.map((filter) => filter.tableId)));
-      const tables = getTables(database)
-        .filter((table) => address == null || getAddress(address) === getAddress(table.address))
-        .filter((table) => !tableIds.length || tableIds.includes(table.tableId));
-
-      const tablesWithRecords = tables.map((table) => {
-        const sqliteTable = buildTable(table);
-        const records = database.select().from(sqliteTable).where(eq(sqliteTable.__isDeleted, false)).all();
-        const filteredRecords = !filters.length
-          ? records
-          : records.filter((record) => {
-              const keyTuple = decodeDynamicField("bytes32[]", record.__key);
-              return filters.some(
-                (filter) =>
-                  filter.tableId === table.tableId &&
-                  (filter.key0 == null || filter.key0 === keyTuple[0]) &&
-                  (filter.key1 == null || filter.key1 === keyTuple[1])
-              );
-            });
-        return {
-          ...table,
-          records: filteredRecords.map((record) => ({
-            key: Object.fromEntries(Object.entries(table.keySchema).map(([name]) => [name, record[name]])),
-            value: Object.fromEntries(Object.entries(table.valueSchema).map(([name]) => [name, record[name]])),
-          })),
-        };
-      });
-
-      const metadata = database.select().from(chainState).where(eq(chainState.chainId, chainId)).all();
-      const { lastUpdatedBlockNumber } = metadata[0] ?? {};
-
-      const result = {
-        blockNumber: lastUpdatedBlockNumber ?? null,
-        tables: tablesWithRecords,
-      };
-
-      debug("findAll", chainId, address, result);
-
-      return result;
+    async getLogs(opts) {
+      const { blockNumber, tables } = getTablesWithRecords(database, opts);
+      const logs = tablesWithRecordsToLogs(tables);
+      return { blockNumber: blockNumber ?? 0n, logs };
+    },
+    async findAll(opts) {
+      return getTablesWithRecords(database, opts);
     },
   };
   return adapter;

package/src/sqlite/getTablesWithRecords.ts

@@ -0,0 +1,75 @@
+import { asc, eq } from "drizzle-orm";
+import { BaseSQLiteDatabase } from "drizzle-orm/sqlite-core";
+import { buildTable, chainState, getTables } from "@latticexyz/store-sync/sqlite";
+import { Hex, getAddress } from "viem";
+import { decodeDynamicField } from "@latticexyz/protocol-parser";
+import { SyncFilter, TableWithRecords } from "@latticexyz/store-sync";
+
+// TODO: refactor sqlite and replace this with getLogs to match postgres (https://github.com/latticexyz/mud/issues/1970)
+
+/**
+ * @deprecated
+ * */
+export function getTablesWithRecords(
+  database: BaseSQLiteDatabase<"sync", any>,
+  {
+    chainId,
+    address,
+    filters = [],
+  }: {
+    readonly chainId: number;
+    readonly address?: Hex;
+    readonly filters?: readonly SyncFilter[];
+  }
+): { blockNumber: bigint | null; tables: readonly TableWithRecords[] } {
+  const metadata = database
+    .select()
+    .from(chainState)
+    .where(eq(chainState.chainId, chainId))
+    .limit(1)
+    .all()
+    .find(() => true);
+
+  // If _any_ filter has a table ID, this will filter down all data to just those tables. Which mean we can't yet mix table filters with key-only filters.
+  // TODO: improve this so we can express this in the query (need to be able to query data across tables more easily)
+  const tableIds = Array.from(new Set(filters.map((filter) => filter.tableId)));
+  const tables = getTables(database)
+    .filter((table) => address == null || getAddress(address) === getAddress(table.address))
+    .filter((table) => !tableIds.length || tableIds.includes(table.tableId));
+
+  const tablesWithRecords = tables.map((table) => {
+    const sqliteTable = buildTable(table);
+    const records = database
+      .select()
+      .from(sqliteTable)
+      .where(eq(sqliteTable.__isDeleted, false))
+      .orderBy(
+        asc(sqliteTable.__lastUpdatedBlockNumber)
+        // TODO: add logIndex (https://github.com/latticexyz/mud/issues/1979)
+      )
+      .all();
+    const filteredRecords = !filters.length
+      ? records
+      : records.filter((record) => {
+          const keyTuple = decodeDynamicField("bytes32[]", record.__key);
+          return filters.some(
+            (filter) =>
+              filter.tableId === table.tableId &&
+              (filter.key0 == null || filter.key0 === keyTuple[0]) &&
+              (filter.key1 == null || filter.key1 === keyTuple[1])
+          );
+        });
+    return {
+      ...table,
+      records: filteredRecords.map((record) => ({
+        key: Object.fromEntries(Object.entries(table.keySchema).map(([name]) => [name, record[name]])),
+        value: Object.fromEntries(Object.entries(table.valueSchema).map(([name]) => [name, record[name]])),
+      })),
+    };
+  });
+
+  return {
+    blockNumber: metadata?.lastUpdatedBlockNumber ?? null,
+    tables: tablesWithRecords,
+  };
+}

package/dist/chunk-X3OEYQLT.js

@@ -1,7 +0,0 @@
-import{z as e,ZodError as c}from"zod";var t=e.intersection(e.object({HOST:e.string().default("0.0.0.0"),PORT:e.coerce.number().positive().default(3001),START_BLOCK:e.coerce.bigint().nonnegative().default(0n),MAX_BLOCK_RANGE:e.coerce.bigint().positive().default(1000n),POLLING_INTERVAL:e.coerce.number().positive().default(1e3)}),e.union([e.object({RPC_HTTP_URL:e.string(),RPC_WS_URL:e.string().optional()}),e.object({RPC_HTTP_URL:e.string().optional(),RPC_WS_URL:e.string()})]));function f(o){let r=o!==void 0?e.intersection(t,o):t;try{return r.parse(process.env)}catch(n){if(n instanceof c){let{_errors:a,...i}=n.format();console.error(`
-Missing or invalid environment variables:
-
-  ${Object.keys(i).join(`
-  `)}
-`),process.exit(1)}throw n}}import s from"debug";var _=s("mud:store-indexer");export{_ as a,f as b};
-//# sourceMappingURL=chunk-X3OEYQLT.js.map

package/dist/chunk-X3OEYQLT.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../bin/parseEnv.ts","../src/debug.ts"],"sourcesContent":["import { z, ZodError, ZodIntersection, ZodTypeAny } from \"zod\";\n\nconst commonSchema = z.intersection(\n  z.object({\n    HOST: z.string().default(\"0.0.0.0\"),\n    PORT: z.coerce.number().positive().default(3001),\n    START_BLOCK: z.coerce.bigint().nonnegative().default(0n),\n    MAX_BLOCK_RANGE: z.coerce.bigint().positive().default(1000n),\n    POLLING_INTERVAL: z.coerce.number().positive().default(1000),\n  }),\n  z.union([\n    z.object({\n      RPC_HTTP_URL: z.string(),\n      RPC_WS_URL: z.string().optional(),\n    }),\n    z.object({\n      RPC_HTTP_URL: z.string().optional(),\n      RPC_WS_URL: z.string(),\n    }),\n  ])\n);\n\nexport function parseEnv<TSchema extends ZodTypeAny | undefined = undefined>(\n  schema?: TSchema\n): z.infer<TSchema extends ZodTypeAny ? ZodIntersection<typeof commonSchema, TSchema> : typeof commonSchema> {\n  const envSchema = schema !== undefined ? z.intersection(commonSchema, schema) : commonSchema;\n  try {\n    return envSchema.parse(process.env);\n  } catch (error) {\n    if (error instanceof ZodError) {\n      const { _errors, ...invalidEnvVars } = error.format();\n      console.error(`\\nMissing or invalid environment variables:\\n\\n  ${Object.keys(invalidEnvVars).join(\"\\n  \")}\\n`);\n      process.exit(1);\n    }\n    throw error;\n  }\n}\n","import createDebug from \"debug\";\n\nexport const debug = createDebug(\"mud:store-indexer\");\n"],"mappings":"AAAA,OAAS,KAAAA,EAAG,YAAAC,MAA6C,MAEzD,IAAMC,EAAeF,EAAE,aACrBA,EAAE,OAAO,CACP,KAAMA,EAAE,OAAO,EAAE,QAAQ,SAAS,EAClC,KAAMA,EAAE,OAAO,OAAO,EAAE,SAAS,EAAE,QAAQ,IAAI,EAC/C,YAAaA,EAAE,OAAO,OAAO,EAAE,YAAY,EAAE,QAAQ,EAAE,EACvD,gBAAiBA,EAAE,OAAO,OAAO,EAAE,SAAS,EAAE,QAAQ,KAAK,EAC3D,iBAAkBA,EAAE,OAAO,OAAO,EAAE,SAAS,EAAE,QAAQ,GAAI,CAC7D,CAAC,EACDA,EAAE,MAAM,CACNA,EAAE,OAAO,CACP,aAAcA,EAAE,OAAO,EACvB,WAAYA,EAAE,OAAO,EAAE,SAAS,CAClC,CAAC,EACDA,EAAE,OAAO,CACP,aAAcA,EAAE,OAAO,EAAE,SAAS,EAClC,WAAYA,EAAE,OAAO,CACvB,CAAC,CACH,CAAC,CACH,EAEO,SAASG,EACdC,EAC2G,CAC3G,IAAMC,EAAYD,IAAW,OAAYJ,EAAE,aAAaE,EAAcE,CAAM,EAAIF,EAChF,GAAI,CACF,OAAOG,EAAU,MAAM,QAAQ,GAAG,CACpC,OAASC,EAAP,CACA,GAAIA,aAAiBL,EAAU,CAC7B,GAAM,CAAE,QAAAM,EAAS,GAAGC,CAAe,EAAIF,EAAM,OAAO,EACpD,QAAQ,MAAM;AAAA;AAAA;AAAA,IAAoD,OAAO,KAAKE,CAAc,EAAE,KAAK;AAAA,GAAM;AAAA,CAAK,EAC9G,QAAQ,KAAK,CAAC,EAEhB,MAAMF,CACR,CACF,CCpCA,OAAOG,MAAiB,QAEjB,IAAMC,EAAQD,EAAY,mBAAmB","names":["z","ZodError","commonSchema","parseEnv","schema","envSchema","error","_errors","invalidEnvVars","createDebug","debug"]}