ponder 0.11.21 → 0.11.22

package/src/bin/utils/run.ts

@@ -1,17 +1,5 @@
 import { runCodegen } from "@/bin/utils/codegen.js";
-import {
-  type Database,
-  getPonderCheckpointTable,
-  getPonderMetaTable,
-} from "@/database/index.js";
-import {
-  commitBlock,
-  createIndexes,
-  createTrigger,
-  dropTrigger,
-  finalize,
-  revert,
-} from "@/database/utils.js";
+import type { Database } from "@/database/index.js";
 import { createIndexingCache } from "@/indexing-store/cache.js";
 import { createHistoricalIndexingStore } from "@/indexing-store/historical.js";
 import { createRealtimeIndexingStore } from "@/indexing-store/realtime.js";
@@ -36,8 +24,9 @@ import { recordAsyncGenerator } from "@/utils/generators.js";
 import { mutex } from "@/utils/mutex.js";
 import { never } from "@/utils/never.js";
 import { startClock } from "@/utils/timer.js";
-import { getTableName, is, sql } from "drizzle-orm";
+import { type TableConfig, getTableName, is, sql } from "drizzle-orm";
 import { PgTable } from "drizzle-orm/pg-core";
+import type { PgTableWithColumns } from "drizzle-orm/pg-core";
 
 /** Starts the sync and indexing services for the specified build. */
 export async function run({
@@ -61,12 +50,6 @@ export async function run({
   onFatalError: (error: Error) => void;
   onReloadableError: (error: Error) => void;
 }) {
-  const PONDER_META = getPonderMetaTable(namespaceBuild.schema);
-  const PONDER_CHECKPOINT = getPonderCheckpointTable(namespaceBuild.schema);
-  const tables = Object.values(schemaBuild.schema).filter(
-    (table): table is PgTable => is(table, PgTable),
-  );
-
   await database.migrateSync();
 
   runCodegen({ common });
@@ -111,12 +94,6 @@ export async function run({
     eventCount,
   });
 
-  const historicalIndexingStore = createHistoricalIndexingStore({
-    common,
-    schemaBuild,
-    indexingCache,
-  });
-
   for (const chain of indexingBuild.chains) {
     const label = { chain: chain.name };
     common.metrics.ponder_historical_total_indexing_seconds.set(
@@ -152,50 +129,47 @@ export async function run({
 
   // If the initial checkpoint is zero, we need to run setup events.
   if (crashRecoveryCheckpoint === undefined) {
-    await database.userQB().transaction(async (tx) => {
-      historicalIndexingStore.qb = tx;
-      indexingCache.qb = tx;
-
-      const result = await indexing.processSetupEvents({
-        db: historicalIndexingStore,
-      });
-
-      if (result.status === "error") {
-        onReloadableError(result.error);
-        return;
-      }
+    await database.retry(async () => {
+      await database.transaction(async (client, tx) => {
+        const historicalIndexingStore = createHistoricalIndexingStore({
+          common,
+          schemaBuild,
+          indexingCache,
+          db: tx,
+          client,
+        });
+        const result = await indexing.processSetupEvents({
+          db: historicalIndexingStore,
+        });
 
-      try {
-        await indexingCache.flush();
-      } catch (error) {
-        if (error instanceof FlushError) {
-          onReloadableError(error as Error);
+        if (result.status === "error") {
+          onReloadableError(result.error);
           return;
         }
-        throw error;
-      }
+
+        try {
+          await indexingCache.flush({ client });
+        } catch (error) {
+          if (error instanceof FlushError) {
+            onReloadableError(error as Error);
+            return;
+          }
+          throw error;
+        }
+      });
     });
   }
 
   // Note: `_ponder_checkpoint` must be updated after the setup events are processed.
-  await database
-    .adminQB("update_checkpoints")
-    .insert(PONDER_CHECKPOINT)
-    .values(
-      indexingBuild.chains.map((chain) => ({
-        chainName: chain.name,
-        chainId: chain.id,
-        latestCheckpoint: sync.getStartCheckpoint(chain),
-        safeCheckpoint: sync.getStartCheckpoint(chain),
-      })),
-    )
-    .onConflictDoUpdate({
-      target: PONDER_CHECKPOINT.chainName,
-      set: {
-        safeCheckpoint: sql`excluded.safe_checkpoint`,
-        latestCheckpoint: sql`excluded.latest_checkpoint`,
-      },
-    });
+  await database.setCheckpoints({
+    checkpoints: indexingBuild.chains.map((chain) => ({
+      chainName: chain.name,
+      chainId: chain.id,
+      latestCheckpoint: sync.getStartCheckpoint(chain),
+      safeCheckpoint: sync.getStartCheckpoint(chain),
+    })),
+    db: database.qb.drizzle,
+  });
 
   // Run historical indexing until complete.
   for await (const events of recordAsyncGenerator(
@@ -213,10 +187,14 @@ export async function run({
   )) {
     let endClock = startClock();
 
-    indexingCache.qb = database.userQB;
     await Promise.all([
-      indexingCache.prefetch({ events: events.events }),
-      cachedViemClient.prefetch({ events: events.events }),
+      indexingCache.prefetch({
+        events: events.events,
+        db: database.qb.drizzle,
+      }),
+      cachedViemClient.prefetch({
+        events: events.events,
+      }),
     ]);
     common.metrics.ponder_historical_transform_duration.inc(
       { step: "prefetch" },
@@ -224,167 +202,161 @@ export async function run({
     );
     if (events.events.length > 0) {
       endClock = startClock();
+      await database.retry(async () => {
+        await database
+          .transaction(async (client, tx) => {
+            common.metrics.ponder_historical_transform_duration.inc(
+              { step: "begin" },
+              endClock(),
+            );
 
-      await database
-        .userQB()
-        .transaction(async (tx) => {
-          historicalIndexingStore.qb = tx;
-          indexingCache.qb = tx;
-
-          common.metrics.ponder_historical_transform_duration.inc(
-            { step: "begin" },
-            endClock(),
-          );
-
-          endClock = startClock();
-
-          const eventChunks = chunk(events.events, 93);
-          for (const eventChunk of eventChunks) {
-            const result = await indexing.processEvents({
-              events: eventChunk,
-              db: historicalIndexingStore,
-              cache: indexingCache,
+            endClock = startClock();
+            const historicalIndexingStore = createHistoricalIndexingStore({
+              common,
+              schemaBuild,
+              indexingCache,
+              db: tx,
+              client,
             });
 
-            if (result.status === "error") {
-              onReloadableError(result.error);
-              return;
-            }
+            const eventChunks = chunk(events.events, 93);
+            for (const eventChunk of eventChunks) {
+              const result = await indexing.processEvents({
+                events: eventChunk,
+                db: historicalIndexingStore,
+                cache: indexingCache,
+              });
 
-            const checkpoint = decodeCheckpoint(
-              eventChunk[eventChunk.length - 1]!.checkpoint,
-            );
+              if (result.status === "error") {
+                onReloadableError(result.error);
+                return;
+              }
 
-            if (preBuild.ordering === "multichain") {
-              const chain = indexingBuild.chains.find(
-                (chain) => chain.id === Number(checkpoint.chainId),
-              )!;
-              common.metrics.ponder_historical_completed_indexing_seconds.set(
-                { chain: chain.name },
-                Math.max(
-                  Number(checkpoint.blockTimestamp) -
-                    Math.max(
-                      sync.seconds[chain.name]!.cached,
-                      sync.seconds[chain.name]!.start,
-                    ),
-                  0,
-                ),
+              const checkpoint = decodeCheckpoint(
+                eventChunk[eventChunk.length - 1]!.checkpoint,
               );
-              common.metrics.ponder_indexing_timestamp.set(
-                { chain: chain.name },
-                Number(checkpoint.blockTimestamp),
-              );
-            } else {
-              for (const chain of indexingBuild.chains) {
+
+              if (preBuild.ordering === "multichain") {
+                const chain = indexingBuild.chains.find(
+                  (chain) => chain.id === Number(checkpoint.chainId),
+                )!;
                 common.metrics.ponder_historical_completed_indexing_seconds.set(
                   { chain: chain.name },
-                  Math.min(
-                    Math.max(
-                      Number(checkpoint.blockTimestamp) -
-                        Math.max(
-                          sync.seconds[chain.name]!.cached,
-                          sync.seconds[chain.name]!.start,
-                        ),
-                      0,
-                    ),
-                    Math.max(
-                      sync.seconds[chain.name]!.end -
+                  Math.max(
+                    Number(checkpoint.blockTimestamp) -
+                      Math.max(
+                        sync.seconds[chain.name]!.cached,
                         sync.seconds[chain.name]!.start,
-                      0,
-                    ),
+                      ),
+                    0,
                   ),
                 );
                 common.metrics.ponder_indexing_timestamp.set(
                   { chain: chain.name },
-                  Math.max(
-                    Number(checkpoint.blockTimestamp),
-                    sync.seconds[chain.name]!.end,
-                  ),
+                  Number(checkpoint.blockTimestamp),
                 );
+              } else {
+                for (const chain of indexingBuild.chains) {
+                  common.metrics.ponder_historical_completed_indexing_seconds.set(
+                    { chain: chain.name },
+                    Math.min(
+                      Math.max(
+                        Number(checkpoint.blockTimestamp) -
+                          Math.max(
+                            sync.seconds[chain.name]!.cached,
+                            sync.seconds[chain.name]!.start,
+                          ),
+                        0,
+                      ),
+                      Math.max(
+                        sync.seconds[chain.name]!.end -
+                          sync.seconds[chain.name]!.start,
+                        0,
+                      ),
+                    ),
+                  );
+                  common.metrics.ponder_indexing_timestamp.set(
+                    { chain: chain.name },
+                    Math.max(
+                      Number(checkpoint.blockTimestamp),
+                      sync.seconds[chain.name]!.end,
+                    ),
+                  );
+                }
               }
-            }
 
-            // Note: allows for terminal and logs to be updated
-            if (preBuild.databaseConfig.kind === "pglite") {
-              await new Promise(setImmediate);
+              // Note: allows for terminal and logs to be updated
+              if (preBuild.databaseConfig.kind === "pglite") {
+                await new Promise(setImmediate);
+              }
+            }
+            await new Promise(setImmediate);
+
+            // underlying metrics collection is actually synchronous
+            // https://github.com/siimon/prom-client/blob/master/lib/histogram.js#L102-L125
+            const { eta, progress } = await getAppProgress(common.metrics);
+            if (eta === undefined || progress === undefined) {
+              common.logger.info({
+                service: "app",
+                msg: `Indexed ${events.events.length} events`,
+              });
+            } else {
+              common.logger.info({
+                service: "app",
+                msg: `Indexed ${events.events.length} events with ${formatPercentage(progress)} complete and ${formatEta(eta * 1_000)} remaining`,
+              });
             }
-          }
-          await new Promise(setImmediate);
 
-          // underlying metrics collection is actually synchronous
-          // https://github.com/siimon/prom-client/blob/master/lib/histogram.js#L102-L125
-          const { eta, progress } = await getAppProgress(common.metrics);
-          if (eta === undefined || progress === undefined) {
-            common.logger.info({
-              service: "app",
-              msg: `Indexed ${events.events.length} events`,
-            });
-          } else {
-            common.logger.info({
-              service: "app",
-              msg: `Indexed ${events.events.length} events with ${formatPercentage(progress)} complete and ${formatEta(eta * 1_000)} remaining`,
-            });
-          }
+            common.metrics.ponder_historical_transform_duration.inc(
+              { step: "index" },
+              endClock(),
+            );
+
+            endClock = startClock();
+            // Note: at this point, the next events can be preloaded, as long as the are not indexed until
+            // the "flush" + "finalize" is complete.
 
-          common.metrics.ponder_historical_transform_duration.inc(
-            { step: "index" },
-            endClock(),
-          );
-
-          endClock = startClock();
-          // Note: at this point, the next events can be preloaded, as long as the are not indexed until
-          // the "flush" + "finalize" is complete.
-
-          try {
-            await indexingCache.flush();
-          } catch (error) {
-            if (error instanceof FlushError) {
-              onReloadableError(error as Error);
-              return;
+            try {
+              await indexingCache.flush({ client });
+            } catch (error) {
+              if (error instanceof FlushError) {
+                onReloadableError(error as Error);
+                return;
+              }
+              throw error;
             }
-            throw error;
-          }
 
-          common.metrics.ponder_historical_transform_duration.inc(
-            { step: "load" },
-            endClock(),
-          );
-          endClock = startClock();
-
-          if (events.checkpoints.length > 0) {
-            await database
-              .adminQB("update_checkpoints")
-              .insert(PONDER_CHECKPOINT)
-              .values(
-                events.checkpoints.map(({ chainId, checkpoint }) => ({
+            common.metrics.ponder_historical_transform_duration.inc(
+              { step: "load" },
+              endClock(),
+            );
+            endClock = startClock();
+
+            await database.setCheckpoints({
+              checkpoints: events.checkpoints.map(
+                ({ chainId, checkpoint }) => ({
                   chainName: indexingBuild.chains.find(
                     (chain) => chain.id === chainId,
                   )!.name,
                   chainId,
                   latestCheckpoint: checkpoint,
                   safeCheckpoint: checkpoint,
-                })),
-              )
-              .onConflictDoUpdate({
-                target: PONDER_CHECKPOINT.chainName,
-                set: {
-                  safeCheckpoint: sql`excluded.safe_checkpoint`,
-                  latestCheckpoint: sql`excluded.latest_checkpoint`,
-                },
-              });
-          }
-
-          common.metrics.ponder_historical_transform_duration.inc(
-            { step: "finalize" },
-            endClock(),
-          );
-          endClock = startClock();
-        })
-        .catch((error) => {
-          indexingCache.rollback();
-          throw error;
-        });
+                }),
+              ),
+              db: tx,
+            });
 
+            common.metrics.ponder_historical_transform_duration.inc(
+              { step: "finalize" },
+              endClock(),
+            );
+            endClock = startClock();
+          })
+          .catch((error) => {
+            indexingCache.rollback();
+            throw error;
+          });
+      });
       cachedViemClient.clear();
       common.metrics.ponder_historical_transform_duration.inc(
         { step: "commit" },
@@ -428,26 +400,28 @@ export async function run({
     msg: "Completed historical indexing",
   });
 
-  await createIndexes(database.adminQB, { statements: schemaBuild.statements });
-  await Promise.all(
-    tables.map((table) => createTrigger(database.adminQB, { table })),
-  );
+  await database.createIndexes();
+  await database.createTriggers();
 
   if (namespaceBuild.viewsSchema) {
-    await database.adminQB("create_views").transaction(async (tx) => {
-      await tx().execute(
+    await database.wrap({ method: "create-views" }, async () => {
+      await database.qb.drizzle.execute(
         sql.raw(`CREATE SCHEMA IF NOT EXISTS "${namespaceBuild.viewsSchema}"`),
       );
 
+      const tables = Object.values(schemaBuild.schema).filter(
+        (table): table is PgTableWithColumns<TableConfig> => is(table, PgTable),
+      );
+
       for (const table of tables) {
         // Note: drop views before creating new ones to avoid enum errors.
-        await tx().execute(
+        await database.qb.drizzle.execute(
           sql.raw(
             `DROP VIEW IF EXISTS "${namespaceBuild.viewsSchema}"."${getTableName(table)}"`,
           ),
         );
 
-        await tx().execute(
+        await database.qb.drizzle.execute(
           sql.raw(
             `CREATE VIEW "${namespaceBuild.viewsSchema}"."${getTableName(table)}" AS SELECT * FROM "${namespaceBuild.schema}"."${getTableName(table)}"`,
           ),
@@ -459,13 +433,13 @@ export async function run({
         msg: `Created ${tables.length} views in schema "${namespaceBuild.viewsSchema}"`,
       });
 
-      await tx().execute(
+      await database.qb.drizzle.execute(
         sql.raw(
           `CREATE OR REPLACE VIEW "${namespaceBuild.viewsSchema}"."_ponder_meta" AS SELECT * FROM "${namespaceBuild.schema}"."_ponder_meta"`,
         ),
       );
 
-      await tx().execute(
+      await database.qb.drizzle.execute(
         sql.raw(
           `CREATE OR REPLACE VIEW "${namespaceBuild.viewsSchema}"."_ponder_checkpoint" AS SELECT * FROM "${namespaceBuild.schema}"."_ponder_checkpoint"`,
         ),
@@ -475,7 +449,7 @@ export async function run({
       const notification = "status_notify()";
       const channel = `${namespaceBuild.viewsSchema}_status_channel`;
 
-      await tx().execute(
+      await database.qb.drizzle.execute(
         sql.raw(`
   CREATE OR REPLACE FUNCTION "${namespaceBuild.viewsSchema}".${notification}
   RETURNS TRIGGER
@@ -488,7 +462,7 @@ export async function run({
   $$;`),
       );
 
-      await tx().execute(
+      await database.qb.drizzle.execute(
         sql.raw(`
   CREATE OR REPLACE TRIGGER "${trigger}"
   AFTER INSERT OR UPDATE OR DELETE
@@ -499,16 +473,13 @@ export async function run({
     });
   }
 
-  await database
-    .adminQB("set_ready")
-    .update(PONDER_META)
-    .set({ value: sql`jsonb_set(value, '{is_ready}', to_jsonb(1))` });
+  await database.setReady();
 
   const realtimeIndexingStore = createRealtimeIndexingStore({
     common,
     schemaBuild,
+    database,
   });
-  realtimeIndexingStore.qb = database.userQB;
 
   const onRealtimeEvent = mutex(async (event: RealtimeEvent) => {
     switch (event.type) {
@@ -542,11 +513,7 @@ export async function run({
 
             if (result.status === "error") onReloadableError(result.error);
 
-            await Promise.all(
-              tables.map((table) =>
-                commitBlock(database.userQB, { table, checkpoint }),
-              ),
-            );
+            await database.commitBlock({ checkpoint, db: database.qb.drizzle });
 
             if (preBuild.ordering === "multichain") {
               common.metrics.ponder_indexing_timestamp.set(
@@ -564,10 +531,11 @@ export async function run({
           }
         }
 
-        if (event.checkpoints.length > 0) {
-          await database
-            .adminQB("update_checkpoints")
-            .insert(PONDER_CHECKPOINT)
+        await database.wrap({ method: "setCheckpoints" }, async () => {
+          if (event.checkpoints.length === 0) return;
+
+          await database.qb.drizzle
+            .insert(database.PONDER_CHECKPOINT)
             .values(
               event.checkpoints.map(({ chainId, checkpoint }) => ({
                 chainName: indexingBuild.chains.find(
@@ -579,10 +547,12 @@ export async function run({
               })),
             )
             .onConflictDoUpdate({
-              target: PONDER_CHECKPOINT.chainName,
-              set: { latestCheckpoint: sql`excluded.latest_checkpoint` },
+              target: database.PONDER_CHECKPOINT.chainName,
+              set: {
+                latestCheckpoint: sql`excluded.latest_checkpoint`,
+              },
             });
-        }
+        });
 
         break;
       }
@@ -590,41 +560,25 @@ export async function run({
         // Note: `_ponder_checkpoint` is not called here, instead it is called
         // in the `block` case.
 
-        await database.userQB().transaction(async (tx) => {
-          for (const table of tables) {
-            await dropTrigger(tx, { table });
-            const count = await revert(tx, {
-              table,
-              checkpoint: event.checkpoint,
-            });
-            common.logger.info({
-              service: "database",
-              msg: `Reverted ${count} unfinalized operations from '${getTableName(table)}'`,
-            });
-            await createTrigger(tx, { table });
-          }
+        await database.removeTriggers();
+        await database.retry(async () => {
+          await database.qb.drizzle.transaction(async (tx) => {
+            await database.revert({ checkpoint: event.checkpoint, tx });
+          });
         });
+        await database.createTriggers();
 
         break;
 
       case "finalize":
-        await database.userQB().transaction(async (tx) => {
-          await tx("update_checkpoints").update(PONDER_CHECKPOINT).set({
-            safeCheckpoint: event.checkpoint,
-          });
-
-          for (const table of tables) {
-            await finalize(tx, { table, checkpoint: event.checkpoint });
-
-            const decoded = decodeCheckpoint(event.checkpoint);
-
-            common.logger.debug({
-              service: "database",
-              msg: `Updated finalized checkpoint to (timestamp=${decoded.blockTimestamp} chainId=${decoded.chainId} block=${decoded.blockNumber})`,
-            });
-          }
+        await database.qb.drizzle.update(database.PONDER_CHECKPOINT).set({
+          safeCheckpoint: event.checkpoint,
         });
 
+        await database.finalize({
+          checkpoint: event.checkpoint,
+          db: database.qb.drizzle,
+        });
         break;
 
       default: