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

package/dist/plugins/persistence.mjs

@@ -1,179 +0,0 @@
-import { d as deserialize, s as serialize } from '../shared/indexer.2c23c9cd.mjs';
-import 'node:fs/promises';
-import 'node:path';
-import 'klona/full';
-import 'consola';
-import 'hookable';
-import 'node:assert';
-import 'node:fs';
-import '@apibara/protocol/testing';
-import { defineIndexerPlugin } from './index.mjs';
-import 'node:async_hooks';
-import 'unctx';
-import '@opentelemetry/api';
-
-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;
-};
-function sqlitePersistence({
-  database
-}) {
-  return defineIndexerPlugin((indexer) => {
-    let store;
-    indexer.hooks.hook("run:before", () => {
-      SqlitePersistence.initialize(database);
-      store = new SqlitePersistence(database);
-    });
-    indexer.hooks.hook("connect:before", ({ request }) => {
-      const { cursor, filter } = store.get();
-      if (cursor) {
-        request.startingCursor = cursor;
-      }
-      if (filter) {
-        request.filter[1] = filter;
-      }
-    });
-    indexer.hooks.hook("transaction:commit", ({ endCursor }) => {
-      if (endCursor) {
-        store.put({ cursor: endCursor });
-      }
-    });
-    indexer.hooks.hook("connect:factory", ({ request, endCursor }) => {
-      if (request.filter[1]) {
-        store.put({ cursor: endCursor, filter: request.filter[1] });
-      }
-    });
-  });
-}
-class SqlitePersistence {
-  constructor(_db) {
-    this._db = _db;
-    /** Sqlite Queries Prepare Statements */
-    __publicField(this, "_getCheckpointQuery");
-    __publicField(this, "_putCheckpointQuery");
-    __publicField(this, "_delCheckpointQuery");
-    __publicField(this, "_getFilterQuery");
-    __publicField(this, "_updateFilterToBlockQuery");
-    __publicField(this, "_insertFilterQuery");
-    __publicField(this, "_delFilterQuery");
-    this._getCheckpointQuery = this._db.prepare(statements.getCheckpoint);
-    this._putCheckpointQuery = this._db.prepare(statements.putCheckpoint);
-    this._delCheckpointQuery = this._db.prepare(statements.delCheckpoint);
-    this._getFilterQuery = this._db.prepare(statements.getFilter);
-    this._updateFilterToBlockQuery = this._db.prepare(
-      statements.updateFilterToBlock
-    );
-    this._insertFilterQuery = this._db.prepare(statements.insertFilter);
-    this._delFilterQuery = this._db.prepare(statements.delFilter);
-  }
-  static initialize(db) {
-    db.prepare(statements.createCheckpointsTable).run();
-    db.prepare(statements.createFiltersTable).run();
-  }
-  get() {
-    const cursor = this._getCheckpoint();
-    const filter = this._getFilter();
-    return { cursor, filter };
-  }
-  put({ cursor, filter }) {
-    if (cursor) {
-      this._putCheckpoint(cursor);
-      if (filter) {
-        this._putFilter(filter, cursor);
-      }
-    }
-  }
-  del() {
-    this._delCheckpoint();
-    this._delFilter();
-  }
-  // --- CHECKPOINTS TABLE METHODS ---
-  _getCheckpoint() {
-    const row = this._getCheckpointQuery.get("default");
-    if (!row)
-      return void 0;
-    return { orderKey: BigInt(row.order_key), uniqueKey: row.unique_key };
-  }
-  _putCheckpoint(cursor) {
-    this._putCheckpointQuery.run(
-      "default",
-      Number(cursor.orderKey),
-      cursor.uniqueKey
-    );
-  }
-  _delCheckpoint() {
-    this._delCheckpointQuery.run("default");
-  }
-  // --- FILTERS TABLE METHODS ---
-  _getFilter() {
-    const row = this._getFilterQuery.get("default");
-    if (!row)
-      return void 0;
-    return deserialize(row.filter);
-  }
-  _putFilter(filter, endCursor) {
-    this._updateFilterToBlockQuery.run(Number(endCursor.orderKey), "default");
-    this._insertFilterQuery.run(
-      "default",
-      serialize(filter),
-      Number(endCursor.orderKey)
-    );
-  }
-  _delFilter() {
-    this._delFilterQuery.run("default");
-  }
-}
-const statements = {
-  beginTxn: "BEGIN TRANSACTION",
-  commitTxn: "COMMIT TRANSACTION",
-  rollbackTxn: "ROLLBACK TRANSACTION",
-  createCheckpointsTable: `
-    CREATE TABLE IF NOT EXISTS checkpoints (
-      id TEXT NOT NULL PRIMARY KEY,
-      order_key INTEGER NOT NULL,
-      unique_key TEXT
-    );`,
-  createFiltersTable: `
-    CREATE TABLE IF NOT EXISTS filters (
-      id TEXT NOT NULL,
-      filter BLOB NOT NULL,
-      from_block INTEGER NOT NULL,
-      to_block INTEGER,
-      PRIMARY KEY (id, from_block)
-    );`,
-  getCheckpoint: `
-    SELECT *
-    FROM checkpoints
-    WHERE id = ?`,
-  putCheckpoint: `
-    INSERT INTO checkpoints (id, order_key, unique_key)
-    VALUES (?, ?, ?)
-    ON CONFLICT(id) DO UPDATE SET
-      order_key = excluded.order_key,
-      unique_key = excluded.unique_key`,
-  delCheckpoint: `
-    DELETE FROM checkpoints
-    WHERE id = ?`,
-  getFilter: `
-    SELECT *
-    FROM filters
-    WHERE id = ? AND to_block IS NULL`,
-  updateFilterToBlock: `
-    UPDATE filters
-    SET to_block = ?
-    WHERE id = ? AND to_block IS NULL`,
-  insertFilter: `
-    INSERT INTO filters (id, filter, from_block)
-    VALUES (?, ?, ?)
-    ON CONFLICT(id, from_block) DO UPDATE SET
-      filter = excluded.filter,
-      from_block = excluded.from_block`,
-  delFilter: `
-    DELETE FROM filters
-    WHERE id = ?`
-};
-
-export { SqlitePersistence, sqlitePersistence };

package/dist/shared/indexer.2c23c9cd.mjs

@@ -1,35 +0,0 @@
-import { AsyncLocalStorage } from 'node:async_hooks';
-import { getContext } from 'unctx';
-import { trace } from '@opentelemetry/api';
-import fs from 'node:fs';
-import path from 'node:path';
-
-const indexerAsyncContext = getContext("indexer", {
-  asyncContext: true,
-  AsyncLocalStorage
-});
-function useIndexerContext() {
-  return indexerAsyncContext.use();
-}
-
-const tracer = trace.getTracer("@apibara/indexer");
-
-function deserialize(str) {
-  return JSON.parse(
-    str,
-    (_, value) => typeof value === "string" && value.match(/^\d+n$/) ? BigInt(value.slice(0, -1)) : value
-  );
-}
-function serialize(obj) {
-  return JSON.stringify(
-    obj,
-    (_, value) => typeof value === "bigint" ? `${value.toString()}n` : value,
-    "	"
-  );
-}
-function isCassetteAvailable(vcrConfig, cassetteName) {
-  const filePath = path.join(vcrConfig.cassetteDir, `${cassetteName}.json`);
-  return fs.existsSync(filePath);
-}
-
-export { indexerAsyncContext as a, deserialize as d, isCassetteAvailable as i, serialize as s, tracer as t, useIndexerContext as u };

package/dist/shared/indexer.318d3617.cjs

@@ -1,47 +0,0 @@
-'use strict';
-
-const node_async_hooks = require('node:async_hooks');
-const unctx = require('unctx');
-const api = require('@opentelemetry/api');
-const fs = require('node:fs');
-const path = require('node:path');
-
-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 indexerAsyncContext = unctx.getContext("indexer", {
-  asyncContext: true,
-  AsyncLocalStorage: node_async_hooks.AsyncLocalStorage
-});
-function useIndexerContext() {
-  return indexerAsyncContext.use();
-}
-
-const tracer = api.trace.getTracer("@apibara/indexer");
-
-function deserialize(str) {
-  return JSON.parse(
-    str,
-    (_, value) => typeof value === "string" && value.match(/^\d+n$/) ? BigInt(value.slice(0, -1)) : value
-  );
-}
-function serialize(obj) {
-  return JSON.stringify(
-    obj,
-    (_, value) => typeof value === "bigint" ? `${value.toString()}n` : value,
-    "	"
-  );
-}
-function isCassetteAvailable(vcrConfig, cassetteName) {
-  const filePath = path__default.join(vcrConfig.cassetteDir, `${cassetteName}.json`);
-  return fs__default.existsSync(filePath);
-}
-
-exports.deserialize = deserialize;
-exports.indexerAsyncContext = indexerAsyncContext;
-exports.isCassetteAvailable = isCassetteAvailable;
-exports.serialize = serialize;
-exports.tracer = tracer;
-exports.useIndexerContext = useIndexerContext;

package/dist/shared/indexer.36530330.mjs

@@ -1,249 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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 };