@apibara/plugin-drizzle 2.0.0-beta.27

package/README.md

@@ -0,0 +1,7 @@
+# `@apibara/plugin-drizzle`
+
+TODO
+
+## Installation
+
+TODO

package/dist/index.cjs

@@ -0,0 +1,14 @@
+'use strict';
+
+class DrizzleStorageError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "DrizzleStorageError";
+  }
+}
+
+function drizzleStorage() {
+  throw new DrizzleStorageError("Not implemented");
+}
+
+exports.drizzleStorage = drizzleStorage;

package/dist/index.d.cts

@@ -0,0 +1,3 @@
+declare function drizzleStorage<TFilter, TBlock>(): void;
+
+export { drizzleStorage };

package/dist/index.d.mts

@@ -0,0 +1,3 @@
+declare function drizzleStorage<TFilter, TBlock>(): void;
+
+export { drizzleStorage };

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+declare function drizzleStorage<TFilter, TBlock>(): void;
+
+export { drizzleStorage };

package/dist/index.mjs

@@ -0,0 +1,12 @@
+class DrizzleStorageError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "DrizzleStorageError";
+  }
+}
+
+function drizzleStorage() {
+  throw new DrizzleStorageError("Not implemented");
+}
+
+export { drizzleStorage };

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@apibara/plugin-drizzle",
+  "version": "2.0.0-beta.27",
+  "type": "module",
+  "files": [
+    "dist",
+    "src",
+    "README.md"
+  ],
+  "main": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs",
+      "default": "./dist/index.mjs"
+    }
+  },
+  "scripts": {
+    "build": "unbuild",
+    "typecheck": "tsc --noEmit",
+    "lint": "biome check .",
+    "lint:fix": "pnpm lint --write",
+    "test": "vitest",
+    "test:ci": "vitest run"
+  },
+  "devDependencies": {
+    "@electric-sql/pglite": "^0.2.14",
+    "@types/node": "^20.14.0",
+    "unbuild": "^2.0.0",
+    "vitest": "^1.6.0"
+  },
+  "dependencies": {
+    "@apibara/indexer": "2.0.0-beta.28",
+    "@apibara/protocol": "2.0.0-beta.28",
+    "drizzle-orm": "^0.37.0",
+    "pg": "^8.13.1",
+    "postgres-range": "^1.1.4"
+  }
+}

package/src/index.ts

@@ -0,0 +1,5 @@
+import { DrizzleStorageError } from "./utils";
+
+export function drizzleStorage<TFilter, TBlock>() {
+  throw new DrizzleStorageError("Not implemented");
+}

package/src/persistence.test.ts

@@ -0,0 +1,7 @@
+import { describe, expect, it } from "vitest";
+
+describe("drizzleStorage", () => {
+  it("should be implemented", () => {
+    expect(true).toBe(true);
+  });
+});

package/src/persistence.ts

@@ -0,0 +1,194 @@
+/*
+import type { Cursor } from "@apibara/protocol";
+import {
+  type ExtractTablesWithRelations,
+  type TablesRelationalConfig,
+  and,
+  eq,
+  isNull,
+} from "drizzle-orm";
+import {
+  type PgDatabase,
+  type PgQueryResultHKT,
+  integer,
+  pgTable,
+  primaryKey,
+  text,
+} from "drizzle-orm/pg-core";
+import { deserialize, serialize } from "../vcr";
+import { defineIndexerPlugin } from "./config";
+
+export const checkpoints = pgTable("checkpoints", {
+  id: text("id").notNull().primaryKey(),
+  orderKey: integer("order_key").notNull(),
+  uniqueKey: text("unique_key")
+    .$type<`0x${string}` | undefined>()
+    .notNull()
+    .default(undefined),
+});
+
+export const filters = pgTable(
+  "filters",
+  {
+    id: text("id").notNull(),
+    filter: text("filter").notNull(),
+    fromBlock: integer("from_block").notNull(),
+    toBlock: integer("to_block"),
+  },
+  (table) => ({
+    pk: primaryKey({ columns: [table.id, table.fromBlock] }),
+  }),
+);
+
+export function drizzlePersistence<
+  TFilter,
+  TBlock,
+  TTxnParams,
+  TQueryResult extends PgQueryResultHKT,
+  TFullSchema extends Record<string, unknown> = Record<string, never>,
+  TSchema extends
+    TablesRelationalConfig = ExtractTablesWithRelations<TFullSchema>,
+>({
+  database,
+  indexerName = "default",
+}: {
+  database: PgDatabase<TQueryResult, TFullSchema, TSchema>;
+  indexerName?: string;
+}) {
+  return defineIndexerPlugin<TFilter, TBlock, TTxnParams>((indexer) => {
+    let store: DrizzlePersistence<TFilter, TQueryResult, TFullSchema, TSchema>;
+
+    indexer.hooks.hook("run:before", async () => {
+      store = new DrizzlePersistence(database, indexerName);
+      // Tables are created by user via migrations in Drizzle
+    });
+
+    indexer.hooks.hook("connect:before", async ({ request }) => {
+      const { cursor, filter } = await store.get();
+
+      if (cursor) {
+        request.startingCursor = cursor;
+      }
+
+      if (filter) {
+        request.filter[1] = filter;
+      }
+    });
+
+    indexer.hooks.hook("transaction:commit", async ({ endCursor }) => {
+      if (endCursor) {
+        await store.put({ cursor: endCursor });
+      }
+    });
+
+    indexer.hooks.hook("connect:factory", async ({ request, endCursor }) => {
+      if (request.filter[1]) {
+        await store.put({ cursor: endCursor, filter: request.filter[1] });
+      }
+    });
+  });
+}
+
+export class DrizzlePersistence<
+  TFilter,
+  TQueryResult extends PgQueryResultHKT,
+  TFullSchema extends Record<string, unknown> = Record<string, never>,
+  TSchema extends
+    TablesRelationalConfig = ExtractTablesWithRelations<TFullSchema>,
+> {
+  constructor(
+    private _db: PgDatabase<TQueryResult, TFullSchema, TSchema>,
+    private _indexerName: string,
+  ) {}
+
+  public async get(): Promise<{ cursor?: Cursor; filter?: TFilter }> {
+    const cursor = await this._getCheckpoint();
+    const filter = await this._getFilter();
+
+    return { cursor, filter };
+  }
+
+  public async put({ cursor, filter }: { cursor?: Cursor; filter?: TFilter }) {
+    if (cursor) {
+      await this._putCheckpoint(cursor);
+
+      if (filter) {
+        await this._putFilter(filter, cursor);
+      }
+    }
+  }
+
+  // --- CHECKPOINTS TABLE METHODS ---
+
+  private async _getCheckpoint(): Promise<Cursor | undefined> {
+    const rows = await this._db
+      .select()
+      .from(checkpoints)
+      .where(eq(checkpoints.id, this._indexerName));
+
+    const row = rows[0];
+    if (!row) return undefined;
+
+    return {
+      orderKey: BigInt(row.orderKey),
+      uniqueKey: row.uniqueKey,
+    };
+  }
+
+  private async _putCheckpoint(cursor: Cursor) {
+    await this._db
+      .insert(checkpoints)
+      .values({
+        id: this._indexerName,
+        orderKey: Number(cursor.orderKey),
+        uniqueKey: cursor.uniqueKey,
+      })
+      .onConflictDoUpdate({
+        target: checkpoints.id,
+        set: {
+          orderKey: Number(cursor.orderKey),
+          uniqueKey: cursor.uniqueKey,
+        },
+      });
+  }
+
+  // --- FILTERS TABLE METHODS ---
+
+  private async _getFilter(): Promise<TFilter | undefined> {
+    const rows = await this._db
+      .select()
+      .from(filters)
+      .where(and(eq(filters.id, this._indexerName), isNull(filters.toBlock)));
+
+    const row = rows[0];
+
+    if (!row) return undefined;
+
+    return deserialize(row.filter) as TFilter;
+  }
+
+  private async _putFilter(filter: TFilter, endCursor: Cursor) {
+    // Update existing filter's to_block
+    await this._db
+      .update(filters)
+      .set({ toBlock: Number(endCursor.orderKey) })
+      .where(and(eq(filters.id, this._indexerName), isNull(filters.toBlock)));
+
+    // Insert new filter
+    await this._db
+      .insert(filters)
+      .values({
+        id: this._indexerName,
+        filter: serialize(filter as Record<string, unknown>),
+        fromBlock: Number(endCursor.orderKey),
+      })
+      .onConflictDoUpdate({
+        target: [filters.id, filters.fromBlock],
+        set: {
+          filter: serialize(filter as Record<string, unknown>),
+          fromBlock: Number(endCursor.orderKey),
+        },
+      });
+  }
+}
+*/

package/src/utils.ts

@@ -0,0 +1,6 @@
+export class DrizzleStorageError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "DrizzleStorageError";
+  }
+}