ponder 0.14.13 → 0.15.0

package/src/indexing-store/historical.ts

@@ -1,4 +1,3 @@
-import { findTableNames, validateQuery } from "@/client/parse.js";
 import type { QB } from "@/database/queryBuilder.js";
 import type { Common } from "@/internal/common.js";
 import {
@@ -13,6 +12,7 @@ import type { IndexingErrorHandler, SchemaBuild } from "@/internal/types.js";
 import { copy, copyOnWrite } from "@/utils/copy.js";
 import { createLock } from "@/utils/mutex.js";
 import { prettyPrint } from "@/utils/print.js";
+import { getSQLQueryRelations, isReadonlySQLQuery } from "@/utils/sql-parse.js";
 import { startClock } from "@/utils/timer.js";
 import {
   type QueryWithTypings,
@@ -27,6 +27,7 @@ import type { IndexingCache, Row } from "./cache.js";
 import {
   type IndexingStore,
   checkOnchainTable,
+  checkTableAccess,
   validateUpdateSet,
 } from "./index.js";
 import { getPrimaryKeyCache } from "./utils.js";
@@ -36,11 +37,13 @@ export const createHistoricalIndexingStore = ({
   schemaBuild: { schema },
   indexingCache,
   indexingErrorHandler,
+  chainId,
 }: {
   common: Common;
   schemaBuild: Pick<SchemaBuild, "schema">;
   indexingCache: IndexingCache;
   indexingErrorHandler: IndexingErrorHandler;
+  chainId?: number;
 }): IndexingStore => {
   let qb: QB = undefined!;
   let isProcessingEvents = true;
@@ -97,6 +100,7 @@ export const createHistoricalIndexingStore = ({
         method: "find",
       });
       checkOnchainTable(table, "find");
+      checkTableAccess(table, "find", key, chainId);
       const ponderRow = await indexingCache.get({ table, key });
       const userRow = ponderRow === null ? null : copyOnWrite(ponderRow);
       return userRow;
@@ -120,6 +124,7 @@ export const createHistoricalIndexingStore = ({
               if (Array.isArray(ponderValues)) {
                 const ponderRows = [];
                 for (const value of ponderValues) {
+                  checkTableAccess(table, "insert", value, chainId);
                   const row = await indexingCache.get({ table, key: value });
 
                   if (row) {
@@ -140,6 +145,7 @@ export const createHistoricalIndexingStore = ({
                 );
                 return userRows;
               } else {
+                checkTableAccess(table, "insert", ponderValues, chainId);
                 const row = await indexingCache.get({
                   table,
                   key: ponderValues,
@@ -171,6 +177,7 @@ export const createHistoricalIndexingStore = ({
                 if (Array.isArray(userValues)) {
                   const ponderRows: Row[] = [];
                   for (const value of userValues) {
+                    checkTableAccess(table, "insert", value, chainId);
                     const ponderRowUpdate = await indexingCache.get({
                       table,
                       key: value,
@@ -230,6 +237,7 @@ export const createHistoricalIndexingStore = ({
                   );
                   return userRows;
                 } else {
+                  checkTableAccess(table, "insert", userValues, chainId);
                   const ponderRowUpdate = await indexingCache.get({
                     table,
                     key: userValues,
@@ -301,6 +309,8 @@ export const createHistoricalIndexingStore = ({
                 if (Array.isArray(ponderValues)) {
                   const ponderRows = [];
                   for (const value of ponderValues) {
+                    checkTableAccess(table, "insert", value, chainId);
+
                     if (qb.$dialect === "pglite") {
                       const row = await indexingCache.get({
                         table,
@@ -343,6 +353,8 @@ export const createHistoricalIndexingStore = ({
                     onRejected,
                   );
                 } else {
+                  checkTableAccess(table, "insert", ponderValues, chainId);
+
                   let ponderRow: Row;
                   if (qb.$dialect === "pglite") {
                     const row = await indexingCache.get({
@@ -405,6 +417,7 @@ export const createHistoricalIndexingStore = ({
             method: "update",
           });
           checkOnchainTable(table, "update");
+          checkTableAccess(table, "update", key, chainId);
 
           const ponderRowUpdate = await indexingCache.get({ table, key });
 
@@ -463,16 +476,13 @@ export const createHistoricalIndexingStore = ({
         method: "delete",
       });
       checkOnchainTable(table, "delete");
+      checkTableAccess(table, "delete", key, chainId);
       return indexingCache.delete({ table, key });
     }),
     // @ts-ignore
     sql: drizzle(
       storeMethodWrapper(async (_sql, params, method, typings) => {
-        let isSelectOnly = false;
-        try {
-          await validateQuery(_sql, false);
-          isSelectOnly = true;
-        } catch {}
+        const isSelectOnly = await isReadonlySQLQuery(_sql);
 
         if (isSelectOnly === false) {
           await indexingCache.flush();
@@ -481,19 +491,19 @@ export const createHistoricalIndexingStore = ({
         } else {
           // Note: Not all nodes are implemented in the parser,
           // so we need to try/catch to avoid throwing an error.
-          let refNames: Set<string> | undefined;
+          let relations: Set<string> | undefined;
           try {
-            refNames = await findTableNames(_sql);
+            relations = await getSQLQueryRelations(_sql);
           } catch {}
 
           if (
-            Array.from(refNames ?? []).some((refName) =>
+            Array.from(relations ?? []).some((refName) =>
               views.some((view) => getViewName(view) === refName),
             )
           ) {
             await indexingCache.flush();
           } else {
-            await indexingCache.flush({ tableNames: refNames });
+            await indexingCache.flush({ tableNames: relations });
           }
         }
 

package/src/indexing-store/index.ts

@@ -1,6 +1,7 @@
 import type { QB } from "@/database/queryBuilder.js";
 import { onchain } from "@/drizzle/onchain.js";
 import {
+  InvalidStoreAccessError,
   InvalidStoreMethodError,
   NonRetryableUserError,
   UndefinedTableError,
@@ -55,3 +56,18 @@ export const checkOnchainTable = (
       : `Indexing functions can only write to onchain tables, and '${getTableConfig(table).name}' is an offchain table or a view.`,
   );
 };
+
+export const checkTableAccess = (
+  table: Table,
+  method: "find" | "insert" | "update" | "delete",
+  key: object,
+  chainId?: number,
+) => {
+  if (chainId === undefined) return;
+  if ("chainId" in key && String(key.chainId) === String(chainId)) return;
+  throw new InvalidStoreAccessError(
+    "chainId" in key
+      ? `db.${method}(${getTableConfig(table).name}) cannot access rows on different chains when ordering is 'isolated'.`
+      : `db.${method}(${getTableConfig(table).name}) must specify 'chainId' when ordering is 'isolated'.`,
+  );
+};

package/src/indexing-store/profile.ts

@@ -63,7 +63,7 @@ const matchEventParameters = (
   event: Event,
   value: any,
 ): ProfilePattern[keyof ProfilePattern] | undefined => {
-  if (eq(event.chainId, value)) {
+  if (eq(event.chain.id, value)) {
     return { type: "derived", value: ["chainId"] };
   }
 
@@ -515,7 +515,7 @@ export const recoverProfilePattern = (
     if (_pattern.type === "derived") {
       const { value, fn } = _pattern;
       if (value[0] === "chainId") {
-        result[key] = event.chainId;
+        result[key] = event.chain.id;
       } else {
         let _result: unknown = event.event;
         for (const prop of value) {
@@ -534,7 +534,7 @@ export const recoverProfilePattern = (
       result[key] = values
         .map(({ value, fn }) => {
           if (value[0] === "chainId") {
-            return event.chainId;
+            return event.chain.id;
           } else {
             let _result: unknown = event.event;
             for (const prop of value) {

package/src/indexing-store/realtime.ts

@@ -22,6 +22,7 @@ import { drizzle } from "drizzle-orm/pg-proxy";
 import {
   type IndexingStore,
   checkOnchainTable,
+  checkTableAccess,
   validateUpdateSet,
 } from "./index.js";
 import { getCacheKey, getPrimaryKeyCache, getWhereCondition } from "./utils.js";
@@ -30,10 +31,12 @@ export const createRealtimeIndexingStore = ({
   common,
   schemaBuild: { schema },
   indexingErrorHandler,
+  chainId,
 }: {
   common: Common;
   schemaBuild: Pick<SchemaBuild, "schema">;
   indexingErrorHandler: IndexingErrorHandler;
+  chainId?: number;
 }): IndexingStore => {
   let qb: QB = undefined!;
   let isProcessingEvents = true;
@@ -96,6 +99,7 @@ export const createRealtimeIndexingStore = ({
         method: "find",
       });
       checkOnchainTable(table, "find");
+      checkTableAccess(table, "find", key, chainId);
       return find(table, key);
     }),
     // @ts-ignore
@@ -137,6 +141,16 @@ export const createRealtimeIndexingStore = ({
                 return rows;
               };
 
+              if (chainId !== undefined) {
+                if (Array.isArray(values)) {
+                  for (const value of values) {
+                    checkTableAccess(table, "insert", value, chainId);
+                  }
+                } else {
+                  checkTableAccess(table, "insert", values, chainId);
+                }
+              }
+
               return qb.wrap((db) =>
                 db
                   .insert(table)
@@ -156,6 +170,7 @@ export const createRealtimeIndexingStore = ({
               if (Array.isArray(values)) {
                 const rows = [];
                 for (const value of values) {
+                  checkTableAccess(table, "insert", value, chainId);
                   const row = await find(table, value);
 
                   if (row) {
@@ -187,6 +202,7 @@ export const createRealtimeIndexingStore = ({
                 }
                 return rows;
               } else {
+                checkTableAccess(table, "insert", values, chainId);
                 const row = await find(table, values);
 
                 if (row) {
@@ -244,6 +260,16 @@ export const createRealtimeIndexingStore = ({
                   return result[0];
                 };
 
+                if (chainId !== undefined) {
+                  if (Array.isArray(values)) {
+                    for (const value of values) {
+                      checkTableAccess(table, "insert", value, chainId);
+                    }
+                  } else {
+                    checkTableAccess(table, "insert", values, chainId);
+                  }
+                }
+
                 return qb.wrap((db) =>
                   db
                     .insert(table)
@@ -281,6 +307,7 @@ export const createRealtimeIndexingStore = ({
             method: "update",
           });
           checkOnchainTable(table, "update");
+          checkTableAccess(table, "update", key, chainId);
 
           const row = await find(table, key);
           if (typeof values === "function") {
@@ -325,6 +352,7 @@ export const createRealtimeIndexingStore = ({
         method: "delete",
       });
       checkOnchainTable(table, "delete");
+      checkTableAccess(table, "delete", key, chainId);
 
       const deleted = await qb.wrap((db) =>
         db.delete(table).where(getWhereCondition(table, key)).returning(),

package/src/internal/errors.ts

@@ -77,6 +77,15 @@ export class NotNullConstraintError extends NonRetryableUserError {
   }
 }
 
+export class InvalidStoreAccessError extends NonRetryableUserError {
+  override name = "InvalidStoreAccessError";
+
+  constructor(message?: string | undefined) {
+    super(message);
+    Object.setPrototypeOf(this, InvalidStoreAccessError.prototype);
+  }
+}
+
 export class RecordNotFoundError extends NonRetryableUserError {
   override name = "RecordNotFoundError";
 
@@ -200,3 +209,20 @@ export class RpcProviderError extends BaseError {
     Object.setPrototypeOf(this, RpcProviderError.prototype);
   }
 }
+
+export const nonRetryableUserErrorNames = [
+  ShutdownError,
+  BuildError,
+  MigrationError,
+  UniqueConstraintError,
+  NotNullConstraintError,
+  InvalidStoreAccessError,
+  RecordNotFoundError,
+  CheckConstraintError,
+  InvalidStoreMethodError,
+  UndefinedTableError,
+  BigIntSerializationError,
+  DelayedInsertError,
+  RawSqlError,
+  IndexingFunctionError,
+].map((err) => err.name);