@vantreeseba/drizzle-graphql 4.1.0 → 4.2.0

package/dist/index.d.cts

@@ -400,6 +400,13 @@ type GeneratedData<TDatabase extends AnyDrizzleDB<any>> = {
 type SchemaFeatures = {
     /** `<plural>Aggregate` root queries and the aggregate output types. @default true */
     aggregates?: boolean;
+    /**
+     * `<plural>GroupBy` root queries — the same aggregates, one row per group. Requires
+     * `aggregates`, whose output types the grouped result reuses.
+     *
+     * @default true
+     */
+    groupBy?: boolean;
     /** `<relation>Aggregate` fields on object types, for to-many relations. @default true */
     relationAggregates?: boolean;
     /** The `distinct` argument on list queries. @default true */

package/dist/index.d.ts

@@ -400,6 +400,13 @@ type GeneratedData<TDatabase extends AnyDrizzleDB<any>> = {
 type SchemaFeatures = {
     /** `<plural>Aggregate` root queries and the aggregate output types. @default true */
     aggregates?: boolean;
+    /**
+     * `<plural>GroupBy` root queries — the same aggregates, one row per group. Requires
+     * `aggregates`, whose output types the grouped result reuses.
+     *
+     * @default true
+     */
+    groupBy?: boolean;
     /** `<relation>Aggregate` fields on object types, for to-many relations. @default true */
     relationAggregates?: boolean;
     /** The `distinct` argument on list queries. @default true */

package/dist/index.js

@@ -1725,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";
@@ -1737,6 +1738,7 @@ var computeResolverFieldNames = (tableName, typeNameMapper, prefixes, suffixes)
     listFieldName,
     singleFieldName,
     aggregateFieldName,
+    groupByFieldName,
     createArrayFieldName,
     createSingleFieldName,
     upsertArrayFieldName,
@@ -1892,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
@@ -1905,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,
@@ -2034,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: [] },
@@ -2174,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) => {
@@ -2268,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 };
@@ -2316,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,
@@ -2357,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);
@@ -2471,6 +2659,7 @@ var generateSchemaData = (db, schema, relations, options) => {
       listFieldName,
       singleFieldName,
       aggregateFieldName,
+      groupByFieldName,
       createArrayFieldName,
       createSingleFieldName,
       upsertArrayFieldName,
@@ -2534,6 +2723,20 @@ 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,
@@ -2553,6 +2756,14 @@ var generateSchemaData = (db, schema, relations, options) => {
         ...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 [
       insertArrGenerated,
       insertSingleGenerated,
@@ -2584,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)) {
@@ -2606,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";
@@ -2767,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
@@ -2857,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({
@@ -2926,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);
@@ -3047,6 +3262,7 @@ function generateSchemaData2(db, schema, relations, options) {
       listFieldName,
       singleFieldName,
       aggregateFieldName,
+      groupByFieldName,
       createArrayFieldName,
       createSingleFieldName,
       upsertArrayFieldName,
@@ -3174,6 +3390,20 @@ 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,
@@ -3193,6 +3423,14 @@ function generateSchemaData2(db, schema, relations, options) {
         ...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) {
       mutations[insertArrGenerated.name] = {
         type: arrTableItemOutput,
@@ -3251,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)) {
@@ -3273,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";
@@ -3372,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
@@ -3462,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({
@@ -3531,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);
@@ -3653,6 +3895,7 @@ var generateSchemaData3 = (db, schema, relations, options) => {
       listFieldName,
       singleFieldName,
       aggregateFieldName,
+      groupByFieldName,
       createArrayFieldName,
       createSingleFieldName,
       upsertArrayFieldName,
@@ -3780,6 +4023,20 @@ 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,
@@ -3799,6 +4056,14 @@ var generateSchemaData3 = (db, schema, relations, options) => {
         ...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) {
       mutations[insertArrGenerated.name] = {
         type: arrTableItemOutput,
@@ -3857,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)) {
@@ -3899,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,