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

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";

package/src/indexer.test.ts

@@ -1,15 +1,37 @@
+import type { Cursor, DataFinality } from "@apibara/protocol";
 import {
   type MockBlock,
   MockClient,
   type MockFilter,
 } from "@apibara/protocol/testing";
-import Database from "better-sqlite3";
 import { describe, expect, it } from "vitest";
-import { useSink } from "./hooks";
+import { type IndexerContext, useMessageMetadataContext } from "./context";
 import { run } from "./indexer";
-import { SqlitePersistence, sqlitePersistence } from "./plugins/persistence";
-import { generateMockMessages, vcr } from "./testing";
-import { getMockIndexer } from "./testing/indexer";
+import {
+  generateMockMessages,
+  getMockIndexer,
+  mockSink,
+  useMockSink,
+} from "./internal/testing";
+
+async function transform<TData>({
+  block: { data },
+}: {
+  block: { data?: TData };
+  cursor?: Cursor;
+  endCursor?: Cursor;
+  finality?: DataFinality;
+  context: IndexerContext;
+}) {
+  const { cursor, endCursor, finality } = useMessageMetadataContext();
+  const { output } = useMockSink();
+  output.push({
+    data,
+    cursor: cursor?.orderKey,
+    endCursor: endCursor?.orderKey,
+    finality,
+  });
+}
 
 describe("Run Test", () => {
   it("should stream messages", async () => {
@@ -17,121 +39,78 @@ describe("Run Test", () => {
       return generateMockMessages();
     });
 
-    const sink = vcr();
+    const output: unknown[] = [];
 
     const indexer = getMockIndexer({
-      sink,
       override: {
-        transform: async ({ context, endCursor, block: { data } }) => {
-          const { writer } = useSink({ context });
-          writer.insert([{ data }]);
-        },
+        plugins: [mockSink({ output })],
+        transform,
       },
     });
 
     await run(client, indexer);
 
-    expect(sink.result).toMatchInlineSnapshot(`
+    expect(output).toMatchInlineSnapshot(`
       [
         {
-          "data": [
-            {
-              "data": "5000000",
-            },
-          ],
-          "endCursor": {
-            "orderKey": 5000000n,
-          },
+          "cursor": 4999999n,
+          "data": "5000000",
+          "endCursor": 5000000n,
+          "finality": "accepted",
         },
         {
-          "data": [
-            {
-              "data": "5000001",
-            },
-          ],
-          "endCursor": {
-            "orderKey": 5000001n,
-          },
+          "cursor": 5000000n,
+          "data": "5000001",
+          "endCursor": 5000001n,
+          "finality": "accepted",
         },
         {
-          "data": [
-            {
-              "data": "5000002",
-            },
-          ],
-          "endCursor": {
-            "orderKey": 5000002n,
-          },
+          "cursor": 5000001n,
+          "data": "5000002",
+          "endCursor": 5000002n,
+          "finality": "accepted",
         },
         {
-          "data": [
-            {
-              "data": "5000003",
-            },
-          ],
-          "endCursor": {
-            "orderKey": 5000003n,
-          },
+          "cursor": 5000002n,
+          "data": "5000003",
+          "endCursor": 5000003n,
+          "finality": "accepted",
         },
         {
-          "data": [
-            {
-              "data": "5000004",
-            },
-          ],
-          "endCursor": {
-            "orderKey": 5000004n,
-          },
+          "cursor": 5000003n,
+          "data": "5000004",
+          "endCursor": 5000004n,
+          "finality": "accepted",
         },
         {
-          "data": [
-            {
-              "data": "5000005",
-            },
-          ],
-          "endCursor": {
-            "orderKey": 5000005n,
-          },
+          "cursor": 5000004n,
+          "data": "5000005",
+          "endCursor": 5000005n,
+          "finality": "accepted",
         },
         {
-          "data": [
-            {
-              "data": "5000006",
-            },
-          ],
-          "endCursor": {
-            "orderKey": 5000006n,
-          },
+          "cursor": 5000005n,
+          "data": "5000006",
+          "endCursor": 5000006n,
+          "finality": "accepted",
         },
         {
-          "data": [
-            {
-              "data": "5000007",
-            },
-          ],
-          "endCursor": {
-            "orderKey": 5000007n,
-          },
+          "cursor": 5000006n,
+          "data": "5000007",
+          "endCursor": 5000007n,
+          "finality": "accepted",
         },
         {
-          "data": [
-            {
-              "data": "5000008",
-            },
-          ],
-          "endCursor": {
-            "orderKey": 5000008n,
-          },
+          "cursor": 5000007n,
+          "data": "5000008",
+          "endCursor": 5000008n,
+          "finality": "accepted",
         },
         {
-          "data": [
-            {
-              "data": "5000009",
-            },
-          ],
-          "endCursor": {
-            "orderKey": 5000009n,
-          },
+          "cursor": 5000008n,
+          "data": "5000009",
+          "endCursor": 5000009n,
+          "finality": "accepted",
         },
       ]
     `);
@@ -255,18 +234,11 @@ describe("Run Test", () => {
       return [];
     });
 
-    const db = Database(":memory:");
+    const output: unknown[] = [];
+    const metadata: Record<string, unknown> = {};
 
-    const sink = vcr();
-
-    // create mock indexer with persistence plugin
     const indexer = getMockIndexer({
-      plugins: [
-        sqlitePersistence({
-          database: db,
-        }),
-      ],
-      sink,
+      plugins: [mockSink({ output, metadata })],
       override: {
         startingCursor: { orderKey: 100n },
         factory: async ({ block }) => {
@@ -280,88 +252,55 @@ describe("Run Test", () => {
 
           return {};
         },
-        transform: async ({ context, endCursor, block: { data } }) => {
-          const { writer } = useSink({ context });
-          writer.insert([{ data }]);
-        },
+        transform,
       },
     });
 
     await run(client, indexer);
 
-    const store = new SqlitePersistence<MockFilter>(db);
-
-    const latest = store.get();
+    expect((metadata.lastCursor as Cursor).orderKey).toEqual(108n);
+    expect((metadata.lastFilter as { filter: unknown }).filter).toEqual("BC");
 
-    expect(latest.cursor?.orderKey).toEqual(108n);
-    expect(latest.filter?.filter).toEqual("BC");
-
-    expect(sink.result).toMatchInlineSnapshot(`
+    expect(output).toMatchInlineSnapshot(`
       [
         {
-          "data": [
-            {
-              "data": "103B",
-            },
-          ],
-          "endCursor": {
-            "orderKey": 103n,
-          },
+          "cursor": 102n,
+          "data": "103B",
+          "endCursor": 103n,
+          "finality": "accepted",
         },
         {
-          "data": [
-            {
-              "data": "104B",
-            },
-          ],
-          "endCursor": {
-            "orderKey": 104n,
-          },
+          "cursor": 103n,
+          "data": "104B",
+          "endCursor": 104n,
+          "finality": "accepted",
         },
         {
-          "data": [
-            {
-              "data": "105B",
-            },
-          ],
-          "endCursor": {
-            "orderKey": 105n,
-          },
+          "cursor": 104n,
+          "data": "105B",
+          "endCursor": 105n,
+          "finality": "accepted",
         },
         {
-          "data": [
-            {
-              "data": "106BC",
-            },
-          ],
-          "endCursor": {
-            "orderKey": 106n,
-          },
+          "cursor": 105n,
+          "data": "106BC",
+          "endCursor": 106n,
+          "finality": "accepted",
         },
         {
-          "data": [
-            {
-              "data": "107BC",
-            },
-          ],
-          "endCursor": {
-            "orderKey": 107n,
-          },
+          "cursor": 106n,
+          "data": "107BC",
+          "endCursor": 107n,
+          "finality": "accepted",
         },
         {
-          "data": [
-            {
-              "data": "108BC",
-            },
-          ],
-          "endCursor": {
-            "orderKey": 108n,
-          },
+          "cursor": 107n,
+          "data": "108BC",
+          "endCursor": 108n,
+          "finality": "accepted",
         },
       ]
     `);
-
-    db.close();
   });
 
   it("factory mode: last cursor should persist when error is thrown in indexer", async () => {
@@ -441,18 +380,11 @@ describe("Run Test", () => {
       return [];
     });
 
-    const db = Database(":memory:");
+    const output: unknown[] = [];
+    const metadata: Record<string, unknown> = {};
 
-    const sink = vcr();
-
-    // create mock indexer with persistence plugin
     const indexer = getMockIndexer({
-      plugins: [
-        sqlitePersistence({
-          database: db,
-        }),
-      ],
-      sink,
+      plugins: [mockSink({ output, metadata })],
       override: {
         startingCursor: { orderKey: 100n },
         factory: async ({ block }) => {
@@ -466,10 +398,7 @@ describe("Run Test", () => {
 
           return {};
         },
-        transform: async ({ context, endCursor, block: { data } }) => {
-          const { writer } = useSink({ context });
-          writer.insert([{ data }]);
-        },
+        transform,
       },
     });
 
@@ -477,15 +406,9 @@ describe("Run Test", () => {
       "this error should occurr!",
     );
 
-    const store = new SqlitePersistence<MockFilter>(db);
-
-    const latest = store.get();
-
-    expect(latest.cursor?.orderKey).toEqual(103n);
-    expect(latest.filter?.filter).toEqual("B");
-
-    expect(sink.result).toMatchInlineSnapshot("[]");
+    expect((metadata.lastCursor as Cursor).orderKey).toEqual(103n);
+    expect((metadata.lastFilter as { filter: unknown }).filter).toEqual("B");
 
-    db.close();
+    expect(output).toMatchInlineSnapshot("[]");
   });
 });