ponder 0.11.21 → 0.11.22

package/src/indexing-store/realtime.ts

@@ -1,4 +1,4 @@
-import type { QB } from "@/database/queryBuilder.js";
+import type { Database } from "@/database/index.js";
 import { getPrimaryKeyColumns } from "@/drizzle/index.js";
 import type { Common } from "@/internal/common.js";
 import { RecordNotFoundError } from "@/internal/errors.js";
@@ -10,6 +10,7 @@ import { drizzle } from "drizzle-orm/pg-proxy";
 import {
   type IndexingStore,
   checkOnchainTable,
+  parseSqlError,
   validateUpdateSet,
 } from "./index.js";
 import { getCacheKey, getWhereCondition } from "./utils.js";
@@ -17,14 +18,14 @@ import { getCacheKey, getWhereCondition } from "./utils.js";
 export const createRealtimeIndexingStore = ({
   common,
   schemaBuild: { schema },
+  database,
 }: {
   common: Common;
   schemaBuild: Pick<SchemaBuild, "schema">;
+  database: Database;
 }): IndexingStore => {
-  let qb: QB = undefined!;
-
   const find = (table: Table, key: object) => {
-    return qb()
+    return database.qb.drizzle
       .select()
       .from(table)
       .where(getWhereCondition(table, key))
@@ -33,144 +34,177 @@ export const createRealtimeIndexingStore = ({
 
   return {
     // @ts-ignore
-    find: async (table: Table, key) => {
-      common.metrics.ponder_indexing_store_queries_total.inc({
-        table: getTableName(table),
-        method: "find",
-      });
-      checkOnchainTable(table, "find");
-      return find(table, key);
-    },
+    find: (table: Table, key) =>
+      database.retry(async () => {
+        common.metrics.ponder_indexing_store_queries_total.inc({
+          table: getTableName(table),
+          method: "find",
+        });
+        checkOnchainTable(table, "find");
+        return find(table, key);
+      }),
     // @ts-ignore
     insert(table: Table) {
       return {
         values: (values: any) => {
           // @ts-ignore
           const inner = {
-            onConflictDoNothing: async () => {
-              common.metrics.ponder_indexing_store_queries_total.inc({
-                table: getTableName(table),
-                method: "insert",
-              });
-              checkOnchainTable(table, "insert");
+            onConflictDoNothing: () =>
+              database.retry(async () => {
+                common.metrics.ponder_indexing_store_queries_total.inc({
+                  table: getTableName(table),
+                  method: "insert",
+                });
+                checkOnchainTable(table, "insert");
 
-              const parseResult = (result: { [x: string]: any }[]) => {
-                if (Array.isArray(values) === false) {
-                  return result.length === 1 ? result[0] : null;
-                }
+                const parseResult = (result: { [x: string]: any }[]) => {
+                  if (Array.isArray(values) === false) {
+                    return result.length === 1 ? result[0] : null;
+                  }
 
-                if (result.length === 0) {
-                  return new Array(values.length).fill(null);
-                }
+                  if (result.length === 0) {
+                    return new Array(values.length).fill(null);
+                  }
 
-                const rows = [];
-                let resultIndex = 0;
+                  const rows = [];
+                  let resultIndex = 0;
 
-                for (let i = 0; i < values.length; i++) {
-                  if (
-                    getCacheKey(table, values[i]) ===
-                    getCacheKey(table, result[resultIndex]!)
-                  ) {
-                    rows.push(result[resultIndex++]!);
-                  } else {
-                    rows.push(null);
+                  for (let i = 0; i < values.length; i++) {
+                    if (
+                      getCacheKey(table, values[i]) ===
+                      getCacheKey(table, result[resultIndex]!)
+                    ) {
+                      rows.push(result[resultIndex++]!);
+                    } else {
+                      rows.push(null);
+                    }
                   }
-                }
 
-                return rows;
-              };
+                  return rows;
+                };
 
-              return qb()
-                .insert(table)
-                .values(values)
-                .onConflictDoNothing()
-                .returning()
-                .then(parseResult);
-            },
-            onConflictDoUpdate: async (valuesU: any) => {
-              common.metrics.ponder_indexing_store_queries_total.inc({
-                table: getTableName(table),
-                method: "insert",
-              });
-              checkOnchainTable(table, "insert");
+                try {
+                  return await database.qb.drizzle
+                    .insert(table)
+                    .values(values)
+                    .onConflictDoNothing()
+                    .returning()
+                    .then(parseResult);
+                } catch (e) {
+                  throw parseSqlError(e);
+                }
+              }),
+            onConflictDoUpdate: (valuesU: any) =>
+              database.retry(async () => {
+                common.metrics.ponder_indexing_store_queries_total.inc({
+                  table: getTableName(table),
+                  method: "insert",
+                });
+                checkOnchainTable(table, "insert");
 
-              if (typeof valuesU === "object") {
-                const set = validateUpdateSet(table, valuesU);
-                return qb()
-                  .insert(table)
-                  .values(values)
-                  .onConflictDoUpdate({
-                    target: getPrimaryKeyColumns(table).map(
-                      // @ts-ignore
-                      ({ js }) => table[js],
-                    ),
-                    set,
-                  })
-                  .returning()
-                  .then((res) => (Array.isArray(values) ? res : res[0]));
-              }
+                if (typeof valuesU === "object") {
+                  try {
+                    const set = validateUpdateSet(table, valuesU);
+                    return await database.qb.drizzle
+                      .insert(table)
+                      .values(values)
+                      .onConflictDoUpdate({
+                        target: getPrimaryKeyColumns(table).map(
+                          // @ts-ignore
+                          ({ js }) => table[js],
+                        ),
+                        set,
+                      })
+                      .returning()
+                      .then((res) => (Array.isArray(values) ? res : res[0]));
+                  } catch (e) {
+                    throw parseSqlError(e);
+                  }
+                }
 
-              if (Array.isArray(values)) {
-                const rows = [];
-                for (const value of values) {
-                  const row = await find(table, value);
+                if (Array.isArray(values)) {
+                  const rows = [];
+                  for (const value of values) {
+                    const row = await find(table, value);
+
+                    if (row === null) {
+                      try {
+                        rows.push(
+                          await database.qb.drizzle
+                            .insert(table)
+                            .values(value)
+                            .returning()
+                            .then((res) => res[0]),
+                        );
+                      } catch (e) {
+                        throw parseSqlError(e);
+                      }
+                    } else {
+                      try {
+                        const set = validateUpdateSet(table, valuesU(row));
+                        rows.push(
+                          await database.qb.drizzle
+                            .update(table)
+                            .set(set)
+                            .where(getWhereCondition(table, value))
+                            .returning()
+                            .then((res) => res[0]),
+                        );
+                      } catch (e) {
+                        throw parseSqlError(e);
+                      }
+                    }
+                  }
+                  return rows;
+                } else {
+                  const row = await find(table, values);
 
                   if (row === null) {
-                    rows.push(
-                      await qb()
+                    try {
+                      return await database.qb.drizzle
                         .insert(table)
-                        .values(value)
+                        .values(values)
                         .returning()
-                        .then((res) => res[0]),
-                    );
+                        .then((res) => res[0]);
+                    } catch (e) {
+                      throw parseSqlError(e);
+                    }
                   } else {
-                    const set = validateUpdateSet(table, valuesU(row));
-                    rows.push(
-                      await qb()
+                    try {
+                      const set = validateUpdateSet(table, valuesU(row));
+                      return await database.qb.drizzle
                         .update(table)
                         .set(set)
-                        .where(getWhereCondition(table, value))
+                        .where(getWhereCondition(table, values))
                         .returning()
-                        .then((res) => res[0]),
-                    );
+                        .then((res) => res[0]);
+                    } catch (e) {
+                      throw parseSqlError(e);
+                    }
                   }
                 }
-                return rows;
-              } else {
-                const row = await find(table, values);
-
-                if (row === null) {
-                  return qb()
-                    .insert(table)
-                    .values(values)
-                    .returning()
-                    .then((res) => res[0]);
-                } else {
-                  const set = validateUpdateSet(table, valuesU(row));
-                  return qb()
-                    .update(table)
-                    .set(set)
-                    .where(getWhereCondition(table, values))
-                    .returning()
-                    .then((res) => res[0]);
-                }
-              }
-            },
+              }),
             // biome-ignore lint/suspicious/noThenProperty: <explanation>
             then: (onFulfilled, onRejected) =>
-              (async () => {
-                common.metrics.ponder_indexing_store_queries_total.inc({
-                  table: getTableName(table),
-                  method: "insert",
-                });
-                checkOnchainTable(table, "insert");
+              database
+                .retry(async () => {
+                  common.metrics.ponder_indexing_store_queries_total.inc({
+                    table: getTableName(table),
+                    method: "insert",
+                  });
+                  checkOnchainTable(table, "insert");
 
-                return qb()
-                  .insert(table)
-                  .values(values)
-                  .returning()
-                  .then((res) => (Array.isArray(values) ? res : res[0]));
-              })().then(onFulfilled, onRejected),
+                  try {
+                    return await database.qb.drizzle
+                      .insert(table)
+                      .values(values)
+                      .returning()
+                      .then((res) => (Array.isArray(values) ? res : res[0]));
+                  } catch (e) {
+                    throw parseSqlError(e);
+                  }
+                })
+                .then(onFulfilled, onRejected),
             catch: (onRejected) => inner.then(undefined, onRejected),
             finally: (onFinally) =>
               inner.then(
@@ -193,86 +227,96 @@ export const createRealtimeIndexingStore = ({
     // @ts-ignore
     update(table: Table, key) {
       return {
-        set: async (values: any) => {
-          common.metrics.ponder_indexing_store_queries_total.inc({
-            table: getTableName(table),
-            method: "update",
-          });
-          checkOnchainTable(table, "update");
+        set: (values: any) =>
+          database.retry(async () => {
+            common.metrics.ponder_indexing_store_queries_total.inc({
+              table: getTableName(table),
+              method: "update",
+            });
+            checkOnchainTable(table, "update");
 
-          if (typeof values === "function") {
-            const row = await find(table, key);
+            if (typeof values === "function") {
+              const row = await find(table, key);
 
-            if (row === null) {
-              const error = new RecordNotFoundError(
-                `No existing record found in table '${getTableName(table)}'`,
-              );
-              error.meta.push(`db.update arguments:\n${prettyPrint(key)}`);
-              throw error;
-            }
+              if (row === null) {
+                const error = new RecordNotFoundError(
+                  `No existing record found in table '${getTableName(table)}'`,
+                );
+                error.meta.push(`db.update arguments:\n${prettyPrint(key)}`);
+                throw error;
+              }
 
-            const set = validateUpdateSet(table, values(row));
-            return qb()
-              .update(table)
-              .set(set)
-              .where(getWhereCondition(table, key))
-              .returning()
-              .then((res) => res[0]);
-          } else {
-            const set = validateUpdateSet(table, values);
-            return qb()
-              .update(table)
-              .set(set)
-              .where(getWhereCondition(table, key))
-              .returning()
-              .then((res) => res[0]);
-          }
-        },
+              try {
+                const set = validateUpdateSet(table, values(row));
+                return await database.qb.drizzle
+                  .update(table)
+                  .set(set)
+                  .where(getWhereCondition(table, key))
+                  .returning()
+                  .then((res) => res[0]);
+              } catch (e) {
+                throw parseSqlError(e);
+              }
+            } else {
+              try {
+                const set = validateUpdateSet(table, values);
+                return await database.qb.drizzle
+                  .update(table)
+                  .set(set)
+                  .where(getWhereCondition(table, key))
+                  .returning()
+                  .then((res) => res[0]);
+              } catch (e) {
+                throw parseSqlError(e);
+              }
+            }
+          }),
       };
     },
     // @ts-ignore
-    delete: async (table: Table, key) => {
-      common.metrics.ponder_indexing_store_queries_total.inc({
-        table: getTableName(table),
-        method: "delete",
-      });
-      checkOnchainTable(table, "delete");
+    delete: (table: Table, key) =>
+      database.retry(async () => {
+        common.metrics.ponder_indexing_store_queries_total.inc({
+          table: getTableName(table),
+          method: "delete",
+        });
+        checkOnchainTable(table, "delete");
 
-      const deleted = await qb()
-        .delete(table)
-        .where(getWhereCondition(table, key))
-        .returning();
+        const deleted = await database.qb.drizzle
+          .delete(table)
+          .where(getWhereCondition(table, key))
+          .returning();
 
-      return deleted.length > 0;
-    },
+        return deleted.length > 0;
+      }),
     // @ts-ignore
     sql: drizzle(
       async (_sql, params, method, typings) => {
         const query: QueryWithTypings = { sql: _sql, params, typings };
-        const endClock = startClock();
 
         try {
-          const result = await qb()
-            ._.session.prepareQuery(
-              query,
-              undefined,
-              undefined,
-              method === "all",
-            )
-            .execute();
+          return await database.retry(async () => {
+            const endClock = startClock();
 
-          // @ts-ignore
-          return { rows: result.rows.map((row) => Object.values(row)) };
-        } finally {
-          common.metrics.ponder_indexing_store_raw_sql_duration.observe(
-            endClock(),
-          );
+            const result = await database.qb.drizzle._.session
+              .prepareQuery(query, undefined, undefined, method === "all")
+              .execute()
+              .catch((error) => {
+                throw parseSqlError(error);
+              })
+              .finally(() => {
+                common.metrics.ponder_indexing_store_raw_sql_duration.observe(
+                  endClock(),
+                );
+              });
+            // @ts-ignore
+            return { rows: result.rows.map((row) => Object.values(row)) };
+          });
+        } catch (error) {
+          throw parseSqlError(error);
         }
       },
       { schema, casing: "snake_case" },
     ),
-    set qb(_qb: QB) {
-      qb = _qb;
-    },
   };
 };

package/src/internal/errors.ts

@@ -126,12 +126,3 @@ export class ShutdownError extends NonRetryableError {
     Object.setPrototypeOf(this, ShutdownError.prototype);
   }
 }
-
-export class TransactionError extends NonRetryableError {
-  override name = "TransactionError";
-
-  constructor(message?: string | undefined) {
-    super(message);
-    Object.setPrototypeOf(this, TransactionError.prototype);
-  }
-}

package/src/server/index.ts

@@ -1,9 +1,5 @@
 import http from "node:http";
-import {
-  type Database,
-  getPonderCheckpointTable,
-  getPonderMetaTable,
-} from "@/database/index.js";
+import type { Database } from "@/database/index.js";
 import type { Common } from "@/internal/common.js";
 import type { ApiBuild, Status } from "@/internal/types.js";
 import { decodeCheckpoint } from "@/utils/checkpoint.js";
@@ -87,11 +83,7 @@ export async function createServer({
       return c.text("", 200);
     })
     .get("/ready", async (c) => {
-      const isReady = await database
-        .readonlyQB("select_ready")
-        .select()
-        .from(getPonderMetaTable())
-        .then((result) => result[0]!.value.is_ready === 1);
+      const isReady = await database.getReady();
 
       if (isReady) {
         return c.text("", 200);
@@ -100,10 +92,7 @@ export async function createServer({
       return c.text("Historical indexing is not complete.", 503);
     })
     .get("/status", async (c) => {
-      const checkpoints = await database
-        .readonlyQB("select_checkpoints")
-        .select()
-        .from(getPonderCheckpointTable());
+      const checkpoints = await globalThis.PONDER_DATABASE.getCheckpoints();
       const status: Status = {};
       for (const { chainName, chainId, latestCheckpoint } of checkpoints) {
         status[chainName] = {