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

package/dist/testing/index.mjs

@@ -1,60 +1,60 @@
-import { test as test$1 } from 'vitest';
-import { i as isCassetteAvailable } from '../shared/indexer.2c23c9cd.mjs';
-import { l as loadCassette, a as record, b as replay } from '../shared/indexer.36530330.mjs';
-export { V as VcrSink, v as vcr } from '../shared/indexer.36530330.mjs';
+import { createClient } from '@apibara/protocol';
+import ci from 'ci-info';
+import { createIndexer } from '../index.mjs';
+import { internalContext } from '../internal/plugins.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 'node:fs';
-import 'node:path';
+import '../shared/indexer.9b21ddd2.mjs';
 import 'node:fs/promises';
-import 'klona/full';
-import 'consola';
-import 'hookable';
-import 'node:assert';
-import '../shared/indexer.93d6b2eb.mjs';
+import 'node:path';
+import 'node:fs';
 import '@apibara/protocol/testing';
 
-const test = test$1.extend({
-  vcr: {
-    withClient
-  }
-});
-async function withClient(cassetteName, range, callback) {
-  const vcrConfig = {
-    cassetteDir: "cassettes"
-  };
-  const cassetteOptions = {
-    name: cassetteName,
-    startingCursor: {
-      orderKey: range.fromBlock
-    },
-    endingCursor: {
-      orderKey: range.toBlock
-    }
-  };
-  const context = {
-    async run(indexer) {
-      const client = loadCassette(vcrConfig, cassetteName);
+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 = [
+        internalContext({
+          indexerName: cassetteName,
+          availableIndexers: [cassetteName]
+        }),
+        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);
       }
-      return await replay(vcrConfig, indexer, cassetteName);
     }
   };
-  await callback(context);
-}
-
-function generateMockMessages(count = 10) {
-  return [...Array(count)].map((_, i) => ({
-    _tag: "data",
-    data: {
-      cursor: { orderKey: BigInt(5e6 - 1) },
-      finality: "accepted",
-      data: [{ data: `${5e6 + i}` }],
-      endCursor: { orderKey: BigInt(5e6 + i) }
-    }
-  }));
 }
 
-export { generateMockMessages, test };
+export { createVcr };

package/dist/vcr/index.cjs

@@ -1,25 +1,92 @@
 'use strict';
 
-const helper = require('../shared/indexer.318d3617.cjs');
-const vcr_index = require('../shared/indexer.541d43eb.cjs');
+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');
-require('node:fs');
-require('node:path');
-require('node:fs/promises');
-require('klona/full');
-require('consola');
-require('hookable');
-require('node:assert');
-require('../shared/indexer.a8b7ab1f.cjs');
-require('@apibara/protocol/testing');
 
+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 = helper.deserialize;
-exports.isCassetteAvailable = helper.isCassetteAvailable;
-exports.serialize = helper.serialize;
-exports.loadCassette = vcr_index.loadCassette;
-exports.record = vcr_index.record;
-exports.replay = vcr_index.replay;
+exports.deserialize = deserialize;
+exports.isCassetteAvailable = isCassetteAvailable;
+exports.loadCassette = loadCassette;
+exports.record = record;
+exports.replay = replay;
+exports.serialize = serialize;

package/dist/vcr/index.d.cts

@@ -1,10 +1,16 @@
-import { V as VcrConfig, C as CassetteOptions } from '../shared/indexer.500fd281.cjs';
-export { a as VcrReplayResult, l as loadCassette, r as replay } from '../shared/indexer.500fd281.cjs';
-import { StreamDataResponse, Client } from '@apibara/protocol';
-import { f as Indexer } from '../shared/indexer.c7ed6b83.cjs';
-import '../shared/indexer.b9c8f0d8.cjs';
+import { Cursor, StreamDataResponse, Client } from '@apibara/protocol';
+import { a as Indexer } from '../shared/indexer.fedcd831.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;
@@ -13,6 +19,9 @@ type CassetteDataType<TFilter, TBlock> = {
     filter: TFilter;
     messages: StreamDataResponse<TBlock>[];
 };
-declare function record<TFilter, TBlock, TTxnParams>(vcrConfig: VcrConfig, client: Client<TFilter, TBlock>, indexerArg: Indexer<TFilter, TBlock, TTxnParams>, cassetteOptions: CassetteOptions): Promise<void>;
+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, CassetteOptions, VcrConfig, deserialize, isCassetteAvailable, record, serialize };
+export { type CassetteDataType, type CassetteOptions, type VcrConfig, deserialize, isCassetteAvailable, loadCassette, record, replay, serialize };

package/dist/vcr/index.d.mts

@@ -1,10 +1,16 @@
-import { V as VcrConfig, C as CassetteOptions } from '../shared/indexer.e1856641.mjs';
-export { a as VcrReplayResult, l as loadCassette, r as replay } from '../shared/indexer.e1856641.mjs';
-import { StreamDataResponse, Client } from '@apibara/protocol';
-import { f as Indexer } from '../shared/indexer.e8bd138d.mjs';
-import '../shared/indexer.b9c8f0d8.mjs';
+import { Cursor, StreamDataResponse, Client } from '@apibara/protocol';
+import { a as Indexer } from '../shared/indexer.fedcd831.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;
@@ -13,6 +19,9 @@ type CassetteDataType<TFilter, TBlock> = {
     filter: TFilter;
     messages: StreamDataResponse<TBlock>[];
 };
-declare function record<TFilter, TBlock, TTxnParams>(vcrConfig: VcrConfig, client: Client<TFilter, TBlock>, indexerArg: Indexer<TFilter, TBlock, TTxnParams>, cassetteOptions: CassetteOptions): Promise<void>;
+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, CassetteOptions, VcrConfig, deserialize, isCassetteAvailable, record, serialize };
+export { type CassetteDataType, type CassetteOptions, type VcrConfig, deserialize, isCassetteAvailable, loadCassette, record, replay, serialize };

package/dist/vcr/index.d.ts

@@ -1,10 +1,16 @@
-import { V as VcrConfig, C as CassetteOptions } from '../shared/indexer.e4f2430f.js';
-export { a as VcrReplayResult, l as loadCassette, r as replay } from '../shared/indexer.e4f2430f.js';
-import { StreamDataResponse, Client } from '@apibara/protocol';
-import { f as Indexer } from '../shared/indexer.f761abcd.js';
-import '../shared/indexer.b9c8f0d8.js';
+import { Cursor, StreamDataResponse, Client } from '@apibara/protocol';
+import { a as Indexer } from '../shared/indexer.fedcd831.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;
@@ -13,6 +19,9 @@ type CassetteDataType<TFilter, TBlock> = {
     filter: TFilter;
     messages: StreamDataResponse<TBlock>[];
 };
-declare function record<TFilter, TBlock, TTxnParams>(vcrConfig: VcrConfig, client: Client<TFilter, TBlock>, indexerArg: Indexer<TFilter, TBlock, TTxnParams>, cassetteOptions: CassetteOptions): Promise<void>;
+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, CassetteOptions, VcrConfig, deserialize, isCassetteAvailable, record, serialize };
+export { type CassetteDataType, type CassetteOptions, type VcrConfig, deserialize, isCassetteAvailable, loadCassette, record, replay, serialize };

package/dist/vcr/index.mjs

@@ -1,14 +1,78 @@
-export { d as deserialize, i as isCassetteAvailable, s as serialize } from '../shared/indexer.2c23c9cd.mjs';
-export { l as loadCassette, a as record, b as replay } from '../shared/indexer.36530330.mjs';
+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';
-import 'node:fs';
-import 'node:path';
-import 'node:fs/promises';
-import 'klona/full';
-import 'consola';
-import 'hookable';
-import 'node:assert';
-import '../shared/indexer.93d6b2eb.mjs';
-import '@apibara/protocol/testing';
+
+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,6 +1,6 @@
 {
   "name": "@apibara/indexer",
-  "version": "2.0.0-beta.9",
+  "version": "2.1.0-beta.2",
   "type": "module",
   "files": [
     "dist",
@@ -16,24 +16,6 @@
       "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",
@@ -52,43 +34,45 @@
       "require": "./dist/plugins/index.cjs",
       "default": "./dist/plugins/index.mjs"
     },
-    "./plugins/kv": {
-      "types": "./dist/plugins/kv.d.ts",
-      "import": "./dist/plugins/kv.mjs",
-      "require": "./dist/plugins/kv.cjs",
-      "default": "./dist/plugins/kv.mjs"
+    "./internal": {
+      "types": "./dist/internal/index.d.ts",
+      "import": "./dist/internal/index.mjs",
+      "require": "./dist/internal/index.cjs",
+      "default": "./dist/internal/index.mjs"
     },
-    "./plugins/persistence": {
-      "types": "./dist/plugins/persistence.d.ts",
-      "import": "./dist/plugins/persistence.mjs",
-      "require": "./dist/plugins/persistence.cjs",
-      "default": "./dist/plugins/persistence.mjs"
+    "./internal/testing": {
+      "types": "./dist/internal/testing.d.ts",
+      "import": "./dist/internal/testing.mjs",
+      "require": "./dist/internal/testing.cjs",
+      "default": "./dist/internal/testing.mjs"
+    },
+    "./internal/plugins": {
+      "types": "./dist/internal/plugins.d.ts",
+      "import": "./dist/internal/plugins.mjs",
+      "require": "./dist/internal/plugins.cjs",
+      "default": "./dist/internal/plugins.mjs"
     }
   },
   "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.17",
     "@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.35.2",
-    "pg": "^8.12.0",
-    "postgres-range": "^1.1.4",
     "unbuild": "^2.0.0",
     "vitest": "^1.6.0"
   },
   "dependencies": {
-    "@apibara/protocol": "2.0.0-beta.9",
+    "@apibara/protocol": "2.1.0-beta.2",
     "@opentelemetry/api": "^1.9.0",
+    "ci-info": "^4.1.0",
     "consola": "^3.2.3",
     "hookable": "^5.5.3",
     "klona": "^2.0.6",
@@ -96,10 +80,6 @@
     "unctx": "^2.3.1"
   },
   "peerDependencies": {
-    "better-sqlite3": "^11.1.2",
-    "csv-stringify": "^6.5.0",
-    "drizzle-orm": "^0.35.2",
-    "postgres-range": "^1.1.4",
     "vitest": "^1.6.0"
   }
 }

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);
+  });
+});

package/src/compose.ts

@@ -0,0 +1,71 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2021 - present, Yusuke Wada and Hono contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+import type { IndexerContext } from "./context";
+
+export type NextFunction = () => Promise<void>;
+export type MiddlewareFunction<C> = (
+  context: C,
+  next: NextFunction,
+) => Promise<void>;
+
+export function compose<C extends IndexerContext>(
+  middleware: MiddlewareFunction<C>[],
+): (context: C, next?: NextFunction) => Promise<void> {
+  return (context, next) => {
+    let index = -1;
+
+    return dispatch(0);
+
+    /// Dispatch the middleware functions.
+    async function dispatch(i: number): Promise<void> {
+      if (i <= index) {
+        throw new Error("next() called multiple times");
+      }
+      index = i;
+
+      let handler: MiddlewareFunction<C> | undefined;
+
+      if (i >= middleware.length) {
+        if (next) {
+          await next();
+        }
+
+        return;
+      }
+
+      if (middleware[i]) {
+        handler = middleware[i];
+      } else {
+        handler = i === middleware.length ? next : undefined;
+      }
+
+      if (!handler) {
+        throw new Error("Handler not found");
+      }
+
+      await handler(context, () => dispatch(i + 1));
+    }
+  };
+}