@vantreeseba/drizzle-graphql 1.0.3 → 3.0.0

package/dist/index.cjs

@@ -30,36 +30,85 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  GraphQLBigIntString: () => GraphQLBigIntString,
+  GraphQLDate: () => import_graphql_scalars.GraphQLDate,
+  GraphQLDateTime: () => import_graphql_scalars.GraphQLDateTime,
+  GraphQLJSON: () => import_graphql_scalars.GraphQLJSON,
+  GraphQLUUID: () => import_graphql_scalars.GraphQLUUID,
   buildSchema: () => buildSchema,
+  createRelationResolverFactory: () => createRelationResolverFactory,
+  defaultErrorMapper: () => defaultErrorMapper,
+  drizzleExecutorKey: () => drizzleExecutorKey,
   extractFilters: () => extractFilters,
-  extractOrderBy: () => extractOrderBy
+  extractOrderBy: () => extractOrderBy,
+  extractRelationJoinColumns: () => extractRelationJoinColumns
 });
 module.exports = __toCommonJS(index_exports);
-var import_drizzle_orm7 = require("drizzle-orm");
+var import_drizzle_orm8 = require("drizzle-orm");
 var import_mysql_core3 = require("drizzle-orm/mysql-core");
 var import_pg_core3 = require("drizzle-orm/pg-core");
 var import_sqlite_core3 = require("drizzle-orm/sqlite-core");
-var import_graphql7 = require("graphql");
-
-// src/util/builders/mysql.ts
-var import_drizzle_orm4 = require("drizzle-orm");
-var import_mysql_core2 = require("drizzle-orm/mysql-core");
-var import_graphql4 = require("graphql");
-var import_graphql_parse_resolve_info = require("graphql-parse-resolve-info");
+var import_graphql9 = require("graphql");
 
 // src/util/builders/common.ts
 var import_drizzle_orm3 = require("drizzle-orm");
-var import_graphql3 = require("graphql");
+var import_graphql4 = require("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
 var import_pluralize = __toESM(require("pluralize"), 1);
 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) => import_pluralize.default.singular(input);
 
 // src/util/data-mappers/index.ts
 var import_drizzle_orm = require("drizzle-orm");
 var import_graphql = require("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];
@@ -89,6 +138,9 @@ var remapToGraphQLCore = (key, value, tableName, column, relationMap) => {
   if (!column) {
     return value;
   }
+  if (isJsonColumn(column)) {
+    return value;
+  }
   if (value instanceof Date) {
     return value.toISOString();
   }
@@ -115,6 +167,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 && (0, import_drizzle_orm.is)(relEntry.relation, import_drizzle_orm.One)) {
+        queryOutput[key] = null;
+        continue;
+      }
       delete queryOutput[key];
       continue;
     }
@@ -161,17 +218,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 import_graphql.GraphQLError(
-        `Invalid JSON in field '${columnName}':
-${e instanceof Error ? e.message : "Unknown error"}`
-      );
-    }
+    return value;
   }
   switch (dataType) {
     case "date": {
@@ -256,15 +303,55 @@ var import_drizzle_orm2 = require("drizzle-orm");
 var import_mysql_core = require("drizzle-orm/mysql-core");
 var import_pg_core = require("drizzle-orm/pg-core");
 var import_sqlite_core = require("drizzle-orm/sqlite-core");
+var import_graphql3 = require("graphql");
+
+// src/util/scalars/index.ts
 var import_graphql2 = require("graphql");
 var import_graphql_scalars = require("graphql-scalars");
+var asDecimalString = (value) => {
+  if (typeof value === "bigint") {
+    return value.toString();
+  }
+  if (typeof value === "number") {
+    if (!Number.isInteger(value)) {
+      throw new import_graphql2.GraphQLError(`BigInt cannot represent non-integer value: ${value}`);
+    }
+    if (!Number.isSafeInteger(value)) {
+      throw new import_graphql2.GraphQLError(
+        `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 import_graphql2.GraphQLError(`BigInt cannot represent non-integer value: "${value}"`);
+    }
+    return value;
+  }
+  throw new import_graphql2.GraphQLError(`BigInt cannot represent value: ${JSON.stringify(value)}`);
+};
+var GraphQLBigIntString = new import_graphql2.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 !== import_graphql2.Kind.STRING && ast.kind !== import_graphql2.Kind.INT) {
+      throw new import_graphql2.GraphQLError(`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) => {
   if (enumMap.has(column)) {
     return enumMap.get(column);
   }
-  const gqlEnum = new import_graphql2.GraphQLEnumType({
+  const gqlEnum = new import_graphql3.GraphQLEnumType({
     name: `${capitalize(tableName)}${capitalize(columnName)}Enum`,
     values: Object.fromEntries(
       column.enumValues.map((e, index) => [
@@ -279,25 +366,25 @@ var generateEnumCached = (column, columnName, tableName) => {
   enumMap.set(column, gqlEnum);
   return gqlEnum;
 };
-var geoXyType = new import_graphql2.GraphQLObjectType({
+var geoXyType = new import_graphql3.GraphQLObjectType({
   name: "PgGeometryObject",
   fields: {
-    x: { type: import_graphql2.GraphQLFloat },
-    y: { type: import_graphql2.GraphQLFloat }
+    x: { type: import_graphql3.GraphQLFloat },
+    y: { type: import_graphql3.GraphQLFloat }
   }
 });
-var geoXyInputType = new import_graphql2.GraphQLInputObjectType({
+var geoXyInputType = new import_graphql3.GraphQLInputObjectType({
   name: "PgGeometryObjectInput",
   fields: {
-    x: { type: import_graphql2.GraphQLFloat },
-    y: { type: import_graphql2.GraphQLFloat }
+    x: { type: import_graphql3.GraphQLFloat },
+    y: { type: import_graphql3.GraphQLFloat }
   }
 });
 var columnToGraphQLCore = (column, columnName, tableName, isInput) => {
   const { type: baseType } = (0, import_drizzle_orm2.extractExtendedColumnType)(column);
   switch (baseType) {
     case "boolean":
-      return { type: import_graphql2.GraphQLBoolean, description: "Boolean" };
+      return { type: import_graphql3.GraphQLBoolean, description: "Boolean" };
     case "object":
       if (column instanceof import_pg_core.PgTimestamp || column instanceof import_pg_core.PgDate) {
         return { type: import_graphql_scalars.GraphQLDateTime, description: "DateTime" };
@@ -306,9 +393,9 @@ var columnToGraphQLCore = (column, columnName, tableName, isInput) => {
         type: isInput ? geoXyInputType : geoXyType,
         description: "Geometry points XY"
       } : column.columnType === "PgBytea" ? {
-        type: new import_graphql2.GraphQLList(new import_graphql2.GraphQLNonNull(import_graphql2.GraphQLInt)),
+        type: new import_graphql3.GraphQLList(new import_graphql3.GraphQLNonNull(import_graphql3.GraphQLInt)),
         description: "Buffer"
-      } : { type: import_graphql2.GraphQLString, description: "JSON" };
+      } : { type: import_graphql_scalars.GraphQLJSON, description: "JSON" };
     case "string":
       if (column.enumValues?.length) {
         return { type: generateEnumCached(column, columnName, tableName) };
@@ -316,34 +403,37 @@ var columnToGraphQLCore = (column, columnName, tableName, isInput) => {
       if (column instanceof import_pg_core.PgTimestamp || column instanceof import_pg_core.PgTimestampString) {
         return { type: import_graphql_scalars.GraphQLDateTime, description: "DateTime" };
       }
+      if (column instanceof import_pg_core.PgUUID) {
+        return { type: import_graphql_scalars.GraphQLUUID, description: "UUID" };
+      }
       if (column instanceof import_pg_core.PgDateString) {
-        return isInput ? { type: import_graphql2.GraphQLString, description: "Date" } : { type: import_graphql_scalars.GraphQLDate, description: "Date" };
+        return isInput ? { type: import_graphql3.GraphQLString, description: "Date" } : { type: import_graphql_scalars.GraphQLDate, description: "Date" };
       }
-      return { type: import_graphql2.GraphQLString, description: "String" };
+      return { type: import_graphql3.GraphQLString, description: "String" };
     case "bigint":
-      return { type: import_graphql2.GraphQLString, description: "BigInt" };
+      return { type: GraphQLBigIntString, description: "BigInt" };
     case "number": {
       const dims = column.dimensions;
       if (dims !== void 0 && dims > 0) {
         const baseDesc = (0, import_drizzle_orm2.is)(column, import_pg_core.PgInteger) || (0, import_drizzle_orm2.is)(column, import_pg_core.PgSerial) ? "Integer" : "Float";
-        const baseType2 = baseDesc === "Integer" ? import_graphql2.GraphQLInt : import_graphql2.GraphQLFloat;
+        const baseType2 = baseDesc === "Integer" ? import_graphql3.GraphQLInt : import_graphql3.GraphQLFloat;
         return {
-          type: new import_graphql2.GraphQLList(new import_graphql2.GraphQLNonNull(baseType2)),
+          type: new import_graphql3.GraphQLList(new import_graphql3.GraphQLNonNull(baseType2)),
           description: `Array<${baseDesc}>`
         };
       }
-      return (0, import_drizzle_orm2.is)(column, import_pg_core.PgInteger) || (0, import_drizzle_orm2.is)(column, import_pg_core.PgSerial) || (0, import_drizzle_orm2.is)(column, import_mysql_core.MySqlInt) || (0, import_drizzle_orm2.is)(column, import_mysql_core.MySqlSerial) || (0, import_drizzle_orm2.is)(column, import_sqlite_core.SQLiteInteger) ? { type: import_graphql2.GraphQLInt, description: "Integer" } : { type: import_graphql2.GraphQLFloat, description: "Float" };
+      return (0, import_drizzle_orm2.is)(column, import_pg_core.PgInteger) || (0, import_drizzle_orm2.is)(column, import_pg_core.PgSerial) || (0, import_drizzle_orm2.is)(column, import_mysql_core.MySqlInt) || (0, import_drizzle_orm2.is)(column, import_mysql_core.MySqlSerial) || (0, import_drizzle_orm2.is)(column, import_sqlite_core.SQLiteInteger) ? { type: import_graphql3.GraphQLInt, description: "Integer" } : { type: import_graphql3.GraphQLFloat, description: "Float" };
     }
     case "array": {
       if (column.columnType === "PgVector") {
         return {
-          type: new import_graphql2.GraphQLList(new import_graphql2.GraphQLNonNull(import_graphql2.GraphQLFloat)),
+          type: new import_graphql3.GraphQLList(new import_graphql3.GraphQLNonNull(import_graphql3.GraphQLFloat)),
           description: "Array<Float>"
         };
       }
       if (column.columnType === "PgGeometry") {
         return {
-          type: new import_graphql2.GraphQLList(new import_graphql2.GraphQLNonNull(import_graphql2.GraphQLFloat)),
+          type: new import_graphql3.GraphQLList(new import_graphql3.GraphQLNonNull(import_graphql3.GraphQLFloat)),
           description: "Tuple<[Float, Float]>"
         };
       }
@@ -354,7 +444,7 @@ var columnToGraphQLCore = (column, columnName, tableName, isInput) => {
         isInput
       );
       return {
-        type: new import_graphql2.GraphQLList(new import_graphql2.GraphQLNonNull(innerType.type)),
+        type: new import_graphql3.GraphQLList(new import_graphql3.GraphQLNonNull(innerType.type)),
         description: `Array<${innerType.description}>`
       };
     }
@@ -362,26 +452,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 = (0, import_drizzle_orm2.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"];
@@ -394,7 +464,7 @@ var drizzleColumnToGraphQLType = (column, columnName, tableName, forceNullable =
   }
   if (column.notNull && !(defaultIsNullable && (column.hasDefault || column.defaultFn))) {
     return {
-      type: new import_graphql2.GraphQLNonNull(typeDesc.type),
+      type: new import_graphql3.GraphQLNonNull(typeDesc.type),
       description: typeDesc.description
     };
   }
@@ -403,7 +473,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)) {
@@ -436,7 +509,172 @@ var buildNamedRelations = (relations, tableEntries) => {
   }
   return namedRelations;
 };
-var extractSelectedColumnsFromTree = (tree, 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 = (0, import_drizzle_orm3.getColumns)(parentTable);
+  const localColPropName = Object.entries(parentCols).find(([, c]) => c === sourceCol)?.[0];
+  const targetCols = (0, import_drizzle_orm3.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 = (0, import_drizzle_orm3.getColumns)(targetTable);
+  const orderExprs = [
+    ...orderByArg ? extractOrderBy(targetTable, orderByArg) : [],
+    ...primaryKeyOrderExprs(targetTable, pkNames)
+  ];
+  const orderClause = orderExprs.length ? import_drizzle_orm3.sql` order by ${import_drizzle_orm3.sql.join(orderExprs, import_drizzle_orm3.sql`, `)}` : import_drizzle_orm3.sql``;
+  const RN = "__drizzle_graphql_rn";
+  const rowNumber = import_drizzle_orm3.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 = [(0, import_drizzle_orm3.gt)(sub[RN], lower)];
+  if (limit != null) {
+    windowConds.push((0, import_drizzle_orm3.lte)(sub[RN], lower + limit));
+  }
+  const rows = await db.select().from(sub).where((0, import_drizzle_orm3.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 = (0, import_drizzle_orm3.and)(
+        (0, import_drizzle_orm3.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 = (0, import_drizzle_orm3.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 = (0, import_drizzle_orm3.getColumns)(table);
   const treeEntries = Object.entries(tree);
   const selectedColumns = [];
@@ -446,6 +684,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];
@@ -453,7 +694,7 @@ var extractSelectedColumnsFromTree = (tree, table) => {
   }
   return Object.fromEntries(selectedColumns);
 };
-var extractSelectedColumnsFromTreeSQLFormat = (tree, table) => {
+var extractSelectedColumnsFromTreeSQLFormat = (tree, table, selectionCtx) => {
   const tableColumns = (0, import_drizzle_orm3.getColumns)(table);
   const treeEntries = Object.entries(tree);
   const selectedColumns = [];
@@ -463,6 +704,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];
@@ -470,12 +714,12 @@ var extractSelectedColumnsFromTreeSQLFormat = (tree, table) => {
   }
   return Object.fromEntries(selectedColumns);
 };
-var innerOrder = new import_graphql3.GraphQLInputObjectType({
+var innerOrder = new import_graphql4.GraphQLInputObjectType({
   name: "InnerOrder",
   fields: {
     direction: {
-      type: new import_graphql3.GraphQLNonNull(
-        new import_graphql3.GraphQLEnumType({
+      type: new import_graphql4.GraphQLNonNull(
+        new import_graphql4.GraphQLEnumType({
           name: "OrderDirection",
           description: "Order by direction",
           values: {
@@ -492,7 +736,7 @@ var innerOrder = new import_graphql3.GraphQLInputObjectType({
       )
     },
     priority: {
-      type: new import_graphql3.GraphQLNonNull(import_graphql3.GraphQLInt),
+      type: new import_graphql4.GraphQLNonNull(import_graphql4.GraphQLInt),
       description: "Priority of current field"
     }
   }
@@ -501,13 +745,13 @@ var resolveGenericFilterName = (column, columnName, columnGraphQLType) => {
   if (columnName === "id" || columnName.endsWith("Id")) {
     return "Id";
   }
-  if (columnGraphQLType.type === import_graphql3.GraphQLBoolean) {
+  if (columnGraphQLType.type === import_graphql4.GraphQLBoolean) {
     return "Boolean";
   }
-  if (columnGraphQLType.type instanceof import_graphql3.GraphQLEnumType) {
+  if (columnGraphQLType.type instanceof import_graphql4.GraphQLEnumType) {
     return columnGraphQLType.type.name;
   }
-  if (columnGraphQLType.type instanceof import_graphql3.GraphQLList) {
+  if (columnGraphQLType.type instanceof import_graphql4.GraphQLList) {
     const desc2 = columnGraphQLType.description ?? "";
     return desc2.includes("Integer") ? "IntArray" : "FloatArray";
   }
@@ -526,7 +770,7 @@ var generateColumnFilterValues = (column, tableName, columnName, cacheCtx) => {
   }
   const colType = columnGraphQLType.type;
   const colDesc = columnGraphQLType.description;
-  const colArr = new import_graphql3.GraphQLList(new import_graphql3.GraphQLNonNull(colType));
+  const colArr = new import_graphql4.GraphQLList(new import_graphql4.GraphQLNonNull(colType));
   const isId = genericName === "Id";
   const baseFields = {
     eq: { type: colType, description: colDesc },
@@ -536,26 +780,26 @@ var generateColumnFilterValues = (column, tableName, columnName, cacheCtx) => {
     gt: { type: colType, description: colDesc },
     gte: { type: colType, description: colDesc },
     ...isId ? {} : {
-      like: { type: import_graphql3.GraphQLString },
-      notLike: { type: import_graphql3.GraphQLString },
-      ilike: { type: import_graphql3.GraphQLString },
-      notIlike: { type: import_graphql3.GraphQLString }
+      like: { type: import_graphql4.GraphQLString },
+      notLike: { type: import_graphql4.GraphQLString },
+      ilike: { type: import_graphql4.GraphQLString },
+      notIlike: { type: import_graphql4.GraphQLString }
     },
     inArray: { type: colArr, description: `Array<${colDesc}>` },
     notInArray: { type: colArr, description: `Array<${colDesc}>` },
-    isNull: { type: import_graphql3.GraphQLBoolean },
-    isNotNull: { type: import_graphql3.GraphQLBoolean }
+    isNull: { type: import_graphql4.GraphQLBoolean },
+    isNotNull: { type: import_graphql4.GraphQLBoolean }
   };
-  const orType = new import_graphql3.GraphQLInputObjectType({
+  const orType = new import_graphql4.GraphQLInputObjectType({
     name: `${genericName}FilterOr`,
     fields: { ...baseFields }
   });
-  const mainType = new import_graphql3.GraphQLInputObjectType({
+  const mainType = new import_graphql4.GraphQLInputObjectType({
     name: `${genericName}Filter`,
     fields: {
       ...baseFields,
       OR: {
-        type: new import_graphql3.GraphQLList(new import_graphql3.GraphQLNonNull(orType))
+        type: new import_graphql4.GraphQLList(new import_graphql4.GraphQLNonNull(orType))
       }
     }
   });
@@ -613,51 +857,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 import_graphql3.GraphQLInputObjectType({
-    name: `${toTypeName(tableName, singularTypes)}OrderBy`,
+  const order = new import_graphql4.GraphQLInputObjectType({
+    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 import_graphql3.GraphQLInputObjectType({
-    name: `${toTypeName(tableName, singularTypes)}Filters`,
-    fields: {
+  const listFilter = new import_graphql4.GraphQLInputObjectType({
+    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] = (0, import_drizzle_orm3.is)(relation, import_drizzle_orm3.One) ? {
+      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 import_graphql4.GraphQLInputObjectType({
+    name: `${resolveTypeName(tableName, typeNameMapper)}FiltersOr`,
+    fields: buildFields
+  });
+  const filters = new import_graphql4.GraphQLInputObjectType({
+    name: `${resolveTypeName(tableName, typeNameMapper)}Filters`,
+    fields: () => ({
+      ...buildFields(),
       OR: {
-        type: new import_graphql3.GraphQLList(
-          new import_graphql3.GraphQLNonNull(
-            new import_graphql3.GraphQLInputObjectType({
-              name: `${toTypeName(tableName, singularTypes)}FiltersOr`,
-              fields: filterColumns
-            })
-          )
-        )
+        type: new import_graphql4.GraphQLList(new import_graphql4.GraphQLNonNull(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,
@@ -681,8 +999,8 @@ var generateSelectFields = (tables, tableName, relationMap, fromTableName, fromR
     cacheCtx.relationFieldContainers.set(tableName, container);
   }
   if (isRootCall && !cacheCtx.objectTypeCache.has(tableName)) {
-    const typeName = toTypeName(tableName, singularTypes);
-    const shell = new import_graphql3.GraphQLObjectType({
+    const typeName = resolveTypeName(tableName, typeNameMapper);
+    const shell = new import_graphql4.GraphQLObjectType({
       name: typeName,
       fields: () => ({ ...tableFields, ...container.fields })
     });
@@ -705,10 +1023,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) {
@@ -720,12 +1041,13 @@ var generateSelectFields = (tables, tableName, relationMap, fromTableName, fromR
           cacheCtx.relationFieldContainers.set(targetTableName, targetContainer);
         }
         const capturedTargetContainer = targetContainer;
-        relType = new import_graphql3.GraphQLObjectType({
-          name: toTypeName(targetTableName, singularTypes),
+        relType = new import_graphql4.GraphQLObjectType({
+          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,
@@ -733,7 +1055,8 @@ var generateSelectFields = (tables, tableName, relationMap, fromTableName, fromR
             type: relType,
             args: {
               where: { type: relSelectData.filters }
-            }
+            },
+            resolve
           }
         ]);
         continue;
@@ -741,15 +1064,36 @@ var generateSelectFields = (tables, tableName, relationMap, fromTableName, fromR
       rawRelationFields.push([
         relationName,
         {
-          type: new import_graphql3.GraphQLNonNull(new import_graphql3.GraphQLList(new import_graphql3.GraphQLNonNull(relType))),
+          type: new import_graphql4.GraphQLNonNull(new import_graphql4.GraphQLList(new import_graphql4.GraphQLNonNull(relType))),
           args: {
             where: { type: relSelectData.filters },
             orderBy: { type: relSelectData.order },
-            offset: { type: import_graphql3.GraphQLInt },
-            limit: { type: import_graphql3.GraphQLInt }
-          }
+            offset: { type: import_graphql4.GraphQLInt },
+            limit: { type: import_graphql4.GraphQLInt }
+          },
+          resolve
         }
       ]);
+      const aggregateFieldName = `${relationName}Aggregate`;
+      if (!tableFields[aggregateFieldName] && !relationsForTable?.[aggregateFieldName]) {
+        const relationAggregate = relationAggregateFactory?.({
+          tableName,
+          relationName,
+          relEntry
+        });
+        if (relationAggregate) {
+          rawRelationFields.push([
+            aggregateFieldName,
+            {
+              type: new import_graphql4.GraphQLNonNull(relationAggregate.type),
+              args: {
+                where: { type: relSelectData.filters }
+              },
+              resolve: relationAggregate.resolve
+            }
+          ]);
+        }
+      }
     }
     const builtRelationFields = Object.fromEntries(rawRelationFields);
     if (isRootCall) {
@@ -773,7 +1117,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,
@@ -785,12 +1129,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 = (0, import_drizzle_orm3.getColumns)(table);
   const columnEntries = Object.entries(columns);
-  const _insertNested = drizzleRelationToGraphQLInsertType(tables, relationMap[tableName] ?? {});
   const insertFields = Object.fromEntries(
     columnEntries.map(([columnName, columnDescription]) => [
       columnName,
@@ -803,22 +1150,22 @@ var generateTableTypes = (tableName, tables, relationMap, withReturning, relatio
       drizzleColumnToGraphQLType(columnDescription, columnName, tableName, true, false, true)
     ])
   );
-  const insertInput = new import_graphql3.GraphQLInputObjectType({
-    name: `${capitalize(insertPrefix)}${toTypeName(tableName, singularTypes)}Input`,
+  const insertInput = new import_graphql4.GraphQLInputObjectType({
+    name: `${capitalize(insertPrefix)}${resolveTypeName(tableName, typeNameMapper)}Input`,
     fields: insertFields
   });
-  const updateInput = new import_graphql3.GraphQLInputObjectType({
-    name: `${capitalize(updatePrefix)}${toTypeName(tableName, singularTypes)}Input`,
+  const updateInput = new import_graphql4.GraphQLInputObjectType({
+    name: `${capitalize(updatePrefix)}${resolveTypeName(tableName, typeNameMapper)}Input`,
     fields: updateFields
   });
-  const selectSingleOutput = cacheCtx.objectTypeCache.get(tableName) ?? new import_graphql3.GraphQLObjectType({
-    name: toTypeName(tableName, singularTypes),
+  const selectSingleOutput = cacheCtx.objectTypeCache.get(tableName) ?? new import_graphql4.GraphQLObjectType({
+    name: resolveTypeName(tableName, typeNameMapper),
     fields: { ...tableFields, ...relationFields }
   });
-  const selectArrOutput = new import_graphql3.GraphQLNonNull(new import_graphql3.GraphQLList(new import_graphql3.GraphQLNonNull(selectSingleOutput)));
+  const selectArrOutput = new import_graphql4.GraphQLNonNull(new import_graphql4.GraphQLList(new import_graphql4.GraphQLNonNull(selectSingleOutput)));
   const arrTableItemOutput = withReturning ? (
     //     ? new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(singleTableItemOutput!)))
-    new import_graphql3.GraphQLNonNull(new import_graphql3.GraphQLList(new import_graphql3.GraphQLNonNull(selectSingleOutput)))
+    new import_graphql4.GraphQLNonNull(new import_graphql4.GraphQLList(new import_graphql4.GraphQLNonNull(selectSingleOutput)))
   ) : void 0;
   const inputs = {
     insertInput,
@@ -841,19 +1188,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" ? (0, import_drizzle_orm3.asc)((0, import_drizzle_orm3.getColumns)(table)[column]) : (0, import_drizzle_orm3.desc)((0, import_drizzle_orm3.getColumns)(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" ? (0, import_drizzle_orm3.asc)((0, import_drizzle_orm3.getColumns)(table)[column]) : (0, import_drizzle_orm3.desc)((0, import_drizzle_orm3.getColumns)(table)[column])
+);
 var extractFiltersColumn = (column, columnName, operators) => {
   if (!operators.OR?.length) {
     delete operators.OR;
@@ -861,7 +1199,7 @@ var extractFiltersColumn = (column, columnName, operators) => {
   const entries = Object.entries(operators);
   if (operators.OR) {
     if (entries.length > 1) {
-      throw new import_graphql3.GraphQLError(`WHERE ${columnName}: Cannot specify both fields and 'OR' in column operators!`);
+      throw new import_graphql4.GraphQLError(`WHERE ${columnName}: Cannot specify both fields and 'OR' in column operators!`);
     }
     const variants2 = [];
     for (const variant of operators.OR) {
@@ -872,60 +1210,93 @@ var extractFiltersColumn = (column, columnName, operators) => {
     }
     return variants2.length ? variants2.length > 1 ? (0, import_drizzle_orm3.or)(...variants2) : variants2[0] : void 0;
   }
+  const singleValueOps = { eq: import_drizzle_orm3.eq, ne: import_drizzle_orm3.ne, gt: import_drizzle_orm3.gt, gte: import_drizzle_orm3.gte, lt: import_drizzle_orm3.lt, lte: import_drizzle_orm3.lte };
+  const stringValueOps = { like: import_drizzle_orm3.like, notLike: import_drizzle_orm3.notLike, ilike: import_drizzle_orm3.ilike, notIlike: import_drizzle_orm3.notIlike };
+  const arrayValueOps = { inArray: import_drizzle_orm3.inArray, notInArray: import_drizzle_orm3.notInArray };
+  const nullableOps = { isNull: import_drizzle_orm3.isNull, isNotNull: import_drizzle_orm3.isNotNull };
   const variants = [];
   for (const [operatorName, operatorValue] of entries) {
     if (operatorValue === null || operatorValue === false) {
       continue;
     }
-    let operator;
-    switch (operatorName) {
-      case "eq":
-        operator = operator ?? import_drizzle_orm3.eq;
-      case "ne":
-        operator = operator ?? import_drizzle_orm3.ne;
-      case "gt":
-        operator = operator ?? import_drizzle_orm3.gt;
-      case "gte":
-        operator = operator ?? import_drizzle_orm3.gte;
-      case "lt":
-        operator = operator ?? import_drizzle_orm3.lt;
-      case "lte": {
-        operator = operator ?? import_drizzle_orm3.lte;
-        const singleValue = remapFromGraphQLCore(operatorValue, column, columnName);
-        variants.push(operator(column, singleValue));
-        break;
-      }
-      case "like":
-        operator = operator ?? import_drizzle_orm3.like;
-      case "notLike":
-        operator = operator ?? import_drizzle_orm3.notLike;
-      case "ilike":
-        operator = operator ?? import_drizzle_orm3.ilike;
-      case "notIlike":
-        operator = operator ?? import_drizzle_orm3.notIlike;
-        variants.push(operator(column, operatorValue));
-        break;
-      case "inArray":
-        operator = operator ?? import_drizzle_orm3.inArray;
-      case "notInArray": {
-        operator = operator ?? import_drizzle_orm3.notInArray;
-        if (!operatorValue.length) {
-          throw new import_graphql3.GraphQLError(`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 import_graphql4.GraphQLError(`WHERE ${columnName}: Unable to use operator ${operatorName} with an empty array!`);
       }
-      case "isNull":
-        operator = operator ?? import_drizzle_orm3.isNull;
-      case "isNotNull":
-        operator = operator ?? import_drizzle_orm3.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 ? (0, import_drizzle_orm3.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 import_graphql4.GraphQLError(`WHERE ${relationName}: Relation cannot be used as a filter`);
+  }
+  const parentColumns = Object.values((0, import_drizzle_orm3.getColumns)(parentTable));
+  const targetColumnsByName = Object.values((0, import_drizzle_orm3.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 import_graphql4.GraphQLError(`WHERE ${relationName}: Relation cannot be used as a filter`);
+    }
+    conditions.push((0, import_drizzle_orm3.eq)(localColumn, foreignColumn));
+  }
+  return conditions.length > 1 ? (0, import_drizzle_orm3.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 import_graphql4.GraphQLError(`WHERE ${relationName}: Relation cannot be used as a filter`);
+  }
+  ctx.aliases ??= { n: 0 };
+  const aliases = ctx.aliases;
+  const aliasedTarget = (0, import_drizzle_orm3.aliasedTable)(targetTable, `dgql_rel_${aliases.n++}`);
+  const joinCondition = buildRelationJoinCondition(parentTable, relation, aliasedTarget, relationName);
+  const relationWhere = relation.where ? (0, import_drizzle_orm3.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 import_drizzle_orm3.sql`not exists (select 1 from ${(0, import_drizzle_orm3.getTableAsAliasSQL)(aliasedTarget)} where ${(0, import_drizzle_orm3.and)(joinCondition, relationWhere, (0, import_drizzle_orm3.not)(inner))})`;
+  }
+  const condition = (0, import_drizzle_orm3.and)(joinCondition, relationWhere, inner);
+  return mode === "none" ? import_drizzle_orm3.sql`not exists (select 1 from ${(0, import_drizzle_orm3.getTableAsAliasSQL)(aliasedTarget)} where ${condition})` : import_drizzle_orm3.sql`exists (select 1 from ${(0, import_drizzle_orm3.getTableAsAliasSQL)(aliasedTarget)} where ${condition})`;
+};
+var extractRelationFilter = (parentTable, relationName, relEntry, value, ctx) => {
+  const relation = relEntry.relation ?? relEntry;
+  if ((0, import_drizzle_orm3.is)(relation, import_drizzle_orm3.One)) {
+    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 ? (0, import_drizzle_orm3.and)(...variants) : variants[0] : void 0;
 };
-var extractFilters = (table, tableName, filters) => {
+var extractFilters = (table, tableName, filters, relationCtx) => {
   if (!filters.OR?.length) {
     delete filters.OR;
   }
@@ -935,28 +1306,33 @@ var extractFilters = (table, tableName, filters) => {
   }
   if (filters.OR) {
     if (entries.length > 1) {
-      throw new import_graphql3.GraphQLError(`WHERE ${tableName}: Cannot specify both fields and 'OR' in table filters!`);
+      throw new import_graphql4.GraphQLError(`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 ? (0, import_drizzle_orm3.or)(...variants2) : variants2[0] : void 0;
   }
+  const columns = (0, import_drizzle_orm3.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 = (0, import_drizzle_orm3.getColumns)(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 ? (0, import_drizzle_orm3.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;
@@ -966,8 +1342,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;
@@ -977,7 +1354,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);
@@ -985,298 +1366,1033 @@ 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: import_graphql4.GraphQLInt
-    },
-    limit: {
-      type: import_graphql4.GraphQLInt
-    },
-    orderBy: {
-      type: orderArgs
-    },
-    where: {
-      type: filterArgs
+  return out;
+};
+var getPrimaryKeyPropNames = (table, compositePkColumnNames) => {
+  const cols = (0, import_drizzle_orm3.getColumns)(table);
+  const entries = Object.entries(cols);
+  const inlinePks = entries.filter(([, c]) => c.primary).map(([k]) => k);
+  if (inlinePks.length) {
+    return inlinePks;
+  }
+  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, limit, orderBy, where } = args;
-        const parsedInfo = (0, import_graphql_parse_resolve_info.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 import_graphql4.GraphQLError(e.message);
-        }
-        throw e;
+  }
+  return [];
+};
+var withPrimaryKeyColumns = (columns, table, pkNames) => {
+  const allCols = (0, import_drizzle_orm3.getColumns)(table);
+  for (const pk of pkNames) {
+    if (!(pk in columns) && allCols[pk]) {
+      columns[pk] = allCols[pk];
+    }
+  }
+  return columns;
+};
+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 = (0, import_drizzle_orm3.getColumns)(table);
+  return pkNames.map((n) => cols[n]).filter(Boolean).map((col) => (0, import_drizzle_orm3.asc)(col));
+};
+var getUniqueColumnSets = (table, getTableConfig4) => {
+  const cols = (0, import_drizzle_orm3.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;
       }
-    },
-    args: queryArgs
+      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 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 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 queryArgs = {
-    offset: {
-      type: import_graphql4.GraphQLInt
-    },
-    orderBy: {
-      type: orderArgs
+  const columnNames = Object.entries((0, import_drizzle_orm3.getColumns)(table)).filter(([columnName, column]) => predicate(column, columnName)).map(([columnName]) => columnName);
+  if (!columnNames.length) {
+    return void 0;
+  }
+  const enumType = new import_graphql4.GraphQLEnumType({
+    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 import_graphql4.GraphQLEnumType({
+  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."
     },
-    where: {
-      type: filterArgs
+    update: {
+      type: new import_graphql4.GraphQLList(new import_graphql4.GraphQLNonNull(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."
     }
   };
-  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 = (0, import_graphql_parse_resolve_info.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 import_graphql4.GraphQLError(e.message);
-        }
-        throw e;
-      }
-    },
-    args: queryArgs
-  };
-};
-var generateInsertArray = (db, tableName, table, baseType) => {
-  const queryName = `insertInto${capitalize(tableName)}`;
-  const queryArgs = {
-    values: {
-      type: new import_graphql4.GraphQLNonNull(new import_graphql4.GraphQLList(new import_graphql4.GraphQLNonNull(baseType)))
+  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 import_graphql4.GraphQLList(new import_graphql4.GraphQLNonNull(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 import_graphql4.GraphQLInputObjectType({
+    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 = (0, import_drizzle_orm3.getColumns)(table);
+  let target;
+  if (withTarget) {
+    const targetNames2 = onConflict?.target?.length ? onConflict.target : [...pkNames];
+    if (!targetNames2.length) {
+      throw new import_graphql4.GraphQLError(
+        "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 import_graphql4.GraphQLError(
+        `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 import_graphql4.GraphQLError(
+        `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) => import_drizzle_orm3.sql`excluded.${import_drizzle_orm3.sql.identifier(columnName)}`;
+var mysqlValuesColumnRef = (columnName) => import_drizzle_orm3.sql`values(${import_drizzle_orm3.sql.identifier(columnName)})`;
+var selectDistinctKeys = async (params) => {
+  const { db, table, tableName, distinct, pkNames, where, orderBy, limit, offset } = params;
+  const cols = (0, import_drizzle_orm3.getColumns)(table);
+  if (!pkNames.length) {
+    throw new import_graphql4.GraphQLError(`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 import_graphql4.GraphQLError(`No known columns were given to 'distinct' on ${tableName}.`);
+  }
+  const orderEntries = orderBy ? orderByEntries(orderBy) : [];
+  const windowOrder = [
+    ...orderEntries.map(([column, direction]) => direction === "asc" ? (0, import_drizzle_orm3.asc)(cols[column]) : (0, import_drizzle_orm3.desc)(cols[column])),
+    ...primaryKeyOrderExprs(table, pkNames)
+  ];
+  const rowNumber = import_drizzle_orm3.sql`row_number() over (partition by ${import_drizzle_orm3.sql.join(partitionCols, import_drizzle_orm3.sql`, `)} order by ${import_drizzle_orm3.sql.join(
+    windowOrder,
+    import_drizzle_orm3.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" ? (0, import_drizzle_orm3.asc)(sub[column]) : (0, import_drizzle_orm3.desc)(sub[column])),
+    ...pkNames.filter((name) => sub[name]).map((name) => (0, import_drizzle_orm3.asc)(sub[name]))
+  ];
+  let query = db.select(Object.fromEntries(pkNames.map((name) => [name, sub[name]]))).from(sub).where((0, import_drizzle_orm3.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 = (0, import_drizzle_orm3.getColumns)(table);
+  if (pkNames.length === 1) {
+    const name = pkNames[0];
+    return (0, import_drizzle_orm3.inArray)(
+      cols[name],
+      keys.map((key) => key[name])
+    );
+  }
+  return (0, import_drizzle_orm3.or)(...keys.map((key) => (0, import_drizzle_orm3.and)(...pkNames.map((name) => (0, import_drizzle_orm3.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 import_graphql4.GraphQLError) {
+    return e;
+  }
+  return e instanceof Error ? new import_graphql4.GraphQLError(e.message, { originalError: e }) : e;
+};
+var defaultErrorMapper = (error) => {
+  if (error instanceof import_graphql4.GraphQLError && !error.originalError) {
+    return error;
+  }
+  return new import_graphql4.GraphQLError("Internal server error", {
+    originalError: error instanceof import_graphql4.GraphQLError ? 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 {
+    typeName,
+    listFieldName,
+    singleFieldName,
+    aggregateFieldName,
+    createArrayFieldName,
+    createSingleFieldName,
+    upsertArrayFieldName,
+    upsertSingleFieldName,
+    updateFieldName,
+    deleteFieldName
+  };
+};
+var selectArrayArgs = (orderArgs, filterArgs, distinctEnum) => ({
+  offset: { type: import_graphql4.GraphQLInt },
+  limit: { type: import_graphql4.GraphQLInt },
+  orderBy: { type: orderArgs },
+  where: { type: filterArgs },
+  ...distinctEnum ? { distinct: { type: new import_graphql4.GraphQLList(new import_graphql4.GraphQLNonNull(distinctEnum)) } } : {}
+});
+var selectSingleArgs = (orderArgs, filterArgs) => ({
+  offset: { type: import_graphql4.GraphQLInt },
+  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) => (0, import_drizzle_orm3.inArray)(aliased[pkName], ids);
+  } else {
+    whereRaw = (aliased) => {
+      const lhs = import_drizzle_orm3.sql.join(
+        pkNames.map((n) => import_drizzle_orm3.sql`${aliased[n]}`),
+        import_drizzle_orm3.sql`, `
+      );
+      const tuples = import_drizzle_orm3.sql.join(
+        keyableRows.map(
+          (row) => import_drizzle_orm3.sql`(${import_drizzle_orm3.sql.join(
+            pkNames.map((n) => import_drizzle_orm3.sql`${row[n]}`),
+            import_drizzle_orm3.sql`, `
+          )})`
+        ),
+        import_drizzle_orm3.sql`, `
+      );
+      return import_drizzle_orm3.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
+var import_drizzle_orm5 = require("drizzle-orm");
+var import_mysql_core2 = require("drizzle-orm/mysql-core");
+var import_graphql6 = require("graphql");
+var import_graphql_parse_resolve_info2 = require("graphql-parse-resolve-info");
+
+// src/util/builders/aggregates.ts
+var import_drizzle_orm4 = require("drizzle-orm");
+var import_graphql5 = require("graphql");
+var import_graphql_parse_resolve_info = require("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: import_drizzle_orm4.avg,
+  sum: import_drizzle_orm4.sum,
+  min: import_drizzle_orm4.min,
+  max: import_drizzle_orm4.max,
+  countNonNull: import_drizzle_orm4.count,
+  countDistinct: import_drizzle_orm4.countDistinct
+};
+var SEP = "__";
+var classifyAggregateColumns = (table, tableName) => {
+  const numeric = {};
+  const orderable = {};
+  const all = {};
+  for (const [columnName, column] of Object.entries((0, import_drizzle_orm4.getColumns)(table))) {
+    all[columnName] = column;
+    const converted = drizzleColumnToGraphQLType(column, columnName, tableName, true, false, false);
+    const gqlType = converted.type;
+    if (gqlType instanceof import_graphql5.GraphQLList || gqlType instanceof import_graphql5.GraphQLObjectType) {
+      continue;
+    }
+    const { type: dataType, constraint } = (0, import_drizzle_orm4.extractExtendedColumnType)(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 import_graphql5.GraphQLNonNull(import_graphql5.GraphQLInt) }
+  };
+  if (Object.keys(numeric).length) {
+    for (const op of ["avg", "sum"]) {
+      fields[op] = {
+        type: new import_graphql5.GraphQLObjectType({
+          name: `${typeName}${capitalize(op)}Aggregate`,
+          fields: Object.fromEntries(Object.keys(numeric).map((columnName) => [columnName, { type: import_graphql5.GraphQLFloat }]))
+        })
+      };
+    }
+  }
+  if (Object.keys(orderable).length) {
+    for (const op of ["min", "max"]) {
+      fields[op] = {
+        type: new import_graphql5.GraphQLObjectType({
+          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 import_graphql5.GraphQLObjectType({
+        name: `${typeName}${capitalize(op)}Aggregate`,
+        fields: Object.fromEntries(
+          columnNames.map((columnName) => [columnName, { type: new import_graphql5.GraphQLNonNull(import_graphql5.GraphQLInt) }])
+        )
+      })
+    };
+  }
+  const aggregateType = new import_graphql5.GraphQLObjectType({
+    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: (0, import_drizzle_orm4.getColumns)(table),
+    dateTimeColumns: new Set(
+      Object.entries(orderable).filter(([, { converted }]) => converted.description === "DateTime").map(([columnName]) => columnName)
+    )
+  };
+};
+var parseAggregateRequest = (info, target) => {
+  const parsedInfo = (0, import_graphql_parse_resolve_info.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 = (0, import_drizzle_orm4.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 = (0, import_drizzle_orm4.and)(
+            (0, import_drizzle_orm4.inArray)(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 = (0, import_graphql_parse_resolve_info2.parseResolveInfo)(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: queryName,
-    resolver: async (_source, args, _context, _info) => {
+    name: fieldName,
+    resolver: async (_source, args, context, info) => {
+      try {
+        const parsedInfo = (0, import_graphql_parse_resolve_info2.parseResolveInfo)(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 import_graphql6.GraphQLNonNull(new import_graphql6.GraphQLList(new import_graphql6.GraphQLNonNull(baseType)))
+    }
+  };
+  return {
+    name: fieldName,
+    resolver: async (_source, args, context, _info) => {
       try {
         const input = remapFromGraphQLArrayInput(args.values, table);
         if (!input.length) {
-          throw new import_graphql4.GraphQLError("No values were provided!");
+          throw new import_graphql6.GraphQLError("No values were provided!");
         }
-        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 import_graphql4.GraphQLError(e.message);
-        }
-        throw e;
+        throw toGraphQLError(e);
       }
     },
     args: queryArgs
   };
 };
-var generateInsertSingle = (db, tableName, table, baseType) => {
-  const queryName = `insertInto${capitalize(tableName)}Single`;
+var generateInsertSingle = (db, _tableName, table, baseType, fieldName) => {
   const queryArgs = {
     values: {
-      type: new import_graphql4.GraphQLNonNull(baseType)
+      type: new import_graphql6.GraphQLNonNull(baseType)
     }
   };
   return {
-    name: queryName,
-    resolver: async (_source, args, _context, _info) => {
+    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 import_graphql4.GraphQLError(e.message);
+        throw toGraphQLError(e);
+      }
+    },
+    args: queryArgs
+  };
+};
+var generateUpsert = (db, table, baseType, onConflictType, fieldName, single) => {
+  const queryArgs = {
+    values: {
+      type: single ? new import_graphql6.GraphQLNonNull(baseType) : new import_graphql6.GraphQLNonNull(new import_graphql6.GraphQLList(new import_graphql6.GraphQLNonNull(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 import_graphql6.GraphQLError("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 import_graphql4.GraphQLNonNull(setArgs)
+      type: new import_graphql6.GraphQLNonNull(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 import_graphql4.GraphQLError("Unable to update with no values specified!");
+          throw new import_graphql6.GraphQLError("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 import_graphql4.GraphQLError(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 import_graphql4.GraphQLError(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, import_mysql_core2.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]) => (0, import_drizzle_orm4.is)(value, import_mysql_core2.MySqlTable));
+  const tableEntries = schemaEntries.filter(([_key, value]) => (0, import_drizzle_orm5.is)(value, import_mysql_core2.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(
@@ -1289,51 +2405,98 @@ var generateSchemaData = (db, schema, relations, relationsDepthLimit, prefixes,
         false,
         relationsDepthLimit,
         cacheCtx,
-        singularTypes,
+        typeNameMapper,
         prefixes.insert,
-        prefixes.update
+        prefixes.update,
+        resolverFactory,
+        relationAggregateFactory
       )
     ])
   );
-  const mutationReturnType = new import_graphql4.GraphQLObjectType({
+  const mutationReturnType = new import_graphql6.GraphQLObjectType({
     name: "MutationReturn",
     fields: {
       isSuccess: {
-        type: new import_graphql4.GraphQLNonNull(import_graphql4.GraphQLBoolean)
+        type: new import_graphql6.GraphQLNonNull(import_graphql6.GraphQLBoolean)
       }
     }
   });
   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,
@@ -1344,235 +2507,280 @@ 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 import_graphql6.GraphQLNonNull(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 = (0, import_drizzle_orm5.is)(relEntry.relation ?? relEntry, import_drizzle_orm5.One);
+      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
-var import_drizzle_orm5 = require("drizzle-orm");
+var import_drizzle_orm6 = require("drizzle-orm");
 var import_pg_core2 = require("drizzle-orm/pg-core");
-var import_graphql5 = require("graphql");
-var import_graphql_parse_resolve_info2 = require("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}`;
+var import_graphql7 = require("graphql");
+var import_graphql_parse_resolve_info3 = require("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: import_graphql5.GraphQLInt
-    },
-    limit: {
-      type: import_graphql5.GraphQLInt
-    },
-    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 = (0, import_graphql_parse_resolve_info2.parseResolveInfo)(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 = (0, import_graphql_parse_resolve_info3.parseResolveInfo)(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 import_graphql5.GraphQLError(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: import_graphql5.GraphQLInt
-    },
-    orderBy: {
-      type: orderArgs
-    },
-    where: {
-      type: filterArgs
-    }
-  };
-  const typeName = toTypeName3(tableName, singularTypes);
+  const queryArgs = selectSingleArgs(orderArgs, filterArgs);
   const table = tables[tableName];
+  const pkNames = pgPrimaryKeyPropNames(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 = (0, import_graphql_parse_resolve_info2.parseResolveInfo)(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 parsedInfo = (0, import_graphql_parse_resolve_info3.parseResolveInfo)(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 import_graphql5.GraphQLError(e.message);
+        if (orderBy) {
+          q = q.orderBy(...extractOrderBy(table, orderBy));
+        } else if (pkNames.length) {
+          q = q.orderBy(...primaryKeyOrderExprs(table, pkNames));
+        }
+        if (offset) {
+          q = q.offset(offset);
         }
-        throw e;
+        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, import_pg_core2.getTableConfig);
+var generateInsertArray2 = (db, tableName, table, tables, relationMap, baseType, fieldName, typeName, typeNameMapper, conflictDoNothing = false) => {
   const queryArgs = {
     values: {
-      type: new import_graphql5.GraphQLNonNull(new import_graphql5.GraphQLList(new import_graphql5.GraphQLNonNull(baseType)))
+      type: new import_graphql7.GraphQLNonNull(new import_graphql7.GraphQLList(new import_graphql7.GraphQLNonNull(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 import_graphql5.GraphQLError("No values were provided!");
+          throw new import_graphql7.GraphQLError("No values were provided!");
         }
-        const parsedInfo = (0, import_graphql_parse_resolve_info2.parseResolveInfo)(info, {
+        const parsedInfo = (0, import_graphql_parse_resolve_info3.parseResolveInfo)(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 import_graphql5.GraphQLError(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 import_graphql5.GraphQLNonNull(baseType)
+      type: new import_graphql7.GraphQLNonNull(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 = (0, import_graphql_parse_resolve_info2.parseResolveInfo)(info, {
+        const parsedInfo = (0, import_graphql_parse_resolve_info3.parseResolveInfo)(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();
         }
@@ -1580,103 +2788,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 import_graphql5.GraphQLError(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 import_graphql7.GraphQLNonNull(baseType) : new import_graphql7.GraphQLNonNull(new import_graphql7.GraphQLList(new import_graphql7.GraphQLNonNull(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 import_graphql7.GraphQLError("No values were provided!");
+        }
+        const parsedInfo = (0, import_graphql_parse_resolve_info3.parseResolveInfo)(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 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 import_graphql5.GraphQLNonNull(setArgs)
+      type: new import_graphql7.GraphQLNonNull(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 = (0, import_graphql_parse_resolve_info2.parseResolveInfo)(info, {
+        const parsedInfo = (0, import_graphql_parse_resolve_info3.parseResolveInfo)(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 import_graphql5.GraphQLError("Unable to update with no values specified!");
+          throw new import_graphql7.GraphQLError("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 import_graphql5.GraphQLError(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 = (0, import_graphql_parse_resolve_info2.parseResolveInfo)(info, {
+        const parsedInfo = (0, import_graphql_parse_resolve_info3.parseResolveInfo)(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 import_graphql5.GraphQLError(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]) => (0, import_drizzle_orm5.is)(value, import_pg_core2.PgTable));
+  const tableEntries = schemaEntries.filter(([_key, value]) => (0, import_drizzle_orm6.is)(value, import_pg_core2.PgTable));
   const tables = Object.fromEntries(tableEntries);
   if (!tableEntries.length) {
     throw new Error(
@@ -1684,13 +2948,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(
@@ -1703,9 +2976,11 @@ function generateSchemaData2(db, schema, relations, relationsDepthLimit, prefixe
         true,
         relationsDepthLimit,
         cacheCtx,
-        singularTypes,
+        typeNameMapper,
         prefixes.insert,
-        prefixes.update
+        prefixes.update,
+        resolverFactory,
+        relationAggregateFactory
       )
     ])
   );
@@ -1714,61 +2989,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], import_pg_core2.getTableConfig) : [];
+    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,
@@ -1779,308 +3131,406 @@ 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 import_graphql7.GraphQLNonNull(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 = (0, import_drizzle_orm6.is)(relEntry.relation ?? relEntry, import_drizzle_orm6.One);
+      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
-var import_drizzle_orm6 = require("drizzle-orm");
+var import_drizzle_orm7 = require("drizzle-orm");
 var import_sqlite_core2 = require("drizzle-orm/sqlite-core");
-var import_graphql6 = require("graphql");
-var import_graphql_parse_resolve_info3 = require("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}`;
+var import_graphql8 = require("graphql");
+var import_graphql_parse_resolve_info4 = require("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: import_graphql6.GraphQLInt
-    },
-    limit: {
-      type: import_graphql6.GraphQLInt
-    },
-    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 = (0, import_graphql_parse_resolve_info3.parseResolveInfo)(info, {
-          deep: true
+        const parsedInfo = (0, import_graphql_parse_resolve_info4.parseResolveInfo)(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 import_graphql6.GraphQLError(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: import_graphql6.GraphQLInt
-    },
-    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 = (0, import_graphql_parse_resolve_info3.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 parsedInfo = (0, import_graphql_parse_resolve_info4.parseResolveInfo)(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 import_graphql6.GraphQLError(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, import_sqlite_core2.getTableConfig);
+var generateInsertArray3 = (db, tableName, table, tables, relationMap, baseType, fieldName, typeName, typeNameMapper, conflictDoNothing = false) => {
   const queryArgs = {
     values: {
-      type: new import_graphql6.GraphQLNonNull(new import_graphql6.GraphQLList(new import_graphql6.GraphQLNonNull(baseType)))
+      type: new import_graphql8.GraphQLNonNull(new import_graphql8.GraphQLList(new import_graphql8.GraphQLNonNull(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 import_graphql6.GraphQLError("No values were provided!");
+          throw new import_graphql8.GraphQLError("No values were provided!");
         }
-        const parsedInfo = (0, import_graphql_parse_resolve_info3.parseResolveInfo)(info, {
+        const parsedInfo = (0, import_graphql_parse_resolve_info4.parseResolveInfo)(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 import_graphql6.GraphQLError(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 import_graphql6.GraphQLNonNull(baseType)
+      type: new import_graphql8.GraphQLNonNull(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 = (0, import_graphql_parse_resolve_info3.parseResolveInfo)(info, {
+        const parsedInfo = (0, import_graphql_parse_resolve_info4.parseResolveInfo)(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 import_graphql6.GraphQLError(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 import_graphql8.GraphQLNonNull(baseType) : new import_graphql8.GraphQLNonNull(new import_graphql8.GraphQLList(new import_graphql8.GraphQLNonNull(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 import_graphql8.GraphQLError("No values were provided!");
+        }
+        const parsedInfo = (0, import_graphql_parse_resolve_info4.parseResolveInfo)(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 import_graphql6.GraphQLNonNull(setArgs)
+      type: new import_graphql8.GraphQLNonNull(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 = (0, import_graphql_parse_resolve_info3.parseResolveInfo)(info, {
+        const parsedInfo = (0, import_graphql_parse_resolve_info4.parseResolveInfo)(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 import_graphql6.GraphQLError("Unable to update with no values specified!");
+          throw new import_graphql8.GraphQLError("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 import_graphql6.GraphQLError(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 = (0, import_graphql_parse_resolve_info3.parseResolveInfo)(info, {
+        const parsedInfo = (0, import_graphql_parse_resolve_info4.parseResolveInfo)(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 import_graphql6.GraphQLError(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]) => (0, import_drizzle_orm6.is)(value, import_sqlite_core2.SQLiteTable));
+  const tableEntries = schemaEntries.filter(([_key, value]) => (0, import_drizzle_orm7.is)(value, import_sqlite_core2.SQLiteTable));
   const tables = Object.fromEntries(tableEntries);
   if (!tableEntries.length) {
     throw new Error(
@@ -2088,13 +3538,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(
@@ -2107,9 +3566,11 @@ var generateSchemaData3 = (db, schema, relations, relationsDepthLimit, prefixes,
         true,
         relationsDepthLimit,
         cacheCtx,
-        singularTypes,
+        typeNameMapper,
         prefixes.insert,
-        prefixes.update
+        prefixes.update,
+        resolverFactory,
+        relationAggregateFactory
       )
     ])
   );
@@ -2118,55 +3579,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], import_sqlite_core2.getTableConfig) : [];
+    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,
@@ -2177,33 +3721,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 import_graphql8.GraphQLNonNull(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 = (0, import_drizzle_orm7.is)(relEntry.relation ?? relEntry, import_drizzle_orm7.One);
+      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
@@ -2218,15 +3816,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(
@@ -2238,69 +3853,62 @@ 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 ((0, import_drizzle_orm7.is)(db, import_mysql_core3.MySqlDatabase)) {
-    generatorOutput = generateSchemaData(
-      db,
-      schema,
-      relations,
-      config?.relationsDepthLimit,
-      prefixes,
-      suffixes,
-      singularTypes
-    );
-  } else if ((0, import_drizzle_orm7.is)(db, import_pg_core3.PgAsyncDatabase)) {
-    generatorOutput = generateSchemaData2(
-      db,
-      schema,
-      relations,
-      config?.relationsDepthLimit,
-      prefixes,
-      suffixes,
-      config?.conflictDoNothing ?? false,
-      singularTypes
-    );
-  } else if ((0, import_drizzle_orm7.is)(db, import_sqlite_core3.BaseSQLiteDatabase)) {
-    generatorOutput = generateSchemaData3(
-      db,
-      schema,
-      relations,
-      config?.relationsDepthLimit,
-      prefixes,
-      suffixes,
-      singularTypes
-    );
+  if ((0, import_drizzle_orm8.is)(db, import_mysql_core3.MySqlDatabase)) {
+    generatorOutput = generateSchemaData(db, schema, relations, generatorOptions);
+  } else if ((0, import_drizzle_orm8.is)(db, import_pg_core3.PgAsyncDatabase)) {
+    generatorOutput = generateSchemaData2(db, schema, relations, generatorOptions);
+  } else if ((0, import_drizzle_orm8.is)(db, import_sqlite_core3.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 import_graphql7.GraphQLObjectType({
+    query: new import_graphql9.GraphQLObjectType({
       name: "Query",
       fields: queries
     })
   };
-  if (config?.mutations !== false) {
-    const mutation = new import_graphql7.GraphQLObjectType({
+  if (config?.mutations !== false && Object.keys(mutations).length) {
+    const mutation = new import_graphql9.GraphQLObjectType({
       name: "Mutation",
       fields: mutations
     });
     graphQLSchemaConfig.mutation = mutation;
   }
-  const outputSchema = new import_graphql7.GraphQLSchema(graphQLSchemaConfig);
+  const outputSchema = new import_graphql9.GraphQLSchema(graphQLSchemaConfig);
   return { schema: outputSchema, entities: generatorOutput };
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  GraphQLBigIntString,
+  GraphQLDate,
+  GraphQLDateTime,
+  GraphQLJSON,
+  GraphQLUUID,
   buildSchema,
+  createRelationResolverFactory,
+  defaultErrorMapper,
+  drizzleExecutorKey,
   extractFilters,
-  extractOrderBy
+  extractOrderBy,
+  extractRelationJoinColumns
 });
 //# sourceMappingURL=index.cjs.map