@apibara/indexer 2.0.0-beta.0 → 2.0.0-beta.4

package/dist/shared/indexer.50aa7ab0.mjs

@@ -1,268 +0,0 @@
-import fs$1 from 'node:fs/promises';
-import path from 'node:path';
-import { createHooks, createDebugger } from 'hookable';
-import { klona } from 'klona/full';
-import assert from 'node:assert';
-import fs from 'node:fs';
-import { MockClient } from '@apibara/protocol/testing';
-import consola from 'consola';
-import { AsyncLocalStorage } from 'node:async_hooks';
-import { getContext } from 'unctx';
-import { trace } from '@opentelemetry/api';
-import { d as defaultSink, S as Sink } from './indexer.371c0482.mjs';
-
-const indexerAsyncContext = getContext("indexer", {
-  asyncContext: true,
-  AsyncLocalStorage
-});
-function useIndexerContext() {
-  return indexerAsyncContext.use();
-}
-
-const tracer = trace.getTracer("@apibara/indexer");
-
-function defineIndexer(streamConfig) {
-  return (config) => ({
-    streamConfig,
-    ...config
-  });
-}
-function createIndexer({
-  streamConfig,
-  ...options
-}) {
-  const indexer = {
-    options,
-    streamConfig,
-    hooks: createHooks()
-  };
-  if (indexer.options.debug) {
-    createDebugger(indexer.hooks, { tag: "indexer" });
-  }
-  indexer.hooks.addHooks(indexer.options.hooks ?? {});
-  for (const plugin of indexer.options.plugins ?? []) {
-    plugin(indexer);
-  }
-  return indexer;
-}
-async function run(client, indexer, sinkArg) {
-  await indexerAsyncContext.callAsync({}, async () => {
-    await indexer.hooks.callHook("run:before");
-    const sink = sinkArg ?? defaultSink();
-    sink.hook("write", async ({ data }) => {
-      await indexer.hooks.callHook("sink:write", { data });
-    });
-    sink.hook("flush", async ({ endCursor, finality }) => {
-      await indexer.hooks.callHook("sink:flush", { endCursor, finality });
-    });
-    const isFactoryMode = indexer.options.factory !== void 0;
-    const request = indexer.streamConfig.Request.make({
-      filter: isFactoryMode ? [indexer.options.filter, {}] : [indexer.options.filter],
-      finality: indexer.options.finality,
-      startingCursor: indexer.options.startingCursor
-    });
-    const options = {};
-    await indexer.hooks.callHook("connect:before", { request, options });
-    let mainFilter;
-    if (isFactoryMode) {
-      mainFilter = request.filter[1];
-    }
-    let stream = client.streamData(request, options);
-    await indexer.hooks.callHook("connect:after");
-    let state = {
-      _tag: "normal"
-    };
-    while (true) {
-      for await (const message of stream) {
-        await indexer.hooks.callHook("message", { message });
-        switch (message._tag) {
-          case "data": {
-            await tracer.startActiveSpan("message data", async (span) => {
-              const blocks = message.data.data;
-              const { cursor, endCursor, finality } = message.data;
-              let block;
-              const output = [];
-              if (isFactoryMode) {
-                assert(indexer.options.factory !== void 0);
-                const [factoryBlock, mainBlock] = blocks;
-                block = mainBlock;
-                if (state._tag === "normal" && factoryBlock !== null) {
-                  const { data, filter } = await indexer.options.factory(factoryBlock);
-                  if (!filter) {
-                    output.push(...data ?? []);
-                  } else {
-                    mainFilter = indexer.streamConfig.mergeFilter(
-                      mainFilter,
-                      filter
-                    );
-                    const request2 = indexer.streamConfig.Request.make({
-                      filter: [indexer.options.filter, mainFilter],
-                      finality: indexer.options.finality,
-                      startingCursor: cursor
-                    });
-                    await indexer.hooks.callHook("connect:factory", {
-                      request: request2,
-                      endCursor
-                    });
-                    stream = client.streamData(request2, options);
-                    state = {
-                      _tag: "recover",
-                      data
-                    };
-                    return;
-                  }
-                } else if (state._tag === "recover") {
-                  output.push(...state.data ?? []);
-                  state = { _tag: "normal" };
-                }
-              } else {
-                block = blocks[0];
-              }
-              if (block) {
-                await tracer.startActiveSpan("handler", async (span2) => {
-                  await indexer.hooks.callHook("handler:before", {
-                    block,
-                    endCursor,
-                    finality
-                  });
-                  try {
-                    const transformOutput = await indexer.options.transform({
-                      block,
-                      cursor,
-                      endCursor,
-                      finality
-                    });
-                    output.push(...transformOutput);
-                    await indexer.hooks.callHook("handler:after", { output });
-                  } catch (error) {
-                    assert(error instanceof Error);
-                    await indexer.hooks.callHook("handler:exception", {
-                      error
-                    });
-                    throw error;
-                  }
-                  span2.end();
-                });
-              }
-              if (output.length > 0) {
-                await tracer.startActiveSpan("sink write", async (span2) => {
-                  await sink.write({
-                    data: output,
-                    cursor,
-                    endCursor,
-                    finality
-                  });
-                  span2.end();
-                });
-              }
-              span.end();
-            });
-            break;
-          }
-          default: {
-            consola.warn("unexpected message", message);
-            throw new Error("not implemented");
-          }
-        }
-        if (state._tag !== "normal") {
-          break;
-        }
-      }
-      if (state._tag !== "normal") {
-        continue;
-      }
-      await indexer.hooks.callHook("run:after");
-      break;
-    }
-  });
-}
-
-function deserialize(str) {
-  return JSON.parse(
-    str,
-    (_, value) => typeof value === "string" && value.match(/^\d+n$/) ? BigInt(value.slice(0, -1)) : value
-  );
-}
-function serialize(obj) {
-  return JSON.stringify(
-    obj,
-    (_, value) => typeof value === "bigint" ? `${value.toString()}n` : value,
-    "	"
-  );
-}
-function isCassetteAvailable(vcrConfig, cassetteName) {
-  const filePath = path.join(vcrConfig.cassetteDir, `${cassetteName}.json`);
-  return fs.existsSync(filePath);
-}
-
-async function record(vcrConfig, client, indexerArg, cassetteOptions) {
-  const indexer = klona(indexerArg);
-  const messages = [];
-  indexer.hooks.addHooks({
-    "connect:before"({ options, request }) {
-      request.startingCursor = cassetteOptions.startingCursor;
-      options.endingCursor = cassetteOptions.endingCursor;
-    },
-    message({ message }) {
-      messages.push(message);
-    },
-    async "run:after"() {
-      const output = {
-        filter: indexer.options.filter,
-        messages
-      };
-      const filePath = path.join(
-        vcrConfig.cassetteDir,
-        `${cassetteOptions.name}.json`
-      );
-      await fs$1.writeFile(filePath, serialize(output), { flag: "w" });
-    }
-  });
-  await run(client, indexer);
-}
-
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => {
-  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-  return value;
-};
-class VcrSink extends Sink {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "result", []);
-  }
-  async write({ data, endCursor, finality }) {
-    await this.callHook("write", { data });
-    this.result.push({ data, endCursor });
-    await this.callHook("flush", { endCursor, finality });
-  }
-}
-function vcr() {
-  return new VcrSink();
-}
-
-async function replay(vcrConfig, indexer, cassetteName) {
-  const client = loadCassette(vcrConfig, cassetteName);
-  const sink = vcr();
-  await run(client, indexer, sink);
-  return {
-    outputs: sink.result
-  };
-}
-function loadCassette(vcrConfig, cassetteName) {
-  const filePath = path.join(vcrConfig.cassetteDir, `${cassetteName}.json`);
-  const data = fs.readFileSync(filePath, "utf8");
-  const cassetteData = deserialize(data);
-  const { filter, messages } = cassetteData;
-  return new MockClient((request, options) => {
-    assert.deepStrictEqual(
-      request.filter,
-      filter,
-      "Request and Cassette filter mismatch"
-    );
-    return messages;
-  });
-}
-
-export { VcrSink as V, deserialize as a, record as b, createIndexer as c, defineIndexer as d, replay as e, isCassetteAvailable as i, loadCassette as l, run as r, serialize as s, useIndexerContext as u, vcr as v };

package/dist/shared/indexer.7c118fb5.d.cts

@@ -1,28 +0,0 @@
-import { Cursor, DataFinality } from '@apibara/protocol';
-import { Hookable } from 'hookable';
-
-type SinkData = Record<string, unknown>;
-interface SinkEvents {
-    write({ data }: {
-        data: SinkData[];
-    }): void;
-    flush({ endCursor, finality, }: {
-        endCursor?: Cursor;
-        finality: DataFinality;
-    }): void;
-}
-type SinkWriteArgs = {
-    data: SinkData[];
-    cursor?: Cursor | undefined;
-    endCursor?: Cursor | undefined;
-    finality: DataFinality;
-};
-declare abstract class Sink extends Hookable<SinkEvents> {
-    abstract write({ data, cursor, endCursor, finality, }: SinkWriteArgs): Promise<void>;
-}
-declare class DefaultSink extends Sink {
-    write({ data, endCursor, finality }: SinkWriteArgs): Promise<void>;
-}
-declare function defaultSink(): DefaultSink;
-
-export { DefaultSink as D, type SinkData as S, type SinkEvents as a, type SinkWriteArgs as b, Sink as c, defaultSink as d };

package/dist/shared/indexer.7c118fb5.d.mts

@@ -1,28 +0,0 @@
-import { Cursor, DataFinality } from '@apibara/protocol';
-import { Hookable } from 'hookable';
-
-type SinkData = Record<string, unknown>;
-interface SinkEvents {
-    write({ data }: {
-        data: SinkData[];
-    }): void;
-    flush({ endCursor, finality, }: {
-        endCursor?: Cursor;
-        finality: DataFinality;
-    }): void;
-}
-type SinkWriteArgs = {
-    data: SinkData[];
-    cursor?: Cursor | undefined;
-    endCursor?: Cursor | undefined;
-    finality: DataFinality;
-};
-declare abstract class Sink extends Hookable<SinkEvents> {
-    abstract write({ data, cursor, endCursor, finality, }: SinkWriteArgs): Promise<void>;
-}
-declare class DefaultSink extends Sink {
-    write({ data, endCursor, finality }: SinkWriteArgs): Promise<void>;
-}
-declare function defaultSink(): DefaultSink;
-
-export { DefaultSink as D, type SinkData as S, type SinkEvents as a, type SinkWriteArgs as b, Sink as c, defaultSink as d };

package/dist/shared/indexer.7c118fb5.d.ts

@@ -1,28 +0,0 @@
-import { Cursor, DataFinality } from '@apibara/protocol';
-import { Hookable } from 'hookable';
-
-type SinkData = Record<string, unknown>;
-interface SinkEvents {
-    write({ data }: {
-        data: SinkData[];
-    }): void;
-    flush({ endCursor, finality, }: {
-        endCursor?: Cursor;
-        finality: DataFinality;
-    }): void;
-}
-type SinkWriteArgs = {
-    data: SinkData[];
-    cursor?: Cursor | undefined;
-    endCursor?: Cursor | undefined;
-    finality: DataFinality;
-};
-declare abstract class Sink extends Hookable<SinkEvents> {
-    abstract write({ data, cursor, endCursor, finality, }: SinkWriteArgs): Promise<void>;
-}
-declare class DefaultSink extends Sink {
-    write({ data, endCursor, finality }: SinkWriteArgs): Promise<void>;
-}
-declare function defaultSink(): DefaultSink;
-
-export { DefaultSink as D, type SinkData as S, type SinkEvents as a, type SinkWriteArgs as b, Sink as c, defaultSink as d };

package/dist/shared/indexer.a27bcb35.d.cts

@@ -1,91 +0,0 @@
-import { StreamDataRequest, StreamDataOptions, Cursor, DataFinality, StreamDataResponse, StreamConfig, Client } from '@apibara/protocol';
-import { NestedHooks, Hookable } from 'hookable';
-import { c as Sink, S as SinkData } from './indexer.7c118fb5.cjs';
-
-type IndexerPlugin<TFilter, TBlock, TRet> = (indexer: Indexer<TFilter, TBlock, TRet>) => void;
-declare function defineIndexerPlugin<TFilter, TBlock, TRet>(def: IndexerPlugin<TFilter, TBlock, TRet>): IndexerPlugin<TFilter, TBlock, TRet>;
-
-interface IndexerHooks<TFilter, TBlock, TRet> {
-    "run:before": () => void;
-    "run:after": () => void;
-    "connect:before": ({ request, options, }: {
-        request: StreamDataRequest<TFilter>;
-        options: StreamDataOptions;
-    }) => void;
-    "connect:after": () => void;
-    "connect:factory": ({ request, endCursor, }: {
-        request: StreamDataRequest<TFilter>;
-        endCursor?: Cursor;
-    }) => void;
-    "handler:before": ({ block, finality, endCursor, }: {
-        block: TBlock;
-        finality: DataFinality;
-        endCursor?: Cursor;
-    }) => void;
-    "handler:after": ({ output }: {
-        output: TRet[];
-    }) => void;
-    "handler:exception": ({ error }: {
-        error: Error;
-    }) => void;
-    "sink:write": ({ data }: {
-        data: TRet[];
-    }) => void;
-    "sink:flush": ({ endCursor, finality, }: {
-        endCursor?: Cursor;
-        finality: DataFinality;
-    }) => void;
-    message: ({ message }: {
-        message: StreamDataResponse<TBlock>;
-    }) => void;
-}
-interface IndexerConfig<TFilter, TBlock, TRet> {
-    streamUrl: string;
-    filter: TFilter;
-    finality?: DataFinality;
-    startingCursor?: Cursor;
-    factory?: (block: TBlock) => Promise<{
-        filter?: TFilter;
-        data?: TRet[];
-    }>;
-    transform: (args: {
-        block: TBlock;
-        cursor?: Cursor | undefined;
-        endCursor?: Cursor | undefined;
-        finality: DataFinality;
-    }) => Promise<TRet[]>;
-    hooks?: NestedHooks<IndexerHooks<TFilter, TBlock, TRet>>;
-    plugins?: ReadonlyArray<IndexerPlugin<TFilter, TBlock, TRet>>;
-    debug?: boolean;
-}
-interface IndexerWithStreamConfig<TFilter, TBlock, TRet> extends IndexerConfig<TFilter, TBlock, TRet> {
-    streamConfig: StreamConfig<TFilter, TBlock>;
-}
-declare function defineIndexer<TFilter, TBlock>(streamConfig: StreamConfig<TFilter, TBlock>): <TRet>(config: IndexerConfig<TFilter, TBlock, TRet>) => IndexerWithStreamConfig<TFilter, TBlock, TRet>;
-interface Indexer<TFilter, TBlock, TRet> {
-    streamConfig: StreamConfig<TFilter, TBlock>;
-    options: IndexerConfig<TFilter, TBlock, TRet>;
-    hooks: Hookable<IndexerHooks<TFilter, TBlock, TRet>>;
-}
-declare function createIndexer<TFilter, TBlock, TRet>({ streamConfig, ...options }: IndexerWithStreamConfig<TFilter, TBlock, TRet>): Indexer<TFilter, TBlock, TRet>;
-declare function run<TFilter, TBlock, TRet>(client: Client<TFilter, TBlock>, indexer: Indexer<TFilter, TBlock, TRet>, sinkArg?: Sink): Promise<void>;
-
-type VcrConfig = {
-    cassetteDir: string;
-};
-type CassetteOptions = {
-    name: string;
-    startingCursor: Cursor;
-    endingCursor: Cursor;
-};
-
-declare function replay<TFilter, TBlock, TRet>(vcrConfig: VcrConfig, indexer: Indexer<TFilter, TBlock, TRet>, cassetteName: string): Promise<VcrReplayResult>;
-type VcrReplayResult = {
-    outputs: Array<{
-        endCursor?: Cursor;
-        data: SinkData[];
-    }>;
-};
-declare function loadCassette<TFilter, TBlock>(vcrConfig: VcrConfig, cassetteName: string): Client<TFilter, TBlock>;
-
-export { type CassetteOptions as C, type Indexer as I, type VcrConfig as V, type IndexerHooks as a, type IndexerConfig as b, type IndexerWithStreamConfig as c, defineIndexer as d, createIndexer as e, type IndexerPlugin as f, defineIndexerPlugin as g, replay as h, type VcrReplayResult as i, loadCassette as l, run as r };