@vantreeseba/drizzle-graphql 1.0.3 → 3.0.0

package/dist/index.js

@@ -1,54 +1,46 @@
 // src/index.ts
-import { is as is6 } from "drizzle-orm";
+import { is as is7 } from "drizzle-orm";
 import { MySqlDatabase } from "drizzle-orm/mysql-core";
 import { PgAsyncDatabase } from "drizzle-orm/pg-core";
 import { BaseSQLiteDatabase } from "drizzle-orm/sqlite-core";
 import {
-  GraphQLObjectType as GraphQLObjectType4,
+  GraphQLObjectType as GraphQLObjectType5,
   GraphQLSchema
 } from "graphql";
 
-// src/util/builders/mysql.ts
-import { is as is3 } from "drizzle-orm";
-import { MySqlTable } from "drizzle-orm/mysql-core";
-import {
-  GraphQLBoolean as GraphQLBoolean3,
-  GraphQLError as GraphQLError3,
-  GraphQLInt as GraphQLInt3,
-  GraphQLList as GraphQLList3,
-  GraphQLNonNull as GraphQLNonNull3,
-  GraphQLObjectType as GraphQLObjectType3
-} from "graphql";
-import { parseResolveInfo } from "graphql-parse-resolve-info";
-
 // src/util/builders/common.ts
 import {
+  aliasedTable,
   and,
   asc,
   desc,
   eq,
-  getColumns as getColumns2,
+  getColumns,
+  getTableAsAliasSQL,
   gt,
   gte,
   ilike,
   inArray,
-  is as is2,
+  is as is3,
   isNotNull,
   isNull,
   like,
   lt,
   lte,
   ne,
+  not,
   notIlike,
   notInArray,
   notLike,
-  One,
-  or
+  One as One2,
+  or,
+  relationsFilterToSQL,
+  sql
 } from "drizzle-orm";
 import {
   GraphQLBoolean as GraphQLBoolean2,
   GraphQLEnumType as GraphQLEnumType2,
-  GraphQLError as GraphQLError2,
+  GraphQLError as GraphQLError3,
   GraphQLInputObjectType as GraphQLInputObjectType2,
   GraphQLInt as GraphQLInt2,
   GraphQLList as GraphQLList2,
@@ -57,15 +49,61 @@ import {
   GraphQLString as GraphQLString2
 } from "graphql";
 
+// src/util/batch-loader/index.ts
+var DRIZZLE_LOADERS_KEY = /* @__PURE__ */ Symbol("drizzle-graphql-loaders");
+var BatchLoader = class {
+  constructor(batchFn) {
+    this.batchFn = batchFn;
+  }
+  batch = [];
+  scheduled = false;
+  load(key) {
+    return new Promise((resolve, reject) => {
+      this.batch.push({ key, resolve, reject });
+      if (!this.scheduled) {
+        this.scheduled = true;
+        Promise.resolve().then(() => this.dispatch());
+      }
+    });
+  }
+  async dispatch() {
+    const current = this.batch.splice(0);
+    this.scheduled = false;
+    try {
+      const results = await this.batchFn(current.map(({ key }) => key));
+      for (let i = 0; i < current.length; i++) {
+        current[i].resolve(results[i]);
+      }
+    } catch (err) {
+      for (const { reject } of current) {
+        reject(err);
+      }
+    }
+  }
+};
+var getOrCreateLoader = (context, key, batchFn) => {
+  if (!context || typeof context !== "object") {
+    return new BatchLoader(batchFn);
+  }
+  if (!context[DRIZZLE_LOADERS_KEY]) {
+    context[DRIZZLE_LOADERS_KEY] = /* @__PURE__ */ new Map();
+  }
+  const loaders = context[DRIZZLE_LOADERS_KEY];
+  if (!loaders.has(key)) {
+    loaders.set(key, new BatchLoader(batchFn));
+  }
+  return loaders.get(key);
+};
+
 // src/util/case-ops/index.ts
 import pluralize from "pluralize";
 var uncapitalize = (input) => input?.length ? `${input[0].toLocaleLowerCase()}${input.length > 1 ? input.slice(1, input.length) : ""}` : input;
 var capitalize = (input) => input?.length ? `${input[0].toLocaleUpperCase()}${input.length > 1 ? input.slice(1, input.length) : ""}` : input;
-var singularize = (input) => pluralize.singular(input);
 
 // src/util/data-mappers/index.ts
-import { getTableColumns } from "drizzle-orm";
+import { getTableColumns, is, One } from "drizzle-orm";
 import { GraphQLError } from "graphql";
+var isJsonColumn = (column) => (column.dataType ?? "").includes("json") && column.columnType !== "PgGeometryObject";
 var remapToGraphQLCore = (key, value, tableName, column, relationMap) => {
   if (Array.isArray(value)) {
     const relations = relationMap?.[tableName];
@@ -95,6 +133,9 @@ var remapToGraphQLCore = (key, value, tableName, column, relationMap) => {
   if (!column) {
     return value;
   }
+  if (isJsonColumn(column)) {
+    return value;
+  }
   if (value instanceof Date) {
     return value.toISOString();
   }
@@ -121,6 +162,11 @@ var remapToGraphQLCore = (key, value, tableName, column, relationMap) => {
 var remapToGraphQLSingleOutput = (queryOutput, tableName, table, relationMap) => {
   for (const [key, value] of Object.entries(queryOutput)) {
     if (value === void 0 || value === null) {
+      const relEntry = value === null ? relationMap?.[tableName]?.[key] : void 0;
+      if (relEntry && is(relEntry.relation, One)) {
+        queryOutput[key] = null;
+        continue;
+      }
       delete queryOutput[key];
       continue;
     }
@@ -167,17 +213,7 @@ var remapFromGraphQLCore = (value, column, columnName) => {
     }
   }
   if (dataType.includes("json") && column.columnType !== "PgGeometryObject") {
-    if (typeof value !== "string") {
-      return value;
-    }
-    try {
-      return JSON.parse(value);
-    } catch (e) {
-      throw new GraphQLError(
-        `Invalid JSON in field '${columnName}':
-${e instanceof Error ? e.message : "Unknown error"}`
-      );
-    }
+    return value;
   }
   switch (dataType) {
     case "date": {
@@ -258,9 +294,9 @@ var remapFromGraphQLArrayInput = (queryInput, table) => {
 };
 
 // src/util/type-converter/index.ts
-import { extractExtendedColumnType, getColumns, is } from "drizzle-orm";
+import { extractExtendedColumnType, is as is2 } from "drizzle-orm";
 import { MySqlInt, MySqlSerial } from "drizzle-orm/mysql-core";
-import { PgDate, PgDateString, PgInteger, PgSerial, PgTimestamp, PgTimestampString } from "drizzle-orm/pg-core";
+import { PgDate, PgDateString, PgInteger, PgSerial, PgTimestamp, PgTimestampString, PgUUID } from "drizzle-orm/pg-core";
 import { SQLiteInteger } from "drizzle-orm/sqlite-core";
 import {
   GraphQLBoolean,
@@ -273,7 +309,47 @@ import {
   GraphQLObjectType,
   GraphQLString
 } from "graphql";
-import { GraphQLDate, GraphQLDateTime } from "graphql-scalars";
+
+// src/util/scalars/index.ts
+import { GraphQLError as GraphQLError2, GraphQLScalarType, Kind } from "graphql";
+import { GraphQLDate, GraphQLDateTime, GraphQLJSON, GraphQLUUID } from "graphql-scalars";
+var asDecimalString = (value) => {
+  if (typeof value === "bigint") {
+    return value.toString();
+  }
+  if (typeof value === "number") {
+    if (!Number.isInteger(value)) {
+      throw new GraphQLError2(`BigInt cannot represent non-integer value: ${value}`);
+    }
+    if (!Number.isSafeInteger(value)) {
+      throw new GraphQLError2(
+        `BigInt cannot represent the number ${value} without precision loss \u2014 pass it as a string instead`
+      );
+    }
+    return String(value);
+  }
+  if (typeof value === "string") {
+    if (!/^-?\d+$/.test(value)) {
+      throw new GraphQLError2(`BigInt cannot represent non-integer value: "${value}"`);
+    }
+    return value;
+  }
+  throw new GraphQLError2(`BigInt cannot represent value: ${JSON.stringify(value)}`);
+};
+var GraphQLBigIntString = new GraphQLScalarType({
+  name: "BigInt",
+  description: "A 64-bit integer, transported as a decimal string so that values beyond JavaScript's safe integer range survive the round-trip intact.",
+  serialize: asDecimalString,
+  parseValue: asDecimalString,
+  parseLiteral: (ast) => {
+    if (ast.kind !== Kind.STRING && ast.kind !== Kind.INT) {
+      throw new GraphQLError2(`BigInt cannot represent a ${ast.kind}`, { nodes: ast });
+    }
+    return asDecimalString(ast.value);
+  }
+});
+
+// src/util/type-converter/index.ts
 var allowedNameChars = /^[a-zA-Z0-9_]+$/;
 var enumMap = /* @__PURE__ */ new WeakMap();
 var generateEnumCached = (column, columnName, tableName) => {
@@ -324,7 +400,7 @@ var columnToGraphQLCore = (column, columnName, tableName, isInput) => {
       } : column.columnType === "PgBytea" ? {
         type: new GraphQLList(new GraphQLNonNull(GraphQLInt)),
         description: "Buffer"
-      } : { type: GraphQLString, description: "JSON" };
+      } : { type: GraphQLJSON, description: "JSON" };
     case "string":
       if (column.enumValues?.length) {
         return { type: generateEnumCached(column, columnName, tableName) };
@@ -332,23 +408,26 @@ var columnToGraphQLCore = (column, columnName, tableName, isInput) => {
       if (column instanceof PgTimestamp || column instanceof PgTimestampString) {
         return { type: GraphQLDateTime, description: "DateTime" };
       }
+      if (column instanceof PgUUID) {
+        return { type: GraphQLUUID, description: "UUID" };
+      }
       if (column instanceof PgDateString) {
         return isInput ? { type: GraphQLString, description: "Date" } : { type: GraphQLDate, description: "Date" };
       }
       return { type: GraphQLString, description: "String" };
     case "bigint":
-      return { type: GraphQLString, description: "BigInt" };
+      return { type: GraphQLBigIntString, description: "BigInt" };
     case "number": {
       const dims = column.dimensions;
       if (dims !== void 0 && dims > 0) {
-        const baseDesc = is(column, PgInteger) || is(column, PgSerial) ? "Integer" : "Float";
+        const baseDesc = is2(column, PgInteger) || is2(column, PgSerial) ? "Integer" : "Float";
         const baseType2 = baseDesc === "Integer" ? GraphQLInt : GraphQLFloat;
         return {
           type: new GraphQLList(new GraphQLNonNull(baseType2)),
           description: `Array<${baseDesc}>`
         };
       }
-      return is(column, PgInteger) || is(column, PgSerial) || is(column, MySqlInt) || is(column, MySqlSerial) || is(column, SQLiteInteger) ? { type: GraphQLInt, description: "Integer" } : { type: GraphQLFloat, description: "Float" };
+      return is2(column, PgInteger) || is2(column, PgSerial) || is2(column, MySqlInt) || is2(column, MySqlSerial) || is2(column, SQLiteInteger) ? { type: GraphQLInt, description: "Integer" } : { type: GraphQLFloat, description: "Float" };
     }
     case "array": {
       if (column.columnType === "PgVector") {
@@ -378,26 +457,6 @@ var columnToGraphQLCore = (column, columnName, tableName, isInput) => {
       throw new Error(`Drizzle-GraphQL Error: Type ${column.dataType} is not implemented!`);
   }
 };
-var drizzleRelationToGraphQLInsertType = (tables, relationMap) => {
-  if (!relationMap) {
-    return null;
-  }
-  for (const [tableName, _val] of Object.entries(relationMap)) {
-    const table = tables[tableName];
-    if (!table) {
-      continue;
-    }
-    const columns = getColumns(table);
-    const columnEntries = Object.entries(columns).filter(([_key, value]) => value.primary);
-    const _connectFields = Object.fromEntries(
-      columnEntries.map(([columnName, columnDescription]) => [
-        columnName,
-        drizzleColumnToGraphQLType(columnDescription, columnName, tableName, false, true, true)
-      ])
-    );
-  }
-  return null;
-};
 var drizzleColumnToGraphQLType = (column, columnName, tableName, forceNullable = false, defaultIsNullable = false, isInput = false) => {
   const typeDesc = columnToGraphQLCore(column, columnName, tableName, isInput);
   const noDesc = ["string", "boolean", "number"];
@@ -419,7 +478,10 @@ var drizzleColumnToGraphQLType = (column, columnName, tableName, forceNullable =
 
 // src/util/builders/common.ts
 var rqbCrashTypes = ["SQLiteBigInt", "SQLiteBlobJson", "SQLiteBlobBuffer"];
-var toTypeName = (name, singular) => singular ? capitalize(singularize(name)) : capitalize(name);
+var resolveTypeName = (name, typeNameMapper) => {
+  const mapped = typeNameMapper?.(name);
+  return mapped ? capitalize(mapped.singular) : capitalize(name);
+};
 var buildNamedRelations = (relations, tableEntries) => {
   const namedRelations = {};
   for (const [relTableName, relConfig] of Object.entries(relations)) {
@@ -452,8 +514,173 @@ var buildNamedRelations = (relations, tableEntries) => {
   }
   return namedRelations;
 };
-var extractSelectedColumnsFromTree = (tree, table) => {
-  const tableColumns = getColumns2(table);
+var attachTargetPrimaryKeys = (namedRelations, tables, resolvePkNames) => {
+  const cache = /* @__PURE__ */ new Map();
+  for (const rels of Object.values(namedRelations)) {
+    for (const relEntry of Object.values(rels)) {
+      const { targetTableName } = relEntry;
+      let pk = cache.get(targetTableName);
+      if (!pk) {
+        const targetTable = tables[targetTableName];
+        pk = targetTable ? resolvePkNames(targetTable) : [];
+        cache.set(targetTableName, pk);
+      }
+      relEntry.targetPkNames = pk;
+    }
+  }
+};
+var extractRelationJoinColumns = (relEntry, parentTable, targetTable) => {
+  const rel = relEntry.relation ?? relEntry;
+  const sourceColumns = rel.sourceColumns;
+  const targetColumns = rel.targetColumns;
+  if (!sourceColumns?.length || !targetColumns?.length) {
+    return void 0;
+  }
+  const sourceCol = sourceColumns[0];
+  const targetCol = targetColumns[0];
+  const parentCols = getColumns(parentTable);
+  const localColPropName = Object.entries(parentCols).find(([, c]) => c === sourceCol)?.[0];
+  const targetCols = getColumns(targetTable);
+  const foreignColPropName = Object.entries(targetCols).find(([, c]) => c === targetCol)?.[0];
+  if (!localColPropName || !foreignColPropName) {
+    return void 0;
+  }
+  return { localColPropName, foreignCol: targetCol, foreignColPropName };
+};
+var drizzleExecutorKey = /* @__PURE__ */ Symbol.for("drizzle-graphql:executor");
+var resolveExecutor = (db, context) => {
+  if (context && typeof context === "object") {
+    const executor = context[drizzleExecutorKey];
+    if (executor) {
+      return executor;
+    }
+  }
+  return db;
+};
+var resolveQueryExecutor = (db, context, tableName, buildTimeQueryBase) => {
+  const executor = resolveExecutor(db, context);
+  return {
+    executor,
+    queryBase: buildTimeQueryBase ? executor?.query?.[tableName] ?? buildTimeQueryBase : buildTimeQueryBase
+  };
+};
+var batchedPaginatedRelationQuery = async (db, targetTable, foreignCol, whereCondition, orderByArg, limit, offset, pkNames) => {
+  const cols = getColumns(targetTable);
+  const orderExprs = [
+    ...orderByArg ? extractOrderBy(targetTable, orderByArg) : [],
+    ...primaryKeyOrderExprs(targetTable, pkNames)
+  ];
+  const orderClause = orderExprs.length ? sql` order by ${sql.join(orderExprs, sql`, `)}` : sql``;
+  const RN = "__drizzle_graphql_rn";
+  const rowNumber = sql`row_number() over (partition by ${foreignCol}${orderClause})`.as(RN);
+  const sub = db.select({ ...cols, [RN]: rowNumber }).from(targetTable).where(whereCondition).as("__paginated");
+  const lower = offset ?? 0;
+  const windowConds = [gt(sub[RN], lower)];
+  if (limit != null) {
+    windowConds.push(lte(sub[RN], lower + limit));
+  }
+  const rows = await db.select().from(sub).where(and(...windowConds)).orderBy(sub[RN]);
+  for (const row of rows) {
+    delete row[RN];
+  }
+  return rows;
+};
+var createRelationResolverFactory = (db, tables, filterCtx) => ({ tableName, relationName, relEntry, isOne }) => {
+  const parentTable = tables[tableName];
+  const targetTableName = relEntry.targetTableName;
+  const targetTable = tables[targetTableName];
+  if (!parentTable || !targetTable) {
+    return void 0;
+  }
+  const joinCols = extractRelationJoinColumns(relEntry, parentTable, targetTable);
+  if (!joinCols) {
+    return void 0;
+  }
+  const { localColPropName, foreignCol, foreignColPropName } = joinCols;
+  const targetPkNames = relEntry.targetPkNames ?? [];
+  return async (parent, args, context) => {
+    if (parent[relationName] !== void 0) {
+      return parent[relationName];
+    }
+    const localValue = parent[localColPropName];
+    if (localValue == null) {
+      return isOne ? null : [];
+    }
+    const { where: whereArg, orderBy: orderByArg, limit, offset } = args ?? {};
+    const argsKey = JSON.stringify({
+      where: whereArg ?? null,
+      orderBy: orderByArg ?? null,
+      limit: limit ?? null,
+      offset: offset ?? null
+    });
+    const loaderKey = `${tableName}::${relationName}::${argsKey}`;
+    const loader = getOrCreateLoader(context, loaderKey, async (parentIds) => {
+      const executor = resolveExecutor(db, context);
+      const uniqueIds = [...new Set(parentIds)];
+      const whereCondition = and(
+        inArray(foreignCol, uniqueIds),
+        whereArg ? extractFilters(targetTable, targetTableName, whereArg, relationFilterCtx(filterCtx, targetTableName)) : void 0
+      );
+      let rows;
+      if (limit != null || offset != null) {
+        rows = await batchedPaginatedRelationQuery(
+          executor,
+          targetTable,
+          foreignCol,
+          whereCondition,
+          orderByArg,
+          limit ?? null,
+          offset ?? null,
+          targetPkNames
+        );
+      } else {
+        let q = executor.select().from(targetTable).where(whereCondition);
+        if (orderByArg) {
+          q = q.orderBy(...extractOrderBy(targetTable, orderByArg));
+        }
+        rows = await q;
+      }
+      if (isOne) {
+        const byKey = new Map(rows.map((row) => [String(row[foreignColPropName]), row]));
+        remapToGraphQLArrayOutput(rows, targetTableName, targetTable);
+        return parentIds.map((id) => byKey.get(String(id)) ?? null);
+      }
+      const grouped = new Map(uniqueIds.map((id) => [String(id), []]));
+      for (const row of rows) {
+        grouped.get(String(row[foreignColPropName]))?.push(row);
+      }
+      remapToGraphQLArrayOutput(rows, targetTableName, targetTable);
+      return parentIds.map((id) => grouped.get(String(id)) ?? []);
+    });
+    return loader.load(localValue);
+  };
+};
+var AGGREGATE_FIELD_SUFFIX = "Aggregate";
+var relationAggregateJoinColumns = (tree, table, selectionCtx) => {
+  const relations = selectionCtx?.relationMap[selectionCtx.tableName];
+  if (!relations || !selectionCtx) {
+    return [];
+  }
+  const tableColumns = getColumns(table);
+  const needed = [];
+  for (const fieldData of Object.values(tree)) {
+    if (tableColumns[fieldData.name] || !fieldData.name.endsWith(AGGREGATE_FIELD_SUFFIX)) {
+      continue;
+    }
+    const relEntry = relations[fieldData.name.slice(0, -AGGREGATE_FIELD_SUFFIX.length)];
+    const targetTable = relEntry ? selectionCtx.tables[relEntry.targetTableName] : void 0;
+    if (!relEntry || !targetTable) {
+      continue;
+    }
+    const joinCols = extractRelationJoinColumns(relEntry, table, targetTable);
+    if (joinCols) {
+      needed.push(joinCols.localColPropName);
+    }
+  }
+  return needed;
+};
+var extractSelectedColumnsFromTree = (tree, table, selectionCtx) => {
+  const tableColumns = getColumns(table);
   const treeEntries = Object.entries(tree);
   const selectedColumns = [];
   for (const [_fieldName, fieldData] of treeEntries) {
@@ -462,6 +689,9 @@ var extractSelectedColumnsFromTree = (tree, table) => {
     }
     selectedColumns.push([fieldData.name, true]);
   }
+  for (const columnName of relationAggregateJoinColumns(tree, table, selectionCtx)) {
+    selectedColumns.push([columnName, true]);
+  }
   if (!selectedColumns.length) {
     const columnKeys = Object.entries(tableColumns);
     const columnName = columnKeys.find((e) => rqbCrashTypes.find((haram) => e[1].columnType !== haram))?.[0] ?? columnKeys[0][0];
@@ -469,8 +699,8 @@ var extractSelectedColumnsFromTree = (tree, table) => {
   }
   return Object.fromEntries(selectedColumns);
 };
-var extractSelectedColumnsFromTreeSQLFormat = (tree, table) => {
-  const tableColumns = getColumns2(table);
+var extractSelectedColumnsFromTreeSQLFormat = (tree, table, selectionCtx) => {
+  const tableColumns = getColumns(table);
   const treeEntries = Object.entries(tree);
   const selectedColumns = [];
   for (const [_fieldName, fieldData] of treeEntries) {
@@ -479,6 +709,9 @@ var extractSelectedColumnsFromTreeSQLFormat = (tree, table) => {
     }
     selectedColumns.push([fieldData.name, tableColumns[fieldData.name]]);
   }
+  for (const columnName of relationAggregateJoinColumns(tree, table, selectionCtx)) {
+    selectedColumns.push([columnName, tableColumns[columnName]]);
+  }
   if (!selectedColumns.length) {
     const columnKeys = Object.entries(tableColumns);
     const columnName = columnKeys.find((e) => rqbCrashTypes.find((haram) => e[1].columnType !== haram))?.[0] ?? columnKeys[0][0];
@@ -585,7 +818,7 @@ var generateTableOrderCached = (table) => {
   }
   let remapped = {};
   try {
-    const columns = getColumns2(table);
+    const columns = getColumns(table);
     const columnEntries = Object.entries(columns);
     remapped = Object.fromEntries(
       columnEntries.map(([columnName, _columnDescription]) => [columnName, { type: innerOrder }])
@@ -600,7 +833,7 @@ var generateTableFilterValuesCached = (table, tableName, cacheCtx) => {
   if (filterMap.has(table)) {
     return filterMap.get(table);
   }
-  const columns = getColumns2(table);
+  const columns = getColumns(table);
   const columnEntries = Object.entries(columns);
   const remapped = Object.fromEntries(
     columnEntries.map(([columnName, columnDescription]) => [
@@ -618,7 +851,7 @@ var generateTableSelectTypeFieldsCached = (table, tableName) => {
   if (fieldMap.has(table)) {
     return fieldMap.get(table);
   }
-  const columns = getColumns2(table);
+  const columns = getColumns(table);
   const columnEntries = Object.entries(columns);
   const remapped = Object.fromEntries(
     columnEntries.map(([columnName, columnDescription]) => [
@@ -629,51 +862,125 @@ var generateTableSelectTypeFieldsCached = (table, tableName) => {
   fieldMap.set(table, remapped);
   return remapped;
 };
-var orderTypeMap = /* @__PURE__ */ new WeakMap();
-var generateTableOrderTypeCached = (table, tableName, singularTypes) => {
-  if (orderTypeMap.has(table)) {
-    return orderTypeMap.get(table);
+var generateTableOrderTypeCached = (table, tableName, typeNameMapper, cacheCtx) => {
+  if (cacheCtx.orderTypeCache.has(table)) {
+    return cacheCtx.orderTypeCache.get(table);
   }
   const orderColumns = generateTableOrderCached(table);
   const order = new GraphQLInputObjectType2({
-    name: `${toTypeName(tableName, singularTypes)}OrderBy`,
+    name: `${resolveTypeName(tableName, typeNameMapper)}OrderBy`,
     fields: orderColumns
   });
-  orderTypeMap.set(table, order);
+  cacheCtx.orderTypeCache.set(table, order);
   return order;
 };
-var filterTypeMap = /* @__PURE__ */ new WeakMap();
-var generateTableFilterTypeCached = (table, tableName, cacheCtx, singularTypes) => {
-  if (filterTypeMap.has(table)) {
-    return filterTypeMap.get(table);
+var isFilterableRelation = (relation) => !relation.through;
+var generateListRelationFilterCached = (targetTable, targetTableName, cacheCtx, typeNameMapper, relationMap, tables) => {
+  const cached = cacheCtx.listRelationFilterCache.get(targetTableName);
+  if (cached) {
+    return cached;
   }
-  const filterColumns = generateTableFilterValuesCached(table, tableName, cacheCtx);
-  const filters = new GraphQLInputObjectType2({
-    name: `${toTypeName(tableName, singularTypes)}Filters`,
-    fields: {
+  const listFilter = new GraphQLInputObjectType2({
+    name: `${resolveTypeName(targetTableName, typeNameMapper)}ListRelationFilter`,
+    fields: () => {
+      const targetFilters = generateTableFilterTypeCached(
+        targetTable,
+        targetTableName,
+        cacheCtx,
+        typeNameMapper,
+        relationMap,
+        tables
+      );
+      return {
+        some: { type: targetFilters, description: "At least one related row matches" },
+        none: { type: targetFilters, description: "No related row matches" },
+        every: { type: targetFilters, description: "Every related row matches" }
+      };
+    }
+  });
+  cacheCtx.listRelationFilterCache.set(targetTableName, listFilter);
+  return listFilter;
+};
+var generateRelationFilterFields = (tableName, cacheCtx, typeNameMapper, columnFields, relationMap, tables) => {
+  const relations = relationMap?.[tableName];
+  if (!relations || !tables) {
+    return {};
+  }
+  const fields = {};
+  for (const [relationName, relEntry] of Object.entries(relations)) {
+    if (relationName in columnFields) {
+      continue;
+    }
+    const targetTable = tables[relEntry.targetTableName];
+    const relation = relEntry.relation ?? relEntry;
+    if (!targetTable || !isFilterableRelation(relation)) {
+      continue;
+    }
+    fields[relationName] = is3(relation, One2) ? {
+      type: generateTableFilterTypeCached(
+        targetTable,
+        relEntry.targetTableName,
+        cacheCtx,
+        typeNameMapper,
+        relationMap,
+        tables
+      ),
+      description: `Matches rows whose ${relationName} matches these filters`
+    } : {
+      type: generateListRelationFilterCached(
+        targetTable,
+        relEntry.targetTableName,
+        cacheCtx,
+        typeNameMapper,
+        relationMap,
+        tables
+      )
+    };
+  }
+  return fields;
+};
+var generateTableFilterTypeCached = (table, tableName, cacheCtx, typeNameMapper, relationMap, tables) => {
+  if (cacheCtx.filterTypeCache.has(table)) {
+    return cacheCtx.filterTypeCache.get(table);
+  }
+  const buildFields = () => {
+    const filterColumns = generateTableFilterValuesCached(table, tableName, cacheCtx);
+    return {
       ...filterColumns,
+      ...generateRelationFilterFields(tableName, cacheCtx, typeNameMapper, filterColumns, relationMap, tables)
+    };
+  };
+  const orFilters = new GraphQLInputObjectType2({
+    name: `${resolveTypeName(tableName, typeNameMapper)}FiltersOr`,
+    fields: buildFields
+  });
+  const filters = new GraphQLInputObjectType2({
+    name: `${resolveTypeName(tableName, typeNameMapper)}Filters`,
+    fields: () => ({
+      ...buildFields(),
       OR: {
-        type: new GraphQLList2(
-          new GraphQLNonNull2(
-            new GraphQLInputObjectType2({
-              name: `${toTypeName(tableName, singularTypes)}FiltersOr`,
-              fields: filterColumns
-            })
-          )
-        )
+        type: new GraphQLList2(new GraphQLNonNull2(orFilters))
       }
-    }
+    })
   });
-  filterTypeMap.set(table, filters);
+  cacheCtx.filterTypeCache.set(table, filters);
   return filters;
 };
-var generateSelectFields = (tables, tableName, relationMap, fromTableName, fromRelationName, withOrder, _relationsDepthLimit, cacheCtx, singularTypes, usedTables = /* @__PURE__ */ new Set()) => {
+var generateSelectFields = (tables, tableName, relationMap, fromTableName, fromRelationName, withOrder, relationsDepthLimit, cacheCtx, typeNameMapper, usedTables = /* @__PURE__ */ new Set(), resolverFactory, currentDepth = 0, relationAggregateFactory) => {
   const table = tables[tableName];
-  const order = withOrder ? generateTableOrderTypeCached(table, tableName, singularTypes) : void 0;
-  const filters = generateTableFilterTypeCached(table, tableName, cacheCtx, singularTypes);
+  const order = withOrder ? generateTableOrderTypeCached(table, tableName, typeNameMapper, cacheCtx) : void 0;
+  const filters = generateTableFilterTypeCached(table, tableName, cacheCtx, typeNameMapper, relationMap, tables);
   const tableFields = generateTableSelectTypeFieldsCached(table, tableName);
   const relationsForTable = relationMap[tableName];
   const relationEntries = relationsForTable ? Object.entries(relationsForTable) : [];
+  if (relationsDepthLimit !== void 0 && currentDepth >= relationsDepthLimit) {
+    return {
+      order,
+      filters,
+      tableFields,
+      relationFields: {}
+    };
+  }
   if (usedTables.has(tableName)) {
     return {
       order,
@@ -697,7 +1004,7 @@ var generateSelectFields = (tables, tableName, relationMap, fromTableName, fromR
     cacheCtx.relationFieldContainers.set(tableName, container);
   }
   if (isRootCall && !cacheCtx.objectTypeCache.has(tableName)) {
-    const typeName = toTypeName(tableName, singularTypes);
+    const typeName = resolveTypeName(tableName, typeNameMapper);
     const shell = new GraphQLObjectType2({
       name: typeName,
       fields: () => ({ ...tableFields, ...container.fields })
@@ -711,7 +1018,7 @@ var generateSelectFields = (tables, tableName, relationMap, fromTableName, fromR
     for (const [relationName, relEntry] of relationEntries) {
       const { targetTableName } = relEntry;
       const relation = relEntry.relation ?? relEntry;
-      const isOne = is2(relation, One);
+      const isOne = is3(relation, One2);
       const relSelectData = generateSelectFields(
         tables,
         targetTableName,
@@ -721,10 +1028,13 @@ var generateSelectFields = (tables, tableName, relationMap, fromTableName, fromR
         relationName,
         // fromRelationName for the relation type
         !isOne,
-        void 0,
+        relationsDepthLimit,
         cacheCtx,
-        singularTypes,
-        nextUsedTables
+        typeNameMapper,
+        nextUsedTables,
+        resolverFactory,
+        currentDepth + 1,
+        relationAggregateFactory
       );
       let relType = cacheCtx.objectTypeCache.get(targetTableName);
       if (!relType) {
@@ -737,11 +1047,12 @@ var generateSelectFields = (tables, tableName, relationMap, fromTableName, fromR
         }
         const capturedTargetContainer = targetContainer;
         relType = new GraphQLObjectType2({
-          name: toTypeName(targetTableName, singularTypes),
+          name: resolveTypeName(targetTableName, typeNameMapper),
           fields: () => ({ ...targetTableFields, ...capturedTargetContainer.fields })
         });
         cacheCtx.objectTypeCache.set(targetTableName, relType);
       }
+      const resolve = resolverFactory?.({ tableName, relationName, relEntry, isOne });
       if (isOne) {
         rawRelationFields.push([
           relationName,
@@ -749,7 +1060,8 @@ var generateSelectFields = (tables, tableName, relationMap, fromTableName, fromR
             type: relType,
             args: {
               where: { type: relSelectData.filters }
-            }
+            },
+            resolve
           }
         ]);
         continue;
@@ -763,9 +1075,30 @@ var generateSelectFields = (tables, tableName, relationMap, fromTableName, fromR
             orderBy: { type: relSelectData.order },
             offset: { type: GraphQLInt2 },
             limit: { type: GraphQLInt2 }
-          }
+          },
+          resolve
         }
       ]);
+      const aggregateFieldName = `${relationName}Aggregate`;
+      if (!tableFields[aggregateFieldName] && !relationsForTable?.[aggregateFieldName]) {
+        const relationAggregate = relationAggregateFactory?.({
+          tableName,
+          relationName,
+          relEntry
+        });
+        if (relationAggregate) {
+          rawRelationFields.push([
+            aggregateFieldName,
+            {
+              type: new GraphQLNonNull2(relationAggregate.type),
+              args: {
+                where: { type: relSelectData.filters }
+              },
+              resolve: relationAggregate.resolve
+            }
+          ]);
+        }
+      }
     }
     const builtRelationFields = Object.fromEntries(rawRelationFields);
     if (isRootCall) {
@@ -789,7 +1122,7 @@ var generateSelectFields = (tables, tableName, relationMap, fromTableName, fromR
     relationFields: {}
   };
 };
-var generateTableTypes = (tableName, tables, relationMap, withReturning, relationsDepthLimit, cacheCtx, singularTypes = false, insertPrefix = "insertInto", updatePrefix = "update") => {
+var generateTableTypes = (tableName, tables, relationMap, withReturning, relationsDepthLimit, cacheCtx, typeNameMapper = void 0, insertPrefix = "create", updatePrefix = "update", resolverFactory, relationAggregateFactory) => {
   const { tableFields, relationFields, filters, order } = generateSelectFields(
     tables,
     tableName,
@@ -801,12 +1134,15 @@ var generateTableTypes = (tableName, tables, relationMap, withReturning, relatio
     true,
     relationsDepthLimit,
     cacheCtx,
-    singularTypes
+    typeNameMapper,
+    /* @__PURE__ */ new Set(),
+    resolverFactory,
+    0,
+    relationAggregateFactory
   );
   const table = tables[tableName];
-  const columns = getColumns2(table);
+  const columns = getColumns(table);
   const columnEntries = Object.entries(columns);
-  const _insertNested = drizzleRelationToGraphQLInsertType(tables, relationMap[tableName] ?? {});
   const insertFields = Object.fromEntries(
     columnEntries.map(([columnName, columnDescription]) => [
       columnName,
@@ -820,15 +1156,15 @@ var generateTableTypes = (tableName, tables, relationMap, withReturning, relatio
     ])
   );
   const insertInput = new GraphQLInputObjectType2({
-    name: `${capitalize(insertPrefix)}${toTypeName(tableName, singularTypes)}Input`,
+    name: `${capitalize(insertPrefix)}${resolveTypeName(tableName, typeNameMapper)}Input`,
     fields: insertFields
   });
   const updateInput = new GraphQLInputObjectType2({
-    name: `${capitalize(updatePrefix)}${toTypeName(tableName, singularTypes)}Input`,
+    name: `${capitalize(updatePrefix)}${resolveTypeName(tableName, typeNameMapper)}Input`,
     fields: updateFields
   });
   const selectSingleOutput = cacheCtx.objectTypeCache.get(tableName) ?? new GraphQLObjectType2({
-    name: toTypeName(tableName, singularTypes),
+    name: resolveTypeName(tableName, typeNameMapper),
     fields: { ...tableFields, ...relationFields }
   });
   const selectArrOutput = new GraphQLNonNull2(new GraphQLList2(new GraphQLNonNull2(selectSingleOutput)));
@@ -857,19 +1193,10 @@ var generateTableTypes = (tableName, tables, relationMap, withReturning, relatio
     outputs
   };
 };
-var extractOrderBy = (table, orderArgs) => {
-  const res = [];
-  for (const [column, config] of Object.entries(orderArgs).sort(
-    (a, b) => (b[1]?.priority ?? 0) - (a[1]?.priority ?? 0)
-  )) {
-    if (!config) {
-      continue;
-    }
-    const { direction } = config;
-    res.push(direction === "asc" ? asc(getColumns2(table)[column]) : desc(getColumns2(table)[column]));
-  }
-  return res;
-};
+var orderByEntries = (orderArgs) => Object.entries(orderArgs).sort((a, b) => (b[1]?.priority ?? 0) - (a[1]?.priority ?? 0)).filter(([, config]) => config).map(([column, config]) => [column, config.direction]);
+var extractOrderBy = (table, orderArgs) => orderByEntries(orderArgs).map(
+  ([column, direction]) => direction === "asc" ? asc(getColumns(table)[column]) : desc(getColumns(table)[column])
+);
 var extractFiltersColumn = (column, columnName, operators) => {
   if (!operators.OR?.length) {
     delete operators.OR;
@@ -877,7 +1204,7 @@ var extractFiltersColumn = (column, columnName, operators) => {
   const entries = Object.entries(operators);
   if (operators.OR) {
     if (entries.length > 1) {
-      throw new GraphQLError2(`WHERE ${columnName}: Cannot specify both fields and 'OR' in column operators!`);
+      throw new GraphQLError3(`WHERE ${columnName}: Cannot specify both fields and 'OR' in column operators!`);
     }
     const variants2 = [];
     for (const variant of operators.OR) {
@@ -888,60 +1215,93 @@ var extractFiltersColumn = (column, columnName, operators) => {
     }
     return variants2.length ? variants2.length > 1 ? or(...variants2) : variants2[0] : void 0;
   }
+  const singleValueOps = { eq, ne, gt, gte, lt, lte };
+  const stringValueOps = { like, notLike, ilike, notIlike };
+  const arrayValueOps = { inArray, notInArray };
+  const nullableOps = { isNull, isNotNull };
   const variants = [];
   for (const [operatorName, operatorValue] of entries) {
     if (operatorValue === null || operatorValue === false) {
       continue;
     }
-    let operator;
-    switch (operatorName) {
-      case "eq":
-        operator = operator ?? eq;
-      case "ne":
-        operator = operator ?? ne;
-      case "gt":
-        operator = operator ?? gt;
-      case "gte":
-        operator = operator ?? gte;
-      case "lt":
-        operator = operator ?? lt;
-      case "lte": {
-        operator = operator ?? lte;
-        const singleValue = remapFromGraphQLCore(operatorValue, column, columnName);
-        variants.push(operator(column, singleValue));
-        break;
-      }
-      case "like":
-        operator = operator ?? like;
-      case "notLike":
-        operator = operator ?? notLike;
-      case "ilike":
-        operator = operator ?? ilike;
-      case "notIlike":
-        operator = operator ?? notIlike;
-        variants.push(operator(column, operatorValue));
-        break;
-      case "inArray":
-        operator = operator ?? inArray;
-      case "notInArray": {
-        operator = operator ?? notInArray;
-        if (!operatorValue.length) {
-          throw new GraphQLError2(`WHERE ${columnName}: Unable to use operator ${operatorName} with an empty array!`);
-        }
-        const arrayValue = operatorValue.map((val) => remapFromGraphQLCore(val, column, columnName));
-        variants.push(operator(column, arrayValue));
-        break;
+    if (operatorName in singleValueOps) {
+      const singleValue = remapFromGraphQLCore(operatorValue, column, columnName);
+      variants.push(singleValueOps[operatorName](column, singleValue));
+    } else if (operatorName in stringValueOps) {
+      variants.push(stringValueOps[operatorName](column, operatorValue));
+    } else if (operatorName in arrayValueOps) {
+      if (!operatorValue.length) {
+        throw new GraphQLError3(`WHERE ${columnName}: Unable to use operator ${operatorName} with an empty array!`);
       }
-      case "isNull":
-        operator = operator ?? isNull;
-      case "isNotNull":
-        operator = operator ?? isNotNull;
-        variants.push(operator(column));
+      const arrayValue = operatorValue.map((val) => remapFromGraphQLCore(val, column, columnName));
+      variants.push(arrayValueOps[operatorName](column, arrayValue));
+    } else if (operatorName in nullableOps) {
+      variants.push(nullableOps[operatorName](column));
+    }
+  }
+  return variants.length ? variants.length > 1 ? and(...variants) : variants[0] : void 0;
+};
+var relationFilterCtx = (base, tableKey) => base ? { ...base, tableKey } : void 0;
+var buildRelationJoinCondition = (parentTable, relation, aliasedTarget, relationName) => {
+  const sourceColumns = relation.sourceColumns;
+  const targetColumns = relation.targetColumns;
+  if (!sourceColumns?.length || sourceColumns.length !== targetColumns?.length) {
+    throw new GraphQLError3(`WHERE ${relationName}: Relation cannot be used as a filter`);
+  }
+  const parentColumns = Object.values(getColumns(parentTable));
+  const targetColumnsByName = Object.values(getColumns(aliasedTarget));
+  const conditions = [];
+  for (let i = 0; i < sourceColumns.length; i++) {
+    const localColumn = parentColumns.find((c) => c.name === sourceColumns[i].name);
+    const foreignColumn = targetColumnsByName.find((c) => c.name === targetColumns[i].name);
+    if (!localColumn || !foreignColumn) {
+      throw new GraphQLError3(`WHERE ${relationName}: Relation cannot be used as a filter`);
+    }
+    conditions.push(eq(localColumn, foreignColumn));
+  }
+  return conditions.length > 1 ? and(...conditions) : conditions[0];
+};
+var buildRelationExists = (parentTable, relationName, relEntry, innerFilters, mode, ctx) => {
+  const { targetTableName } = relEntry;
+  const targetTable = ctx.tables[targetTableName];
+  const relation = relEntry.relation ?? relEntry;
+  if (!targetTable || !isFilterableRelation(relation)) {
+    throw new GraphQLError3(`WHERE ${relationName}: Relation cannot be used as a filter`);
+  }
+  ctx.aliases ??= { n: 0 };
+  const aliases = ctx.aliases;
+  const aliasedTarget = aliasedTable(targetTable, `dgql_rel_${aliases.n++}`);
+  const joinCondition = buildRelationJoinCondition(parentTable, relation, aliasedTarget, relationName);
+  const relationWhere = relation.where ? relationsFilterToSQL(relation.isReversed ? parentTable : aliasedTarget, relation.where) : void 0;
+  const inner = innerFilters ? extractFilters(aliasedTarget, targetTableName, innerFilters, { ...ctx, tableKey: targetTableName, aliases }) : void 0;
+  if (mode === "every") {
+    if (!inner) {
+      return void 0;
+    }
+    return sql`not exists (select 1 from ${getTableAsAliasSQL(aliasedTarget)} where ${and(joinCondition, relationWhere, not(inner))})`;
+  }
+  const condition = and(joinCondition, relationWhere, inner);
+  return mode === "none" ? sql`not exists (select 1 from ${getTableAsAliasSQL(aliasedTarget)} where ${condition})` : sql`exists (select 1 from ${getTableAsAliasSQL(aliasedTarget)} where ${condition})`;
+};
+var extractRelationFilter = (parentTable, relationName, relEntry, value, ctx) => {
+  const relation = relEntry.relation ?? relEntry;
+  if (is3(relation, One2)) {
+    return buildRelationExists(parentTable, relationName, relEntry, value, "some", ctx);
+  }
+  const variants = [];
+  for (const mode of ["some", "none", "every"]) {
+    const inner = value[mode];
+    if (inner === void 0 || inner === null) {
+      continue;
+    }
+    const extracted = buildRelationExists(parentTable, relationName, relEntry, inner, mode, ctx);
+    if (extracted) {
+      variants.push(extracted);
     }
   }
   return variants.length ? variants.length > 1 ? and(...variants) : variants[0] : void 0;
 };
-var extractFilters = (table, tableName, filters) => {
+var extractFilters = (table, tableName, filters, relationCtx) => {
   if (!filters.OR?.length) {
     delete filters.OR;
   }
@@ -951,28 +1311,33 @@ var extractFilters = (table, tableName, filters) => {
   }
   if (filters.OR) {
     if (entries.length > 1) {
-      throw new GraphQLError2(`WHERE ${tableName}: Cannot specify both fields and 'OR' in table filters!`);
+      throw new GraphQLError3(`WHERE ${tableName}: Cannot specify both fields and 'OR' in table filters!`);
     }
     const variants2 = [];
     for (const variant of filters.OR) {
-      const extracted = extractFilters(table, tableName, variant);
+      const extracted = extractFilters(table, tableName, variant, relationCtx);
       if (extracted) {
         variants2.push(extracted);
       }
     }
     return variants2.length ? variants2.length > 1 ? or(...variants2) : variants2[0] : void 0;
   }
+  const columns = getColumns(table);
+  const relations = relationCtx?.relationMap[relationCtx.tableKey];
   const variants = [];
-  for (const [columnName, operators] of entries) {
-    if (operators === null) {
+  for (const [fieldName, operators] of entries) {
+    if (operators === null || operators === void 0) {
       continue;
     }
-    const column = getColumns2(table)[columnName];
-    variants.push(extractFiltersColumn(column, columnName, operators));
+    const column = columns[fieldName];
+    const extracted = column ? extractFiltersColumn(column, fieldName, operators) : relations?.[fieldName] && relationCtx ? extractRelationFilter(table, fieldName, relations[fieldName], operators, relationCtx) : void 0;
+    if (extracted) {
+      variants.push(extracted);
+    }
   }
   return variants.length ? variants.length > 1 ? and(...variants) : variants[0] : void 0;
 };
-var extractRelationsParamsInner = (relationMap, tables, tableName, typeName, originField, singularTypes = false, _isInitial = false) => {
+var extractRelationsParamsInner = (relationMap, tables, tableName, typeName, originField, typeNameMapper, _isInitial = false, filterCtx) => {
   const relationsForTable = relationMap[tableName];
   if (!relationsForTable) {
     return void 0;
@@ -982,8 +1347,9 @@ var extractRelationsParamsInner = (relationMap, tables, tableName, typeName, ori
     return void 0;
   }
   const args = {};
-  for (const [relName, { targetTableName }] of Object.entries(relationsForTable)) {
-    const relTypeName = toTypeName(targetTableName, singularTypes);
+  for (const [relName, relEntry] of Object.entries(relationsForTable)) {
+    const { targetTableName, targetPkNames } = relEntry;
+    const relTypeName = resolveTypeName(targetTableName, typeNameMapper);
     const field = baseField[relName] ?? Object.values(baseField).find((f) => f.name === relName);
     if (!field) {
       continue;
@@ -993,7 +1359,11 @@ var extractRelationsParamsInner = (relationMap, tables, tableName, typeName, ori
     if (!relFieldSelection) {
       continue;
     }
-    const columns = extractSelectedColumnsFromTree(relFieldSelection, tables[targetTableName]);
+    const columns = extractSelectedColumnsFromTree(relFieldSelection, tables[targetTableName], {
+      tableName: targetTableName,
+      relationMap,
+      tables
+    });
     const thisRecord = {};
     thisRecord.columns = columns;
     const relationField = Object.values(baseField).find((e) => e.name === relName);
@@ -1001,298 +1371,1056 @@ var extractRelationsParamsInner = (relationMap, tables, tableName, typeName, ori
     const offset = relationArgs?.offset ?? void 0;
     const limit = relationArgs?.limit ?? void 0;
     const relWhere = relationArgs?.where;
-    thisRecord.where = relWhere ? { RAW: (aliasedTable) => extractFilters(aliasedTable, relName, relWhere) } : void 0;
-    thisRecord.orderBy = relationArgs?.orderBy ? (aliasedTable) => extractOrderBy(aliasedTable, relationArgs.orderBy) : void 0;
+    thisRecord.where = relWhere ? {
+      RAW: (aliasedTable2) => extractFilters(aliasedTable2, relName, relWhere, relationFilterCtx(filterCtx, targetTableName))
+    } : void 0;
+    const hasPagination = offset != null || limit != null;
+    const pkNames = targetPkNames ?? [];
+    thisRecord.orderBy = relationArgs?.orderBy ? (aliasedTable2) => extractOrderBy(aliasedTable2, relationArgs.orderBy) : hasPagination && pkNames.length ? (aliasedTable2) => primaryKeyOrderExprs(aliasedTable2, pkNames) : void 0;
     thisRecord.offset = offset;
     thisRecord.limit = limit;
-    const relWith = relationField ? extractRelationsParamsInner(relationMap, tables, targetTableName, relTypeName, relationField, singularTypes) : void 0;
+    const relWith = relationField ? extractRelationsParamsInner(
+      relationMap,
+      tables,
+      targetTableName,
+      relTypeName,
+      relationField,
+      typeNameMapper,
+      false,
+      filterCtx
+    ) : void 0;
     thisRecord.with = relWith;
     args[relName] = thisRecord;
   }
   return args;
 };
-var extractRelationsParams = (relationMap, tables, tableName, info, typeName, singularTypes = false) => {
+var extractRelationsParams = (relationMap, tables, tableName, info, typeName, typeNameMapper, filterCtx) => {
   if (!info) {
     return void 0;
   }
-  return extractRelationsParamsInner(relationMap, tables, tableName, typeName, info, singularTypes, true);
+  return extractRelationsParamsInner(relationMap, tables, tableName, typeName, info, typeNameMapper, true, filterCtx);
 };
-
-// src/util/builders/mysql.ts
-var toTypeName2 = (name, singular) => singular ? capitalize(singularize(name)) : capitalize(name);
-var generateSelectArray = (db, tableName, tables, relationMap, orderArgs, filterArgs, listSuffix, singularTypes) => {
-  const queryName = `${uncapitalize(tableName)}${listSuffix}`;
-  const queryBase = db.query[tableName];
-  if (!queryBase) {
-    throw new Error(
-      `Drizzle-GraphQL Error: Table ${tableName} not found in drizzle instance. Did you forget to pass schema to drizzle constructor?`
+var pruneNonEagerRelations = (relationMap, shouldEagerLoad) => {
+  const out = {};
+  for (const [tableName, rels] of Object.entries(relationMap)) {
+    out[tableName] = Object.fromEntries(
+      Object.entries(rels).filter(([relationName]) => shouldEagerLoad(tableName, relationName))
     );
   }
-  const queryArgs = {
-    offset: {
-      type: GraphQLInt3
-    },
-    limit: {
-      type: GraphQLInt3
-    },
-    orderBy: {
-      type: orderArgs
-    },
-    where: {
-      type: filterArgs
-    }
-  };
-  const typeName = toTypeName2(tableName, singularTypes);
-  const table = tables[tableName];
-  return {
-    name: queryName,
-    resolver: async (_source, args, _context, info) => {
-      try {
-        const { offset, limit, orderBy, where } = args;
-        const parsedInfo = parseResolveInfo(info, {
-          deep: true
-        });
-        const query = queryBase.findMany({
-          columns: extractSelectedColumnsFromTree(parsedInfo.fieldsByTypeName[typeName], table),
-          offset,
-          limit,
-          // drizzle-orm v1 RQB calls orderBy with the aliased table proxy —
-          // use it directly so column refs match the CTE alias.
-          orderBy: orderBy ? (aliasedTable) => extractOrderBy(aliasedTable, orderBy) : void 0,
-          where: where ? { RAW: (aliased) => extractFilters(aliased, tableName, where) } : void 0,
-          with: relationMap[tableName] ? extractRelationsParams(relationMap, tables, tableName, parsedInfo, typeName, singularTypes) : void 0
-        });
-        const result = await query;
-        return remapToGraphQLArrayOutput(result, tableName, table, relationMap);
-      } catch (e) {
-        if (e instanceof Error) {
-          throw new GraphQLError3(e.message);
-        }
-        throw e;
-      }
-    },
-    args: queryArgs
-  };
+  return out;
 };
-var generateSelectSingle = (db, tableName, tables, relationMap, orderArgs, filterArgs, singleSuffix, singularTypes) => {
-  const queryName = `${uncapitalize(tableName)}${singleSuffix}`;
-  const queryBase = db.query[tableName];
-  if (!queryBase) {
-    throw new Error(
-      `Drizzle-GraphQL Error: Table ${tableName} not found in drizzle instance. Did you forget to pass schema to drizzle constructor?`
-    );
+var getPrimaryKeyPropNames = (table, compositePkColumnNames) => {
+  const cols = getColumns(table);
+  const entries = Object.entries(cols);
+  const inlinePks = entries.filter(([, c]) => c.primary).map(([k]) => k);
+  if (inlinePks.length) {
+    return inlinePks;
   }
-  const queryArgs = {
-    offset: {
-      type: GraphQLInt3
-    },
-    orderBy: {
-      type: orderArgs
-    },
-    where: {
-      type: filterArgs
+  if (compositePkColumnNames?.length) {
+    const wanted = new Set(compositePkColumnNames);
+    const fromComposite = entries.filter(([, c]) => wanted.has(c.name)).map(([k]) => k);
+    if (fromComposite.length) {
+      return fromComposite;
     }
-  };
-  const typeName = toTypeName2(tableName, singularTypes);
-  const table = tables[tableName];
-  return {
-    name: queryName,
-    resolver: async (_source, args, _context, info) => {
-      try {
-        const { offset, orderBy, where } = args;
-        const parsedInfo = parseResolveInfo(info, {
-          deep: true
-        });
-        const query = queryBase.findFirst({
-          columns: extractSelectedColumnsFromTree(parsedInfo.fieldsByTypeName[typeName], table),
-          offset,
-          // drizzle-orm v1 RQB calls orderBy with the aliased table proxy —
-          // use it directly so column refs match the CTE alias.
-          orderBy: orderBy ? (aliasedTable) => extractOrderBy(aliasedTable, orderBy) : void 0,
-          where: where ? { RAW: (aliased) => extractFilters(aliased, tableName, where) } : void 0,
-          with: relationMap[tableName] ? extractRelationsParams(relationMap, tables, tableName, parsedInfo, typeName, singularTypes) : void 0
-        });
-        const result = await query;
-        if (!result) {
-          return void 0;
-        }
-        return remapToGraphQLSingleOutput(result, tableName, table, relationMap);
-      } catch (e) {
-        if (e instanceof Error) {
-          throw new GraphQLError3(e.message);
-        }
-        throw e;
-      }
-    },
-    args: queryArgs
-  };
+  }
+  return [];
 };
-var generateInsertArray = (db, tableName, table, baseType) => {
-  const queryName = `insertInto${capitalize(tableName)}`;
-  const queryArgs = {
-    values: {
-      type: new GraphQLNonNull3(new GraphQLList3(new GraphQLNonNull3(baseType)))
+var withPrimaryKeyColumns = (columns, table, pkNames) => {
+  const allCols = getColumns(table);
+  for (const pk of pkNames) {
+    if (!(pk in columns) && allCols[pk]) {
+      columns[pk] = allCols[pk];
     }
-  };
-  return {
-    name: queryName,
-    resolver: async (_source, args, _context, _info) => {
-      try {
-        const input = remapFromGraphQLArrayInput(args.values, table);
-        if (!input.length) {
-          throw new GraphQLError3("No values were provided!");
-        }
-        await db.insert(table).values(input);
-        return { isSuccess: true };
-      } catch (e) {
-        if (e instanceof Error) {
-          throw new GraphQLError3(e.message);
-        }
-        throw e;
-      }
-    },
-    args: queryArgs
-  };
+  }
+  return columns;
 };
-var generateInsertSingle = (db, tableName, table, baseType) => {
-  const queryName = `insertInto${capitalize(tableName)}Single`;
-  const queryArgs = {
-    values: {
-      type: new GraphQLNonNull3(baseType)
+var getPrimaryKeyPropNamesFromConfig = (table, getTableConfig4) => {
+  const compositePkColumnNames = getTableConfig4(table).primaryKeys.flatMap((pk) => pk.columns.map((c) => c.name));
+  return getPrimaryKeyPropNames(table, compositePkColumnNames);
+};
+var primaryKeyOrderExprs = (table, pkNames) => {
+  const cols = getColumns(table);
+  return pkNames.map((n) => cols[n]).filter(Boolean).map((col) => asc(col));
+};
+var getUniqueColumnSets = (table, getTableConfig4) => {
+  const cols = getColumns(table);
+  const propNameByColumnName = new Map(Object.entries(cols).map(([propName, col]) => [col.name, propName]));
+  const toPropNames = (columnNames) => {
+    const propNames = [];
+    for (const columnName of columnNames) {
+      const propName = columnName === void 0 ? void 0 : propNameByColumnName.get(columnName);
+      if (!propName) {
+        return void 0;
+      }
+      propNames.push(propName);
     }
+    return propNames.length ? propNames : void 0;
   };
+  const config = getTableConfig4(table);
+  const candidates = [
+    // Inline `.primaryKey()` columns, then table-level `primaryKey({ columns })`.
+    Object.entries(cols).filter(([, col]) => col.primary).map(([propName]) => propName),
+    ...config.primaryKeys.map((pk) => toPropNames(pk.columns.map((c) => c.name))),
+    ...(config.uniqueConstraints ?? []).map((uc) => toPropNames(uc.columns.map((c) => c.name))),
+    ...(config.indexes ?? []).filter((index) => index.config.unique).map((index) => toPropNames(index.config.columns.map((c) => c?.name))),
+    ...Object.entries(cols).filter(([, col]) => col.isUnique).map(([propName]) => [propName])
+  ];
+  const seen = /* @__PURE__ */ new Set();
+  const sets = [];
+  for (const set of candidates) {
+    if (!set?.length) {
+      continue;
+    }
+    const key = [...set].sort().join(",");
+    if (seen.has(key)) {
+      continue;
+    }
+    seen.add(key);
+    sets.push(set);
+  }
+  return sets;
+};
+var DISTINCT_RN = "__drizzle_graphql_distinct_rn";
+var columnEnumCache = /* @__PURE__ */ new WeakMap();
+var generateColumnEnum = (table, enumName, description, predicate = () => true) => {
+  let tableCache = columnEnumCache.get(table);
+  const cached = tableCache?.get(enumName);
+  if (cached) {
+    return cached;
+  }
+  const columnNames = Object.entries(getColumns(table)).filter(([columnName, column]) => predicate(column, columnName)).map(([columnName]) => columnName);
+  if (!columnNames.length) {
+    return void 0;
+  }
+  const enumType = new GraphQLEnumType2({
+    name: enumName,
+    description,
+    values: Object.fromEntries(columnNames.map((columnName) => [columnName, { value: columnName }]))
+  });
+  if (!tableCache) {
+    tableCache = /* @__PURE__ */ new Map();
+    columnEnumCache.set(table, tableCache);
+  }
+  tableCache.set(enumName, enumType);
+  return enumType;
+};
+var generateDistinctEnum = (table, typeName) => generateColumnEnum(table, `${typeName}DistinctColumn`, `Columns of ${typeName} that a query can be made distinct on`);
+var conflictActionEnum = new GraphQLEnumType2({
+  name: "ConflictAction",
+  description: "What an upsert does when a row with the same unique key already exists",
+  values: {
+    UPDATE: { value: "UPDATE", description: "Overwrite the conflicting row with the supplied values" },
+    NOTHING: { value: "NOTHING", description: "Keep the existing row and insert nothing" }
+  }
+});
+var generateOnConflictInput = (params) => {
+  const { table, typeName, uniqueSets, tableFilters, withTarget } = params;
+  const updateEnum = generateColumnEnum(
+    table,
+    `${typeName}UpdateColumn`,
+    `Columns of ${typeName} that an upsert can overwrite`
+  );
+  if (!updateEnum) {
+    return void 0;
+  }
+  const fields = {
+    action: {
+      type: conflictActionEnum,
+      defaultValue: "UPDATE",
+      description: "Whether a conflicting row is overwritten or left alone. Defaults to UPDATE."
+    },
+    update: {
+      type: new GraphQLList2(new GraphQLNonNull2(updateEnum)),
+      description: "Columns to overwrite on conflict. Defaults to every column the request supplied, minus the conflict target. Columns the request did not supply cannot be listed here \u2014 there would be no value to write."
+    }
+  };
+  if (withTarget) {
+    const uniqueColumns = new Set(uniqueSets.flat());
+    const targetEnum = generateColumnEnum(
+      table,
+      `${typeName}ConflictTarget`,
+      `Columns of ${typeName} that carry a unique constraint, and so can be conflicted on`,
+      (_column, columnName) => uniqueColumns.has(columnName)
+    );
+    if (!targetEnum) {
+      return void 0;
+    }
+    fields["target"] = {
+      type: new GraphQLList2(new GraphQLNonNull2(targetEnum)),
+      description: "The unique column set a conflict is detected on. Must match one of the table\u2019s unique constraints exactly. Defaults to the primary key."
+    };
+    fields["where"] = {
+      type: tableFilters,
+      description: "Only overwrite conflicting rows that match this filter. Others are left alone."
+    };
+  }
+  return new GraphQLInputObjectType2({
+    name: `${typeName}OnConflict`,
+    description: `Conflict handling for an upsert of ${typeName}`,
+    fields
+  });
+};
+var resolveConflictPlan = (params) => {
+  const { table, values, onConflict, pkNames, uniqueSets, excludedRef, withTarget, buildWhere } = params;
+  const columns = getColumns(table);
+  let target;
+  if (withTarget) {
+    const targetNames2 = onConflict?.target?.length ? onConflict.target : [...pkNames];
+    if (!targetNames2.length) {
+      throw new GraphQLError3(
+        "Unable to upsert: no conflict target was given and this table has no primary key. Pass onConflict.target."
+      );
+    }
+    const requested = [...targetNames2].sort().join(",");
+    if (!uniqueSets.some((set2) => [...set2].sort().join(",") === requested)) {
+      throw new GraphQLError3(
+        `Unable to upsert: [${targetNames2.join(", ")}] is not a unique constraint on this table. Valid conflict targets: ${uniqueSets.map((set2) => `[${set2.join(", ")}]`).join(", ")}.`
+      );
+    }
+    target = targetNames2.map((name) => columns[name]);
+  }
+  if ((onConflict?.action ?? "UPDATE") === "NOTHING") {
+    return { action: "NOTHING", target, set: {}, setWhere: void 0 };
+  }
+  const supplied = new Set(values.flatMap((row) => Object.keys(row)));
+  const targetNames = new Set(withTarget ? onConflict?.target?.length ? onConflict.target : pkNames : []);
+  let updateNames;
+  if (onConflict?.update?.length) {
+    const unsupplied = onConflict.update.filter((name) => !supplied.has(name));
+    if (unsupplied.length) {
+      throw new GraphQLError3(
+        `Unable to upsert: onConflict.update lists ${unsupplied.join(", ")}, which the values do not supply.`
+      );
+    }
+    updateNames = onConflict.update;
+  } else {
+    updateNames = [...supplied].filter((name) => !targetNames.has(name));
+  }
+  if (!updateNames.length) {
+    return { action: "NOTHING", target, set: {}, setWhere: void 0 };
+  }
+  const set = Object.fromEntries(updateNames.map((name) => [name, excludedRef(columns[name].name)]));
+  const setWhere = onConflict?.where && buildWhere ? buildWhere(onConflict.where) : void 0;
+  return { action: "UPDATE", target, set, setWhere };
+};
+var excludedColumnRef = (columnName) => sql`excluded.${sql.identifier(columnName)}`;
+var mysqlValuesColumnRef = (columnName) => sql`values(${sql.identifier(columnName)})`;
+var selectDistinctKeys = async (params) => {
+  const { db, table, tableName, distinct, pkNames, where, orderBy, limit, offset } = params;
+  const cols = getColumns(table);
+  if (!pkNames.length) {
+    throw new GraphQLError3(`Table ${tableName} has no primary key, so 'distinct' cannot be applied to it.`);
+  }
+  const partitionCols = distinct.map((name) => cols[name]).filter(Boolean);
+  if (!partitionCols.length) {
+    throw new GraphQLError3(`No known columns were given to 'distinct' on ${tableName}.`);
+  }
+  const orderEntries = orderBy ? orderByEntries(orderBy) : [];
+  const windowOrder = [
+    ...orderEntries.map(([column, direction]) => direction === "asc" ? asc(cols[column]) : desc(cols[column])),
+    ...primaryKeyOrderExprs(table, pkNames)
+  ];
+  const rowNumber = sql`row_number() over (partition by ${sql.join(partitionCols, sql`, `)} order by ${sql.join(
+    windowOrder,
+    sql`, `
+  )})`.as(DISTINCT_RN);
+  const sub = db.select({ ...cols, [DISTINCT_RN]: rowNumber }).from(table).where(where).as("__dgql_distinct");
+  const outerOrder = [
+    ...orderEntries.map(([column, direction]) => direction === "asc" ? asc(sub[column]) : desc(sub[column])),
+    ...pkNames.filter((name) => sub[name]).map((name) => asc(sub[name]))
+  ];
+  let query = db.select(Object.fromEntries(pkNames.map((name) => [name, sub[name]]))).from(sub).where(eq(sub[DISTINCT_RN], 1)).orderBy(...outerOrder);
+  if (offset) {
+    query = query.offset(offset);
+  }
+  if (limit != null) {
+    query = query.limit(limit);
+  }
+  return await query;
+};
+var primaryKeyRestriction = (table, pkNames, keys) => {
+  const cols = getColumns(table);
+  if (pkNames.length === 1) {
+    const name = pkNames[0];
+    return inArray(
+      cols[name],
+      keys.map((key) => key[name])
+    );
+  }
+  return or(...keys.map((key) => and(...pkNames.map((name) => eq(cols[name], key[name])))));
+};
+var prepareMutationRelationColumns = (params) => {
+  const { relationMap, tables, tableName, typeName, typeNameMapper, table, pkNames, parsedInfo } = params;
+  const withParams = relationMap[tableName] ? extractRelationsParams(relationMap, tables, tableName, parsedInfo, typeName, typeNameMapper) : void 0;
+  const hasRelations = !!(withParams && Object.keys(withParams).length);
+  const baseColumns = extractSelectedColumnsFromTreeSQLFormat(parsedInfo.fieldsByTypeName[typeName], table, {
+    tableName,
+    relationMap,
+    tables
+  });
+  const columns = hasRelations ? withPrimaryKeyColumns(baseColumns, table, pkNames) : baseColumns;
+  return { columns, hasRelations, withParams };
+};
+var toGraphQLError = (e) => {
+  if (e instanceof GraphQLError3) {
+    return e;
+  }
+  return e instanceof Error ? new GraphQLError3(e.message, { originalError: e }) : e;
+};
+var defaultErrorMapper = (error) => {
+  if (error instanceof GraphQLError3 && !error.originalError) {
+    return error;
+  }
+  return new GraphQLError3("Internal server error", {
+    originalError: error instanceof GraphQLError3 ? error.originalError ?? error : error instanceof Error ? error : null,
+    extensions: { code: "INTERNAL_SERVER_ERROR" }
+  });
+};
+var applyErrorMapper = (entities, mapError) => {
+  const wrap = (resolve) => (...args) => {
+    try {
+      const result = resolve(...args);
+      if (result && typeof result.then === "function") {
+        return result.then(void 0, (e) => {
+          throw mapError(e);
+        });
+      }
+      return result;
+    } catch (e) {
+      throw mapError(e);
+    }
+  };
+  for (const field of [...Object.values(entities.queries), ...Object.values(entities.mutations)]) {
+    if (field?.resolve) {
+      field.resolve = wrap(field.resolve);
+    }
+  }
+  for (const type of Object.values(entities.types)) {
+    if (typeof type?.getFields !== "function") {
+      continue;
+    }
+    for (const field of Object.values(type.getFields())) {
+      if (field?.resolve) {
+        field.resolve = wrap(field.resolve);
+      }
+    }
+  }
+  for (const tableResolvers of Object.values(entities.fieldResolvers ?? {})) {
+    for (const [relationName, resolve] of Object.entries(tableResolvers)) {
+      tableResolvers[relationName] = wrap(resolve);
+    }
+  }
+};
+var computeResolverFieldNames = (tableName, typeNameMapper, prefixes, suffixes) => {
+  const mapped = typeNameMapper?.(tableName);
+  const typeName = mapped ? capitalize(mapped.singular) : capitalize(tableName);
+  const listFieldName = (mapped?.plural ?? uncapitalize(tableName)) + suffixes.list;
+  const singleFieldName = mapped?.singular ?? uncapitalize(tableName) + suffixes.single;
+  const aggregateFieldName = `${mapped?.plural ?? uncapitalize(tableName)}Aggregate`;
+  const createArrayFieldName = `${prefixes.insert}${mapped ? capitalize(mapped.plural) : capitalize(tableName)}`;
+  const createSingleFieldName = mapped ? `${prefixes.insert}${capitalize(mapped.singular)}` : `${prefixes.insert}${capitalize(tableName)}${suffixes.single}`;
+  const upsertPrefix = prefixes.upsert ?? "upsert";
+  const upsertArrayFieldName = `${upsertPrefix}${mapped ? capitalize(mapped.plural) : capitalize(tableName)}`;
+  const upsertSingleFieldName = mapped ? `${upsertPrefix}${capitalize(mapped.singular)}` : `${upsertPrefix}${capitalize(tableName)}${suffixes.single}`;
+  const updateFieldName = `${prefixes.update}${mapped ? capitalize(mapped.singular) : capitalize(tableName)}`;
+  const deleteFieldName = `${prefixes.delete}${mapped ? capitalize(mapped.singular) : capitalize(tableName)}`;
   return {
-    name: queryName,
-    resolver: async (_source, args, _context, _info) => {
+    typeName,
+    listFieldName,
+    singleFieldName,
+    aggregateFieldName,
+    createArrayFieldName,
+    createSingleFieldName,
+    upsertArrayFieldName,
+    upsertSingleFieldName,
+    updateFieldName,
+    deleteFieldName
+  };
+};
+var selectArrayArgs = (orderArgs, filterArgs, distinctEnum) => ({
+  offset: { type: GraphQLInt2 },
+  limit: { type: GraphQLInt2 },
+  orderBy: { type: orderArgs },
+  where: { type: filterArgs },
+  ...distinctEnum ? { distinct: { type: new GraphQLList2(new GraphQLNonNull2(distinctEnum)) } } : {}
+});
+var selectSingleArgs = (orderArgs, filterArgs) => ({
+  offset: { type: GraphQLInt2 },
+  orderBy: { type: orderArgs },
+  where: { type: filterArgs }
+});
+var runRelationalSelect = async (opts) => {
+  const {
+    queryBase,
+    tables,
+    tableName,
+    table,
+    relationMap,
+    typeName,
+    typeNameMapper,
+    parsedInfo,
+    offset,
+    orderBy,
+    where,
+    single,
+    filterCtx,
+    pkNames
+  } = opts;
+  const distinct = opts.distinct?.length ? opts.distinct : void 0;
+  const needsDefaultOrder = single || offset != null || opts.limit != null;
+  let distinctKeys;
+  if (distinct) {
+    distinctKeys = await selectDistinctKeys({
+      db: opts.db,
+      table,
+      tableName,
+      distinct,
+      pkNames: pkNames ?? [],
+      where: where ? extractFilters(table, tableName, where, relationFilterCtx(filterCtx, tableName)) : void 0,
+      orderBy,
+      limit: single ? 1 : opts.limit,
+      offset
+    });
+    if (!distinctKeys.length) {
+      return single ? void 0 : [];
+    }
+  }
+  const params = {
+    columns: extractSelectedColumnsFromTree(parsedInfo.fieldsByTypeName[typeName], table, {
+      tableName,
+      relationMap,
+      tables
+    }),
+    offset: distinctKeys ? void 0 : offset,
+    // drizzle-orm v1 RQB calls orderBy/where with the aliased table proxy — use it
+    // directly so column refs match the CTE alias.
+    orderBy: distinctKeys ? (aliasedTable2) => [
+      ...orderBy ? extractOrderBy(aliasedTable2, orderBy) : [],
+      ...primaryKeyOrderExprs(aliasedTable2, pkNames)
+    ] : orderBy ? (aliasedTable2) => extractOrderBy(aliasedTable2, orderBy) : needsDefaultOrder && pkNames?.length ? (aliasedTable2) => primaryKeyOrderExprs(aliasedTable2, pkNames) : void 0,
+    where: distinctKeys ? { RAW: (aliasedTable2) => primaryKeyRestriction(aliasedTable2, pkNames, distinctKeys) } : where ? {
+      RAW: (aliasedTable2) => extractFilters(aliasedTable2, tableName, where, relationFilterCtx(filterCtx, tableName))
+    } : void 0,
+    with: relationMap[tableName] ? extractRelationsParams(relationMap, tables, tableName, parsedInfo, typeName, typeNameMapper, filterCtx) : void 0
+  };
+  if (single) {
+    const result2 = await queryBase.findFirst(params);
+    return result2 ? remapToGraphQLSingleOutput(result2, tableName, table, relationMap) : void 0;
+  }
+  params.limit = distinctKeys ? void 0 : opts.limit;
+  const result = await queryBase.findMany(params);
+  return remapToGraphQLArrayOutput(result, tableName, table, relationMap);
+};
+var eagerLoadMutationRelations = async (db, tableName, rows, pkNames, withParams) => {
+  if (!rows.length || !pkNames.length || !withParams || !Object.keys(withParams).length) {
+    return rows;
+  }
+  const queryBase = db.query?.[tableName];
+  if (!queryBase) {
+    return rows;
+  }
+  const keyableRows = rows.filter((row) => pkNames.every((n) => row[n] != null));
+  if (!keyableRows.length) {
+    return rows;
+  }
+  const pkColumns = {};
+  for (const pk of pkNames) {
+    pkColumns[pk] = true;
+  }
+  const relationNames = Object.keys(withParams);
+  const keyOf = (row) => JSON.stringify(pkNames.map((n) => typeof row[n] === "bigint" ? row[n].toString() : row[n]));
+  let whereRaw;
+  if (pkNames.length === 1) {
+    const pkName = pkNames[0];
+    const ids = keyableRows.map((r) => r[pkName]);
+    whereRaw = (aliased) => inArray(aliased[pkName], ids);
+  } else {
+    whereRaw = (aliased) => {
+      const lhs = sql.join(
+        pkNames.map((n) => sql`${aliased[n]}`),
+        sql`, `
+      );
+      const tuples = sql.join(
+        keyableRows.map(
+          (row) => sql`(${sql.join(
+            pkNames.map((n) => sql`${row[n]}`),
+            sql`, `
+          )})`
+        ),
+        sql`, `
+      );
+      return sql`(${lhs}) in (${tuples})`;
+    };
+  }
+  let enriched;
+  try {
+    enriched = await queryBase.findMany({
+      columns: pkColumns,
+      where: { RAW: whereRaw },
+      with: withParams
+    });
+  } catch (err) {
+    console.warn(
+      `[drizzle-graphql] eager-loading relations for a "${tableName}" mutation failed; falling back to lazy resolution.`,
+      err
+    );
+    return rows;
+  }
+  const byKey = new Map(enriched.map((e) => [keyOf(e), e]));
+  for (const row of rows) {
+    const match = byKey.get(keyOf(row));
+    if (!match) {
+      continue;
+    }
+    for (const rel of relationNames) {
+      row[rel] = match[rel];
+    }
+  }
+  return rows;
+};
+
+// src/util/builders/mysql.ts
+import { is as is4, One as One3 } from "drizzle-orm";
+import { getTableConfig, MySqlTable } from "drizzle-orm/mysql-core";
+import {
+  GraphQLBoolean as GraphQLBoolean3,
+  GraphQLError as GraphQLError4,
+  GraphQLList as GraphQLList4,
+  GraphQLNonNull as GraphQLNonNull4,
+  GraphQLObjectType as GraphQLObjectType4
+} from "graphql";
+import { parseResolveInfo as parseResolveInfo2 } from "graphql-parse-resolve-info";
+
+// src/util/builders/aggregates.ts
+import {
+  and as and2,
+  avg,
+  count,
+  countDistinct,
+  extractExtendedColumnType as extractExtendedColumnType2,
+  getColumns as getColumns2,
+  inArray as inArray2,
+  max,
+  min,
+  sum
+} from "drizzle-orm";
+import {
+  GraphQLFloat as GraphQLFloat2,
+  GraphQLInt as GraphQLInt3,
+  GraphQLList as GraphQLList3,
+  GraphQLNonNull as GraphQLNonNull3,
+  GraphQLObjectType as GraphQLObjectType3
+} from "graphql";
+import { parseResolveInfo } from "graphql-parse-resolve-info";
+var AGGREGATE_OPS = ["avg", "sum", "min", "max", "countNonNull", "countDistinct"];
+var COUNT_OPS = /* @__PURE__ */ new Set(["countNonNull", "countDistinct"]);
+var OP_FNS = {
+  avg,
+  sum,
+  min,
+  max,
+  countNonNull: count,
+  countDistinct
+};
+var SEP = "__";
+var classifyAggregateColumns = (table, tableName) => {
+  const numeric = {};
+  const orderable = {};
+  const all = {};
+  for (const [columnName, column] of Object.entries(getColumns2(table))) {
+    all[columnName] = column;
+    const converted = drizzleColumnToGraphQLType(column, columnName, tableName, true, false, false);
+    const gqlType = converted.type;
+    if (gqlType instanceof GraphQLList3 || gqlType instanceof GraphQLObjectType3) {
+      continue;
+    }
+    const { type: dataType, constraint } = extractExtendedColumnType2(column);
+    if (dataType === "boolean" || dataType === "array" || dataType === "custom") {
+      continue;
+    }
+    if (dataType === "object" && constraint !== "date") {
+      continue;
+    }
+    orderable[columnName] = { column, converted };
+    if (dataType === "number") {
+      numeric[columnName] = column;
+    }
+  }
+  return { numeric, orderable, all };
+};
+var generateAggregateTypes = (table, tableName, typeName, cacheCtx) => {
+  const cached = cacheCtx?.aggregateTypeCache.get(tableName);
+  if (cached) {
+    return cached;
+  }
+  const { numeric, orderable, all } = classifyAggregateColumns(table, tableName);
+  const fields = {
+    count: { type: new GraphQLNonNull3(GraphQLInt3) }
+  };
+  if (Object.keys(numeric).length) {
+    for (const op of ["avg", "sum"]) {
+      fields[op] = {
+        type: new GraphQLObjectType3({
+          name: `${typeName}${capitalize(op)}Aggregate`,
+          fields: Object.fromEntries(Object.keys(numeric).map((columnName) => [columnName, { type: GraphQLFloat2 }]))
+        })
+      };
+    }
+  }
+  if (Object.keys(orderable).length) {
+    for (const op of ["min", "max"]) {
+      fields[op] = {
+        type: new GraphQLObjectType3({
+          name: `${typeName}${capitalize(op)}Aggregate`,
+          fields: Object.fromEntries(
+            Object.entries(orderable).map(([columnName, { converted }]) => [
+              columnName,
+              { type: converted.type, description: converted.description }
+            ])
+          )
+        })
+      };
+    }
+  }
+  const countSets = { countNonNull: all, countDistinct: orderable };
+  for (const [op, columns] of Object.entries(countSets)) {
+    const columnNames = Object.keys(columns);
+    if (!columnNames.length) {
+      continue;
+    }
+    fields[op] = {
+      type: new GraphQLObjectType3({
+        name: `${typeName}${capitalize(op)}Aggregate`,
+        fields: Object.fromEntries(
+          columnNames.map((columnName) => [columnName, { type: new GraphQLNonNull3(GraphQLInt3) }])
+        )
+      })
+    };
+  }
+  const aggregateType = new GraphQLObjectType3({
+    name: `${typeName}Aggregate`,
+    fields
+  });
+  cacheCtx?.aggregateTypeCache.set(tableName, aggregateType);
+  return aggregateType;
+};
+var parseDriverDateTime = (raw) => {
+  let v = raw.includes(" ") ? raw.replace(" ", "T") : raw;
+  if (!v.includes("T")) {
+    v = `${v}T00:00:00`;
+  }
+  if (!/(?:[Zz]|[+-]\d{2}(?::?\d{2})?)$/.test(v)) {
+    v = `${v}Z`;
+  }
+  const parsed = new Date(v);
+  return Number.isNaN(parsed.getTime()) ? new Date(raw) : parsed;
+};
+var aggregateTarget = (table, tableName, typeName) => {
+  const { orderable } = classifyAggregateColumns(table, tableName);
+  return {
+    tableName,
+    typeName,
+    columns: getColumns2(table),
+    dateTimeColumns: new Set(
+      Object.entries(orderable).filter(([, { converted }]) => converted.description === "DateTime").map(([columnName]) => columnName)
+    )
+  };
+};
+var parseAggregateRequest = (info, target) => {
+  const parsedInfo = parseResolveInfo(info, { deep: true });
+  const selectionTree = parsedInfo.fieldsByTypeName[`${target.typeName}Aggregate`] ?? {};
+  const request = {
+    count: false,
+    ops: { avg: [], sum: [], min: [], max: [], countNonNull: [], countDistinct: [] },
+    selection: {}
+  };
+  for (const field of Object.values(selectionTree)) {
+    if (field.name === "count") {
+      request.count = true;
+      request.selection.count = count();
+      continue;
+    }
+    if (!AGGREGATE_OPS.includes(field.name)) {
+      continue;
+    }
+    const op = field.name;
+    const subTree = field.fieldsByTypeName[`${target.typeName}${capitalize(op)}Aggregate`];
+    if (!subTree) {
+      continue;
+    }
+    for (const subField of Object.values(subTree)) {
+      const columnName = subField.name;
+      const column = target.columns[columnName];
+      if (!column || request.ops[op].includes(columnName)) {
+        continue;
+      }
+      request.ops[op].push(columnName);
+      request.selection[`${op}${SEP}${columnName}`] = OP_FNS[op](column);
+    }
+  }
+  return request;
+};
+var assembleAggregateRow = (row, request, target) => {
+  const result = {};
+  if (request.count) {
+    result.count = row.count == null ? 0 : Number(row.count);
+  }
+  for (const op of AGGREGATE_OPS) {
+    if (!request.ops[op].length) {
+      continue;
+    }
+    const opResult = {};
+    for (const columnName of request.ops[op]) {
+      const value = row[`${op}${SEP}${columnName}`];
+      if (COUNT_OPS.has(op)) {
+        opResult[columnName] = value == null ? 0 : Number(value);
+      } else if (value == null) {
+        opResult[columnName] = null;
+      } else if (op === "avg" || op === "sum") {
+        opResult[columnName] = Number(value);
+      } else {
+        const column = target.columns[columnName];
+        const decoded = typeof value === "string" && target.dateTimeColumns.has(columnName) ? parseDriverDateTime(value) : value;
+        opResult[columnName] = remapToGraphQLCore(columnName, decoded, target.tableName, column);
+      }
+    }
+    result[op] = opResult;
+  }
+  return result;
+};
+var generateAggregate = (db, tableName, table, typeName, fieldName, filterArgs, filterCtx) => {
+  const target = aggregateTarget(table, tableName, typeName);
+  const queryArgs = {
+    where: { type: filterArgs }
+  };
+  return {
+    name: fieldName,
+    resolver: async (_source, args, context, info) => {
+      try {
+        const request = parseAggregateRequest(info, target);
+        if (!Object.keys(request.selection).length) {
+          return {};
+        }
+        let query = resolveExecutor(db, context).select(request.selection).from(table);
+        if (args.where) {
+          query = query.where(extractFilters(table, tableName, args.where, relationFilterCtx(filterCtx, tableName)));
+        }
+        const rows = await query;
+        return assembleAggregateRow(rows[0] ?? {}, request, target);
+      } catch (e) {
+        throw toGraphQLError(e);
+      }
+    },
+    args: queryArgs
+  };
+};
+var GROUP_KEY = "__dgql_group_key";
+var createRelationAggregateFactory = (db, tables, cacheCtx, typeNameMapper, filterCtx) => {
+  return ({ tableName, relationName, relEntry }) => {
+    const parentTable = tables[tableName];
+    const targetTableName = relEntry.targetTableName;
+    const targetTable = tables[targetTableName];
+    if (!parentTable || !targetTable) {
+      return void 0;
+    }
+    const joinCols = extractRelationJoinColumns(relEntry, parentTable, targetTable);
+    if (!joinCols) {
+      return void 0;
+    }
+    const { localColPropName, foreignCol } = joinCols;
+    const targetTypeName = resolveTypeName(targetTableName, typeNameMapper);
+    const type = generateAggregateTypes(targetTable, targetTableName, targetTypeName, cacheCtx);
+    const target = aggregateTarget(targetTable, targetTableName, targetTypeName);
+    const resolve = async (parent, args, context, info) => {
+      try {
+        const request = parseAggregateRequest(info, target);
+        if (!Object.keys(request.selection).length) {
+          return {};
+        }
+        const localValue = parent[localColPropName];
+        if (localValue == null) {
+          return assembleAggregateRow({}, request, target);
+        }
+        const whereArg = args?.where;
+        const argsKey = JSON.stringify({
+          where: whereArg ?? null,
+          selection: Object.keys(request.selection).sort()
+        });
+        const loaderKey = `${tableName}::${relationName}::aggregate::${argsKey}`;
+        const loader = getOrCreateLoader(context, loaderKey, async (parentIds) => {
+          const executor = resolveExecutor(db, context);
+          const uniqueIds = [...new Set(parentIds)];
+          const whereCondition = and2(
+            inArray2(foreignCol, uniqueIds),
+            whereArg ? extractFilters(targetTable, targetTableName, whereArg, relationFilterCtx(filterCtx, targetTableName)) : void 0
+          );
+          const rows = await executor.select({ [GROUP_KEY]: foreignCol, ...request.selection }).from(targetTable).where(whereCondition).groupBy(foreignCol);
+          const byKey = new Map(rows.map((row) => [row[GROUP_KEY], row]));
+          return parentIds.map((id) => byKey.get(id) ?? {});
+        });
+        return assembleAggregateRow(await loader.load(localValue), request, target);
+      } catch (e) {
+        throw toGraphQLError(e);
+      }
+    };
+    return { type, resolve };
+  };
+};
+
+// src/util/builders/mysql.ts
+var generateSelectArray = (db, tableName, tables, relationMap, orderArgs, filterArgs, fieldName, typeName, typeNameMapper, filterCtx, distinctEnabled = true) => {
+  const queryBase = db.query[tableName];
+  if (!queryBase) {
+    throw new Error(
+      `Drizzle-GraphQL Error: Table ${tableName} not found in drizzle instance. Did you forget to pass schema to drizzle constructor?`
+    );
+  }
+  const table = tables[tableName];
+  const pkNames = mysqlPrimaryKeyPropNames(table);
+  const queryArgs = selectArrayArgs(
+    orderArgs,
+    filterArgs,
+    distinctEnabled ? generateDistinctEnum(table, typeName) : void 0
+  );
+  return {
+    name: fieldName,
+    resolver: async (_source, args, context, info) => {
+      try {
+        const parsedInfo = parseResolveInfo2(info, { deep: true });
+        const { executor, queryBase: requestQueryBase } = resolveQueryExecutor(db, context, tableName, queryBase);
+        return await runRelationalSelect({
+          queryBase: requestQueryBase,
+          tables,
+          tableName,
+          table,
+          relationMap,
+          typeName,
+          typeNameMapper,
+          parsedInfo,
+          ...args,
+          single: false,
+          filterCtx,
+          pkNames,
+          db: executor
+        });
+      } catch (e) {
+        throw toGraphQLError(e);
+      }
+    },
+    args: queryArgs
+  };
+};
+var generateSelectSingle = (db, tableName, tables, relationMap, orderArgs, filterArgs, fieldName, typeName, typeNameMapper, filterCtx) => {
+  const queryBase = db.query[tableName];
+  if (!queryBase) {
+    throw new Error(
+      `Drizzle-GraphQL Error: Table ${tableName} not found in drizzle instance. Did you forget to pass schema to drizzle constructor?`
+    );
+  }
+  const queryArgs = selectSingleArgs(orderArgs, filterArgs);
+  const table = tables[tableName];
+  const pkNames = mysqlPrimaryKeyPropNames(table);
+  return {
+    name: fieldName,
+    resolver: async (_source, args, context, info) => {
+      try {
+        const parsedInfo = parseResolveInfo2(info, { deep: true });
+        const { executor, queryBase: requestQueryBase } = resolveQueryExecutor(db, context, tableName, queryBase);
+        return await runRelationalSelect({
+          queryBase: requestQueryBase,
+          tables,
+          tableName,
+          table,
+          relationMap,
+          typeName,
+          typeNameMapper,
+          parsedInfo,
+          ...args,
+          single: true,
+          filterCtx,
+          pkNames,
+          db: executor
+        });
+      } catch (e) {
+        throw toGraphQLError(e);
+      }
+    },
+    args: queryArgs
+  };
+};
+var generateInsertArray = (db, _tableName, table, baseType, fieldName) => {
+  const queryArgs = {
+    values: {
+      type: new GraphQLNonNull4(new GraphQLList4(new GraphQLNonNull4(baseType)))
+    }
+  };
+  return {
+    name: fieldName,
+    resolver: async (_source, args, context, _info) => {
+      try {
+        const input = remapFromGraphQLArrayInput(args.values, table);
+        if (!input.length) {
+          throw new GraphQLError4("No values were provided!");
+        }
+        await resolveExecutor(db, context).insert(table).values(input);
+        return { isSuccess: true };
+      } catch (e) {
+        throw toGraphQLError(e);
+      }
+    },
+    args: queryArgs
+  };
+};
+var generateInsertSingle = (db, _tableName, table, baseType, fieldName) => {
+  const queryArgs = {
+    values: {
+      type: new GraphQLNonNull4(baseType)
+    }
+  };
+  return {
+    name: fieldName,
+    resolver: async (_source, args, context, _info) => {
       try {
         const input = remapFromGraphQLSingleInput(args.values, table);
-        await db.insert(table).values(input);
+        await resolveExecutor(db, context).insert(table).values(input);
         return { isSuccess: true };
       } catch (e) {
-        if (e instanceof Error) {
-          throw new GraphQLError3(e.message);
+        throw toGraphQLError(e);
+      }
+    },
+    args: queryArgs
+  };
+};
+var generateUpsert = (db, table, baseType, onConflictType, fieldName, single) => {
+  const queryArgs = {
+    values: {
+      type: single ? new GraphQLNonNull4(baseType) : new GraphQLNonNull4(new GraphQLList4(new GraphQLNonNull4(baseType)))
+    },
+    onConflict: {
+      type: onConflictType,
+      description: "How a conflicting row is resolved. Defaults to overwriting it."
+    }
+  };
+  const pkNames = mysqlPrimaryKeyPropNames(table);
+  return {
+    name: fieldName,
+    resolver: async (_source, args, context, _info) => {
+      try {
+        const input = single ? [remapFromGraphQLSingleInput(args.values, table)] : remapFromGraphQLArrayInput(args.values, table);
+        if (!input.length) {
+          throw new GraphQLError4("No values were provided!");
         }
-        throw e;
+        const plan = resolveConflictPlan({
+          table,
+          values: input,
+          onConflict: args.onConflict,
+          pkNames,
+          uniqueSets: [],
+          excludedRef: mysqlValuesColumnRef,
+          withTarget: false
+        });
+        const executor = resolveExecutor(db, context);
+        if (plan.action === "NOTHING") {
+          await executor.insert(table).ignore().values(input);
+        } else {
+          await executor.insert(table).values(input).onDuplicateKeyUpdate({ set: plan.set });
+        }
+        return { isSuccess: true };
+      } catch (e) {
+        throw toGraphQLError(e);
       }
     },
     args: queryArgs
   };
 };
-var generateUpdate = (db, tableName, table, setArgs, filterArgs) => {
-  const queryName = `update${capitalize(tableName)}`;
+var generateUpdate = (db, tableName, table, setArgs, filterArgs, fieldName, filterCtx) => {
   const queryArgs = {
     set: {
-      type: new GraphQLNonNull3(setArgs)
+      type: new GraphQLNonNull4(setArgs)
     },
     where: {
       type: filterArgs
     }
   };
   return {
-    name: queryName,
-    resolver: async (_source, args, _context, _info) => {
+    name: fieldName,
+    resolver: async (_source, args, context, _info) => {
       try {
         const { where, set } = args;
         const input = remapFromGraphQLSingleInput(set, table);
         if (!Object.keys(input).length) {
-          throw new GraphQLError3("Unable to update with no values specified!");
+          throw new GraphQLError4("Unable to update with no values specified!");
         }
-        let query = db.update(table).set(input);
+        const executor = resolveExecutor(db, context);
+        let query = executor.update(table).set(input);
         if (where) {
-          const filters = extractFilters(table, tableName, where);
+          const filters = extractFilters(table, tableName, where, relationFilterCtx(filterCtx, tableName));
           query = query.where(filters);
         }
         await query;
         return { isSuccess: true };
       } catch (e) {
-        if (e instanceof Error) {
-          throw new GraphQLError3(e.message);
-        }
-        throw e;
+        throw toGraphQLError(e);
       }
     },
     args: queryArgs
   };
 };
-var generateDelete = (db, tableName, table, filterArgs) => {
-  const queryName = `deleteFrom${capitalize(tableName)}`;
+var generateDelete = (db, tableName, table, filterArgs, fieldName, filterCtx) => {
   const queryArgs = {
     where: {
       type: filterArgs
     }
   };
   return {
-    name: queryName,
-    resolver: async (_source, args, _context, _info) => {
+    name: fieldName,
+    resolver: async (_source, args, context, _info) => {
       try {
         const { where } = args;
-        let query = db.delete(table);
+        const executor = resolveExecutor(db, context);
+        let query = executor.delete(table);
         if (where) {
-          const filters = extractFilters(table, tableName, where);
+          const filters = extractFilters(table, tableName, where, relationFilterCtx(filterCtx, tableName));
           query = query.where(filters);
         }
         await query;
         return { isSuccess: true };
       } catch (e) {
-        if (e instanceof Error) {
-          throw new GraphQLError3(e.message);
-        }
-        throw e;
+        throw toGraphQLError(e);
       }
     },
     args: queryArgs
   };
 };
-var buildNamedRelations2 = (relations, tableEntries) => {
-  const namedRelations = {};
-  for (const [relTableName, relConfig] of Object.entries(relations)) {
-    if (!relConfig?.relations) {
-      continue;
-    }
-    const namedConfig = {};
-    for (const [innerRelName, innerRelValue] of Object.entries(relConfig.relations)) {
-      const targetTable = innerRelValue.targetTable ?? innerRelValue.referencedTable;
-      const directTargetName = innerRelValue.targetTableName;
-      let targetTableName;
-      if (directTargetName) {
-        const targetEntry = tableEntries.find(([key]) => key === directTargetName);
-        targetTableName = targetEntry?.[0];
-      } else if (targetTable) {
-        const targetEntry = tableEntries.find(([, tableValue]) => tableValue === targetTable);
-        targetTableName = targetEntry?.[0];
-      }
-      if (!targetTableName) {
-        continue;
-      }
-      namedConfig[innerRelName] = {
-        relation: innerRelValue,
-        targetTableName
-      };
-    }
-    if (Object.keys(namedConfig).length > 0) {
-      namedRelations[relTableName] = namedConfig;
-    }
-  }
-  return namedRelations;
-};
-var generateSchemaData = (db, schema, relations, relationsDepthLimit, prefixes, suffixes, singularTypes = false) => {
+var mysqlPrimaryKeyPropNames = (table) => getPrimaryKeyPropNamesFromConfig(table, getTableConfig);
+var generateSchemaData = (db, schema, relations, options) => {
+  const { relationsDepthLimit, prefixes, suffixes, typeNameMapper, shouldEagerLoad, features } = options;
   const rawSchema = schema;
   const schemaEntries = Object.entries(rawSchema);
-  const tableEntries = schemaEntries.filter(([_key, value]) => is3(value, MySqlTable));
+  const tableEntries = schemaEntries.filter(([_key, value]) => is4(value, MySqlTable));
   const tables = Object.fromEntries(tableEntries);
   if (!tableEntries.length) {
     throw new Error(
       "Drizzle-GraphQL Error: No tables detected in Drizzle-ORM's database instance. Did you forget to pass schema to drizzle constructor?"
     );
   }
-  const namedRelations = buildNamedRelations2(relations ?? {}, tableEntries);
+  const namedRelations = buildNamedRelations(relations ?? {}, tableEntries);
+  attachTargetPrimaryKeys(namedRelations, tables, mysqlPrimaryKeyPropNames);
+  const eagerRelations = pruneNonEagerRelations(namedRelations, shouldEagerLoad);
+  const filterCtx = { tables, relationMap: namedRelations };
+  const resolverFactory = createRelationResolverFactory(db, tables, filterCtx);
   const cacheCtx = {
     genericFilterCache: /* @__PURE__ */ new Map(),
     objectTypeCache: /* @__PURE__ */ new Map(),
     relationFieldContainers: /* @__PURE__ */ new Map(),
     fullyBuiltTables: /* @__PURE__ */ new Set(),
-    relationTypeCache: /* @__PURE__ */ new Map()
+    relationTypeCache: /* @__PURE__ */ new Map(),
+    orderTypeCache: /* @__PURE__ */ new WeakMap(),
+    filterTypeCache: /* @__PURE__ */ new WeakMap(),
+    listRelationFilterCache: /* @__PURE__ */ new Map(),
+    aggregateTypeCache: /* @__PURE__ */ new Map()
   };
+  const relationAggregateFactory = features.relationAggregates ? createRelationAggregateFactory(db, tables, cacheCtx, typeNameMapper, filterCtx) : void 0;
   const queries = {};
   const mutations = {};
   const gqlSchemaTypes = Object.fromEntries(
@@ -1305,51 +2433,98 @@ var generateSchemaData = (db, schema, relations, relationsDepthLimit, prefixes,
         false,
         relationsDepthLimit,
         cacheCtx,
-        singularTypes,
+        typeNameMapper,
         prefixes.insert,
-        prefixes.update
+        prefixes.update,
+        resolverFactory,
+        relationAggregateFactory
       )
     ])
   );
-  const mutationReturnType = new GraphQLObjectType3({
+  const mutationReturnType = new GraphQLObjectType4({
     name: "MutationReturn",
     fields: {
       isSuccess: {
-        type: new GraphQLNonNull3(GraphQLBoolean3)
+        type: new GraphQLNonNull4(GraphQLBoolean3)
       }
     }
   });
   const inputs = {};
-  const outputs = {
-    MutationReturn: mutationReturnType
-  };
+  const outputs = {};
+  if (features.insert || features.upsert || features.update || features.delete) {
+    outputs.MutationReturn = mutationReturnType;
+  }
   for (const [tableName, tableTypes] of Object.entries(gqlSchemaTypes)) {
     const { insertInput, updateInput, tableFilters, tableOrder } = tableTypes.inputs;
     const { selectSingleOutput, selectArrOutput } = tableTypes.outputs;
+    const {
+      typeName,
+      listFieldName,
+      singleFieldName,
+      aggregateFieldName,
+      createArrayFieldName,
+      createSingleFieldName,
+      upsertArrayFieldName,
+      upsertSingleFieldName,
+      updateFieldName,
+      deleteFieldName
+    } = computeResolverFieldNames(tableName, typeNameMapper, prefixes, suffixes);
     const selectArrGenerated = generateSelectArray(
       db,
       tableName,
       tables,
-      namedRelations,
+      eagerRelations,
       tableOrder,
       tableFilters,
-      suffixes.list,
-      singularTypes
+      listFieldName,
+      typeName,
+      typeNameMapper,
+      filterCtx,
+      features.distinct
     );
     const selectSingleGenerated = generateSelectSingle(
       db,
       tableName,
       tables,
-      namedRelations,
+      eagerRelations,
       tableOrder,
       tableFilters,
-      suffixes.single,
-      singularTypes
+      singleFieldName,
+      typeName,
+      typeNameMapper,
+      filterCtx
     );
-    const insertArrGenerated = generateInsertArray(db, tableName, schema[tableName], insertInput);
-    const insertSingleGenerated = generateInsertSingle(db, tableName, schema[tableName], insertInput);
-    const updateGenerated = generateUpdate(db, tableName, schema[tableName], updateInput, tableFilters);
-    const deleteGenerated = generateDelete(db, tableName, schema[tableName], tableFilters);
+    const insertArrGenerated = features.insert ? generateInsertArray(db, tableName, schema[tableName], insertInput, createArrayFieldName) : void 0;
+    const insertSingleGenerated = features.insert ? generateInsertSingle(db, tableName, schema[tableName], insertInput, createSingleFieldName) : void 0;
+    const onConflictInput = features.upsert ? generateOnConflictInput({
+      table: schema[tableName],
+      typeName,
+      uniqueSets: [],
+      tableFilters,
+      withTarget: false
+    }) : void 0;
+    const upsertArrGenerated = onConflictInput ? generateUpsert(db, schema[tableName], insertInput, onConflictInput, upsertArrayFieldName, false) : void 0;
+    const upsertSingleGenerated = onConflictInput ? generateUpsert(db, schema[tableName], insertInput, onConflictInput, upsertSingleFieldName, true) : void 0;
+    const updateGenerated = features.update ? generateUpdate(
+      db,
+      tableName,
+      schema[tableName],
+      updateInput,
+      tableFilters,
+      updateFieldName,
+      filterCtx
+    ) : void 0;
+    const deleteGenerated = features.delete ? generateDelete(db, tableName, schema[tableName], tableFilters, deleteFieldName, filterCtx) : void 0;
+    const aggregateType = features.aggregates ? generateAggregateTypes(schema[tableName], tableName, typeName, cacheCtx) : void 0;
+    const aggregateGenerated = features.aggregates ? generateAggregate(
+      db,
+      tableName,
+      schema[tableName],
+      typeName,
+      aggregateFieldName,
+      tableFilters,
+      filterCtx
+    ) : void 0;
     queries[selectArrGenerated.name] = {
       type: selectArrOutput,
       args: selectArrGenerated.args,
@@ -1360,240 +2535,284 @@ var generateSchemaData = (db, schema, relations, relationsDepthLimit, prefixes,
       args: selectSingleGenerated.args,
       resolve: selectSingleGenerated.resolver
     };
-    mutations[insertArrGenerated.name] = {
-      type: mutationReturnType,
-      args: insertArrGenerated.args,
-      resolve: insertArrGenerated.resolver
-    };
-    mutations[insertSingleGenerated.name] = {
-      type: mutationReturnType,
-      args: insertSingleGenerated.args,
-      resolve: insertSingleGenerated.resolver
-    };
-    mutations[updateGenerated.name] = {
-      type: mutationReturnType,
-      args: updateGenerated.args,
-      resolve: updateGenerated.resolver
-    };
-    mutations[deleteGenerated.name] = {
-      type: mutationReturnType,
-      args: deleteGenerated.args,
-      resolve: deleteGenerated.resolver
-    };
-    [insertInput, updateInput, tableFilters, tableOrder].forEach((e) => {
+    if (aggregateGenerated && aggregateType) {
+      queries[aggregateGenerated.name] = {
+        type: new GraphQLNonNull4(aggregateType),
+        args: aggregateGenerated.args,
+        resolve: aggregateGenerated.resolver
+      };
+    }
+    for (const generated of [
+      insertArrGenerated,
+      insertSingleGenerated,
+      upsertArrGenerated,
+      upsertSingleGenerated,
+      updateGenerated,
+      deleteGenerated
+    ]) {
+      if (generated) {
+        mutations[generated.name] = {
+          type: mutationReturnType,
+          args: generated.args,
+          resolve: generated.resolver
+        };
+      }
+    }
+    const activeInputs = [
+      // The insert input types the upsert mutations too, so either feature keeps it.
+      ...features.insert || onConflictInput ? [insertInput] : [],
+      ...onConflictInput ? [onConflictInput] : [],
+      ...features.update ? [updateInput] : [],
+      tableFilters,
+      tableOrder
+    ];
+    activeInputs.forEach((e) => {
       inputs[e.name] = e;
     });
     outputs[selectSingleOutput.name] = selectSingleOutput;
+    if (aggregateType) {
+      outputs[aggregateType.name] = aggregateType;
+    }
+  }
+  const fieldResolvers = {};
+  for (const [tableName, tableRelations] of Object.entries(namedRelations)) {
+    const relResolvers = {};
+    for (const [relName, relEntry] of Object.entries(tableRelations)) {
+      const isOne = is4(relEntry.relation ?? relEntry, One3);
+      const resolver = resolverFactory({ tableName, relationName: relName, relEntry, isOne });
+      if (resolver) {
+        relResolvers[relName] = resolver;
+      }
+    }
+    if (Object.keys(relResolvers).length > 0) {
+      fieldResolvers[tableName] = relResolvers;
+    }
   }
-  return { queries, mutations, inputs, types: outputs };
+  return { queries, mutations, inputs, types: outputs, fieldResolvers };
 };
 
 // src/util/builders/pg.ts
-import { is as is4 } from "drizzle-orm";
-import { PgTable } from "drizzle-orm/pg-core";
+import { is as is5, One as One4 } from "drizzle-orm";
+import { getTableConfig as getTableConfig2, PgTable } from "drizzle-orm/pg-core";
 import {
-  GraphQLError as GraphQLError4,
-  GraphQLInt as GraphQLInt4,
-  GraphQLList as GraphQLList4,
-  GraphQLNonNull as GraphQLNonNull4
+  GraphQLError as GraphQLError5,
+  GraphQLList as GraphQLList5,
+  GraphQLNonNull as GraphQLNonNull5
 } from "graphql";
-import { parseResolveInfo as parseResolveInfo2 } from "graphql-parse-resolve-info";
-var toTypeName3 = (name, singular) => singular ? capitalize(singularize(name)) : capitalize(name);
-var generateSelectArray2 = (db, tableName, tables, relationMap, orderArgs, filterArgs, listSuffix, singularTypes) => {
-  const queryEntityBase = singularTypes ? singularize(uncapitalize(tableName)) : uncapitalize(tableName);
-  const queryName = `${queryEntityBase}${listSuffix}`;
+import { parseResolveInfo as parseResolveInfo3 } from "graphql-parse-resolve-info";
+var generateSelectArray2 = (db, tableName, tables, relationMap, orderArgs, filterArgs, fieldName, typeName, typeNameMapper, filterCtx, distinctEnabled = true) => {
   const queryBase = db.query[tableName];
-  const queryArgs = {
-    offset: {
-      type: GraphQLInt4
-    },
-    limit: {
-      type: GraphQLInt4
-    },
-    orderBy: {
-      type: orderArgs
-    },
-    where: {
-      type: filterArgs
-    }
-  };
-  const typeName = toTypeName3(tableName, singularTypes);
   const table = tables[tableName];
+  const pkNames = pgPrimaryKeyPropNames(table);
+  const queryArgs = selectArrayArgs(
+    orderArgs,
+    filterArgs,
+    distinctEnabled ? generateDistinctEnum(table, typeName) : void 0
+  );
   return {
-    name: queryName,
-    resolver: async (_source, args, _context, info) => {
+    name: fieldName,
+    resolver: async (_source, args, context, info) => {
       try {
-        const { offset, limit, orderBy, where } = args;
-        const parsedInfo = parseResolveInfo2(info, {
-          deep: true
-        });
-        const selectedColumns = extractSelectedColumnsFromTree(parsedInfo.fieldsByTypeName[typeName], table);
-        let result;
-        if (queryBase) {
-          const withParams = relationMap[tableName] ? extractRelationsParams(relationMap, tables, tableName, parsedInfo, typeName, singularTypes) : void 0;
-          result = await queryBase.findMany({
-            columns: selectedColumns,
-            offset,
+        const parsedInfo = parseResolveInfo3(info, { deep: true });
+        const { executor, queryBase: requestQueryBase } = resolveQueryExecutor(db, context, tableName, queryBase);
+        if (requestQueryBase) {
+          return await runRelationalSelect({
+            queryBase: requestQueryBase,
+            tables,
+            tableName,
+            table,
+            relationMap,
+            typeName,
+            typeNameMapper,
+            parsedInfo,
+            ...args,
+            single: false,
+            filterCtx,
+            pkNames,
+            db: executor
+          });
+        }
+        const { offset, limit, orderBy, where, distinct } = args;
+        const selectedColumnsSql = extractSelectedColumnsFromTreeSQLFormat(
+          parsedInfo.fieldsByTypeName[typeName],
+          table,
+          { tableName, relationMap, tables }
+        );
+        const whereSql = where ? extractFilters(table, tableName, where, relationFilterCtx(filterCtx, tableName)) : void 0;
+        let distinctKeys;
+        if (distinct?.length) {
+          distinctKeys = await selectDistinctKeys({
+            db: executor,
+            table,
+            tableName,
+            distinct,
+            pkNames,
+            where: whereSql,
+            orderBy,
             limit,
-            // drizzle-orm v1 RQB calls orderBy with the aliased table proxy (e.g.
-            // d0, d1) — use it directly so column refs match the CTE alias.
-            orderBy: orderBy ? (aliasedTable) => extractOrderBy(aliasedTable, orderBy) : void 0,
-            where: where ? { RAW: (aliased) => extractFilters(aliased, tableName, where) } : void 0,
-            with: withParams
+            offset
           });
-        } else {
-          let q = db.select(selectedColumns).from(table);
-          if (where) {
-            q = q.where(extractFilters(table, tableName, where));
-          }
-          if (orderBy) {
-            q = q.orderBy(...extractOrderBy(table, orderBy));
+          if (!distinctKeys.length) {
+            return [];
           }
+        }
+        let q = executor.select(selectedColumnsSql).from(table);
+        if (distinctKeys) {
+          q = q.where(primaryKeyRestriction(table, pkNames, distinctKeys));
+        } else if (whereSql) {
+          q = q.where(whereSql);
+        }
+        if (orderBy) {
+          q = q.orderBy(
+            ...extractOrderBy(table, orderBy),
+            ...distinctKeys ? primaryKeyOrderExprs(table, pkNames) : []
+          );
+        } else if ((distinctKeys || offset != null || limit != null) && pkNames.length) {
+          q = q.orderBy(...primaryKeyOrderExprs(table, pkNames));
+        }
+        if (!distinctKeys) {
           if (offset) {
             q = q.offset(offset);
           }
           if (limit) {
             q = q.limit(limit);
           }
-          result = await q;
         }
-        return remapToGraphQLArrayOutput(result, tableName, table, relationMap);
+        return remapToGraphQLArrayOutput(await q, tableName, table, relationMap);
       } catch (e) {
-        if (e instanceof Error) {
-          throw new GraphQLError4(e.message);
-        }
-        throw e;
+        throw toGraphQLError(e);
       }
     },
     args: queryArgs
   };
 };
-var generateSelectSingle2 = (db, tableName, tables, relationMap, orderArgs, filterArgs, singleSuffix, singularTypes) => {
-  const queryEntityBase = singularTypes ? singularize(uncapitalize(tableName)) : uncapitalize(tableName);
-  const queryName = `${queryEntityBase}${singleSuffix}`;
+var generateSelectSingle2 = (db, tableName, tables, relationMap, orderArgs, filterArgs, fieldName, typeName, typeNameMapper, filterCtx) => {
   const queryBase = db.query[tableName];
-  const queryArgs = {
-    offset: {
-      type: GraphQLInt4
-    },
-    orderBy: {
-      type: orderArgs
-    },
-    where: {
-      type: filterArgs
-    }
-  };
-  const typeName = toTypeName3(tableName, singularTypes);
+  const queryArgs = selectSingleArgs(orderArgs, filterArgs);
   const table = tables[tableName];
-  return {
-    name: queryName,
-    resolver: async (_source, args, _context, info) => {
-      try {
-        const { offset, orderBy, where } = args;
-        const parsedInfo = parseResolveInfo2(info, {
-          deep: true
-        });
-        const selectedColumns = extractSelectedColumnsFromTree(parsedInfo.fieldsByTypeName[typeName], table);
-        let result;
-        if (queryBase) {
-          result = await queryBase.findFirst({
-            columns: selectedColumns,
-            offset,
-            // drizzle-orm v1 RQB calls orderBy with the aliased table proxy (e.g.
-            // d0, d1) — use it directly so column refs match the CTE alias.
-            orderBy: orderBy ? (aliasedTable) => extractOrderBy(aliasedTable, orderBy) : void 0,
-            where: where ? { RAW: (aliased) => extractFilters(aliased, tableName, where) } : void 0,
-            with: relationMap[tableName] ? extractRelationsParams(relationMap, tables, tableName, parsedInfo, typeName, singularTypes) : void 0
+  const pkNames = pgPrimaryKeyPropNames(table);
+  return {
+    name: fieldName,
+    resolver: async (_source, args, context, info) => {
+      try {
+        const parsedInfo = parseResolveInfo3(info, { deep: true });
+        const { executor, queryBase: requestQueryBase } = resolveQueryExecutor(db, context, tableName, queryBase);
+        if (requestQueryBase) {
+          return await runRelationalSelect({
+            queryBase: requestQueryBase,
+            tables,
+            tableName,
+            table,
+            relationMap,
+            typeName,
+            typeNameMapper,
+            parsedInfo,
+            ...args,
+            single: true,
+            filterCtx,
+            pkNames,
+            db: executor
           });
-        } else {
-          let q = db.select(selectedColumns).from(table);
-          if (where) {
-            q = q.where(extractFilters(table, tableName, where));
-          }
-          if (orderBy) {
-            q = q.orderBy(...extractOrderBy(table, orderBy));
-          }
-          if (offset) {
-            q = q.offset(offset);
-          }
-          const rows = await q.limit(1);
-          result = rows[0];
         }
-        if (!result) {
-          return void 0;
+        const { offset, orderBy, where } = args;
+        const selectedColumnsSql = extractSelectedColumnsFromTreeSQLFormat(
+          parsedInfo.fieldsByTypeName[typeName],
+          table,
+          { tableName, relationMap, tables }
+        );
+        let q = executor.select(selectedColumnsSql).from(table);
+        if (where) {
+          q = q.where(extractFilters(table, tableName, where, relationFilterCtx(filterCtx, tableName)));
         }
-        return remapToGraphQLSingleOutput(result, tableName, table, relationMap);
-      } catch (e) {
-        if (e instanceof Error) {
-          throw new GraphQLError4(e.message);
+        if (orderBy) {
+          q = q.orderBy(...extractOrderBy(table, orderBy));
+        } else if (pkNames.length) {
+          q = q.orderBy(...primaryKeyOrderExprs(table, pkNames));
         }
-        throw e;
+        if (offset) {
+          q = q.offset(offset);
+        }
+        const rows = await q.limit(1);
+        const result = rows[0];
+        return result ? remapToGraphQLSingleOutput(result, tableName, table, relationMap) : void 0;
+      } catch (e) {
+        throw toGraphQLError(e);
       }
     },
     args: queryArgs
   };
 };
-var generateInsertArray2 = (db, tableName, table, baseType, prefix, conflictDoNothing = false, singularTypes = false) => {
-  const queryName = `${prefix}${capitalize(tableName)}`;
-  const typeName = toTypeName3(tableName, singularTypes);
+var pgPrimaryKeyPropNames = (table) => getPrimaryKeyPropNamesFromConfig(table, getTableConfig2);
+var generateInsertArray2 = (db, tableName, table, tables, relationMap, baseType, fieldName, typeName, typeNameMapper, conflictDoNothing = false) => {
   const queryArgs = {
     values: {
-      type: new GraphQLNonNull4(new GraphQLList4(new GraphQLNonNull4(baseType)))
+      type: new GraphQLNonNull5(new GraphQLList5(new GraphQLNonNull5(baseType)))
     }
   };
+  const pkNames = pgPrimaryKeyPropNames(table);
   return {
-    name: queryName,
-    resolver: async (_source, args, _context, info) => {
+    name: fieldName,
+    resolver: async (_source, args, context, info) => {
       try {
         const input = remapFromGraphQLArrayInput(args.values, table);
         if (!input.length) {
-          throw new GraphQLError4("No values were provided!");
+          throw new GraphQLError5("No values were provided!");
         }
-        const parsedInfo = parseResolveInfo2(info, {
+        const parsedInfo = parseResolveInfo3(info, {
           deep: true
         });
-        const columns = extractSelectedColumnsFromTreeSQLFormat(
-          parsedInfo.fieldsByTypeName[typeName],
-          table
-        );
-        let query = db.insert(table).values(input).returning(columns);
+        const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
+          relationMap,
+          tables,
+          tableName,
+          typeName,
+          typeNameMapper,
+          table,
+          pkNames,
+          parsedInfo
+        });
+        const executor = resolveExecutor(db, context);
+        let query = executor.insert(table).values(input).returning(columns);
         if (conflictDoNothing) {
           query = query.onConflictDoNothing();
         }
         const result = await query;
-        return remapToGraphQLArrayOutput(result, tableName, table);
+        const enriched = hasRelations ? await eagerLoadMutationRelations(executor, tableName, result, pkNames, withParams) : result;
+        return remapToGraphQLArrayOutput(enriched, tableName, table, relationMap);
       } catch (e) {
-        if (e instanceof Error) {
-          throw new GraphQLError4(e.message);
-        }
-        throw e;
+        throw toGraphQLError(e);
       }
     },
     args: queryArgs
   };
 };
-var generateInsertSingle2 = (db, tableName, table, baseType, prefix, conflictDoNothing = false, singularTypes = false) => {
-  const queryEntityBase = singularTypes ? singularize(capitalize(tableName)) : capitalize(tableName);
-  const queryName = singularTypes ? `${prefix}${queryEntityBase}` : `${prefix}${queryEntityBase}Single`;
-  const typeName = toTypeName3(tableName, singularTypes);
+var generateInsertSingle2 = (db, tableName, table, tables, relationMap, baseType, fieldName, typeName, typeNameMapper, conflictDoNothing = false) => {
   const queryArgs = {
     values: {
-      type: new GraphQLNonNull4(baseType)
+      type: new GraphQLNonNull5(baseType)
     }
   };
+  const pkNames = pgPrimaryKeyPropNames(table);
   return {
-    name: queryName,
-    resolver: async (_source, args, _context, info) => {
+    name: fieldName,
+    resolver: async (_source, args, context, info) => {
       try {
         const input = remapFromGraphQLSingleInput(args.values, table);
-        const parsedInfo = parseResolveInfo2(info, {
+        const parsedInfo = parseResolveInfo3(info, {
           deep: true
         });
-        const columns = extractSelectedColumnsFromTreeSQLFormat(
-          parsedInfo.fieldsByTypeName[typeName],
-          table
-        );
-        let query = db.insert(table).values(input).returning(columns);
+        const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
+          relationMap,
+          tables,
+          tableName,
+          typeName,
+          typeNameMapper,
+          table,
+          pkNames,
+          parsedInfo
+        });
+        const executor = resolveExecutor(db, context);
+        let query = executor.insert(table).values(input).returning(columns);
         if (conflictDoNothing) {
           query = query.onConflictDoNothing();
         }
@@ -1601,103 +2820,159 @@ var generateInsertSingle2 = (db, tableName, table, baseType, prefix, conflictDoN
         if (!result[0]) {
           return void 0;
         }
-        return remapToGraphQLSingleOutput(result[0], tableName, table);
+        const enriched = hasRelations ? await eagerLoadMutationRelations(executor, tableName, result, pkNames, withParams) : result;
+        return remapToGraphQLSingleOutput(enriched[0], tableName, table, relationMap);
       } catch (e) {
-        if (e instanceof Error) {
-          throw new GraphQLError4(e.message);
+        throw toGraphQLError(e);
+      }
+    },
+    args: queryArgs
+  };
+};
+var generateUpsert2 = (db, tableName, table, tables, relationMap, baseType, onConflictType, uniqueSets, fieldName, typeName, single, typeNameMapper, filterCtx) => {
+  const queryArgs = {
+    values: {
+      type: single ? new GraphQLNonNull5(baseType) : new GraphQLNonNull5(new GraphQLList5(new GraphQLNonNull5(baseType)))
+    },
+    onConflict: {
+      type: onConflictType,
+      description: "How a conflicting row is resolved. Defaults to overwriting it on the primary key."
+    }
+  };
+  const pkNames = pgPrimaryKeyPropNames(table);
+  return {
+    name: fieldName,
+    resolver: async (_source, args, context, info) => {
+      try {
+        const input = single ? [remapFromGraphQLSingleInput(args.values, table)] : remapFromGraphQLArrayInput(args.values, table);
+        if (!input.length) {
+          throw new GraphQLError5("No values were provided!");
         }
-        throw e;
+        const parsedInfo = parseResolveInfo3(info, { deep: true });
+        const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
+          relationMap,
+          tables,
+          tableName,
+          typeName,
+          typeNameMapper,
+          table,
+          pkNames,
+          parsedInfo
+        });
+        const plan = resolveConflictPlan({
+          table,
+          values: input,
+          onConflict: args.onConflict,
+          pkNames,
+          uniqueSets,
+          excludedRef: excludedColumnRef,
+          withTarget: true,
+          buildWhere: (where) => extractFilters(table, tableName, where, relationFilterCtx(filterCtx, tableName))
+        });
+        const executor = resolveExecutor(db, context);
+        let query = executor.insert(table).values(input).returning(columns);
+        query = plan.action === "NOTHING" ? query.onConflictDoNothing(plan.target ? { target: plan.target } : void 0) : query.onConflictDoUpdate({ target: plan.target, set: plan.set, setWhere: plan.setWhere });
+        const result = await query;
+        if (single && !result[0]) {
+          return void 0;
+        }
+        const enriched = hasRelations ? await eagerLoadMutationRelations(executor, tableName, result, pkNames, withParams) : result;
+        return single ? remapToGraphQLSingleOutput(enriched[0], tableName, table, relationMap) : remapToGraphQLArrayOutput(enriched, tableName, table, relationMap);
+      } catch (e) {
+        throw toGraphQLError(e);
       }
     },
     args: queryArgs
   };
 };
-var generateUpdate2 = (db, tableName, table, setArgs, filterArgs, prefix, singularTypes = false) => {
-  const queryName = `${prefix}${capitalize(tableName)}`;
-  const typeName = toTypeName3(tableName, singularTypes);
+var generateUpdate2 = (db, tableName, table, tables, relationMap, setArgs, filterArgs, fieldName, typeName, typeNameMapper, filterCtx) => {
   const queryArgs = {
     set: {
-      type: new GraphQLNonNull4(setArgs)
+      type: new GraphQLNonNull5(setArgs)
     },
     where: {
       type: filterArgs
     }
   };
+  const pkNames = pgPrimaryKeyPropNames(table);
   return {
-    name: queryName,
-    resolver: async (_source, args, _context, info) => {
+    name: fieldName,
+    resolver: async (_source, args, context, info) => {
       try {
         const { where, set } = args;
-        const parsedInfo = parseResolveInfo2(info, {
+        const parsedInfo = parseResolveInfo3(info, {
           deep: true
         });
-        const columns = extractSelectedColumnsFromTreeSQLFormat(
-          parsedInfo.fieldsByTypeName[typeName],
-          table
-        );
+        const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
+          relationMap,
+          tables,
+          tableName,
+          typeName,
+          typeNameMapper,
+          table,
+          pkNames,
+          parsedInfo
+        });
         const input = remapFromGraphQLSingleInput(set, table);
         if (!Object.keys(input).length) {
-          throw new GraphQLError4("Unable to update with no values specified!");
+          throw new GraphQLError5("Unable to update with no values specified!");
         }
-        let query = db.update(table).set(input);
+        const executor = resolveExecutor(db, context);
+        let query = executor.update(table).set(input);
         if (where) {
-          const filters = extractFilters(table, tableName, where);
+          const filters = extractFilters(table, tableName, where, relationFilterCtx(filterCtx, tableName));
           query = query.where(filters);
         }
         query = query.returning(columns);
         const result = await query;
-        return remapToGraphQLArrayOutput(result, tableName, table);
+        const enriched = hasRelations ? await eagerLoadMutationRelations(executor, tableName, result, pkNames, withParams) : result;
+        return remapToGraphQLArrayOutput(enriched, tableName, table, relationMap);
       } catch (e) {
-        if (e instanceof Error) {
-          throw new GraphQLError4(e.message);
-        }
-        throw e;
+        throw toGraphQLError(e);
       }
     },
     args: queryArgs
   };
 };
-var generateDelete2 = (db, tableName, table, filterArgs, prefix, singularTypes = false) => {
-  const queryName = `${prefix}${capitalize(tableName)}`;
-  const typeName = toTypeName3(tableName, singularTypes);
+var generateDelete2 = (db, tableName, table, filterArgs, fieldName, typeName, filterCtx, selectionCtx) => {
   const queryArgs = {
     where: {
       type: filterArgs
     }
   };
   return {
-    name: queryName,
-    resolver: async (_source, args, _context, info) => {
+    name: fieldName,
+    resolver: async (_source, args, context, info) => {
       try {
         const { where } = args;
-        const parsedInfo = parseResolveInfo2(info, {
+        const parsedInfo = parseResolveInfo3(info, {
           deep: true
         });
         const columns = extractSelectedColumnsFromTreeSQLFormat(
           parsedInfo.fieldsByTypeName[typeName],
-          table
+          table,
+          selectionCtx
         );
-        let query = db.delete(table);
+        const executor = resolveExecutor(db, context);
+        let query = executor.delete(table);
         if (where) {
-          const filters = extractFilters(table, tableName, where);
+          const filters = extractFilters(table, tableName, where, relationFilterCtx(filterCtx, tableName));
           query = query.where(filters);
         }
         query = query.returning(columns);
         const result = await query;
         return remapToGraphQLArrayOutput(result, tableName, table);
       } catch (e) {
-        if (e instanceof Error) {
-          throw new GraphQLError4(e.message);
-        }
-        throw e;
+        throw toGraphQLError(e);
       }
     },
     args: queryArgs
   };
 };
-function generateSchemaData2(db, schema, relations, relationsDepthLimit, prefixes, suffixes, conflictDoNothing = false, singularTypes = false) {
+function generateSchemaData2(db, schema, relations, options) {
+  const { relationsDepthLimit, prefixes, suffixes, conflictDoNothing, typeNameMapper, shouldEagerLoad, features } = options;
   const schemaEntries = Object.entries(schema);
-  const tableEntries = schemaEntries.filter(([_key, value]) => is4(value, PgTable));
+  const tableEntries = schemaEntries.filter(([_key, value]) => is5(value, PgTable));
   const tables = Object.fromEntries(tableEntries);
   if (!tableEntries.length) {
     throw new Error(
@@ -1705,13 +2980,22 @@ function generateSchemaData2(db, schema, relations, relationsDepthLimit, prefixe
     );
   }
   const namedRelations = buildNamedRelations(relations ?? {}, tableEntries);
+  attachTargetPrimaryKeys(namedRelations, tables, pgPrimaryKeyPropNames);
+  const eagerRelations = pruneNonEagerRelations(namedRelations, shouldEagerLoad);
+  const filterCtx = { tables, relationMap: namedRelations };
+  const resolverFactory = createRelationResolverFactory(db, tables, filterCtx);
   const cacheCtx = {
     genericFilterCache: /* @__PURE__ */ new Map(),
     objectTypeCache: /* @__PURE__ */ new Map(),
     relationFieldContainers: /* @__PURE__ */ new Map(),
     fullyBuiltTables: /* @__PURE__ */ new Set(),
-    relationTypeCache: /* @__PURE__ */ new Map()
+    relationTypeCache: /* @__PURE__ */ new Map(),
+    orderTypeCache: /* @__PURE__ */ new WeakMap(),
+    filterTypeCache: /* @__PURE__ */ new WeakMap(),
+    listRelationFilterCache: /* @__PURE__ */ new Map(),
+    aggregateTypeCache: /* @__PURE__ */ new Map()
   };
+  const relationAggregateFactory = features.relationAggregates ? createRelationAggregateFactory(db, tables, cacheCtx, typeNameMapper, filterCtx) : void 0;
   const queries = {};
   const mutations = {};
   const gqlSchemaTypes = Object.fromEntries(
@@ -1724,9 +3008,11 @@ function generateSchemaData2(db, schema, relations, relationsDepthLimit, prefixe
         true,
         relationsDepthLimit,
         cacheCtx,
-        singularTypes,
+        typeNameMapper,
         prefixes.insert,
-        prefixes.update
+        prefixes.update,
+        resolverFactory,
+        relationAggregateFactory
       )
     ])
   );
@@ -1735,61 +3021,138 @@ function generateSchemaData2(db, schema, relations, relationsDepthLimit, prefixe
   for (const [tableName, tableTypes] of Object.entries(gqlSchemaTypes)) {
     const { insertInput, updateInput, tableFilters, tableOrder } = tableTypes.inputs;
     const { selectSingleOutput, selectArrOutput, singleTableItemOutput, arrTableItemOutput } = tableTypes.outputs;
+    const {
+      typeName,
+      listFieldName,
+      singleFieldName,
+      aggregateFieldName,
+      createArrayFieldName,
+      createSingleFieldName,
+      upsertArrayFieldName,
+      upsertSingleFieldName,
+      updateFieldName,
+      deleteFieldName
+    } = computeResolverFieldNames(tableName, typeNameMapper, prefixes, suffixes);
     const selectArrGenerated = generateSelectArray2(
       db,
       tableName,
       tables,
-      namedRelations,
+      eagerRelations,
       tableOrder,
       tableFilters,
-      suffixes.list,
-      singularTypes
+      listFieldName,
+      typeName,
+      typeNameMapper,
+      filterCtx,
+      features.distinct
     );
     const selectSingleGenerated = generateSelectSingle2(
       db,
       tableName,
       tables,
-      namedRelations,
+      eagerRelations,
       tableOrder,
       tableFilters,
-      suffixes.single,
-      singularTypes
+      singleFieldName,
+      typeName,
+      typeNameMapper,
+      filterCtx
     );
-    const insertArrGenerated = generateInsertArray2(
+    const insertArrGenerated = features.insert ? generateInsertArray2(
       db,
       tableName,
       schema[tableName],
+      tables,
+      eagerRelations,
       insertInput,
-      prefixes.insert,
-      conflictDoNothing,
-      singularTypes
-    );
-    const insertSingleGenerated = generateInsertSingle2(
+      createArrayFieldName,
+      typeName,
+      typeNameMapper,
+      conflictDoNothing
+    ) : void 0;
+    const insertSingleGenerated = features.insert ? generateInsertSingle2(
       db,
       tableName,
       schema[tableName],
+      tables,
+      eagerRelations,
       insertInput,
-      prefixes.insert,
-      conflictDoNothing,
-      singularTypes
-    );
-    const updateGenerated = generateUpdate2(
+      createSingleFieldName,
+      typeName,
+      typeNameMapper,
+      conflictDoNothing
+    ) : void 0;
+    const uniqueSets = features.upsert ? getUniqueColumnSets(schema[tableName], getTableConfig2) : [];
+    const onConflictInput = features.upsert ? generateOnConflictInput({
+      table: schema[tableName],
+      typeName,
+      uniqueSets,
+      tableFilters,
+      withTarget: true
+    }) : void 0;
+    const upsertArrGenerated = onConflictInput ? generateUpsert2(
+      db,
+      tableName,
+      schema[tableName],
+      tables,
+      eagerRelations,
+      insertInput,
+      onConflictInput,
+      uniqueSets,
+      upsertArrayFieldName,
+      typeName,
+      false,
+      typeNameMapper,
+      filterCtx
+    ) : void 0;
+    const upsertSingleGenerated = onConflictInput ? generateUpsert2(
+      db,
+      tableName,
+      schema[tableName],
+      tables,
+      eagerRelations,
+      insertInput,
+      onConflictInput,
+      uniqueSets,
+      upsertSingleFieldName,
+      typeName,
+      true,
+      typeNameMapper,
+      filterCtx
+    ) : void 0;
+    const updateGenerated = features.update ? generateUpdate2(
       db,
       tableName,
       schema[tableName],
+      tables,
+      eagerRelations,
       updateInput,
       tableFilters,
-      prefixes.update,
-      singularTypes
-    );
-    const deleteGenerated = generateDelete2(
+      updateFieldName,
+      typeName,
+      typeNameMapper,
+      filterCtx
+    ) : void 0;
+    const deleteGenerated = features.delete ? generateDelete2(
       db,
       tableName,
       schema[tableName],
       tableFilters,
-      prefixes.delete,
-      singularTypes
-    );
+      deleteFieldName,
+      typeName,
+      filterCtx,
+      { tableName, relationMap: namedRelations, tables }
+    ) : void 0;
+    const aggregateType = features.aggregates ? generateAggregateTypes(schema[tableName], tableName, typeName, cacheCtx) : void 0;
+    const aggregateGenerated = features.aggregates ? generateAggregate(
+      db,
+      tableName,
+      schema[tableName],
+      typeName,
+      aggregateFieldName,
+      tableFilters,
+      filterCtx
+    ) : void 0;
     queries[selectArrGenerated.name] = {
       type: selectArrOutput,
       args: selectArrGenerated.args,
@@ -1800,313 +3163,410 @@ function generateSchemaData2(db, schema, relations, relationsDepthLimit, prefixe
       args: selectSingleGenerated.args,
       resolve: selectSingleGenerated.resolver
     };
-    mutations[insertArrGenerated.name] = {
-      type: arrTableItemOutput,
-      args: insertArrGenerated.args,
-      resolve: insertArrGenerated.resolver
-    };
-    mutations[insertSingleGenerated.name] = {
-      type: singleTableItemOutput,
-      args: insertSingleGenerated.args,
-      resolve: insertSingleGenerated.resolver
-    };
-    mutations[updateGenerated.name] = {
-      type: arrTableItemOutput,
-      args: updateGenerated.args,
-      resolve: updateGenerated.resolver
-    };
-    mutations[deleteGenerated.name] = {
-      type: arrTableItemOutput,
-      args: deleteGenerated.args,
-      resolve: deleteGenerated.resolver
-    };
-    [insertInput, updateInput, tableFilters, tableOrder].forEach((e) => {
+    if (aggregateGenerated && aggregateType) {
+      queries[aggregateGenerated.name] = {
+        type: new GraphQLNonNull5(aggregateType),
+        args: aggregateGenerated.args,
+        resolve: aggregateGenerated.resolver
+      };
+    }
+    if (insertArrGenerated) {
+      mutations[insertArrGenerated.name] = {
+        type: arrTableItemOutput,
+        args: insertArrGenerated.args,
+        resolve: insertArrGenerated.resolver
+      };
+    }
+    if (insertSingleGenerated) {
+      mutations[insertSingleGenerated.name] = {
+        type: singleTableItemOutput,
+        args: insertSingleGenerated.args,
+        resolve: insertSingleGenerated.resolver
+      };
+    }
+    if (upsertArrGenerated) {
+      mutations[upsertArrGenerated.name] = {
+        type: arrTableItemOutput,
+        args: upsertArrGenerated.args,
+        resolve: upsertArrGenerated.resolver
+      };
+    }
+    if (upsertSingleGenerated) {
+      mutations[upsertSingleGenerated.name] = {
+        type: singleTableItemOutput,
+        args: upsertSingleGenerated.args,
+        resolve: upsertSingleGenerated.resolver
+      };
+    }
+    if (updateGenerated) {
+      mutations[updateGenerated.name] = {
+        type: arrTableItemOutput,
+        args: updateGenerated.args,
+        resolve: updateGenerated.resolver
+      };
+    }
+    if (deleteGenerated) {
+      mutations[deleteGenerated.name] = {
+        type: arrTableItemOutput,
+        args: deleteGenerated.args,
+        resolve: deleteGenerated.resolver
+      };
+    }
+    const activeInputs = [
+      // The insert input types the upsert mutations too, so either feature keeps it.
+      ...features.insert || onConflictInput ? [insertInput] : [],
+      ...onConflictInput ? [onConflictInput] : [],
+      ...features.update ? [updateInput] : [],
+      tableFilters,
+      tableOrder
+    ];
+    activeInputs.forEach((e) => {
       inputs[e.name] = e;
     });
     outputs[selectSingleOutput.name] = selectSingleOutput;
     outputs[singleTableItemOutput.name] = singleTableItemOutput;
+    if (aggregateType) {
+      outputs[aggregateType.name] = aggregateType;
+    }
+  }
+  const fieldResolvers = {};
+  for (const [tableName, tableRelations] of Object.entries(namedRelations)) {
+    const relResolvers = {};
+    for (const [relName, relEntry] of Object.entries(tableRelations)) {
+      const isOne = is5(relEntry.relation ?? relEntry, One4);
+      const resolver = resolverFactory({ tableName, relationName: relName, relEntry, isOne });
+      if (resolver) {
+        relResolvers[relName] = resolver;
+      }
+    }
+    if (Object.keys(relResolvers).length > 0) {
+      fieldResolvers[tableName] = relResolvers;
+    }
   }
-  return { queries, mutations, inputs, types: outputs };
+  return { queries, mutations, inputs, types: outputs, fieldResolvers };
 }
 
 // src/util/builders/sqlite.ts
-import { is as is5 } from "drizzle-orm";
-import { SQLiteTable } from "drizzle-orm/sqlite-core";
+import { is as is6, One as One5 } from "drizzle-orm";
+import { getTableConfig as getTableConfig3, SQLiteTable } from "drizzle-orm/sqlite-core";
 import {
-  GraphQLError as GraphQLError5,
-  GraphQLInt as GraphQLInt5,
-  GraphQLList as GraphQLList5,
-  GraphQLNonNull as GraphQLNonNull5
+  GraphQLError as GraphQLError6,
+  GraphQLList as GraphQLList6,
+  GraphQLNonNull as GraphQLNonNull6
 } from "graphql";
-import { parseResolveInfo as parseResolveInfo3 } from "graphql-parse-resolve-info";
-var toTypeName4 = (name, singular) => singular ? capitalize(singularize(name)) : capitalize(name);
-var generateSelectArray3 = (db, tableName, tables, relationMap, orderArgs, filterArgs, listSuffix, singularTypes) => {
-  const queryEntityBase = singularTypes ? singularize(uncapitalize(tableName)) : uncapitalize(tableName);
-  const queryName = `${queryEntityBase}${listSuffix}`;
+import { parseResolveInfo as parseResolveInfo4 } from "graphql-parse-resolve-info";
+var generateSelectArray3 = (db, tableName, tables, relationMap, orderArgs, filterArgs, fieldName, typeName, typeNameMapper, filterCtx, distinctEnabled = true) => {
   const queryBase = db.query[tableName];
   if (!queryBase) {
     throw new Error(
       `Drizzle-GraphQL Error: Table ${tableName} not found in drizzle instance. Did you forget to pass schema to drizzle constructor?`
     );
   }
-  const queryArgs = {
-    offset: {
-      type: GraphQLInt5
-    },
-    limit: {
-      type: GraphQLInt5
-    },
-    orderBy: {
-      type: orderArgs
-    },
-    where: {
-      type: filterArgs
-    }
-  };
-  const typeName = toTypeName4(tableName, singularTypes);
   const table = tables[tableName];
+  const pkNames = sqlitePrimaryKeyPropNames(table);
+  const queryArgs = selectArrayArgs(
+    orderArgs,
+    filterArgs,
+    distinctEnabled ? generateDistinctEnum(table, typeName) : void 0
+  );
   return {
-    name: queryName,
-    resolver: async (_source, args, _context, info) => {
+    name: fieldName,
+    resolver: async (_source, args, context, info) => {
       try {
-        const { offset, limit, orderBy, where } = args;
-        const parsedInfo = parseResolveInfo3(info, {
-          deep: true
+        const parsedInfo = parseResolveInfo4(info, { deep: true });
+        const { executor, queryBase: requestQueryBase } = resolveQueryExecutor(db, context, tableName, queryBase);
+        return await runRelationalSelect({
+          queryBase: requestQueryBase,
+          tables,
+          tableName,
+          table,
+          relationMap,
+          typeName,
+          typeNameMapper,
+          parsedInfo,
+          ...args,
+          single: false,
+          filterCtx,
+          pkNames,
+          db: executor
         });
-        const query = queryBase.findMany({
-          columns: extractSelectedColumnsFromTree(parsedInfo.fieldsByTypeName[typeName], table),
-          offset,
-          limit,
-          // drizzle-orm v1 RQB calls orderBy with the aliased table proxy —
-          // use it directly so column refs match the CTE alias.
-          orderBy: orderBy ? (aliasedTable) => extractOrderBy(aliasedTable, orderBy) : void 0,
-          where: where ? { RAW: (aliased) => extractFilters(aliased, tableName, where) } : void 0,
-          with: relationMap[tableName] ? extractRelationsParams(relationMap, tables, tableName, parsedInfo, typeName, singularTypes) : void 0
-        });
-        const result = await query;
-        return remapToGraphQLArrayOutput(result, tableName, table, relationMap);
       } catch (e) {
-        if (e instanceof Error) {
-          throw new GraphQLError5(e.message);
-        }
-        throw e;
+        throw toGraphQLError(e);
       }
     },
     args: queryArgs
   };
 };
-var generateSelectSingle3 = (db, tableName, tables, relationMap, orderArgs, filterArgs, singleSuffix, singularTypes) => {
-  const queryEntityBase = singularTypes ? singularize(uncapitalize(tableName)) : uncapitalize(tableName);
-  const queryName = `${queryEntityBase}${singleSuffix}`;
+var generateSelectSingle3 = (db, tableName, tables, relationMap, orderArgs, filterArgs, fieldName, typeName, typeNameMapper, filterCtx) => {
   const queryBase = db.query[tableName];
   if (!queryBase) {
     throw new Error(
       `Drizzle-GraphQL Error: Table ${tableName} not found in drizzle instance. Did you forget to pass schema to drizzle constructor?`
     );
   }
-  const queryArgs = {
-    offset: {
-      type: GraphQLInt5
-    },
-    orderBy: {
-      type: orderArgs
-    },
-    where: {
-      type: filterArgs
-    }
-  };
-  const typeName = toTypeName4(tableName, singularTypes);
+  const queryArgs = selectSingleArgs(orderArgs, filterArgs);
   const table = tables[tableName];
+  const pkNames = sqlitePrimaryKeyPropNames(table);
   return {
-    name: queryName,
-    resolver: async (_source, args, _context, info) => {
+    name: fieldName,
+    resolver: async (_source, args, context, info) => {
       try {
-        const { offset, orderBy, where } = args;
-        const parsedInfo = parseResolveInfo3(info, {
-          deep: true
-        });
-        const query = queryBase.findFirst({
-          columns: extractSelectedColumnsFromTree(parsedInfo.fieldsByTypeName[typeName], table),
-          offset,
-          // drizzle-orm v1 RQB calls orderBy with the aliased table proxy —
-          // use it directly so column refs match the CTE alias.
-          orderBy: orderBy ? (aliasedTable) => extractOrderBy(aliasedTable, orderBy) : void 0,
-          where: where ? { RAW: (aliased) => extractFilters(aliased, tableName, where) } : void 0,
-          with: relationMap[tableName] ? extractRelationsParams(relationMap, tables, tableName, parsedInfo, typeName, singularTypes) : void 0
+        const parsedInfo = parseResolveInfo4(info, { deep: true });
+        const { executor, queryBase: requestQueryBase } = resolveQueryExecutor(db, context, tableName, queryBase);
+        return await runRelationalSelect({
+          queryBase: requestQueryBase,
+          tables,
+          tableName,
+          table,
+          relationMap,
+          typeName,
+          typeNameMapper,
+          parsedInfo,
+          ...args,
+          single: true,
+          filterCtx,
+          pkNames,
+          db: executor
         });
-        const result = await query;
-        if (!result) {
-          return void 0;
-        }
-        return remapToGraphQLSingleOutput(result, tableName, table, relationMap);
       } catch (e) {
-        if (e instanceof Error) {
-          throw new GraphQLError5(e.message);
-        }
-        throw e;
+        throw toGraphQLError(e);
       }
     },
     args: queryArgs
   };
 };
-var generateInsertArray3 = (db, tableName, table, baseType, singularTypes = false) => {
-  const queryName = `insertInto${capitalize(tableName)}`;
-  const typeName = toTypeName4(tableName, singularTypes);
+var sqlitePrimaryKeyPropNames = (table) => getPrimaryKeyPropNamesFromConfig(table, getTableConfig3);
+var generateInsertArray3 = (db, tableName, table, tables, relationMap, baseType, fieldName, typeName, typeNameMapper, conflictDoNothing = false) => {
   const queryArgs = {
     values: {
-      type: new GraphQLNonNull5(new GraphQLList5(new GraphQLNonNull5(baseType)))
+      type: new GraphQLNonNull6(new GraphQLList6(new GraphQLNonNull6(baseType)))
     }
   };
+  const pkNames = sqlitePrimaryKeyPropNames(table);
   return {
-    name: queryName,
-    resolver: async (_source, args, _context, info) => {
+    name: fieldName,
+    resolver: async (_source, args, context, info) => {
       try {
         const input = remapFromGraphQLArrayInput(args.values, table);
         if (!input.length) {
-          throw new GraphQLError5("No values were provided!");
+          throw new GraphQLError6("No values were provided!");
         }
-        const parsedInfo = parseResolveInfo3(info, {
+        const parsedInfo = parseResolveInfo4(info, {
           deep: true
         });
-        const columns = extractSelectedColumnsFromTreeSQLFormat(
-          parsedInfo.fieldsByTypeName[typeName],
-          table
-        );
-        const result = await db.insert(table).values(input).returning(columns).onConflictDoNothing();
-        return remapToGraphQLArrayOutput(result, tableName, table);
-      } catch (e) {
-        if (e instanceof Error) {
-          throw new GraphQLError5(e.message);
+        const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
+          relationMap,
+          tables,
+          tableName,
+          typeName,
+          typeNameMapper,
+          table,
+          pkNames,
+          parsedInfo
+        });
+        const executor = resolveExecutor(db, context);
+        let query = executor.insert(table).values(input).returning(columns);
+        if (conflictDoNothing) {
+          query = query.onConflictDoNothing();
         }
-        throw e;
+        const result = await query;
+        const enriched = hasRelations ? await eagerLoadMutationRelations(executor, tableName, result, pkNames, withParams) : result;
+        return remapToGraphQLArrayOutput(enriched, tableName, table, relationMap);
+      } catch (e) {
+        throw toGraphQLError(e);
       }
     },
     args: queryArgs
   };
 };
-var generateInsertSingle3 = (db, tableName, table, baseType, singularTypes = false) => {
-  const queryEntityBase = singularTypes ? singularize(capitalize(tableName)) : capitalize(tableName);
-  const queryName = singularTypes ? `insertInto${queryEntityBase}` : `insertInto${queryEntityBase}Single`;
-  const typeName = toTypeName4(tableName, singularTypes);
+var generateInsertSingle3 = (db, tableName, table, tables, relationMap, baseType, fieldName, typeName, typeNameMapper, conflictDoNothing = false) => {
   const queryArgs = {
     values: {
-      type: new GraphQLNonNull5(baseType)
+      type: new GraphQLNonNull6(baseType)
     }
   };
+  const pkNames = sqlitePrimaryKeyPropNames(table);
   return {
-    name: queryName,
-    resolver: async (_source, args, _context, info) => {
+    name: fieldName,
+    resolver: async (_source, args, context, info) => {
       try {
         const input = remapFromGraphQLSingleInput(args.values, table);
-        const parsedInfo = parseResolveInfo3(info, {
+        const parsedInfo = parseResolveInfo4(info, {
           deep: true
         });
-        const columns = extractSelectedColumnsFromTreeSQLFormat(
-          parsedInfo.fieldsByTypeName[typeName],
-          table
-        );
-        const result = await db.insert(table).values(input).returning(columns).onConflictDoNothing();
+        const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
+          relationMap,
+          tables,
+          tableName,
+          typeName,
+          typeNameMapper,
+          table,
+          pkNames,
+          parsedInfo
+        });
+        const executor = resolveExecutor(db, context);
+        let query = executor.insert(table).values(input).returning(columns);
+        if (conflictDoNothing) {
+          query = query.onConflictDoNothing();
+        }
+        const result = await query;
         if (!result[0]) {
           return void 0;
         }
-        return remapToGraphQLSingleOutput(result[0], tableName, table);
+        const enriched = hasRelations ? await eagerLoadMutationRelations(executor, tableName, result, pkNames, withParams) : result;
+        return remapToGraphQLSingleOutput(enriched[0], tableName, table, relationMap);
       } catch (e) {
-        if (e instanceof Error) {
-          throw new GraphQLError5(e.message);
+        throw toGraphQLError(e);
+      }
+    },
+    args: queryArgs
+  };
+};
+var generateUpsert3 = (db, tableName, table, tables, relationMap, baseType, onConflictType, uniqueSets, fieldName, typeName, single, typeNameMapper, filterCtx) => {
+  const queryArgs = {
+    values: {
+      type: single ? new GraphQLNonNull6(baseType) : new GraphQLNonNull6(new GraphQLList6(new GraphQLNonNull6(baseType)))
+    },
+    onConflict: {
+      type: onConflictType,
+      description: "How a conflicting row is resolved. Defaults to overwriting it on the primary key."
+    }
+  };
+  const pkNames = sqlitePrimaryKeyPropNames(table);
+  return {
+    name: fieldName,
+    resolver: async (_source, args, context, info) => {
+      try {
+        const input = single ? [remapFromGraphQLSingleInput(args.values, table)] : remapFromGraphQLArrayInput(args.values, table);
+        if (!input.length) {
+          throw new GraphQLError6("No values were provided!");
+        }
+        const parsedInfo = parseResolveInfo4(info, { deep: true });
+        const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
+          relationMap,
+          tables,
+          tableName,
+          typeName,
+          typeNameMapper,
+          table,
+          pkNames,
+          parsedInfo
+        });
+        const plan = resolveConflictPlan({
+          table,
+          values: input,
+          onConflict: args.onConflict,
+          pkNames,
+          uniqueSets,
+          excludedRef: excludedColumnRef,
+          withTarget: true,
+          buildWhere: (where) => extractFilters(table, tableName, where, relationFilterCtx(filterCtx, tableName))
+        });
+        const executor = resolveExecutor(db, context);
+        let query = executor.insert(table).values(input).returning(columns);
+        query = plan.action === "NOTHING" ? query.onConflictDoNothing(plan.target ? { target: plan.target } : void 0) : query.onConflictDoUpdate({ target: plan.target, set: plan.set, setWhere: plan.setWhere });
+        const result = await query;
+        if (single && !result[0]) {
+          return void 0;
         }
-        throw e;
+        const enriched = hasRelations ? await eagerLoadMutationRelations(executor, tableName, result, pkNames, withParams) : result;
+        return single ? remapToGraphQLSingleOutput(enriched[0], tableName, table, relationMap) : remapToGraphQLArrayOutput(enriched, tableName, table, relationMap);
+      } catch (e) {
+        throw toGraphQLError(e);
       }
     },
     args: queryArgs
   };
 };
-var generateUpdate3 = (db, tableName, table, setArgs, filterArgs, singularTypes = false) => {
-  const queryName = `update${capitalize(tableName)}`;
-  const typeName = toTypeName4(tableName, singularTypes);
+var generateUpdate3 = (db, tableName, table, tables, relationMap, setArgs, filterArgs, fieldName, typeName, typeNameMapper, filterCtx) => {
   const queryArgs = {
     set: {
-      type: new GraphQLNonNull5(setArgs)
+      type: new GraphQLNonNull6(setArgs)
     },
     where: {
       type: filterArgs
     }
   };
+  const pkNames = sqlitePrimaryKeyPropNames(table);
   return {
-    name: queryName,
-    resolver: async (_source, args, _context, info) => {
+    name: fieldName,
+    resolver: async (_source, args, context, info) => {
       try {
         const { where, set } = args;
-        const parsedInfo = parseResolveInfo3(info, {
+        const parsedInfo = parseResolveInfo4(info, {
           deep: true
         });
-        const columns = extractSelectedColumnsFromTreeSQLFormat(
-          parsedInfo.fieldsByTypeName[typeName],
-          table
-        );
+        const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
+          relationMap,
+          tables,
+          tableName,
+          typeName,
+          typeNameMapper,
+          table,
+          pkNames,
+          parsedInfo
+        });
         const input = remapFromGraphQLSingleInput(set, table);
         if (!Object.keys(input).length) {
-          throw new GraphQLError5("Unable to update with no values specified!");
+          throw new GraphQLError6("Unable to update with no values specified!");
         }
-        let query = db.update(table).set(input);
+        const executor = resolveExecutor(db, context);
+        let query = executor.update(table).set(input);
         if (where) {
-          const filters = extractFilters(table, tableName, where);
+          const filters = extractFilters(table, tableName, where, relationFilterCtx(filterCtx, tableName));
           query = query.where(filters);
         }
         query = query.returning(columns);
         const result = await query;
-        return remapToGraphQLArrayOutput(result, tableName, table);
+        const enriched = hasRelations ? await eagerLoadMutationRelations(executor, tableName, result, pkNames, withParams) : result;
+        return remapToGraphQLArrayOutput(enriched, tableName, table, relationMap);
       } catch (e) {
-        if (e instanceof Error) {
-          throw new GraphQLError5(e.message);
-        }
-        throw e;
+        throw toGraphQLError(e);
       }
     },
     args: queryArgs
   };
 };
-var generateDelete3 = (db, tableName, table, filterArgs, singularTypes = false) => {
-  const queryName = `deleteFrom${capitalize(tableName)}`;
-  const typeName = toTypeName4(tableName, singularTypes);
+var generateDelete3 = (db, tableName, table, filterArgs, fieldName, typeName, filterCtx, selectionCtx) => {
   const queryArgs = {
     where: {
       type: filterArgs
     }
   };
   return {
-    name: queryName,
-    resolver: async (_source, args, _context, info) => {
+    name: fieldName,
+    resolver: async (_source, args, context, info) => {
       try {
         const { where } = args;
-        const parsedInfo = parseResolveInfo3(info, {
+        const parsedInfo = parseResolveInfo4(info, {
           deep: true
         });
         const columns = extractSelectedColumnsFromTreeSQLFormat(
           parsedInfo.fieldsByTypeName[typeName],
-          table
+          table,
+          selectionCtx
         );
-        let query = db.delete(table);
+        const executor = resolveExecutor(db, context);
+        let query = executor.delete(table);
         if (where) {
-          const filters = extractFilters(table, tableName, where);
+          const filters = extractFilters(table, tableName, where, relationFilterCtx(filterCtx, tableName));
           query = query.where(filters);
         }
         query = query.returning(columns);
         const result = await query;
         return remapToGraphQLArrayOutput(result, tableName, table);
       } catch (e) {
-        if (e instanceof Error) {
-          throw new GraphQLError5(e.message);
-        }
-        throw e;
+        throw toGraphQLError(e);
       }
     },
     args: queryArgs
   };
 };
-var generateSchemaData3 = (db, schema, relations, relationsDepthLimit, prefixes, suffixes, singularTypes = false) => {
+var generateSchemaData3 = (db, schema, relations, options) => {
+  const { relationsDepthLimit, prefixes, suffixes, conflictDoNothing, typeNameMapper, shouldEagerLoad, features } = options;
   const rawSchema = schema;
   const schemaEntries = Object.entries(rawSchema);
-  const tableEntries = schemaEntries.filter(([_key, value]) => is5(value, SQLiteTable));
+  const tableEntries = schemaEntries.filter(([_key, value]) => is6(value, SQLiteTable));
   const tables = Object.fromEntries(tableEntries);
   if (!tableEntries.length) {
     throw new Error(
@@ -2114,13 +3574,22 @@ var generateSchemaData3 = (db, schema, relations, relationsDepthLimit, prefixes,
     );
   }
   const namedRelations = buildNamedRelations(relations ?? {}, tableEntries);
+  attachTargetPrimaryKeys(namedRelations, tables, sqlitePrimaryKeyPropNames);
+  const eagerRelations = pruneNonEagerRelations(namedRelations, shouldEagerLoad);
+  const filterCtx = { tables, relationMap: namedRelations };
+  const resolverFactory = createRelationResolverFactory(db, tables, filterCtx);
   const cacheCtx = {
     genericFilterCache: /* @__PURE__ */ new Map(),
     objectTypeCache: /* @__PURE__ */ new Map(),
     relationFieldContainers: /* @__PURE__ */ new Map(),
     fullyBuiltTables: /* @__PURE__ */ new Set(),
-    relationTypeCache: /* @__PURE__ */ new Map()
+    relationTypeCache: /* @__PURE__ */ new Map(),
+    orderTypeCache: /* @__PURE__ */ new WeakMap(),
+    filterTypeCache: /* @__PURE__ */ new WeakMap(),
+    listRelationFilterCache: /* @__PURE__ */ new Map(),
+    aggregateTypeCache: /* @__PURE__ */ new Map()
   };
+  const relationAggregateFactory = features.relationAggregates ? createRelationAggregateFactory(db, tables, cacheCtx, typeNameMapper, filterCtx) : void 0;
   const queries = {};
   const mutations = {};
   const gqlSchemaTypes = Object.fromEntries(
@@ -2133,9 +3602,11 @@ var generateSchemaData3 = (db, schema, relations, relationsDepthLimit, prefixes,
         true,
         relationsDepthLimit,
         cacheCtx,
-        singularTypes,
+        typeNameMapper,
         prefixes.insert,
-        prefixes.update
+        prefixes.update,
+        resolverFactory,
+        relationAggregateFactory
       )
     ])
   );
@@ -2144,55 +3615,138 @@ var generateSchemaData3 = (db, schema, relations, relationsDepthLimit, prefixes,
   for (const [tableName, tableTypes] of Object.entries(gqlSchemaTypes)) {
     const { insertInput, updateInput, tableFilters, tableOrder } = tableTypes.inputs;
     const { selectSingleOutput, selectArrOutput, singleTableItemOutput, arrTableItemOutput } = tableTypes.outputs;
+    const {
+      typeName,
+      listFieldName,
+      singleFieldName,
+      aggregateFieldName,
+      createArrayFieldName,
+      createSingleFieldName,
+      upsertArrayFieldName,
+      upsertSingleFieldName,
+      updateFieldName,
+      deleteFieldName
+    } = computeResolverFieldNames(tableName, typeNameMapper, prefixes, suffixes);
     const selectArrGenerated = generateSelectArray3(
       db,
       tableName,
       tables,
-      namedRelations,
+      eagerRelations,
       tableOrder,
       tableFilters,
-      suffixes.list,
-      singularTypes
+      listFieldName,
+      typeName,
+      typeNameMapper,
+      filterCtx,
+      features.distinct
     );
     const selectSingleGenerated = generateSelectSingle3(
       db,
       tableName,
       tables,
-      namedRelations,
+      eagerRelations,
       tableOrder,
       tableFilters,
-      suffixes.single,
-      singularTypes
+      singleFieldName,
+      typeName,
+      typeNameMapper,
+      filterCtx
     );
-    const insertArrGenerated = generateInsertArray3(
+    const insertArrGenerated = features.insert ? generateInsertArray3(
       db,
       tableName,
       schema[tableName],
+      tables,
+      eagerRelations,
       insertInput,
-      singularTypes
-    );
-    const insertSingleGenerated = generateInsertSingle3(
+      createArrayFieldName,
+      typeName,
+      typeNameMapper,
+      conflictDoNothing
+    ) : void 0;
+    const insertSingleGenerated = features.insert ? generateInsertSingle3(
+      db,
+      tableName,
+      schema[tableName],
+      tables,
+      eagerRelations,
+      insertInput,
+      createSingleFieldName,
+      typeName,
+      typeNameMapper,
+      conflictDoNothing
+    ) : void 0;
+    const uniqueSets = features.upsert ? getUniqueColumnSets(schema[tableName], getTableConfig3) : [];
+    const onConflictInput = features.upsert ? generateOnConflictInput({
+      table: schema[tableName],
+      typeName,
+      uniqueSets,
+      tableFilters,
+      withTarget: true
+    }) : void 0;
+    const upsertArrGenerated = onConflictInput ? generateUpsert3(
       db,
       tableName,
       schema[tableName],
+      tables,
+      eagerRelations,
       insertInput,
-      singularTypes
-    );
-    const updateGenerated = generateUpdate3(
+      onConflictInput,
+      uniqueSets,
+      upsertArrayFieldName,
+      typeName,
+      false,
+      typeNameMapper,
+      filterCtx
+    ) : void 0;
+    const upsertSingleGenerated = onConflictInput ? generateUpsert3(
+      db,
+      tableName,
+      schema[tableName],
+      tables,
+      eagerRelations,
+      insertInput,
+      onConflictInput,
+      uniqueSets,
+      upsertSingleFieldName,
+      typeName,
+      true,
+      typeNameMapper,
+      filterCtx
+    ) : void 0;
+    const updateGenerated = features.update ? generateUpdate3(
       db,
       tableName,
       schema[tableName],
+      tables,
+      eagerRelations,
       updateInput,
       tableFilters,
-      singularTypes
-    );
-    const deleteGenerated = generateDelete3(
+      updateFieldName,
+      typeName,
+      typeNameMapper,
+      filterCtx
+    ) : void 0;
+    const deleteGenerated = features.delete ? generateDelete3(
       db,
       tableName,
       schema[tableName],
       tableFilters,
-      singularTypes
-    );
+      deleteFieldName,
+      typeName,
+      filterCtx,
+      { tableName, relationMap: namedRelations, tables }
+    ) : void 0;
+    const aggregateType = features.aggregates ? generateAggregateTypes(schema[tableName], tableName, typeName, cacheCtx) : void 0;
+    const aggregateGenerated = features.aggregates ? generateAggregate(
+      db,
+      tableName,
+      schema[tableName],
+      typeName,
+      aggregateFieldName,
+      tableFilters,
+      filterCtx
+    ) : void 0;
     queries[selectArrGenerated.name] = {
       type: selectArrOutput,
       args: selectArrGenerated.args,
@@ -2203,33 +3757,87 @@ var generateSchemaData3 = (db, schema, relations, relationsDepthLimit, prefixes,
       args: selectSingleGenerated.args,
       resolve: selectSingleGenerated.resolver
     };
-    mutations[insertArrGenerated.name] = {
-      type: arrTableItemOutput,
-      args: insertArrGenerated.args,
-      resolve: insertArrGenerated.resolver
-    };
-    mutations[insertSingleGenerated.name] = {
-      type: singleTableItemOutput,
-      args: insertSingleGenerated.args,
-      resolve: insertSingleGenerated.resolver
-    };
-    mutations[updateGenerated.name] = {
-      type: arrTableItemOutput,
-      args: updateGenerated.args,
-      resolve: updateGenerated.resolver
-    };
-    mutations[deleteGenerated.name] = {
-      type: arrTableItemOutput,
-      args: deleteGenerated.args,
-      resolve: deleteGenerated.resolver
-    };
-    [insertInput, updateInput, tableFilters, tableOrder].forEach((e) => {
+    if (aggregateGenerated && aggregateType) {
+      queries[aggregateGenerated.name] = {
+        type: new GraphQLNonNull6(aggregateType),
+        args: aggregateGenerated.args,
+        resolve: aggregateGenerated.resolver
+      };
+    }
+    if (insertArrGenerated) {
+      mutations[insertArrGenerated.name] = {
+        type: arrTableItemOutput,
+        args: insertArrGenerated.args,
+        resolve: insertArrGenerated.resolver
+      };
+    }
+    if (insertSingleGenerated) {
+      mutations[insertSingleGenerated.name] = {
+        type: singleTableItemOutput,
+        args: insertSingleGenerated.args,
+        resolve: insertSingleGenerated.resolver
+      };
+    }
+    if (upsertArrGenerated) {
+      mutations[upsertArrGenerated.name] = {
+        type: arrTableItemOutput,
+        args: upsertArrGenerated.args,
+        resolve: upsertArrGenerated.resolver
+      };
+    }
+    if (upsertSingleGenerated) {
+      mutations[upsertSingleGenerated.name] = {
+        type: singleTableItemOutput,
+        args: upsertSingleGenerated.args,
+        resolve: upsertSingleGenerated.resolver
+      };
+    }
+    if (updateGenerated) {
+      mutations[updateGenerated.name] = {
+        type: arrTableItemOutput,
+        args: updateGenerated.args,
+        resolve: updateGenerated.resolver
+      };
+    }
+    if (deleteGenerated) {
+      mutations[deleteGenerated.name] = {
+        type: arrTableItemOutput,
+        args: deleteGenerated.args,
+        resolve: deleteGenerated.resolver
+      };
+    }
+    const activeInputs = [
+      // The insert input types the upsert mutations too, so either feature keeps it.
+      ...features.insert || onConflictInput ? [insertInput] : [],
+      ...onConflictInput ? [onConflictInput] : [],
+      ...features.update ? [updateInput] : [],
+      tableFilters,
+      tableOrder
+    ];
+    activeInputs.forEach((e) => {
       inputs[e.name] = e;
     });
     outputs[selectSingleOutput.name] = selectSingleOutput;
     outputs[singleTableItemOutput.name] = singleTableItemOutput;
+    if (aggregateType) {
+      outputs[aggregateType.name] = aggregateType;
+    }
+  }
+  const fieldResolvers = {};
+  for (const [tableName, tableRelations] of Object.entries(namedRelations)) {
+    const relResolvers = {};
+    for (const [relName, relEntry] of Object.entries(tableRelations)) {
+      const isOne = is6(relEntry.relation ?? relEntry, One5);
+      const resolver = resolverFactory({ tableName, relationName: relName, relEntry, isOne });
+      if (resolver) {
+        relResolvers[relName] = resolver;
+      }
+    }
+    if (Object.keys(relResolvers).length > 0) {
+      fieldResolvers[tableName] = relResolvers;
+    }
   }
-  return { queries, mutations, inputs, types: outputs };
+  return { queries, mutations, inputs, types: outputs, fieldResolvers };
 };
 
 // src/index.ts
@@ -2244,15 +3852,32 @@ var buildSchema = (db, config) => {
     );
   }
   const prefixes = {
-    insert: config?.prefixes?.insert ?? "insertInto",
-    delete: config?.prefixes?.delete ?? "deleteFrom",
-    update: config?.prefixes?.update ?? "update"
+    insert: config?.prefixes?.insert ?? "create",
+    delete: config?.prefixes?.delete ?? "delete",
+    update: config?.prefixes?.update ?? "update",
+    upsert: config?.prefixes?.upsert ?? "upsert"
   };
   const suffixes = {
     list: config?.suffixes?.list ?? "",
     single: config?.suffixes?.single ?? "Single"
   };
-  const singularTypes = config?.singularTypes ?? false;
+  const typeNameMapper = config?.typeNameMapper;
+  const features = {
+    aggregates: config?.features?.aggregates ?? true,
+    relationAggregates: config?.features?.relationAggregates ?? true,
+    distinct: config?.features?.distinct ?? true,
+    insert: config?.features?.insert ?? true,
+    update: config?.features?.update ?? true,
+    delete: config?.features?.delete ?? true,
+    upsert: config?.features?.upsert ?? false
+  };
+  const eagerOpt = config?.eagerLoadRelations;
+  const shouldEagerLoad = eagerOpt === void 0 || eagerOpt === true ? () => true : eagerOpt === false ? () => false : eagerOpt;
+  if (!typeNameMapper && suffixes.list === suffixes.single) {
+    throw new Error(
+      "Drizzle-GraphQL Error: List and single query suffixes cannot be the same. This would create conflicting GraphQL field names."
+    );
+  }
   if (typeof config?.relationsDepthLimit === "number") {
     if (config.relationsDepthLimit < 0) {
       throw new Error(
@@ -2264,57 +3889,41 @@ var buildSchema = (db, config) => {
         "Drizzle-GraphQL Error: config.relationsDepthLimit is supposed to be nonnegative integer or undefined!"
       );
     }
-    if (suffixes.list === suffixes.single) {
-      throw new Error(
-        "Drizzle-GraphQL Error: List and single query suffixes cannot be the same. This would create conflicting GraphQL field names."
-      );
-    }
   }
+  const generatorOptions = {
+    relationsDepthLimit: config?.relationsDepthLimit,
+    prefixes,
+    suffixes,
+    conflictDoNothing: config?.conflictDoNothing ?? false,
+    typeNameMapper,
+    shouldEagerLoad,
+    features
+  };
   let generatorOutput;
-  if (is6(db, MySqlDatabase)) {
-    generatorOutput = generateSchemaData(
-      db,
-      schema,
-      relations,
-      config?.relationsDepthLimit,
-      prefixes,
-      suffixes,
-      singularTypes
-    );
-  } else if (is6(db, PgAsyncDatabase)) {
-    generatorOutput = generateSchemaData2(
-      db,
-      schema,
-      relations,
-      config?.relationsDepthLimit,
-      prefixes,
-      suffixes,
-      config?.conflictDoNothing ?? false,
-      singularTypes
-    );
-  } else if (is6(db, BaseSQLiteDatabase)) {
-    generatorOutput = generateSchemaData3(
-      db,
-      schema,
-      relations,
-      config?.relationsDepthLimit,
-      prefixes,
-      suffixes,
-      singularTypes
-    );
+  if (is7(db, MySqlDatabase)) {
+    generatorOutput = generateSchemaData(db, schema, relations, generatorOptions);
+  } else if (is7(db, PgAsyncDatabase)) {
+    generatorOutput = generateSchemaData2(db, schema, relations, generatorOptions);
+  } else if (is7(db, BaseSQLiteDatabase)) {
+    generatorOutput = generateSchemaData3(db, schema, relations, generatorOptions);
   } else {
     throw new Error("Drizzle-GraphQL Error: Unknown database instance type");
   }
+  const onError = config?.onError;
+  applyErrorMapper(
+    generatorOutput,
+    onError ? (error) => onError(error) ?? defaultErrorMapper(error) : defaultErrorMapper
+  );
   const { queries, mutations, inputs, types } = generatorOutput;
   const graphQLSchemaConfig = {
     types: [...Object.values(inputs), ...Object.values(types)],
-    query: new GraphQLObjectType4({
+    query: new GraphQLObjectType5({
       name: "Query",
       fields: queries
     })
   };
-  if (config?.mutations !== false) {
-    const mutation = new GraphQLObjectType4({
+  if (config?.mutations !== false && Object.keys(mutations).length) {
+    const mutation = new GraphQLObjectType5({
       name: "Mutation",
       fields: mutations
     });
@@ -2324,8 +3933,17 @@ var buildSchema = (db, config) => {
   return { schema: outputSchema, entities: generatorOutput };
 };
 export {
+  GraphQLBigIntString,
+  GraphQLDate,
+  GraphQLDateTime,
+  GraphQLJSON,
+  GraphQLUUID,
   buildSchema,
+  createRelationResolverFactory,
+  defaultErrorMapper,
+  drizzleExecutorKey,
   extractFilters,
-  extractOrderBy
+  extractOrderBy,
+  extractRelationJoinColumns
 };
 //# sourceMappingURL=index.js.map