@apibara/plugin-drizzle 2.0.0-beta.36 → 2.0.0-beta.37

package/dist/index.cjs

@@ -2,6 +2,8 @@
 
 const indexer = require('@apibara/indexer');
 const plugins = require('@apibara/indexer/plugins');
+const internal = require('@apibara/indexer/internal');
+const plugins$1 = require('@apibara/indexer/internal/plugins');
 const drizzleOrm = require('drizzle-orm');
 const pgCore = require('drizzle-orm/pg-core');
 
@@ -29,6 +31,9 @@ function serialize(obj) {
     "	"
   );
 }
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
 
 const CHECKPOINTS_TABLE_NAME = "__indexer_checkpoints";
 const FILTERS_TABLE_NAME = "__indexer_filters";
@@ -117,11 +122,11 @@ async function initializePersistentState(tx) {
   }
 }
 async function persistState(props) {
-  const { tx, endCursor, filter, indexerName } = props;
+  const { tx, endCursor, filter, indexerId } = props;
   try {
     if (endCursor) {
       await tx.insert(checkpoints).values({
-        id: indexerName,
+        id: indexerId,
         orderKey: Number(endCursor.orderKey),
         uniqueKey: endCursor.uniqueKey
       }).onConflictDoUpdate({
@@ -132,9 +137,9 @@ async function persistState(props) {
         }
       });
       if (filter) {
-        await tx.update(filters).set({ toBlock: Number(endCursor.orderKey) }).where(drizzleOrm.and(drizzleOrm.eq(filters.id, indexerName), drizzleOrm.isNull(filters.toBlock)));
+        await tx.update(filters).set({ toBlock: Number(endCursor.orderKey) }).where(drizzleOrm.and(drizzleOrm.eq(filters.id, indexerId), drizzleOrm.isNull(filters.toBlock)));
         await tx.insert(filters).values({
-          id: indexerName,
+          id: indexerId,
           filter: serialize(filter),
           fromBlock: Number(endCursor.orderKey),
           toBlock: null
@@ -155,14 +160,14 @@ async function persistState(props) {
   }
 }
 async function getState(props) {
-  const { tx, indexerName } = props;
+  const { tx, indexerId } = props;
   try {
-    const checkpointRows = await tx.select().from(checkpoints).where(drizzleOrm.eq(checkpoints.id, indexerName));
+    const checkpointRows = await tx.select().from(checkpoints).where(drizzleOrm.eq(checkpoints.id, indexerId));
     const cursor = checkpointRows[0] ? {
       orderKey: BigInt(checkpointRows[0].orderKey),
       uniqueKey: checkpointRows[0].uniqueKey
     } : void 0;
-    const filterRows = await tx.select().from(filters).where(drizzleOrm.and(drizzleOrm.eq(filters.id, indexerName), drizzleOrm.isNull(filters.toBlock)));
+    const filterRows = await tx.select().from(filters).where(drizzleOrm.and(drizzleOrm.eq(filters.id, indexerId), drizzleOrm.isNull(filters.toBlock)));
     const filter = filterRows[0] ? deserialize(filterRows[0].filter) : void 0;
     return { cursor, filter };
   } catch (error) {
@@ -172,17 +177,17 @@ async function getState(props) {
   }
 }
 async function invalidateState(props) {
-  const { tx, cursor, indexerName } = props;
+  const { tx, cursor, indexerId } = props;
   try {
     await tx.delete(filters).where(
       drizzleOrm.and(
-        drizzleOrm.eq(filters.id, indexerName),
+        drizzleOrm.eq(filters.id, indexerId),
         drizzleOrm.gt(filters.fromBlock, Number(cursor.orderKey))
       )
     );
     await tx.update(filters).set({ toBlock: null }).where(
       drizzleOrm.and(
-        drizzleOrm.eq(filters.id, indexerName),
+        drizzleOrm.eq(filters.id, indexerId),
         drizzleOrm.gt(filters.toBlock, Number(cursor.orderKey))
       )
     );
@@ -193,11 +198,11 @@ async function invalidateState(props) {
   }
 }
 async function finalizeState(props) {
-  const { tx, cursor, indexerName } = props;
+  const { tx, cursor, indexerId } = props;
   try {
     await tx.delete(filters).where(
       drizzleOrm.and(
-        drizzleOrm.eq(filters.id, indexerName),
+        drizzleOrm.eq(filters.id, indexerId),
         drizzleOrm.lt(filters.toBlock, Number(cursor.orderKey))
       )
     );
@@ -208,15 +213,19 @@ async function finalizeState(props) {
   }
 }
 
+function getReorgTriggerName(table, indexerId) {
+  return `${table}_reorg_${indexerId}`;
+}
 pgCore.pgTable("__reorg_rollback", {
   n: pgCore.serial("n").primaryKey(),
   op: pgCore.char("op", { length: 1 }).$type().notNull(),
   table_name: pgCore.text("table_name").notNull(),
   cursor: pgCore.integer("cursor").notNull(),
   row_id: pgCore.text("row_id"),
-  row_value: pgCore.jsonb("row_value")
+  row_value: pgCore.jsonb("row_value"),
+  indexer_id: pgCore.text("indexer_id").notNull()
 });
-async function initializeReorgRollbackTable(tx) {
+async function initializeReorgRollbackTable(tx, indexerId) {
   try {
     await tx.execute(
       drizzleOrm.sql.raw(`
@@ -226,33 +235,14 @@ async function initializeReorgRollbackTable(tx) {
           table_name TEXT NOT NULL,
           cursor INTEGER NOT NULL,
           row_id TEXT,
-          row_value JSONB
+          row_value JSONB,
+          indexer_id TEXT NOT NULL
         );
       `)
     );
     await tx.execute(
       drizzleOrm.sql.raw(`
-        CREATE OR REPLACE FUNCTION reorg_checkpoint()
-        RETURNS TRIGGER AS $$
-        DECLARE
-          id_col TEXT := TG_ARGV[0]::TEXT;
-          order_key INTEGER := TG_ARGV[1]::INTEGER;
-          new_id_value TEXT := row_to_json(NEW.*)->>id_col;
-          old_id_value TEXT := row_to_json(OLD.*)->>id_col;
-        BEGIN
-          IF (TG_OP = 'DELETE') THEN
-            INSERT INTO __reorg_rollback(op, table_name, cursor, row_id, row_value)
-              SELECT 'D', TG_TABLE_NAME, order_key, old_id_value, row_to_json(OLD.*);
-          ELSIF (TG_OP = 'UPDATE') THEN
-            INSERT INTO __reorg_rollback(op, table_name, cursor, row_id, row_value)
-              SELECT 'U', TG_TABLE_NAME, order_key, new_id_value, row_to_json(OLD.*);
-          ELSIF (TG_OP = 'INSERT') THEN
-            INSERT INTO __reorg_rollback(op, table_name, cursor, row_id, row_value)
-              SELECT 'I', TG_TABLE_NAME, order_key, new_id_value, null;
-          END IF;
-          RETURN NULL;
-        END;
-        $$ LANGUAGE plpgsql;
+        CREATE INDEX IF NOT EXISTS idx_reorg_rollback_indexer_id_cursor ON __reorg_rollback(indexer_id, cursor);
       `)
     );
   } catch (error) {
@@ -260,19 +250,56 @@ async function initializeReorgRollbackTable(tx) {
       cause: error
     });
   }
+  try {
+    await tx.execute(
+      drizzleOrm.sql.raw(`
+      CREATE OR REPLACE FUNCTION reorg_checkpoint()
+      RETURNS TRIGGER AS $$
+      DECLARE
+        id_col TEXT := TG_ARGV[0]::TEXT;
+        order_key INTEGER := TG_ARGV[1]::INTEGER;
+        indexer_id TEXT := TG_ARGV[2]::TEXT;
+        new_id_value TEXT := row_to_json(NEW.*)->>id_col;
+        old_id_value TEXT := row_to_json(OLD.*)->>id_col;
+      BEGIN
+        IF (TG_OP = 'DELETE') THEN
+          INSERT INTO __reorg_rollback(op, table_name, cursor, row_id, row_value, indexer_id)
+            SELECT 'D', TG_TABLE_NAME, order_key, old_id_value, row_to_json(OLD.*), indexer_id;
+        ELSIF (TG_OP = 'UPDATE') THEN
+          INSERT INTO __reorg_rollback(op, table_name, cursor, row_id, row_value, indexer_id)
+            SELECT 'U', TG_TABLE_NAME, order_key, new_id_value, row_to_json(OLD.*), indexer_id;
+        ELSIF (TG_OP = 'INSERT') THEN
+          INSERT INTO __reorg_rollback(op, table_name, cursor, row_id, row_value, indexer_id)
+            SELECT 'I', TG_TABLE_NAME, order_key, new_id_value, null, indexer_id;
+        END IF;
+        RETURN NULL;
+      END;
+      $$ LANGUAGE plpgsql;
+    `)
+    );
+  } catch (error) {
+    throw new DrizzleStorageError(
+      "Failed to create reorg checkpoint function",
+      {
+        cause: error
+      }
+    );
+  }
 }
-async function registerTriggers(tx, tables, endCursor, idColumn) {
+async function registerTriggers(tx, tables, endCursor, idColumn, indexerId) {
   try {
     for (const table of tables) {
       await tx.execute(
-        drizzleOrm.sql.raw(`DROP TRIGGER IF EXISTS ${table}_reorg ON ${table};`)
+        drizzleOrm.sql.raw(
+          `DROP TRIGGER IF EXISTS ${getReorgTriggerName(table, indexerId)} ON ${table};`
+        )
       );
       await tx.execute(
         drizzleOrm.sql.raw(`
-          CREATE CONSTRAINT TRIGGER ${table}_reorg
+          CREATE CONSTRAINT TRIGGER ${getReorgTriggerName(table, indexerId)}
           AFTER INSERT OR UPDATE OR DELETE ON ${table}
           DEFERRABLE INITIALLY DEFERRED
-          FOR EACH ROW EXECUTE FUNCTION reorg_checkpoint('${idColumn}', ${`${Number(endCursor.orderKey)}`});
+          FOR EACH ROW EXECUTE FUNCTION reorg_checkpoint('${idColumn}', ${`${Number(endCursor.orderKey)}`}, '${indexerId}');
         `)
       );
     }
@@ -282,11 +309,13 @@ async function registerTriggers(tx, tables, endCursor, idColumn) {
     });
   }
 }
-async function removeTriggers(db, tables) {
+async function removeTriggers(db, tables, indexerId) {
   try {
     for (const table of tables) {
       await db.execute(
-        drizzleOrm.sql.raw(`DROP TRIGGER IF EXISTS ${table}_reorg ON ${table};`)
+        drizzleOrm.sql.raw(
+          `DROP TRIGGER IF EXISTS ${getReorgTriggerName(table, indexerId)} ON ${table};`
+        )
       );
     }
   } catch (error) {
@@ -295,12 +324,13 @@ async function removeTriggers(db, tables) {
     });
   }
 }
-async function invalidate(tx, cursor, idColumn) {
+async function invalidate(tx, cursor, idColumn, indexerId) {
   const { rows: result } = await tx.execute(
     drizzleOrm.sql.raw(`
       WITH deleted AS (
         DELETE FROM __reorg_rollback
         WHERE cursor > ${Number(cursor.orderKey)}
+        AND indexer_id = '${indexerId}'
         RETURNING *
       )
       SELECT * FROM deleted ORDER BY n DESC;
@@ -387,12 +417,13 @@ async function invalidate(tx, cursor, idColumn) {
     }
   }
 }
-async function finalize(tx, cursor) {
+async function finalize(tx, cursor, indexerId) {
   try {
     await tx.execute(
       drizzleOrm.sql.raw(`
       DELETE FROM __reorg_rollback
       WHERE cursor <= ${Number(cursor.orderKey)}
+      AND indexer_id = '${indexerId}'
     `)
     );
   } catch (error) {
@@ -403,6 +434,7 @@ async function finalize(tx, cursor) {
 }
 
 const DRIZZLE_PROPERTY = "_drizzle";
+const MAX_RETRIES = 5;
 function useDrizzleStorage(_db) {
   const context = indexer.useIndexerContext();
   if (!context[DRIZZLE_PROPERTY]) {
@@ -415,12 +447,13 @@ function useDrizzleStorage(_db) {
 function drizzleStorage({
   db,
   persistState: enablePersistence = true,
-  indexerName = "default",
+  indexerName: identifier = "default",
   schema,
   idColumn = "id"
 }) {
   return plugins.defineIndexerPlugin((indexer) => {
     let tableNames = [];
+    let indexerId = "";
     try {
       tableNames = Object.values(schema ?? db._.schema ?? {}).map(
         (table) => table.dbName
@@ -431,12 +464,31 @@ function drizzleStorage({
       });
     }
     indexer.hooks.hook("run:before", async () => {
-      await withTransaction(db, async (tx) => {
-        await initializeReorgRollbackTable(tx);
-        if (enablePersistence) {
-          await initializePersistentState(tx);
+      const { indexerName: indexerFileName, availableIndexers } = plugins$1.useInternalContext();
+      indexerId = internal.generateIndexerId(indexerFileName, identifier);
+      let retries = 0;
+      while (retries <= MAX_RETRIES) {
+        try {
+          await withTransaction(db, async (tx) => {
+            await initializeReorgRollbackTable(tx, indexerId);
+            if (enablePersistence) {
+              await initializePersistentState(tx);
+            }
+          });
+          break;
+        } catch (error) {
+          if (retries === MAX_RETRIES) {
+            throw new DrizzleStorageError(
+              "Initialization failed after 5 retries",
+              {
+                cause: error
+              }
+            );
+          }
+          await sleep(retries * 1e3);
+          retries++;
         }
-      });
+      }
     });
     indexer.hooks.hook("connect:before", async ({ request }) => {
       if (!enablePersistence) {
@@ -445,7 +497,7 @@ function drizzleStorage({
       await withTransaction(db, async (tx) => {
         const { cursor, filter } = await getState({
           tx,
-          indexerName
+          indexerId
         });
         if (cursor) {
           request.startingCursor = cursor;
@@ -461,9 +513,9 @@ function drizzleStorage({
         return;
       }
       await withTransaction(db, async (tx) => {
-        await invalidate(tx, cursor, idColumn);
+        await invalidate(tx, cursor, idColumn, indexerId);
         if (enablePersistence) {
-          await invalidateState({ tx, cursor, indexerName });
+          await invalidateState({ tx, cursor, indexerId });
         }
       });
     });
@@ -477,7 +529,7 @@ function drizzleStorage({
           tx,
           endCursor,
           filter: request.filter[1],
-          indexerName
+          indexerId
         });
       }
     });
@@ -487,9 +539,9 @@ function drizzleStorage({
         throw new DrizzleStorageError("Finalized Cursor is undefined");
       }
       await withTransaction(db, async (tx) => {
-        await finalize(tx, cursor);
+        await finalize(tx, cursor, indexerId);
         if (enablePersistence) {
-          await finalizeState({ tx, cursor, indexerName });
+          await finalizeState({ tx, cursor, indexerId });
         }
       });
     });
@@ -499,9 +551,9 @@ function drizzleStorage({
         throw new DrizzleStorageError("Invalidate Cursor is undefined");
       }
       await withTransaction(db, async (tx) => {
-        await invalidate(tx, cursor, idColumn);
+        await invalidate(tx, cursor, idColumn, indexerId);
         if (enablePersistence) {
-          await invalidateState({ tx, cursor, indexerName });
+          await invalidateState({ tx, cursor, indexerId });
         }
       });
     });
@@ -515,7 +567,13 @@ function drizzleStorage({
           await withTransaction(db, async (tx) => {
             context[DRIZZLE_PROPERTY] = { db: tx };
             if (finality !== "finalized") {
-              await registerTriggers(tx, tableNames, endCursor, idColumn);
+              await registerTriggers(
+                tx,
+                tableNames,
+                endCursor,
+                idColumn,
+                indexerId
+              );
             }
             await next();
             delete context[DRIZZLE_PROPERTY];
@@ -523,15 +581,15 @@ function drizzleStorage({
               await persistState({
                 tx,
                 endCursor,
-                indexerName
+                indexerId
               });
             }
           });
           if (finality !== "finalized") {
-            await removeTriggers(db, tableNames);
+            await removeTriggers(db, tableNames, indexerId);
           }
         } catch (error) {
-          await removeTriggers(db, tableNames);
+          await removeTriggers(db, tableNames, indexerId);
           throw new DrizzleStorageError("Failed to run handler:middleware", {
             cause: error
           });

package/dist/index.d.cts

@@ -23,6 +23,6 @@ interface DrizzleStorageOptions<TQueryResult extends PgQueryResultHKT, TFullSche
  * @param options.schema - The schema of the database.
  * @param options.idColumn - The column to use as the id. Defaults to 'id'.
  */
-declare function drizzleStorage<TFilter, TBlock, TQueryResult extends PgQueryResultHKT, TFullSchema extends Record<string, unknown> = Record<string, never>, TSchema extends TablesRelationalConfig = ExtractTablesWithRelations<TFullSchema>>({ db, persistState: enablePersistence, indexerName, schema, idColumn, }: DrizzleStorageOptions<TQueryResult, TFullSchema, TSchema>): _apibara_indexer_plugins.IndexerPlugin<TFilter, TBlock>;
+declare function drizzleStorage<TFilter, TBlock, TQueryResult extends PgQueryResultHKT, TFullSchema extends Record<string, unknown> = Record<string, never>, TSchema extends TablesRelationalConfig = ExtractTablesWithRelations<TFullSchema>>({ db, persistState: enablePersistence, indexerName: identifier, schema, idColumn, }: DrizzleStorageOptions<TQueryResult, TFullSchema, TSchema>): _apibara_indexer_plugins.IndexerPlugin<TFilter, TBlock>;
 
 export { type DrizzleStorage, type DrizzleStorageOptions, drizzleStorage, useDrizzleStorage };

package/dist/index.d.mts

@@ -23,6 +23,6 @@ interface DrizzleStorageOptions<TQueryResult extends PgQueryResultHKT, TFullSche
  * @param options.schema - The schema of the database.
  * @param options.idColumn - The column to use as the id. Defaults to 'id'.
  */
-declare function drizzleStorage<TFilter, TBlock, TQueryResult extends PgQueryResultHKT, TFullSchema extends Record<string, unknown> = Record<string, never>, TSchema extends TablesRelationalConfig = ExtractTablesWithRelations<TFullSchema>>({ db, persistState: enablePersistence, indexerName, schema, idColumn, }: DrizzleStorageOptions<TQueryResult, TFullSchema, TSchema>): _apibara_indexer_plugins.IndexerPlugin<TFilter, TBlock>;
+declare function drizzleStorage<TFilter, TBlock, TQueryResult extends PgQueryResultHKT, TFullSchema extends Record<string, unknown> = Record<string, never>, TSchema extends TablesRelationalConfig = ExtractTablesWithRelations<TFullSchema>>({ db, persistState: enablePersistence, indexerName: identifier, schema, idColumn, }: DrizzleStorageOptions<TQueryResult, TFullSchema, TSchema>): _apibara_indexer_plugins.IndexerPlugin<TFilter, TBlock>;
 
 export { type DrizzleStorage, type DrizzleStorageOptions, drizzleStorage, useDrizzleStorage };

package/dist/index.d.ts

@@ -23,6 +23,6 @@ interface DrizzleStorageOptions<TQueryResult extends PgQueryResultHKT, TFullSche
  * @param options.schema - The schema of the database.
  * @param options.idColumn - The column to use as the id. Defaults to 'id'.
  */
-declare function drizzleStorage<TFilter, TBlock, TQueryResult extends PgQueryResultHKT, TFullSchema extends Record<string, unknown> = Record<string, never>, TSchema extends TablesRelationalConfig = ExtractTablesWithRelations<TFullSchema>>({ db, persistState: enablePersistence, indexerName, schema, idColumn, }: DrizzleStorageOptions<TQueryResult, TFullSchema, TSchema>): _apibara_indexer_plugins.IndexerPlugin<TFilter, TBlock>;
+declare function drizzleStorage<TFilter, TBlock, TQueryResult extends PgQueryResultHKT, TFullSchema extends Record<string, unknown> = Record<string, never>, TSchema extends TablesRelationalConfig = ExtractTablesWithRelations<TFullSchema>>({ db, persistState: enablePersistence, indexerName: identifier, schema, idColumn, }: DrizzleStorageOptions<TQueryResult, TFullSchema, TSchema>): _apibara_indexer_plugins.IndexerPlugin<TFilter, TBlock>;
 
 export { type DrizzleStorage, type DrizzleStorageOptions, drizzleStorage, useDrizzleStorage };

package/dist/index.mjs

@@ -1,6 +1,8 @@
 import { useIndexerContext } from '@apibara/indexer';
 import { defineIndexerPlugin } from '@apibara/indexer/plugins';
-import { and, eq, isNull, gt, lt, sql } from 'drizzle-orm';
+import { generateIndexerId } from '@apibara/indexer/internal';
+import { useInternalContext } from '@apibara/indexer/internal/plugins';
+import { eq, and, isNull, gt, lt, sql } from 'drizzle-orm';
 import { pgTable, text, integer, primaryKey, serial, char, jsonb } from 'drizzle-orm/pg-core';
 
 class DrizzleStorageError extends Error {
@@ -27,6 +29,9 @@ function serialize(obj) {
     "	"
   );
 }
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
 
 const CHECKPOINTS_TABLE_NAME = "__indexer_checkpoints";
 const FILTERS_TABLE_NAME = "__indexer_filters";
@@ -115,11 +120,11 @@ async function initializePersistentState(tx) {
   }
 }
 async function persistState(props) {
-  const { tx, endCursor, filter, indexerName } = props;
+  const { tx, endCursor, filter, indexerId } = props;
   try {
     if (endCursor) {
       await tx.insert(checkpoints).values({
-        id: indexerName,
+        id: indexerId,
         orderKey: Number(endCursor.orderKey),
         uniqueKey: endCursor.uniqueKey
       }).onConflictDoUpdate({
@@ -130,9 +135,9 @@ async function persistState(props) {
         }
       });
       if (filter) {
-        await tx.update(filters).set({ toBlock: Number(endCursor.orderKey) }).where(and(eq(filters.id, indexerName), isNull(filters.toBlock)));
+        await tx.update(filters).set({ toBlock: Number(endCursor.orderKey) }).where(and(eq(filters.id, indexerId), isNull(filters.toBlock)));
         await tx.insert(filters).values({
-          id: indexerName,
+          id: indexerId,
           filter: serialize(filter),
           fromBlock: Number(endCursor.orderKey),
           toBlock: null
@@ -153,14 +158,14 @@ async function persistState(props) {
   }
 }
 async function getState(props) {
-  const { tx, indexerName } = props;
+  const { tx, indexerId } = props;
   try {
-    const checkpointRows = await tx.select().from(checkpoints).where(eq(checkpoints.id, indexerName));
+    const checkpointRows = await tx.select().from(checkpoints).where(eq(checkpoints.id, indexerId));
     const cursor = checkpointRows[0] ? {
       orderKey: BigInt(checkpointRows[0].orderKey),
       uniqueKey: checkpointRows[0].uniqueKey
     } : void 0;
-    const filterRows = await tx.select().from(filters).where(and(eq(filters.id, indexerName), isNull(filters.toBlock)));
+    const filterRows = await tx.select().from(filters).where(and(eq(filters.id, indexerId), isNull(filters.toBlock)));
     const filter = filterRows[0] ? deserialize(filterRows[0].filter) : void 0;
     return { cursor, filter };
   } catch (error) {
@@ -170,17 +175,17 @@ async function getState(props) {
   }
 }
 async function invalidateState(props) {
-  const { tx, cursor, indexerName } = props;
+  const { tx, cursor, indexerId } = props;
   try {
     await tx.delete(filters).where(
       and(
-        eq(filters.id, indexerName),
+        eq(filters.id, indexerId),
         gt(filters.fromBlock, Number(cursor.orderKey))
       )
     );
     await tx.update(filters).set({ toBlock: null }).where(
       and(
-        eq(filters.id, indexerName),
+        eq(filters.id, indexerId),
         gt(filters.toBlock, Number(cursor.orderKey))
       )
     );
@@ -191,11 +196,11 @@ async function invalidateState(props) {
   }
 }
 async function finalizeState(props) {
-  const { tx, cursor, indexerName } = props;
+  const { tx, cursor, indexerId } = props;
   try {
     await tx.delete(filters).where(
       and(
-        eq(filters.id, indexerName),
+        eq(filters.id, indexerId),
         lt(filters.toBlock, Number(cursor.orderKey))
       )
     );
@@ -206,15 +211,19 @@ async function finalizeState(props) {
   }
 }
 
+function getReorgTriggerName(table, indexerId) {
+  return `${table}_reorg_${indexerId}`;
+}
 pgTable("__reorg_rollback", {
   n: serial("n").primaryKey(),
   op: char("op", { length: 1 }).$type().notNull(),
   table_name: text("table_name").notNull(),
   cursor: integer("cursor").notNull(),
   row_id: text("row_id"),
-  row_value: jsonb("row_value")
+  row_value: jsonb("row_value"),
+  indexer_id: text("indexer_id").notNull()
 });
-async function initializeReorgRollbackTable(tx) {
+async function initializeReorgRollbackTable(tx, indexerId) {
   try {
     await tx.execute(
       sql.raw(`
@@ -224,33 +233,14 @@ async function initializeReorgRollbackTable(tx) {
           table_name TEXT NOT NULL,
           cursor INTEGER NOT NULL,
           row_id TEXT,
-          row_value JSONB
+          row_value JSONB,
+          indexer_id TEXT NOT NULL
         );
       `)
     );
     await tx.execute(
       sql.raw(`
-        CREATE OR REPLACE FUNCTION reorg_checkpoint()
-        RETURNS TRIGGER AS $$
-        DECLARE
-          id_col TEXT := TG_ARGV[0]::TEXT;
-          order_key INTEGER := TG_ARGV[1]::INTEGER;
-          new_id_value TEXT := row_to_json(NEW.*)->>id_col;
-          old_id_value TEXT := row_to_json(OLD.*)->>id_col;
-        BEGIN
-          IF (TG_OP = 'DELETE') THEN
-            INSERT INTO __reorg_rollback(op, table_name, cursor, row_id, row_value)
-              SELECT 'D', TG_TABLE_NAME, order_key, old_id_value, row_to_json(OLD.*);
-          ELSIF (TG_OP = 'UPDATE') THEN
-            INSERT INTO __reorg_rollback(op, table_name, cursor, row_id, row_value)
-              SELECT 'U', TG_TABLE_NAME, order_key, new_id_value, row_to_json(OLD.*);
-          ELSIF (TG_OP = 'INSERT') THEN
-            INSERT INTO __reorg_rollback(op, table_name, cursor, row_id, row_value)
-              SELECT 'I', TG_TABLE_NAME, order_key, new_id_value, null;
-          END IF;
-          RETURN NULL;
-        END;
-        $$ LANGUAGE plpgsql;
+        CREATE INDEX IF NOT EXISTS idx_reorg_rollback_indexer_id_cursor ON __reorg_rollback(indexer_id, cursor);
       `)
     );
   } catch (error) {
@@ -258,19 +248,56 @@ async function initializeReorgRollbackTable(tx) {
       cause: error
     });
   }
+  try {
+    await tx.execute(
+      sql.raw(`
+      CREATE OR REPLACE FUNCTION reorg_checkpoint()
+      RETURNS TRIGGER AS $$
+      DECLARE
+        id_col TEXT := TG_ARGV[0]::TEXT;
+        order_key INTEGER := TG_ARGV[1]::INTEGER;
+        indexer_id TEXT := TG_ARGV[2]::TEXT;
+        new_id_value TEXT := row_to_json(NEW.*)->>id_col;
+        old_id_value TEXT := row_to_json(OLD.*)->>id_col;
+      BEGIN
+        IF (TG_OP = 'DELETE') THEN
+          INSERT INTO __reorg_rollback(op, table_name, cursor, row_id, row_value, indexer_id)
+            SELECT 'D', TG_TABLE_NAME, order_key, old_id_value, row_to_json(OLD.*), indexer_id;
+        ELSIF (TG_OP = 'UPDATE') THEN
+          INSERT INTO __reorg_rollback(op, table_name, cursor, row_id, row_value, indexer_id)
+            SELECT 'U', TG_TABLE_NAME, order_key, new_id_value, row_to_json(OLD.*), indexer_id;
+        ELSIF (TG_OP = 'INSERT') THEN
+          INSERT INTO __reorg_rollback(op, table_name, cursor, row_id, row_value, indexer_id)
+            SELECT 'I', TG_TABLE_NAME, order_key, new_id_value, null, indexer_id;
+        END IF;
+        RETURN NULL;
+      END;
+      $$ LANGUAGE plpgsql;
+    `)
+    );
+  } catch (error) {
+    throw new DrizzleStorageError(
+      "Failed to create reorg checkpoint function",
+      {
+        cause: error
+      }
+    );
+  }
 }
-async function registerTriggers(tx, tables, endCursor, idColumn) {
+async function registerTriggers(tx, tables, endCursor, idColumn, indexerId) {
   try {
     for (const table of tables) {
       await tx.execute(
-        sql.raw(`DROP TRIGGER IF EXISTS ${table}_reorg ON ${table};`)
+        sql.raw(
+          `DROP TRIGGER IF EXISTS ${getReorgTriggerName(table, indexerId)} ON ${table};`
+        )
       );
       await tx.execute(
         sql.raw(`
-          CREATE CONSTRAINT TRIGGER ${table}_reorg
+          CREATE CONSTRAINT TRIGGER ${getReorgTriggerName(table, indexerId)}
           AFTER INSERT OR UPDATE OR DELETE ON ${table}
           DEFERRABLE INITIALLY DEFERRED
-          FOR EACH ROW EXECUTE FUNCTION reorg_checkpoint('${idColumn}', ${`${Number(endCursor.orderKey)}`});
+          FOR EACH ROW EXECUTE FUNCTION reorg_checkpoint('${idColumn}', ${`${Number(endCursor.orderKey)}`}, '${indexerId}');
         `)
       );
     }
@@ -280,11 +307,13 @@ async function registerTriggers(tx, tables, endCursor, idColumn) {
     });
   }
 }
-async function removeTriggers(db, tables) {
+async function removeTriggers(db, tables, indexerId) {
   try {
     for (const table of tables) {
       await db.execute(
-        sql.raw(`DROP TRIGGER IF EXISTS ${table}_reorg ON ${table};`)
+        sql.raw(
+          `DROP TRIGGER IF EXISTS ${getReorgTriggerName(table, indexerId)} ON ${table};`
+        )
       );
     }
   } catch (error) {
@@ -293,12 +322,13 @@ async function removeTriggers(db, tables) {
     });
   }
 }
-async function invalidate(tx, cursor, idColumn) {
+async function invalidate(tx, cursor, idColumn, indexerId) {
   const { rows: result } = await tx.execute(
     sql.raw(`
       WITH deleted AS (
         DELETE FROM __reorg_rollback
         WHERE cursor > ${Number(cursor.orderKey)}
+        AND indexer_id = '${indexerId}'
         RETURNING *
       )
       SELECT * FROM deleted ORDER BY n DESC;
@@ -385,12 +415,13 @@ async function invalidate(tx, cursor, idColumn) {
     }
   }
 }
-async function finalize(tx, cursor) {
+async function finalize(tx, cursor, indexerId) {
   try {
     await tx.execute(
       sql.raw(`
       DELETE FROM __reorg_rollback
       WHERE cursor <= ${Number(cursor.orderKey)}
+      AND indexer_id = '${indexerId}'
     `)
     );
   } catch (error) {
@@ -401,6 +432,7 @@ async function finalize(tx, cursor) {
 }
 
 const DRIZZLE_PROPERTY = "_drizzle";
+const MAX_RETRIES = 5;
 function useDrizzleStorage(_db) {
   const context = useIndexerContext();
   if (!context[DRIZZLE_PROPERTY]) {
@@ -413,12 +445,13 @@ function useDrizzleStorage(_db) {
 function drizzleStorage({
   db,
   persistState: enablePersistence = true,
-  indexerName = "default",
+  indexerName: identifier = "default",
   schema,
   idColumn = "id"
 }) {
   return defineIndexerPlugin((indexer) => {
     let tableNames = [];
+    let indexerId = "";
     try {
       tableNames = Object.values(schema ?? db._.schema ?? {}).map(
         (table) => table.dbName
@@ -429,12 +462,31 @@ function drizzleStorage({
       });
     }
     indexer.hooks.hook("run:before", async () => {
-      await withTransaction(db, async (tx) => {
-        await initializeReorgRollbackTable(tx);
-        if (enablePersistence) {
-          await initializePersistentState(tx);
+      const { indexerName: indexerFileName, availableIndexers } = useInternalContext();
+      indexerId = generateIndexerId(indexerFileName, identifier);
+      let retries = 0;
+      while (retries <= MAX_RETRIES) {
+        try {
+          await withTransaction(db, async (tx) => {
+            await initializeReorgRollbackTable(tx, indexerId);
+            if (enablePersistence) {
+              await initializePersistentState(tx);
+            }
+          });
+          break;
+        } catch (error) {
+          if (retries === MAX_RETRIES) {
+            throw new DrizzleStorageError(
+              "Initialization failed after 5 retries",
+              {
+                cause: error
+              }
+            );
+          }
+          await sleep(retries * 1e3);
+          retries++;
         }
-      });
+      }
     });
     indexer.hooks.hook("connect:before", async ({ request }) => {
       if (!enablePersistence) {
@@ -443,7 +495,7 @@ function drizzleStorage({
       await withTransaction(db, async (tx) => {
         const { cursor, filter } = await getState({
           tx,
-          indexerName
+          indexerId
         });
         if (cursor) {
           request.startingCursor = cursor;
@@ -459,9 +511,9 @@ function drizzleStorage({
         return;
       }
       await withTransaction(db, async (tx) => {
-        await invalidate(tx, cursor, idColumn);
+        await invalidate(tx, cursor, idColumn, indexerId);
         if (enablePersistence) {
-          await invalidateState({ tx, cursor, indexerName });
+          await invalidateState({ tx, cursor, indexerId });
         }
       });
     });
@@ -475,7 +527,7 @@ function drizzleStorage({
           tx,
           endCursor,
           filter: request.filter[1],
-          indexerName
+          indexerId
         });
       }
     });
@@ -485,9 +537,9 @@ function drizzleStorage({
         throw new DrizzleStorageError("Finalized Cursor is undefined");
       }
       await withTransaction(db, async (tx) => {
-        await finalize(tx, cursor);
+        await finalize(tx, cursor, indexerId);
         if (enablePersistence) {
-          await finalizeState({ tx, cursor, indexerName });
+          await finalizeState({ tx, cursor, indexerId });
         }
       });
     });
@@ -497,9 +549,9 @@ function drizzleStorage({
         throw new DrizzleStorageError("Invalidate Cursor is undefined");
       }
       await withTransaction(db, async (tx) => {
-        await invalidate(tx, cursor, idColumn);
+        await invalidate(tx, cursor, idColumn, indexerId);
         if (enablePersistence) {
-          await invalidateState({ tx, cursor, indexerName });
+          await invalidateState({ tx, cursor, indexerId });
         }
       });
     });
@@ -513,7 +565,13 @@ function drizzleStorage({
           await withTransaction(db, async (tx) => {
             context[DRIZZLE_PROPERTY] = { db: tx };
             if (finality !== "finalized") {
-              await registerTriggers(tx, tableNames, endCursor, idColumn);
+              await registerTriggers(
+                tx,
+                tableNames,
+                endCursor,
+                idColumn,
+                indexerId
+              );
             }
             await next();
             delete context[DRIZZLE_PROPERTY];
@@ -521,15 +579,15 @@ function drizzleStorage({
               await persistState({
                 tx,
                 endCursor,
-                indexerName
+                indexerId
               });
             }
           });
           if (finality !== "finalized") {
-            await removeTriggers(db, tableNames);
+            await removeTriggers(db, tableNames, indexerId);
           }
         } catch (error) {
-          await removeTriggers(db, tableNames);
+          await removeTriggers(db, tableNames, indexerId);
           throw new DrizzleStorageError("Failed to run handler:middleware", {
             cause: error
           });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@apibara/plugin-drizzle",
-  "version": "2.0.0-beta.36",
+  "version": "2.0.0-beta.37",
   "type": "module",
   "files": [
     "dist",
@@ -39,8 +39,8 @@
     "vitest": "^1.6.0"
   },
   "dependencies": {
-    "@apibara/indexer": "2.0.0-beta.37",
-    "@apibara/protocol": "2.0.0-beta.37",
+    "@apibara/indexer": "2.0.0-beta.38",
+    "@apibara/protocol": "2.0.0-beta.38",
     "postgres-range": "^1.1.4"
   }
 }

package/src/index.ts

@@ -6,6 +6,8 @@ import type {
   TablesRelationalConfig,
 } from "drizzle-orm";
 
+import { generateIndexerId } from "@apibara/indexer/internal";
+import { useInternalContext } from "@apibara/indexer/internal/plugins";
 import type { Cursor, DataFinality } from "@apibara/protocol";
 import type {
   PgDatabase,
@@ -26,9 +28,10 @@ import {
   registerTriggers,
   removeTriggers,
 } from "./storage";
-import { DrizzleStorageError, withTransaction } from "./utils";
+import { DrizzleStorageError, sleep, withTransaction } from "./utils";
 
 const DRIZZLE_PROPERTY = "_drizzle";
+const MAX_RETRIES = 5;
 
 export type DrizzleStorage<
   TQueryResult extends PgQueryResultHKT,
@@ -91,12 +94,13 @@ export function drizzleStorage<
 >({
   db,
   persistState: enablePersistence = true,
-  indexerName = "default",
+  indexerName: identifier = "default",
   schema,
   idColumn = "id",
 }: DrizzleStorageOptions<TQueryResult, TFullSchema, TSchema>) {
   return defineIndexerPlugin<TFilter, TBlock>((indexer) => {
     let tableNames: string[] = [];
+    let indexerId = "";
 
     try {
       tableNames = Object.values((schema as TSchema) ?? db._.schema ?? {}).map(
@@ -109,12 +113,35 @@ export function drizzleStorage<
     }
 
     indexer.hooks.hook("run:before", async () => {
-      await withTransaction(db, async (tx) => {
-        await initializeReorgRollbackTable(tx);
-        if (enablePersistence) {
-          await initializePersistentState(tx);
+      const { indexerName: indexerFileName, availableIndexers } =
+        useInternalContext();
+
+      indexerId = generateIndexerId(indexerFileName, identifier);
+
+      let retries = 0;
+
+      while (retries <= MAX_RETRIES) {
+        try {
+          await withTransaction(db, async (tx) => {
+            await initializeReorgRollbackTable(tx, indexerId);
+            if (enablePersistence) {
+              await initializePersistentState(tx);
+            }
+          });
+          break;
+        } catch (error) {
+          if (retries === MAX_RETRIES) {
+            throw new DrizzleStorageError(
+              "Initialization failed after 5 retries",
+              {
+                cause: error,
+              },
+            );
+          }
+          await sleep(retries * 1000);
+          retries++;
         }
-      });
+      }
     });
 
     indexer.hooks.hook("connect:before", async ({ request }) => {
@@ -130,7 +157,7 @@ export function drizzleStorage<
           TSchema
         >({
           tx,
-          indexerName,
+          indexerId,
         });
         if (cursor) {
           request.startingCursor = cursor;
@@ -150,10 +177,10 @@ export function drizzleStorage<
       }
 
       await withTransaction(db, async (tx) => {
-        await invalidate(tx, cursor, idColumn);
+        await invalidate(tx, cursor, idColumn, indexerId);
 
         if (enablePersistence) {
-          await invalidateState({ tx, cursor, indexerName });
+          await invalidateState({ tx, cursor, indexerId });
         }
       });
     });
@@ -171,7 +198,7 @@ export function drizzleStorage<
           tx,
           endCursor,
           filter: request.filter[1],
-          indexerName,
+          indexerId,
         });
       }
     });
@@ -184,10 +211,10 @@ export function drizzleStorage<
       }
 
       await withTransaction(db, async (tx) => {
-        await finalize(tx, cursor);
+        await finalize(tx, cursor, indexerId);
 
         if (enablePersistence) {
-          await finalizeState({ tx, cursor, indexerName });
+          await finalizeState({ tx, cursor, indexerId });
         }
       });
     });
@@ -200,10 +227,10 @@ export function drizzleStorage<
       }
 
       await withTransaction(db, async (tx) => {
-        await invalidate(tx, cursor, idColumn);
+        await invalidate(tx, cursor, idColumn, indexerId);
 
         if (enablePersistence) {
-          await invalidateState({ tx, cursor, indexerName });
+          await invalidateState({ tx, cursor, indexerId });
         }
       });
     });
@@ -228,7 +255,13 @@ export function drizzleStorage<
             >;
 
             if (finality !== "finalized") {
-              await registerTriggers(tx, tableNames, endCursor, idColumn);
+              await registerTriggers(
+                tx,
+                tableNames,
+                endCursor,
+                idColumn,
+                indexerId,
+              );
             }
 
             await next();
@@ -238,17 +271,17 @@ export function drizzleStorage<
               await persistState({
                 tx,
                 endCursor,
-                indexerName,
+                indexerId,
               });
             }
           });
 
           if (finality !== "finalized") {
             // remove trigger outside of the transaction or it won't be triggered.
-            await removeTriggers(db, tableNames);
+            await removeTriggers(db, tableNames, indexerId);
           }
         } catch (error) {
-          await removeTriggers(db, tableNames);
+          await removeTriggers(db, tableNames, indexerId);
 
           throw new DrizzleStorageError("Failed to run handler:middleware", {
             cause: error,

package/src/persistence.ts

@@ -141,16 +141,16 @@ export async function persistState<
   tx: PgTransaction<TQueryResult, TFullSchema, TSchema>;
   endCursor: Cursor;
   filter?: TFilter;
-  indexerName: string;
+  indexerId: string;
 }) {
-  const { tx, endCursor, filter, indexerName } = props;
+  const { tx, endCursor, filter, indexerId } = props;
 
   try {
     if (endCursor) {
       await tx
         .insert(checkpoints)
         .values({
-          id: indexerName,
+          id: indexerId,
           orderKey: Number(endCursor.orderKey),
           uniqueKey: endCursor.uniqueKey,
         })
@@ -166,12 +166,12 @@ export async function persistState<
         await tx
           .update(filters)
           .set({ toBlock: Number(endCursor.orderKey) })
-          .where(and(eq(filters.id, indexerName), isNull(filters.toBlock)));
+          .where(and(eq(filters.id, indexerId), isNull(filters.toBlock)));
 
         await tx
           .insert(filters)
           .values({
-            id: indexerName,
+            id: indexerId,
             filter: serialize(filter),
             fromBlock: Number(endCursor.orderKey),
             toBlock: null,
@@ -201,15 +201,15 @@ export async function getState<
     TablesRelationalConfig = ExtractTablesWithRelations<TFullSchema>,
 >(props: {
   tx: PgTransaction<TQueryResult, TFullSchema, TSchema>;
-  indexerName: string;
+  indexerId: string;
 }): Promise<{ cursor?: Cursor; filter?: TFilter }> {
-  const { tx, indexerName } = props;
+  const { tx, indexerId } = props;
 
   try {
     const checkpointRows = await tx
       .select()
       .from(checkpoints)
-      .where(eq(checkpoints.id, indexerName));
+      .where(eq(checkpoints.id, indexerId));
 
     const cursor = checkpointRows[0]
       ? {
@@ -221,7 +221,7 @@ export async function getState<
     const filterRows = await tx
       .select()
       .from(filters)
-      .where(and(eq(filters.id, indexerName), isNull(filters.toBlock)));
+      .where(and(eq(filters.id, indexerId), isNull(filters.toBlock)));
 
     const filter = filterRows[0]
       ? deserialize<TFilter>(filterRows[0].filter)
@@ -243,16 +243,16 @@ export async function invalidateState<
 >(props: {
   tx: PgTransaction<TQueryResult, TFullSchema, TSchema>;
   cursor: Cursor;
-  indexerName: string;
+  indexerId: string;
 }) {
-  const { tx, cursor, indexerName } = props;
+  const { tx, cursor, indexerId } = props;
 
   try {
     await tx
       .delete(filters)
       .where(
         and(
-          eq(filters.id, indexerName),
+          eq(filters.id, indexerId),
           gt(filters.fromBlock, Number(cursor.orderKey)),
         ),
       );
@@ -262,7 +262,7 @@ export async function invalidateState<
       .set({ toBlock: null })
       .where(
         and(
-          eq(filters.id, indexerName),
+          eq(filters.id, indexerId),
           gt(filters.toBlock, Number(cursor.orderKey)),
         ),
       );
@@ -281,16 +281,16 @@ export async function finalizeState<
 >(props: {
   tx: PgTransaction<TQueryResult, TFullSchema, TSchema>;
   cursor: Cursor;
-  indexerName: string;
+  indexerId: string;
 }) {
-  const { tx, cursor, indexerName } = props;
+  const { tx, cursor, indexerId } = props;
 
   try {
     await tx
       .delete(filters)
       .where(
         and(
-          eq(filters.id, indexerName),
+          eq(filters.id, indexerId),
           lt(filters.toBlock, Number(cursor.orderKey)),
         ),
       );

package/src/storage.ts

@@ -16,6 +16,11 @@ import {
   text,
 } from "drizzle-orm/pg-core";
 import { DrizzleStorageError } from "./utils";
+
+function getReorgTriggerName(table: string, indexerId: string) {
+  return `${table}_reorg_${indexerId}`;
+}
+
 export type ReorgOperation = "I" | "U" | "D";
 
 export const reorgRollbackTable = pgTable("__reorg_rollback", {
@@ -25,6 +30,7 @@ export const reorgRollbackTable = pgTable("__reorg_rollback", {
   cursor: integer("cursor").notNull(),
   row_id: text("row_id"),
   row_value: jsonb("row_value"),
+  indexer_id: text("indexer_id").notNull(),
 });
 
 export type ReorgRollbackRow = typeof reorgRollbackTable.$inferSelect;
@@ -34,7 +40,7 @@ export async function initializeReorgRollbackTable<
   TFullSchema extends Record<string, unknown> = Record<string, never>,
   TSchema extends
     TablesRelationalConfig = ExtractTablesWithRelations<TFullSchema>,
->(tx: PgTransaction<TQueryResult, TFullSchema, TSchema>) {
+>(tx: PgTransaction<TQueryResult, TFullSchema, TSchema>, indexerId: string) {
   try {
     // Create the audit log table
     await tx.execute(
@@ -45,35 +51,15 @@ export async function initializeReorgRollbackTable<
           table_name TEXT NOT NULL,
           cursor INTEGER NOT NULL,
           row_id TEXT,
-          row_value JSONB
+          row_value JSONB,
+          indexer_id TEXT NOT NULL
         );
       `),
     );
 
-    // Create the trigger function
     await tx.execute(
       sql.raw(`
-        CREATE OR REPLACE FUNCTION reorg_checkpoint()
-        RETURNS TRIGGER AS $$
-        DECLARE
-          id_col TEXT := TG_ARGV[0]::TEXT;
-          order_key INTEGER := TG_ARGV[1]::INTEGER;
-          new_id_value TEXT := row_to_json(NEW.*)->>id_col;
-          old_id_value TEXT := row_to_json(OLD.*)->>id_col;
-        BEGIN
-          IF (TG_OP = 'DELETE') THEN
-            INSERT INTO __reorg_rollback(op, table_name, cursor, row_id, row_value)
-              SELECT 'D', TG_TABLE_NAME, order_key, old_id_value, row_to_json(OLD.*);
-          ELSIF (TG_OP = 'UPDATE') THEN
-            INSERT INTO __reorg_rollback(op, table_name, cursor, row_id, row_value)
-              SELECT 'U', TG_TABLE_NAME, order_key, new_id_value, row_to_json(OLD.*);
-          ELSIF (TG_OP = 'INSERT') THEN
-            INSERT INTO __reorg_rollback(op, table_name, cursor, row_id, row_value)
-              SELECT 'I', TG_TABLE_NAME, order_key, new_id_value, null;
-          END IF;
-          RETURN NULL;
-        END;
-        $$ LANGUAGE plpgsql;
+        CREATE INDEX IF NOT EXISTS idx_reorg_rollback_indexer_id_cursor ON __reorg_rollback(indexer_id, cursor);
       `),
     );
   } catch (error) {
@@ -81,6 +67,43 @@ export async function initializeReorgRollbackTable<
       cause: error,
     });
   }
+
+  try {
+    // Create the trigger function
+    await tx.execute(
+      sql.raw(`
+      CREATE OR REPLACE FUNCTION reorg_checkpoint()
+      RETURNS TRIGGER AS $$
+      DECLARE
+        id_col TEXT := TG_ARGV[0]::TEXT;
+        order_key INTEGER := TG_ARGV[1]::INTEGER;
+        indexer_id TEXT := TG_ARGV[2]::TEXT;
+        new_id_value TEXT := row_to_json(NEW.*)->>id_col;
+        old_id_value TEXT := row_to_json(OLD.*)->>id_col;
+      BEGIN
+        IF (TG_OP = 'DELETE') THEN
+          INSERT INTO __reorg_rollback(op, table_name, cursor, row_id, row_value, indexer_id)
+            SELECT 'D', TG_TABLE_NAME, order_key, old_id_value, row_to_json(OLD.*), indexer_id;
+        ELSIF (TG_OP = 'UPDATE') THEN
+          INSERT INTO __reorg_rollback(op, table_name, cursor, row_id, row_value, indexer_id)
+            SELECT 'U', TG_TABLE_NAME, order_key, new_id_value, row_to_json(OLD.*), indexer_id;
+        ELSIF (TG_OP = 'INSERT') THEN
+          INSERT INTO __reorg_rollback(op, table_name, cursor, row_id, row_value, indexer_id)
+            SELECT 'I', TG_TABLE_NAME, order_key, new_id_value, null, indexer_id;
+        END IF;
+        RETURN NULL;
+      END;
+      $$ LANGUAGE plpgsql;
+    `),
+    );
+  } catch (error) {
+    throw new DrizzleStorageError(
+      "Failed to create reorg checkpoint function",
+      {
+        cause: error,
+      },
+    );
+  }
 }
 
 export async function registerTriggers<
@@ -93,18 +116,21 @@ export async function registerTriggers<
   tables: string[],
   endCursor: Cursor,
   idColumn: string,
+  indexerId: string,
 ) {
   try {
     for (const table of tables) {
       await tx.execute(
-        sql.raw(`DROP TRIGGER IF EXISTS ${table}_reorg ON ${table};`),
+        sql.raw(
+          `DROP TRIGGER IF EXISTS ${getReorgTriggerName(table, indexerId)} ON ${table};`,
+        ),
       );
       await tx.execute(
         sql.raw(`
-          CREATE CONSTRAINT TRIGGER ${table}_reorg
+          CREATE CONSTRAINT TRIGGER ${getReorgTriggerName(table, indexerId)}
           AFTER INSERT OR UPDATE OR DELETE ON ${table}
           DEFERRABLE INITIALLY DEFERRED
-          FOR EACH ROW EXECUTE FUNCTION reorg_checkpoint('${idColumn}', ${`${Number(endCursor.orderKey)}`});
+          FOR EACH ROW EXECUTE FUNCTION reorg_checkpoint('${idColumn}', ${`${Number(endCursor.orderKey)}`}, '${indexerId}');
         `),
       );
     }
@@ -120,11 +146,17 @@ export async function removeTriggers<
   TFullSchema extends Record<string, unknown> = Record<string, never>,
   TSchema extends
     TablesRelationalConfig = ExtractTablesWithRelations<TFullSchema>,
->(db: PgDatabase<TQueryResult, TFullSchema, TSchema>, tables: string[]) {
+>(
+  db: PgDatabase<TQueryResult, TFullSchema, TSchema>,
+  tables: string[],
+  indexerId: string,
+) {
   try {
     for (const table of tables) {
       await db.execute(
-        sql.raw(`DROP TRIGGER IF EXISTS ${table}_reorg ON ${table};`),
+        sql.raw(
+          `DROP TRIGGER IF EXISTS ${getReorgTriggerName(table, indexerId)} ON ${table};`,
+        ),
       );
     }
   } catch (error) {
@@ -143,6 +175,7 @@ export async function invalidate<
   tx: PgTransaction<TQueryResult, TFullSchema, TSchema>,
   cursor: Cursor,
   idColumn: string,
+  indexerId: string,
 ) {
   // Get and delete operations after cursor in one query, ordered by newest first
   const { rows: result } = (await tx.execute(
@@ -150,6 +183,7 @@ export async function invalidate<
       WITH deleted AS (
         DELETE FROM __reorg_rollback
         WHERE cursor > ${Number(cursor.orderKey)}
+        AND indexer_id = '${indexerId}'
         RETURNING *
       )
       SELECT * FROM deleted ORDER BY n DESC;
@@ -263,12 +297,17 @@ export async function finalize<
   TFullSchema extends Record<string, unknown> = Record<string, never>,
   TSchema extends
     TablesRelationalConfig = ExtractTablesWithRelations<TFullSchema>,
->(tx: PgTransaction<TQueryResult, TFullSchema, TSchema>, cursor: Cursor) {
+>(
+  tx: PgTransaction<TQueryResult, TFullSchema, TSchema>,
+  cursor: Cursor,
+  indexerId: string,
+) {
   try {
     await tx.execute(
       sql.raw(`
       DELETE FROM __reorg_rollback
       WHERE cursor <= ${Number(cursor.orderKey)}
+      AND indexer_id = '${indexerId}'
     `),
     );
   } catch (error) {

package/src/utils.ts

@@ -44,3 +44,7 @@ export function serialize<T>(obj: T): string {
     "\t",
   );
 }
+
+export function sleep(ms: number) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}