@mikeatlast/ponder 0.16.1-fork.1

package/src/graphql/json.ts

@@ -0,0 +1,62 @@
+// Modified from https://github.com/taion/graphql-type-json/blob/master/src/index.js
+import {
+  type GraphQLScalarLiteralParser,
+  GraphQLScalarType,
+  Kind,
+  type ObjectValueNode,
+  type ValueNode,
+  print,
+} from "graphql";
+
+export const GraphQLJSON = new GraphQLScalarType({
+  name: "JSON",
+  description:
+    "The `JSON` scalar type represents JSON values as specified by [ECMA-404](http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-404.pdf).",
+  serialize: (x) => x,
+  parseValue: (x) => x,
+  parseLiteral: (ast, variables) => {
+    if (ast.kind !== Kind.OBJECT) {
+      throw new TypeError(
+        `JSONObject cannot represent non-object value: ${print(ast)}`,
+      );
+    }
+
+    return parseObject(ast, variables);
+  },
+});
+
+const parseLiteral = (
+  ast: ValueNode,
+  variables: Parameters<GraphQLScalarType["parseLiteral"]>[1],
+): ReturnType<GraphQLScalarLiteralParser<unknown>> => {
+  switch (ast.kind) {
+    case Kind.STRING:
+    case Kind.BOOLEAN:
+      return ast.value;
+    case Kind.INT:
+    case Kind.FLOAT:
+      return Number.parseFloat(ast.value);
+    case Kind.OBJECT:
+      return parseObject(ast, variables);
+    case Kind.LIST:
+      return ast.values.map((n) => parseLiteral(n, variables));
+    case Kind.NULL:
+      return null;
+    case Kind.VARIABLE:
+      return variables ? variables[ast.name.value] : undefined;
+    default:
+      throw new TypeError(`JSON cannot represent value: ${print(ast)}`);
+  }
+};
+
+const parseObject = (
+  ast: ObjectValueNode,
+  variables: Parameters<GraphQLScalarType["parseLiteral"]>[1],
+) => {
+  const value = Object.create(null);
+  ast.fields.forEach((field) => {
+    value[field.name.value] = parseLiteral(field.value, variables);
+  });
+
+  return value;
+};

package/src/graphql/middleware.ts

@@ -0,0 +1,115 @@
+import { graphiQLHtml } from "@/graphql/graphiql.html.js";
+import type { Schema } from "@/internal/types.js";
+import type { ReadonlyDrizzle } from "@/types/db.js";
+import { maxAliasesPlugin } from "@escape.tech/graphql-armor-max-aliases";
+import { maxDepthPlugin } from "@escape.tech/graphql-armor-max-depth";
+import { maxTokensPlugin } from "@escape.tech/graphql-armor-max-tokens";
+import { type GraphQLSchema, printSchema } from "graphql";
+import { createYoga } from "graphql-yoga";
+import { createMiddleware } from "hono/factory";
+import { buildDataLoaderCache, buildGraphQLSchema } from "./index.js";
+
+/**
+ * Middleware for GraphQL with an interactive web view.
+ *
+ * - Docs: https://ponder.sh/docs/api-reference/ponder/api-endpoints#graphql
+ *
+ * @example
+ * import { db } from "ponder:api";
+ * import schema from "ponder:schema";
+ * import { graphql } from "@/index.js";
+ * import { Hono } from "hono";
+ *
+ * const app = new Hono();
+ *
+ * app.use("/graphql", graphql({ db, schema }));
+ *
+ * export default app;
+ *
+ */
+export const graphql = (
+  { schema }: { db: ReadonlyDrizzle<Schema>; schema: Schema },
+  {
+    maxOperationTokens = 1000,
+    maxOperationDepth = 100,
+    maxOperationAliases = 30,
+  }: {
+    maxOperationTokens?: number;
+    maxOperationDepth?: number;
+    maxOperationAliases?: number;
+  } = {
+    // Default limits are from Apollo:
+    // https://www.apollographql.com/blog/prevent-graph-misuse-with-operation-size-and-complexity-limits
+    maxOperationTokens: 1000,
+    maxOperationDepth: 100,
+    maxOperationAliases: 30,
+  },
+) => {
+  if (globalThis.PONDER_DATABASE === undefined) {
+    throw new Error(
+      "graphql() middleware cannot be initialized outside of a Ponder project",
+    );
+  }
+
+  const graphqlSchema = buildGraphQLSchema({ schema });
+
+  generateSchema({ graphqlSchema }).catch(() => {});
+
+  const yoga = createYoga({
+    graphqlEndpoint: "*", // Disable built-in route validation, use Hono routing instead
+    schema: graphqlSchema,
+    context: () => {
+      const getDataLoader = buildDataLoaderCache(
+        globalThis.PONDER_DATABASE.readonlyQB,
+      );
+
+      return { qb: globalThis.PONDER_DATABASE.readonlyQB, getDataLoader };
+    },
+    maskedErrors: process.env.NODE_ENV === "production",
+    logging: false,
+    graphiql: false,
+    parserAndValidationCache: false,
+    plugins: [
+      maxTokensPlugin({ n: maxOperationTokens }),
+      maxDepthPlugin({ n: maxOperationDepth, ignoreIntrospection: false }),
+      maxAliasesPlugin({ n: maxOperationAliases, allowList: [] }),
+    ],
+  });
+
+  return createMiddleware(async (c) => {
+    if (c.req.method === "GET") {
+      return c.html(graphiQLHtml);
+    }
+
+    const response = await yoga.handle(c.req.raw);
+    if (response.status === 200) return response;
+    // set response status to 200, must construct a new response object because Response.status is readonly
+
+    // TODO: Figure out why Yoga is returning 500 status codes for GraphQL errors.
+    const body = response.body;
+    const headers = new Headers(response.headers);
+    return new Response(body, {
+      status: 200,
+      statusText: "OK",
+      headers,
+    });
+  });
+};
+
+async function generateSchema({
+  graphqlSchema,
+}: { graphqlSchema: GraphQLSchema }) {
+  const fs = await import(/* webpackIgnore: true */ "node:fs");
+  const path = await import(/* webpackIgnore: true */ "node:path");
+
+  fs.mkdirSync(path.join(process.cwd(), "generated"), { recursive: true });
+  fs.writeFileSync(
+    path.join(process.cwd(), "generated", "schema.graphql"),
+    printSchema(graphqlSchema),
+    "utf-8",
+  );
+
+  globalThis.PONDER_COMMON?.logger.debug({
+    msg: `Wrote file "generated/schema.graphql"`,
+  });
+}

package/src/index.ts

@@ -0,0 +1,139 @@
+export { createConfig } from "@/config/index.js";
+export { factory } from "@/config/address.js";
+export type {
+  Block,
+  Log,
+  Transaction,
+  TransactionReceipt,
+} from "@/types/eth.js";
+export type { Virtual } from "@/types/virtual.js";
+export {
+  type MergeAbis,
+  type ReplaceBigInts,
+  mergeAbis,
+  loadBalance,
+  rateLimit,
+  replaceBigInts,
+} from "@ponder/utils";
+
+import type { Config } from "@/config/index.js";
+import type { Prettify } from "./types/utils.js";
+
+export type ContractConfig = Prettify<Config["contracts"][string]>;
+export type ChainConfig = Prettify<Config["chains"][string]>;
+export type BlockConfig = Prettify<Config["blocks"][string]>;
+export type DatabaseConfig = Prettify<Config["database"]>;
+
+export type { CreateConfigReturnType } from "@/config/index.js";
+export type { GetEventFilter } from "@/config/eventFilter.js";
+export type { AddressConfig } from "@/config/address.js";
+
+export {
+  onchainTable,
+  onchainView,
+  onchainEnum,
+  primaryKey,
+  hex,
+  bigint,
+} from "@/drizzle/onchain.js";
+
+export type {
+  AnyPgColumn,
+  PgColumn,
+  ExtraConfigColumn,
+  PgColumnBuilder,
+  PgColumnBuilderBase,
+  PgEnumColumnBuilder,
+  PgEnumColumnBuilderInitial,
+  PgTable,
+  PgTableExtraConfig,
+  PgTableWithColumns,
+  PgTextConfig,
+  TableConfig,
+} from "drizzle-orm/pg-core";
+
+export type {
+  OnchainTable,
+  BuildExtraConfigColumns,
+  PgColumnsBuilders,
+  PrimaryKeyBuilder,
+  OnchainEnum,
+} from "@/drizzle/onchain.js";
+
+export type { ReadonlyDrizzle } from "@/types/db.js";
+
+export { client } from "@/client/index.js";
+
+export { graphql } from "@/graphql/middleware.js";
+
+export {
+  sql,
+  eq,
+  gt,
+  gte,
+  lt,
+  lte,
+  ne,
+  isNull,
+  isNotNull,
+  inArray,
+  notInArray,
+  exists,
+  notExists,
+  between,
+  notBetween,
+  like,
+  notLike,
+  ilike,
+  notIlike,
+  not,
+  asc,
+  desc,
+  and,
+  or,
+  count,
+  countDistinct,
+  avg,
+  avgDistinct,
+  sum,
+  sumDistinct,
+  max,
+  min,
+  relations,
+} from "drizzle-orm";
+
+export {
+  bigint as int8,
+  boolean,
+  char,
+  cidr,
+  date,
+  doublePrecision,
+  inet,
+  integer,
+  interval,
+  json,
+  jsonb,
+  line,
+  macaddr,
+  macaddr8,
+  numeric,
+  point,
+  real,
+  smallint,
+  text,
+  time,
+  timestamp,
+  uuid,
+  varchar,
+  index,
+  uniqueIndex,
+  alias,
+  foreignKey,
+  union,
+  unionAll,
+  intersect,
+  intersectAll,
+  except,
+  exceptAll,
+} from "drizzle-orm/pg-core";

package/src/indexing/addStackTrace.ts

@@ -0,0 +1,69 @@
+import { readFileSync } from "node:fs";
+import type { Options } from "@/internal/options.js";
+import { codeFrameColumns } from "@babel/code-frame";
+import { type StackFrame, parse as parseStackTrace } from "stacktrace-parser";
+
+// Note: this currently works for both indexing functions and api
+// routes only because the api route dir is a subdir of the indexing function
+// dir.
+
+export const addStackTrace = (error: Error, options: Options) => {
+  if (!error.stack) return;
+
+  const stackTrace = parseStackTrace(error.stack);
+
+  let codeFrame: string | undefined;
+  let userStackTrace: StackFrame[];
+
+  // Find first frame that occurred within user code.
+  const firstUserFrameIndex = stackTrace.findIndex((frame) =>
+    frame.file?.includes(options.indexingDir),
+  );
+
+  if (firstUserFrameIndex >= 0) {
+    userStackTrace = stackTrace.filter((frame) =>
+      frame.file?.includes(options.indexingDir),
+    );
+
+    const firstUserFrame = stackTrace[firstUserFrameIndex];
+    if (firstUserFrame?.file && firstUserFrame?.lineNumber) {
+      try {
+        const sourceContent = readFileSync(firstUserFrame.file, {
+          encoding: "utf-8",
+        });
+        codeFrame = codeFrameColumns(
+          sourceContent,
+          {
+            start: {
+              line: firstUserFrame.lineNumber,
+              column: firstUserFrame.column ?? undefined,
+            },
+          },
+          { highlightCode: true },
+        );
+      } catch (err) {
+        // Ignore errors here.
+      }
+    }
+  } else {
+    userStackTrace = stackTrace;
+  }
+
+  const formattedStackTrace = [
+    `${error.name}: ${error.message}`,
+    ...userStackTrace.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})`;
+      }
+    }),
+    codeFrame,
+  ].join("\n");
+
+  error.stack = formattedStackTrace;
+};