@ensnode/ponder-subgraph 0.18.0 → 0.19.0

package/dist/middleware.js

@@ -62,20 +62,7 @@ import {
 } from "graphql";
 import { GraphQLJSON } from "graphql-scalars";
 
-// src/helpers.ts
-var intersectionOf = (arrays) => arrays.reduce((a, b) => a.filter((c) => b.includes(c)));
-var capitalize = (str) => {
-  if (!str) return str;
-  return `${str.charAt(0).toUpperCase()}${str.slice(1)}`;
-};
-
 // src/serialize.ts
-function serialize(value) {
-  return JSON.stringify(
-    value,
-    (_, v) => typeof v === "bigint" ? { __type: "bigint", value: v.toString() } : v
-  );
-}
 function deserialize(value) {
   return JSON.parse(
     value,
@@ -85,8 +72,6 @@ function deserialize(value) {
 
 // src/graphql.ts
 var onchain = Symbol.for("ponder:onchain");
-var DEFAULT_LIMIT = 100;
-var MAX_LIMIT = 1e3;
 var OrderDirectionEnum = new GraphQLEnumType({
   name: "OrderDirection",
   values: {
@@ -94,326 +79,6 @@ var OrderDirectionEnum = new GraphQLEnumType({
     desc: { value: "desc" }
   }
 });
-function buildGraphQLSchema(_schema, polymorphicConfig = { types: {}, fields: {} }) {
-  const schema = { ..._schema };
-  const _tablesConfig = extractTablesRelationalConfig(schema, createTableRelationsHelpers);
-  const polymorphicTableConfigs = Object.fromEntries(
-    Object.entries(polymorphicConfig.types).map(([interfaceTypeName, implementingTables]) => [
-      interfaceTypeName,
-      implementingTables.map((table) => getTableUniqueName(table)).map((tableName) => _tablesConfig.tables[_tablesConfig.tableNamesMap[tableName]])
-    ])
-  );
-  Object.assign(
-    schema,
-    ...Object.keys(polymorphicConfig.types).map(
-      (interfaceTypeName) => getIntersectionTableSchema(interfaceTypeName, polymorphicTableConfigs[interfaceTypeName])
-    )
-  );
-  const polymorphicFields = Object.entries(polymorphicConfig.fields).map(([fieldPath, interfaceTypeName]) => [
-    fieldPath.split("."),
-    interfaceTypeName
-  ]);
-  const tablesConfig = extractTablesRelationalConfig(schema, createTableRelationsHelpers);
-  const tables = Object.values(tablesConfig.tables);
-  const enums = Object.entries(schema).filter(
-    (el) => isPgEnum(el[1])
-  );
-  const enumTypes = {};
-  for (const [enumTsName, enumObject] of enums) {
-    enumTypes[enumObject.enumName] = new GraphQLEnumType({
-      name: enumTsName,
-      values: enumObject.enumValues.reduce(
-        (acc, cur) => ({ ...acc, [cur]: {} }),
-        {}
-      )
-    });
-  }
-  const entityOrderByEnums = {};
-  for (const table of tables) {
-    const values = Object.keys(table.columns).reduce(
-      (acc, columnName) => ({
-        ...acc,
-        [columnName]: { value: columnName }
-      }),
-      {}
-    );
-    entityOrderByEnums[table.tsName] = new GraphQLEnumType({
-      name: `${getSubgraphEntityName(table.tsName)}_orderBy`,
-      values
-    });
-  }
-  const entityFilterTypes = {};
-  for (const table of tables) {
-    const filterType = new GraphQLInputObjectType({
-      name: `${getSubgraphEntityName(table.tsName)}_filter`,
-      fields: () => {
-        const filterFields = {
-          // Logical operators
-          // NOTE: lower case and/or
-          and: { type: new GraphQLList(filterType) },
-          or: { type: new GraphQLList(filterType) }
-        };
-        for (const [columnName, column] of Object.entries(table.columns)) {
-          const type = columnToGraphQLCore(column, enumTypes);
-          if (type instanceof GraphQLList) {
-            const baseType = innerType(type);
-            conditionSuffixes.universal.forEach((suffix) => {
-              filterFields[`${columnName}${suffix}`] = {
-                type: new GraphQLList(baseType)
-              };
-            });
-            conditionSuffixes.plural.forEach((suffix) => {
-              filterFields[`${columnName}${suffix}`] = { type: baseType };
-            });
-          }
-          if (type instanceof GraphQLScalarType || type instanceof GraphQLEnumType) {
-            if (type.name === "JSON") continue;
-            conditionSuffixes.universal.forEach((suffix) => {
-              filterFields[`${columnName}${suffix}`] = {
-                type
-              };
-            });
-            conditionSuffixes.singular.forEach((suffix) => {
-              filterFields[`${columnName}${suffix}`] = {
-                type: new GraphQLList(type)
-              };
-            });
-            if (["String", "ID"].includes(type.name)) {
-              conditionSuffixes.string.forEach((suffix) => {
-                filterFields[`${columnName}${suffix}`] = {
-                  type
-                };
-              });
-              conditionSuffixes.numeric.forEach((suffix) => {
-                filterFields[`${columnName}${suffix}`] = {
-                  type
-                };
-              });
-            }
-            if (["Int", "Float", "BigInt"].includes(type.name)) {
-              conditionSuffixes.numeric.forEach((suffix) => {
-                filterFields[`${columnName}${suffix}`] = {
-                  type
-                };
-              });
-            }
-          }
-        }
-        for (const [relationName, relation] of Object.entries(table.relations)) {
-          if (is(relation, One)) {
-            conditionSuffixes.universal.forEach((suffix) => {
-              filterFields[`${relation.fieldName}${suffix}`] = {
-                type: GraphQLString
-              };
-            });
-          }
-        }
-        return filterFields;
-      }
-    });
-    entityFilterTypes[table.tsName] = filterType;
-  }
-  const entityTypes = {};
-  const interfaceTypes = {};
-  const entityPageTypes = {};
-  for (const interfaceTypeName of Object.keys(polymorphicTableConfigs)) {
-    const table = tablesConfig.tables[interfaceTypeName];
-    interfaceTypes[interfaceTypeName] = new GraphQLInterfaceType({
-      name: interfaceTypeName,
-      fields: () => {
-        const fieldConfigMap = {};
-        for (const [columnName, column] of Object.entries(table.columns)) {
-          const type = columnToGraphQLCore(column, enumTypes);
-          fieldConfigMap[columnName] = {
-            type: column.notNull ? new GraphQLNonNull(type) : type
-          };
-        }
-        return fieldConfigMap;
-      }
-    });
-  }
-  for (const table of tables) {
-    if (isInterfaceType(polymorphicConfig, table.tsName)) continue;
-    const entityTypeName = getSubgraphEntityName(table.tsName);
-    entityTypes[table.tsName] = new GraphQLObjectType({
-      name: entityTypeName,
-      interfaces: Object.entries(polymorphicTableConfigs).filter(
-        ([, implementingTables]) => implementingTables.map((table2) => table2.tsName).includes(table.tsName)
-      ).map(([interfaceTypeName]) => interfaceTypes[interfaceTypeName]),
-      fields: () => {
-        var _a, _b, _c, _d;
-        const fieldConfigMap = {};
-        for (const [columnName, column] of Object.entries(table.columns)) {
-          const type = columnToGraphQLCore(column, enumTypes);
-          fieldConfigMap[columnName] = {
-            type: column.notNull ? new GraphQLNonNull(type) : type
-          };
-        }
-        const relations2 = Object.entries(table.relations);
-        for (const [relationName, relation] of relations2) {
-          const referencedTable = tables.find(
-            (table2) => table2.dbName === relation.referencedTableName
-          );
-          if (!referencedTable)
-            throw new Error(
-              `Internal error: Referenced table "${relation.referencedTableName}" not found`
-            );
-          const referencedEntityType = entityTypes[referencedTable.tsName];
-          const referencedEntityPageType = entityPageTypes[referencedTable.tsName];
-          const referencedEntityFilterType = entityFilterTypes[referencedTable.tsName];
-          if (referencedEntityType === void 0 || referencedEntityPageType === void 0 || referencedEntityFilterType === void 0)
-            throw new Error(
-              `Internal error: Referenced entity types not found for table "${referencedTable.tsName}" `
-            );
-          if (is(relation, One)) {
-            const fields = ((_a = relation.config) == null ? void 0 : _a.fields) ?? [];
-            const references = ((_b = relation.config) == null ? void 0 : _b.references) ?? [];
-            if (fields.length !== references.length) {
-              throw new Error(
-                "Internal error: Fields and references arrays must be the same length"
-              );
-            }
-            fieldConfigMap[relationName] = {
-              // Note: There is a `relation.isNullable` field here but it appears
-              // to be internal / incorrect. Until we have support for foriegn
-              // key constraints, all `one` relations must be nullable.
-              type: referencedEntityType,
-              resolve: (parent, _args, context) => {
-                const loader = context.getDataLoader({ table: referencedTable });
-                const rowFragment = {};
-                for (let i = 0; i < references.length; i++) {
-                  const referenceColumn = references[i];
-                  const fieldColumn = fields[i];
-                  const fieldColumnTsName = getColumnTsName(fieldColumn);
-                  const referenceColumnTsName = getColumnTsName(referenceColumn);
-                  rowFragment[referenceColumnTsName] = parent[fieldColumnTsName];
-                }
-                const encodedId = encodeRowFragment(rowFragment);
-                return loader.load(encodedId);
-              }
-            };
-          } else if (is(relation, Many)) {
-            const oneRelation = Object.values(referencedTable.relations).find(
-              (relation2) => relation2.relationName === relationName || is(relation2, One) && relation2.referencedTableName === table.dbName
-            );
-            if (!oneRelation)
-              throw new Error(
-                `Internal error: Relation "${relationName}" not found in table "${referencedTable.tsName}"`
-              );
-            const fields = ((_c = oneRelation.config) == null ? void 0 : _c.fields) ?? [];
-            const references = ((_d = oneRelation.config) == null ? void 0 : _d.references) ?? [];
-            const referencedEntityOrderByType = entityOrderByEnums[referencedTable.tsName];
-            if (!referencedEntityOrderByType)
-              throw new Error(`Entity_orderBy Enum not found for ${referencedTable.tsName}`);
-            fieldConfigMap[relationName] = {
-              type: referencedEntityPageType,
-              args: {
-                where: { type: referencedEntityFilterType },
-                orderBy: { type: referencedEntityOrderByType },
-                orderDirection: { type: OrderDirectionEnum },
-                first: { type: GraphQLInt },
-                skip: { type: GraphQLInt }
-              },
-              resolve: (parent, args, context, info) => {
-                const relationalConditions = [];
-                for (let i = 0; i < references.length; i++) {
-                  const column = fields[i];
-                  const value = parent[references[i].name];
-                  relationalConditions.push(eq(column, value));
-                }
-                return executePluralQuery(
-                  referencedTable,
-                  schema[referencedTable.tsName],
-                  context.drizzle,
-                  args,
-                  relationalConditions
-                );
-              }
-            };
-          } else {
-            throw new Error(
-              `Internal error: Relation "${relationName}" is unsupported, expected One or Many`
-            );
-          }
-        }
-        polymorphicFields.filter(([[parent]]) => parent === entityTypeName).forEach(([[, fieldName], interfaceTypeName]) => {
-          fieldConfigMap[fieldName] = definePolymorphicPluralField({
-            schema,
-            interfaceType: interfaceTypes[interfaceTypeName],
-            filterType: entityFilterTypes[interfaceTypeName],
-            orderByType: entityOrderByEnums[interfaceTypeName],
-            intersectionTableConfig: tablesConfig.tables[interfaceTypeName],
-            implementingTableConfigs: polymorphicTableConfigs[interfaceTypeName]
-          });
-        });
-        return fieldConfigMap;
-      }
-    });
-    entityPageTypes[table.tsName] = new GraphQLNonNull(
-      new GraphQLList(new GraphQLNonNull(entityTypes[table.tsName]))
-    );
-  }
-  const queryFields = {};
-  for (const table of tables) {
-    if (isInterfaceType(polymorphicConfig, table.tsName)) continue;
-    const entityType = entityTypes[table.tsName];
-    const entityPageType = entityPageTypes[table.tsName];
-    const entityFilterType = entityFilterTypes[table.tsName];
-    const singularFieldName = table.tsName.charAt(0).toLowerCase() + table.tsName.slice(1);
-    const pluralFieldName = `${singularFieldName}s`;
-    queryFields[singularFieldName] = {
-      type: entityType,
-      // Find the primary key columns and GraphQL core types and include them
-      // as arguments to the singular query type.
-      args: Object.fromEntries(
-        table.primaryKey.map((column) => [
-          getColumnTsName(column),
-          {
-            type: new GraphQLNonNull(columnToGraphQLCore(column, enumTypes))
-          }
-        ])
-      ),
-      resolve: async (_parent, args, context) => {
-        const loader = context.getDataLoader({ table });
-        const encodedId = encodeRowFragment(args);
-        return loader.load(encodedId);
-      }
-    };
-    const entityOrderByType = entityOrderByEnums[table.tsName];
-    if (!entityOrderByType) throw new Error(`Entity_orderBy Enum not found for ${table.tsName}`);
-    queryFields[pluralFieldName] = {
-      type: entityPageType,
-      args: {
-        where: { type: entityFilterType },
-        orderBy: { type: entityOrderByType },
-        orderDirection: { type: OrderDirectionEnum },
-        first: { type: GraphQLInt },
-        skip: { type: GraphQLInt }
-      },
-      resolve: async (_parent, args, context, info) => {
-        return executePluralQuery(table, schema[table.tsName], context.drizzle, args);
-      }
-    };
-  }
-  polymorphicFields.filter(([[parent]]) => parent === "Query").forEach(([[, fieldName], interfaceTypeName]) => {
-    queryFields[fieldName] = definePolymorphicPluralField({
-      schema,
-      interfaceType: interfaceTypes[interfaceTypeName],
-      filterType: entityFilterTypes[interfaceTypeName],
-      orderByType: entityOrderByEnums[interfaceTypeName],
-      intersectionTableConfig: tablesConfig.tables[interfaceTypeName],
-      implementingTableConfigs: polymorphicTableConfigs[interfaceTypeName]
-    });
-  });
-  return new GraphQLSchema({
-    // Include these here so they are listed first in the printed schema.
-    types: [GraphQLJSON, GraphQLBigInt, GraphQLPageInfo],
-    query: new GraphQLObjectType({
-      name: "Query",
-      fields: queryFields
-    })
-  });
-}
 var GraphQLPageInfo = new GraphQLObjectType({
   name: "PageInfo",
   fields: {
@@ -437,85 +102,6 @@ var GraphQLBigInt = new GraphQLScalarType({
     }
   }
 });
-var columnToGraphQLCore = (column, enumTypes) => {
-  if (column.columnType === "PgEvmBigint") {
-    return GraphQLBigInt;
-  }
-  if (column instanceof PgEnumColumn) {
-    if (column.enum === void 0) {
-      throw new Error(
-        `Internal error: Expected enum column "${getColumnTsName(column)}" to have an "enum" property`
-      );
-    }
-    const enumType = enumTypes[column.enum.enumName];
-    if (enumType === void 0) {
-      throw new Error(
-        `Internal error: Expected to find a GraphQL enum named "${column.enum.enumName}"`
-      );
-    }
-    return enumType;
-  }
-  switch (column.dataType) {
-    case "boolean":
-      return GraphQLBoolean;
-    case "json":
-      return GraphQLJSON;
-    case "date":
-      return GraphQLString;
-    case "string":
-      return GraphQLString;
-    case "bigint":
-      return GraphQLString;
-    case "number":
-      return is(column, PgInteger) || is(column, PgSerial) ? GraphQLInt : GraphQLFloat;
-    case "buffer":
-      return new GraphQLList(new GraphQLNonNull(GraphQLInt));
-    case "array": {
-      if (column.columnType === "PgVector") {
-        return new GraphQLList(new GraphQLNonNull(GraphQLFloat));
-      }
-      if (column.columnType === "PgGeometry") {
-        return new GraphQLList(new GraphQLNonNull(GraphQLFloat));
-      }
-      const innerType2 = columnToGraphQLCore(column.baseColumn, enumTypes);
-      return new GraphQLList(new GraphQLNonNull(innerType2));
-    }
-    default:
-      throw new Error(`Type ${column.dataType} is not implemented`);
-  }
-};
-var innerType = (type) => {
-  if (type instanceof GraphQLScalarType || type instanceof GraphQLEnumType) return type;
-  if (type instanceof GraphQLList || type instanceof GraphQLNonNull) return innerType(type.ofType);
-  throw new Error(`Type ${type.toString()} is not implemented`);
-};
-async function executePluralQuery(table, from, drizzle, args, extraConditions = []) {
-  const limit = args.first ?? DEFAULT_LIMIT;
-  if (limit > MAX_LIMIT) {
-    throw new Error(`Invalid limit. Got ${limit}, expected <=${MAX_LIMIT}.`);
-  }
-  const skip = args.skip ?? 0;
-  const orderBySchema = buildOrderBySchema(table, args);
-  const orderBy = orderBySchema.map(([columnName, direction]) => {
-    const column = table.columns[columnName];
-    if (column === void 0) {
-      throw new Error(`Unknown column "${columnName}" used in orderBy argument`);
-    }
-    return direction === "asc" ? asc(column) : desc(column);
-  });
-  const whereConditions = buildWhereConditions(args.where, table);
-  const query = drizzle.select().from(from).where(and(...whereConditions, ...extraConditions)).orderBy(...orderBy).limit(limit).offset(skip);
-  const startTime = performance.now();
-  const rows = await query;
-  const queryDurationSeconds = (performance.now() - startTime) / 1e3;
-  const isSlowQuery = queryDurationSeconds > 2;
-  if (isSlowQuery) {
-    console.warn(`Slow Query Detected (${queryDurationSeconds.toFixed(4)}s)`);
-    console.warn(new PgDialect().sqlToQuery(query.getSQL()).sql);
-    console.log("\n");
-  }
-  return rows;
-}
 var conditionSuffixes = {
   universal: ["", "_not"],
   singular: ["_in", "_not_in"],
@@ -637,15 +223,6 @@ function buildWhereConditions(where, table) {
   }
   return conditions;
 }
-function buildOrderBySchema(table, args) {
-  const userDirection = args.orderDirection ?? "asc";
-  const userColumns = args.orderBy !== void 0 ? [[args.orderBy, userDirection]] : [];
-  const pkColumns = table.primaryKey.map((column) => [getColumnTsName(column), userDirection]);
-  const missingPkColumns = pkColumns.filter(
-    (pkColumn) => !userColumns.some((userColumn) => userColumn[0] === pkColumn[0])
-  );
-  return [...userColumns, ...missingPkColumns];
-}
 function buildDataLoaderCache({ drizzle }) {
   const dataLoaderMap = /* @__PURE__ */ new Map();
   return ({ table }) => {
@@ -677,149 +254,14 @@ function buildDataLoaderCache({ drizzle }) {
     return dataLoader;
   };
 }
-function getColumnTsName(column) {
-  const tableColumns = getTableColumns(column.table);
-  return Object.entries(tableColumns).find(([_, c]) => c.name === column.name)[0];
-}
-function encodeRowFragment(rowFragment) {
-  return Buffer.from(serialize(rowFragment)).toString("base64");
-}
 function decodeRowFragment(encodedRowFragment) {
   return deserialize(Buffer.from(encodedRowFragment, "base64").toString());
 }
-function getSubgraphEntityName(tsName) {
-  return capitalize(tsName);
-}
-function isInterfaceType(polymorphicConfig, columnName) {
-  return columnName in polymorphicConfig.types;
-}
-function getIntersectionTableSchema(interfaceTypeName, tableConfigs) {
-  if (tableConfigs.length === 0) throw new Error("Must have some tables to intersect");
-  const baseColumns = tableConfigs[0].columns;
-  const baseRelations = tableConfigs[0].relations;
-  const commonColumnNames = intersectionOf(
-    tableConfigs.map((table) => Object.keys(table.columns))
-    //
-  );
-  const commonRelationsNames = intersectionOf(
-    tableConfigs.map((table) => Object.keys(table.relations))
-  );
-  const intersectionTable = pgTable("intersection_table", (t) => {
-    function getColumnBuilder(column) {
-      const sqlType = column.getSQLType();
-      if (sqlType === "numeric(78)") {
-        return t.numeric({ precision: 78 });
-      }
-      const built = t[sqlType.split("(")[0]]();
-      return column.primary ? built.primaryKey() : built;
-    }
-    const columnMap = {};
-    for (const columnName of commonColumnNames) {
-      const baseColumn = baseColumns[columnName];
-      columnMap[columnName] = getColumnBuilder(baseColumn).notNull(baseColumn.notNull);
-    }
-    return columnMap;
-  });
-  const intersectionTableRelations = relations(
-    intersectionTable,
-    ({ one }) => commonRelationsNames.reduce((memo, relationName) => {
-      const relation = baseRelations[relationName];
-      if (is(relation, One)) {
-        memo[relationName] = one(relation.referencedTable, relation.config);
-      } else if (is(relation, Many)) {
-      }
-      return memo;
-    }, {})
-  );
-  return {
-    [interfaceTypeName]: intersectionTable,
-    [`${interfaceTypeName}Relations`]: intersectionTableRelations
-  };
-}
-function getColumnsUnion(tables) {
-  return tables.reduce(
-    (memo, table) => ({
-      ...memo,
-      ...table.columns
-    }),
-    {}
-  );
-}
-function buildUnionAllQuery(drizzle, schema, tables, where = {}) {
-  const allColumns = getColumnsUnion(tables);
-  const allColumnNames = Object.keys(allColumns).sort();
-  const subqueries = tables.map((table) => {
-    const selectAllColumnsIncludingNulls = allColumnNames.reduce((memo, columnName) => {
-      const column = allColumns[columnName];
-      const dbColumnName = table.columns[columnName] ? toSnakeCase(table.columns[columnName].name) : "NULL";
-      return {
-        ...memo,
-        [columnName]: sql.raw(`${dbColumnName}::${column.getSQLType()}`).as(column.name)
-      };
-    }, {});
-    const relationalConditions = Object.entries(where).map(
-      ([foreignKeyName, foreignKeyValue]) => eq(table.columns[foreignKeyName], foreignKeyValue)
-    );
-    return drizzle.select({
-      ...selectAllColumnsIncludingNulls,
-      // inject __typename into each subquery
-      __typename: sql.raw(`'${getSubgraphEntityName(table.tsName)}'`).as("__typename")
-    }).from(schema[table.tsName]).where(and(...relationalConditions)).$dynamic();
-  });
-  return subqueries.reduce((memo, fragment, i) => i === 0 ? fragment : memo.unionAll(fragment)).as("intersection_table");
-}
-function definePolymorphicPluralField({
-  schema,
-  interfaceType,
-  filterType,
-  orderByType,
-  intersectionTableConfig,
-  implementingTableConfigs
-}) {
-  return {
-    type: new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(interfaceType))),
-    args: {
-      where: { type: filterType },
-      orderBy: { type: orderByType },
-      orderDirection: { type: OrderDirectionEnum },
-      first: { type: GraphQLInt },
-      skip: { type: GraphQLInt }
-    },
-    resolve: async (parent, args, { drizzle }, info) => {
-      const foreignKeyName = getForeignKeyFieldName(intersectionTableConfig, info.parentType.name);
-      const relationalFilter = foreignKeyName ? { [foreignKeyName]: parent.id } : {};
-      const subquery = buildUnionAllQuery(
-        drizzle,
-        schema,
-        implementingTableConfigs,
-        relationalFilter
-      );
-      return executePluralQuery(intersectionTableConfig, subquery, drizzle, args);
-    }
-  };
-}
-function getForeignKeyFieldName(table, parentTypeName) {
-  var _a, _b, _c;
-  const relationName = Object.keys(table.relations).find(
-    (relationName2) => getSubgraphEntityName(relationName2) === parentTypeName
-  );
-  if (!relationName) return;
-  const relation = table.relations[relationName];
-  if (!is(relation, One)) return;
-  const fkEntry = Object.entries(((_c = (_b = (_a = relation.config) == null ? void 0 : _a.fields) == null ? void 0 : _b[0]) == null ? void 0 : _c.table) ?? {}).find(
-    ([_, column]) => {
-      var _a2, _b2, _c2;
-      return column.name === ((_c2 = (_b2 = (_a2 = relation.config) == null ? void 0 : _a2.fields) == null ? void 0 : _b2[0]) == null ? void 0 : _c2.name);
-    }
-  );
-  return fkEntry == null ? void 0 : fkEntry[0];
-}
 
 // src/middleware.ts
 var graphql = ({
   db,
-  schema,
-  polymorphicConfig
+  graphqlSchema
 }, {
   maxOperationTokens = 1e3,
   maxOperationDepth = 100,
@@ -831,7 +273,6 @@ var graphql = ({
   maxOperationDepth: 100,
   maxOperationAliases: 30
 }) => {
-  const graphqlSchema = buildGraphQLSchema(schema, polymorphicConfig);
   const yoga = createYoga({
     graphqlEndpoint: "*",
     // Disable built-in route validation, use Hono routing instead