@mikeatlast/ponder 0.16.1-fork.1

package/src/indexing-store/profile.ts

@@ -0,0 +1,557 @@
+import type { Event } from "@/internal/types.js";
+import { orderObject } from "@/utils/order.js";
+import type { Column, Table } from "drizzle-orm";
+import type { ProfilePattern, Row } from "./cache.js";
+import { getCacheKey } from "./utils.js";
+
+export const getProfilePatternKey = (pattern: ProfilePattern): string => {
+  return JSON.stringify(orderObject(pattern), (_, value) => {
+    if (typeof value === "bigint") {
+      return value.toString();
+    }
+    return value;
+  });
+};
+
+const eq = (target: bigint | string | number | boolean, value: any) => {
+  if (target === value) return true;
+  if (target && value && target.toString() === value.toString()) return true;
+  return false;
+};
+
+const delimiters = ["-", "_", ":", "#", "$"];
+
+export const recordProfilePattern = (
+  event: Event,
+  table: Table,
+  key: object,
+  hints: ProfilePattern[],
+  cache: Map<Table, [string, Column][]>,
+): ProfilePattern | undefined => {
+  globalThis.DISABLE_EVENT_PROXY = true;
+  for (const hint of hints) {
+    if (
+      getCacheKey(table, key, cache) ===
+      getCacheKey(table, recoverProfilePattern(hint, event), cache)
+    ) {
+      globalThis.DISABLE_EVENT_PROXY = false;
+      return hint;
+    }
+  }
+
+  const result: ProfilePattern = {};
+
+  for (const [js] of cache.get(table)!) {
+    // @ts-ignore
+    const value = key[js]!;
+
+    const pattern = matchEventParameters(event, value);
+
+    if (pattern === undefined) {
+      globalThis.DISABLE_EVENT_PROXY = false;
+      return undefined;
+    }
+
+    result[js] = pattern;
+  }
+
+  globalThis.DISABLE_EVENT_PROXY = false;
+  return result;
+};
+
+const matchEventParameters = (
+  event: Event,
+  value: any,
+): ProfilePattern[keyof ProfilePattern] | undefined => {
+  if (eq(event.chain.id, value)) {
+    return { type: "derived", value: ["chainId"] };
+  }
+
+  if (eq(event.event.id, value)) {
+    return { type: "derived", value: ["id"] };
+  }
+
+  switch (event.type) {
+    case "block": {
+      if (eq(event.event.block.hash, value)) {
+        return { type: "derived", value: ["block", "hash"] };
+      }
+
+      if (eq(event.event.block.number, value)) {
+        return { type: "derived", value: ["block", "number"] };
+      }
+
+      if (eq(event.event.block.timestamp, value)) {
+        return { type: "derived", value: ["block", "timestamp"] };
+      }
+
+      if (eq(event.event.block.timestamp / 60n, value)) {
+        return {
+          type: "derived",
+          value: ["block", "timestamp"],
+          fn: (value) => (value as bigint) / 60n,
+        };
+      }
+
+      if (eq(event.event.block.timestamp / 3600n, value)) {
+        return {
+          type: "derived",
+          value: ["block", "timestamp"],
+          fn: (value) => (value as bigint) / 3600n,
+        };
+      }
+
+      if (eq(event.event.block.timestamp / 86400n, value)) {
+        return {
+          type: "derived",
+          value: ["block", "timestamp"],
+          fn: (value) => (value as bigint) / 86400n,
+        };
+      }
+
+      if (event.event.block.miner && eq(event.event.block.miner, value)) {
+        return { type: "derived", value: ["block", "miner"] };
+      }
+
+      break;
+    }
+
+    case "transaction": {
+      if (eq(event.event.block.hash, value)) {
+        return { type: "derived", value: ["block", "hash"] };
+      }
+
+      if (eq(event.event.block.number, value)) {
+        return { type: "derived", value: ["block", "number"] };
+      }
+
+      if (eq(event.event.block.timestamp, value)) {
+        return { type: "derived", value: ["block", "timestamp"] };
+      }
+
+      if (eq(event.event.block.timestamp / 60n, value)) {
+        return {
+          type: "derived",
+          value: ["block", "timestamp"],
+          fn: (value) => (value as bigint) / 60n,
+        };
+      }
+
+      if (eq(event.event.block.timestamp / 3600n, value)) {
+        return {
+          type: "derived",
+          value: ["block", "timestamp"],
+          fn: (value) => (value as bigint) / 3600n,
+        };
+      }
+
+      if (eq(event.event.block.timestamp / 86400n, value)) {
+        return {
+          type: "derived",
+          value: ["block", "timestamp"],
+          fn: (value) => (value as bigint) / 86400n,
+        };
+      }
+
+      if (event.event.block.miner && eq(event.event.block.miner, value)) {
+        return { type: "derived", value: ["block", "miner"] };
+      }
+
+      if (eq(event.event.transaction.hash, value)) {
+        return { type: "derived", value: ["transaction", "hash"] };
+      }
+
+      if (eq(event.event.transaction.from, value)) {
+        return { type: "derived", value: ["transaction", "from"] };
+      }
+
+      if (event.event.transaction.to && eq(event.event.transaction.to, value)) {
+        return { type: "derived", value: ["transaction", "to"] };
+      }
+
+      if (eq(event.event.transaction.transactionIndex, value)) {
+        return { type: "derived", value: ["transaction", "transactionIndex"] };
+      }
+
+      if (
+        event.event.transactionReceipt?.contractAddress &&
+        eq(event.event.transactionReceipt.contractAddress, value)
+      ) {
+        return {
+          type: "derived",
+          value: ["transactionReceipt", "contractAddress"],
+        };
+      }
+
+      break;
+    }
+
+    case "log": {
+      // Note: explicitly skip profiling args if they are an array
+      if (
+        event.event.args !== undefined &&
+        Array.isArray(event.event.args) === false
+      ) {
+        for (const argKey of Object.keys(event.event.args)) {
+          const argValue = (event.event.args as { [key: string]: unknown })[
+            argKey
+          ] as string | bigint | number | boolean;
+
+          if (typeof argValue !== "object" && eq(argValue, value)) {
+            return { type: "derived", value: ["args", argKey] };
+          }
+        }
+      }
+
+      if (eq(event.event.log.address, value)) {
+        return { type: "derived", value: ["log", "address"] };
+      }
+
+      if (eq(event.event.log.logIndex, value)) {
+        return { type: "derived", value: ["log", "logIndex"] };
+      }
+
+      if (eq(event.event.block.hash, value)) {
+        return { type: "derived", value: ["block", "hash"] };
+      }
+
+      if (eq(event.event.block.number, value)) {
+        return { type: "derived", value: ["block", "number"] };
+      }
+
+      if (eq(event.event.block.timestamp, value)) {
+        return { type: "derived", value: ["block", "timestamp"] };
+      }
+
+      if (eq(event.event.block.timestamp / 60n, value)) {
+        return {
+          type: "derived",
+          value: ["block", "timestamp"],
+          fn: (value) => (value as bigint) / 60n,
+        };
+      }
+
+      if (eq(event.event.block.timestamp / 3600n, value)) {
+        return {
+          type: "derived",
+          value: ["block", "timestamp"],
+          fn: (value) => (value as bigint) / 3600n,
+        };
+      }
+
+      if (eq(event.event.block.timestamp / 86400n, value)) {
+        return {
+          type: "derived",
+          value: ["block", "timestamp"],
+          fn: (value) => (value as bigint) / 86400n,
+        };
+      }
+
+      if (event.event.block.miner && eq(event.event.block.miner, value)) {
+        return { type: "derived", value: ["block", "miner"] };
+      }
+
+      if (eq(event.event.transaction.hash, value)) {
+        return { type: "derived", value: ["transaction", "hash"] };
+      }
+
+      if (eq(event.event.transaction.from, value)) {
+        return { type: "derived", value: ["transaction", "from"] };
+      }
+
+      if (event.event.transaction.to && eq(event.event.transaction.to, value)) {
+        return { type: "derived", value: ["transaction", "to"] };
+      }
+
+      if (eq(event.event.transaction.transactionIndex, value)) {
+        return { type: "derived", value: ["transaction", "transactionIndex"] };
+      }
+
+      if (
+        event.event.transactionReceipt?.contractAddress &&
+        eq(event.event.transactionReceipt.contractAddress, value)
+      ) {
+        return {
+          type: "derived",
+          value: ["transactionReceipt", "contractAddress"],
+        };
+      }
+
+      break;
+    }
+
+    case "trace": {
+      // Note: explicitly skip profiling args if they are an array
+      if (
+        event.event.args !== undefined &&
+        Array.isArray(event.event.args) === false
+      ) {
+        for (const argKey of Object.keys(event.event.args)) {
+          const argValue = (event.event.args as { [key: string]: unknown })[
+            argKey
+          ] as string | bigint | number | boolean;
+
+          if (typeof argValue !== "object" && eq(argValue, value)) {
+            return { type: "derived", value: ["args", argKey] };
+          }
+        }
+      }
+
+      // Note: explicitly skip profiling result if it is an array
+      if (
+        event.event.result !== undefined &&
+        Array.isArray(event.event.result) === false
+      ) {
+        for (const argKey of Object.keys(event.event.result)) {
+          const argValue = (event.event.result as { [key: string]: unknown })[
+            argKey
+          ] as string | bigint | number | boolean;
+
+          if (typeof argValue !== "object" && eq(argValue, value)) {
+            return { type: "derived", value: ["result", argKey] };
+          }
+        }
+      }
+
+      if (eq(event.event.trace.from, value)) {
+        return { type: "derived", value: ["trace", "from"] };
+      }
+
+      if (event.event.trace.to && eq(event.event.trace.to, value)) {
+        return { type: "derived", value: ["trace", "to"] };
+      }
+
+      if (eq(event.event.block.hash, value)) {
+        return { type: "derived", value: ["block", "hash"] };
+      }
+
+      if (eq(event.event.block.number, value)) {
+        return { type: "derived", value: ["block", "number"] };
+      }
+
+      if (eq(event.event.block.timestamp, value)) {
+        return { type: "derived", value: ["block", "timestamp"] };
+      }
+
+      if (eq(event.event.block.timestamp / 60n, value)) {
+        return {
+          type: "derived",
+          value: ["block", "timestamp"],
+          fn: (value) => (value as bigint) / 60n,
+        };
+      }
+
+      if (eq(event.event.block.timestamp / 3600n, value)) {
+        return {
+          type: "derived",
+          value: ["block", "timestamp"],
+          fn: (value) => (value as bigint) / 3600n,
+        };
+      }
+
+      if (eq(event.event.block.timestamp / 86400n, value)) {
+        return {
+          type: "derived",
+          value: ["block", "timestamp"],
+          fn: (value) => (value as bigint) / 86400n,
+        };
+      }
+
+      if (event.event.block.miner && eq(event.event.block.miner, value)) {
+        return { type: "derived", value: ["block", "miner"] };
+      }
+
+      if (eq(event.event.transaction.hash, value)) {
+        return { type: "derived", value: ["transaction", "hash"] };
+      }
+
+      if (eq(event.event.transaction.from, value)) {
+        return { type: "derived", value: ["transaction", "from"] };
+      }
+
+      if (event.event.transaction.to && eq(event.event.transaction.to, value)) {
+        return { type: "derived", value: ["transaction", "to"] };
+      }
+
+      if (eq(event.event.transaction.transactionIndex, value)) {
+        return { type: "derived", value: ["transaction", "transactionIndex"] };
+      }
+
+      if (
+        event.event.transactionReceipt?.contractAddress &&
+        eq(event.event.transactionReceipt.contractAddress, value)
+      ) {
+        return {
+          type: "derived",
+          value: ["transactionReceipt", "contractAddress"],
+        };
+      }
+
+      break;
+    }
+
+    case "transfer": {
+      if (eq(event.event.transfer.from, value)) {
+        return { type: "derived", value: ["transfer", "from"] };
+      }
+
+      if (eq(event.event.transfer.to, value)) {
+        return { type: "derived", value: ["transfer", "to"] };
+      }
+
+      if (eq(event.event.trace.from, value)) {
+        return { type: "derived", value: ["trace", "from"] };
+      }
+
+      if (event.event.trace.to && eq(event.event.trace.to, value)) {
+        return { type: "derived", value: ["trace", "to"] };
+      }
+
+      if (eq(event.event.block.hash, value)) {
+        return { type: "derived", value: ["block", "hash"] };
+      }
+
+      if (eq(event.event.block.number, value)) {
+        return { type: "derived", value: ["block", "number"] };
+      }
+
+      if (eq(event.event.block.timestamp, value)) {
+        return { type: "derived", value: ["block", "timestamp"] };
+      }
+
+      if (eq(event.event.block.timestamp / 60n, value)) {
+        return {
+          type: "derived",
+          value: ["block", "timestamp"],
+          fn: (value) => (value as bigint) / 60n,
+        };
+      }
+
+      if (eq(event.event.block.timestamp / 3600n, value)) {
+        return {
+          type: "derived",
+          value: ["block", "timestamp"],
+          fn: (value) => (value as bigint) / 3600n,
+        };
+      }
+
+      if (eq(event.event.block.timestamp / 86400n, value)) {
+        return {
+          type: "derived",
+          value: ["block", "timestamp"],
+          fn: (value) => (value as bigint) / 86400n,
+        };
+      }
+
+      if (event.event.block.miner && eq(event.event.block.miner, value)) {
+        return { type: "derived", value: ["block", "miner"] };
+      }
+
+      if (eq(event.event.transaction.hash, value)) {
+        return { type: "derived", value: ["transaction", "hash"] };
+      }
+
+      if (eq(event.event.transaction.from, value)) {
+        return { type: "derived", value: ["transaction", "from"] };
+      }
+
+      if (event.event.transaction.to && eq(event.event.transaction.to, value)) {
+        return { type: "derived", value: ["transaction", "to"] };
+      }
+
+      if (eq(event.event.transaction.transactionIndex, value)) {
+        return { type: "derived", value: ["transaction", "transactionIndex"] };
+      }
+
+      if (
+        event.event.transactionReceipt?.contractAddress &&
+        eq(event.event.transactionReceipt.contractAddress, value)
+      ) {
+        return {
+          type: "derived",
+          value: ["transactionReceipt", "contractAddress"],
+        };
+      }
+
+      break;
+    }
+  }
+
+  if (typeof value === "string") {
+    del: for (const delimiter of delimiters) {
+      const subValues = value.split(delimiter);
+      if (subValues.length > 1) {
+        const result: ProfilePattern[keyof ProfilePattern] = {
+          type: "delimeter",
+          values: [],
+          delimiter,
+        };
+
+        for (const subValue of subValues) {
+          const match = matchEventParameters(event, subValue);
+          if (match?.type === "derived") {
+            result.values.push(match);
+            continue;
+          }
+
+          continue del;
+        }
+
+        return result;
+      }
+    }
+  }
+
+  return undefined;
+};
+
+export const recoverProfilePattern = (
+  pattern: ProfilePattern,
+  event: Event,
+): Row => {
+  const result: Row = {};
+
+  for (const [key, _pattern] of Object.entries(pattern)) {
+    if (_pattern.type === "derived") {
+      const { value, fn } = _pattern;
+      if (value[0] === "chainId") {
+        result[key] = event.chain.id;
+      } else {
+        let _result: unknown = event.event;
+        for (const prop of value) {
+          // @ts-ignore
+          _result = _result[prop];
+        }
+
+        if (fn) {
+          _result = fn(_result);
+        }
+
+        result[key] = _result;
+      }
+    } else {
+      const { values, delimiter } = _pattern;
+      result[key] = values
+        .map(({ value, fn }) => {
+          if (value[0] === "chainId") {
+            return event.chain.id;
+          } else {
+            let _result: unknown = event.event;
+            for (const prop of value) {
+              // @ts-ignore
+              _result = _result[prop];
+            }
+
+            if (fn) {
+              _result = fn(_result);
+            }
+
+            return _result;
+          }
+        })
+        .join(delimiter);
+    }
+  }
+
+  return result;
+};

package/src/indexing-store/utils.ts

@@ -0,0 +1,162 @@
+import { getPrimaryKeyColumns } from "@/drizzle/index.js";
+import {
+  BigIntSerializationError,
+  NotNullConstraintError,
+} from "@/internal/errors.js";
+import { prettyPrint } from "@/utils/print.js";
+import {
+  type Column,
+  type SQL,
+  type SQLWrapper,
+  type Table,
+  and,
+  eq,
+  getTableColumns,
+  getTableName,
+} from "drizzle-orm";
+import { PgArray } from "drizzle-orm/pg-core";
+
+/**
+ * Returns true if the column has a "default" value that is used when no value is passed.
+ * Handles `.default`, `.$defaultFn()`, `.$onUpdateFn()`.
+ */
+export const hasEmptyValue = (column: Column) => {
+  return column.hasDefault;
+};
+
+/** Returns the "default" value for `column`. */
+export const getEmptyValue = (column: Column, isUpdate: boolean) => {
+  if (isUpdate && column.onUpdateFn) {
+    return column.onUpdateFn();
+  }
+  if (column.default !== undefined) return column.default;
+  if (column.defaultFn !== undefined) return column.defaultFn();
+  if (column.onUpdateFn !== undefined) return column.onUpdateFn();
+
+  // TODO(kyle) is it an invariant that it doesn't get here
+
+  return undefined;
+};
+
+export const getPrimaryKeyCache = (tables: Table[]) => {
+  const cache = new Map<Table, [string, Column][]>();
+
+  for (const table of tables) {
+    cache.set(table, []);
+    for (const { js } of getPrimaryKeyColumns(table)) {
+      // @ts-expect-error
+      cache.get(table)!.push([js, table[js]!]);
+    }
+  }
+
+  return cache;
+};
+
+export const normalizeColumn = (
+  column: Column,
+  value: unknown,
+  isUpdate: boolean,
+): unknown => {
+  if (value === undefined) {
+    if (hasEmptyValue(column)) return getEmptyValue(column, isUpdate);
+    return null;
+  }
+  if (value === null) return null;
+  if (column.mapToDriverValue === undefined) return value;
+
+  try {
+    if (Array.isArray(value) && column instanceof PgArray) {
+      return value.map((v) => {
+        if (column.baseColumn.columnType === "PgTimestamp") {
+          return v;
+        }
+
+        return column.baseColumn.mapFromDriverValue(
+          column.baseColumn.mapToDriverValue(v),
+        );
+      });
+    }
+
+    if (column.columnType === "PgTimestamp") {
+      return value;
+    }
+
+    return column.mapFromDriverValue(column.mapToDriverValue(value));
+  } catch (e) {
+    if (
+      (e as Error)?.message?.includes("Do not know how to serialize a BigInt")
+    ) {
+      const error = new BigIntSerializationError((e as Error).message);
+      error.meta.push(
+        "Hint:\n  The JSON column type does not support BigInt values. Use the replaceBigInts() helper function before inserting into the database. Docs: https://ponder.sh/docs/api-reference/ponder-utils#replacebigints",
+      );
+      throw error;
+    }
+
+    throw e;
+  }
+};
+
+export const normalizeRow = (
+  table: Table,
+  row: { [key: string]: unknown },
+  isUpdate: boolean,
+) => {
+  for (const [columnName, column] of Object.entries(getTableColumns(table))) {
+    // not-null constraint
+    if (
+      isUpdate === false &&
+      (row[columnName] === undefined || row[columnName] === null) &&
+      column.notNull &&
+      hasEmptyValue(column) === false
+    ) {
+      const error = new NotNullConstraintError(
+        `Column '${getTableName(
+          table,
+        )}.${columnName}' violates not-null constraint.`,
+      );
+      error.meta.push(`db.insert arguments:\n${prettyPrint(row)}`);
+      throw error;
+    }
+
+    row[columnName] = normalizeColumn(column, row[columnName], isUpdate);
+  }
+
+  return row;
+};
+
+export const getCacheKey = (
+  table: Table,
+  key: object,
+  cache: Map<Table, [string, Column][]>,
+): string => {
+  const primaryKeys = cache.get(table)!;
+
+  if (primaryKeys.length === 1) {
+    const [pk, col] = primaryKeys[0]!;
+    // @ts-expect-error
+    return String(normalizeColumn(col, key[pk]!, false));
+  }
+
+  let result = "";
+  for (let i = 0; i < primaryKeys.length; i++) {
+    const [pk, col] = primaryKeys[i]!;
+    // @ts-expect-error
+    const value = normalizeColumn(col, key[pk]!, false);
+    result += `${String(value)}_`;
+  }
+
+  return result;
+};
+
+/** Returns an sql where condition for `table` with `key`. */
+export const getWhereCondition = (table: Table, key: Object): SQL<unknown> => {
+  const conditions: SQLWrapper[] = [];
+
+  for (const { js } of getPrimaryKeyColumns(table)) {
+    // @ts-ignore
+    conditions.push(eq(table[js]!, key[js]));
+  }
+
+  return and(...conditions)!;
+};