@apibara/indexer 2.0.0-beta.5 → 2.0.0-beta.7

package/dist/shared/indexer.36530330.mjs

@@ -0,0 +1,249 @@
+import { a as indexerAsyncContext, u as useIndexerContext, t as tracer, s as serialize, d as deserialize } from './indexer.2c23c9cd.mjs';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { klona } from 'klona/full';
+import consola from 'consola';
+import { createHooks, createDebugger } from 'hookable';
+import assert from 'node:assert';
+import { d as defaultSink, S as Sink } from './indexer.93d6b2eb.mjs';
+import fs$1 from 'node:fs';
+import { MockClient } from '@apibara/protocol/testing';
+
+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) {
+  await indexerAsyncContext.callAsync({}, async () => {
+    const context = useIndexerContext();
+    const sink = indexer.options.sink ?? defaultSink();
+    context.sink = sink;
+    await indexer.hooks.callHook("run:before");
+    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)[Symbol.asyncIterator]();
+    await indexer.hooks.callHook("connect:after");
+    while (true) {
+      const { value: message, done } = await stream.next();
+      if (done) {
+        break;
+      }
+      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;
+            await sink.transaction(
+              { cursor, endCursor, finality },
+              async (txn) => {
+                context.sinkTransaction = txn;
+                let block;
+                if (isFactoryMode) {
+                  assert(indexer.options.factory !== void 0);
+                  const [factoryBlock, mainBlock] = blocks;
+                  block = mainBlock;
+                  if (factoryBlock !== null) {
+                    const { filter } = await indexer.options.factory({
+                      block: factoryBlock,
+                      context
+                    });
+                    if (filter) {
+                      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)[Symbol.asyncIterator]();
+                      const { value: message2 } = await stream.next();
+                      assert(message2._tag === "data");
+                      const [_factoryBlock, _block] = message2.data.data;
+                      block = _block;
+                    }
+                  }
+                } else {
+                  block = blocks[0];
+                }
+                if (block) {
+                  await tracer.startActiveSpan("handler", async (span2) => {
+                    await indexer.hooks.callHook("handler:before", {
+                      block,
+                      endCursor,
+                      finality
+                    });
+                    try {
+                      await indexer.options.transform({
+                        block,
+                        cursor,
+                        endCursor,
+                        finality,
+                        context
+                      });
+                      await indexer.hooks.callHook("handler:after", {
+                        block,
+                        finality,
+                        endCursor
+                      });
+                    } catch (error) {
+                      assert(error instanceof Error);
+                      await indexer.hooks.callHook("handler:exception", {
+                        error
+                      });
+                      throw error;
+                    }
+                    span2.end();
+                  });
+                }
+              }
+            );
+            await indexer.hooks.callHook("transaction:commit", {
+              finality,
+              endCursor
+            });
+            span.end();
+          });
+          break;
+        }
+        case "invalidate": {
+          await tracer.startActiveSpan("message invalidate", async (span) => {
+            await sink.invalidate(message.invalidate.cursor);
+          });
+          break;
+        }
+        default: {
+          consola.warn("unexpected message", message);
+          throw new Error("not implemented");
+        }
+      }
+      await indexer.hooks.callHook("run:after");
+    }
+  });
+}
+
+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.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;
+};
+const transactionHelper = (context) => {
+  return {
+    insert: (data) => {
+      context.buffer.push(...data);
+    }
+  };
+};
+class VcrSink extends Sink {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "result", []);
+  }
+  write({ data, endCursor }) {
+    if (data.length === 0)
+      return;
+    this.result.push({ data, endCursor });
+  }
+  async transaction({ cursor, endCursor, finality }, cb) {
+    const context = {
+      buffer: []
+    };
+    const writer = transactionHelper(context);
+    await cb({ writer });
+    this.write({ data: context.buffer, endCursor });
+  }
+  async invalidate(cursor) {
+    throw new Error("Not implemented");
+  }
+}
+function vcr() {
+  return new VcrSink();
+}
+
+async function replay(vcrConfig, indexer, cassetteName) {
+  const client = loadCassette(vcrConfig, cassetteName);
+  const sink = vcr();
+  await run(client, indexer);
+  return {
+    outputs: sink.result
+  };
+}
+function loadCassette(vcrConfig, cassetteName) {
+  const filePath = path.join(vcrConfig.cassetteDir, `${cassetteName}.json`);
+  const data = fs$1.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, record as a, replay as b, createIndexer as c, defineIndexer as d, loadCassette as l, run as r, vcr as v };

package/dist/shared/indexer.500fd281.d.cts

@@ -0,0 +1,23 @@
+import { Cursor, Client } from '@apibara/protocol';
+import { f as Indexer } from './indexer.c7ed6b83.cjs';
+import { b as SinkData } from './indexer.b9c8f0d8.cjs';
+
+type VcrConfig = {
+    cassetteDir: string;
+};
+type CassetteOptions = {
+    name: string;
+    startingCursor: Cursor;
+    endingCursor: Cursor;
+};
+
+declare function replay<TFilter, TBlock, TTxnParams>(vcrConfig: VcrConfig, indexer: Indexer<TFilter, TBlock, TTxnParams>, 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 VcrConfig as V, type VcrReplayResult as a, loadCassette as l, replay as r };

package/dist/shared/indexer.541d43eb.cjs

@@ -0,0 +1,266 @@
+'use strict';
+
+const helper = require('./indexer.318d3617.cjs');
+const fs = require('node:fs/promises');
+const path = require('node:path');
+const full = require('klona/full');
+const consola = require('consola');
+const hookable = require('hookable');
+const assert = require('node:assert');
+const sink = require('./indexer.a8b7ab1f.cjs');
+const fs$1 = require('node:fs');
+const testing = require('@apibara/protocol/testing');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
+
+const fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
+const path__default = /*#__PURE__*/_interopDefaultCompat(path);
+const consola__default = /*#__PURE__*/_interopDefaultCompat(consola);
+const assert__default = /*#__PURE__*/_interopDefaultCompat(assert);
+const fs__default$1 = /*#__PURE__*/_interopDefaultCompat(fs$1);
+
+function defineIndexer(streamConfig) {
+  return (config) => ({
+    streamConfig,
+    ...config
+  });
+}
+function createIndexer({
+  streamConfig,
+  ...options
+}) {
+  const indexer = {
+    options,
+    streamConfig,
+    hooks: hookable.createHooks()
+  };
+  if (indexer.options.debug) {
+    hookable.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) {
+  await helper.indexerAsyncContext.callAsync({}, async () => {
+    const context = helper.useIndexerContext();
+    const sink$1 = indexer.options.sink ?? sink.defaultSink();
+    context.sink = sink$1;
+    await indexer.hooks.callHook("run:before");
+    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)[Symbol.asyncIterator]();
+    await indexer.hooks.callHook("connect:after");
+    while (true) {
+      const { value: message, done } = await stream.next();
+      if (done) {
+        break;
+      }
+      await indexer.hooks.callHook("message", { message });
+      switch (message._tag) {
+        case "data": {
+          await helper.tracer.startActiveSpan("message data", async (span) => {
+            const blocks = message.data.data;
+            const { cursor, endCursor, finality } = message.data;
+            await sink$1.transaction(
+              { cursor, endCursor, finality },
+              async (txn) => {
+                context.sinkTransaction = txn;
+                let block;
+                if (isFactoryMode) {
+                  assert__default(indexer.options.factory !== void 0);
+                  const [factoryBlock, mainBlock] = blocks;
+                  block = mainBlock;
+                  if (factoryBlock !== null) {
+                    const { filter } = await indexer.options.factory({
+                      block: factoryBlock,
+                      context
+                    });
+                    if (filter) {
+                      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)[Symbol.asyncIterator]();
+                      const { value: message2 } = await stream.next();
+                      assert__default(message2._tag === "data");
+                      const [_factoryBlock, _block] = message2.data.data;
+                      block = _block;
+                    }
+                  }
+                } else {
+                  block = blocks[0];
+                }
+                if (block) {
+                  await helper.tracer.startActiveSpan("handler", async (span2) => {
+                    await indexer.hooks.callHook("handler:before", {
+                      block,
+                      endCursor,
+                      finality
+                    });
+                    try {
+                      await indexer.options.transform({
+                        block,
+                        cursor,
+                        endCursor,
+                        finality,
+                        context
+                      });
+                      await indexer.hooks.callHook("handler:after", {
+                        block,
+                        finality,
+                        endCursor
+                      });
+                    } catch (error) {
+                      assert__default(error instanceof Error);
+                      await indexer.hooks.callHook("handler:exception", {
+                        error
+                      });
+                      throw error;
+                    }
+                    span2.end();
+                  });
+                }
+              }
+            );
+            await indexer.hooks.callHook("transaction:commit", {
+              finality,
+              endCursor
+            });
+            span.end();
+          });
+          break;
+        }
+        case "invalidate": {
+          await helper.tracer.startActiveSpan("message invalidate", async (span) => {
+            await sink$1.invalidate(message.invalidate.cursor);
+          });
+          break;
+        }
+        default: {
+          consola__default.warn("unexpected message", message);
+          throw new Error("not implemented");
+        }
+      }
+      await indexer.hooks.callHook("run:after");
+    }
+  });
+}
+
+async function record(vcrConfig, client, indexerArg, cassetteOptions) {
+  const indexer = full.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__default.join(
+        vcrConfig.cassetteDir,
+        `${cassetteOptions.name}.json`
+      );
+      await fs__default.writeFile(filePath, helper.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;
+};
+const transactionHelper = (context) => {
+  return {
+    insert: (data) => {
+      context.buffer.push(...data);
+    }
+  };
+};
+class VcrSink extends sink.Sink {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "result", []);
+  }
+  write({ data, endCursor }) {
+    if (data.length === 0)
+      return;
+    this.result.push({ data, endCursor });
+  }
+  async transaction({ cursor, endCursor, finality }, cb) {
+    const context = {
+      buffer: []
+    };
+    const writer = transactionHelper(context);
+    await cb({ writer });
+    this.write({ data: context.buffer, endCursor });
+  }
+  async invalidate(cursor) {
+    throw new Error("Not implemented");
+  }
+}
+function vcr() {
+  return new VcrSink();
+}
+
+async function replay(vcrConfig, indexer, cassetteName) {
+  const client = loadCassette(vcrConfig, cassetteName);
+  const sink = vcr();
+  await run(client, indexer);
+  return {
+    outputs: sink.result
+  };
+}
+function loadCassette(vcrConfig, cassetteName) {
+  const filePath = path__default.join(vcrConfig.cassetteDir, `${cassetteName}.json`);
+  const data = fs__default$1.readFileSync(filePath, "utf8");
+  const cassetteData = helper.deserialize(data);
+  const { filter, messages } = cassetteData;
+  return new testing.MockClient((request, options) => {
+    assert__default.deepStrictEqual(
+      request.filter,
+      filter,
+      "Request and Cassette filter mismatch"
+    );
+    return messages;
+  });
+}
+
+exports.VcrSink = VcrSink;
+exports.createIndexer = createIndexer;
+exports.defineIndexer = defineIndexer;
+exports.loadCassette = loadCassette;
+exports.record = record;
+exports.replay = replay;
+exports.run = run;
+exports.vcr = vcr;

package/dist/shared/indexer.93d6b2eb.mjs

@@ -0,0 +1,17 @@
+import consola from 'consola';
+
+class Sink {
+}
+class DefaultSink extends Sink {
+  async transaction({ cursor, endCursor, finality }, cb) {
+    await cb({});
+  }
+  async invalidate(cursor) {
+    consola.info(`Invalidating cursor ${cursor?.orderKey}`);
+  }
+}
+function defaultSink() {
+  return new DefaultSink();
+}
+
+export { DefaultSink as D, Sink as S, defaultSink as d };

package/dist/shared/indexer.a8b7ab1f.cjs

@@ -0,0 +1,25 @@
+'use strict';
+
+const consola = require('consola');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
+
+const consola__default = /*#__PURE__*/_interopDefaultCompat(consola);
+
+class Sink {
+}
+class DefaultSink extends Sink {
+  async transaction({ cursor, endCursor, finality }, cb) {
+    await cb({});
+  }
+  async invalidate(cursor) {
+    consola__default.info(`Invalidating cursor ${cursor?.orderKey}`);
+  }
+}
+function defaultSink() {
+  return new DefaultSink();
+}
+
+exports.DefaultSink = DefaultSink;
+exports.Sink = Sink;
+exports.defaultSink = defaultSink;

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

@@ -0,0 +1,19 @@
+import { Cursor, DataFinality } from '@apibara/protocol';
+
+type SinkData = Record<string, unknown>;
+type SinkCursorParams = {
+    cursor?: Cursor;
+    endCursor?: Cursor;
+    finality: DataFinality;
+};
+declare abstract class Sink<TTxnParams = unknown> {
+    abstract transaction({ cursor, endCursor, finality }: SinkCursorParams, cb: (params: TTxnParams) => Promise<void>): Promise<void>;
+    abstract invalidate(cursor?: Cursor): Promise<void>;
+}
+declare class DefaultSink extends Sink<unknown> {
+    transaction({ cursor, endCursor, finality }: SinkCursorParams, cb: (params: unknown) => Promise<void>): Promise<void>;
+    invalidate(cursor?: Cursor): Promise<void>;
+}
+declare function defaultSink(): DefaultSink;
+
+export { DefaultSink as D, Sink as S, type SinkCursorParams as a, type SinkData as b, defaultSink as d };

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

@@ -0,0 +1,19 @@
+import { Cursor, DataFinality } from '@apibara/protocol';
+
+type SinkData = Record<string, unknown>;
+type SinkCursorParams = {
+    cursor?: Cursor;
+    endCursor?: Cursor;
+    finality: DataFinality;
+};
+declare abstract class Sink<TTxnParams = unknown> {
+    abstract transaction({ cursor, endCursor, finality }: SinkCursorParams, cb: (params: TTxnParams) => Promise<void>): Promise<void>;
+    abstract invalidate(cursor?: Cursor): Promise<void>;
+}
+declare class DefaultSink extends Sink<unknown> {
+    transaction({ cursor, endCursor, finality }: SinkCursorParams, cb: (params: unknown) => Promise<void>): Promise<void>;
+    invalidate(cursor?: Cursor): Promise<void>;
+}
+declare function defaultSink(): DefaultSink;
+
+export { DefaultSink as D, Sink as S, type SinkCursorParams as a, type SinkData as b, defaultSink as d };

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

@@ -0,0 +1,19 @@
+import { Cursor, DataFinality } from '@apibara/protocol';
+
+type SinkData = Record<string, unknown>;
+type SinkCursorParams = {
+    cursor?: Cursor;
+    endCursor?: Cursor;
+    finality: DataFinality;
+};
+declare abstract class Sink<TTxnParams = unknown> {
+    abstract transaction({ cursor, endCursor, finality }: SinkCursorParams, cb: (params: TTxnParams) => Promise<void>): Promise<void>;
+    abstract invalidate(cursor?: Cursor): Promise<void>;
+}
+declare class DefaultSink extends Sink<unknown> {
+    transaction({ cursor, endCursor, finality }: SinkCursorParams, cb: (params: unknown) => Promise<void>): Promise<void>;
+    invalidate(cursor?: Cursor): Promise<void>;
+}
+declare function defaultSink(): DefaultSink;
+
+export { DefaultSink as D, Sink as S, type SinkCursorParams as a, type SinkData as b, defaultSink as d };