@vantreeseba/drizzle-graphql 4.0.0 → 4.2.0

package/dist/index.js

@@ -655,6 +655,12 @@ var createRelationResolverFactory = (db, tables, filterCtx) => ({ tableName, rel
     return loader.load(localValue);
   };
 };
+var listFieldComplexity = (options) => ({ args, childComplexity }) => {
+  const limit = args["limit"];
+  const rows = typeof limit === "number" && limit > 0 ? limit : options.defaultListSize;
+  return rows * Math.max(childComplexity, 1);
+};
+var aggregateFieldComplexity = (options) => ({ childComplexity }) => options.aggregateCost + childComplexity;
 var AGGREGATE_FIELD_SUFFIX = "Aggregate";
 var relationAggregateJoinColumns = (tree, table, selectionCtx) => {
   const relations = selectionCtx?.relationMap[selectionCtx.tableName];
@@ -1076,7 +1082,8 @@ var generateSelectFields = (tables, tableName, relationMap, fromTableName, fromR
             offset: { type: GraphQLInt2 },
             limit: { type: GraphQLInt2 }
           },
-          resolve
+          resolve,
+          ...cacheCtx.complexity ? { extensions: { complexity: listFieldComplexity(cacheCtx.complexity) } } : {}
         }
       ]);
       const aggregateFieldName = `${relationName}Aggregate`;
@@ -1094,7 +1101,8 @@ var generateSelectFields = (tables, tableName, relationMap, fromTableName, fromR
               args: {
                 where: { type: relSelectData.filters }
               },
-              resolve: relationAggregate.resolve
+              resolve: relationAggregate.resolve,
+              ...cacheCtx.complexity ? { extensions: { complexity: aggregateFieldComplexity(cacheCtx.complexity) } } : {}
             }
           ]);
         }
@@ -1717,6 +1725,7 @@ var computeResolverFieldNames = (tableName, typeNameMapper, prefixes, suffixes)
   const listFieldName = (mapped?.plural ?? uncapitalize(tableName)) + suffixes.list;
   const singleFieldName = mapped?.singular ?? uncapitalize(tableName) + suffixes.single;
   const aggregateFieldName = `${mapped?.plural ?? uncapitalize(tableName)}Aggregate`;
+  const groupByFieldName = `${mapped?.plural ?? uncapitalize(tableName)}GroupBy`;
   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";
@@ -1729,6 +1738,7 @@ var computeResolverFieldNames = (tableName, typeNameMapper, prefixes, suffixes)
     listFieldName,
     singleFieldName,
     aggregateFieldName,
+    groupByFieldName,
     createArrayFieldName,
     createSingleFieldName,
     upsertArrayFieldName,
@@ -1884,7 +1894,7 @@ import { is as is4, One as One3 } from "drizzle-orm";
 import { getTableConfig, MySqlTable } from "drizzle-orm/mysql-core";
 import {
   GraphQLBoolean as GraphQLBoolean3,
-  GraphQLError as GraphQLError4,
+  GraphQLError as GraphQLError5,
   GraphQLList as GraphQLList4,
   GraphQLNonNull as GraphQLNonNull4,
   GraphQLObjectType as GraphQLObjectType4
@@ -1897,15 +1907,23 @@ import {
   avg,
   count,
   countDistinct,
+  eq as eq2,
   extractExtendedColumnType as extractExtendedColumnType2,
   getColumns as getColumns2,
+  gt as gt2,
+  gte as gte2,
   inArray as inArray2,
+  lt as lt2,
+  lte as lte2,
   max,
   min,
+  ne as ne2,
   sum
 } from "drizzle-orm";
 import {
+  GraphQLError as GraphQLError4,
   GraphQLFloat as GraphQLFloat2,
+  GraphQLInputObjectType as GraphQLInputObjectType3,
   GraphQLInt as GraphQLInt3,
   GraphQLList as GraphQLList3,
   GraphQLNonNull as GraphQLNonNull3,
@@ -2026,9 +2044,9 @@ var aggregateTarget = (table, tableName, typeName) => {
     )
   };
 };
-var parseAggregateRequest = (info, target) => {
+var parseAggregateRequest = (info, target, rootTypeName = `${target.typeName}Aggregate`) => {
   const parsedInfo = parseResolveInfo(info, { deep: true });
-  const selectionTree = parsedInfo.fieldsByTypeName[`${target.typeName}Aggregate`] ?? {};
+  const selectionTree = parsedInfo.fieldsByTypeName[rootTypeName] ?? {};
   const request = {
     count: false,
     ops: { avg: [], sum: [], min: [], max: [], countNonNull: [], countDistinct: [] },
@@ -2166,6 +2184,184 @@ var createRelationAggregateFactory = (db, tables, cacheCtx, typeNameMapper, filt
     return { type, resolve };
   };
 };
+var GROUP_COL = `group${SEP}`;
+var HAVING_OPS = { eq: eq2, ne: ne2, gt: gt2, gte: gte2, lt: lt2, lte: lte2 };
+var groupableColumns = (table, tableName) => {
+  const { orderable } = classifyAggregateColumns(table, tableName);
+  const groupable = { ...orderable };
+  for (const [columnName, column] of Object.entries(getColumns2(table))) {
+    if (groupable[columnName]) {
+      continue;
+    }
+    const { type: dataType } = extractExtendedColumnType2(column);
+    if (dataType !== "boolean") {
+      continue;
+    }
+    groupable[columnName] = {
+      column,
+      converted: drizzleColumnToGraphQLType(column, columnName, tableName, true, false, false)
+    };
+  }
+  return groupable;
+};
+var generateGroupByEnum = (table, tableName, typeName) => {
+  const groupable = groupableColumns(table, tableName);
+  return generateColumnEnum(
+    table,
+    `${typeName}GroupByColumn`,
+    `Columns of ${typeName} that a query can group by`,
+    (_column, columnName) => Boolean(groupable[columnName])
+  );
+};
+var aggregateNumberFilter = new GraphQLInputObjectType3({
+  name: "AggregateNumberFilter",
+  description: "Compares an aggregated value. Several operators in one filter are ANDed together.",
+  fields: Object.fromEntries(Object.keys(HAVING_OPS).map((op) => [op, { type: GraphQLFloat2 }]))
+});
+var generateHavingInput = (table, tableName, typeName) => {
+  const { numeric, orderable, all } = classifyAggregateColumns(table, tableName);
+  const fields = {
+    count: { type: aggregateNumberFilter, description: "Filters groups by how many rows they contain" }
+  };
+  const opColumns = {
+    avg: numeric,
+    sum: numeric,
+    min: numeric,
+    max: numeric,
+    countNonNull: all,
+    countDistinct: orderable
+  };
+  for (const [op, columns] of Object.entries(opColumns)) {
+    const columnNames = Object.keys(columns);
+    if (!columnNames.length) {
+      continue;
+    }
+    fields[op] = {
+      type: new GraphQLInputObjectType3({
+        name: `${typeName}${capitalize(op)}Having`,
+        fields: Object.fromEntries(columnNames.map((columnName) => [columnName, { type: aggregateNumberFilter }]))
+      })
+    };
+  }
+  return new GraphQLInputObjectType3({
+    name: `${typeName}Having`,
+    description: `Filters ${typeName} groups by their aggregated values`,
+    fields
+  });
+};
+var generateGroupByType = (table, tableName, typeName, cacheCtx) => {
+  const groupable = groupableColumns(table, tableName);
+  if (!Object.keys(groupable).length) {
+    return void 0;
+  }
+  const keysType = new GraphQLObjectType3({
+    name: `${typeName}GroupKeys`,
+    description: `The grouped column values of one ${typeName} group. A column the query did not group by is null.`,
+    fields: Object.fromEntries(
+      Object.entries(groupable).map(([columnName, { converted }]) => [
+        columnName,
+        { type: converted.type, description: converted.description }
+      ])
+    )
+  });
+  const aggregateType = generateAggregateTypes(table, tableName, typeName, cacheCtx);
+  const aggregateFields = Object.fromEntries(
+    Object.values(aggregateType.getFields()).map((field) => [
+      field.name,
+      { type: field.type, description: field.description ?? void 0 }
+    ])
+  );
+  return new GraphQLObjectType3({
+    name: `${typeName}GroupBy`,
+    fields: { group: { type: new GraphQLNonNull3(keysType) }, ...aggregateFields }
+  });
+};
+var havingComparisons = (expression, filter) => Object.entries(filter).filter(([op, value]) => value != null && op in HAVING_OPS).map(([op, value]) => HAVING_OPS[op](expression, value));
+var buildHavingCondition = (having, columns) => {
+  if (!having) {
+    return void 0;
+  }
+  const conditions = [];
+  for (const [key, value] of Object.entries(having)) {
+    if (value == null) {
+      continue;
+    }
+    if (key === "count") {
+      conditions.push(...havingComparisons(count(), value));
+      continue;
+    }
+    if (!AGGREGATE_OPS.includes(key)) {
+      continue;
+    }
+    for (const [columnName, filter] of Object.entries(value)) {
+      const column = columns[columnName];
+      if (!column || filter == null) {
+        continue;
+      }
+      conditions.push(...havingComparisons(OP_FNS[key](column), filter));
+    }
+  }
+  return conditions.length ? and2(...conditions) : void 0;
+};
+var generateGroupBy = (db, tableName, table, typeName, fieldName, filterArgs, groupByEnum, havingInput, filterCtx) => {
+  const target = aggregateTarget(table, tableName, typeName);
+  const groupable = groupableColumns(table, tableName);
+  const columns = getColumns2(table);
+  const rootTypeName = `${typeName}GroupBy`;
+  const queryArgs = {
+    groupBy: {
+      type: new GraphQLNonNull3(new GraphQLList3(new GraphQLNonNull3(groupByEnum))),
+      description: "Columns to group by. One result row per distinct combination of their values."
+    },
+    where: { type: filterArgs, description: "Filters the rows before they are grouped." },
+    having: { type: havingInput, description: "Filters the groups after they are aggregated." }
+  };
+  return {
+    name: fieldName,
+    resolver: async (_source, args, context, info) => {
+      try {
+        const requestedKeys = [...new Set(args.groupBy ?? [])];
+        if (!requestedKeys.length) {
+          throw new GraphQLError4("At least one column to group by is required!");
+        }
+        const keyColumns = requestedKeys.map((columnName) => {
+          const groupableColumn = groupable[columnName];
+          if (!groupableColumn) {
+            throw new GraphQLError4(`Cannot group ${typeName} by ${columnName}!`);
+          }
+          return [columnName, groupableColumn.column];
+        });
+        const request = parseAggregateRequest(info, target, rootTypeName);
+        const selection = {
+          ...Object.fromEntries(keyColumns.map(([columnName, column]) => [`${GROUP_COL}${columnName}`, column])),
+          ...request.selection
+        };
+        let query = resolveExecutor(db, context).select(selection).from(table);
+        if (args.where) {
+          query = query.where(extractFilters(table, tableName, args.where, relationFilterCtx(filterCtx, tableName)));
+        }
+        query = query.groupBy(...keyColumns.map(([, column]) => column));
+        const havingCondition = buildHavingCondition(args.having, columns);
+        if (havingCondition) {
+          query = query.having(havingCondition);
+        }
+        const rows = await query;
+        return rows.map((row) => {
+          const group = {};
+          for (const [columnName, column] of keyColumns) {
+            const value = row[`${GROUP_COL}${columnName}`];
+            const decoded = typeof value === "string" && target.dateTimeColumns.has(columnName) ? parseDriverDateTime(value) : value;
+            group[columnName] = value == null ? null : remapToGraphQLCore(columnName, decoded, tableName, column);
+          }
+          return { group, ...assembleAggregateRow(row, request, target) };
+        });
+      } catch (e) {
+        throw toGraphQLError(e);
+      }
+    },
+    args: queryArgs
+  };
+};
 
 // src/util/builders/mysql.ts
 var generateSelectArray = (db, tableName, tables, relationMap, orderArgs, filterArgs, fieldName, typeName, typeNameMapper, filterCtx, distinctEnabled = true) => {
@@ -2260,7 +2456,7 @@ var generateInsertArray = (db, _tableName, table, baseType, fieldName) => {
       try {
         const input = remapFromGraphQLArrayInput(args.values, table);
         if (!input.length) {
-          throw new GraphQLError4("No values were provided!");
+          throw new GraphQLError5("No values were provided!");
         }
         await resolveExecutor(db, context).insert(table).values(input);
         return { isSuccess: true };
@@ -2308,7 +2504,7 @@ var generateUpsert = (db, table, baseType, onConflictType, fieldName, single) =>
       try {
         const input = single ? [remapFromGraphQLSingleInput(args.values, table)] : remapFromGraphQLArrayInput(args.values, table);
         if (!input.length) {
-          throw new GraphQLError4("No values were provided!");
+          throw new GraphQLError5("No values were provided!");
         }
         const plan = resolveConflictPlan({
           table,
@@ -2349,7 +2545,7 @@ var generateUpdate = (db, tableName, table, setArgs, filterArgs, fieldName, filt
         const { where, set } = args;
         const input = remapFromGraphQLSingleInput(set, table);
         if (!Object.keys(input).length) {
-          throw new GraphQLError4("Unable to update with no values specified!");
+          throw new GraphQLError5("Unable to update with no values specified!");
         }
         const executor = resolveExecutor(db, context);
         let query = executor.update(table).set(input);
@@ -2394,7 +2590,7 @@ var generateDelete = (db, tableName, table, filterArgs, fieldName, filterCtx) =>
 };
 var mysqlPrimaryKeyPropNames = (table) => getPrimaryKeyPropNamesFromConfig(table, getTableConfig);
 var generateSchemaData = (db, schema, relations, options) => {
-  const { relationsDepthLimit, prefixes, suffixes, typeNameMapper, shouldEagerLoad, features } = options;
+  const { relationsDepthLimit, prefixes, suffixes, typeNameMapper, shouldEagerLoad, features, complexity } = options;
   const rawSchema = schema;
   const schemaEntries = Object.entries(rawSchema);
   const tableEntries = schemaEntries.filter(([_key, value]) => is4(value, MySqlTable));
@@ -2418,7 +2614,8 @@ var generateSchemaData = (db, schema, relations, options) => {
     orderTypeCache: /* @__PURE__ */ new WeakMap(),
     filterTypeCache: /* @__PURE__ */ new WeakMap(),
     listRelationFilterCache: /* @__PURE__ */ new Map(),
-    aggregateTypeCache: /* @__PURE__ */ new Map()
+    aggregateTypeCache: /* @__PURE__ */ new Map(),
+    complexity
   };
   const relationAggregateFactory = features.relationAggregates ? createRelationAggregateFactory(db, tables, cacheCtx, typeNameMapper, filterCtx) : void 0;
   const queries = {};
@@ -2462,6 +2659,7 @@ var generateSchemaData = (db, schema, relations, options) => {
       listFieldName,
       singleFieldName,
       aggregateFieldName,
+      groupByFieldName,
       createArrayFieldName,
       createSingleFieldName,
       upsertArrayFieldName,
@@ -2525,10 +2723,25 @@ var generateSchemaData = (db, schema, relations, options) => {
       tableFilters,
       filterCtx
     ) : void 0;
+    const groupByType = features.aggregates && features.groupBy ? generateGroupByType(schema[tableName], tableName, typeName, cacheCtx) : void 0;
+    const groupByEnum = groupByType ? generateGroupByEnum(schema[tableName], tableName, typeName) : void 0;
+    const havingInput = groupByEnum ? generateHavingInput(schema[tableName], tableName, typeName) : void 0;
+    const groupByGenerated = groupByType && groupByEnum && havingInput ? generateGroupBy(
+      db,
+      tableName,
+      schema[tableName],
+      typeName,
+      groupByFieldName,
+      tableFilters,
+      groupByEnum,
+      havingInput,
+      filterCtx
+    ) : void 0;
     queries[selectArrGenerated.name] = {
       type: selectArrOutput,
       args: selectArrGenerated.args,
-      resolve: selectArrGenerated.resolver
+      resolve: selectArrGenerated.resolver,
+      ...complexity ? { extensions: { complexity: listFieldComplexity(complexity) } } : {}
     };
     queries[selectSingleGenerated.name] = {
       type: selectSingleOutput,
@@ -2539,7 +2752,16 @@ var generateSchemaData = (db, schema, relations, options) => {
       queries[aggregateGenerated.name] = {
         type: new GraphQLNonNull4(aggregateType),
         args: aggregateGenerated.args,
-        resolve: aggregateGenerated.resolver
+        resolve: aggregateGenerated.resolver,
+        ...complexity ? { extensions: { complexity: aggregateFieldComplexity(complexity) } } : {}
+      };
+    }
+    if (groupByGenerated && groupByType) {
+      queries[groupByGenerated.name] = {
+        type: new GraphQLNonNull4(new GraphQLList4(new GraphQLNonNull4(groupByType))),
+        args: groupByGenerated.args,
+        resolve: groupByGenerated.resolver,
+        ...complexity ? { extensions: { complexity: aggregateFieldComplexity(complexity) } } : {}
       };
     }
     for (const generated of [
@@ -2573,6 +2795,10 @@ var generateSchemaData = (db, schema, relations, options) => {
     if (aggregateType) {
       outputs[aggregateType.name] = aggregateType;
     }
+    if (groupByType && havingInput) {
+      outputs[groupByType.name] = groupByType;
+      inputs[havingInput.name] = havingInput;
+    }
   }
   const fieldResolvers = {};
   for (const [tableName, tableRelations] of Object.entries(namedRelations)) {
@@ -2595,7 +2821,7 @@ var generateSchemaData = (db, schema, relations, options) => {
 import { is as is5, One as One4 } from "drizzle-orm";
 import { getTableConfig as getTableConfig2, PgTable } from "drizzle-orm/pg-core";
 import {
-  GraphQLError as GraphQLError5,
+  GraphQLError as GraphQLError6,
   GraphQLList as GraphQLList5,
   GraphQLNonNull as GraphQLNonNull5
 } from "graphql";
@@ -2756,7 +2982,7 @@ var generateInsertArray2 = (db, tableName, table, tables, relationMap, baseType,
       try {
         const input = remapFromGraphQLArrayInput(args.values, table);
         if (!input.length) {
-          throw new GraphQLError5("No values were provided!");
+          throw new GraphQLError6("No values were provided!");
         }
         const parsedInfo = parseResolveInfo3(info, {
           deep: true
@@ -2846,7 +3072,7 @@ var generateUpsert2 = (db, tableName, table, tables, relationMap, baseType, onCo
       try {
         const input = single ? [remapFromGraphQLSingleInput(args.values, table)] : remapFromGraphQLArrayInput(args.values, table);
         if (!input.length) {
-          throw new GraphQLError5("No values were provided!");
+          throw new GraphQLError6("No values were provided!");
         }
         const parsedInfo = parseResolveInfo3(info, { deep: true });
         const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
@@ -2915,7 +3141,7 @@ var generateUpdate2 = (db, tableName, table, tables, relationMap, setArgs, filte
         });
         const input = remapFromGraphQLSingleInput(set, table);
         if (!Object.keys(input).length) {
-          throw new GraphQLError5("Unable to update with no values specified!");
+          throw new GraphQLError6("Unable to update with no values specified!");
         }
         const executor = resolveExecutor(db, context);
         let query = executor.update(table).set(input);
@@ -2970,7 +3196,16 @@ var generateDelete2 = (db, tableName, table, filterArgs, fieldName, typeName, fi
   };
 };
 function generateSchemaData2(db, schema, relations, options) {
-  const { relationsDepthLimit, prefixes, suffixes, conflictDoNothing, typeNameMapper, shouldEagerLoad, features } = options;
+  const {
+    relationsDepthLimit,
+    prefixes,
+    suffixes,
+    conflictDoNothing,
+    typeNameMapper,
+    shouldEagerLoad,
+    features,
+    complexity
+  } = options;
   const schemaEntries = Object.entries(schema);
   const tableEntries = schemaEntries.filter(([_key, value]) => is5(value, PgTable));
   const tables = Object.fromEntries(tableEntries);
@@ -2993,7 +3228,8 @@ function generateSchemaData2(db, schema, relations, options) {
     orderTypeCache: /* @__PURE__ */ new WeakMap(),
     filterTypeCache: /* @__PURE__ */ new WeakMap(),
     listRelationFilterCache: /* @__PURE__ */ new Map(),
-    aggregateTypeCache: /* @__PURE__ */ new Map()
+    aggregateTypeCache: /* @__PURE__ */ new Map(),
+    complexity
   };
   const relationAggregateFactory = features.relationAggregates ? createRelationAggregateFactory(db, tables, cacheCtx, typeNameMapper, filterCtx) : void 0;
   const queries = {};
@@ -3026,6 +3262,7 @@ function generateSchemaData2(db, schema, relations, options) {
       listFieldName,
       singleFieldName,
       aggregateFieldName,
+      groupByFieldName,
       createArrayFieldName,
       createSingleFieldName,
       upsertArrayFieldName,
@@ -3153,10 +3390,25 @@ function generateSchemaData2(db, schema, relations, options) {
       tableFilters,
       filterCtx
     ) : void 0;
+    const groupByType = features.aggregates && features.groupBy ? generateGroupByType(schema[tableName], tableName, typeName, cacheCtx) : void 0;
+    const groupByEnum = groupByType ? generateGroupByEnum(schema[tableName], tableName, typeName) : void 0;
+    const havingInput = groupByEnum ? generateHavingInput(schema[tableName], tableName, typeName) : void 0;
+    const groupByGenerated = groupByType && groupByEnum && havingInput ? generateGroupBy(
+      db,
+      tableName,
+      schema[tableName],
+      typeName,
+      groupByFieldName,
+      tableFilters,
+      groupByEnum,
+      havingInput,
+      filterCtx
+    ) : void 0;
     queries[selectArrGenerated.name] = {
       type: selectArrOutput,
       args: selectArrGenerated.args,
-      resolve: selectArrGenerated.resolver
+      resolve: selectArrGenerated.resolver,
+      ...complexity ? { extensions: { complexity: listFieldComplexity(complexity) } } : {}
     };
     queries[selectSingleGenerated.name] = {
       type: selectSingleOutput,
@@ -3167,7 +3419,16 @@ function generateSchemaData2(db, schema, relations, options) {
       queries[aggregateGenerated.name] = {
         type: new GraphQLNonNull5(aggregateType),
         args: aggregateGenerated.args,
-        resolve: aggregateGenerated.resolver
+        resolve: aggregateGenerated.resolver,
+        ...complexity ? { extensions: { complexity: aggregateFieldComplexity(complexity) } } : {}
+      };
+    }
+    if (groupByGenerated && groupByType) {
+      queries[groupByGenerated.name] = {
+        type: new GraphQLNonNull5(new GraphQLList5(new GraphQLNonNull5(groupByType))),
+        args: groupByGenerated.args,
+        resolve: groupByGenerated.resolver,
+        ...complexity ? { extensions: { complexity: aggregateFieldComplexity(complexity) } } : {}
       };
     }
     if (insertArrGenerated) {
@@ -3228,6 +3489,10 @@ function generateSchemaData2(db, schema, relations, options) {
     if (aggregateType) {
       outputs[aggregateType.name] = aggregateType;
     }
+    if (groupByType && havingInput) {
+      outputs[groupByType.name] = groupByType;
+      inputs[havingInput.name] = havingInput;
+    }
   }
   const fieldResolvers = {};
   for (const [tableName, tableRelations] of Object.entries(namedRelations)) {
@@ -3250,7 +3515,7 @@ function generateSchemaData2(db, schema, relations, options) {
 import { is as is6, One as One5 } from "drizzle-orm";
 import { getTableConfig as getTableConfig3, SQLiteTable } from "drizzle-orm/sqlite-core";
 import {
-  GraphQLError as GraphQLError6,
+  GraphQLError as GraphQLError7,
   GraphQLList as GraphQLList6,
   GraphQLNonNull as GraphQLNonNull6
 } from "graphql";
@@ -3349,7 +3614,7 @@ var generateInsertArray3 = (db, tableName, table, tables, relationMap, baseType,
       try {
         const input = remapFromGraphQLArrayInput(args.values, table);
         if (!input.length) {
-          throw new GraphQLError6("No values were provided!");
+          throw new GraphQLError7("No values were provided!");
         }
         const parsedInfo = parseResolveInfo4(info, {
           deep: true
@@ -3439,7 +3704,7 @@ var generateUpsert3 = (db, tableName, table, tables, relationMap, baseType, onCo
       try {
         const input = single ? [remapFromGraphQLSingleInput(args.values, table)] : remapFromGraphQLArrayInput(args.values, table);
         if (!input.length) {
-          throw new GraphQLError6("No values were provided!");
+          throw new GraphQLError7("No values were provided!");
         }
         const parsedInfo = parseResolveInfo4(info, { deep: true });
         const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
@@ -3508,7 +3773,7 @@ var generateUpdate3 = (db, tableName, table, tables, relationMap, setArgs, filte
         });
         const input = remapFromGraphQLSingleInput(set, table);
         if (!Object.keys(input).length) {
-          throw new GraphQLError6("Unable to update with no values specified!");
+          throw new GraphQLError7("Unable to update with no values specified!");
         }
         const executor = resolveExecutor(db, context);
         let query = executor.update(table).set(input);
@@ -3563,7 +3828,16 @@ var generateDelete3 = (db, tableName, table, filterArgs, fieldName, typeName, fi
   };
 };
 var generateSchemaData3 = (db, schema, relations, options) => {
-  const { relationsDepthLimit, prefixes, suffixes, conflictDoNothing, typeNameMapper, shouldEagerLoad, features } = options;
+  const {
+    relationsDepthLimit,
+    prefixes,
+    suffixes,
+    conflictDoNothing,
+    typeNameMapper,
+    shouldEagerLoad,
+    features,
+    complexity
+  } = options;
   const rawSchema = schema;
   const schemaEntries = Object.entries(rawSchema);
   const tableEntries = schemaEntries.filter(([_key, value]) => is6(value, SQLiteTable));
@@ -3587,7 +3861,8 @@ var generateSchemaData3 = (db, schema, relations, options) => {
     orderTypeCache: /* @__PURE__ */ new WeakMap(),
     filterTypeCache: /* @__PURE__ */ new WeakMap(),
     listRelationFilterCache: /* @__PURE__ */ new Map(),
-    aggregateTypeCache: /* @__PURE__ */ new Map()
+    aggregateTypeCache: /* @__PURE__ */ new Map(),
+    complexity
   };
   const relationAggregateFactory = features.relationAggregates ? createRelationAggregateFactory(db, tables, cacheCtx, typeNameMapper, filterCtx) : void 0;
   const queries = {};
@@ -3620,6 +3895,7 @@ var generateSchemaData3 = (db, schema, relations, options) => {
       listFieldName,
       singleFieldName,
       aggregateFieldName,
+      groupByFieldName,
       createArrayFieldName,
       createSingleFieldName,
       upsertArrayFieldName,
@@ -3747,10 +4023,25 @@ var generateSchemaData3 = (db, schema, relations, options) => {
       tableFilters,
       filterCtx
     ) : void 0;
+    const groupByType = features.aggregates && features.groupBy ? generateGroupByType(schema[tableName], tableName, typeName, cacheCtx) : void 0;
+    const groupByEnum = groupByType ? generateGroupByEnum(schema[tableName], tableName, typeName) : void 0;
+    const havingInput = groupByEnum ? generateHavingInput(schema[tableName], tableName, typeName) : void 0;
+    const groupByGenerated = groupByType && groupByEnum && havingInput ? generateGroupBy(
+      db,
+      tableName,
+      schema[tableName],
+      typeName,
+      groupByFieldName,
+      tableFilters,
+      groupByEnum,
+      havingInput,
+      filterCtx
+    ) : void 0;
     queries[selectArrGenerated.name] = {
       type: selectArrOutput,
       args: selectArrGenerated.args,
-      resolve: selectArrGenerated.resolver
+      resolve: selectArrGenerated.resolver,
+      ...complexity ? { extensions: { complexity: listFieldComplexity(complexity) } } : {}
     };
     queries[selectSingleGenerated.name] = {
       type: selectSingleOutput,
@@ -3761,7 +4052,16 @@ var generateSchemaData3 = (db, schema, relations, options) => {
       queries[aggregateGenerated.name] = {
         type: new GraphQLNonNull6(aggregateType),
         args: aggregateGenerated.args,
-        resolve: aggregateGenerated.resolver
+        resolve: aggregateGenerated.resolver,
+        ...complexity ? { extensions: { complexity: aggregateFieldComplexity(complexity) } } : {}
+      };
+    }
+    if (groupByGenerated && groupByType) {
+      queries[groupByGenerated.name] = {
+        type: new GraphQLNonNull6(new GraphQLList6(new GraphQLNonNull6(groupByType))),
+        args: groupByGenerated.args,
+        resolve: groupByGenerated.resolver,
+        ...complexity ? { extensions: { complexity: aggregateFieldComplexity(complexity) } } : {}
       };
     }
     if (insertArrGenerated) {
@@ -3822,6 +4122,10 @@ var generateSchemaData3 = (db, schema, relations, options) => {
     if (aggregateType) {
       outputs[aggregateType.name] = aggregateType;
     }
+    if (groupByType && havingInput) {
+      outputs[groupByType.name] = groupByType;
+      inputs[havingInput.name] = havingInput;
+    }
   }
   const fieldResolvers = {};
   for (const [tableName, tableRelations] of Object.entries(namedRelations)) {
@@ -3864,6 +4168,7 @@ var buildSchema = (db, config) => {
   const typeNameMapper = config?.typeNameMapper;
   const features = {
     aggregates: config?.features?.aggregates ?? true,
+    groupBy: config?.features?.groupBy ?? true,
     relationAggregates: config?.features?.relationAggregates ?? true,
     distinct: config?.features?.distinct ?? true,
     insert: config?.features?.insert ?? true,
@@ -3871,6 +4176,11 @@ var buildSchema = (db, config) => {
     delete: config?.features?.delete ?? true,
     upsert: config?.features?.upsert ?? false
   };
+  const complexityConfig = config?.complexity ?? true;
+  const complexity = complexityConfig === false ? void 0 : {
+    defaultListSize: (complexityConfig === true ? void 0 : complexityConfig.defaultListSize) ?? 10,
+    aggregateCost: (complexityConfig === true ? void 0 : complexityConfig.aggregateCost) ?? 10
+  };
   const eagerOpt = config?.eagerLoadRelations;
   const shouldEagerLoad = eagerOpt === void 0 || eagerOpt === true ? () => true : eagerOpt === false ? () => false : eagerOpt;
   if (!typeNameMapper && suffixes.list === suffixes.single) {
@@ -3897,7 +4207,8 @@ var buildSchema = (db, config) => {
     conflictDoNothing: config?.conflictDoNothing ?? false,
     typeNameMapper,
     shouldEagerLoad,
-    features
+    features,
+    complexity
   };
   let generatorOutput;
   if (is7(db, MySqlDatabase)) {