@apibara/indexer 2.1.0-beta.40 → 2.1.0-beta.41

package/dist/shared/{indexer.806c605c.d.mts → indexer.4ef52548.d.mts}

@@ -13,35 +13,51 @@ declare function defineIndexerPlugin<TFilter, TBlock>(def: IndexerPlugin<TFilter
 
 type UseMiddlewareFunction = (fn: MiddlewareFunction<IndexerContext>) => void;
 interface IndexerHooks<TFilter, TBlock> {
-    "plugins:init": () => void;
-    "run:before": () => void;
-    "run:after": () => void;
+    "plugins:init": ({ abortSignal }: {
+        abortSignal?: AbortSignal;
+    }) => void;
+    "run:before": ({ abortSignal }: {
+        abortSignal?: AbortSignal;
+    }) => void;
+    "run:after": ({ abortSignal }: {
+        abortSignal?: AbortSignal;
+    }) => void;
     "connect:before": ({ request, options, }: {
         request: StreamDataRequest<TFilter>;
         options: StreamDataOptions;
+        abortSignal?: AbortSignal;
     }) => void;
     "connect:after": ({ request, }: {
         request: StreamDataRequest<TFilter>;
+        abortSignal?: AbortSignal;
     }) => void;
-    "connect:factory": ({ request, endCursor, }: {
+    "connect:factory": ({ request, endCursor, abortSignal, }: {
         request: StreamDataRequest<TFilter>;
         endCursor?: Cursor;
+        abortSignal?: AbortSignal;
     }) => void;
-    "handler:middleware": ({ use }: {
+    "handler:middleware": ({ use, abortSignal, }: {
         use: UseMiddlewareFunction;
+        abortSignal?: AbortSignal;
     }) => void;
-    message: ({ message }: {
+    message: ({ message, abortSignal, }: {
         message: StreamDataResponse<TBlock>;
+        abortSignal?: AbortSignal;
     }) => void;
-    "message:invalidate": ({ message }: {
+    "message:invalidate": ({ message, abortSignal, }: {
         message: Invalidate;
+        abortSignal?: AbortSignal;
     }) => void;
-    "message:finalize": ({ message }: {
+    "message:finalize": ({ message, abortSignal, }: {
         message: Finalize;
+        abortSignal?: AbortSignal;
+    }) => void;
+    "message:heartbeat": ({ abortSignal }: {
+        abortSignal?: AbortSignal;
     }) => void;
-    "message:heartbeat": () => void;
-    "message:systemMessage": ({ message }: {
+    "message:systemMessage": ({ message, abortSignal, }: {
         message: SystemMessage;
+        abortSignal?: AbortSignal;
     }) => void;
 }
 type IndexerStartingCursor = {
@@ -61,6 +77,7 @@ type HandlerArgs<TBlock> = {
     finality: DataFinality;
     production: DataProduction;
     context: IndexerContext;
+    abortSignal?: AbortSignal;
 };
 type IndexerConfig<TFilter, TBlock> = {
     streamUrl: string;
@@ -93,7 +110,8 @@ interface ReconnectOptions {
 declare function runWithReconnect<TFilter, TBlock>(client: Client<TFilter, TBlock>, indexer: Indexer<TFilter, TBlock>, options?: ReconnectOptions): Promise<void>;
 interface RunOptions {
     onConnect?: () => void | Promise<void>;
+    abortSignal?: AbortSignal;
 }
 declare function run<TFilter, TBlock>(client: Client<TFilter, TBlock>, indexer: Indexer<TFilter, TBlock>, runOptions?: RunOptions): Promise<void>;
 
-export { type HandlerArgs as H, type IndexerWithStreamConfig as I, type ReconnectOptions as R, type UseMiddlewareFunction as U, type IndexerHooks as a, type Indexer as b, type IndexerPlugin as c, type IndexerConfig as d, defineIndexerPlugin 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 };
+export { type HandlerArgs as H, type IndexerHooks as I, type ReconnectOptions as R, type UseMiddlewareFunction as U, type IndexerStartingCursor as a, type IndexerConfig as b, type IndexerWithStreamConfig as c, defineIndexer as d, type Indexer as e, createIndexer as f, type RunOptions as g, run as h, type IndexerPlugin as i, defineIndexerPlugin as j, runWithReconnect as r, useIndexerContext as u };

package/dist/shared/{indexer.806c605c.d.ts → indexer.4ef52548.d.ts}

@@ -13,35 +13,51 @@ declare function defineIndexerPlugin<TFilter, TBlock>(def: IndexerPlugin<TFilter
 
 type UseMiddlewareFunction = (fn: MiddlewareFunction<IndexerContext>) => void;
 interface IndexerHooks<TFilter, TBlock> {
-    "plugins:init": () => void;
-    "run:before": () => void;
-    "run:after": () => void;
+    "plugins:init": ({ abortSignal }: {
+        abortSignal?: AbortSignal;
+    }) => void;
+    "run:before": ({ abortSignal }: {
+        abortSignal?: AbortSignal;
+    }) => void;
+    "run:after": ({ abortSignal }: {
+        abortSignal?: AbortSignal;
+    }) => void;
     "connect:before": ({ request, options, }: {
         request: StreamDataRequest<TFilter>;
         options: StreamDataOptions;
+        abortSignal?: AbortSignal;
     }) => void;
     "connect:after": ({ request, }: {
         request: StreamDataRequest<TFilter>;
+        abortSignal?: AbortSignal;
     }) => void;
-    "connect:factory": ({ request, endCursor, }: {
+    "connect:factory": ({ request, endCursor, abortSignal, }: {
         request: StreamDataRequest<TFilter>;
         endCursor?: Cursor;
+        abortSignal?: AbortSignal;
     }) => void;
-    "handler:middleware": ({ use }: {
+    "handler:middleware": ({ use, abortSignal, }: {
         use: UseMiddlewareFunction;
+        abortSignal?: AbortSignal;
     }) => void;
-    message: ({ message }: {
+    message: ({ message, abortSignal, }: {
         message: StreamDataResponse<TBlock>;
+        abortSignal?: AbortSignal;
     }) => void;
-    "message:invalidate": ({ message }: {
+    "message:invalidate": ({ message, abortSignal, }: {
         message: Invalidate;
+        abortSignal?: AbortSignal;
     }) => void;
-    "message:finalize": ({ message }: {
+    "message:finalize": ({ message, abortSignal, }: {
         message: Finalize;
+        abortSignal?: AbortSignal;
+    }) => void;
+    "message:heartbeat": ({ abortSignal }: {
+        abortSignal?: AbortSignal;
     }) => void;
-    "message:heartbeat": () => void;
-    "message:systemMessage": ({ message }: {
+    "message:systemMessage": ({ message, abortSignal, }: {
         message: SystemMessage;
+        abortSignal?: AbortSignal;
     }) => void;
 }
 type IndexerStartingCursor = {
@@ -61,6 +77,7 @@ type HandlerArgs<TBlock> = {
     finality: DataFinality;
     production: DataProduction;
     context: IndexerContext;
+    abortSignal?: AbortSignal;
 };
 type IndexerConfig<TFilter, TBlock> = {
     streamUrl: string;
@@ -93,7 +110,8 @@ interface ReconnectOptions {
 declare function runWithReconnect<TFilter, TBlock>(client: Client<TFilter, TBlock>, indexer: Indexer<TFilter, TBlock>, options?: ReconnectOptions): Promise<void>;
 interface RunOptions {
     onConnect?: () => void | Promise<void>;
+    abortSignal?: AbortSignal;
 }
 declare function run<TFilter, TBlock>(client: Client<TFilter, TBlock>, indexer: Indexer<TFilter, TBlock>, runOptions?: RunOptions): Promise<void>;
 
-export { type HandlerArgs as H, type IndexerWithStreamConfig as I, type ReconnectOptions as R, type UseMiddlewareFunction as U, type IndexerHooks as a, type Indexer as b, type IndexerPlugin as c, type IndexerConfig as d, defineIndexerPlugin 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 };
+export { type HandlerArgs as H, type IndexerHooks as I, type ReconnectOptions as R, type UseMiddlewareFunction as U, type IndexerStartingCursor as a, type IndexerConfig as b, type IndexerWithStreamConfig as c, defineIndexer as d, type Indexer as e, createIndexer as f, type RunOptions as g, run as h, type IndexerPlugin as i, defineIndexerPlugin as j, runWithReconnect as r, useIndexerContext as u };

package/dist/testing/index.d.cts

@@ -1,5 +1,5 @@
 import { NestedHooks } from 'hookable';
-import { I as IndexerWithStreamConfig, a as IndexerHooks } from '../shared/indexer.806c605c.cjs';
+import { c as IndexerWithStreamConfig, I as IndexerHooks } from '../shared/indexer.4ef52548.cjs';
 import '@apibara/protocol';
 
 type VcrResult = Record<string, unknown>;

package/dist/testing/index.d.mts

@@ -1,5 +1,5 @@
 import { NestedHooks } from 'hookable';
-import { I as IndexerWithStreamConfig, a as IndexerHooks } from '../shared/indexer.806c605c.mjs';
+import { c as IndexerWithStreamConfig, I as IndexerHooks } from '../shared/indexer.4ef52548.mjs';
 import '@apibara/protocol';
 
 type VcrResult = Record<string, unknown>;

package/dist/testing/index.d.ts

@@ -1,5 +1,5 @@
 import { NestedHooks } from 'hookable';
-import { I as IndexerWithStreamConfig, a as IndexerHooks } from '../shared/indexer.806c605c.js';
+import { c as IndexerWithStreamConfig, I as IndexerHooks } from '../shared/indexer.4ef52548.js';
 import '@apibara/protocol';
 
 type VcrResult = Record<string, unknown>;

package/dist/vcr/index.d.cts

@@ -1,5 +1,5 @@
 import { Cursor, StreamDataResponse, Client } from '@apibara/protocol';
-import { b as Indexer } from '../shared/indexer.806c605c.cjs';
+import { e as Indexer } from '../shared/indexer.4ef52548.cjs';
 import 'hookable';
 
 type VcrConfig = {

package/dist/vcr/index.d.mts

@@ -1,5 +1,5 @@
 import { Cursor, StreamDataResponse, Client } from '@apibara/protocol';
-import { b as Indexer } from '../shared/indexer.806c605c.mjs';
+import { e as Indexer } from '../shared/indexer.4ef52548.mjs';
 import 'hookable';
 
 type VcrConfig = {

package/dist/vcr/index.d.ts

@@ -1,5 +1,5 @@
 import { Cursor, StreamDataResponse, Client } from '@apibara/protocol';
-import { b as Indexer } from '../shared/indexer.806c605c.js';
+import { e as Indexer } from '../shared/indexer.4ef52548.js';
 import 'hookable';
 
 type VcrConfig = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@apibara/indexer",
-  "version": "2.1.0-beta.40",
+  "version": "2.1.0-beta.41",
   "type": "module",
   "files": [
     "dist",
@@ -70,7 +70,7 @@
     "vitest": "^1.6.0"
   },
   "dependencies": {
-    "@apibara/protocol": "2.1.0-beta.40",
+    "@apibara/protocol": "2.1.0-beta.41",
     "@opentelemetry/api": "^1.9.0",
     "ci-info": "^4.1.0",
     "consola": "^3.4.2",

package/src/index.ts

@@ -1,2 +1,3 @@
 export * from "./indexer";
 export { useIndexerContext } from "./context";
+export { reloadIndexer, ReloadIndexerRequest } from "./utils";

package/src/indexer.ts

@@ -33,40 +33,63 @@ import {
 import { createIndexerMetrics, createTracer } from "./otel";
 import type { IndexerPlugin } from "./plugins";
 import { useInternalContext } from "./plugins/context";
+import { reloadIfNeeded } from "./utils";
 
 export type UseMiddlewareFunction = (
   fn: MiddlewareFunction<IndexerContext>,
 ) => void;
 
 export interface IndexerHooks<TFilter, TBlock> {
-  "plugins:init": () => void;
-  "run:before": () => void;
-  "run:after": () => void;
+  "plugins:init": ({ abortSignal }: { abortSignal?: AbortSignal }) => void;
+  "run:before": ({ abortSignal }: { abortSignal?: AbortSignal }) => void;
+  "run:after": ({ abortSignal }: { abortSignal?: AbortSignal }) => void;
   "connect:before": ({
     request,
     options,
   }: {
     request: StreamDataRequest<TFilter>;
     options: StreamDataOptions;
+    abortSignal?: AbortSignal;
   }) => void;
   "connect:after": ({
     request,
   }: {
     request: StreamDataRequest<TFilter>;
+    abortSignal?: AbortSignal;
   }) => void;
   "connect:factory": ({
     request,
     endCursor,
+    abortSignal,
   }: {
     request: StreamDataRequest<TFilter>;
     endCursor?: Cursor;
+    abortSignal?: AbortSignal;
   }) => 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": () => void;
-  "message:systemMessage": ({ message }: { message: SystemMessage }) => void;
+  "handler:middleware": ({
+    use,
+    abortSignal,
+  }: { use: UseMiddlewareFunction; abortSignal?: AbortSignal }) => void;
+  message: ({
+    message,
+    abortSignal,
+  }: {
+    message: StreamDataResponse<TBlock>;
+    abortSignal?: AbortSignal;
+  }) => void;
+  "message:invalidate": ({
+    message,
+    abortSignal,
+  }: { message: Invalidate; abortSignal?: AbortSignal }) => void;
+  "message:finalize": ({
+    message,
+    abortSignal,
+  }: { message: Finalize; abortSignal?: AbortSignal }) => void;
+  "message:heartbeat": ({ abortSignal }: { abortSignal?: AbortSignal }) => void;
+  "message:systemMessage": ({
+    message,
+    abortSignal,
+  }: { message: SystemMessage; abortSignal?: AbortSignal }) => void;
 }
 
 export type IndexerStartingCursor =
@@ -90,6 +113,7 @@ export type HandlerArgs<TBlock> = {
   finality: DataFinality;
   production: DataProduction;
   context: IndexerContext;
+  abortSignal?: AbortSignal;
 };
 
 export type IndexerConfig<TFilter, TBlock> = {
@@ -170,15 +194,19 @@ export async function runWithReconnect<TFilter, TBlock>(
   const retryDelay = options.retryDelay ?? 1_000;
   const maxWait = options.maxWait ?? 30_000;
 
-  const runOptions: RunOptions = {
-    onConnect() {
-      retryCount = 0;
-    },
-  };
-
   while (true) {
+    const abortController = new AbortController();
+
+    const runOptions: RunOptions = {
+      onConnect() {
+        retryCount = 0;
+      },
+      abortSignal: abortController.signal,
+    };
+
     try {
       await run(client, indexer, runOptions);
+      abortController.abort();
       return;
     } catch (error) {
       // Only reconnect on internal/server errors.
@@ -186,6 +214,8 @@ export async function runWithReconnect<TFilter, TBlock>(
 
       retryCount++;
 
+      abortController.abort();
+
       if (error instanceof ClientError || error instanceof ServerError) {
         const isServerError = error instanceof ServerError;
 
@@ -209,7 +239,6 @@ export async function runWithReconnect<TFilter, TBlock>(
           }
         }
       }
-
       throw error;
     }
   }
@@ -217,6 +246,7 @@ export async function runWithReconnect<TFilter, TBlock>(
 
 export interface RunOptions {
   onConnect?: () => void | Promise<void>;
+  abortSignal?: AbortSignal;
 }
 
 export async function run<TFilter, TBlock>(
@@ -231,14 +261,16 @@ export async function run<TFilter, TBlock>(
       context.debug = true;
     }
 
-    await indexer.hooks.callHook("plugins:init");
+    const { abortSignal } = runOptions;
+
+    await indexer.hooks.callHook("plugins:init", { abortSignal });
 
-    const middleware = await registerMiddleware(indexer);
+    const middleware = await registerMiddleware(indexer, abortSignal);
 
     const indexerMetrics = createIndexerMetrics();
     const tracer = createTracer();
 
-    await indexer.hooks.callHook("run:before");
+    await indexer.hooks.callHook("run:before", { abortSignal });
 
     const { indexerName: indexerId } = useInternalContext();
 
@@ -269,7 +301,11 @@ export async function run<TFilter, TBlock>(
 
     const options: StreamDataOptions = {};
 
-    await indexer.hooks.callHook("connect:before", { request, options });
+    await indexer.hooks.callHook("connect:before", {
+      request,
+      options,
+      abortSignal,
+    });
 
     // store main filter, so later it can be merged
     let mainFilter: TFilter;
@@ -282,7 +318,7 @@ export async function run<TFilter, TBlock>(
       StreamDataResponse<TBlock>
     > = client.streamData(request, options)[Symbol.asyncIterator]();
 
-    await indexer.hooks.callHook("connect:after", { request });
+    await indexer.hooks.callHook("connect:after", { request, abortSignal });
 
     let onConnectCalled = false;
 
@@ -300,7 +336,7 @@ export async function run<TFilter, TBlock>(
         }
       }
 
-      await indexer.hooks.callHook("message", { message });
+      await indexer.hooks.callHook("message", { message, abortSignal });
 
       switch (message._tag) {
         case "data": {
@@ -320,6 +356,8 @@ export async function run<TFilter, TBlock>(
               },
             );
 
+            reloadIfNeeded();
+
             await middleware(context, async () => {
               let block: TBlock | null;
 
@@ -339,6 +377,7 @@ export async function run<TFilter, TBlock>(
                     finality,
                     production,
                     context,
+                    abortSignal,
                   });
 
                   // write returned data from factory function if filter is not defined
@@ -360,6 +399,7 @@ export async function run<TFilter, TBlock>(
                     await indexer.hooks.callHook("connect:factory", {
                       request,
                       endCursor,
+                      abortSignal,
                     });
 
                     // create new stream with new request
@@ -391,6 +431,7 @@ export async function run<TFilter, TBlock>(
                     finality,
                     production,
                     context,
+                    abortSignal,
                   });
 
                   span.end();
@@ -398,6 +439,8 @@ export async function run<TFilter, TBlock>(
               }
             });
 
+            reloadIfNeeded();
+
             span.end();
           });
 
@@ -420,6 +463,7 @@ export async function run<TFilter, TBlock>(
             });
             await indexer.hooks.callHook("message:invalidate", {
               message: message.invalidate,
+              abortSignal,
             });
             span.end();
           });
@@ -429,6 +473,7 @@ export async function run<TFilter, TBlock>(
           await tracer.startActiveSpan("message finalize", async (span) => {
             await indexer.hooks.callHook("message:finalize", {
               message: message.finalize,
+              abortSignal,
             });
             span.end();
           });
@@ -436,7 +481,11 @@ export async function run<TFilter, TBlock>(
         }
         case "heartbeat": {
           await tracer.startActiveSpan("message heartbeat", async (span) => {
-            await indexer.hooks.callHook("message:heartbeat");
+            reloadIfNeeded();
+
+            await indexer.hooks.callHook("message:heartbeat", { abortSignal });
+            reloadIfNeeded();
+
             span.end();
           });
           break;
@@ -460,6 +509,7 @@ export async function run<TFilter, TBlock>(
 
               await indexer.hooks.callHook("message:systemMessage", {
                 message: message.systemMessage,
+                abortSignal,
               });
               span.end();
             },
@@ -471,21 +521,22 @@ export async function run<TFilter, TBlock>(
           throw new Error("not implemented");
         }
       }
-
-      await indexer.hooks.callHook("run:after");
     }
+
+    await indexer.hooks.callHook("run:after", { abortSignal });
   });
 }
 
 async function registerMiddleware<TFilter, TBlock>(
   indexer: Indexer<TFilter, TBlock>,
+  abortSignal?: AbortSignal,
 ): Promise<MiddlewareFunction<IndexerContext>> {
   const middleware: MiddlewareFunction<IndexerContext>[] = [];
   const use = (fn: MiddlewareFunction<IndexerContext>) => {
     middleware.push(fn);
   };
 
-  await indexer.hooks.callHook("handler:middleware", { use });
+  await indexer.hooks.callHook("handler:middleware", { use, abortSignal });
 
   const composed = compose(middleware);
 

package/src/internal/testing.ts

@@ -10,15 +10,19 @@ import { type IndexerConfig, createIndexer, defineIndexer } from "../indexer";
 import { defineIndexerPlugin, logger } from "../plugins";
 import { type InternalContext, internalContext } from "./plugins";
 
+export type InvalidateConfig = {
+  invalidateFromIndex: number;
+  invalidateTriggerIndex: number;
+};
+
+export type FinalizeConfig = {
+  finalizeToIndex: number;
+  finalizeTriggerIndex: number;
+};
+
 export type MockMessagesOptions = {
-  invalidate?: {
-    invalidateFromIndex: number;
-    invalidateTriggerIndex: number;
-  };
-  finalize?: {
-    finalizeToIndex: number;
-    finalizeTriggerIndex: number;
-  };
+  invalidate?: InvalidateConfig | InvalidateConfig[];
+  finalize?: FinalizeConfig | FinalizeConfig[];
   uniqueKey?: boolean;
   baseBlockNumber?: bigint;
 };
@@ -27,18 +31,35 @@ export function generateMockMessages(
   count = 10,
   options?: MockMessagesOptions,
 ): MockStreamResponse[] {
-  const invalidateAt = options?.invalidate;
-  const finalizeAt = options?.finalize;
   const messages: MockStreamResponse[] = [];
-
   const baseBlockNumber = options?.baseBlockNumber ?? BigInt(5_000_000);
 
+  const invalidateConfigs = options?.invalidate
+    ? Array.isArray(options.invalidate)
+      ? options.invalidate
+      : [options.invalidate]
+    : [];
+
+  const finalizeConfigs = options?.finalize
+    ? Array.isArray(options.finalize)
+      ? options.finalize
+      : [options.finalize]
+    : [];
+
   for (let i = 0; i < count; i++) {
     const currentBlockNumber = baseBlockNumber + BigInt(i);
     const uniqueKey = uniqueKeyFromOrderKey(currentBlockNumber);
-    if (invalidateAt && i === invalidateAt.invalidateTriggerIndex) {
+
+    const invalidateConfig = invalidateConfigs.find(
+      (cfg) => cfg.invalidateTriggerIndex === i,
+    );
+    const finalizeConfig = finalizeConfigs.find(
+      (cfg) => cfg.finalizeTriggerIndex === i,
+    );
+
+    if (invalidateConfig) {
       const invalidateToBlock =
-        baseBlockNumber + BigInt(invalidateAt.invalidateFromIndex);
+        baseBlockNumber + BigInt(invalidateConfig.invalidateFromIndex);
       messages.push({
         _tag: "invalidate",
         invalidate: {
@@ -50,16 +71,16 @@ export function generateMockMessages(
           },
         } as Invalidate,
       });
-    } else if (finalizeAt && i === finalizeAt.finalizeTriggerIndex) {
-      const fianlizedToBlock =
-        baseBlockNumber + BigInt(finalizeAt.finalizeToIndex);
+    } else if (finalizeConfig) {
+      const finalizedToBlock =
+        baseBlockNumber + BigInt(finalizeConfig.finalizeToIndex);
       messages.push({
         _tag: "finalize",
         finalize: {
           cursor: {
-            orderKey: fianlizedToBlock,
+            orderKey: finalizedToBlock,
             uniqueKey: options?.uniqueKey
-              ? uniqueKeyFromOrderKey(fianlizedToBlock)
+              ? uniqueKeyFromOrderKey(finalizedToBlock)
               : undefined,
           },
         } as Finalize,

package/src/utils/index.ts

@@ -0,0 +1,21 @@
+import { useIndexerContext } from "../context";
+
+export function reloadIndexer() {
+  const context = useIndexerContext();
+  context._reload = true;
+}
+
+export function reloadIfNeeded() {
+  const context = useIndexerContext();
+  if (context._reload) {
+    context._reload = false;
+    throw new ReloadIndexerRequest();
+  }
+}
+
+export class ReloadIndexerRequest extends Error {
+  constructor(message?: string) {
+    super(message);
+    this.name = "ReloadIndexerRequest";
+  }
+}