@apibara/plugin-mongo 2.0.0-beta.28

package/README.md

@@ -0,0 +1,7 @@
+# `@apibara/sink-mongo`
+
+TODO
+
+## Installation
+
+TODO

package/dist/index.cjs

@@ -0,0 +1,292 @@
+'use strict';
+
+const indexer = require('@apibara/indexer');
+const plugins = require('@apibara/indexer/plugins');
+
+async function invalidate(db, session, cursor, collections) {
+  const orderKeyValue = Number(cursor.orderKey);
+  for (const collection of collections) {
+    await db.collection(collection).deleteMany(
+      {
+        "_cursor.from": {
+          $gt: orderKeyValue
+        }
+      },
+      { session }
+    );
+    await db.collection(collection).updateMany(
+      { "_cursor.to": { $gt: orderKeyValue } },
+      {
+        $set: {
+          "_cursor.to": null
+        }
+      },
+      { session }
+    );
+  }
+}
+async function finalize(db, session, cursor, collections) {
+  const orderKeyValue = Number(cursor.orderKey);
+  for (const collection of collections) {
+    await db.collection(collection).deleteMany(
+      {
+        "_cursor.to": { $lt: orderKeyValue }
+      },
+      { session }
+    );
+  }
+}
+
+class MongoStorage {
+  constructor(db, session, endCursor) {
+    this.db = db;
+    this.session = session;
+    this.endCursor = endCursor;
+  }
+  collection(name, options) {
+    const collection = this.db.collection(name, options);
+    return new MongoCollection(
+      this.session,
+      collection,
+      this.endCursor
+    );
+  }
+}
+class MongoCollection {
+  constructor(session, collection, endCursor) {
+    this.session = session;
+    this.collection = collection;
+    this.endCursor = endCursor;
+  }
+  async insertOne(doc, options) {
+    return await this.collection.insertOne(
+      {
+        ...doc,
+        _cursor: {
+          from: Number(this.endCursor?.orderKey),
+          to: null
+        }
+      },
+      { ...options, session: this.session }
+    );
+  }
+  async insertMany(docs, options) {
+    return await this.collection.insertMany(
+      docs.map((doc) => ({
+        ...doc,
+        _cursor: {
+          from: Number(this.endCursor?.orderKey),
+          to: null
+        }
+      })),
+      { ...options, session: this.session }
+    );
+  }
+  async updateOne(filter, update, options) {
+    const oldDoc = await this.collection.findOneAndUpdate(
+      {
+        ...filter,
+        "_cursor.to": null
+      },
+      {
+        ...update,
+        $set: {
+          ...update.$set,
+          "_cursor.from": Number(this.endCursor?.orderKey)
+        }
+      },
+      {
+        ...options,
+        session: this.session,
+        returnDocument: "before"
+      }
+    );
+    if (oldDoc) {
+      const { _id, ...doc } = oldDoc;
+      await this.collection.insertOne(
+        {
+          ...doc,
+          _cursor: {
+            ...oldDoc._cursor,
+            to: Number(this.endCursor?.orderKey)
+          }
+        },
+        { session: this.session }
+      );
+    }
+    return {
+      acknowledged: true,
+      modifiedCount: oldDoc ? 1 : 0,
+      upsertedId: null,
+      upsertedCount: 0,
+      matchedCount: oldDoc ? 1 : 0
+    };
+  }
+  async updateMany(filter, update, options) {
+    const oldDocs = await this.collection.find(
+      {
+        ...filter,
+        "_cursor.to": null
+      },
+      { session: this.session }
+    ).toArray();
+    const updateResult = await this.collection.updateMany(
+      {
+        ...filter,
+        "_cursor.to": null
+      },
+      {
+        ...update,
+        $set: {
+          ...update.$set,
+          "_cursor.from": Number(this.endCursor?.orderKey)
+        }
+      },
+      { ...options, session: this.session }
+    );
+    const oldDocsWithUpdatedCursor = oldDocs.map(({ _id, ...doc }) => ({
+      ...doc,
+      _cursor: {
+        ...doc._cursor,
+        to: Number(this.endCursor?.orderKey)
+      }
+    }));
+    if (oldDocsWithUpdatedCursor.length > 0) {
+      await this.collection.insertMany(
+        oldDocsWithUpdatedCursor,
+        { session: this.session }
+      );
+    }
+    return updateResult;
+  }
+  async deleteOne(filter, options) {
+    return await this.collection.updateOne(
+      {
+        ...filter,
+        "_cursor.to": null
+      },
+      {
+        $set: {
+          "_cursor.to": Number(this.endCursor?.orderKey)
+        }
+      },
+      { ...options, session: this.session }
+    );
+  }
+  async deleteMany(filter, options) {
+    return await this.collection.updateMany(
+      {
+        ...filter ?? {},
+        "_cursor.to": null
+      },
+      {
+        $set: {
+          "_cursor.to": Number(this.endCursor?.orderKey)
+        }
+      },
+      { ...options, session: this.session }
+    );
+  }
+  async findOne(filter, options) {
+    return await this.collection.findOne(
+      {
+        ...filter,
+        "_cursor.to": null
+      },
+      { ...options, session: this.session }
+    );
+  }
+  find(filter, options) {
+    return this.collection.find(
+      {
+        ...filter,
+        "_cursor.to": null
+      },
+      { ...options, session: this.session }
+    );
+  }
+}
+
+class MongoStorageError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "MongoStorageError";
+  }
+}
+async function withTransaction(client, cb) {
+  return await client.withSession(async (session) => {
+    return await session.withTransaction(async (session2) => {
+      return await cb(session2);
+    });
+  });
+}
+
+const MONGO_PROPERTY = "_mongo";
+function useMongoStorage() {
+  const context = indexer.useIndexerContext();
+  if (!context[MONGO_PROPERTY]) {
+    throw new MongoStorageError(
+      "mongo storage is not available. Did you register the plugin?"
+    );
+  }
+  return context[MONGO_PROPERTY];
+}
+function mongoStorage({
+  client,
+  dbName,
+  dbOptions,
+  collections,
+  persistState: enablePersistence = true
+}) {
+  return plugins.defineIndexerPlugin((indexer) => {
+    indexer.hooks.hook("message:finalize", async ({ message }) => {
+      const { cursor } = message.finalize;
+      if (!cursor) {
+        throw new MongoStorageError("finalized cursor is undefined");
+      }
+      await withTransaction(client, async (session) => {
+        const db = client.db(dbName, dbOptions);
+        await finalize(db, session, cursor, collections);
+      });
+    });
+    indexer.hooks.hook("message:invalidate", async ({ message }) => {
+      const { cursor } = message.invalidate;
+      if (!cursor) {
+        throw new MongoStorageError("invalidate cursor is undefined");
+      }
+      await withTransaction(client, async (session) => {
+        const db = client.db(dbName, dbOptions);
+        await invalidate(db, session, cursor, collections);
+      });
+    });
+    indexer.hooks.hook("connect:after", async ({ request }) => {
+      const cursor = request.startingCursor;
+      if (!cursor) {
+        return;
+      }
+      await withTransaction(client, async (session) => {
+        const db = client.db(dbName, dbOptions);
+        await invalidate(db, session, cursor, collections);
+      });
+    });
+    indexer.hooks.hook("handler:middleware", async ({ use }) => {
+      use(async (context, next) => {
+        const { endCursor } = context;
+        if (!endCursor) {
+          throw new MongoStorageError("end cursor is undefined");
+        }
+        await withTransaction(client, async (session) => {
+          const db = client.db(dbName, dbOptions);
+          context[MONGO_PROPERTY] = new MongoStorage(db, session, endCursor);
+          await next();
+          delete context[MONGO_PROPERTY];
+        });
+      });
+    });
+  });
+}
+
+exports.MongoCollection = MongoCollection;
+exports.MongoStorage = MongoStorage;
+exports.mongoStorage = mongoStorage;
+exports.useMongoStorage = useMongoStorage;

package/dist/index.d.cts

@@ -0,0 +1,37 @@
+import * as _apibara_indexer_plugins from '@apibara/indexer/plugins';
+import { Db, ClientSession, Document, CollectionOptions, Collection, OptionalUnlessRequiredId, InsertOneOptions, InsertOneResult, BulkWriteOptions, InsertManyResult, Filter, UpdateFilter, UpdateOptions, UpdateResult, DeleteOptions, FindOptions, WithId, FindCursor, MongoClient, DbOptions } from 'mongodb';
+import { Cursor } from '@apibara/protocol';
+
+declare class MongoStorage {
+    private db;
+    private session;
+    private endCursor?;
+    constructor(db: Db, session: ClientSession, endCursor?: Cursor | undefined);
+    collection<TSchema extends Document = Document>(name: string, options?: CollectionOptions): MongoCollection<TSchema>;
+}
+declare class MongoCollection<TSchema extends Document> {
+    private session;
+    private collection;
+    private endCursor?;
+    constructor(session: ClientSession, collection: Collection<TSchema>, endCursor?: Cursor | undefined);
+    insertOne(doc: OptionalUnlessRequiredId<TSchema>, options?: InsertOneOptions): Promise<InsertOneResult<TSchema>>;
+    insertMany(docs: ReadonlyArray<OptionalUnlessRequiredId<TSchema>>, options?: BulkWriteOptions): Promise<InsertManyResult<TSchema>>;
+    updateOne(filter: Filter<TSchema>, update: UpdateFilter<TSchema>, options?: UpdateOptions): Promise<UpdateResult<TSchema>>;
+    updateMany(filter: Filter<TSchema>, update: UpdateFilter<TSchema>, options?: UpdateOptions): Promise<UpdateResult<TSchema>>;
+    deleteOne(filter: Filter<TSchema>, options?: DeleteOptions): Promise<UpdateResult<TSchema>>;
+    deleteMany(filter?: Filter<TSchema>, options?: DeleteOptions): Promise<UpdateResult<TSchema>>;
+    findOne(filter: Filter<TSchema>, options?: Omit<FindOptions, "timeoutMode">): Promise<WithId<TSchema> | null>;
+    find(filter: Filter<TSchema>, options?: FindOptions): FindCursor<WithId<TSchema>>;
+}
+
+declare function useMongoStorage(): MongoStorage;
+interface MongoStorageOptions {
+    client: MongoClient;
+    dbName: string;
+    dbOptions?: DbOptions;
+    collections: string[];
+    persistState?: boolean;
+}
+declare function mongoStorage<TFilter, TBlock>({ client, dbName, dbOptions, collections, persistState: enablePersistence, }: MongoStorageOptions): _apibara_indexer_plugins.IndexerPlugin<TFilter, TBlock>;
+
+export { MongoCollection, MongoStorage, type MongoStorageOptions, mongoStorage, useMongoStorage };

package/dist/index.d.mts

@@ -0,0 +1,37 @@
+import * as _apibara_indexer_plugins from '@apibara/indexer/plugins';
+import { Db, ClientSession, Document, CollectionOptions, Collection, OptionalUnlessRequiredId, InsertOneOptions, InsertOneResult, BulkWriteOptions, InsertManyResult, Filter, UpdateFilter, UpdateOptions, UpdateResult, DeleteOptions, FindOptions, WithId, FindCursor, MongoClient, DbOptions } from 'mongodb';
+import { Cursor } from '@apibara/protocol';
+
+declare class MongoStorage {
+    private db;
+    private session;
+    private endCursor?;
+    constructor(db: Db, session: ClientSession, endCursor?: Cursor | undefined);
+    collection<TSchema extends Document = Document>(name: string, options?: CollectionOptions): MongoCollection<TSchema>;
+}
+declare class MongoCollection<TSchema extends Document> {
+    private session;
+    private collection;
+    private endCursor?;
+    constructor(session: ClientSession, collection: Collection<TSchema>, endCursor?: Cursor | undefined);
+    insertOne(doc: OptionalUnlessRequiredId<TSchema>, options?: InsertOneOptions): Promise<InsertOneResult<TSchema>>;
+    insertMany(docs: ReadonlyArray<OptionalUnlessRequiredId<TSchema>>, options?: BulkWriteOptions): Promise<InsertManyResult<TSchema>>;
+    updateOne(filter: Filter<TSchema>, update: UpdateFilter<TSchema>, options?: UpdateOptions): Promise<UpdateResult<TSchema>>;
+    updateMany(filter: Filter<TSchema>, update: UpdateFilter<TSchema>, options?: UpdateOptions): Promise<UpdateResult<TSchema>>;
+    deleteOne(filter: Filter<TSchema>, options?: DeleteOptions): Promise<UpdateResult<TSchema>>;
+    deleteMany(filter?: Filter<TSchema>, options?: DeleteOptions): Promise<UpdateResult<TSchema>>;
+    findOne(filter: Filter<TSchema>, options?: Omit<FindOptions, "timeoutMode">): Promise<WithId<TSchema> | null>;
+    find(filter: Filter<TSchema>, options?: FindOptions): FindCursor<WithId<TSchema>>;
+}
+
+declare function useMongoStorage(): MongoStorage;
+interface MongoStorageOptions {
+    client: MongoClient;
+    dbName: string;
+    dbOptions?: DbOptions;
+    collections: string[];
+    persistState?: boolean;
+}
+declare function mongoStorage<TFilter, TBlock>({ client, dbName, dbOptions, collections, persistState: enablePersistence, }: MongoStorageOptions): _apibara_indexer_plugins.IndexerPlugin<TFilter, TBlock>;
+
+export { MongoCollection, MongoStorage, type MongoStorageOptions, mongoStorage, useMongoStorage };

package/dist/index.d.ts

@@ -0,0 +1,37 @@
+import * as _apibara_indexer_plugins from '@apibara/indexer/plugins';
+import { Db, ClientSession, Document, CollectionOptions, Collection, OptionalUnlessRequiredId, InsertOneOptions, InsertOneResult, BulkWriteOptions, InsertManyResult, Filter, UpdateFilter, UpdateOptions, UpdateResult, DeleteOptions, FindOptions, WithId, FindCursor, MongoClient, DbOptions } from 'mongodb';
+import { Cursor } from '@apibara/protocol';
+
+declare class MongoStorage {
+    private db;
+    private session;
+    private endCursor?;
+    constructor(db: Db, session: ClientSession, endCursor?: Cursor | undefined);
+    collection<TSchema extends Document = Document>(name: string, options?: CollectionOptions): MongoCollection<TSchema>;
+}
+declare class MongoCollection<TSchema extends Document> {
+    private session;
+    private collection;
+    private endCursor?;
+    constructor(session: ClientSession, collection: Collection<TSchema>, endCursor?: Cursor | undefined);
+    insertOne(doc: OptionalUnlessRequiredId<TSchema>, options?: InsertOneOptions): Promise<InsertOneResult<TSchema>>;
+    insertMany(docs: ReadonlyArray<OptionalUnlessRequiredId<TSchema>>, options?: BulkWriteOptions): Promise<InsertManyResult<TSchema>>;
+    updateOne(filter: Filter<TSchema>, update: UpdateFilter<TSchema>, options?: UpdateOptions): Promise<UpdateResult<TSchema>>;
+    updateMany(filter: Filter<TSchema>, update: UpdateFilter<TSchema>, options?: UpdateOptions): Promise<UpdateResult<TSchema>>;
+    deleteOne(filter: Filter<TSchema>, options?: DeleteOptions): Promise<UpdateResult<TSchema>>;
+    deleteMany(filter?: Filter<TSchema>, options?: DeleteOptions): Promise<UpdateResult<TSchema>>;
+    findOne(filter: Filter<TSchema>, options?: Omit<FindOptions, "timeoutMode">): Promise<WithId<TSchema> | null>;
+    find(filter: Filter<TSchema>, options?: FindOptions): FindCursor<WithId<TSchema>>;
+}
+
+declare function useMongoStorage(): MongoStorage;
+interface MongoStorageOptions {
+    client: MongoClient;
+    dbName: string;
+    dbOptions?: DbOptions;
+    collections: string[];
+    persistState?: boolean;
+}
+declare function mongoStorage<TFilter, TBlock>({ client, dbName, dbOptions, collections, persistState: enablePersistence, }: MongoStorageOptions): _apibara_indexer_plugins.IndexerPlugin<TFilter, TBlock>;
+
+export { MongoCollection, MongoStorage, type MongoStorageOptions, mongoStorage, useMongoStorage };

package/dist/index.mjs

@@ -0,0 +1,287 @@
+import { useIndexerContext } from '@apibara/indexer';
+import { defineIndexerPlugin } from '@apibara/indexer/plugins';
+
+async function invalidate(db, session, cursor, collections) {
+  const orderKeyValue = Number(cursor.orderKey);
+  for (const collection of collections) {
+    await db.collection(collection).deleteMany(
+      {
+        "_cursor.from": {
+          $gt: orderKeyValue
+        }
+      },
+      { session }
+    );
+    await db.collection(collection).updateMany(
+      { "_cursor.to": { $gt: orderKeyValue } },
+      {
+        $set: {
+          "_cursor.to": null
+        }
+      },
+      { session }
+    );
+  }
+}
+async function finalize(db, session, cursor, collections) {
+  const orderKeyValue = Number(cursor.orderKey);
+  for (const collection of collections) {
+    await db.collection(collection).deleteMany(
+      {
+        "_cursor.to": { $lt: orderKeyValue }
+      },
+      { session }
+    );
+  }
+}
+
+class MongoStorage {
+  constructor(db, session, endCursor) {
+    this.db = db;
+    this.session = session;
+    this.endCursor = endCursor;
+  }
+  collection(name, options) {
+    const collection = this.db.collection(name, options);
+    return new MongoCollection(
+      this.session,
+      collection,
+      this.endCursor
+    );
+  }
+}
+class MongoCollection {
+  constructor(session, collection, endCursor) {
+    this.session = session;
+    this.collection = collection;
+    this.endCursor = endCursor;
+  }
+  async insertOne(doc, options) {
+    return await this.collection.insertOne(
+      {
+        ...doc,
+        _cursor: {
+          from: Number(this.endCursor?.orderKey),
+          to: null
+        }
+      },
+      { ...options, session: this.session }
+    );
+  }
+  async insertMany(docs, options) {
+    return await this.collection.insertMany(
+      docs.map((doc) => ({
+        ...doc,
+        _cursor: {
+          from: Number(this.endCursor?.orderKey),
+          to: null
+        }
+      })),
+      { ...options, session: this.session }
+    );
+  }
+  async updateOne(filter, update, options) {
+    const oldDoc = await this.collection.findOneAndUpdate(
+      {
+        ...filter,
+        "_cursor.to": null
+      },
+      {
+        ...update,
+        $set: {
+          ...update.$set,
+          "_cursor.from": Number(this.endCursor?.orderKey)
+        }
+      },
+      {
+        ...options,
+        session: this.session,
+        returnDocument: "before"
+      }
+    );
+    if (oldDoc) {
+      const { _id, ...doc } = oldDoc;
+      await this.collection.insertOne(
+        {
+          ...doc,
+          _cursor: {
+            ...oldDoc._cursor,
+            to: Number(this.endCursor?.orderKey)
+          }
+        },
+        { session: this.session }
+      );
+    }
+    return {
+      acknowledged: true,
+      modifiedCount: oldDoc ? 1 : 0,
+      upsertedId: null,
+      upsertedCount: 0,
+      matchedCount: oldDoc ? 1 : 0
+    };
+  }
+  async updateMany(filter, update, options) {
+    const oldDocs = await this.collection.find(
+      {
+        ...filter,
+        "_cursor.to": null
+      },
+      { session: this.session }
+    ).toArray();
+    const updateResult = await this.collection.updateMany(
+      {
+        ...filter,
+        "_cursor.to": null
+      },
+      {
+        ...update,
+        $set: {
+          ...update.$set,
+          "_cursor.from": Number(this.endCursor?.orderKey)
+        }
+      },
+      { ...options, session: this.session }
+    );
+    const oldDocsWithUpdatedCursor = oldDocs.map(({ _id, ...doc }) => ({
+      ...doc,
+      _cursor: {
+        ...doc._cursor,
+        to: Number(this.endCursor?.orderKey)
+      }
+    }));
+    if (oldDocsWithUpdatedCursor.length > 0) {
+      await this.collection.insertMany(
+        oldDocsWithUpdatedCursor,
+        { session: this.session }
+      );
+    }
+    return updateResult;
+  }
+  async deleteOne(filter, options) {
+    return await this.collection.updateOne(
+      {
+        ...filter,
+        "_cursor.to": null
+      },
+      {
+        $set: {
+          "_cursor.to": Number(this.endCursor?.orderKey)
+        }
+      },
+      { ...options, session: this.session }
+    );
+  }
+  async deleteMany(filter, options) {
+    return await this.collection.updateMany(
+      {
+        ...filter ?? {},
+        "_cursor.to": null
+      },
+      {
+        $set: {
+          "_cursor.to": Number(this.endCursor?.orderKey)
+        }
+      },
+      { ...options, session: this.session }
+    );
+  }
+  async findOne(filter, options) {
+    return await this.collection.findOne(
+      {
+        ...filter,
+        "_cursor.to": null
+      },
+      { ...options, session: this.session }
+    );
+  }
+  find(filter, options) {
+    return this.collection.find(
+      {
+        ...filter,
+        "_cursor.to": null
+      },
+      { ...options, session: this.session }
+    );
+  }
+}
+
+class MongoStorageError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "MongoStorageError";
+  }
+}
+async function withTransaction(client, cb) {
+  return await client.withSession(async (session) => {
+    return await session.withTransaction(async (session2) => {
+      return await cb(session2);
+    });
+  });
+}
+
+const MONGO_PROPERTY = "_mongo";
+function useMongoStorage() {
+  const context = useIndexerContext();
+  if (!context[MONGO_PROPERTY]) {
+    throw new MongoStorageError(
+      "mongo storage is not available. Did you register the plugin?"
+    );
+  }
+  return context[MONGO_PROPERTY];
+}
+function mongoStorage({
+  client,
+  dbName,
+  dbOptions,
+  collections,
+  persistState: enablePersistence = true
+}) {
+  return defineIndexerPlugin((indexer) => {
+    indexer.hooks.hook("message:finalize", async ({ message }) => {
+      const { cursor } = message.finalize;
+      if (!cursor) {
+        throw new MongoStorageError("finalized cursor is undefined");
+      }
+      await withTransaction(client, async (session) => {
+        const db = client.db(dbName, dbOptions);
+        await finalize(db, session, cursor, collections);
+      });
+    });
+    indexer.hooks.hook("message:invalidate", async ({ message }) => {
+      const { cursor } = message.invalidate;
+      if (!cursor) {
+        throw new MongoStorageError("invalidate cursor is undefined");
+      }
+      await withTransaction(client, async (session) => {
+        const db = client.db(dbName, dbOptions);
+        await invalidate(db, session, cursor, collections);
+      });
+    });
+    indexer.hooks.hook("connect:after", async ({ request }) => {
+      const cursor = request.startingCursor;
+      if (!cursor) {
+        return;
+      }
+      await withTransaction(client, async (session) => {
+        const db = client.db(dbName, dbOptions);
+        await invalidate(db, session, cursor, collections);
+      });
+    });
+    indexer.hooks.hook("handler:middleware", async ({ use }) => {
+      use(async (context, next) => {
+        const { endCursor } = context;
+        if (!endCursor) {
+          throw new MongoStorageError("end cursor is undefined");
+        }
+        await withTransaction(client, async (session) => {
+          const db = client.db(dbName, dbOptions);
+          context[MONGO_PROPERTY] = new MongoStorage(db, session, endCursor);
+          await next();
+          delete context[MONGO_PROPERTY];
+        });
+      });
+    });
+  });
+}
+
+export { MongoCollection, MongoStorage, mongoStorage, useMongoStorage };

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@apibara/plugin-mongo",
+  "version": "2.0.0-beta.28",
+  "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": {
+    "@types/node": "^20.14.0",
+    "mongodb": "^6.12.0",
+    "unbuild": "^2.0.0",
+    "vitest": "^1.6.0"
+  },
+  "peerDependencies": {
+    "mongodb": "^6.12.0"
+  },
+  "dependencies": {
+    "@apibara/indexer": "2.0.0-beta.28",
+    "@apibara/protocol": "2.0.0-beta.28"
+  }
+}

package/src/index.ts

@@ -0,0 +1,104 @@
+import { useIndexerContext } from "@apibara/indexer";
+import { defineIndexerPlugin } from "@apibara/indexer/plugins";
+import type { DbOptions, MongoClient } from "mongodb";
+
+import { finalize, invalidate } from "./mongo";
+import { MongoStorage } from "./storage";
+import { MongoStorageError, withTransaction } from "./utils";
+
+export { MongoCollection, MongoStorage } from "./storage";
+
+const MONGO_PROPERTY = "_mongo";
+
+export function useMongoStorage(): MongoStorage {
+  const context = useIndexerContext();
+
+  if (!context[MONGO_PROPERTY]) {
+    throw new MongoStorageError(
+      "mongo storage is not available. Did you register the plugin?",
+    );
+  }
+
+  return context[MONGO_PROPERTY] as MongoStorage;
+}
+
+export interface MongoStorageOptions {
+  client: MongoClient;
+  dbName: string;
+  dbOptions?: DbOptions;
+  collections: string[];
+  persistState?: boolean;
+}
+
+export function mongoStorage<TFilter, TBlock>({
+  client,
+  dbName,
+  dbOptions,
+  collections,
+  persistState: enablePersistence = true,
+}: MongoStorageOptions) {
+  return defineIndexerPlugin<TFilter, TBlock>((indexer) => {
+    indexer.hooks.hook("message:finalize", async ({ message }) => {
+      const { cursor } = message.finalize;
+
+      if (!cursor) {
+        throw new MongoStorageError("finalized cursor is undefined");
+      }
+
+      await withTransaction(client, async (session) => {
+        const db = client.db(dbName, dbOptions);
+        await finalize(db, session, cursor, collections);
+      });
+    });
+
+    indexer.hooks.hook("message:invalidate", async ({ message }) => {
+      const { cursor } = message.invalidate;
+
+      if (!cursor) {
+        throw new MongoStorageError("invalidate cursor is undefined");
+      }
+
+      await withTransaction(client, async (session) => {
+        const db = client.db(dbName, dbOptions);
+        await invalidate(db, session, cursor, collections);
+      });
+    });
+
+    indexer.hooks.hook("connect:after", async ({ request }) => {
+      // On restart, we need to invalidate data for blocks that were processed but not persisted.
+      const cursor = request.startingCursor;
+
+      if (!cursor) {
+        return;
+      }
+
+      await withTransaction(client, async (session) => {
+        const db = client.db(dbName, dbOptions);
+        await invalidate(db, session, cursor, collections);
+      });
+    });
+
+    indexer.hooks.hook("handler:middleware", async ({ use }) => {
+      use(async (context, next) => {
+        const { endCursor } = context;
+
+        if (!endCursor) {
+          throw new MongoStorageError("end cursor is undefined");
+        }
+
+        await withTransaction(client, async (session) => {
+          const db = client.db(dbName, dbOptions);
+          context[MONGO_PROPERTY] = new MongoStorage(db, session, endCursor);
+
+          await next();
+
+          delete context[MONGO_PROPERTY];
+
+          if (enablePersistence) {
+            // TODO: persist state
+          }
+        });
+      });
+    });
+  });
+}

package/src/mongo.ts

@@ -0,0 +1,51 @@
+import type { Cursor } from "@apibara/protocol";
+import type { ClientSession, Db } from "mongodb";
+
+export async function invalidate(
+  db: Db,
+  session: ClientSession,
+  cursor: Cursor,
+  collections: string[],
+) {
+  const orderKeyValue = Number(cursor.orderKey);
+  for (const collection of collections) {
+    // Delete documents where the lower bound of _cursor is greater than the invalidate cursor
+    await db.collection(collection).deleteMany(
+      {
+        "_cursor.from": {
+          $gt: orderKeyValue,
+        },
+      },
+      { session },
+    );
+
+    // Update documents where the upper bound of _cursor is greater than the invalidate cursor
+    await db.collection(collection).updateMany(
+      { "_cursor.to": { $gt: orderKeyValue } },
+      {
+        $set: {
+          "_cursor.to": null,
+        },
+      },
+      { session },
+    );
+  }
+}
+
+export async function finalize(
+  db: Db,
+  session: ClientSession,
+  cursor: Cursor,
+  collections: string[],
+) {
+  const orderKeyValue = Number(cursor.orderKey);
+  for (const collection of collections) {
+    // Delete documents where the upper bound of _cursor is less than the finalize cursor
+    await db.collection(collection).deleteMany(
+      {
+        "_cursor.to": { $lt: orderKeyValue },
+      },
+      { session },
+    );
+  }
+}

package/src/storage.ts

@@ -0,0 +1,258 @@
+import type { Cursor } from "@apibara/protocol";
+import type {
+  BulkWriteOptions,
+  ClientSession,
+  Collection,
+  CollectionOptions,
+  Db,
+  DeleteOptions,
+  Document,
+  Filter,
+  FindCursor,
+  FindOneAndUpdateOptions,
+  FindOptions,
+  InsertManyResult,
+  InsertOneOptions,
+  InsertOneResult,
+  MatchKeysAndValues,
+  OptionalUnlessRequiredId,
+  UpdateFilter,
+  UpdateOptions,
+  UpdateResult,
+  WithId,
+} from "mongodb";
+
+export class MongoStorage {
+  constructor(
+    private db: Db,
+    private session: ClientSession,
+    private endCursor?: Cursor,
+  ) {}
+
+  collection<TSchema extends Document = Document>(
+    name: string,
+    options?: CollectionOptions,
+  ) {
+    const collection = this.db.collection<TSchema>(name, options);
+
+    return new MongoCollection<TSchema>(
+      this.session,
+      collection,
+      this.endCursor,
+    );
+  }
+}
+
+export type MongoCursor = {
+  from: number | null;
+  to: number | null;
+};
+
+export type CursoredSchema<TSchema extends Document> = TSchema & {
+  _cursor: MongoCursor;
+};
+
+export class MongoCollection<TSchema extends Document> {
+  constructor(
+    private session: ClientSession,
+    private collection: Collection<TSchema>,
+    private endCursor?: Cursor,
+  ) {}
+
+  async insertOne(
+    doc: OptionalUnlessRequiredId<TSchema>,
+    options?: InsertOneOptions,
+  ): Promise<InsertOneResult<TSchema>> {
+    return await this.collection.insertOne(
+      {
+        ...doc,
+        _cursor: {
+          from: Number(this.endCursor?.orderKey),
+          to: null,
+        } as MongoCursor,
+      },
+      { ...options, session: this.session },
+    );
+  }
+
+  async insertMany(
+    docs: ReadonlyArray<OptionalUnlessRequiredId<TSchema>>,
+    options?: BulkWriteOptions,
+  ): Promise<InsertManyResult<TSchema>> {
+    return await this.collection.insertMany(
+      docs.map((doc) => ({
+        ...doc,
+        _cursor: {
+          from: Number(this.endCursor?.orderKey),
+          to: null,
+        } as MongoCursor,
+      })),
+      { ...options, session: this.session },
+    );
+  }
+
+  async updateOne(
+    filter: Filter<TSchema>,
+    update: UpdateFilter<TSchema>,
+    options?: UpdateOptions,
+  ): Promise<UpdateResult<TSchema>> {
+    // 1. Find and update the document, getting the old version
+    const oldDoc = await this.collection.findOneAndUpdate(
+      {
+        ...filter,
+        "_cursor.to": null,
+      },
+      {
+        ...update,
+        $set: {
+          ...update.$set,
+          "_cursor.from": Number(this.endCursor?.orderKey),
+        } as unknown as MatchKeysAndValues<TSchema>,
+      },
+      {
+        ...options,
+        session: this.session,
+        returnDocument: "before",
+      } as FindOneAndUpdateOptions,
+    );
+
+    // 2. If we found and updated a document, insert its old version
+    if (oldDoc) {
+      const { _id, ...doc } = oldDoc;
+      await this.collection.insertOne(
+        {
+          ...doc,
+          _cursor: {
+            ...oldDoc._cursor,
+            to: Number(this.endCursor?.orderKey),
+          },
+        } as unknown as OptionalUnlessRequiredId<TSchema>,
+        { session: this.session },
+      );
+    }
+
+    // 3. Return an UpdateResult-compatible object
+    return {
+      acknowledged: true,
+      modifiedCount: oldDoc ? 1 : 0,
+      upsertedId: null,
+      upsertedCount: 0,
+      matchedCount: oldDoc ? 1 : 0,
+    };
+  }
+
+  async updateMany(
+    filter: Filter<TSchema>,
+    update: UpdateFilter<TSchema>,
+    options?: UpdateOptions,
+  ): Promise<UpdateResult<TSchema>> {
+    // 1. Find all documents matching the filter that are latest (to: null)
+    const oldDocs = await this.collection
+      .find(
+        {
+          ...filter,
+          "_cursor.to": null,
+        },
+        { session: this.session },
+      )
+      .toArray();
+
+    // 2. Update to the new values with updateMany
+    // (setting _cursor.from to endCursor, leaving _cursor.to unchanged)
+    const updateResult = await this.collection.updateMany(
+      {
+        ...filter,
+        "_cursor.to": null,
+      },
+      {
+        ...update,
+        $set: {
+          ...update.$set,
+          "_cursor.from": Number(this.endCursor?.orderKey),
+        } as unknown as MatchKeysAndValues<TSchema>,
+      },
+      { ...options, session: this.session },
+    );
+
+    // 3. Adjust the cursor.to of the old values
+    const oldDocsWithUpdatedCursor = oldDocs.map(({ _id, ...doc }) => ({
+      ...doc,
+      _cursor: {
+        ...doc._cursor,
+        to: Number(this.endCursor?.orderKey),
+      },
+    }));
+
+    // 4. Insert the old values back into the db
+    if (oldDocsWithUpdatedCursor.length > 0) {
+      await this.collection.insertMany(
+        oldDocsWithUpdatedCursor as unknown as OptionalUnlessRequiredId<TSchema>[],
+        { session: this.session },
+      );
+    }
+
+    return updateResult;
+  }
+
+  async deleteOne(
+    filter: Filter<TSchema>,
+    options?: DeleteOptions,
+  ): Promise<UpdateResult<TSchema>> {
+    return await this.collection.updateOne(
+      {
+        ...filter,
+        "_cursor.to": null,
+      },
+      {
+        $set: {
+          "_cursor.to": Number(this.endCursor?.orderKey),
+        } as unknown as MatchKeysAndValues<TSchema>,
+      },
+      { ...options, session: this.session },
+    );
+  }
+
+  async deleteMany(
+    filter?: Filter<TSchema>,
+    options?: DeleteOptions,
+  ): Promise<UpdateResult<TSchema>> {
+    return await this.collection.updateMany(
+      {
+        ...((filter ?? {}) as Filter<TSchema>),
+        "_cursor.to": null,
+      },
+      {
+        $set: {
+          "_cursor.to": Number(this.endCursor?.orderKey),
+        } as unknown as MatchKeysAndValues<TSchema>,
+      },
+      { ...options, session: this.session },
+    );
+  }
+
+  async findOne(
+    filter: Filter<TSchema>,
+    options?: Omit<FindOptions, "timeoutMode">,
+  ): Promise<WithId<TSchema> | null> {
+    return await this.collection.findOne(
+      {
+        ...filter,
+        "_cursor.to": null,
+      },
+      { ...options, session: this.session },
+    );
+  }
+
+  find(
+    filter: Filter<TSchema>,
+    options?: FindOptions,
+  ): FindCursor<WithId<TSchema>> {
+    return this.collection.find(
+      {
+        ...filter,
+        "_cursor.to": null,
+      },
+      { ...options, session: this.session },
+    );
+  }
+}

package/src/utils.ts

@@ -0,0 +1,19 @@
+import type { ClientSession, MongoClient } from "mongodb";
+
+export class MongoStorageError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "MongoStorageError";
+  }
+}
+
+export async function withTransaction<T>(
+  client: MongoClient,
+  cb: (session: ClientSession) => Promise<T>,
+) {
+  return await client.withSession(async (session) => {
+    return await session.withTransaction(async (session) => {
+      return await cb(session);
+    });
+  });
+}