@apibara/indexer 2.0.0-beta.9 → 2.1.0-beta.2

package/dist/shared/indexer.2416906c.cjs

@@ -0,0 +1,29 @@
+'use strict';
+
+const consola = require('consola');
+const context = require('./indexer.077335f3.cjs');
+const config = require('./indexer.601ceab0.cjs');
+
+function logger({
+  logger: logger2
+} = {}) {
+  return config.defineIndexerPlugin((indexer) => {
+    indexer.hooks.hook("run:before", () => {
+      const ctx = context.useIndexerContext();
+      if (logger2) {
+        ctx.logger = consola.consola.create({ reporters: [logger2] });
+      } else {
+        ctx.logger = consola.consola.create({});
+      }
+    });
+  });
+}
+function useLogger() {
+  const ctx = context.useIndexerContext();
+  if (!ctx?.logger)
+    throw new Error("Logger plugin is not available in context");
+  return ctx.logger;
+}
+
+exports.logger = logger;
+exports.useLogger = useLogger;

package/dist/shared/indexer.601ceab0.cjs

@@ -0,0 +1,7 @@
+'use strict';
+
+function defineIndexerPlugin(def) {
+  return def;
+}
+
+exports.defineIndexerPlugin = defineIndexerPlugin;

package/dist/shared/indexer.9b21ddd2.mjs

@@ -0,0 +1,5 @@
+function defineIndexerPlugin(def) {
+  return def;
+}
+
+export { defineIndexerPlugin as d };

package/dist/shared/indexer.a55ad619.mjs

@@ -0,0 +1,12 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { getContext } from 'unctx';
+
+const indexerAsyncContext = getContext("indexer", {
+  asyncContext: true,
+  AsyncLocalStorage
+});
+function useIndexerContext() {
+  return indexerAsyncContext.use();
+}
+
+export { indexerAsyncContext as i, useIndexerContext as u };

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

@@ -0,0 +1,100 @@
+import { StreamDataRequest, StreamDataOptions, Cursor, StreamDataResponse, Invalidate, Finalize, Heartbeat, SystemMessage, DataFinality, StreamConfig, Client } from '@apibara/protocol';
+import { NestedHooks, Hookable } from 'hookable';
+
+interface IndexerContext extends Record<string, any> {
+}
+declare function useIndexerContext(): IndexerContext;
+
+type NextFunction = () => Promise<void>;
+type MiddlewareFunction<C> = (context: C, next: NextFunction) => Promise<void>;
+
+type IndexerPlugin<TFilter, TBlock> = (indexer: Indexer<TFilter, TBlock>) => void;
+declare function defineIndexerPlugin<TFilter, TBlock>(def: IndexerPlugin<TFilter, TBlock>): IndexerPlugin<TFilter, TBlock>;
+
+type UseMiddlewareFunction = (fn: MiddlewareFunction<IndexerContext>) => void;
+interface IndexerHooks<TFilter, TBlock> {
+    "run:before": () => void;
+    "run:after": () => void;
+    "connect:before": ({ request, options, }: {
+        request: StreamDataRequest<TFilter>;
+        options: StreamDataOptions;
+    }) => void;
+    "connect:after": ({ request, }: {
+        request: StreamDataRequest<TFilter>;
+    }) => void;
+    "connect:factory": ({ request, endCursor, }: {
+        request: StreamDataRequest<TFilter>;
+        endCursor?: Cursor;
+    }) => void;
+    "handler:middleware": ({ use }: {
+        use: UseMiddlewareFunction;
+    }) => void;
+    message: ({ message }: {
+        message: StreamDataResponse<TBlock>;
+    }) => void;
+    "message:invalidate": ({ message }: {
+        message: Invalidate;
+    }) => void;
+    "message:finalize": ({ message }: {
+        message: Finalize;
+    }) => void;
+    "message:heartbeat": ({ message }: {
+        message: Heartbeat;
+    }) => void;
+    "message:systemMessage": ({ message }: {
+        message: SystemMessage;
+    }) => void;
+}
+type IndexerStartingCursor = {
+    startingCursor?: never;
+    startingBlock: bigint;
+} | {
+    startingCursor: Cursor;
+    startingBlock?: never;
+} | {
+    startingCursor?: never;
+    startingBlock?: never;
+};
+type IndexerConfig<TFilter, TBlock> = {
+    streamUrl: string;
+    filter: TFilter;
+    finality?: DataFinality;
+    factory?: ({ block, context, }: {
+        block: TBlock;
+        context: IndexerContext;
+    }) => Promise<{
+        filter?: TFilter;
+    }>;
+    transform: (args: {
+        block: TBlock;
+        cursor?: Cursor | undefined;
+        endCursor?: Cursor | undefined;
+        finality: DataFinality;
+        context: IndexerContext;
+    }) => Promise<void>;
+    hooks?: NestedHooks<IndexerHooks<TFilter, TBlock>>;
+    plugins?: ReadonlyArray<IndexerPlugin<TFilter, TBlock>>;
+    debug?: boolean;
+} & IndexerStartingCursor;
+type IndexerWithStreamConfig<TFilter, TBlock> = IndexerConfig<TFilter, TBlock> & {
+    streamConfig: StreamConfig<TFilter, TBlock>;
+};
+declare function defineIndexer<TFilter, TBlock>(streamConfig: StreamConfig<TFilter, TBlock>): (config: IndexerConfig<TFilter, TBlock>) => IndexerWithStreamConfig<TFilter, TBlock>;
+interface Indexer<TFilter, TBlock> {
+    streamConfig: StreamConfig<TFilter, TBlock>;
+    options: IndexerConfig<TFilter, TBlock>;
+    hooks: Hookable<IndexerHooks<TFilter, TBlock>>;
+}
+declare function createIndexer<TFilter, TBlock>({ streamConfig, ...options }: IndexerWithStreamConfig<TFilter, TBlock>): Indexer<TFilter, TBlock>;
+interface ReconnectOptions {
+    maxRetries?: number;
+    retryDelay?: number;
+    maxWait?: number;
+}
+declare function runWithReconnect<TFilter, TBlock>(client: Client<TFilter, TBlock>, indexer: Indexer<TFilter, TBlock>, options?: ReconnectOptions): Promise<void>;
+interface RunOptions {
+    onConnect?: () => void | Promise<void>;
+}
+declare function run<TFilter, TBlock>(client: Client<TFilter, TBlock>, indexer: Indexer<TFilter, TBlock>, runOptions?: RunOptions): Promise<void>;
+
+export { type IndexerWithStreamConfig as I, type ReconnectOptions as R, type UseMiddlewareFunction as U, type Indexer as a, type IndexerPlugin as b, type IndexerConfig as c, defineIndexerPlugin as d, type IndexerHooks as e, type IndexerStartingCursor as f, defineIndexer as g, createIndexer as h, type RunOptions as i, run as j, runWithReconnect as r, useIndexerContext as u };

package/dist/shared/indexer.fedcd831.d.mts

@@ -0,0 +1,100 @@
+import { StreamDataRequest, StreamDataOptions, Cursor, StreamDataResponse, Invalidate, Finalize, Heartbeat, SystemMessage, DataFinality, StreamConfig, Client } from '@apibara/protocol';
+import { NestedHooks, Hookable } from 'hookable';
+
+interface IndexerContext extends Record<string, any> {
+}
+declare function useIndexerContext(): IndexerContext;
+
+type NextFunction = () => Promise<void>;
+type MiddlewareFunction<C> = (context: C, next: NextFunction) => Promise<void>;
+
+type IndexerPlugin<TFilter, TBlock> = (indexer: Indexer<TFilter, TBlock>) => void;
+declare function defineIndexerPlugin<TFilter, TBlock>(def: IndexerPlugin<TFilter, TBlock>): IndexerPlugin<TFilter, TBlock>;
+
+type UseMiddlewareFunction = (fn: MiddlewareFunction<IndexerContext>) => void;
+interface IndexerHooks<TFilter, TBlock> {
+    "run:before": () => void;
+    "run:after": () => void;
+    "connect:before": ({ request, options, }: {
+        request: StreamDataRequest<TFilter>;
+        options: StreamDataOptions;
+    }) => void;
+    "connect:after": ({ request, }: {
+        request: StreamDataRequest<TFilter>;
+    }) => void;
+    "connect:factory": ({ request, endCursor, }: {
+        request: StreamDataRequest<TFilter>;
+        endCursor?: Cursor;
+    }) => void;
+    "handler:middleware": ({ use }: {
+        use: UseMiddlewareFunction;
+    }) => void;
+    message: ({ message }: {
+        message: StreamDataResponse<TBlock>;
+    }) => void;
+    "message:invalidate": ({ message }: {
+        message: Invalidate;
+    }) => void;
+    "message:finalize": ({ message }: {
+        message: Finalize;
+    }) => void;
+    "message:heartbeat": ({ message }: {
+        message: Heartbeat;
+    }) => void;
+    "message:systemMessage": ({ message }: {
+        message: SystemMessage;
+    }) => void;
+}
+type IndexerStartingCursor = {
+    startingCursor?: never;
+    startingBlock: bigint;
+} | {
+    startingCursor: Cursor;
+    startingBlock?: never;
+} | {
+    startingCursor?: never;
+    startingBlock?: never;
+};
+type IndexerConfig<TFilter, TBlock> = {
+    streamUrl: string;
+    filter: TFilter;
+    finality?: DataFinality;
+    factory?: ({ block, context, }: {
+        block: TBlock;
+        context: IndexerContext;
+    }) => Promise<{
+        filter?: TFilter;
+    }>;
+    transform: (args: {
+        block: TBlock;
+        cursor?: Cursor | undefined;
+        endCursor?: Cursor | undefined;
+        finality: DataFinality;
+        context: IndexerContext;
+    }) => Promise<void>;
+    hooks?: NestedHooks<IndexerHooks<TFilter, TBlock>>;
+    plugins?: ReadonlyArray<IndexerPlugin<TFilter, TBlock>>;
+    debug?: boolean;
+} & IndexerStartingCursor;
+type IndexerWithStreamConfig<TFilter, TBlock> = IndexerConfig<TFilter, TBlock> & {
+    streamConfig: StreamConfig<TFilter, TBlock>;
+};
+declare function defineIndexer<TFilter, TBlock>(streamConfig: StreamConfig<TFilter, TBlock>): (config: IndexerConfig<TFilter, TBlock>) => IndexerWithStreamConfig<TFilter, TBlock>;
+interface Indexer<TFilter, TBlock> {
+    streamConfig: StreamConfig<TFilter, TBlock>;
+    options: IndexerConfig<TFilter, TBlock>;
+    hooks: Hookable<IndexerHooks<TFilter, TBlock>>;
+}
+declare function createIndexer<TFilter, TBlock>({ streamConfig, ...options }: IndexerWithStreamConfig<TFilter, TBlock>): Indexer<TFilter, TBlock>;
+interface ReconnectOptions {
+    maxRetries?: number;
+    retryDelay?: number;
+    maxWait?: number;
+}
+declare function runWithReconnect<TFilter, TBlock>(client: Client<TFilter, TBlock>, indexer: Indexer<TFilter, TBlock>, options?: ReconnectOptions): Promise<void>;
+interface RunOptions {
+    onConnect?: () => void | Promise<void>;
+}
+declare function run<TFilter, TBlock>(client: Client<TFilter, TBlock>, indexer: Indexer<TFilter, TBlock>, runOptions?: RunOptions): Promise<void>;
+
+export { type IndexerWithStreamConfig as I, type ReconnectOptions as R, type UseMiddlewareFunction as U, type Indexer as a, type IndexerPlugin as b, type IndexerConfig as c, defineIndexerPlugin as d, type IndexerHooks as e, type IndexerStartingCursor as f, defineIndexer as g, createIndexer as h, type RunOptions as i, run as j, runWithReconnect as r, useIndexerContext as u };

package/dist/shared/indexer.fedcd831.d.ts

@@ -0,0 +1,100 @@
+import { StreamDataRequest, StreamDataOptions, Cursor, StreamDataResponse, Invalidate, Finalize, Heartbeat, SystemMessage, DataFinality, StreamConfig, Client } from '@apibara/protocol';
+import { NestedHooks, Hookable } from 'hookable';
+
+interface IndexerContext extends Record<string, any> {
+}
+declare function useIndexerContext(): IndexerContext;
+
+type NextFunction = () => Promise<void>;
+type MiddlewareFunction<C> = (context: C, next: NextFunction) => Promise<void>;
+
+type IndexerPlugin<TFilter, TBlock> = (indexer: Indexer<TFilter, TBlock>) => void;
+declare function defineIndexerPlugin<TFilter, TBlock>(def: IndexerPlugin<TFilter, TBlock>): IndexerPlugin<TFilter, TBlock>;
+
+type UseMiddlewareFunction = (fn: MiddlewareFunction<IndexerContext>) => void;
+interface IndexerHooks<TFilter, TBlock> {
+    "run:before": () => void;
+    "run:after": () => void;
+    "connect:before": ({ request, options, }: {
+        request: StreamDataRequest<TFilter>;
+        options: StreamDataOptions;
+    }) => void;
+    "connect:after": ({ request, }: {
+        request: StreamDataRequest<TFilter>;
+    }) => void;
+    "connect:factory": ({ request, endCursor, }: {
+        request: StreamDataRequest<TFilter>;
+        endCursor?: Cursor;
+    }) => void;
+    "handler:middleware": ({ use }: {
+        use: UseMiddlewareFunction;
+    }) => void;
+    message: ({ message }: {
+        message: StreamDataResponse<TBlock>;
+    }) => void;
+    "message:invalidate": ({ message }: {
+        message: Invalidate;
+    }) => void;
+    "message:finalize": ({ message }: {
+        message: Finalize;
+    }) => void;
+    "message:heartbeat": ({ message }: {
+        message: Heartbeat;
+    }) => void;
+    "message:systemMessage": ({ message }: {
+        message: SystemMessage;
+    }) => void;
+}
+type IndexerStartingCursor = {
+    startingCursor?: never;
+    startingBlock: bigint;
+} | {
+    startingCursor: Cursor;
+    startingBlock?: never;
+} | {
+    startingCursor?: never;
+    startingBlock?: never;
+};
+type IndexerConfig<TFilter, TBlock> = {
+    streamUrl: string;
+    filter: TFilter;
+    finality?: DataFinality;
+    factory?: ({ block, context, }: {
+        block: TBlock;
+        context: IndexerContext;
+    }) => Promise<{
+        filter?: TFilter;
+    }>;
+    transform: (args: {
+        block: TBlock;
+        cursor?: Cursor | undefined;
+        endCursor?: Cursor | undefined;
+        finality: DataFinality;
+        context: IndexerContext;
+    }) => Promise<void>;
+    hooks?: NestedHooks<IndexerHooks<TFilter, TBlock>>;
+    plugins?: ReadonlyArray<IndexerPlugin<TFilter, TBlock>>;
+    debug?: boolean;
+} & IndexerStartingCursor;
+type IndexerWithStreamConfig<TFilter, TBlock> = IndexerConfig<TFilter, TBlock> & {
+    streamConfig: StreamConfig<TFilter, TBlock>;
+};
+declare function defineIndexer<TFilter, TBlock>(streamConfig: StreamConfig<TFilter, TBlock>): (config: IndexerConfig<TFilter, TBlock>) => IndexerWithStreamConfig<TFilter, TBlock>;
+interface Indexer<TFilter, TBlock> {
+    streamConfig: StreamConfig<TFilter, TBlock>;
+    options: IndexerConfig<TFilter, TBlock>;
+    hooks: Hookable<IndexerHooks<TFilter, TBlock>>;
+}
+declare function createIndexer<TFilter, TBlock>({ streamConfig, ...options }: IndexerWithStreamConfig<TFilter, TBlock>): Indexer<TFilter, TBlock>;
+interface ReconnectOptions {
+    maxRetries?: number;
+    retryDelay?: number;
+    maxWait?: number;
+}
+declare function runWithReconnect<TFilter, TBlock>(client: Client<TFilter, TBlock>, indexer: Indexer<TFilter, TBlock>, options?: ReconnectOptions): Promise<void>;
+interface RunOptions {
+    onConnect?: () => void | Promise<void>;
+}
+declare function run<TFilter, TBlock>(client: Client<TFilter, TBlock>, indexer: Indexer<TFilter, TBlock>, runOptions?: RunOptions): Promise<void>;
+
+export { type IndexerWithStreamConfig as I, type ReconnectOptions as R, type UseMiddlewareFunction as U, type Indexer as a, type IndexerPlugin as b, type IndexerConfig as c, defineIndexerPlugin as d, type IndexerHooks as e, type IndexerStartingCursor as f, defineIndexer as g, createIndexer as h, type RunOptions as i, run as j, runWithReconnect as r, useIndexerContext as u };

package/dist/shared/indexer.ff25c953.mjs

@@ -0,0 +1,26 @@
+import { consola } from 'consola';
+import { u as useIndexerContext } from './indexer.a55ad619.mjs';
+import { d as defineIndexerPlugin } from './indexer.9b21ddd2.mjs';
+
+function logger({
+  logger: logger2
+} = {}) {
+  return defineIndexerPlugin((indexer) => {
+    indexer.hooks.hook("run:before", () => {
+      const ctx = useIndexerContext();
+      if (logger2) {
+        ctx.logger = consola.create({ reporters: [logger2] });
+      } else {
+        ctx.logger = consola.create({});
+      }
+    });
+  });
+}
+function useLogger() {
+  const ctx = useIndexerContext();
+  if (!ctx?.logger)
+    throw new Error("Logger plugin is not available in context");
+  return ctx.logger;
+}
+
+export { logger as l, useLogger as u };

package/dist/testing/index.cjs

@@ -1,64 +1,66 @@
 'use strict';
 
-const vitest = require('vitest');
-const helper = require('../shared/indexer.318d3617.cjs');
-const vcr_index = require('../shared/indexer.541d43eb.cjs');
+const protocol = require('@apibara/protocol');
+const ci = require('ci-info');
+const index = require('../index.cjs');
+const internal_plugins = require('../internal/plugins.cjs');
+const logger = require('../shared/indexer.2416906c.cjs');
+const vcr_index = require('../vcr/index.cjs');
+require('consola');
+require('hookable');
+require('node:assert');
+require('../shared/indexer.077335f3.cjs');
 require('node:async_hooks');
 require('unctx');
 require('@opentelemetry/api');
-require('node:fs');
-require('node:path');
+require('../shared/indexer.601ceab0.cjs');
 require('node:fs/promises');
-require('klona/full');
-require('consola');
-require('hookable');
-require('node:assert');
-require('../shared/indexer.a8b7ab1f.cjs');
+require('node:path');
+require('node:fs');
 require('@apibara/protocol/testing');
 
-const test = vitest.test.extend({
-  vcr: {
-    withClient
-  }
-});
-async function withClient(cassetteName, range, callback) {
-  const vcrConfig = {
-    cassetteDir: "cassettes"
-  };
-  const cassetteOptions = {
-    name: cassetteName,
-    startingCursor: {
-      orderKey: range.fromBlock
-    },
-    endingCursor: {
-      orderKey: range.toBlock
-    }
-  };
-  const context = {
-    async run(indexer) {
-      const client = vcr_index.loadCassette(vcrConfig, cassetteName);
-      if (!helper.isCassetteAvailable(vcrConfig, cassetteName)) {
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
+
+const ci__default = /*#__PURE__*/_interopDefaultCompat(ci);
+
+function createVcr() {
+  return {
+    async run(cassetteName, indexerConfig, range) {
+      const vcrConfig = {
+        cassetteDir: "cassettes"
+      };
+      const cassetteOptions = {
+        name: cassetteName,
+        startingCursor: {
+          orderKey: range.fromBlock
+        },
+        endingCursor: {
+          orderKey: range.toBlock
+        }
+      };
+      indexerConfig.plugins = [
+        internal_plugins.internalContext({
+          indexerName: cassetteName,
+          availableIndexers: [cassetteName]
+        }),
+        logger.logger(),
+        ...indexerConfig.plugins ?? []
+      ];
+      const indexer = index.createIndexer(indexerConfig);
+      if (!vcr_index.isCassetteAvailable(vcrConfig, cassetteName)) {
+        if (ci__default.isCI) {
+          throw new Error("Cannot record cassette in CI");
+        }
+        const client = protocol.createClient(
+          indexer.streamConfig,
+          indexer.options.streamUrl
+        );
         await vcr_index.record(vcrConfig, client, indexer, cassetteOptions);
+      } else {
+        await vcr_index.replay(vcrConfig, indexer, cassetteName);
       }
-      return await vcr_index.replay(vcrConfig, indexer, cassetteName);
     }
   };
-  await callback(context);
-}
-
-function generateMockMessages(count = 10) {
-  return [...Array(count)].map((_, i) => ({
-    _tag: "data",
-    data: {
-      cursor: { orderKey: BigInt(5e6 - 1) },
-      finality: "accepted",
-      data: [{ data: `${5e6 + i}` }],
-      endCursor: { orderKey: BigInt(5e6 + i) }
-    }
-  }));
 }
 
-exports.VcrSink = vcr_index.VcrSink;
-exports.vcr = vcr_index.vcr;
-exports.generateMockMessages = generateMockMessages;
-exports.test = test;
+exports.createVcr = createVcr;

package/dist/testing/index.d.cts

@@ -1,40 +1,12 @@
-import * as vitest from 'vitest';
-import { f as Indexer } from '../shared/indexer.c7ed6b83.cjs';
-import { a as VcrReplayResult } from '../shared/indexer.500fd281.cjs';
-import { Cursor } from '@apibara/protocol';
-import { S as Sink, b as SinkData, a as SinkCursorParams } from '../shared/indexer.b9c8f0d8.cjs';
-import { MockStreamResponse } from '@apibara/protocol/testing';
+import { I as IndexerWithStreamConfig } from '../shared/indexer.fedcd831.cjs';
+import '@apibara/protocol';
 import 'hookable';
 
-declare const test: vitest.TestAPI<{
-    vcr: {
-        withClient: typeof withClient;
-    };
-}>;
-type WithClientContext<TFilter, TBlock, TTxnParams> = {
-    run: (indexerArgs: Indexer<TFilter, TBlock, TTxnParams>) => Promise<VcrReplayResult>;
+declare function createVcr(): {
+    run<TFilter, TBlock>(cassetteName: string, indexerConfig: IndexerWithStreamConfig<TFilter, TBlock>, range: {
+        fromBlock: bigint;
+        toBlock: bigint;
+    }): Promise<void>;
 };
-declare function withClient<TFilter, TBlock, TTxnParams>(cassetteName: string, range: {
-    fromBlock: bigint;
-    toBlock: bigint;
-}, callback: (context: WithClientContext<TFilter, TBlock, TTxnParams>) => Promise<void>): Promise<void>;
 
-type TxnParams = {
-    writer: {
-        insert: (data: SinkData[]) => void;
-    };
-};
-declare class VcrSink extends Sink {
-    result: VcrReplayResult["outputs"];
-    write({ data, endCursor }: {
-        data: SinkData[];
-        endCursor?: Cursor;
-    }): void;
-    transaction({ cursor, endCursor, finality }: SinkCursorParams, cb: (params: TxnParams) => Promise<void>): Promise<void>;
-    invalidate(cursor?: Cursor): Promise<void>;
-}
-declare function vcr(): VcrSink;
-
-declare function generateMockMessages(count?: number): MockStreamResponse[];
-
-export { VcrSink, generateMockMessages, test, vcr };
+export { createVcr };

package/dist/testing/index.d.mts

@@ -1,40 +1,12 @@
-import * as vitest from 'vitest';
-import { f as Indexer } from '../shared/indexer.e8bd138d.mjs';
-import { a as VcrReplayResult } from '../shared/indexer.e1856641.mjs';
-import { Cursor } from '@apibara/protocol';
-import { S as Sink, b as SinkData, a as SinkCursorParams } from '../shared/indexer.b9c8f0d8.mjs';
-import { MockStreamResponse } from '@apibara/protocol/testing';
+import { I as IndexerWithStreamConfig } from '../shared/indexer.fedcd831.mjs';
+import '@apibara/protocol';
 import 'hookable';
 
-declare const test: vitest.TestAPI<{
-    vcr: {
-        withClient: typeof withClient;
-    };
-}>;
-type WithClientContext<TFilter, TBlock, TTxnParams> = {
-    run: (indexerArgs: Indexer<TFilter, TBlock, TTxnParams>) => Promise<VcrReplayResult>;
+declare function createVcr(): {
+    run<TFilter, TBlock>(cassetteName: string, indexerConfig: IndexerWithStreamConfig<TFilter, TBlock>, range: {
+        fromBlock: bigint;
+        toBlock: bigint;
+    }): Promise<void>;
 };
-declare function withClient<TFilter, TBlock, TTxnParams>(cassetteName: string, range: {
-    fromBlock: bigint;
-    toBlock: bigint;
-}, callback: (context: WithClientContext<TFilter, TBlock, TTxnParams>) => Promise<void>): Promise<void>;
 
-type TxnParams = {
-    writer: {
-        insert: (data: SinkData[]) => void;
-    };
-};
-declare class VcrSink extends Sink {
-    result: VcrReplayResult["outputs"];
-    write({ data, endCursor }: {
-        data: SinkData[];
-        endCursor?: Cursor;
-    }): void;
-    transaction({ cursor, endCursor, finality }: SinkCursorParams, cb: (params: TxnParams) => Promise<void>): Promise<void>;
-    invalidate(cursor?: Cursor): Promise<void>;
-}
-declare function vcr(): VcrSink;
-
-declare function generateMockMessages(count?: number): MockStreamResponse[];
-
-export { VcrSink, generateMockMessages, test, vcr };
+export { createVcr };

package/dist/testing/index.d.ts

@@ -1,40 +1,12 @@
-import * as vitest from 'vitest';
-import { f as Indexer } from '../shared/indexer.f761abcd.js';
-import { a as VcrReplayResult } from '../shared/indexer.e4f2430f.js';
-import { Cursor } from '@apibara/protocol';
-import { S as Sink, b as SinkData, a as SinkCursorParams } from '../shared/indexer.b9c8f0d8.js';
-import { MockStreamResponse } from '@apibara/protocol/testing';
+import { I as IndexerWithStreamConfig } from '../shared/indexer.fedcd831.js';
+import '@apibara/protocol';
 import 'hookable';
 
-declare const test: vitest.TestAPI<{
-    vcr: {
-        withClient: typeof withClient;
-    };
-}>;
-type WithClientContext<TFilter, TBlock, TTxnParams> = {
-    run: (indexerArgs: Indexer<TFilter, TBlock, TTxnParams>) => Promise<VcrReplayResult>;
+declare function createVcr(): {
+    run<TFilter, TBlock>(cassetteName: string, indexerConfig: IndexerWithStreamConfig<TFilter, TBlock>, range: {
+        fromBlock: bigint;
+        toBlock: bigint;
+    }): Promise<void>;
 };
-declare function withClient<TFilter, TBlock, TTxnParams>(cassetteName: string, range: {
-    fromBlock: bigint;
-    toBlock: bigint;
-}, callback: (context: WithClientContext<TFilter, TBlock, TTxnParams>) => Promise<void>): Promise<void>;
 
-type TxnParams = {
-    writer: {
-        insert: (data: SinkData[]) => void;
-    };
-};
-declare class VcrSink extends Sink {
-    result: VcrReplayResult["outputs"];
-    write({ data, endCursor }: {
-        data: SinkData[];
-        endCursor?: Cursor;
-    }): void;
-    transaction({ cursor, endCursor, finality }: SinkCursorParams, cb: (params: TxnParams) => Promise<void>): Promise<void>;
-    invalidate(cursor?: Cursor): Promise<void>;
-}
-declare function vcr(): VcrSink;
-
-declare function generateMockMessages(count?: number): MockStreamResponse[];
-
-export { VcrSink, generateMockMessages, test, vcr };
+export { createVcr };