@vantreeseba/drizzle-graphql 2.0.0 → 4.0.0

package/dist/index.cjs

@@ -30,28 +30,29 @@ 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,
   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");
@@ -107,6 +108,7 @@ var capitalize = (input) => input?.length ? `${input[0].toLocaleUpperCase()}${in
 // 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];
@@ -136,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();
   }
@@ -213,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": {
@@ -308,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) => [
@@ -331,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" };
@@ -358,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) };
@@ -368,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]>"
         };
       }
@@ -406,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}>`
       };
     }
@@ -426,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
     };
   }
@@ -504,6 +542,23 @@ var extractRelationJoinColumns = (relEntry, parentTable, targetTable) => {
   }
   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 = [
@@ -525,7 +580,7 @@ var batchedPaginatedRelationQuery = async (db, targetTable, foreignCol, whereCon
   }
   return rows;
 };
-var createRelationResolverFactory = (db, tables) => ({ tableName, relationName, relEntry, isOne }) => {
+var createRelationResolverFactory = (db, tables, filterCtx) => ({ tableName, relationName, relEntry, isOne }) => {
   const parentTable = tables[tableName];
   const targetTableName = relEntry.targetTableName;
   const targetTable = tables[targetTableName];
@@ -555,15 +610,16 @@ var createRelationResolverFactory = (db, tables) => ({ tableName, relationName,
     });
     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) : void 0
+        whereArg ? extractFilters(targetTable, targetTableName, whereArg, relationFilterCtx(filterCtx, targetTableName)) : void 0
       );
       let rows;
       if (limit != null || offset != null) {
         rows = await batchedPaginatedRelationQuery(
-          db,
+          executor,
           targetTable,
           foreignCol,
           whereCondition,
@@ -573,7 +629,7 @@ var createRelationResolverFactory = (db, tables) => ({ tableName, relationName,
           targetPkNames
         );
       } else {
-        let q = db.select().from(targetTable).where(whereCondition);
+        let q = executor.select().from(targetTable).where(whereCondition);
         if (orderByArg) {
           q = q.orderBy(...extractOrderBy(targetTable, orderByArg));
         }
@@ -594,7 +650,31 @@ var createRelationResolverFactory = (db, tables) => ({ tableName, relationName,
     return loader.load(localValue);
   };
 };
-var extractSelectedColumnsFromTree = (tree, table) => {
+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 = [];
@@ -604,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];
@@ -611,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 = [];
@@ -621,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];
@@ -628,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: {
@@ -650,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"
     }
   }
@@ -659,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";
   }
@@ -684,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 },
@@ -694,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))
       }
     }
   });
@@ -776,41 +862,109 @@ var generateTableOrderTypeCached = (table, tableName, typeNameMapper, cacheCtx)
     return cacheCtx.orderTypeCache.get(table);
   }
   const orderColumns = generateTableOrderCached(table);
-  const order = new import_graphql3.GraphQLInputObjectType({
+  const order = new import_graphql4.GraphQLInputObjectType({
     name: `${resolveTypeName(tableName, typeNameMapper)}OrderBy`,
     fields: orderColumns
   });
   cacheCtx.orderTypeCache.set(table, order);
   return order;
 };
-var generateTableFilterTypeCached = (table, tableName, cacheCtx, typeNameMapper) => {
+var isFilterableRelation = (relation) => !relation.through;
+var generateListRelationFilterCached = (targetTable, targetTableName, cacheCtx, typeNameMapper, relationMap, tables) => {
+  const cached = cacheCtx.listRelationFilterCache.get(targetTableName);
+  if (cached) {
+    return cached;
+  }
+  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 filterColumns = generateTableFilterValuesCached(table, tableName, cacheCtx);
-  const filters = new import_graphql3.GraphQLInputObjectType({
-    name: `${resolveTypeName(tableName, typeNameMapper)}Filters`,
-    fields: {
+  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: `${resolveTypeName(tableName, typeNameMapper)}FiltersOr`,
-              fields: filterColumns
-            })
-          )
-        )
+        type: new import_graphql4.GraphQLList(new import_graphql4.GraphQLNonNull(orFilters))
       }
-    }
+    })
   });
   cacheCtx.filterTypeCache.set(table, filters);
   return filters;
 };
-var generateSelectFields = (tables, tableName, relationMap, fromTableName, fromRelationName, withOrder, relationsDepthLimit, cacheCtx, typeNameMapper, usedTables = /* @__PURE__ */ new Set(), resolverFactory, currentDepth = 0) => {
+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, typeNameMapper, cacheCtx) : void 0;
-  const filters = generateTableFilterTypeCached(table, tableName, cacheCtx, typeNameMapper);
+  const filters = generateTableFilterTypeCached(table, tableName, cacheCtx, typeNameMapper, relationMap, tables);
   const tableFields = generateTableSelectTypeFieldsCached(table, tableName);
   const relationsForTable = relationMap[tableName];
   const relationEntries = relationsForTable ? Object.entries(relationsForTable) : [];
@@ -846,7 +1000,7 @@ var generateSelectFields = (tables, tableName, relationMap, fromTableName, fromR
   }
   if (isRootCall && !cacheCtx.objectTypeCache.has(tableName)) {
     const typeName = resolveTypeName(tableName, typeNameMapper);
-    const shell = new import_graphql3.GraphQLObjectType({
+    const shell = new import_graphql4.GraphQLObjectType({
       name: typeName,
       fields: () => ({ ...tableFields, ...container.fields })
     });
@@ -874,7 +1028,8 @@ var generateSelectFields = (tables, tableName, relationMap, fromTableName, fromR
         typeNameMapper,
         nextUsedTables,
         resolverFactory,
-        currentDepth + 1
+        currentDepth + 1,
+        relationAggregateFactory
       );
       let relType = cacheCtx.objectTypeCache.get(targetTableName);
       if (!relType) {
@@ -886,7 +1041,7 @@ var generateSelectFields = (tables, tableName, relationMap, fromTableName, fromR
           cacheCtx.relationFieldContainers.set(targetTableName, targetContainer);
         }
         const capturedTargetContainer = targetContainer;
-        relType = new import_graphql3.GraphQLObjectType({
+        relType = new import_graphql4.GraphQLObjectType({
           name: resolveTypeName(targetTableName, typeNameMapper),
           fields: () => ({ ...targetTableFields, ...capturedTargetContainer.fields })
         });
@@ -909,16 +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) {
@@ -942,7 +1117,7 @@ var generateSelectFields = (tables, tableName, relationMap, fromTableName, fromR
     relationFields: {}
   };
 };
-var generateTableTypes = (tableName, tables, relationMap, withReturning, relationsDepthLimit, cacheCtx, typeNameMapper = void 0, insertPrefix = "create", updatePrefix = "update", resolverFactory) => {
+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,
@@ -957,7 +1132,8 @@ var generateTableTypes = (tableName, tables, relationMap, withReturning, relatio
     typeNameMapper,
     /* @__PURE__ */ new Set(),
     resolverFactory,
-    0
+    0,
+    relationAggregateFactory
   );
   const table = tables[tableName];
   const columns = (0, import_drizzle_orm3.getColumns)(table);
@@ -974,22 +1150,22 @@ var generateTableTypes = (tableName, tables, relationMap, withReturning, relatio
       drizzleColumnToGraphQLType(columnDescription, columnName, tableName, true, false, true)
     ])
   );
-  const insertInput = new import_graphql3.GraphQLInputObjectType({
+  const insertInput = new import_graphql4.GraphQLInputObjectType({
     name: `${capitalize(insertPrefix)}${resolveTypeName(tableName, typeNameMapper)}Input`,
     fields: insertFields
   });
-  const updateInput = new import_graphql3.GraphQLInputObjectType({
+  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({
+  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,
@@ -1012,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;
@@ -1032,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) {
@@ -1059,7 +1226,7 @@ var extractFiltersColumn = (column, columnName, operators) => {
       variants.push(stringValueOps[operatorName](column, operatorValue));
     } else if (operatorName in arrayValueOps) {
       if (!operatorValue.length) {
-        throw new import_graphql3.GraphQLError(`WHERE ${columnName}: Unable to use operator ${operatorName} with an empty array!`);
+        throw new import_graphql4.GraphQLError(`WHERE ${columnName}: Unable to use operator ${operatorName} with an empty array!`);
       }
       const arrayValue = operatorValue.map((val) => remapFromGraphQLCore(val, column, columnName));
       variants.push(arrayValueOps[operatorName](column, arrayValue));
@@ -1069,7 +1236,67 @@ var extractFiltersColumn = (column, columnName, operators) => {
   }
   return variants.length ? variants.length > 1 ? (0, import_drizzle_orm3.and)(...variants) : variants[0] : void 0;
 };
-var extractFilters = (table, tableName, filters) => {
+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, relationCtx) => {
   if (!filters.OR?.length) {
     delete filters.OR;
   }
@@ -1079,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, typeNameMapper, _isInitial = false) => {
+var extractRelationsParamsInner = (relationMap, tables, tableName, typeName, originField, typeNameMapper, _isInitial = false, filterCtx) => {
   const relationsForTable = relationMap[tableName];
   if (!relationsForTable) {
     return void 0;
@@ -1122,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);
@@ -1130,23 +1366,34 @@ 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.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 ? (aliasedTable) => extractOrderBy(aliasedTable, relationArgs.orderBy) : hasPagination && pkNames.length ? (aliasedTable) => primaryKeyOrderExprs(aliasedTable, pkNames) : void 0;
+    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, typeNameMapper) : 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, typeNameMapper) => {
+var extractRelationsParams = (relationMap, tables, tableName, info, typeName, typeNameMapper, filterCtx) => {
   if (!info) {
     return void 0;
   }
-  return extractRelationsParamsInner(relationMap, tables, tableName, typeName, info, typeNameMapper, true);
+  return extractRelationsParamsInner(relationMap, tables, tableName, typeName, info, typeNameMapper, true, filterCtx);
 };
 var pruneNonEagerRelations = (relationMap, shouldEagerLoad) => {
   const out = {};
@@ -1190,42 +1437,310 @@ 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;
+      }
+      propNames.push(propName);
+    }
+    return propNames.length ? propNames : void 0;
+  };
+  const config = getTableConfig4(table);
+  const candidates = [
+    // Inline `.primaryKey()` columns, then table-level `primaryKey({ columns })`.
+    Object.entries(cols).filter(([, col]) => col.primary).map(([propName]) => propName),
+    ...config.primaryKeys.map((pk) => toPropNames(pk.columns.map((c) => c.name))),
+    ...(config.uniqueConstraints ?? []).map((uc) => toPropNames(uc.columns.map((c) => c.name))),
+    ...(config.indexes ?? []).filter((index) => index.config.unique).map((index) => toPropNames(index.config.columns.map((c) => c?.name))),
+    ...Object.entries(cols).filter(([, col]) => col.isUnique).map(([propName]) => [propName])
+  ];
+  const seen = /* @__PURE__ */ new Set();
+  const sets = [];
+  for (const set of candidates) {
+    if (!set?.length) {
+      continue;
+    }
+    const key = [...set].sort().join(",");
+    if (seen.has(key)) {
+      continue;
+    }
+    seen.add(key);
+    sets.push(set);
+  }
+  return sets;
+};
+var DISTINCT_RN = "__drizzle_graphql_distinct_rn";
+var columnEnumCache = /* @__PURE__ */ new WeakMap();
+var generateColumnEnum = (table, enumName, description, predicate = () => true) => {
+  let tableCache = columnEnumCache.get(table);
+  const cached = tableCache?.get(enumName);
+  if (cached) {
+    return cached;
+  }
+  const columnNames = Object.entries((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."
+    },
+    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."
+    }
+  };
+  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);
+  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) => e instanceof Error ? new import_graphql3.GraphQLError(e.message) : e;
+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) => ({
-  offset: { type: import_graphql3.GraphQLInt },
-  limit: { type: import_graphql3.GraphQLInt },
+var selectArrayArgs = (orderArgs, filterArgs, distinctEnum) => ({
+  offset: { type: import_graphql4.GraphQLInt },
+  limit: { type: import_graphql4.GraphQLInt },
   orderBy: { type: orderArgs },
-  where: { type: filterArgs }
+  where: { type: filterArgs },
+  ...distinctEnum ? { distinct: { type: new import_graphql4.GraphQLList(new import_graphql4.GraphQLNonNull(distinctEnum)) } } : {}
 });
 var selectSingleArgs = (orderArgs, filterArgs) => ({
-  offset: { type: import_graphql3.GraphQLInt },
+  offset: { type: import_graphql4.GraphQLInt },
   orderBy: { type: orderArgs },
   where: { type: filterArgs }
 });
@@ -1242,22 +1757,52 @@ var runRelationalSelect = async (opts) => {
     offset,
     orderBy,
     where,
-    single
+    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),
-    offset,
+    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: orderBy ? (aliasedTable) => extractOrderBy(aliasedTable, orderBy) : void 0,
-    where: where ? { RAW: (aliasedTable) => extractFilters(aliasedTable, tableName, where) } : void 0,
-    with: relationMap[tableName] ? extractRelationsParams(relationMap, tables, tableName, parsedInfo, typeName, typeNameMapper) : void 0
+    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 = opts.limit;
+  params.limit = distinctKeys ? void 0 : opts.limit;
   const result = await queryBase.findMany(params);
   return remapToGraphQLArrayOutput(result, tableName, table, relationMap);
 };
@@ -1330,55 +1875,331 @@ var eagerLoadMutationRelations = async (db, tableName, rows, pkNames, withParams
 };
 
 // src/util/builders/mysql.ts
-var generateSelectArray = (db, tableName, tables, relationMap, orderArgs, filterArgs, fieldName, typeName, typeNameMapper) => {
-  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 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;
+    }
   }
-  const queryArgs = selectArrayArgs(orderArgs, filterArgs);
-  const table = tables[tableName];
-  return {
-    name: fieldName,
-    resolver: async (_source, args, _context, info) => {
-      try {
-        const parsedInfo = (0, import_graphql_parse_resolve_info.parseResolveInfo)(info, { deep: true });
-        return await runRelationalSelect({
-          queryBase,
-          tables,
-          tableName,
-          table,
-          relationMap,
-          typeName,
-          typeNameMapper,
-          parsedInfo,
-          ...args,
-          single: false
-        });
-      } catch (e) {
-        throw toGraphQLError(e);
-      }
-    },
-    args: queryArgs
-  };
+  return { numeric, orderable, all };
 };
-var generateSelectSingle = (db, tableName, tables, relationMap, orderArgs, filterArgs, fieldName, typeName, typeNameMapper) => {
-  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 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: fieldName,
-    resolver: async (_source, args, _context, info) => {
+    resolver: async (_source, args, context, info) => {
       try {
-        const parsedInfo = (0, import_graphql_parse_resolve_info.parseResolveInfo)(info, { deep: true });
+        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,
+          queryBase: requestQueryBase,
           tables,
           tableName,
           table,
@@ -1387,7 +2208,10 @@ var generateSelectSingle = (db, tableName, tables, relationMap, orderArgs, filte
           typeNameMapper,
           parsedInfo,
           ...args,
-          single: true
+          single: true,
+          filterCtx,
+          pkNames,
+          db: executor
         });
       } catch (e) {
         throw toGraphQLError(e);
@@ -1399,18 +2223,18 @@ var generateSelectSingle = (db, tableName, tables, relationMap, orderArgs, filte
 var generateInsertArray = (db, _tableName, table, baseType, fieldName) => {
   const queryArgs = {
     values: {
-      type: new import_graphql4.GraphQLNonNull(new import_graphql4.GraphQLList(new import_graphql4.GraphQLNonNull(baseType)))
+      type: new import_graphql6.GraphQLNonNull(new import_graphql6.GraphQLList(new import_graphql6.GraphQLNonNull(baseType)))
     }
   };
   return {
     name: fieldName,
-    resolver: async (_source, args, _context, _info) => {
+    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) {
         throw toGraphQLError(e);
@@ -1422,15 +2246,57 @@ var generateInsertArray = (db, _tableName, table, baseType, fieldName) => {
 var generateInsertSingle = (db, _tableName, table, baseType, fieldName) => {
   const queryArgs = {
     values: {
-      type: new import_graphql4.GraphQLNonNull(baseType)
+      type: new import_graphql6.GraphQLNonNull(baseType)
     }
   };
   return {
     name: fieldName,
-    resolver: async (_source, args, _context, _info) => {
+    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) {
+        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!");
+        }
+        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);
@@ -1439,10 +2305,10 @@ var generateInsertSingle = (db, _tableName, table, baseType, fieldName) => {
     args: queryArgs
   };
 };
-var generateUpdate = (db, tableName, table, setArgs, filterArgs, fieldName) => {
+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
@@ -1450,16 +2316,17 @@ var generateUpdate = (db, tableName, table, setArgs, filterArgs, fieldName) => {
   };
   return {
     name: fieldName,
-    resolver: async (_source, args, _context, _info) => {
+    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;
@@ -1471,7 +2338,7 @@ var generateUpdate = (db, tableName, table, setArgs, filterArgs, fieldName) => {
     args: queryArgs
   };
 };
-var generateDelete = (db, tableName, table, filterArgs, fieldName) => {
+var generateDelete = (db, tableName, table, filterArgs, fieldName, filterCtx) => {
   const queryArgs = {
     where: {
       type: filterArgs
@@ -1479,12 +2346,13 @@ var generateDelete = (db, tableName, table, filterArgs, fieldName) => {
   };
   return {
     name: fieldName,
-    resolver: async (_source, args, _context, _info) => {
+    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;
@@ -1497,10 +2365,11 @@ var generateDelete = (db, tableName, table, filterArgs, fieldName) => {
   };
 };
 var mysqlPrimaryKeyPropNames = (table) => getPrimaryKeyPropNamesFromConfig(table, import_mysql_core2.getTableConfig);
-var generateSchemaData = (db, schema, relations, relationsDepthLimit, prefixes, suffixes, typeNameMapper, shouldEagerLoad = () => true) => {
+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(
@@ -1510,7 +2379,8 @@ var generateSchemaData = (db, schema, relations, relationsDepthLimit, prefixes,
   const namedRelations = buildNamedRelations(relations ?? {}, tableEntries);
   attachTargetPrimaryKeys(namedRelations, tables, mysqlPrimaryKeyPropNames);
   const eagerRelations = pruneNonEagerRelations(namedRelations, shouldEagerLoad);
-  const resolverFactory = createRelationResolverFactory(db, tables);
+  const filterCtx = { tables, relationMap: namedRelations };
+  const resolverFactory = createRelationResolverFactory(db, tables, filterCtx);
   const cacheCtx = {
     genericFilterCache: /* @__PURE__ */ new Map(),
     objectTypeCache: /* @__PURE__ */ new Map(),
@@ -1518,8 +2388,11 @@ var generateSchemaData = (db, schema, relations, relationsDepthLimit, prefixes,
     fullyBuiltTables: /* @__PURE__ */ new Set(),
     relationTypeCache: /* @__PURE__ */ new Map(),
     orderTypeCache: /* @__PURE__ */ new WeakMap(),
-    filterTypeCache: /* @__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(
@@ -1535,22 +2408,24 @@ var generateSchemaData = (db, schema, relations, relationsDepthLimit, prefixes,
         typeNameMapper,
         prefixes.insert,
         prefixes.update,
-        resolverFactory
+        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;
@@ -1558,8 +2433,11 @@ var generateSchemaData = (db, schema, relations, relationsDepthLimit, prefixes,
       typeName,
       listFieldName,
       singleFieldName,
+      aggregateFieldName,
       createArrayFieldName,
       createSingleFieldName,
+      upsertArrayFieldName,
+      upsertSingleFieldName,
       updateFieldName,
       deleteFieldName
     } = computeResolverFieldNames(tableName, typeNameMapper, prefixes, suffixes);
@@ -1572,7 +2450,9 @@ var generateSchemaData = (db, schema, relations, relationsDepthLimit, prefixes,
       tableFilters,
       listFieldName,
       typeName,
-      typeNameMapper
+      typeNameMapper,
+      filterCtx,
+      features.distinct
     );
     const selectSingleGenerated = generateSelectSingle(
       db,
@@ -1583,37 +2463,40 @@ var generateSchemaData = (db, schema, relations, relationsDepthLimit, prefixes,
       tableFilters,
       singleFieldName,
       typeName,
-      typeNameMapper
-    );
-    const insertArrGenerated = generateInsertArray(
-      db,
-      tableName,
-      schema[tableName],
-      insertInput,
-      createArrayFieldName
-    );
-    const insertSingleGenerated = generateInsertSingle(
-      db,
-      tableName,
-      schema[tableName],
-      insertInput,
-      createSingleFieldName
+      typeNameMapper,
+      filterCtx
     );
-    const updateGenerated = generateUpdate(
+    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
-    );
-    const deleteGenerated = generateDelete(
+      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,
-      deleteFieldName
-    );
+      filterCtx
+    ) : void 0;
     queries[selectArrGenerated.name] = {
       type: selectArrOutput,
       args: selectArrGenerated.args,
@@ -1624,36 +2507,50 @@ 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_orm4.is)(relEntry.relation ?? relEntry, import_drizzle_orm4.One);
+      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;
@@ -1667,22 +2564,28 @@ var generateSchemaData = (db, schema, relations, relationsDepthLimit, prefixes,
 };
 
 // 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 generateSelectArray2 = (db, tableName, tables, relationMap, orderArgs, filterArgs, fieldName, typeName, typeNameMapper) => {
+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 = selectArrayArgs(orderArgs, filterArgs);
   const table = tables[tableName];
+  const pkNames = pgPrimaryKeyPropNames(table);
+  const queryArgs = selectArrayArgs(
+    orderArgs,
+    filterArgs,
+    distinctEnabled ? generateDistinctEnum(table, typeName) : void 0
+  );
   return {
     name: fieldName,
-    resolver: async (_source, args, _context, info) => {
+    resolver: async (_source, args, context, info) => {
       try {
-        const parsedInfo = (0, import_graphql_parse_resolve_info2.parseResolveInfo)(info, { deep: true });
-        if (queryBase) {
+        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,
+            queryBase: requestQueryBase,
             tables,
             tableName,
             table,
@@ -1691,26 +2594,57 @@ var generateSelectArray2 = (db, tableName, tables, relationMap, orderArgs, filte
             typeNameMapper,
             parsedInfo,
             ...args,
-            single: false
+            single: false,
+            filterCtx,
+            pkNames,
+            db: executor
           });
         }
-        const { offset, limit, orderBy, where } = args;
+        const { offset, limit, orderBy, where, distinct } = args;
         const selectedColumnsSql = extractSelectedColumnsFromTreeSQLFormat(
           parsedInfo.fieldsByTypeName[typeName],
-          table
+          table,
+          { tableName, relationMap, tables }
         );
-        let q = db.select(selectedColumnsSql).from(table);
-        if (where) {
-          q = q.where(extractFilters(table, tableName, where));
+        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,
+            offset
+          });
+          if (!distinctKeys.length) {
+            return [];
+          }
         }
-        if (orderBy) {
-          q = q.orderBy(...extractOrderBy(table, orderBy));
+        let q = executor.select(selectedColumnsSql).from(table);
+        if (distinctKeys) {
+          q = q.where(primaryKeyRestriction(table, pkNames, distinctKeys));
+        } else if (whereSql) {
+          q = q.where(whereSql);
         }
-        if (offset) {
-          q = q.offset(offset);
+        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 (limit) {
-          q = q.limit(limit);
+        if (!distinctKeys) {
+          if (offset) {
+            q = q.offset(offset);
+          }
+          if (limit) {
+            q = q.limit(limit);
+          }
         }
         return remapToGraphQLArrayOutput(await q, tableName, table, relationMap);
       } catch (e) {
@@ -1720,18 +2654,20 @@ var generateSelectArray2 = (db, tableName, tables, relationMap, orderArgs, filte
     args: queryArgs
   };
 };
-var generateSelectSingle2 = (db, tableName, tables, relationMap, orderArgs, filterArgs, fieldName, typeName, typeNameMapper) => {
+var generateSelectSingle2 = (db, tableName, tables, relationMap, orderArgs, filterArgs, fieldName, typeName, typeNameMapper, filterCtx) => {
   const queryBase = db.query[tableName];
   const queryArgs = selectSingleArgs(orderArgs, filterArgs);
   const table = tables[tableName];
+  const pkNames = pgPrimaryKeyPropNames(table);
   return {
     name: fieldName,
-    resolver: async (_source, args, _context, info) => {
+    resolver: async (_source, args, context, info) => {
       try {
-        const parsedInfo = (0, import_graphql_parse_resolve_info2.parseResolveInfo)(info, { deep: true });
-        if (queryBase) {
+        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,
+            queryBase: requestQueryBase,
             tables,
             tableName,
             table,
@@ -1740,20 +2676,26 @@ var generateSelectSingle2 = (db, tableName, tables, relationMap, orderArgs, filt
             typeNameMapper,
             parsedInfo,
             ...args,
-            single: true
+            single: true,
+            filterCtx,
+            pkNames,
+            db: executor
           });
         }
         const { offset, orderBy, where } = args;
         const selectedColumnsSql = extractSelectedColumnsFromTreeSQLFormat(
           parsedInfo.fieldsByTypeName[typeName],
-          table
+          table,
+          { tableName, relationMap, tables }
         );
-        let q = db.select(selectedColumnsSql).from(table);
+        let q = executor.select(selectedColumnsSql).from(table);
         if (where) {
-          q = q.where(extractFilters(table, tableName, where));
+          q = q.where(extractFilters(table, tableName, where, relationFilterCtx(filterCtx, tableName)));
         }
         if (orderBy) {
           q = q.orderBy(...extractOrderBy(table, orderBy));
+        } else if (pkNames.length) {
+          q = q.orderBy(...primaryKeyOrderExprs(table, pkNames));
         }
         if (offset) {
           q = q.offset(offset);
@@ -1772,19 +2714,19 @@ var pgPrimaryKeyPropNames = (table) => getPrimaryKeyPropNamesFromConfig(table, i
 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: fieldName,
-    resolver: async (_source, args, _context, info) => {
+    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, hasRelations, withParams } = prepareMutationRelationColumns({
@@ -1797,12 +2739,13 @@ var generateInsertArray2 = (db, tableName, table, tables, relationMap, baseType,
           pkNames,
           parsedInfo
         });
-        let query = db.insert(table).values(input).returning(columns);
+        const executor = resolveExecutor(db, context);
+        let query = executor.insert(table).values(input).returning(columns);
         if (conflictDoNothing) {
           query = query.onConflictDoNothing();
         }
         const result = await query;
-        const enriched = hasRelations ? await eagerLoadMutationRelations(db, tableName, result, pkNames, withParams) : result;
+        const enriched = hasRelations ? await eagerLoadMutationRelations(executor, tableName, result, pkNames, withParams) : result;
         return remapToGraphQLArrayOutput(enriched, tableName, table, relationMap);
       } catch (e) {
         throw toGraphQLError(e);
@@ -1814,16 +2757,16 @@ var generateInsertArray2 = (db, tableName, table, tables, relationMap, baseType,
 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: fieldName,
-    resolver: async (_source, args, _context, info) => {
+    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, hasRelations, withParams } = prepareMutationRelationColumns({
@@ -1836,7 +2779,8 @@ var generateInsertSingle2 = (db, tableName, table, tables, relationMap, baseType
           pkNames,
           parsedInfo
         });
-        let query = db.insert(table).values(input).returning(columns);
+        const executor = resolveExecutor(db, context);
+        let query = executor.insert(table).values(input).returning(columns);
         if (conflictDoNothing) {
           query = query.onConflictDoNothing();
         }
@@ -1844,7 +2788,7 @@ var generateInsertSingle2 = (db, tableName, table, tables, relationMap, baseType
         if (!result[0]) {
           return void 0;
         }
-        const enriched = hasRelations ? await eagerLoadMutationRelations(db, tableName, result, pkNames, withParams) : result;
+        const enriched = hasRelations ? await eagerLoadMutationRelations(executor, tableName, result, pkNames, withParams) : result;
         return remapToGraphQLSingleOutput(enriched[0], tableName, table, relationMap);
       } catch (e) {
         throw toGraphQLError(e);
@@ -1853,10 +2797,66 @@ var generateInsertSingle2 = (db, tableName, table, tables, relationMap, baseType
     args: queryArgs
   };
 };
-var generateUpdate2 = (db, tableName, table, tables, relationMap, setArgs, filterArgs, fieldName, typeName, typeNameMapper) => {
+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;
+        }
+        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, 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
@@ -1865,10 +2865,10 @@ var generateUpdate2 = (db, tableName, table, tables, relationMap, setArgs, filte
   const pkNames = pgPrimaryKeyPropNames(table);
   return {
     name: fieldName,
-    resolver: async (_source, args, _context, info) => {
+    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, hasRelations, withParams } = prepareMutationRelationColumns({
@@ -1883,16 +2883,17 @@ var generateUpdate2 = (db, tableName, table, tables, relationMap, setArgs, filte
         });
         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;
-        const enriched = hasRelations ? await eagerLoadMutationRelations(db, tableName, result, pkNames, withParams) : result;
+        const enriched = hasRelations ? await eagerLoadMutationRelations(executor, tableName, result, pkNames, withParams) : result;
         return remapToGraphQLArrayOutput(enriched, tableName, table, relationMap);
       } catch (e) {
         throw toGraphQLError(e);
@@ -1901,7 +2902,7 @@ var generateUpdate2 = (db, tableName, table, tables, relationMap, setArgs, filte
     args: queryArgs
   };
 };
-var generateDelete2 = (db, tableName, table, filterArgs, fieldName, typeName) => {
+var generateDelete2 = (db, tableName, table, filterArgs, fieldName, typeName, filterCtx, selectionCtx) => {
   const queryArgs = {
     where: {
       type: filterArgs
@@ -1909,19 +2910,21 @@ var generateDelete2 = (db, tableName, table, filterArgs, fieldName, typeName) =>
   };
   return {
     name: fieldName,
-    resolver: async (_source, args, _context, info) => {
+    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);
@@ -1934,9 +2937,10 @@ var generateDelete2 = (db, tableName, table, filterArgs, fieldName, typeName) =>
     args: queryArgs
   };
 };
-function generateSchemaData2(db, schema, relations, relationsDepthLimit, prefixes, suffixes, conflictDoNothing = false, typeNameMapper, shouldEagerLoad = () => true) {
+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(
@@ -1946,7 +2950,8 @@ function generateSchemaData2(db, schema, relations, relationsDepthLimit, prefixe
   const namedRelations = buildNamedRelations(relations ?? {}, tableEntries);
   attachTargetPrimaryKeys(namedRelations, tables, pgPrimaryKeyPropNames);
   const eagerRelations = pruneNonEagerRelations(namedRelations, shouldEagerLoad);
-  const resolverFactory = createRelationResolverFactory(db, tables);
+  const filterCtx = { tables, relationMap: namedRelations };
+  const resolverFactory = createRelationResolverFactory(db, tables, filterCtx);
   const cacheCtx = {
     genericFilterCache: /* @__PURE__ */ new Map(),
     objectTypeCache: /* @__PURE__ */ new Map(),
@@ -1954,8 +2959,11 @@ function generateSchemaData2(db, schema, relations, relationsDepthLimit, prefixe
     fullyBuiltTables: /* @__PURE__ */ new Set(),
     relationTypeCache: /* @__PURE__ */ new Map(),
     orderTypeCache: /* @__PURE__ */ new WeakMap(),
-    filterTypeCache: /* @__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(
@@ -1971,7 +2979,8 @@ function generateSchemaData2(db, schema, relations, relationsDepthLimit, prefixe
         typeNameMapper,
         prefixes.insert,
         prefixes.update,
-        resolverFactory
+        resolverFactory,
+        relationAggregateFactory
       )
     ])
   );
@@ -1984,8 +2993,11 @@ function generateSchemaData2(db, schema, relations, relationsDepthLimit, prefixe
       typeName,
       listFieldName,
       singleFieldName,
+      aggregateFieldName,
       createArrayFieldName,
       createSingleFieldName,
+      upsertArrayFieldName,
+      upsertSingleFieldName,
       updateFieldName,
       deleteFieldName
     } = computeResolverFieldNames(tableName, typeNameMapper, prefixes, suffixes);
@@ -1998,7 +3010,9 @@ function generateSchemaData2(db, schema, relations, relationsDepthLimit, prefixe
       tableFilters,
       listFieldName,
       typeName,
-      typeNameMapper
+      typeNameMapper,
+      filterCtx,
+      features.distinct
     );
     const selectSingleGenerated = generateSelectSingle2(
       db,
@@ -2009,9 +3023,10 @@ function generateSchemaData2(db, schema, relations, relationsDepthLimit, prefixe
       tableFilters,
       singleFieldName,
       typeName,
-      typeNameMapper
+      typeNameMapper,
+      filterCtx
     );
-    const insertArrGenerated = generateInsertArray2(
+    const insertArrGenerated = features.insert ? generateInsertArray2(
       db,
       tableName,
       schema[tableName],
@@ -2022,8 +3037,8 @@ function generateSchemaData2(db, schema, relations, relationsDepthLimit, prefixe
       typeName,
       typeNameMapper,
       conflictDoNothing
-    );
-    const insertSingleGenerated = generateInsertSingle2(
+    ) : void 0;
+    const insertSingleGenerated = features.insert ? generateInsertSingle2(
       db,
       tableName,
       schema[tableName],
@@ -2034,8 +3049,46 @@ function generateSchemaData2(db, schema, relations, relationsDepthLimit, prefixe
       typeName,
       typeNameMapper,
       conflictDoNothing
-    );
-    const updateGenerated = generateUpdate2(
+    ) : 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],
@@ -2045,16 +3098,29 @@ function generateSchemaData2(db, schema, relations, relationsDepthLimit, prefixe
       tableFilters,
       updateFieldName,
       typeName,
-      typeNameMapper
-    );
-    const deleteGenerated = generateDelete2(
+      typeNameMapper,
+      filterCtx
+    ) : void 0;
+    const deleteGenerated = features.delete ? generateDelete2(
       db,
       tableName,
       schema[tableName],
       tableFilters,
       deleteFieldName,
-      typeName
-    );
+      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,
@@ -2065,37 +3131,77 @@ 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_orm5.is)(relEntry.relation ?? relEntry, import_drizzle_orm5.One);
+      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;
@@ -2109,26 +3215,32 @@ function generateSchemaData2(db, schema, relations, relationsDepthLimit, prefixe
 }
 
 // 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 generateSelectArray3 = (db, tableName, tables, relationMap, orderArgs, filterArgs, fieldName, typeName, typeNameMapper) => {
+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 = selectArrayArgs(orderArgs, filterArgs);
   const table = tables[tableName];
+  const pkNames = sqlitePrimaryKeyPropNames(table);
+  const queryArgs = selectArrayArgs(
+    orderArgs,
+    filterArgs,
+    distinctEnabled ? generateDistinctEnum(table, typeName) : void 0
+  );
   return {
     name: fieldName,
-    resolver: async (_source, args, _context, info) => {
+    resolver: async (_source, args, context, info) => {
       try {
-        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,
+          queryBase: requestQueryBase,
           tables,
           tableName,
           table,
@@ -2137,7 +3249,10 @@ var generateSelectArray3 = (db, tableName, tables, relationMap, orderArgs, filte
           typeNameMapper,
           parsedInfo,
           ...args,
-          single: false
+          single: false,
+          filterCtx,
+          pkNames,
+          db: executor
         });
       } catch (e) {
         throw toGraphQLError(e);
@@ -2146,7 +3261,7 @@ var generateSelectArray3 = (db, tableName, tables, relationMap, orderArgs, filte
     args: queryArgs
   };
 };
-var generateSelectSingle3 = (db, tableName, tables, relationMap, orderArgs, filterArgs, fieldName, typeName, typeNameMapper) => {
+var generateSelectSingle3 = (db, tableName, tables, relationMap, orderArgs, filterArgs, fieldName, typeName, typeNameMapper, filterCtx) => {
   const queryBase = db.query[tableName];
   if (!queryBase) {
     throw new Error(
@@ -2155,13 +3270,15 @@ var generateSelectSingle3 = (db, tableName, tables, relationMap, orderArgs, filt
   }
   const queryArgs = selectSingleArgs(orderArgs, filterArgs);
   const table = tables[tableName];
+  const pkNames = sqlitePrimaryKeyPropNames(table);
   return {
     name: fieldName,
-    resolver: async (_source, args, _context, info) => {
+    resolver: async (_source, args, context, info) => {
       try {
-        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,
+          queryBase: requestQueryBase,
           tables,
           tableName,
           table,
@@ -2170,7 +3287,10 @@ var generateSelectSingle3 = (db, tableName, tables, relationMap, orderArgs, filt
           typeNameMapper,
           parsedInfo,
           ...args,
-          single: true
+          single: true,
+          filterCtx,
+          pkNames,
+          db: executor
         });
       } catch (e) {
         throw toGraphQLError(e);
@@ -2180,22 +3300,22 @@ var generateSelectSingle3 = (db, tableName, tables, relationMap, orderArgs, filt
   };
 };
 var sqlitePrimaryKeyPropNames = (table) => getPrimaryKeyPropNamesFromConfig(table, import_sqlite_core2.getTableConfig);
-var generateInsertArray3 = (db, tableName, table, tables, relationMap, baseType, fieldName, typeName, typeNameMapper) => {
+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: fieldName,
-    resolver: async (_source, args, _context, info) => {
+    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, hasRelations, withParams } = prepareMutationRelationColumns({
@@ -2208,8 +3328,13 @@ var generateInsertArray3 = (db, tableName, table, tables, relationMap, baseType,
           pkNames,
           parsedInfo
         });
-        const result = await db.insert(table).values(input).returning(columns).onConflictDoNothing();
-        const enriched = hasRelations ? await eagerLoadMutationRelations(db, tableName, result, pkNames, withParams) : result;
+        const executor = resolveExecutor(db, context);
+        let query = executor.insert(table).values(input).returning(columns);
+        if (conflictDoNothing) {
+          query = query.onConflictDoNothing();
+        }
+        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);
@@ -2218,19 +3343,19 @@ var generateInsertArray3 = (db, tableName, table, tables, relationMap, baseType,
     args: queryArgs
   };
 };
-var generateInsertSingle3 = (db, tableName, table, tables, relationMap, baseType, fieldName, typeName, typeNameMapper) => {
+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: fieldName,
-    resolver: async (_source, args, _context, info) => {
+    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, hasRelations, withParams } = prepareMutationRelationColumns({
@@ -2243,11 +3368,16 @@ var generateInsertSingle3 = (db, tableName, table, tables, relationMap, baseType
           pkNames,
           parsedInfo
         });
-        const result = await db.insert(table).values(input).returning(columns).onConflictDoNothing();
+        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;
         }
-        const enriched = hasRelations ? await eagerLoadMutationRelations(db, tableName, result, pkNames, withParams) : result;
+        const enriched = hasRelations ? await eagerLoadMutationRelations(executor, tableName, result, pkNames, withParams) : result;
         return remapToGraphQLSingleOutput(enriched[0], tableName, table, relationMap);
       } catch (e) {
         throw toGraphQLError(e);
@@ -2256,10 +3386,66 @@ var generateInsertSingle3 = (db, tableName, table, tables, relationMap, baseType
     args: queryArgs
   };
 };
-var generateUpdate3 = (db, tableName, table, tables, relationMap, setArgs, filterArgs, fieldName, typeName, typeNameMapper) => {
+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;
+        }
+        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, 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
@@ -2268,10 +3454,10 @@ var generateUpdate3 = (db, tableName, table, tables, relationMap, setArgs, filte
   const pkNames = sqlitePrimaryKeyPropNames(table);
   return {
     name: fieldName,
-    resolver: async (_source, args, _context, info) => {
+    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, hasRelations, withParams } = prepareMutationRelationColumns({
@@ -2286,16 +3472,17 @@ var generateUpdate3 = (db, tableName, table, tables, relationMap, setArgs, filte
         });
         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;
-        const enriched = hasRelations ? await eagerLoadMutationRelations(db, tableName, result, pkNames, withParams) : result;
+        const enriched = hasRelations ? await eagerLoadMutationRelations(executor, tableName, result, pkNames, withParams) : result;
         return remapToGraphQLArrayOutput(enriched, tableName, table, relationMap);
       } catch (e) {
         throw toGraphQLError(e);
@@ -2304,7 +3491,7 @@ var generateUpdate3 = (db, tableName, table, tables, relationMap, setArgs, filte
     args: queryArgs
   };
 };
-var generateDelete3 = (db, tableName, table, filterArgs, fieldName, typeName) => {
+var generateDelete3 = (db, tableName, table, filterArgs, fieldName, typeName, filterCtx, selectionCtx) => {
   const queryArgs = {
     where: {
       type: filterArgs
@@ -2312,19 +3499,21 @@ var generateDelete3 = (db, tableName, table, filterArgs, fieldName, typeName) =>
   };
   return {
     name: fieldName,
-    resolver: async (_source, args, _context, info) => {
+    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);
@@ -2337,10 +3526,11 @@ var generateDelete3 = (db, tableName, table, filterArgs, fieldName, typeName) =>
     args: queryArgs
   };
 };
-var generateSchemaData3 = (db, schema, relations, relationsDepthLimit, prefixes, suffixes, typeNameMapper, shouldEagerLoad = () => true) => {
+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(
@@ -2350,7 +3540,8 @@ var generateSchemaData3 = (db, schema, relations, relationsDepthLimit, prefixes,
   const namedRelations = buildNamedRelations(relations ?? {}, tableEntries);
   attachTargetPrimaryKeys(namedRelations, tables, sqlitePrimaryKeyPropNames);
   const eagerRelations = pruneNonEagerRelations(namedRelations, shouldEagerLoad);
-  const resolverFactory = createRelationResolverFactory(db, tables);
+  const filterCtx = { tables, relationMap: namedRelations };
+  const resolverFactory = createRelationResolverFactory(db, tables, filterCtx);
   const cacheCtx = {
     genericFilterCache: /* @__PURE__ */ new Map(),
     objectTypeCache: /* @__PURE__ */ new Map(),
@@ -2358,8 +3549,11 @@ var generateSchemaData3 = (db, schema, relations, relationsDepthLimit, prefixes,
     fullyBuiltTables: /* @__PURE__ */ new Set(),
     relationTypeCache: /* @__PURE__ */ new Map(),
     orderTypeCache: /* @__PURE__ */ new WeakMap(),
-    filterTypeCache: /* @__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(
@@ -2375,7 +3569,8 @@ var generateSchemaData3 = (db, schema, relations, relationsDepthLimit, prefixes,
         typeNameMapper,
         prefixes.insert,
         prefixes.update,
-        resolverFactory
+        resolverFactory,
+        relationAggregateFactory
       )
     ])
   );
@@ -2388,8 +3583,11 @@ var generateSchemaData3 = (db, schema, relations, relationsDepthLimit, prefixes,
       typeName,
       listFieldName,
       singleFieldName,
+      aggregateFieldName,
       createArrayFieldName,
       createSingleFieldName,
+      upsertArrayFieldName,
+      upsertSingleFieldName,
       updateFieldName,
       deleteFieldName
     } = computeResolverFieldNames(tableName, typeNameMapper, prefixes, suffixes);
@@ -2402,7 +3600,9 @@ var generateSchemaData3 = (db, schema, relations, relationsDepthLimit, prefixes,
       tableFilters,
       listFieldName,
       typeName,
-      typeNameMapper
+      typeNameMapper,
+      filterCtx,
+      features.distinct
     );
     const selectSingleGenerated = generateSelectSingle3(
       db,
@@ -2413,9 +3613,10 @@ var generateSchemaData3 = (db, schema, relations, relationsDepthLimit, prefixes,
       tableFilters,
       singleFieldName,
       typeName,
-      typeNameMapper
+      typeNameMapper,
+      filterCtx
     );
-    const insertArrGenerated = generateInsertArray3(
+    const insertArrGenerated = features.insert ? generateInsertArray3(
       db,
       tableName,
       schema[tableName],
@@ -2424,9 +3625,10 @@ var generateSchemaData3 = (db, schema, relations, relationsDepthLimit, prefixes,
       insertInput,
       createArrayFieldName,
       typeName,
-      typeNameMapper
-    );
-    const insertSingleGenerated = generateInsertSingle3(
+      typeNameMapper,
+      conflictDoNothing
+    ) : void 0;
+    const insertSingleGenerated = features.insert ? generateInsertSingle3(
       db,
       tableName,
       schema[tableName],
@@ -2435,9 +3637,48 @@ var generateSchemaData3 = (db, schema, relations, relationsDepthLimit, prefixes,
       insertInput,
       createSingleFieldName,
       typeName,
-      typeNameMapper
-    );
-    const updateGenerated = generateUpdate3(
+      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,
+      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],
@@ -2447,16 +3688,29 @@ var generateSchemaData3 = (db, schema, relations, relationsDepthLimit, prefixes,
       tableFilters,
       updateFieldName,
       typeName,
-      typeNameMapper
-    );
-    const deleteGenerated = generateDelete3(
+      typeNameMapper,
+      filterCtx
+    ) : void 0;
+    const deleteGenerated = features.delete ? generateDelete3(
       db,
       tableName,
       schema[tableName],
       tableFilters,
       deleteFieldName,
-      typeName
-    );
+      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,
@@ -2467,37 +3721,77 @@ 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_orm6.is)(relEntry.relation ?? relEntry, import_drizzle_orm6.One);
+      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;
@@ -2524,13 +3818,23 @@ var buildSchema = (db, config) => {
   const prefixes = {
     insert: config?.prefixes?.insert ?? "create",
     delete: config?.prefixes?.delete ?? "delete",
-    update: config?.prefixes?.update ?? "update"
+    update: config?.prefixes?.update ?? "update",
+    upsert: config?.prefixes?.upsert ?? "upsert"
   };
   const suffixes = {
     list: config?.suffixes?.list ?? "",
     single: config?.suffixes?.single ?? "Single"
   };
   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) {
@@ -2550,66 +3854,59 @@ var buildSchema = (db, config) => {
       );
     }
   }
+  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,
-      typeNameMapper,
-      shouldEagerLoad
-    );
-  } else if ((0, import_drizzle_orm7.is)(db, import_pg_core3.PgAsyncDatabase)) {
-    generatorOutput = generateSchemaData2(
-      db,
-      schema,
-      relations,
-      config?.relationsDepthLimit,
-      prefixes,
-      suffixes,
-      config?.conflictDoNothing ?? false,
-      typeNameMapper,
-      shouldEagerLoad
-    );
-  } else if ((0, import_drizzle_orm7.is)(db, import_sqlite_core3.BaseSQLiteDatabase)) {
-    generatorOutput = generateSchemaData3(
-      db,
-      schema,
-      relations,
-      config?.relationsDepthLimit,
-      prefixes,
-      suffixes,
-      typeNameMapper,
-      shouldEagerLoad
-    );
+  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,
   extractRelationJoinColumns