@apibara/indexer 2.0.0-beta.3 → 2.0.0-beta.31

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

@@ -0,0 +1,58 @@
+'use strict';
+
+const protocol = require('@apibara/protocol');
+const ci = require('ci-info');
+const index = require('../index.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('../shared/indexer.601ceab0.cjs');
+require('node:fs/promises');
+require('node:path');
+require('node:fs');
+require('@apibara/protocol/testing');
+
+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 = [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);
+      }
+    }
+  };
+}
+
+exports.createVcr = createVcr;

package/dist/testing/index.d.cts

@@ -0,0 +1,12 @@
+import { I as IndexerWithStreamConfig } from '../shared/indexer.8939ecc8.cjs';
+import '@apibara/protocol';
+import 'hookable';
+
+declare function createVcr(): {
+    run<TFilter, TBlock>(cassetteName: string, indexerConfig: IndexerWithStreamConfig<TFilter, TBlock>, range: {
+        fromBlock: bigint;
+        toBlock: bigint;
+    }): Promise<void>;
+};
+
+export { createVcr };

package/dist/testing/index.d.mts

@@ -0,0 +1,12 @@
+import { I as IndexerWithStreamConfig } from '../shared/indexer.8939ecc8.mjs';
+import '@apibara/protocol';
+import 'hookable';
+
+declare function createVcr(): {
+    run<TFilter, TBlock>(cassetteName: string, indexerConfig: IndexerWithStreamConfig<TFilter, TBlock>, range: {
+        fromBlock: bigint;
+        toBlock: bigint;
+    }): Promise<void>;
+};
+
+export { createVcr };

package/dist/testing/index.d.ts

@@ -0,0 +1,12 @@
+import { I as IndexerWithStreamConfig } from '../shared/indexer.8939ecc8.js';
+import '@apibara/protocol';
+import 'hookable';
+
+declare function createVcr(): {
+    run<TFilter, TBlock>(cassetteName: string, indexerConfig: IndexerWithStreamConfig<TFilter, TBlock>, range: {
+        fromBlock: bigint;
+        toBlock: bigint;
+    }): Promise<void>;
+};
+
+export { createVcr };

package/dist/testing/index.mjs

@@ -0,0 +1,52 @@
+import { createClient } from '@apibara/protocol';
+import ci from 'ci-info';
+import { createIndexer } from '../index.mjs';
+import { l as logger } from '../shared/indexer.ff25c953.mjs';
+import { isCassetteAvailable, record, replay } from '../vcr/index.mjs';
+import 'consola';
+import 'hookable';
+import 'node:assert';
+import '../shared/indexer.a55ad619.mjs';
+import 'node:async_hooks';
+import 'unctx';
+import '@opentelemetry/api';
+import '../shared/indexer.9b21ddd2.mjs';
+import 'node:fs/promises';
+import 'node:path';
+import 'node:fs';
+import '@apibara/protocol/testing';
+
+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 = [logger(), ...indexerConfig.plugins ?? []];
+      const indexer = createIndexer(indexerConfig);
+      if (!isCassetteAvailable(vcrConfig, cassetteName)) {
+        if (ci.isCI) {
+          throw new Error("Cannot record cassette in CI");
+        }
+        const client = createClient(
+          indexer.streamConfig,
+          indexer.options.streamUrl
+        );
+        await record(vcrConfig, client, indexer, cassetteOptions);
+      } else {
+        await replay(vcrConfig, indexer, cassetteName);
+      }
+    }
+  };
+}
+
+export { createVcr };

package/dist/vcr/index.cjs

@@ -0,0 +1,92 @@
+'use strict';
+
+const fs$1 = require('node:fs/promises');
+const path = require('node:path');
+const index = require('../index.cjs');
+const assert = require('node:assert');
+const fs = require('node:fs');
+const testing = require('@apibara/protocol/testing');
+require('@apibara/protocol');
+require('consola');
+require('hookable');
+require('../shared/indexer.077335f3.cjs');
+require('node:async_hooks');
+require('unctx');
+require('@opentelemetry/api');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
+
+const fs__default$1 = /*#__PURE__*/_interopDefaultCompat(fs$1);
+const path__default = /*#__PURE__*/_interopDefaultCompat(path);
+const assert__default = /*#__PURE__*/_interopDefaultCompat(assert);
+const fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
+
+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);
+}
+
+async function record(vcrConfig, client, indexer, cassetteOptions) {
+  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
+      };
+      await fs__default$1.mkdir(vcrConfig.cassetteDir, { recursive: true });
+      const filePath = path__default.join(
+        vcrConfig.cassetteDir,
+        `${cassetteOptions.name}.json`
+      );
+      await fs__default$1.writeFile(filePath, serialize(output), { flag: "w" });
+    }
+  });
+  await index.run(client, indexer);
+}
+
+async function replay(vcrConfig, indexer, cassetteName) {
+  const client = loadCassette(vcrConfig, cassetteName);
+  await index.run(client, indexer);
+}
+function loadCassette(vcrConfig, cassetteName) {
+  const filePath = path__default.join(vcrConfig.cassetteDir, `${cassetteName}.json`);
+  const data = fs__default.readFileSync(filePath, "utf8");
+  const cassetteData = deserialize(data);
+  const { filter, messages } = cassetteData;
+  return new testing.MockClient((request, options) => {
+    assert__default.deepStrictEqual(
+      request.filter,
+      [filter],
+      "Indexer and cassette filter mismatch. Hint: delete the cassette and run again."
+    );
+    return messages;
+  });
+}
+
+exports.deserialize = deserialize;
+exports.isCassetteAvailable = isCassetteAvailable;
+exports.loadCassette = loadCassette;
+exports.record = record;
+exports.replay = replay;
+exports.serialize = serialize;

package/dist/vcr/index.d.cts

@@ -0,0 +1,27 @@
+import { Cursor, StreamDataResponse, Client } from '@apibara/protocol';
+import { c as Indexer } from '../shared/indexer.8939ecc8.cjs';
+import 'hookable';
+
+type VcrConfig = {
+    cassetteDir: string;
+};
+type CassetteOptions = {
+    name: string;
+    startingCursor: Cursor;
+    endingCursor: Cursor;
+};
+
+declare function deserialize(str: string): any;
+declare function serialize(obj: Record<string, unknown>): string;
+declare function isCassetteAvailable(vcrConfig: VcrConfig, cassetteName: string): boolean;
+
+type CassetteDataType<TFilter, TBlock> = {
+    filter: TFilter;
+    messages: StreamDataResponse<TBlock>[];
+};
+declare function record<TFilter, TBlock, TTxnParams>(vcrConfig: VcrConfig, client: Client<TFilter, TBlock>, indexer: Indexer<TFilter, TBlock>, cassetteOptions: CassetteOptions): Promise<void>;
+
+declare function replay<TFilter, TBlock, TTxnParams>(vcrConfig: VcrConfig, indexer: Indexer<TFilter, TBlock>, cassetteName: string): Promise<void>;
+declare function loadCassette<TFilter, TBlock>(vcrConfig: VcrConfig, cassetteName: string): Client<TFilter, TBlock>;
+
+export { type CassetteDataType, type CassetteOptions, type VcrConfig, deserialize, isCassetteAvailable, loadCassette, record, replay, serialize };

package/dist/vcr/index.d.mts

@@ -0,0 +1,27 @@
+import { Cursor, StreamDataResponse, Client } from '@apibara/protocol';
+import { c as Indexer } from '../shared/indexer.8939ecc8.mjs';
+import 'hookable';
+
+type VcrConfig = {
+    cassetteDir: string;
+};
+type CassetteOptions = {
+    name: string;
+    startingCursor: Cursor;
+    endingCursor: Cursor;
+};
+
+declare function deserialize(str: string): any;
+declare function serialize(obj: Record<string, unknown>): string;
+declare function isCassetteAvailable(vcrConfig: VcrConfig, cassetteName: string): boolean;
+
+type CassetteDataType<TFilter, TBlock> = {
+    filter: TFilter;
+    messages: StreamDataResponse<TBlock>[];
+};
+declare function record<TFilter, TBlock, TTxnParams>(vcrConfig: VcrConfig, client: Client<TFilter, TBlock>, indexer: Indexer<TFilter, TBlock>, cassetteOptions: CassetteOptions): Promise<void>;
+
+declare function replay<TFilter, TBlock, TTxnParams>(vcrConfig: VcrConfig, indexer: Indexer<TFilter, TBlock>, cassetteName: string): Promise<void>;
+declare function loadCassette<TFilter, TBlock>(vcrConfig: VcrConfig, cassetteName: string): Client<TFilter, TBlock>;
+
+export { type CassetteDataType, type CassetteOptions, type VcrConfig, deserialize, isCassetteAvailable, loadCassette, record, replay, serialize };

package/dist/vcr/index.d.ts

@@ -0,0 +1,27 @@
+import { Cursor, StreamDataResponse, Client } from '@apibara/protocol';
+import { c as Indexer } from '../shared/indexer.8939ecc8.js';
+import 'hookable';
+
+type VcrConfig = {
+    cassetteDir: string;
+};
+type CassetteOptions = {
+    name: string;
+    startingCursor: Cursor;
+    endingCursor: Cursor;
+};
+
+declare function deserialize(str: string): any;
+declare function serialize(obj: Record<string, unknown>): string;
+declare function isCassetteAvailable(vcrConfig: VcrConfig, cassetteName: string): boolean;
+
+type CassetteDataType<TFilter, TBlock> = {
+    filter: TFilter;
+    messages: StreamDataResponse<TBlock>[];
+};
+declare function record<TFilter, TBlock, TTxnParams>(vcrConfig: VcrConfig, client: Client<TFilter, TBlock>, indexer: Indexer<TFilter, TBlock>, cassetteOptions: CassetteOptions): Promise<void>;
+
+declare function replay<TFilter, TBlock, TTxnParams>(vcrConfig: VcrConfig, indexer: Indexer<TFilter, TBlock>, cassetteName: string): Promise<void>;
+declare function loadCassette<TFilter, TBlock>(vcrConfig: VcrConfig, cassetteName: string): Client<TFilter, TBlock>;
+
+export { type CassetteDataType, type CassetteOptions, type VcrConfig, deserialize, isCassetteAvailable, loadCassette, record, replay, serialize };

package/dist/vcr/index.mjs

@@ -0,0 +1,78 @@
+import fs$1 from 'node:fs/promises';
+import path from 'node:path';
+import { run } from '../index.mjs';
+import assert from 'node:assert';
+import fs from 'node:fs';
+import { MockClient } from '@apibara/protocol/testing';
+import '@apibara/protocol';
+import 'consola';
+import 'hookable';
+import '../shared/indexer.a55ad619.mjs';
+import 'node:async_hooks';
+import 'unctx';
+import '@opentelemetry/api';
+
+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);
+}
+
+async function record(vcrConfig, client, indexer, cassetteOptions) {
+  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
+      };
+      await fs$1.mkdir(vcrConfig.cassetteDir, { recursive: true });
+      const filePath = path.join(
+        vcrConfig.cassetteDir,
+        `${cassetteOptions.name}.json`
+      );
+      await fs$1.writeFile(filePath, serialize(output), { flag: "w" });
+    }
+  });
+  await run(client, indexer);
+}
+
+async function replay(vcrConfig, indexer, cassetteName) {
+  const client = loadCassette(vcrConfig, cassetteName);
+  await run(client, indexer);
+}
+function loadCassette(vcrConfig, cassetteName) {
+  const filePath = path.join(vcrConfig.cassetteDir, `${cassetteName}.json`);
+  const data = fs.readFileSync(filePath, "utf8");
+  const cassetteData = deserialize(data);
+  const { filter, messages } = cassetteData;
+  return new MockClient((request, options) => {
+    assert.deepStrictEqual(
+      request.filter,
+      [filter],
+      "Indexer and cassette filter mismatch. Hint: delete the cassette and run again."
+    );
+    return messages;
+  });
+}
+
+export { deserialize, isCassetteAvailable, loadCassette, record, replay, serialize };

package/package.json

@@ -1,9 +1,14 @@
 {
   "name": "@apibara/indexer",
-  "version": "2.0.0-beta.3",
+  "version": "2.0.0-beta.31",
   "type": "module",
-  "source": "./src/index.ts",
+  "files": [
+    "dist",
+    "src",
+    "README.md"
+  ],
   "main": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
@@ -11,56 +16,51 @@
       "require": "./dist/index.cjs",
       "default": "./dist/index.mjs"
     },
-    "./sinks/sqlite": {
-      "types": "./dist/sinks/sqlite.d.ts",
-      "import": "./dist/sinks/sqlite.mjs",
-      "require": "./dist/sinks/sqlite.cjs",
-      "default": "./dist/sinks/sqlite.mjs"
-    },
-    "./sinks/csv": {
-      "types": "./dist/sinks/csv.d.ts",
-      "import": "./dist/sinks/csv.mjs",
-      "require": "./dist/sinks/csv.cjs",
-      "default": "./dist/sinks/csv.mjs"
-    },
-    "./sinks/drizzle": {
-      "types": "./dist/sinks/drizzle/index.d.ts",
-      "import": "./dist/sinks/drizzle/index.mjs",
-      "require": "./dist/sinks/drizzle/index.cjs",
-      "default": "./dist/sinks/drizzle/index.mjs"
-    },
     "./testing": {
       "types": "./dist/testing/index.d.ts",
       "import": "./dist/testing/index.mjs",
       "require": "./dist/testing/index.cjs",
       "default": "./dist/testing/index.mjs"
+    },
+    "./vcr": {
+      "types": "./dist/vcr/index.d.ts",
+      "import": "./dist/vcr/index.mjs",
+      "require": "./dist/vcr/index.cjs",
+      "default": "./dist/vcr/index.mjs"
+    },
+    "./plugins": {
+      "types": "./dist/plugins/index.d.ts",
+      "import": "./dist/plugins/index.mjs",
+      "require": "./dist/plugins/index.cjs",
+      "default": "./dist/plugins/index.mjs"
+    },
+    "./internal": {
+      "types": "./dist/internal/testing.d.ts",
+      "import": "./dist/internal/testing.mjs",
+      "require": "./dist/internal/testing.cjs",
+      "default": "./dist/internal/testing.mjs"
     }
   },
-  "publishConfig": {},
   "scripts": {
     "build": "unbuild",
-    "lint": "biome check .",
     "typecheck": "tsc --noEmit",
+    "lint": "biome check .",
     "lint:fix": "pnpm lint --write",
     "test": "vitest",
-    "test:ci": "vitest run",
-    "format": "biome format . --write"
+    "test:ci": "vitest run"
   },
   "devDependencies": {
+    "@electric-sql/pglite": "^0.2.14",
     "@types/better-sqlite3": "^7.6.11",
     "@types/node": "^20.14.0",
     "@types/pg": "^8.11.10",
-    "better-sqlite3": "^11.1.2",
-    "csv-stringify": "^6.5.0",
-    "drizzle-orm": "^0.33.0",
-    "pg": "^8.12.0",
-    "postgres-range": "^1.1.4",
     "unbuild": "^2.0.0",
     "vitest": "^1.6.0"
   },
   "dependencies": {
-    "@apibara/protocol": "2.0.0-beta.3",
+    "@apibara/protocol": "2.0.0-beta.31",
     "@opentelemetry/api": "^1.9.0",
+    "ci-info": "^4.1.0",
     "consola": "^3.2.3",
     "hookable": "^5.5.3",
     "klona": "^2.0.6",
@@ -68,16 +68,6 @@
     "unctx": "^2.3.1"
   },
   "peerDependencies": {
-    "better-sqlite3": "^11.1.2",
-    "csv-stringify": "^6.5.0",
-    "drizzle-orm": "^0.33.0",
-    "postgres-range": "^1.1.4",
     "vitest": "^1.6.0"
-  },
-  "files": [
-    "dist",
-    "src",
-    "README.md"
-  ],
-  "types": "./dist/index.d.ts"
+  }
 }

package/src/compose.test.ts

@@ -0,0 +1,76 @@
+import { describe, expect, it } from "vitest";
+import { type MiddlewareFunction, type NextFunction, compose } from "./compose";
+
+type C = {
+  bag: Record<string, unknown>;
+  finalized: boolean;
+};
+
+type MiddlewareTuple = MiddlewareFunction<C>;
+
+describe("compose", () => {
+  async function a(context: C, next: NextFunction) {
+    context.bag.log = "log";
+    await next();
+  }
+
+  async function b(context: C, next: NextFunction) {
+    await next();
+    context.bag.headers = "custom-header";
+  }
+
+  async function c(context: C, next: NextFunction) {
+    context.bag.xxx = "yyy";
+    await next();
+    context.bag.zzz = context.bag.xxx;
+  }
+
+  async function handler(context: C, next: NextFunction) {
+    context.bag.log = `${context.bag.log} message`;
+    await next();
+    context.bag.message = "new response";
+  }
+
+  const middleware: MiddlewareTuple[] = [];
+
+  middleware.push(a);
+  middleware.push(b);
+  middleware.push(c);
+  middleware.push(handler);
+
+  it("composes", async () => {
+    const context: C = {
+      bag: {},
+      finalized: false,
+    };
+
+    const composed = compose<C>(middleware);
+    await composed(context);
+
+    expect(context.bag.log).toBeDefined();
+    expect(context.bag.log).toBe("log message");
+    expect(context.bag.headers).toBe("custom-header");
+    expect(context.bag.xxx).toBe("yyy");
+    expect(context.bag.zzz).toBe("yyy");
+    expect(context.finalized).toBe(false);
+  });
+
+  it("accepts a next function", async () => {
+    const context: C = {
+      bag: {},
+      finalized: false,
+    };
+
+    const composed = compose<C>(middleware);
+    await composed(context, async () => {
+      context.finalized = true;
+    });
+
+    expect(context.bag.log).toBeDefined();
+    expect(context.bag.log).toBe("log message");
+    expect(context.bag.headers).toBe("custom-header");
+    expect(context.bag.xxx).toBe("yyy");
+    expect(context.bag.zzz).toBe("yyy");
+    expect(context.finalized).toBe(true);
+  });
+});