@apibara/indexer 2.0.0-beta.4 → 2.0.0-beta.40

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.4",
+  "version": "2.0.0-beta.40",
   "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,63 @@
       "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/index.d.ts",
+      "import": "./dist/internal/index.mjs",
+      "require": "./dist/internal/index.cjs",
+      "default": "./dist/internal/index.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"
     }
   },
-  "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.4",
+    "@apibara/protocol": "2.0.0-beta.40",
     "@opentelemetry/api": "^1.9.0",
+    "ci-info": "^4.1.0",
     "consola": "^3.2.3",
     "hookable": "^5.5.3",
     "klona": "^2.0.6",
@@ -68,16 +80,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);
+  });
+});

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

package/src/context.ts

@@ -1,19 +1,25 @@
 import { AsyncLocalStorage } from "node:async_hooks";
+import type { Cursor, DataFinality } from "@apibara/protocol";
 import { getContext } from "unctx";
-import type { Sink } from "./sink";
 
 // biome-ignore lint/suspicious/noExplicitAny: context type
-export interface IndexerContext<TTxnParams = any> extends Record<string, any> {
-  sink?: Sink<TTxnParams>;
-  sinkTransaction?: TTxnParams;
-}
+export interface IndexerContext extends Record<string, any> {}
 
 export const indexerAsyncContext = getContext<IndexerContext>("indexer", {
   asyncContext: true,
   AsyncLocalStorage,
 });
 
-// biome-ignore lint/suspicious/noExplicitAny: <explanation>
-export function useIndexerContext<TTxnParams = any>() {
-  return indexerAsyncContext.use() as IndexerContext<TTxnParams>;
+export function useIndexerContext() {
+  return indexerAsyncContext.use() as IndexerContext;
+}
+
+export interface MessageMetadataContext extends IndexerContext {
+  cursor?: Cursor;
+  endCursor?: Cursor;
+  finality?: DataFinality;
+}
+
+export function useMessageMetadataContext(): MessageMetadataContext {
+  return useIndexerContext() as MessageMetadataContext;
 }

package/src/index.ts

@@ -1,7 +1,2 @@
 export * from "./indexer";
-export * from "./sink";
 export { useIndexerContext } from "./context";
-
-export * from "./plugins";
-export * from "./vcr";
-export * from "./hooks";