@apibara/plugin-sqlite 2.1.0-beta.20 → 2.1.0-beta.21

package/dist/index.cjs

@@ -49,45 +49,56 @@ function initializeKeyValueStore(db) {
   db.exec(statements$1.createTable);
 }
 class KeyValueStore {
-  constructor(db, endCursor, finality, serialize, deserialize) {
+  constructor(db, endCursor, finality, serialize, deserialize, indexerId) {
     this.db = db;
     this.endCursor = endCursor;
     this.finality = finality;
     this.serialize = serialize;
     this.deserialize = deserialize;
+    this.indexerId = indexerId;
     assertInTransaction(db);
   }
   get(key) {
-    const row = this.db.prepare(statements$1.get).get(key);
+    const row = this.db.prepare(statements$1.get).get(key, this.indexerId);
     return row ? this.deserialize(row.v) : void 0;
   }
   put(key, value) {
-    this.db.prepare(statements$1.updateToBlock).run(Number(this.endCursor.orderKey), key);
-    this.db.prepare(statements$1.insertIntoKvs).run(
+    this.db.prepare(statements$1.updateToBlock).run(Number(this.endCursor.orderKey), key, this.indexerId);
+    this.db.prepare(
+      statements$1.insertIntoKvs
+    ).run(
       Number(this.endCursor.orderKey),
       key,
-      this.serialize(value)
+      this.serialize(value),
+      this.indexerId
     );
   }
   del(key) {
-    this.db.prepare(statements$1.del).run(Number(this.endCursor.orderKey), key);
+    this.db.prepare(statements$1.del).run(Number(this.endCursor.orderKey), key, this.indexerId);
   }
 }
-function finalizeKV(db, cursor) {
+function finalizeKV(db, cursor, indexerId) {
   assertInTransaction(db);
   db.prepare(statements$1.finalize).run(
-    Number(cursor.orderKey)
+    Number(cursor.orderKey),
+    indexerId
   );
 }
-function invalidateKV(db, cursor) {
+function invalidateKV(db, cursor, indexerId) {
   assertInTransaction(db);
   db.prepare(statements$1.invalidateDelete).run(
-    Number(cursor.orderKey)
+    Number(cursor.orderKey),
+    indexerId
   );
   db.prepare(statements$1.invalidateUpdate).run(
-    Number(cursor.orderKey)
+    Number(cursor.orderKey),
+    indexerId
   );
 }
+function cleanupKV(db, indexerId) {
+  assertInTransaction(db);
+  db.prepare(statements$1.cleanup).run(indexerId);
+}
 const statements$1 = {
   createTable: `
     CREATE TABLE IF NOT EXISTS kvs (
@@ -95,33 +106,37 @@ const statements$1 = {
       to_block INTEGER,
       k TEXT NOT NULL,
       v BLOB NOT NULL,
-      PRIMARY KEY (from_block, k)
+      id TEXT NOT NULL,
+      PRIMARY KEY (from_block, k, id)
       );`,
   get: `
     SELECT v
     FROM kvs
-    WHERE k = ? AND to_block IS NULL`,
+    WHERE k = ? AND id = ? AND to_block IS NULL`,
   updateToBlock: `
     UPDATE kvs
     SET to_block = ?
-    WHERE k = ? AND to_block IS NULL`,
+    WHERE k = ? AND id = ? AND to_block IS NULL`,
   insertIntoKvs: `
-    INSERT INTO kvs (from_block, to_block, k, v)
-    VALUES (?, NULL, ?, ?)`,
+    INSERT INTO kvs (from_block, to_block, k, v, id)
+    VALUES (?, NULL, ?, ?, ?)`,
   del: `
     UPDATE kvs
     SET to_block = ?
-    WHERE k = ? AND to_block IS NULL`,
+    WHERE k = ? AND id = ? AND to_block IS NULL`,
   finalize: `
     DELETE FROM kvs
-    WHERE to_block <= ?`,
+    WHERE to_block <= ? AND id = ?`,
   invalidateDelete: `
     DELETE FROM kvs
-    WHERE from_block > ?`,
+    WHERE from_block > ? AND id = ?`,
   invalidateUpdate: `
     UPDATE kvs
     SET to_block = NULL
-    WHERE to_block > ?`
+    WHERE to_block > ? AND id = ?`,
+  cleanup: `
+    DELETE FROM kvs
+    WHERE id = ?`
 };
 
 function initializePersistentState(db) {
@@ -189,6 +204,12 @@ function invalidateState(props) {
     Number(cursor.orderKey)
   );
 }
+function resetPersistence(props) {
+  const { db, indexerId } = props;
+  assertInTransaction(db);
+  db.prepare(statements.resetCheckpoint).run(indexerId);
+  db.prepare(statements.resetFilter).run(indexerId);
+}
 const statements = {
   createCheckpointsTable: `
     CREATE TABLE IF NOT EXISTS checkpoints (
@@ -243,7 +264,13 @@ const statements = {
   invalidateFilterUpdate: `
     UPDATE filters
     SET to_block = NULL
-    WHERE id = ? AND to_block > ?`
+    WHERE id = ? AND to_block > ?`,
+  resetCheckpoint: `
+    DELETE FROM checkpoints
+    WHERE id = ?`,
+  resetFilter: `
+    DELETE FROM filters
+    WHERE id = ?`
 };
 
 const KV_PROPERTY = "_kv_sqlite";
@@ -268,10 +295,13 @@ function sqliteStorage({
   return plugins.defineIndexerPlugin((indexer) => {
     let indexerId = "";
     let prevFinality;
+    const alwaysReindex = process.env["APIBARA_ALWAYS_REINDEX"] === "true";
     indexer.hooks.hook("run:before", async () => {
       const { indexerName: indexerFileName, availableIndexers } = plugins$1.useInternalContext();
+      const logger = plugins.useLogger();
       indexerId = internal.generateIndexerId(indexerFileName, identifier);
       let retries = 0;
+      let cleanupApplied = false;
       while (retries <= MAX_RETRIES) {
         try {
           await withTransaction(database, async (db) => {
@@ -281,6 +311,18 @@ function sqliteStorage({
             if (enableKeyValueStore) {
               initializeKeyValueStore(db);
             }
+            if (alwaysReindex && !cleanupApplied) {
+              if (enableKeyValueStore) {
+                logger.warn("Reindexing: Cleaning up key-value store");
+                cleanupKV(db, indexerId);
+              }
+              if (enablePersistState) {
+                logger.warn("Reindexing: Resetting persistence state");
+                resetPersistence({ db, indexerId });
+              }
+              cleanupApplied = true;
+              logger.success("All data has been cleaned up for reindexing");
+            }
           });
           break;
         } catch (error) {
@@ -321,7 +363,7 @@ function sqliteStorage({
           invalidateState({ db, cursor, indexerId });
         }
         if (enableKeyValueStore) {
-          invalidateKV(db, cursor);
+          invalidateKV(db, cursor, indexerId);
         }
       });
     });
@@ -349,7 +391,7 @@ function sqliteStorage({
           finalizeState({ db, cursor, indexerId });
         }
         if (enableKeyValueStore) {
-          finalizeKV(db, cursor);
+          finalizeKV(db, cursor, indexerId);
         }
       });
     });
@@ -363,7 +405,7 @@ function sqliteStorage({
           invalidateState({ db, cursor, indexerId });
         }
         if (enableKeyValueStore) {
-          invalidateKV(db, cursor);
+          invalidateKV(db, cursor, indexerId);
         }
       });
     });
@@ -381,7 +423,7 @@ function sqliteStorage({
         await withTransaction(database, async (db) => {
           if (prevFinality === "pending") {
             if (enableKeyValueStore) {
-              invalidateKV(db, cursor);
+              invalidateKV(db, cursor, indexerId);
             }
           }
           if (enableKeyValueStore) {
@@ -390,7 +432,8 @@ function sqliteStorage({
               endCursor,
               finality,
               serializeFn,
-              deserializeFn
+              deserializeFn,
+              indexerId
             );
           }
           await next();

package/dist/index.d.cts

@@ -11,7 +11,8 @@ declare class KeyValueStore {
     private readonly finality;
     private readonly serialize;
     private readonly deserialize;
-    constructor(db: Database, endCursor: Cursor, finality: DataFinality, serialize: SerializeFn, deserialize: DeserializeFn);
+    private readonly indexerId;
+    constructor(db: Database, endCursor: Cursor, finality: DataFinality, serialize: SerializeFn, deserialize: DeserializeFn, indexerId: string);
     get<T>(key: string): T | undefined;
     put<T>(key: string, value: T): void;
     del(key: string): void;

package/dist/index.d.mts

@@ -11,7 +11,8 @@ declare class KeyValueStore {
     private readonly finality;
     private readonly serialize;
     private readonly deserialize;
-    constructor(db: Database, endCursor: Cursor, finality: DataFinality, serialize: SerializeFn, deserialize: DeserializeFn);
+    private readonly indexerId;
+    constructor(db: Database, endCursor: Cursor, finality: DataFinality, serialize: SerializeFn, deserialize: DeserializeFn, indexerId: string);
     get<T>(key: string): T | undefined;
     put<T>(key: string, value: T): void;
     del(key: string): void;

package/dist/index.d.ts

@@ -11,7 +11,8 @@ declare class KeyValueStore {
     private readonly finality;
     private readonly serialize;
     private readonly deserialize;
-    constructor(db: Database, endCursor: Cursor, finality: DataFinality, serialize: SerializeFn, deserialize: DeserializeFn);
+    private readonly indexerId;
+    constructor(db: Database, endCursor: Cursor, finality: DataFinality, serialize: SerializeFn, deserialize: DeserializeFn, indexerId: string);
     get<T>(key: string): T | undefined;
     put<T>(key: string, value: T): void;
     del(key: string): void;

package/dist/index.mjs

@@ -1,5 +1,5 @@
 import { useIndexerContext } from '@apibara/indexer';
-import { defineIndexerPlugin } from '@apibara/indexer/plugins';
+import { defineIndexerPlugin, useLogger } from '@apibara/indexer/plugins';
 import { generateIndexerId } from '@apibara/indexer/internal';
 import { useInternalContext } from '@apibara/indexer/internal/plugins';
 import { normalizeCursor } from '@apibara/protocol';
@@ -47,45 +47,56 @@ function initializeKeyValueStore(db) {
   db.exec(statements$1.createTable);
 }
 class KeyValueStore {
-  constructor(db, endCursor, finality, serialize, deserialize) {
+  constructor(db, endCursor, finality, serialize, deserialize, indexerId) {
     this.db = db;
     this.endCursor = endCursor;
     this.finality = finality;
     this.serialize = serialize;
     this.deserialize = deserialize;
+    this.indexerId = indexerId;
     assertInTransaction(db);
   }
   get(key) {
-    const row = this.db.prepare(statements$1.get).get(key);
+    const row = this.db.prepare(statements$1.get).get(key, this.indexerId);
     return row ? this.deserialize(row.v) : void 0;
   }
   put(key, value) {
-    this.db.prepare(statements$1.updateToBlock).run(Number(this.endCursor.orderKey), key);
-    this.db.prepare(statements$1.insertIntoKvs).run(
+    this.db.prepare(statements$1.updateToBlock).run(Number(this.endCursor.orderKey), key, this.indexerId);
+    this.db.prepare(
+      statements$1.insertIntoKvs
+    ).run(
       Number(this.endCursor.orderKey),
       key,
-      this.serialize(value)
+      this.serialize(value),
+      this.indexerId
     );
   }
   del(key) {
-    this.db.prepare(statements$1.del).run(Number(this.endCursor.orderKey), key);
+    this.db.prepare(statements$1.del).run(Number(this.endCursor.orderKey), key, this.indexerId);
   }
 }
-function finalizeKV(db, cursor) {
+function finalizeKV(db, cursor, indexerId) {
   assertInTransaction(db);
   db.prepare(statements$1.finalize).run(
-    Number(cursor.orderKey)
+    Number(cursor.orderKey),
+    indexerId
   );
 }
-function invalidateKV(db, cursor) {
+function invalidateKV(db, cursor, indexerId) {
   assertInTransaction(db);
   db.prepare(statements$1.invalidateDelete).run(
-    Number(cursor.orderKey)
+    Number(cursor.orderKey),
+    indexerId
   );
   db.prepare(statements$1.invalidateUpdate).run(
-    Number(cursor.orderKey)
+    Number(cursor.orderKey),
+    indexerId
   );
 }
+function cleanupKV(db, indexerId) {
+  assertInTransaction(db);
+  db.prepare(statements$1.cleanup).run(indexerId);
+}
 const statements$1 = {
   createTable: `
     CREATE TABLE IF NOT EXISTS kvs (
@@ -93,33 +104,37 @@ const statements$1 = {
       to_block INTEGER,
       k TEXT NOT NULL,
       v BLOB NOT NULL,
-      PRIMARY KEY (from_block, k)
+      id TEXT NOT NULL,
+      PRIMARY KEY (from_block, k, id)
       );`,
   get: `
     SELECT v
     FROM kvs
-    WHERE k = ? AND to_block IS NULL`,
+    WHERE k = ? AND id = ? AND to_block IS NULL`,
   updateToBlock: `
     UPDATE kvs
     SET to_block = ?
-    WHERE k = ? AND to_block IS NULL`,
+    WHERE k = ? AND id = ? AND to_block IS NULL`,
   insertIntoKvs: `
-    INSERT INTO kvs (from_block, to_block, k, v)
-    VALUES (?, NULL, ?, ?)`,
+    INSERT INTO kvs (from_block, to_block, k, v, id)
+    VALUES (?, NULL, ?, ?, ?)`,
   del: `
     UPDATE kvs
     SET to_block = ?
-    WHERE k = ? AND to_block IS NULL`,
+    WHERE k = ? AND id = ? AND to_block IS NULL`,
   finalize: `
     DELETE FROM kvs
-    WHERE to_block <= ?`,
+    WHERE to_block <= ? AND id = ?`,
   invalidateDelete: `
     DELETE FROM kvs
-    WHERE from_block > ?`,
+    WHERE from_block > ? AND id = ?`,
   invalidateUpdate: `
     UPDATE kvs
     SET to_block = NULL
-    WHERE to_block > ?`
+    WHERE to_block > ? AND id = ?`,
+  cleanup: `
+    DELETE FROM kvs
+    WHERE id = ?`
 };
 
 function initializePersistentState(db) {
@@ -187,6 +202,12 @@ function invalidateState(props) {
     Number(cursor.orderKey)
   );
 }
+function resetPersistence(props) {
+  const { db, indexerId } = props;
+  assertInTransaction(db);
+  db.prepare(statements.resetCheckpoint).run(indexerId);
+  db.prepare(statements.resetFilter).run(indexerId);
+}
 const statements = {
   createCheckpointsTable: `
     CREATE TABLE IF NOT EXISTS checkpoints (
@@ -241,7 +262,13 @@ const statements = {
   invalidateFilterUpdate: `
     UPDATE filters
     SET to_block = NULL
-    WHERE id = ? AND to_block > ?`
+    WHERE id = ? AND to_block > ?`,
+  resetCheckpoint: `
+    DELETE FROM checkpoints
+    WHERE id = ?`,
+  resetFilter: `
+    DELETE FROM filters
+    WHERE id = ?`
 };
 
 const KV_PROPERTY = "_kv_sqlite";
@@ -266,10 +293,13 @@ function sqliteStorage({
   return defineIndexerPlugin((indexer) => {
     let indexerId = "";
     let prevFinality;
+    const alwaysReindex = process.env["APIBARA_ALWAYS_REINDEX"] === "true";
     indexer.hooks.hook("run:before", async () => {
       const { indexerName: indexerFileName, availableIndexers } = useInternalContext();
+      const logger = useLogger();
       indexerId = generateIndexerId(indexerFileName, identifier);
       let retries = 0;
+      let cleanupApplied = false;
       while (retries <= MAX_RETRIES) {
         try {
           await withTransaction(database, async (db) => {
@@ -279,6 +309,18 @@ function sqliteStorage({
             if (enableKeyValueStore) {
               initializeKeyValueStore(db);
             }
+            if (alwaysReindex && !cleanupApplied) {
+              if (enableKeyValueStore) {
+                logger.warn("Reindexing: Cleaning up key-value store");
+                cleanupKV(db, indexerId);
+              }
+              if (enablePersistState) {
+                logger.warn("Reindexing: Resetting persistence state");
+                resetPersistence({ db, indexerId });
+              }
+              cleanupApplied = true;
+              logger.success("All data has been cleaned up for reindexing");
+            }
           });
           break;
         } catch (error) {
@@ -319,7 +361,7 @@ function sqliteStorage({
           invalidateState({ db, cursor, indexerId });
         }
         if (enableKeyValueStore) {
-          invalidateKV(db, cursor);
+          invalidateKV(db, cursor, indexerId);
         }
       });
     });
@@ -347,7 +389,7 @@ function sqliteStorage({
           finalizeState({ db, cursor, indexerId });
         }
         if (enableKeyValueStore) {
-          finalizeKV(db, cursor);
+          finalizeKV(db, cursor, indexerId);
         }
       });
     });
@@ -361,7 +403,7 @@ function sqliteStorage({
           invalidateState({ db, cursor, indexerId });
         }
         if (enableKeyValueStore) {
-          invalidateKV(db, cursor);
+          invalidateKV(db, cursor, indexerId);
         }
       });
     });
@@ -379,7 +421,7 @@ function sqliteStorage({
         await withTransaction(database, async (db) => {
           if (prevFinality === "pending") {
             if (enableKeyValueStore) {
-              invalidateKV(db, cursor);
+              invalidateKV(db, cursor, indexerId);
             }
           }
           if (enableKeyValueStore) {
@@ -388,7 +430,8 @@ function sqliteStorage({
               endCursor,
               finality,
               serializeFn,
-              deserializeFn
+              deserializeFn,
+              indexerId
             );
           }
           await next();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@apibara/plugin-sqlite",
-  "version": "2.1.0-beta.20",
+  "version": "2.1.0-beta.21",
   "type": "module",
   "files": [
     "dist",
@@ -36,7 +36,7 @@
     "better-sqlite3": "^9.0.0"
   },
   "dependencies": {
-    "@apibara/indexer": "2.1.0-beta.20",
-    "@apibara/protocol": "2.1.0-beta.20"
+    "@apibara/indexer": "2.1.0-beta.21",
+    "@apibara/protocol": "2.1.0-beta.21"
   }
 }

package/src/index.ts

@@ -1,5 +1,5 @@
 import { useIndexerContext } from "@apibara/indexer";
-import { defineIndexerPlugin } from "@apibara/indexer/plugins";
+import { defineIndexerPlugin, useLogger } from "@apibara/indexer/plugins";
 import type { Cursor, DataFinality } from "@apibara/protocol";
 import type { Database as SqliteDatabase } from "better-sqlite3";
 
@@ -7,6 +7,7 @@ import { generateIndexerId } from "@apibara/indexer/internal";
 import { useInternalContext } from "@apibara/indexer/internal/plugins";
 import {
   KeyValueStore,
+  cleanupKV,
   finalizeKV,
   initializeKeyValueStore,
   invalidateKV,
@@ -17,6 +18,7 @@ import {
   initializePersistentState,
   invalidateState,
   persistState,
+  resetPersistence,
 } from "./persistence";
 import {
   type DeserializeFn,
@@ -77,15 +79,20 @@ export function sqliteStorage<TFilter, TBlock>({
   return defineIndexerPlugin<TFilter, TBlock>((indexer) => {
     let indexerId = "";
     let prevFinality: DataFinality | undefined;
+    const alwaysReindex = process.env["APIBARA_ALWAYS_REINDEX"] === "true";
 
     indexer.hooks.hook("run:before", async () => {
       const { indexerName: indexerFileName, availableIndexers } =
         useInternalContext();
 
+      const logger = useLogger();
+
       indexerId = generateIndexerId(indexerFileName, identifier);
 
       let retries = 0;
 
+      let cleanupApplied = false;
+
       while (retries <= MAX_RETRIES) {
         try {
           await withTransaction(database, async (db) => {
@@ -96,6 +103,22 @@ export function sqliteStorage<TFilter, TBlock>({
             if (enableKeyValueStore) {
               initializeKeyValueStore(db);
             }
+
+            if (alwaysReindex && !cleanupApplied) {
+              if (enableKeyValueStore) {
+                logger.warn("Reindexing: Cleaning up key-value store");
+                cleanupKV(db, indexerId);
+              }
+
+              if (enablePersistState) {
+                logger.warn("Reindexing: Resetting persistence state");
+                resetPersistence({ db, indexerId });
+              }
+
+              cleanupApplied = true;
+
+              logger.success("All data has been cleaned up for reindexing");
+            }
           });
           break;
         } catch (error) {
@@ -145,7 +168,7 @@ export function sqliteStorage<TFilter, TBlock>({
         }
 
         if (enableKeyValueStore) {
-          invalidateKV(db, cursor);
+          invalidateKV(db, cursor, indexerId);
         }
       });
     });
@@ -182,7 +205,7 @@ export function sqliteStorage<TFilter, TBlock>({
         }
 
         if (enableKeyValueStore) {
-          finalizeKV(db, cursor);
+          finalizeKV(db, cursor, indexerId);
         }
       });
     });
@@ -200,7 +223,7 @@ export function sqliteStorage<TFilter, TBlock>({
         }
 
         if (enableKeyValueStore) {
-          invalidateKV(db, cursor);
+          invalidateKV(db, cursor, indexerId);
         }
       });
     });
@@ -227,7 +250,7 @@ export function sqliteStorage<TFilter, TBlock>({
           if (prevFinality === "pending") {
             // invalidate if previous block's finality was "pending"
             if (enableKeyValueStore) {
-              invalidateKV(db, cursor);
+              invalidateKV(db, cursor, indexerId);
             }
           }
 
@@ -238,6 +261,7 @@ export function sqliteStorage<TFilter, TBlock>({
               finality,
               serializeFn,
               deserializeFn,
+              indexerId,
             );
           }
 

package/src/kv.ts

@@ -19,64 +19,80 @@ export class KeyValueStore {
     private readonly finality: DataFinality,
     private readonly serialize: SerializeFn,
     private readonly deserialize: DeserializeFn,
+    private readonly indexerId: string,
   ) {
     assertInTransaction(db);
   }
 
   get<T>(key: string): T | undefined {
-    const row = this.db.prepare<string, KeyValueRow>(statements.get).get(key);
+    const row = this.db
+      .prepare<[string, string], KeyValueRow>(statements.get)
+      .get(key, this.indexerId);
 
     return row ? this.deserialize(row.v) : undefined;
   }
 
   put<T>(key: string, value: T) {
     this.db
-      .prepare<[number, string], KeyValueRow>(statements.updateToBlock)
-      .run(Number(this.endCursor.orderKey), key);
+      .prepare<[number, string, string], KeyValueRow>(statements.updateToBlock)
+      .run(Number(this.endCursor.orderKey), key, this.indexerId);
 
     this.db
-      .prepare<[number, string, string], KeyValueRow>(statements.insertIntoKvs)
+      .prepare<[number, string, string, string], KeyValueRow>(
+        statements.insertIntoKvs,
+      )
       .run(
         Number(this.endCursor.orderKey),
         key,
         this.serialize(value as Record<string, unknown>),
+        this.indexerId,
       );
   }
 
   del(key: string) {
     this.db
-      .prepare<[number, string], KeyValueRow>(statements.del)
-      .run(Number(this.endCursor.orderKey), key);
+      .prepare<[number, string, string], KeyValueRow>(statements.del)
+      .run(Number(this.endCursor.orderKey), key, this.indexerId);
   }
 }
 
-export function finalizeKV(db: Database, cursor: Cursor) {
+export function finalizeKV(db: Database, cursor: Cursor, indexerId: string) {
   assertInTransaction(db);
 
-  db.prepare<[number], KeyValueRow>(statements.finalize).run(
+  db.prepare<[number, string], KeyValueRow>(statements.finalize).run(
     Number(cursor.orderKey),
+    indexerId,
   );
 }
 
-export function invalidateKV(db: Database, cursor: Cursor) {
+export function invalidateKV(db: Database, cursor: Cursor, indexerId: string) {
   assertInTransaction(db);
 
   // Delete entries that started after the invalidation cursor
-  db.prepare<[number], KeyValueRow>(statements.invalidateDelete).run(
+  db.prepare<[number, string], KeyValueRow>(statements.invalidateDelete).run(
     Number(cursor.orderKey),
+    indexerId,
   );
 
   // Update entries that were supposed to end after the invalidation cursor
-  db.prepare<[number], KeyValueRow>(statements.invalidateUpdate).run(
+  db.prepare<[number, string], KeyValueRow>(statements.invalidateUpdate).run(
     Number(cursor.orderKey),
+    indexerId,
   );
 }
 
+export function cleanupKV(db: Database, indexerId: string) {
+  assertInTransaction(db);
+
+  db.prepare<[string], KeyValueRow>(statements.cleanup).run(indexerId);
+}
+
 export type KeyValueRow = {
   from_block: number;
   to_block: number;
   k: string;
   v: string;
+  id: string;
 };
 
 const statements = {
@@ -86,31 +102,35 @@ const statements = {
       to_block INTEGER,
       k TEXT NOT NULL,
       v BLOB NOT NULL,
-      PRIMARY KEY (from_block, k)
+      id TEXT NOT NULL,
+      PRIMARY KEY (from_block, k, id)
       );`,
   get: `
     SELECT v
     FROM kvs
-    WHERE k = ? AND to_block IS NULL`,
+    WHERE k = ? AND id = ? AND to_block IS NULL`,
   updateToBlock: `
     UPDATE kvs
     SET to_block = ?
-    WHERE k = ? AND to_block IS NULL`,
+    WHERE k = ? AND id = ? AND to_block IS NULL`,
   insertIntoKvs: `
-    INSERT INTO kvs (from_block, to_block, k, v)
-    VALUES (?, NULL, ?, ?)`,
+    INSERT INTO kvs (from_block, to_block, k, v, id)
+    VALUES (?, NULL, ?, ?, ?)`,
   del: `
     UPDATE kvs
     SET to_block = ?
-    WHERE k = ? AND to_block IS NULL`,
+    WHERE k = ? AND id = ? AND to_block IS NULL`,
   finalize: `
     DELETE FROM kvs
-    WHERE to_block <= ?`,
+    WHERE to_block <= ? AND id = ?`,
   invalidateDelete: `
     DELETE FROM kvs
-    WHERE from_block > ?`,
+    WHERE from_block > ? AND id = ?`,
   invalidateUpdate: `
     UPDATE kvs
     SET to_block = NULL
-    WHERE to_block > ?`,
-};
+    WHERE to_block > ? AND id = ?`,
+  cleanup: `
+    DELETE FROM kvs
+    WHERE id = ?`,
+} as const;

package/src/persistence.ts

@@ -100,6 +100,16 @@ export function invalidateState(props: {
   );
 }
 
+export function resetPersistence(props: {
+  db: Database;
+  indexerId: string;
+}) {
+  const { db, indexerId } = props;
+  assertInTransaction(db);
+  db.prepare<[string]>(statements.resetCheckpoint).run(indexerId);
+  db.prepare<[string]>(statements.resetFilter).run(indexerId);
+}
+
 export type CheckpointRow = {
   id: string;
   order_key: number;
@@ -168,4 +178,10 @@ const statements = {
     UPDATE filters
     SET to_block = NULL
     WHERE id = ? AND to_block > ?`,
+  resetCheckpoint: `
+    DELETE FROM checkpoints
+    WHERE id = ?`,
+  resetFilter: `
+    DELETE FROM filters
+    WHERE id = ?`,
 };