@mikeatlast/ponder 0.16.1-fork.1

package/src/build/plugin.ts

@@ -0,0 +1,58 @@
+import type { Common } from "@/internal/common.js";
+import type { Plugin } from "vite";
+
+const virtualModule = () => `export const ponder = {
+  fns: [],
+  on(name, fn) {
+    this.fns.push({ name, fn });
+  },
+};
+`;
+
+const schemaModule = (
+  schemaPath: string,
+) => `import * as schema from "${schemaPath}";
+export * from "${schemaPath}";
+export default schema;
+`;
+
+const apiModule = () => `import { createPublicClient, custom } from "viem";
+
+if (globalThis.PONDER_INDEXING_BUILD === undefined || globalThis.PONDER_DATABASE === undefined) {
+  throw new Error('Invalid dependency graph. Config, schema, and indexing function files cannot import objects from the API function file "src/api/index.ts".')
+}
+
+const publicClients = {};
+
+for (let i = 0; i < globalThis.PONDER_INDEXING_BUILD.chains.length; i++) {
+  const chain = globalThis.PONDER_INDEXING_BUILD.chains[i];
+  const rpc = globalThis.PONDER_INDEXING_BUILD.rpcs[i];
+  publicClients[chain.name] = createPublicClient({
+    chain: chain.viemChain,
+    transport: custom({
+      request(body) {
+        return rpc.request(body);
+      }
+    }),
+  })
+}
+
+export const db = globalThis.PONDER_DATABASE.readonlyQB.raw;
+export { publicClients };
+`;
+
+export const vitePluginPonder = (options: Common["options"]): Plugin => {
+  // On Windows, options.schemaFile is a Windows-style path. We need to convert it to a
+  // Unix-style path for codegen, because TS import paths are Unix-style even on Windows.
+  const schemaPath = options.schemaFile.replace(/\\/g, "/");
+
+  return {
+    name: "ponder",
+    load: (id) => {
+      if (id === "ponder:registry") return virtualModule();
+      if (id === "ponder:schema") return schemaModule(schemaPath);
+      if (id === "ponder:api") return apiModule();
+      return null;
+    },
+  };
+};

package/src/build/pre.ts

@@ -0,0 +1,114 @@
+import path from "node:path";
+import type { Config } from "@/config/index.js";
+import { BuildError } from "@/internal/errors.js";
+import type { Logger } from "@/internal/logger.js";
+import type { Options } from "@/internal/options.js";
+import type { DatabaseConfig } from "@/internal/types.js";
+
+export function buildPre({
+  config,
+  options,
+  logger,
+}: {
+  config: Config;
+  options: Pick<Options, "rootDir" | "ponderDir">;
+  logger: Logger;
+}): {
+  databaseConfig: DatabaseConfig;
+  ordering: NonNullable<Config["ordering"]>;
+} {
+  // Build database.
+  let databaseConfig: DatabaseConfig;
+
+  // Determine PGlite directory, preferring config.database.directory if available
+  const pgliteDir =
+    config.database?.kind === "pglite" && config.database.directory
+      ? config.database.directory === "memory://"
+        ? "memory://"
+        : path.resolve(config.database.directory)
+      : path.join(options.ponderDir, "pglite");
+
+  if (config.database?.kind) {
+    if (config.database.kind === "postgres") {
+      let connectionString: string | undefined = undefined;
+
+      if (config.database.connectionString) {
+        connectionString = config.database.connectionString;
+      } else if (process.env.DATABASE_PRIVATE_URL) {
+        connectionString = process.env.DATABASE_PRIVATE_URL;
+      } else if (process.env.DATABASE_URL) {
+        connectionString = process.env.DATABASE_URL;
+      }
+
+      if (connectionString === undefined) {
+        if (config.database.poolConfig === undefined) {
+          throw new Error(
+            "Invalid database configuration: Either 'connectionString' or 'poolConfig' must be defined.",
+          );
+        }
+        logger.warn({
+          msg: "No database connection string set. Using 'poolConfig' for connection authentication.",
+        });
+      }
+
+      const poolConfig = {
+        // Note: Override `connectionString` with `poolConfig` if available.
+        connectionString,
+        ...(config.database.poolConfig ?? {}),
+        max: config.database.poolConfig?.max ?? 30,
+        ssl: config.database.poolConfig?.ssl ?? false,
+      } satisfies (DatabaseConfig & { kind: "postgres" })["poolConfig"];
+
+      databaseConfig = { kind: "postgres", poolConfig };
+    } else {
+      databaseConfig = { kind: "pglite", options: { dataDir: pgliteDir } };
+    }
+  } else {
+    let connectionString: string | undefined = undefined;
+    if (process.env.DATABASE_PRIVATE_URL) {
+      connectionString = process.env.DATABASE_PRIVATE_URL;
+    } else if (process.env.DATABASE_URL) {
+      connectionString = process.env.DATABASE_URL;
+    }
+
+    // If either of the DATABASE_URL env vars are set, use Postgres.
+    if (connectionString !== undefined) {
+      const poolConfig = { connectionString, max: 30 };
+
+      databaseConfig = { kind: "postgres", poolConfig };
+    } else {
+      // Fall back to PGlite.
+
+      databaseConfig = { kind: "pglite", options: { dataDir: pgliteDir } };
+    }
+  }
+
+  return {
+    databaseConfig,
+    ordering: config.ordering ?? "multichain",
+  };
+}
+
+export function safeBuildPre({
+  config,
+  options,
+  logger,
+}: {
+  config: Config;
+  options: Pick<Options, "rootDir" | "ponderDir">;
+  logger: Logger;
+}) {
+  try {
+    const result = buildPre({ config, options, logger });
+
+    return {
+      status: "success",
+      databaseConfig: result.databaseConfig,
+      ordering: result.ordering,
+    } as const;
+  } catch (_error) {
+    const buildError = new BuildError((_error as Error).message);
+    buildError.stack = undefined;
+    return { status: "error", error: buildError } as const;
+  }
+}

package/src/build/schema.ts

@@ -0,0 +1,358 @@
+import {
+  PONDER_CHECKPOINT_TABLE_NAME,
+  PONDER_META_TABLE_NAME,
+} from "@/database/index.js";
+import { getPrimaryKeyColumns } from "@/drizzle/index.js";
+import { getSql } from "@/drizzle/kit/index.js";
+import { MAX_DATABASE_OBJECT_NAME_LENGTH } from "@/drizzle/onchain.js";
+import { BuildError } from "@/internal/errors.js";
+import type { PreBuild, Schema } from "@/internal/types.js";
+import {
+  SQL,
+  getTableColumns,
+  getTableName,
+  getViewName,
+  is,
+} from "drizzle-orm";
+import {
+  PgBigSerial53,
+  PgBigSerial64,
+  PgColumn,
+  PgSequence,
+  PgSerial,
+  PgSmallSerial,
+  PgTable,
+  PgView,
+  getTableConfig,
+  getViewConfig,
+} from "drizzle-orm/pg-core";
+
+/**
+ * @dev The maximum notify message size is 8KB (8000 / 63 > 100).
+ */
+const TABLE_LIMIT = 100;
+
+export const buildSchema = ({
+  schema,
+  preBuild,
+}: { schema: Schema; preBuild: Pick<PreBuild, "ordering"> }) => {
+  const statements = getSql(schema);
+
+  const tableNames = new Set<string>();
+  const viewNames = new Set<string>();
+  const indexNames = new Set<string>();
+
+  for (const [name, s] of Object.entries(schema)) {
+    if (is(s, PgTable)) {
+      let hasPrimaryKey = false;
+      let hasChainIdColumn = false;
+
+      if (
+        name === PONDER_META_TABLE_NAME ||
+        name === PONDER_CHECKPOINT_TABLE_NAME
+      ) {
+        throw new Error(
+          `Schema validation failed: '${name}' is a reserved table name.`,
+        );
+      }
+
+      if (name.length > MAX_DATABASE_OBJECT_NAME_LENGTH) {
+        throw new Error(
+          `Schema validation failed: '${name}' table name cannot be longer than ${MAX_DATABASE_OBJECT_NAME_LENGTH} characters.`,
+        );
+      }
+
+      const columnNames = new Set<string>();
+
+      for (const [columnName, column] of Object.entries(getTableColumns(s))) {
+        if (column.primary) {
+          if (hasPrimaryKey) {
+            throw new Error(
+              `Schema validation failed: '${name}' has multiple primary keys.`,
+            );
+          } else {
+            hasPrimaryKey = true;
+          }
+        }
+
+        if (
+          column instanceof PgSerial ||
+          column instanceof PgSmallSerial ||
+          column instanceof PgBigSerial53 ||
+          column instanceof PgBigSerial64
+        ) {
+          throw new Error(
+            `Schema validation failed: '${name}.${columnName}' has a serial column and serial columns are unsupported.`,
+          );
+        }
+
+        if (column.isUnique) {
+          throw new Error(
+            `Schema validation failed: '${name}.${columnName}' has a unique constraint and unique constraints are unsupported.`,
+          );
+        }
+
+        if (column.generated !== undefined) {
+          throw new Error(
+            `Schema validation failed: '${name}.${columnName}' is a generated column and generated columns are unsupported.`,
+          );
+        }
+
+        if (column.generatedIdentity !== undefined) {
+          throw new Error(
+            `Schema validation failed: '${name}.${columnName}' is a generated column and generated columns are unsupported.`,
+          );
+        }
+
+        if (column.hasDefault) {
+          if (column.default && column.default instanceof SQL) {
+            throw new Error(
+              `Schema validation failed: '${name}.${columnName}' is a default column and default columns with raw sql are unsupported.`,
+            );
+          }
+
+          if (column.defaultFn && column.defaultFn() instanceof SQL) {
+            throw new Error(
+              `Schema validation failed: '${name}.${columnName}' is a default column and default columns with raw sql are unsupported.`,
+            );
+          }
+
+          if (column.onUpdateFn && column.onUpdateFn() instanceof SQL) {
+            throw new Error(
+              `Schema validation failed: '${name}.${columnName}' is a default column and default columns with raw sql are unsupported.`,
+            );
+          }
+        }
+
+        // TODO(kyle) It is an invariant that `getColumnCasing(column, "snake_case") === column.name`
+        if (columnName === "chainId" && column.name === "chain_id") {
+          hasChainIdColumn = true;
+        }
+
+        // Note: Ponder lets postgres handle the column name length limit and truncation.
+
+        if (
+          column.name === "operation_id" ||
+          column.name === "operation" ||
+          column.name === "checkpoint"
+        ) {
+          throw new Error(
+            `Schema validation failed: '${name}.${columnName}' is a reserved column name.`,
+          );
+        }
+
+        if (columnNames.has(column.name)) {
+          throw new Error(
+            `Schema validation failed: '${name}.${column.name}' column name is used multiple times.`,
+          );
+        } else {
+          columnNames.add(column.name);
+        }
+      }
+
+      if (preBuild.ordering === "experimental_isolated") {
+        if (hasChainIdColumn === false) {
+          throw new Error(
+            `Schema validation failed: '${name}' does not have required 'chainId' column.`,
+          );
+        }
+
+        if (
+          getTableColumns(s).chainId!.dataType !== "number" &&
+          getTableColumns(s).chainId!.dataType !== "bigint"
+        ) {
+          throw new Error(
+            `Schema validation failed: '${name}'.chainId column must be an integer or numeric.`,
+          );
+        }
+
+        if (
+          getPrimaryKeyColumns(s).some(({ sql }) => sql === "chain_id") ===
+          false
+        ) {
+          throw new Error(
+            `Schema validation failed: '${name}.chain_id' column is required to be in the primary key when ordering is 'isolated'.`,
+          );
+        }
+      }
+
+      if (tableNames.has(getTableName(s))) {
+        throw new Error(
+          `Schema validation failed: table name '${getTableName(s)}' is used multiple times.`,
+        );
+      } else {
+        tableNames.add(getTableName(s));
+      }
+
+      if (getTableConfig(s).primaryKeys.length > 1) {
+        throw new Error(
+          `Schema validation failed: '${name}' has multiple primary keys.`,
+        );
+      }
+
+      if (getTableConfig(s).primaryKeys.length === 1 && hasPrimaryKey) {
+        throw new Error(
+          `Schema validation failed: '${name}' has multiple primary keys.`,
+        );
+      }
+
+      if (
+        getTableConfig(s).primaryKeys.length === 0 &&
+        hasPrimaryKey === false
+      ) {
+        throw new Error(
+          `Schema validation failed: '${name}' has no primary key. Declare one with ".primaryKey()".`,
+        );
+      }
+
+      if (getTableConfig(s).foreignKeys.length > 0) {
+        throw new Error(
+          `Schema validation failed: '${name}' has a foreign key constraint and foreign key constraints are unsupported.`,
+        );
+      }
+
+      if (getTableConfig(s).checks.length > 0) {
+        throw new Error(
+          `Schema validation failed: '${name}' has a check constraint and check constraints are unsupported.`,
+        );
+      }
+
+      if (getTableConfig(s).uniqueConstraints.length > 0) {
+        throw new Error(
+          `Schema validation failed: '${name}' has a unique constraint and unique constraints are unsupported.`,
+        );
+      }
+
+      for (const index of getTableConfig(s).indexes) {
+        // Note: Ponder lets postgres handle the index name length limit and truncation.
+
+        if (index.config.name && indexNames.has(index.config.name)) {
+          throw new Error(
+            `Schema validation failed: index name '${index.config.name}' is used multiple times.`,
+          );
+        } else if (index.config.name) {
+          indexNames.add(index.config.name);
+        }
+      }
+    }
+
+    if (is(s, PgSequence)) {
+      throw new Error(
+        `Schema validation failed: '${name}' is a sequence and sequences are unsupported.`,
+      );
+    }
+
+    if (is(s, PgView)) {
+      // Note: Ponder lets postgres handle the view name length limit and truncation.
+
+      if (viewNames.has(getViewName(s))) {
+        throw new Error(
+          `Schema validation failed: view name '${getViewName(s)}' is used multiple times.`,
+        );
+      } else {
+        viewNames.add(getViewName(s));
+      }
+
+      const viewConfig = getViewConfig(s);
+
+      if (viewConfig.selectedFields.length === 0) {
+        throw new Error(
+          `Schema validation failed: view '${getViewName(s)}' has no selected fields.`,
+        );
+      }
+
+      if (viewConfig.isExisting) {
+        throw new Error(
+          `Schema validation failed: view '${getViewName(s)}' is an existing view and existing views are unsupported.`,
+        );
+      }
+
+      if (viewConfig.query === undefined) {
+        throw new Error(
+          `Schema validation failed: view '${getViewName(s)}' has no underlying query.`,
+        );
+      }
+
+      const columnNames = new Set<string>();
+
+      if (viewConfig)
+        for (const [columnName, column] of Object.entries(
+          viewConfig.selectedFields,
+        )) {
+          if (
+            is(column, PgColumn) === false &&
+            is(column, SQL.Aliased) === false
+          ) {
+            throw new Error(
+              `Schema validation failed: view '${getViewName(s)}.${columnName}' is a non-column selected field.`,
+            );
+          }
+
+          if (is(column, PgColumn)) {
+            if (
+              column instanceof PgSerial ||
+              column instanceof PgSmallSerial ||
+              column instanceof PgBigSerial53 ||
+              column instanceof PgBigSerial64
+            ) {
+              throw new Error(
+                `Schema validation failed: '${name}.${columnName}' has a serial column and serial columns are unsupported.`,
+              );
+            }
+
+            if (column.isUnique) {
+              throw new Error(
+                `Schema validation failed: '${name}.${columnName}' has a unique constraint and unique constraints are unsupported.`,
+              );
+            }
+
+            if (column.generated !== undefined) {
+              throw new Error(
+                `Schema validation failed: '${name}.${columnName}' is a generated column and generated columns are unsupported.`,
+              );
+            }
+
+            if (column.generatedIdentity !== undefined) {
+              throw new Error(
+                `Schema validation failed: '${name}.${columnName}' is a generated column and generated columns are unsupported.`,
+              );
+            }
+
+            if (columnNames.has((column as PgColumn).name)) {
+              throw new Error(
+                `Schema validation failed: '${name}.${(column as PgColumn).name}' column name is used multiple times.`,
+              );
+            } else {
+              columnNames.add((column as PgColumn).name);
+            }
+          }
+        }
+    }
+  }
+
+  if (tableNames.size > TABLE_LIMIT) {
+    throw new Error(
+      `Schema validation failed: the maximum number of tables is ${TABLE_LIMIT}.`,
+    );
+  }
+
+  return { statements };
+};
+
+export const safeBuildSchema = ({
+  schema,
+  preBuild,
+}: { schema: Schema; preBuild: Pick<PreBuild, "ordering"> }) => {
+  try {
+    const result = buildSchema({ schema, preBuild });
+
+    return {
+      status: "success",
+      ...result,
+    } as const;
+  } catch (_error) {
+    const buildError = new BuildError((_error as Error).message);
+    buildError.stack = undefined;
+    return { status: "error", error: buildError } as const;
+  }
+};

package/src/build/stacktrace.ts

@@ -0,0 +1,137 @@
+import { readFileSync } from "node:fs";
+import { codeFrameColumns } from "@babel/code-frame";
+import { parse as parseStackTrace } from "stacktrace-parser";
+
+class ESBuildTransformError extends Error {
+  override name = "ESBuildTransformError";
+}
+
+class ESBuildBuildError extends Error {
+  override name = "ESBuildBuildError";
+}
+
+class ESBuildContextError extends Error {
+  override name = "ESBuildContextError";
+}
+
+type ViteNodeError =
+  | ESBuildTransformError
+  | ESBuildBuildError
+  | ESBuildContextError
+  | Error;
+
+export function parseViteNodeError(file: string, error: Error): ViteNodeError {
+  let resolvedError: ViteNodeError;
+
+  if (/^(Transform failed|Build failed|Context failed)/.test(error.message)) {
+    // Handle ESBuild errors based on this error message construction logic:
+    // https://github.com/evanw/esbuild/blob/4e11b50fe3178ed0a78c077df78788d66304d379/lib/shared/common.ts#L1659
+    const errorKind = error.message.split(" with ")[0] as
+      | "Transform failed"
+      | "Build failed"
+      | "Context failed";
+    const innerError = error.message
+      .split("\n")
+      .slice(1)
+      .map((message) => {
+        let location: string | undefined = undefined;
+        let detail: string | undefined = undefined;
+        if (message.includes(": ERROR: ")) {
+          // /path/to/file.ts:11:9: ERROR: Expected ")" but found ";"
+          const s = message.split(": ERROR: ");
+          location = s[0];
+          detail = s[1];
+        } else {
+          // error: some error without a location
+          detail = message.slice(7);
+        }
+        return { location, detail };
+      })[0];
+
+    // If we aren't able to extract an inner error, just return the original.
+    if (!innerError) return error;
+
+    resolvedError =
+      errorKind === "Transform failed"
+        ? new ESBuildTransformError(innerError.detail)
+        : errorKind === "Build failed"
+          ? new ESBuildBuildError(innerError.detail)
+          : new ESBuildContextError(innerError.detail);
+    if (innerError.location)
+      resolvedError.stack = `    at ${innerError.location}`;
+  }
+  // If it's not an ESBuild error, it's a user-land vm.runModuleInContext execution error.
+  // Attempt to build a user-land stack trace.
+  else if (error.stack) {
+    const stackFrames = parseStackTrace(error.stack);
+
+    const userStackFrames = [];
+    for (const rawStackFrame of stackFrames) {
+      if (rawStackFrame.methodName.includes("ViteNodeRunner.runModule")) break;
+      userStackFrames.push(rawStackFrame);
+    }
+
+    const userStack = userStackFrames
+      .map(({ file, lineNumber, column, methodName }) => {
+        const prefix = "    at";
+        const path = `${file}${lineNumber !== null ? `:${lineNumber}` : ""}${
+          column !== null ? `:${column}` : ""
+        }`;
+        if (methodName === null || methodName === "<unknown>") {
+          return `${prefix} ${path}`;
+        } else {
+          return `${prefix} ${methodName} (${path})`;
+        }
+      })
+      .join("\n");
+
+    resolvedError = error;
+    resolvedError.stack = userStack;
+  }
+  // Still a vm.runModuleInContext execution error, but no stack.
+  else {
+    resolvedError = error;
+  }
+
+  // Attempt to build a code frame for the top of the user stack. This works for
+  // both ESBuild and vm.runModuleInContext errors.
+  if (resolvedError.stack) {
+    const userStackFrames = parseStackTrace(resolvedError.stack);
+
+    let codeFrame: string | undefined = undefined;
+    for (const { file, lineNumber, column } of userStackFrames) {
+      if (file !== null && lineNumber !== null) {
+        try {
+          const sourceFileContents = readFileSync(file, { encoding: "utf-8" });
+          codeFrame = codeFrameColumns(
+            sourceFileContents,
+            { start: { line: lineNumber, column: column ?? undefined } },
+            { highlightCode: true },
+          );
+          break;
+        } catch (err) {
+          // No-op.
+        }
+      }
+    }
+
+    resolvedError.stack = `${resolvedError.name}: ${resolvedError.message}\n${resolvedError.stack}`;
+    if (codeFrame) resolvedError.stack += `\n${codeFrame}`;
+  }
+
+  // Finally, add a useful relative file name and verb to the error message.
+  const verb =
+    resolvedError.name === "ESBuildTransformError"
+      ? "transforming"
+      : resolvedError.name === "ESBuildBuildError" ||
+          resolvedError.name === "ESBuildContextError"
+        ? "building"
+        : "executing";
+
+  // This can throw with "Cannot set property message of [object Object] which has only a getter"
+  try {
+    resolvedError.message = `Error while ${verb} ${file}: ${resolvedError.message}`;
+  } catch (e) {}
+
+  return resolvedError;
+}