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

package/dist/internal/index.d.cts

@@ -0,0 +1,3 @@
+declare function generateIndexerId(fileBasedName: string, identifier?: string): string;
+
+export { generateIndexerId };

package/dist/internal/index.d.mts

@@ -0,0 +1,3 @@
+declare function generateIndexerId(fileBasedName: string, identifier?: string): string;
+
+export { generateIndexerId };

package/dist/internal/index.d.ts

@@ -0,0 +1,3 @@
+declare function generateIndexerId(fileBasedName: string, identifier?: string): string;
+
+export { generateIndexerId };

package/dist/internal/index.mjs

@@ -0,0 +1,8 @@
+function generateIndexerId(fileBasedName, identifier) {
+  return `indexer_${fileBasedName}_${identifier || "default"}`.replace(
+    /[^a-zA-Z0-9_]/g,
+    "_"
+  );
+}
+
+export { generateIndexerId };

package/dist/internal/plugins.cjs

@@ -0,0 +1,38 @@
+'use strict';
+
+const context = require('../shared/indexer.077335f3.cjs');
+const config = require('../shared/indexer.601ceab0.cjs');
+require('node:async_hooks');
+require('unctx');
+
+const INTERNAL_CONTEXT_PROPERTY = "_internal";
+function internalContext(values) {
+  return config.defineIndexerPlugin((indexer) => {
+    indexer.hooks.hook("run:before", () => {
+      try {
+        const ctx = context.useIndexerContext();
+        ctx[INTERNAL_CONTEXT_PROPERTY] = {
+          ...ctx[INTERNAL_CONTEXT_PROPERTY] || {},
+          ...values
+        };
+      } catch (error) {
+        throw new Error("Failed to set internal context", {
+          cause: error
+        });
+      }
+    });
+  });
+}
+function useInternalContext() {
+  const ctx = context.useIndexerContext();
+  if (ctx[INTERNAL_CONTEXT_PROPERTY] === void 0) {
+    throw new Error(
+      "Internal context is not available, possibly 'internalContext' plugin is missing!"
+    );
+  }
+  return ctx[INTERNAL_CONTEXT_PROPERTY];
+}
+
+exports.INTERNAL_CONTEXT_PROPERTY = INTERNAL_CONTEXT_PROPERTY;
+exports.internalContext = internalContext;
+exports.useInternalContext = useInternalContext;

package/dist/internal/plugins.d.cts

@@ -0,0 +1,13 @@
+import { b as IndexerPlugin } from '../shared/indexer.fedcd831.cjs';
+import '@apibara/protocol';
+import 'hookable';
+
+declare const INTERNAL_CONTEXT_PROPERTY = "_internal";
+declare function internalContext<TFilter, TBlock, TTxnParams>(values: Record<string, unknown>): IndexerPlugin<TFilter, TBlock>;
+type InternalContext = {
+    indexerName: string;
+    availableIndexers: string[];
+};
+declare function useInternalContext(): InternalContext;
+
+export { INTERNAL_CONTEXT_PROPERTY, type InternalContext, internalContext, useInternalContext };

package/dist/internal/plugins.d.mts

@@ -0,0 +1,13 @@
+import { b as IndexerPlugin } from '../shared/indexer.fedcd831.mjs';
+import '@apibara/protocol';
+import 'hookable';
+
+declare const INTERNAL_CONTEXT_PROPERTY = "_internal";
+declare function internalContext<TFilter, TBlock, TTxnParams>(values: Record<string, unknown>): IndexerPlugin<TFilter, TBlock>;
+type InternalContext = {
+    indexerName: string;
+    availableIndexers: string[];
+};
+declare function useInternalContext(): InternalContext;
+
+export { INTERNAL_CONTEXT_PROPERTY, type InternalContext, internalContext, useInternalContext };

package/dist/internal/plugins.d.ts

@@ -0,0 +1,13 @@
+import { b as IndexerPlugin } from '../shared/indexer.fedcd831.js';
+import '@apibara/protocol';
+import 'hookable';
+
+declare const INTERNAL_CONTEXT_PROPERTY = "_internal";
+declare function internalContext<TFilter, TBlock, TTxnParams>(values: Record<string, unknown>): IndexerPlugin<TFilter, TBlock>;
+type InternalContext = {
+    indexerName: string;
+    availableIndexers: string[];
+};
+declare function useInternalContext(): InternalContext;
+
+export { INTERNAL_CONTEXT_PROPERTY, type InternalContext, internalContext, useInternalContext };

package/dist/internal/plugins.mjs

@@ -0,0 +1,34 @@
+import { u as useIndexerContext } from '../shared/indexer.a55ad619.mjs';
+import { d as defineIndexerPlugin } from '../shared/indexer.9b21ddd2.mjs';
+import 'node:async_hooks';
+import 'unctx';
+
+const INTERNAL_CONTEXT_PROPERTY = "_internal";
+function internalContext(values) {
+  return defineIndexerPlugin((indexer) => {
+    indexer.hooks.hook("run:before", () => {
+      try {
+        const ctx = useIndexerContext();
+        ctx[INTERNAL_CONTEXT_PROPERTY] = {
+          ...ctx[INTERNAL_CONTEXT_PROPERTY] || {},
+          ...values
+        };
+      } catch (error) {
+        throw new Error("Failed to set internal context", {
+          cause: error
+        });
+      }
+    });
+  });
+}
+function useInternalContext() {
+  const ctx = useIndexerContext();
+  if (ctx[INTERNAL_CONTEXT_PROPERTY] === void 0) {
+    throw new Error(
+      "Internal context is not available, possibly 'internalContext' plugin is missing!"
+    );
+  }
+  return ctx[INTERNAL_CONTEXT_PROPERTY];
+}
+
+export { INTERNAL_CONTEXT_PROPERTY, internalContext, useInternalContext };

package/dist/internal/testing.cjs

@@ -0,0 +1,118 @@
+'use strict';
+
+const protocol = require('@apibara/protocol');
+const testing = require('@apibara/protocol/testing');
+const context = require('../shared/indexer.077335f3.cjs');
+const index = require('../index.cjs');
+const config = require('../shared/indexer.601ceab0.cjs');
+require('consola');
+const internal_plugins = require('./plugins.cjs');
+require('node:async_hooks');
+require('unctx');
+require('hookable');
+require('node:assert');
+require('@opentelemetry/api');
+
+function generateMockMessages(count = 10, options) {
+  const invalidateAt = options?.invalidate;
+  const finalizeAt = options?.finalize;
+  const messages = [];
+  for (let i = 0; i < count; i++) {
+    if (invalidateAt && i === invalidateAt.invalidateTriggerIndex) {
+      messages.push({
+        _tag: "invalidate",
+        invalidate: {
+          cursor: {
+            orderKey: BigInt(5e6 + invalidateAt.invalidateFromIndex)
+          }
+        }
+      });
+    } else if (finalizeAt && i === finalizeAt.finalizeTriggerIndex) {
+      messages.push({
+        _tag: "finalize",
+        finalize: {
+          cursor: {
+            orderKey: BigInt(5e6 + finalizeAt.finalizeToIndex)
+          }
+        }
+      });
+    } else {
+      messages.push({
+        _tag: "data",
+        data: {
+          cursor: { orderKey: BigInt(5e6 + i - 1) },
+          finality: "accepted",
+          data: [{ data: `${5e6 + i}` }],
+          endCursor: { orderKey: BigInt(5e6 + i) },
+          production: "backfill"
+        }
+      });
+    }
+  }
+  return messages;
+}
+function getMockIndexer(params) {
+  const { internalContext: contextParams, override } = params ?? {};
+  const { plugins, ...rest } = override ?? {};
+  return index.createIndexer(
+    index.defineIndexer(testing.MockStream)({
+      streamUrl: "https://sepolia.ethereum.a5a.ch",
+      finality: "accepted",
+      filter: {},
+      async transform() {
+      },
+      plugins: [
+        internal_plugins.internalContext(
+          contextParams ?? {
+            availableIndexers: ["testing"],
+            indexerName: "testing"
+          }
+        ),
+        ...plugins ?? []
+      ],
+      ...rest ?? {}
+    })
+  );
+}
+function mockSink({
+  output,
+  metadata
+}) {
+  return config.defineIndexerPlugin((indexer) => {
+    indexer.hooks.hook("connect:before", ({ request }) => {
+      if (metadata?.lastCursor && protocol.isCursor(metadata.lastCursor)) {
+        request.startingCursor = metadata.lastCursor;
+      }
+      if (metadata?.lastFilter) {
+        request.filter[1] = metadata.lastFilter;
+      }
+    });
+    indexer.hooks.hook("connect:factory", ({ request, endCursor }) => {
+      if (request.filter[1]) {
+        if (metadata) {
+          metadata.lastCursor = endCursor;
+          metadata.lastFilter = request.filter[1];
+        }
+      }
+    });
+    indexer.hooks.hook("handler:middleware", ({ use }) => {
+      use(async (context, next) => {
+        context.output = output;
+        await next();
+        context.output = null;
+        if (metadata) {
+          metadata.lastCursor = context.endCursor;
+        }
+      });
+    });
+  });
+}
+function useMockSink() {
+  const context$1 = context.useIndexerContext();
+  return { output: context$1.output };
+}
+
+exports.generateMockMessages = generateMockMessages;
+exports.getMockIndexer = getMockIndexer;
+exports.mockSink = mockSink;
+exports.useMockSink = useMockSink;

package/dist/internal/testing.d.cts

@@ -0,0 +1,42 @@
+import { a as Indexer, b as IndexerPlugin, c as IndexerConfig } from '../shared/indexer.fedcd831.cjs';
+import { MockStreamResponse, MockFilter, MockBlock } from '@apibara/protocol/testing';
+import { InternalContext } from './plugins.cjs';
+import '@apibara/protocol';
+import 'hookable';
+
+type MockMessagesOptions = {
+    invalidate?: {
+        invalidateFromIndex: number;
+        invalidateTriggerIndex: number;
+    };
+    finalize?: {
+        finalizeToIndex: number;
+        finalizeTriggerIndex: number;
+    };
+};
+declare function generateMockMessages(count?: number, options?: MockMessagesOptions): MockStreamResponse[];
+type MockIndexerParams = {
+    internalContext?: InternalContext;
+    override?: Partial<IndexerConfig<MockFilter, MockBlock>>;
+};
+declare function getMockIndexer(params?: MockIndexerParams): Indexer<{
+    readonly filter?: string | undefined;
+}, {
+    readonly data?: string | undefined;
+}>;
+type MockRet = {
+    data: string;
+};
+/**
+ * A mock sink used for testing. The indexer function can write to the output array.
+ * The indexer context is optionally written to the metadata object.
+ */
+declare function mockSink<TFilter, TBlock>({ output, metadata, }: {
+    output: unknown[];
+    metadata?: Record<string, unknown>;
+}): IndexerPlugin<TFilter, TBlock>;
+declare function useMockSink(): {
+    output: unknown[];
+};
+
+export { type MockMessagesOptions, type MockRet, generateMockMessages, getMockIndexer, mockSink, useMockSink };

package/dist/internal/testing.d.mts

@@ -0,0 +1,42 @@
+import { a as Indexer, b as IndexerPlugin, c as IndexerConfig } from '../shared/indexer.fedcd831.mjs';
+import { MockStreamResponse, MockFilter, MockBlock } from '@apibara/protocol/testing';
+import { InternalContext } from './plugins.mjs';
+import '@apibara/protocol';
+import 'hookable';
+
+type MockMessagesOptions = {
+    invalidate?: {
+        invalidateFromIndex: number;
+        invalidateTriggerIndex: number;
+    };
+    finalize?: {
+        finalizeToIndex: number;
+        finalizeTriggerIndex: number;
+    };
+};
+declare function generateMockMessages(count?: number, options?: MockMessagesOptions): MockStreamResponse[];
+type MockIndexerParams = {
+    internalContext?: InternalContext;
+    override?: Partial<IndexerConfig<MockFilter, MockBlock>>;
+};
+declare function getMockIndexer(params?: MockIndexerParams): Indexer<{
+    readonly filter?: string | undefined;
+}, {
+    readonly data?: string | undefined;
+}>;
+type MockRet = {
+    data: string;
+};
+/**
+ * A mock sink used for testing. The indexer function can write to the output array.
+ * The indexer context is optionally written to the metadata object.
+ */
+declare function mockSink<TFilter, TBlock>({ output, metadata, }: {
+    output: unknown[];
+    metadata?: Record<string, unknown>;
+}): IndexerPlugin<TFilter, TBlock>;
+declare function useMockSink(): {
+    output: unknown[];
+};
+
+export { type MockMessagesOptions, type MockRet, generateMockMessages, getMockIndexer, mockSink, useMockSink };

package/dist/internal/testing.d.ts

@@ -0,0 +1,42 @@
+import { a as Indexer, b as IndexerPlugin, c as IndexerConfig } from '../shared/indexer.fedcd831.js';
+import { MockStreamResponse, MockFilter, MockBlock } from '@apibara/protocol/testing';
+import { InternalContext } from './plugins.js';
+import '@apibara/protocol';
+import 'hookable';
+
+type MockMessagesOptions = {
+    invalidate?: {
+        invalidateFromIndex: number;
+        invalidateTriggerIndex: number;
+    };
+    finalize?: {
+        finalizeToIndex: number;
+        finalizeTriggerIndex: number;
+    };
+};
+declare function generateMockMessages(count?: number, options?: MockMessagesOptions): MockStreamResponse[];
+type MockIndexerParams = {
+    internalContext?: InternalContext;
+    override?: Partial<IndexerConfig<MockFilter, MockBlock>>;
+};
+declare function getMockIndexer(params?: MockIndexerParams): Indexer<{
+    readonly filter?: string | undefined;
+}, {
+    readonly data?: string | undefined;
+}>;
+type MockRet = {
+    data: string;
+};
+/**
+ * A mock sink used for testing. The indexer function can write to the output array.
+ * The indexer context is optionally written to the metadata object.
+ */
+declare function mockSink<TFilter, TBlock>({ output, metadata, }: {
+    output: unknown[];
+    metadata?: Record<string, unknown>;
+}): IndexerPlugin<TFilter, TBlock>;
+declare function useMockSink(): {
+    output: unknown[];
+};
+
+export { type MockMessagesOptions, type MockRet, generateMockMessages, getMockIndexer, mockSink, useMockSink };

package/dist/internal/testing.mjs

@@ -0,0 +1,113 @@
+import { isCursor } from '@apibara/protocol';
+import { MockStream } from '@apibara/protocol/testing';
+import { u as useIndexerContext } from '../shared/indexer.a55ad619.mjs';
+import { createIndexer, defineIndexer } from '../index.mjs';
+import { d as defineIndexerPlugin } from '../shared/indexer.9b21ddd2.mjs';
+import 'consola';
+import { internalContext } from './plugins.mjs';
+import 'node:async_hooks';
+import 'unctx';
+import 'hookable';
+import 'node:assert';
+import '@opentelemetry/api';
+
+function generateMockMessages(count = 10, options) {
+  const invalidateAt = options?.invalidate;
+  const finalizeAt = options?.finalize;
+  const messages = [];
+  for (let i = 0; i < count; i++) {
+    if (invalidateAt && i === invalidateAt.invalidateTriggerIndex) {
+      messages.push({
+        _tag: "invalidate",
+        invalidate: {
+          cursor: {
+            orderKey: BigInt(5e6 + invalidateAt.invalidateFromIndex)
+          }
+        }
+      });
+    } else if (finalizeAt && i === finalizeAt.finalizeTriggerIndex) {
+      messages.push({
+        _tag: "finalize",
+        finalize: {
+          cursor: {
+            orderKey: BigInt(5e6 + finalizeAt.finalizeToIndex)
+          }
+        }
+      });
+    } else {
+      messages.push({
+        _tag: "data",
+        data: {
+          cursor: { orderKey: BigInt(5e6 + i - 1) },
+          finality: "accepted",
+          data: [{ data: `${5e6 + i}` }],
+          endCursor: { orderKey: BigInt(5e6 + i) },
+          production: "backfill"
+        }
+      });
+    }
+  }
+  return messages;
+}
+function getMockIndexer(params) {
+  const { internalContext: contextParams, override } = params ?? {};
+  const { plugins, ...rest } = override ?? {};
+  return createIndexer(
+    defineIndexer(MockStream)({
+      streamUrl: "https://sepolia.ethereum.a5a.ch",
+      finality: "accepted",
+      filter: {},
+      async transform() {
+      },
+      plugins: [
+        internalContext(
+          contextParams ?? {
+            availableIndexers: ["testing"],
+            indexerName: "testing"
+          }
+        ),
+        ...plugins ?? []
+      ],
+      ...rest ?? {}
+    })
+  );
+}
+function mockSink({
+  output,
+  metadata
+}) {
+  return defineIndexerPlugin((indexer) => {
+    indexer.hooks.hook("connect:before", ({ request }) => {
+      if (metadata?.lastCursor && isCursor(metadata.lastCursor)) {
+        request.startingCursor = metadata.lastCursor;
+      }
+      if (metadata?.lastFilter) {
+        request.filter[1] = metadata.lastFilter;
+      }
+    });
+    indexer.hooks.hook("connect:factory", ({ request, endCursor }) => {
+      if (request.filter[1]) {
+        if (metadata) {
+          metadata.lastCursor = endCursor;
+          metadata.lastFilter = request.filter[1];
+        }
+      }
+    });
+    indexer.hooks.hook("handler:middleware", ({ use }) => {
+      use(async (context, next) => {
+        context.output = output;
+        await next();
+        context.output = null;
+        if (metadata) {
+          metadata.lastCursor = context.endCursor;
+        }
+      });
+    });
+  });
+}
+function useMockSink() {
+  const context = useIndexerContext();
+  return { output: context.output };
+}
+
+export { generateMockMessages, getMockIndexer, mockSink, useMockSink };

package/dist/plugins/index.cjs

@@ -1,7 +1,43 @@
 'use strict';
 
-function defineIndexerPlugin(def) {
-  return def;
+const config = require('../shared/indexer.601ceab0.cjs');
+const logger = require('../shared/indexer.2416906c.cjs');
+const protocol = require('@apibara/protocol');
+require('consola');
+require('../shared/indexer.077335f3.cjs');
+require('node:async_hooks');
+require('unctx');
+
+function inMemoryPersistence() {
+  return config.defineIndexerPlugin((indexer) => {
+    let lastCursor;
+    let lastFilter;
+    indexer.hooks.hook("connect:before", ({ request }) => {
+      if (lastCursor) {
+        request.startingCursor = lastCursor;
+      }
+      if (lastFilter) {
+        request.filter[1] = lastFilter;
+      }
+    });
+    indexer.hooks.hook("connect:factory", ({ request, endCursor }) => {
+      if (request.filter[1]) {
+        lastCursor = endCursor;
+        lastFilter = request.filter[1];
+      }
+    });
+    indexer.hooks.hook("handler:middleware", ({ use }) => {
+      use(async (context, next) => {
+        await next();
+        if (context.endCursor && protocol.isCursor(context.endCursor)) {
+          lastCursor = context.endCursor;
+        }
+      });
+    });
+  });
 }
 
-exports.defineIndexerPlugin = defineIndexerPlugin;
+exports.defineIndexerPlugin = config.defineIndexerPlugin;
+exports.logger = logger.logger;
+exports.useLogger = logger.useLogger;
+exports.inMemoryPersistence = inMemoryPersistence;

package/dist/plugins/index.d.cts

@@ -1,4 +1,18 @@
-export { I as IndexerPlugin, h as defineIndexerPlugin } from '../shared/indexer.c7ed6b83.cjs';
+import { b as IndexerPlugin } from '../shared/indexer.fedcd831.cjs';
+export { d as defineIndexerPlugin } from '../shared/indexer.fedcd831.cjs';
+import { ConsolaReporter, ConsolaInstance } from 'consola';
+export { ConsolaInstance, ConsolaReporter } from 'consola';
 import '@apibara/protocol';
 import 'hookable';
-import '../shared/indexer.b9c8f0d8.cjs';
+
+declare function logger<TFilter, TBlock, TTxnParams>({ logger, }?: {
+    logger?: ConsolaReporter;
+}): IndexerPlugin<TFilter, TBlock>;
+declare function useLogger(): ConsolaInstance;
+
+/**
+ * A plugin that persists the last cursor and filter to memory.
+ */
+declare function inMemoryPersistence<TFilter, TBlock>(): IndexerPlugin<TFilter, TBlock>;
+
+export { IndexerPlugin, inMemoryPersistence, logger, useLogger };

package/dist/plugins/index.d.mts

@@ -1,4 +1,18 @@
-export { I as IndexerPlugin, h as defineIndexerPlugin } from '../shared/indexer.e8bd138d.mjs';
+import { b as IndexerPlugin } from '../shared/indexer.fedcd831.mjs';
+export { d as defineIndexerPlugin } from '../shared/indexer.fedcd831.mjs';
+import { ConsolaReporter, ConsolaInstance } from 'consola';
+export { ConsolaInstance, ConsolaReporter } from 'consola';
 import '@apibara/protocol';
 import 'hookable';
-import '../shared/indexer.b9c8f0d8.mjs';
+
+declare function logger<TFilter, TBlock, TTxnParams>({ logger, }?: {
+    logger?: ConsolaReporter;
+}): IndexerPlugin<TFilter, TBlock>;
+declare function useLogger(): ConsolaInstance;
+
+/**
+ * A plugin that persists the last cursor and filter to memory.
+ */
+declare function inMemoryPersistence<TFilter, TBlock>(): IndexerPlugin<TFilter, TBlock>;
+
+export { IndexerPlugin, inMemoryPersistence, logger, useLogger };

package/dist/plugins/index.d.ts

@@ -1,4 +1,18 @@
-export { I as IndexerPlugin, h as defineIndexerPlugin } from '../shared/indexer.f761abcd.js';
+import { b as IndexerPlugin } from '../shared/indexer.fedcd831.js';
+export { d as defineIndexerPlugin } from '../shared/indexer.fedcd831.js';
+import { ConsolaReporter, ConsolaInstance } from 'consola';
+export { ConsolaInstance, ConsolaReporter } from 'consola';
 import '@apibara/protocol';
 import 'hookable';
-import '../shared/indexer.b9c8f0d8.js';
+
+declare function logger<TFilter, TBlock, TTxnParams>({ logger, }?: {
+    logger?: ConsolaReporter;
+}): IndexerPlugin<TFilter, TBlock>;
+declare function useLogger(): ConsolaInstance;
+
+/**
+ * A plugin that persists the last cursor and filter to memory.
+ */
+declare function inMemoryPersistence<TFilter, TBlock>(): IndexerPlugin<TFilter, TBlock>;
+
+export { IndexerPlugin, inMemoryPersistence, logger, useLogger };

package/dist/plugins/index.mjs

@@ -1,5 +1,38 @@
-function defineIndexerPlugin(def) {
-  return def;
+import { d as defineIndexerPlugin } from '../shared/indexer.9b21ddd2.mjs';
+export { l as logger, u as useLogger } from '../shared/indexer.ff25c953.mjs';
+import { isCursor } from '@apibara/protocol';
+import 'consola';
+import '../shared/indexer.a55ad619.mjs';
+import 'node:async_hooks';
+import 'unctx';
+
+function inMemoryPersistence() {
+  return defineIndexerPlugin((indexer) => {
+    let lastCursor;
+    let lastFilter;
+    indexer.hooks.hook("connect:before", ({ request }) => {
+      if (lastCursor) {
+        request.startingCursor = lastCursor;
+      }
+      if (lastFilter) {
+        request.filter[1] = lastFilter;
+      }
+    });
+    indexer.hooks.hook("connect:factory", ({ request, endCursor }) => {
+      if (request.filter[1]) {
+        lastCursor = endCursor;
+        lastFilter = request.filter[1];
+      }
+    });
+    indexer.hooks.hook("handler:middleware", ({ use }) => {
+      use(async (context, next) => {
+        await next();
+        if (context.endCursor && isCursor(context.endCursor)) {
+          lastCursor = context.endCursor;
+        }
+      });
+    });
+  });
 }
 
-export { defineIndexerPlugin };
+export { defineIndexerPlugin, inMemoryPersistence };

package/dist/shared/indexer.077335f3.cjs

@@ -0,0 +1,15 @@
+'use strict';
+
+const node_async_hooks = require('node:async_hooks');
+const unctx = require('unctx');
+
+const indexerAsyncContext = unctx.getContext("indexer", {
+  asyncContext: true,
+  AsyncLocalStorage: node_async_hooks.AsyncLocalStorage
+});
+function useIndexerContext() {
+  return indexerAsyncContext.use();
+}
+
+exports.indexerAsyncContext = indexerAsyncContext;
+exports.useIndexerContext = useIndexerContext;