@ensnode/ponder-subgraph 0.1.0

package/dist/middleware.js

@@ -0,0 +1,867 @@
+// src/middleware.ts
+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 { createYoga } from "graphql-yoga";
+import { createMiddleware } from "hono/factory";
+
+// src/graphql.ts
+import DataLoader from "dataloader";
+import {
+  Many,
+  One,
+  and,
+  arrayContained,
+  arrayContains,
+  asc,
+  createTableRelationsHelpers,
+  desc,
+  eq,
+  extractTablesRelationalConfig,
+  getTableColumns,
+  getTableUniqueName,
+  gt,
+  gte,
+  inArray,
+  is,
+  isNotNull,
+  isNull,
+  like,
+  lt,
+  lte,
+  ne,
+  not,
+  notInArray,
+  notLike,
+  or,
+  relations,
+  sql
+} from "drizzle-orm";
+import {
+  PgDialect,
+  PgEnumColumn,
+  PgInteger,
+  PgSerial,
+  isPgEnum,
+  pgTable
+} from "drizzle-orm/pg-core";
+import {
+  GraphQLBoolean,
+  GraphQLEnumType,
+  GraphQLFloat,
+  GraphQLInputObjectType,
+  GraphQLInt,
+  GraphQLInterfaceType,
+  GraphQLList,
+  GraphQLNonNull,
+  GraphQLObjectType,
+  GraphQLScalarType,
+  GraphQLSchema,
+  GraphQLString
+} 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,
+    (_, value_) => (value_ == null ? void 0 : value_.__type) === "bigint" ? BigInt(value_.value) : 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: {
+    asc: { value: "asc" },
+    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: {
+    hasNextPage: { type: new GraphQLNonNull(GraphQLBoolean) },
+    hasPreviousPage: { type: new GraphQLNonNull(GraphQLBoolean) },
+    startCursor: { type: GraphQLString },
+    endCursor: { type: GraphQLString }
+  }
+});
+var GraphQLBigInt = new GraphQLScalarType({
+  name: "BigInt",
+  serialize: (value) => String(value),
+  parseValue: (value) => BigInt(value),
+  parseLiteral: (value) => {
+    if (value.kind === "StringValue") {
+      return BigInt(value.value);
+    } else {
+      throw new Error(
+        `Invalid value kind provided for field of type BigInt: ${value.kind}. Expected: StringValue`
+      );
+    }
+  }
+});
+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"],
+  plural: ["_has", "_not_has"],
+  numeric: ["_gt", "_lt", "_gte", "_lte"],
+  string: [
+    "_contains",
+    "_not_contains",
+    "_starts_with",
+    "_ends_with",
+    "_not_starts_with",
+    "_not_ends_with"
+  ]
+};
+var conditionSuffixesByLengthDesc = Object.values(conditionSuffixes).flat().sort((a, b) => b.length - a.length);
+function buildWhereConditions(where, table) {
+  const conditions = [];
+  if (where === void 0) return conditions;
+  for (const [whereKey, rawValue] of Object.entries(where)) {
+    if (whereKey === "and" || whereKey === "or") {
+      if (!Array.isArray(rawValue)) {
+        throw new Error(
+          `Invalid query: Expected an array for the ${whereKey} operator. Got: ${rawValue}`
+        );
+      }
+      const nestedConditions = rawValue.flatMap(
+        (subWhere) => buildWhereConditions(subWhere, table)
+      );
+      if (nestedConditions.length > 0) {
+        conditions.push(whereKey === "and" ? and(...nestedConditions) : or(...nestedConditions));
+      }
+      continue;
+    }
+    const conditionSuffix = conditionSuffixesByLengthDesc.find((s) => whereKey.endsWith(s));
+    if (conditionSuffix === void 0) {
+      throw new Error(`Invariant violation: Condition suffix not found for where key ${whereKey}`);
+    }
+    const columnName = whereKey.slice(0, whereKey.length - conditionSuffix.length);
+    const column = columnName in table.relations ? (
+      // if the referenced name is a relation, the relevant column is this table's `${relationName}Id`
+      table.columns[`${columnName}Id`]
+    ) : (
+      // otherwise validate that the column name is present in the table
+      table.columns[columnName]
+    );
+    if (column === void 0) {
+      throw new Error(`Invalid query: Where clause contains unknown column ${columnName}`);
+    }
+    switch (conditionSuffix) {
+      case "":
+        if (column.columnType === "PgArray") {
+          conditions.push(and(arrayContains(column, rawValue), arrayContained(column, rawValue)));
+        } else {
+          if (rawValue === null) {
+            conditions.push(isNull(column));
+          } else {
+            conditions.push(eq(column, rawValue));
+          }
+        }
+        break;
+      case "_not":
+        if (column.columnType === "PgArray") {
+          conditions.push(
+            not(and(arrayContains(column, rawValue), arrayContained(column, rawValue)))
+          );
+        } else {
+          if (rawValue === null) {
+            conditions.push(isNotNull(column));
+          } else {
+            conditions.push(ne(column, rawValue));
+          }
+        }
+        break;
+      case "_in":
+        conditions.push(inArray(column, rawValue));
+        break;
+      case "_not_in":
+        conditions.push(notInArray(column, rawValue));
+        break;
+      case "_has":
+        conditions.push(arrayContains(column, [rawValue]));
+        break;
+      case "_not_has":
+        conditions.push(not(arrayContains(column, [rawValue])));
+        break;
+      case "_gt":
+        conditions.push(gt(column, rawValue));
+        break;
+      case "_lt":
+        conditions.push(lt(column, rawValue));
+        break;
+      case "_gte":
+        conditions.push(gte(column, rawValue));
+        break;
+      case "_lte":
+        conditions.push(lte(column, rawValue));
+        break;
+      case "_contains":
+        conditions.push(like(column, `%${rawValue}%`));
+        break;
+      case "_not_contains":
+        conditions.push(notLike(column, `%${rawValue}%`));
+        break;
+      case "_starts_with":
+        conditions.push(like(column, `${rawValue}%`));
+        break;
+      case "_ends_with":
+        conditions.push(like(column, `%${rawValue}`));
+        break;
+      case "_not_starts_with":
+        conditions.push(notLike(column, `${rawValue}%`));
+        break;
+      case "_not_ends_with":
+        conditions.push(notLike(column, `%${rawValue}`));
+        break;
+      default:
+        throw new Error(`Invalid Condition Suffix ${conditionSuffix}`);
+    }
+  }
+  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 }) => {
+    const baseQuery = drizzle.query[table.tsName];
+    if (baseQuery === void 0)
+      throw new Error(`Internal error: Unknown table "${table.tsName}" in data loader cache`);
+    let dataLoader = dataLoaderMap.get(table);
+    if (dataLoader === void 0) {
+      dataLoader = new DataLoader(
+        async (encodedIds) => {
+          const decodedRowFragments = encodedIds.map(decodeRowFragment);
+          const idConditions = decodedRowFragments.map(
+            (decodedRowFragment) => and(...buildWhereConditions(decodedRowFragment, table))
+          );
+          const rows = await baseQuery.findMany({
+            where: or(...idConditions),
+            limit: encodedIds.length
+          });
+          return decodedRowFragments.map(
+            (fragment) => rows.find(
+              (row) => Object.entries(fragment).every(([col, val]) => row[col] === val)
+            )
+          );
+        },
+        { maxBatchSize: 1e3 }
+      );
+      dataLoaderMap.set(table, dataLoader);
+    }
+    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) => {
+      var _a;
+      const column = allColumns[columnName];
+      return {
+        ...memo,
+        [columnName]: sql.raw(`${((_a = table.columns[columnName]) == null ? void 0 : _a.name) ?? "NULL"}::${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
+}, {
+  maxOperationTokens = 1e3,
+  maxOperationDepth = 100,
+  maxOperationAliases = 30
+} = {
+  // Default limits are from Apollo:
+  // https://www.apollographql.com/blog/prevent-graph-misuse-with-operation-size-and-complexity-limit
+  maxOperationTokens: 1e3,
+  maxOperationDepth: 100,
+  maxOperationAliases: 30
+}) => {
+  const graphqlSchema = buildGraphQLSchema(schema, polymorphicConfig);
+  const yoga = createYoga({
+    graphqlEndpoint: "*",
+    // Disable built-in route validation, use Hono routing instead
+    schema: graphqlSchema,
+    context: () => {
+      const getDataLoader = buildDataLoaderCache({ drizzle: db });
+      return { drizzle: db, getDataLoader };
+    },
+    maskedErrors: process.env.NODE_ENV === "production" ? true : {
+      maskError(error) {
+        console.error(error.originalError);
+        return error;
+      }
+    },
+    logging: false,
+    graphiql: true,
+    parserAndValidationCache: false,
+    plugins: [
+      maxTokensPlugin({ n: maxOperationTokens }),
+      maxDepthPlugin({ n: maxOperationDepth, ignoreIntrospection: false }),
+      maxAliasesPlugin({ n: maxOperationAliases, allowList: [] })
+    ]
+  });
+  return createMiddleware(async (c) => {
+    const response = await yoga.handle(c.req.raw);
+    response.status = 200;
+    response.statusText = "OK";
+    return response;
+  });
+};
+export {
+  graphql
+};
+//# sourceMappingURL=middleware.js.map