@vantreeseba/drizzle-graphql 4.0.0 → 4.2.0

package/dist/index.cjs

@@ -650,6 +650,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];
@@ -1071,7 +1077,8 @@ var generateSelectFields = (tables, tableName, relationMap, fromTableName, fromR
             offset: { type: import_graphql4.GraphQLInt },
             limit: { type: import_graphql4.GraphQLInt }
           },
-          resolve
+          resolve,
+          ...cacheCtx.complexity ? { extensions: { complexity: listFieldComplexity(cacheCtx.complexity) } } : {}
         }
       ]);
       const aggregateFieldName = `${relationName}Aggregate`;
@@ -1089,7 +1096,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) } } : {}
             }
           ]);
         }
@@ -1712,6 +1720,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";
@@ -1724,6 +1733,7 @@ var computeResolverFieldNames = (tableName, typeNameMapper, prefixes, suffixes)
     listFieldName,
     singleFieldName,
     aggregateFieldName,
+    groupByFieldName,
     createArrayFieldName,
     createSingleFieldName,
     upsertArrayFieldName,
@@ -1998,9 +2008,9 @@ var aggregateTarget = (table, tableName, typeName) => {
     )
   };
 };
-var parseAggregateRequest = (info, target) => {
+var parseAggregateRequest = (info, target, rootTypeName = `${target.typeName}Aggregate`) => {
   const parsedInfo = (0, import_graphql_parse_resolve_info.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: [] },
@@ -2138,6 +2148,184 @@ var createRelationAggregateFactory = (db, tables, cacheCtx, typeNameMapper, filt
     return { type, resolve };
   };
 };
+var GROUP_COL = `group${SEP}`;
+var HAVING_OPS = { eq: import_drizzle_orm4.eq, ne: import_drizzle_orm4.ne, gt: import_drizzle_orm4.gt, gte: import_drizzle_orm4.gte, lt: import_drizzle_orm4.lt, lte: import_drizzle_orm4.lte };
+var groupableColumns = (table, tableName) => {
+  const { orderable } = classifyAggregateColumns(table, tableName);
+  const groupable = { ...orderable };
+  for (const [columnName, column] of Object.entries((0, import_drizzle_orm4.getColumns)(table))) {
+    if (groupable[columnName]) {
+      continue;
+    }
+    const { type: dataType } = (0, import_drizzle_orm4.extractExtendedColumnType)(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 import_graphql5.GraphQLInputObjectType({
+  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: import_graphql5.GraphQLFloat }]))
+});
+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 import_graphql5.GraphQLInputObjectType({
+        name: `${typeName}${capitalize(op)}Having`,
+        fields: Object.fromEntries(columnNames.map((columnName) => [columnName, { type: aggregateNumberFilter }]))
+      })
+    };
+  }
+  return new import_graphql5.GraphQLInputObjectType({
+    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 import_graphql5.GraphQLObjectType({
+    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 import_graphql5.GraphQLObjectType({
+    name: `${typeName}GroupBy`,
+    fields: { group: { type: new import_graphql5.GraphQLNonNull(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((0, import_drizzle_orm4.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 ? (0, import_drizzle_orm4.and)(...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 = (0, import_drizzle_orm4.getColumns)(table);
+  const rootTypeName = `${typeName}GroupBy`;
+  const queryArgs = {
+    groupBy: {
+      type: new import_graphql5.GraphQLNonNull(new import_graphql5.GraphQLList(new import_graphql5.GraphQLNonNull(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 import_graphql5.GraphQLError("At least one column to group by is required!");
+        }
+        const keyColumns = requestedKeys.map((columnName) => {
+          const groupableColumn = groupable[columnName];
+          if (!groupableColumn) {
+            throw new import_graphql5.GraphQLError(`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) => {
@@ -2366,7 +2554,7 @@ var generateDelete = (db, tableName, table, filterArgs, fieldName, filterCtx) =>
 };
 var mysqlPrimaryKeyPropNames = (table) => getPrimaryKeyPropNamesFromConfig(table, import_mysql_core2.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]) => (0, import_drizzle_orm5.is)(value, import_mysql_core2.MySqlTable));
@@ -2390,7 +2578,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 = {};
@@ -2434,6 +2623,7 @@ var generateSchemaData = (db, schema, relations, options) => {
       listFieldName,
       singleFieldName,
       aggregateFieldName,
+      groupByFieldName,
       createArrayFieldName,
       createSingleFieldName,
       upsertArrayFieldName,
@@ -2497,10 +2687,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,
@@ -2511,7 +2716,16 @@ var generateSchemaData = (db, schema, relations, options) => {
       queries[aggregateGenerated.name] = {
         type: new import_graphql6.GraphQLNonNull(aggregateType),
         args: aggregateGenerated.args,
-        resolve: aggregateGenerated.resolver
+        resolve: aggregateGenerated.resolver,
+        ...complexity ? { extensions: { complexity: aggregateFieldComplexity(complexity) } } : {}
+      };
+    }
+    if (groupByGenerated && groupByType) {
+      queries[groupByGenerated.name] = {
+        type: new import_graphql6.GraphQLNonNull(new import_graphql6.GraphQLList(new import_graphql6.GraphQLNonNull(groupByType))),
+        args: groupByGenerated.args,
+        resolve: groupByGenerated.resolver,
+        ...complexity ? { extensions: { complexity: aggregateFieldComplexity(complexity) } } : {}
       };
     }
     for (const generated of [
@@ -2545,6 +2759,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)) {
@@ -2938,7 +3156,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]) => (0, import_drizzle_orm6.is)(value, import_pg_core2.PgTable));
   const tables = Object.fromEntries(tableEntries);
@@ -2961,7 +3188,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 = {};
@@ -2994,6 +3222,7 @@ function generateSchemaData2(db, schema, relations, options) {
       listFieldName,
       singleFieldName,
       aggregateFieldName,
+      groupByFieldName,
       createArrayFieldName,
       createSingleFieldName,
       upsertArrayFieldName,
@@ -3121,10 +3350,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,
@@ -3135,7 +3379,16 @@ function generateSchemaData2(db, schema, relations, options) {
       queries[aggregateGenerated.name] = {
         type: new import_graphql7.GraphQLNonNull(aggregateType),
         args: aggregateGenerated.args,
-        resolve: aggregateGenerated.resolver
+        resolve: aggregateGenerated.resolver,
+        ...complexity ? { extensions: { complexity: aggregateFieldComplexity(complexity) } } : {}
+      };
+    }
+    if (groupByGenerated && groupByType) {
+      queries[groupByGenerated.name] = {
+        type: new import_graphql7.GraphQLNonNull(new import_graphql7.GraphQLList(new import_graphql7.GraphQLNonNull(groupByType))),
+        args: groupByGenerated.args,
+        resolve: groupByGenerated.resolver,
+        ...complexity ? { extensions: { complexity: aggregateFieldComplexity(complexity) } } : {}
       };
     }
     if (insertArrGenerated) {
@@ -3196,6 +3449,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)) {
@@ -3527,7 +3784,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]) => (0, import_drizzle_orm7.is)(value, import_sqlite_core2.SQLiteTable));
@@ -3551,7 +3817,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 = {};
@@ -3584,6 +3851,7 @@ var generateSchemaData3 = (db, schema, relations, options) => {
       listFieldName,
       singleFieldName,
       aggregateFieldName,
+      groupByFieldName,
       createArrayFieldName,
       createSingleFieldName,
       upsertArrayFieldName,
@@ -3711,10 +3979,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,
@@ -3725,7 +4008,16 @@ var generateSchemaData3 = (db, schema, relations, options) => {
       queries[aggregateGenerated.name] = {
         type: new import_graphql8.GraphQLNonNull(aggregateType),
         args: aggregateGenerated.args,
-        resolve: aggregateGenerated.resolver
+        resolve: aggregateGenerated.resolver,
+        ...complexity ? { extensions: { complexity: aggregateFieldComplexity(complexity) } } : {}
+      };
+    }
+    if (groupByGenerated && groupByType) {
+      queries[groupByGenerated.name] = {
+        type: new import_graphql8.GraphQLNonNull(new import_graphql8.GraphQLList(new import_graphql8.GraphQLNonNull(groupByType))),
+        args: groupByGenerated.args,
+        resolve: groupByGenerated.resolver,
+        ...complexity ? { extensions: { complexity: aggregateFieldComplexity(complexity) } } : {}
       };
     }
     if (insertArrGenerated) {
@@ -3786,6 +4078,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)) {
@@ -3828,6 +4124,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,
@@ -3835,6 +4132,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) {
@@ -3861,7 +4163,8 @@ var buildSchema = (db, config) => {
     conflictDoNothing: config?.conflictDoNothing ?? false,
     typeNameMapper,
     shouldEagerLoad,
-    features
+    features,
+    complexity
   };
   let generatorOutput;
   if ((0, import_drizzle_orm8.is)(db, import_mysql_core3.MySqlDatabase)) {