@vantreeseba/drizzle-graphql 4.1.0 → 5.0.0

package/dist/index.js

@@ -41,6 +41,7 @@ import {
   GraphQLBoolean as GraphQLBoolean2,
   GraphQLEnumType as GraphQLEnumType2,
   GraphQLError as GraphQLError3,
+  GraphQLFloat as GraphQLFloat2,
   GraphQLInputObjectType as GraphQLInputObjectType2,
   GraphQLInt as GraphQLInt2,
   GraphQLList as GraphQLList2,
@@ -293,23 +294,6 @@ var remapFromGraphQLArrayInput = (queryInput, table) => {
   return queryInput;
 };
 
-// src/util/type-converter/index.ts
-import { extractExtendedColumnType, is as is2 } from "drizzle-orm";
-import { MySqlInt, MySqlSerial } from "drizzle-orm/mysql-core";
-import { PgDate, PgDateString, PgInteger, PgSerial, PgTimestamp, PgTimestampString, PgUUID } from "drizzle-orm/pg-core";
-import { SQLiteInteger } from "drizzle-orm/sqlite-core";
-import {
-  GraphQLBoolean,
-  GraphQLEnumType,
-  GraphQLFloat,
-  GraphQLInputObjectType,
-  GraphQLInt,
-  GraphQLList,
-  GraphQLNonNull,
-  GraphQLObjectType,
-  GraphQLString
-} from "graphql";
-
 // src/util/scalars/index.ts
 import { GraphQLError as GraphQLError2, GraphQLScalarType, Kind } from "graphql";
 import { GraphQLDate, GraphQLDateTime, GraphQLJSON, GraphQLUUID } from "graphql-scalars";
@@ -348,8 +332,54 @@ var GraphQLBigIntString = new GraphQLScalarType({
     return asDecimalString(ast.value);
   }
 });
+var numericStringPattern = /^[+-]?(\d+(\.\d*)?|\.\d+)([eE][+-]?\d+)?$/;
+var asNumericString = (value) => {
+  if (typeof value === "bigint") {
+    return value.toString();
+  }
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) {
+      throw new GraphQLError2(`Decimal cannot represent non-finite value: ${value}`);
+    }
+    return String(value);
+  }
+  if (typeof value === "string") {
+    if (!numericStringPattern.test(value)) {
+      throw new GraphQLError2(`Decimal cannot represent non-numeric value: "${value}"`);
+    }
+    return value;
+  }
+  throw new GraphQLError2(`Decimal cannot represent value: ${JSON.stringify(value)}`);
+};
+var GraphQLDecimalString = new GraphQLScalarType({
+  name: "Decimal",
+  description: "An arbitrary-precision decimal, transported as a numeric string so that values beyond JavaScript's double-precision range survive the round-trip intact.",
+  serialize: asNumericString,
+  parseValue: asNumericString,
+  parseLiteral: (ast) => {
+    if (ast.kind !== Kind.STRING && ast.kind !== Kind.INT && ast.kind !== Kind.FLOAT) {
+      throw new GraphQLError2(`Decimal cannot represent a ${ast.kind}`, { nodes: ast });
+    }
+    return asNumericString(ast.value);
+  }
+});
 
 // src/util/type-converter/index.ts
+import { extractExtendedColumnType, is as is2 } from "drizzle-orm";
+import { MySqlInt, MySqlSerial } from "drizzle-orm/mysql-core";
+import { PgDate, PgDateString, PgInteger, PgSerial, PgTimestamp, PgTimestampString, PgUUID } from "drizzle-orm/pg-core";
+import { SQLiteInteger } from "drizzle-orm/sqlite-core";
+import {
+  GraphQLBoolean,
+  GraphQLEnumType,
+  GraphQLFloat,
+  GraphQLInputObjectType,
+  GraphQLInt,
+  GraphQLList,
+  GraphQLNonNull,
+  GraphQLObjectType,
+  GraphQLString
+} from "graphql";
 var allowedNameChars = /^[a-zA-Z0-9_]+$/;
 var enumMap = /* @__PURE__ */ new WeakMap();
 var generateEnumCached = (column, columnName, tableName) => {
@@ -386,7 +416,7 @@ var geoXyInputType = new GraphQLInputObjectType({
   }
 });
 var columnToGraphQLCore = (column, columnName, tableName, isInput) => {
-  const { type: baseType } = extractExtendedColumnType(column);
+  const { type: baseType, constraint } = extractExtendedColumnType(column);
   switch (baseType) {
     case "boolean":
       return { type: GraphQLBoolean, description: "Boolean" };
@@ -405,6 +435,9 @@ var columnToGraphQLCore = (column, columnName, tableName, isInput) => {
       if (column.enumValues?.length) {
         return { type: generateEnumCached(column, columnName, tableName) };
       }
+      if (constraint === "numeric" && !column.dimensions) {
+        return { type: GraphQLDecimalString, description: "Decimal" };
+      }
       if (column instanceof PgTimestamp || column instanceof PgTimestampString) {
         return { type: GraphQLDateTime, description: "DateTime" };
       }
@@ -414,6 +447,15 @@ var columnToGraphQLCore = (column, columnName, tableName, isInput) => {
       if (column instanceof PgDateString) {
         return isInput ? { type: GraphQLString, description: "Date" } : { type: GraphQLDate, description: "Date" };
       }
+      {
+        const dims = column.dimensions;
+        if (dims !== void 0 && dims > 0) {
+          return {
+            type: new GraphQLList(new GraphQLNonNull(GraphQLString)),
+            description: "Array<String>"
+          };
+        }
+      }
       return { type: GraphQLString, description: "String" };
     case "bigint":
       return { type: GraphQLBigIntString, description: "BigInt" };
@@ -564,10 +606,10 @@ var resolveQueryExecutor = (db, context, tableName, buildTimeQueryBase) => {
     queryBase: buildTimeQueryBase ? executor?.query?.[tableName] ?? buildTimeQueryBase : buildTimeQueryBase
   };
 };
-var batchedPaginatedRelationQuery = async (db, targetTable, foreignCol, whereCondition, orderByArg, limit, offset, pkNames) => {
+var batchedPaginatedRelationQuery = async (db, targetTable, foreignCol, whereCondition, orderByArg, limit, offset, pkNames, orderCtx) => {
   const cols = getColumns(targetTable);
   const orderExprs = [
-    ...orderByArg ? extractOrderBy(targetTable, orderByArg) : [],
+    ...orderByArg ? extractOrderBy(targetTable, orderByArg, orderCtx) : [],
     ...primaryKeyOrderExprs(targetTable, pkNames)
   ];
   const orderClause = orderExprs.length ? sql` order by ${sql.join(orderExprs, sql`, `)}` : sql``;
@@ -631,12 +673,13 @@ var createRelationResolverFactory = (db, tables, filterCtx) => ({ tableName, rel
           orderByArg,
           limit ?? null,
           offset ?? null,
-          targetPkNames
+          targetPkNames,
+          relationFilterCtx(filterCtx, targetTableName)
         );
       } else {
         let q = executor.select().from(targetTable).where(whereCondition);
         if (orderByArg) {
-          q = q.orderBy(...extractOrderBy(targetTable, orderByArg));
+          q = q.orderBy(...extractOrderBy(targetTable, orderByArg, relationFilterCtx(filterCtx, targetTableName)));
         }
         rows = await q;
       }
@@ -725,6 +768,20 @@ var extractSelectedColumnsFromTreeSQLFormat = (tree, table, selectionCtx) => {
   }
   return Object.fromEntries(selectedColumns);
 };
+var orderNulls = new GraphQLEnumType2({
+  name: "OrderNulls",
+  description: "Where NULL values sort relative to non-NULL values",
+  values: {
+    first: {
+      value: "first",
+      description: "NULL values sort before all non-NULL values"
+    },
+    last: {
+      value: "last",
+      description: "NULL values sort after all non-NULL values"
+    }
+  }
+});
 var innerOrder = new GraphQLInputObjectType2({
   name: "InnerOrder",
   fields: {
@@ -749,6 +806,10 @@ var innerOrder = new GraphQLInputObjectType2({
     priority: {
       type: new GraphQLNonNull2(GraphQLInt2),
       description: "Priority of current field"
+    },
+    nulls: {
+      type: orderNulls,
+      description: "Where NULL values sort. Defaults to the database's own rule (PostgreSQL: last on asc, first on desc; MySQL/SQLite: first on asc, last on desc)"
     }
   }
 });
@@ -762,9 +823,25 @@ var resolveGenericFilterName = (column, columnName, columnGraphQLType) => {
   if (columnGraphQLType.type instanceof GraphQLEnumType2) {
     return columnGraphQLType.type.name;
   }
+  if (columnGraphQLType.type === GraphQLBigIntString) {
+    return "BigInt";
+  }
+  if (columnGraphQLType.type === GraphQLDecimalString) {
+    return "Decimal";
+  }
   if (columnGraphQLType.type instanceof GraphQLList2) {
     const desc2 = columnGraphQLType.description ?? "";
-    return desc2.includes("Integer") ? "IntArray" : "FloatArray";
+    let inner = columnGraphQLType.type.ofType;
+    if (inner instanceof GraphQLNonNull2) {
+      inner = inner.ofType;
+    }
+    if (desc2.includes("Integer") || inner === GraphQLInt2) {
+      return "IntArray";
+    }
+    if (desc2.includes("Float") || inner === GraphQLFloat2) {
+      return "FloatArray";
+    }
+    return "StringArray";
   }
   const ct = column.columnType ?? "";
   if (ct === "PgTimestamp" || ct === "PgTimestampString" || ct === "PgDate") {
@@ -777,12 +854,12 @@ var generateColumnFilterValues = (column, tableName, columnName, cacheCtx) => {
   const genericName = resolveGenericFilterName(column, columnName, columnGraphQLType);
   const cached = cacheCtx.genericFilterCache.get(genericName);
   if (cached) {
-    return cached.main;
+    return cached;
   }
   const colType = columnGraphQLType.type;
   const colDesc = columnGraphQLType.description;
   const colArr = new GraphQLList2(new GraphQLNonNull2(colType));
-  const isId = genericName === "Id";
+  const omitStringOps = genericName === "Id" || genericName === "BigInt" || genericName === "Decimal";
   const baseFields = {
     eq: { type: colType, description: colDesc },
     ne: { type: colType, description: colDesc },
@@ -790,31 +867,60 @@ var generateColumnFilterValues = (column, tableName, columnName, cacheCtx) => {
     lte: { type: colType, description: colDesc },
     gt: { type: colType, description: colDesc },
     gte: { type: colType, description: colDesc },
-    ...isId ? {} : {
+    ...omitStringOps ? {} : {
       like: { type: GraphQLString2 },
       notLike: { type: GraphQLString2 },
       ilike: { type: GraphQLString2 },
-      notIlike: { type: GraphQLString2 }
+      notIlike: { type: GraphQLString2 },
+      startsWith: {
+        type: GraphQLString2,
+        description: "Matches values starting with the given string. `%`, `_` and `\\` are matched literally."
+      },
+      endsWith: {
+        type: GraphQLString2,
+        description: "Matches values ending with the given string. `%`, `_` and `\\` are matched literally."
+      },
+      contains: {
+        type: GraphQLString2,
+        description: "Matches values containing the given string. `%`, `_` and `\\` are matched literally."
+      },
+      iStartsWith: {
+        type: GraphQLString2,
+        description: "Case-insensitive `startsWith`."
+      },
+      iEndsWith: {
+        type: GraphQLString2,
+        description: "Case-insensitive `endsWith`."
+      },
+      iContains: {
+        type: GraphQLString2,
+        description: "Case-insensitive `contains`."
+      }
     },
     inArray: { type: colArr, description: `Array<${colDesc}>` },
     notInArray: { type: colArr, description: `Array<${colDesc}>` },
     isNull: { type: GraphQLBoolean2 },
     isNotNull: { type: GraphQLBoolean2 }
   };
-  const orType = new GraphQLInputObjectType2({
-    name: `${genericName}FilterOr`,
-    fields: { ...baseFields }
-  });
   const mainType = new GraphQLInputObjectType2({
     name: `${genericName}Filter`,
-    fields: {
+    fields: () => ({
       ...baseFields,
       OR: {
-        type: new GraphQLList2(new GraphQLNonNull2(orType))
+        type: new GraphQLList2(new GraphQLNonNull2(mainType)),
+        description: "At least one branch matches; ANDed with any sibling operators"
+      },
+      AND: {
+        type: new GraphQLList2(new GraphQLNonNull2(mainType)),
+        description: "Every branch matches"
+      },
+      NOT: {
+        type: mainType,
+        description: "Negates the nested operators"
       }
-    }
+    })
   });
-  cacheCtx.genericFilterCache.set(genericName, { main: mainType, or: orType });
+  cacheCtx.genericFilterCache.set(genericName, mainType);
   return mainType;
 };
 var orderMap = /* @__PURE__ */ new WeakMap();
@@ -868,19 +974,53 @@ var generateTableSelectTypeFieldsCached = (table, tableName) => {
   fieldMap.set(table, remapped);
   return remapped;
 };
-var generateTableOrderTypeCached = (table, tableName, typeNameMapper, cacheCtx) => {
+var isFilterableRelation = (relation) => !relation.through;
+var generateRelationOrderFields = (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 || !is3(relation, One2) || !isFilterableRelation(relation)) {
+      continue;
+    }
+    fields[relationName] = {
+      type: generateTableOrderTypeCached(
+        targetTable,
+        relEntry.targetTableName,
+        typeNameMapper,
+        cacheCtx,
+        relationMap,
+        tables
+      ),
+      description: `Order by columns of the related ${relationName} row`
+    };
+  }
+  return fields;
+};
+var generateTableOrderTypeCached = (table, tableName, typeNameMapper, cacheCtx, relationMap, tables) => {
   if (cacheCtx.orderTypeCache.has(table)) {
     return cacheCtx.orderTypeCache.get(table);
   }
-  const orderColumns = generateTableOrderCached(table);
   const order = new GraphQLInputObjectType2({
     name: `${resolveTypeName(tableName, typeNameMapper)}OrderBy`,
-    fields: orderColumns
+    fields: () => {
+      const orderColumns = generateTableOrderCached(table);
+      return {
+        ...orderColumns,
+        ...generateRelationOrderFields(tableName, cacheCtx, typeNameMapper, orderColumns, relationMap, tables)
+      };
+    }
   });
   cacheCtx.orderTypeCache.set(table, order);
   return order;
 };
-var isFilterableRelation = (relation) => !relation.through;
 var generateListRelationFilterCached = (targetTable, targetTableName, cacheCtx, typeNameMapper, relationMap, tables) => {
   const cached = cacheCtx.listRelationFilterCache.get(targetTableName);
   if (cached) {
@@ -919,7 +1059,7 @@ var generateRelationFilterFields = (tableName, cacheCtx, typeNameMapper, columnF
     }
     const targetTable = tables[relEntry.targetTableName];
     const relation = relEntry.relation ?? relEntry;
-    if (!targetTable || !isFilterableRelation(relation)) {
+    if (!targetTable) {
       continue;
     }
     fields[relationName] = is3(relation, One2) ? {
@@ -956,16 +1096,21 @@ var generateTableFilterTypeCached = (table, tableName, cacheCtx, typeNameMapper,
       ...generateRelationFilterFields(tableName, cacheCtx, typeNameMapper, filterColumns, relationMap, tables)
     };
   };
-  const orFilters = new GraphQLInputObjectType2({
-    name: `${resolveTypeName(tableName, typeNameMapper)}FiltersOr`,
-    fields: buildFields
-  });
   const filters = new GraphQLInputObjectType2({
     name: `${resolveTypeName(tableName, typeNameMapper)}Filters`,
     fields: () => ({
       ...buildFields(),
       OR: {
-        type: new GraphQLList2(new GraphQLNonNull2(orFilters))
+        type: new GraphQLList2(new GraphQLNonNull2(filters)),
+        description: "At least one branch matches; ANDed with any sibling fields"
+      },
+      AND: {
+        type: new GraphQLList2(new GraphQLNonNull2(filters)),
+        description: "Every branch matches"
+      },
+      NOT: {
+        type: filters,
+        description: "Negates the nested filters"
       }
     })
   });
@@ -974,7 +1119,7 @@ var generateTableFilterTypeCached = (table, tableName, cacheCtx, typeNameMapper,
 };
 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 order = withOrder ? generateTableOrderTypeCached(table, tableName, typeNameMapper, cacheCtx, relationMap, tables) : void 0;
   const filters = generateTableFilterTypeCached(table, tableName, cacheCtx, typeNameMapper, relationMap, tables);
   const tableFields = generateTableSelectTypeFieldsCached(table, tableName);
   const relationsForTable = relationMap[tableName];
@@ -1060,10 +1205,11 @@ var generateSelectFields = (tables, tableName, relationMap, fromTableName, fromR
       }
       const resolve = resolverFactory?.({ tableName, relationName, relEntry, isOne });
       if (isOne) {
+        const isRequired = relation.optional === false;
         rawRelationFields.push([
           relationName,
           {
-            type: relType,
+            type: isRequired ? new GraphQLNonNull2(relType) : relType,
             args: {
               where: { type: relSelectData.filters }
             },
@@ -1201,28 +1347,95 @@ var generateTableTypes = (tableName, tables, relationMap, withReturning, relatio
     outputs
   };
 };
-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" ? asc(getColumns(table)[column]) : desc(getColumns(table)[column])
-);
-var extractFiltersColumn = (column, columnName, operators) => {
-  if (!operators.OR?.length) {
-    delete operators.OR;
+var orderByEntries = (orderArgs) => Object.entries(orderArgs).sort((a, b) => (b[1]?.priority ?? 0) - (a[1]?.priority ?? 0)).filter(([, config]) => config).map(([column, config]) => {
+  if (typeof config === "object" && config.direction === void 0) {
+    throw new GraphQLError3(`ORDER BY ${column}: ordering through a relation is not supported in this query`);
+  }
+  return [column, config.direction, config.nulls ?? void 0];
+});
+var orderExpressions = (expr, direction, nulls, dialectColumn) => {
+  const directed = direction === "asc" ? asc(expr) : desc(expr);
+  if (!nulls) {
+    return [directed];
+  }
+  const isMySql = (dialectColumn.columnType ?? "").startsWith("MySql");
+  if (isMySql) {
+    const nullsKey = nulls === "first" ? desc(sql`(${expr} is null)`) : asc(sql`(${expr} is null)`);
+    return [nullsKey, directed];
+  }
+  return [nulls === "first" ? sql`${directed} nulls first` : sql`${directed} nulls last`];
+};
+var extendRelationOrderChain = (parentTable, relationName, relEntry, ctx, chain) => {
+  const targetTable = ctx.tables[relEntry.targetTableName];
+  const relation = relEntry.relation ?? relEntry;
+  if (!targetTable || !is3(relation, One2) || !isFilterableRelation(relation)) {
+    throw new GraphQLError3(`ORDER BY ${relationName}: Relation cannot be used for ordering`);
   }
-  const entries = Object.entries(operators);
-  if (operators.OR) {
-    if (entries.length > 1) {
-      throw new GraphQLError3(`WHERE ${columnName}: Cannot specify both fields and 'OR' in column operators!`);
+  ctx.aliases ??= { n: 0 };
+  const aliasedTarget = aliasedTable(targetTable, `dgql_ord_${ctx.aliases.n++}`);
+  const joinCondition = buildRelationJoinCondition(parentTable, relation, aliasedTarget, relationName);
+  const relationWhere = relation.where ? relationsFilterToSQL(relation.isReversed ? parentTable : aliasedTarget, relation.where) : void 0;
+  return {
+    fromParts: [...chain?.fromParts ?? [], getTableAsAliasSQL(aliasedTarget)],
+    conditions: [
+      ...chain?.conditions ?? [],
+      ...joinCondition ? [joinCondition] : [],
+      ...relationWhere ? [relationWhere] : []
+    ],
+    table: aliasedTarget
+  };
+};
+var collectOrderEntries = (table, tableKey, orderArgs, ctx, chain, out) => {
+  const columns = getColumns(table);
+  const relations = ctx?.relationMap[tableKey];
+  for (const [key, config] of Object.entries(orderArgs)) {
+    if (config === null || config === void 0) {
+      continue;
     }
-    const variants2 = [];
-    for (const variant of operators.OR) {
-      const extracted = extractFiltersColumn(column, columnName, variant);
-      if (extracted) {
-        variants2.push(extracted);
-      }
+    const column = columns[key];
+    if (column) {
+      out.push({
+        expression: chain ? sql`(select ${column} from ${sql.join(chain.fromParts, sql`, `)} where ${and(...chain.conditions)})` : column,
+        column,
+        direction: config.direction,
+        nulls: config.nulls ?? void 0,
+        priority: config.priority ?? 0
+      });
+      continue;
+    }
+    const relEntry = relations?.[key];
+    if (!relEntry || !ctx) {
+      throw new GraphQLError3(`ORDER BY ${key}: Unknown column or relation`);
     }
-    return variants2.length ? variants2.length > 1 ? or(...variants2) : variants2[0] : void 0;
+    const nextChain = extendRelationOrderChain(chain?.table ?? table, key, relEntry, ctx, chain);
+    collectOrderEntries(nextChain.table, relEntry.targetTableName, config, ctx, nextChain, out);
+  }
+};
+var extractOrderBy = (table, orderArgs, ctx) => {
+  const entries = [];
+  collectOrderEntries(table, ctx?.tableKey ?? "", orderArgs, ctx, void 0, entries);
+  return entries.sort((a, b) => b.priority - a.priority).flatMap((entry) => orderExpressions(entry.expression, entry.direction, entry.nulls, entry.column));
+};
+var LIKE_ESCAPE_CHAR = "\\";
+var escapeLikeValue = (value) => value.replace(/[\\%_]/g, (char) => `\\${char}`);
+var safeLikeOps = {
+  startsWith: { buildPattern: (value) => `${escapeLikeValue(value)}%`, insensitive: false },
+  endsWith: { buildPattern: (value) => `%${escapeLikeValue(value)}`, insensitive: false },
+  contains: { buildPattern: (value) => `%${escapeLikeValue(value)}%`, insensitive: false },
+  iStartsWith: { buildPattern: (value) => `${escapeLikeValue(value)}%`, insensitive: true },
+  iEndsWith: { buildPattern: (value) => `%${escapeLikeValue(value)}`, insensitive: true },
+  iContains: { buildPattern: (value) => `%${escapeLikeValue(value)}%`, insensitive: true }
+};
+var safeLikeCondition = (column, pattern, insensitive) => {
+  if (!insensitive) {
+    return sql`${column} like ${pattern} escape ${LIKE_ESCAPE_CHAR}`;
   }
+  const isPg = (column.columnType ?? "").startsWith("Pg");
+  return isPg ? sql`${column} ilike ${pattern} escape ${LIKE_ESCAPE_CHAR}` : sql`lower(${column}) like ${pattern.toLowerCase()} escape ${LIKE_ESCAPE_CHAR}`;
+};
+var extractFiltersColumn = (column, columnName, operators) => {
+  const { OR, AND, NOT, ...restOperators } = operators;
+  const entries = Object.entries(restOperators);
   const singleValueOps = { eq, ne, gt, gte, lt, lte };
   const stringValueOps = { like, notLike, ilike, notIlike };
   const arrayValueOps = { inArray, notInArray };
@@ -1237,6 +1450,9 @@ var extractFiltersColumn = (column, columnName, operators) => {
       variants.push(singleValueOps[operatorName](column, singleValue));
     } else if (operatorName in stringValueOps) {
       variants.push(stringValueOps[operatorName](column, operatorValue));
+    } else if (operatorName in safeLikeOps) {
+      const { buildPattern, insensitive } = safeLikeOps[operatorName];
+      variants.push(safeLikeCondition(column, buildPattern(operatorValue), insensitive));
     } else if (operatorName in arrayValueOps) {
       if (!operatorValue.length) {
         throw new GraphQLError3(`WHERE ${columnName}: Unable to use operator ${operatorName} with an empty array!`);
@@ -1245,6 +1461,34 @@ var extractFiltersColumn = (column, columnName, operators) => {
       variants.push(arrayValueOps[operatorName](column, arrayValue));
     } else if (operatorName in nullableOps) {
       variants.push(nullableOps[operatorName](column));
+    } else {
+      throw new GraphQLError3(`WHERE ${columnName}: Unknown operator: ${operatorName}`);
+    }
+  }
+  if (AND?.length) {
+    for (const variant of AND) {
+      const extracted = extractFiltersColumn(column, columnName, variant);
+      if (extracted) {
+        variants.push(extracted);
+      }
+    }
+  }
+  if (NOT) {
+    const extracted = extractFiltersColumn(column, columnName, NOT);
+    if (extracted) {
+      variants.push(not(extracted));
+    }
+  }
+  if (OR?.length) {
+    const orVariants = [];
+    for (const variant of OR) {
+      const extracted = extractFiltersColumn(column, columnName, variant);
+      if (extracted) {
+        orVariants.push(extracted);
+      }
+    }
+    if (orVariants.length) {
+      variants.push(orVariants.length > 1 ? or(...orVariants) : orVariants[0]);
     }
   }
   return variants.length ? variants.length > 1 ? and(...variants) : variants[0] : void 0;
@@ -1269,39 +1513,105 @@ var buildRelationJoinCondition = (parentTable, relation, aliasedTarget, relation
   }
   return conditions.length > 1 ? and(...conditions) : conditions[0];
 };
+var resolveJunctionColumn = (aliasedThrough, junctionRef, relationName) => {
+  const throughColumns = getColumns(aliasedThrough);
+  const key = junctionRef?._?.key;
+  const byKey = key ? throughColumns[key] : void 0;
+  if (byKey) {
+    return byKey;
+  }
+  const columnName = junctionRef?._?.column?.name;
+  const byName = columnName ? Object.values(throughColumns).find((c) => c.name === columnName) : void 0;
+  if (!byName) {
+    throw new GraphQLError3(`WHERE ${relationName}: Relation cannot be used as a filter`);
+  }
+  return byName;
+};
+var buildThroughJoinConditions = (parentTable, relation, aliasedThrough, aliasedTarget, relationName) => {
+  const sourceColumns = relation.sourceColumns;
+  const targetColumns = relation.targetColumns;
+  const through = relation.through;
+  if (!sourceColumns?.length || !targetColumns?.length || through?.source.length !== sourceColumns.length || through.target.length !== targetColumns.length) {
+    throw new GraphQLError3(`WHERE ${relationName}: Relation cannot be used as a filter`);
+  }
+  const parentColumns = Object.values(getColumns(parentTable));
+  const targetTableColumns = Object.values(getColumns(aliasedTarget));
+  const correlationConditions = [];
+  for (let i = 0; i < sourceColumns.length; i++) {
+    const localColumn = parentColumns.find((c) => c.name === sourceColumns[i].name);
+    if (!localColumn) {
+      throw new GraphQLError3(`WHERE ${relationName}: Relation cannot be used as a filter`);
+    }
+    correlationConditions.push(eq(localColumn, resolveJunctionColumn(aliasedThrough, through.source[i], relationName)));
+  }
+  const junctionJoinConditions = [];
+  for (let i = 0; i < targetColumns.length; i++) {
+    const foreignColumn = targetTableColumns.find((c) => c.name === targetColumns[i].name);
+    if (!foreignColumn) {
+      throw new GraphQLError3(`WHERE ${relationName}: Relation cannot be used as a filter`);
+    }
+    junctionJoinConditions.push(
+      eq(resolveJunctionColumn(aliasedThrough, through.target[i], relationName), foreignColumn)
+    );
+  }
+  return {
+    correlation: correlationConditions.length > 1 ? and(...correlationConditions) : correlationConditions[0],
+    junctionJoin: junctionJoinConditions.length > 1 ? and(...junctionJoinConditions) : junctionJoinConditions[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)) {
+  if (!targetTable) {
     throw new GraphQLError3(`WHERE ${relationName}: Relation cannot be used as a filter`);
   }
   ctx.aliases ??= { n: 0 };
   const aliases = ctx.aliases;
   const aliasedTarget = aliasedTable(targetTable, `dgql_rel_${aliases.n++}`);
-  const joinCondition = buildRelationJoinCondition(parentTable, relation, aliasedTarget, relationName);
+  const throughTable = relation.throughTable;
+  let fromClause;
+  let joinCondition;
+  if (throughTable) {
+    const aliasedThrough = aliasedTable(throughTable, `dgql_rel_${aliases.n++}`);
+    const { correlation, junctionJoin } = buildThroughJoinConditions(
+      parentTable,
+      relation,
+      aliasedThrough,
+      aliasedTarget,
+      relationName
+    );
+    fromClause = sql`${getTableAsAliasSQL(aliasedTarget)} inner join ${getTableAsAliasSQL(aliasedThrough)} on ${junctionJoin}`;
+    joinCondition = correlation;
+  } else {
+    fromClause = getTableAsAliasSQL(aliasedTarget);
+    joinCondition = buildRelationJoinCondition(parentTable, relation, aliasedTarget, relationName);
+  }
   const relationWhere = relation.where ? 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 sql`not exists (select 1 from ${getTableAsAliasSQL(aliasedTarget)} where ${and(joinCondition, relationWhere, not(inner))})`;
+    return sql`not exists (select 1 from ${fromClause} where ${and(joinCondition, relationWhere, not(inner))})`;
   }
   const condition = and(joinCondition, relationWhere, inner);
-  return mode === "none" ? sql`not exists (select 1 from ${getTableAsAliasSQL(aliasedTarget)} where ${condition})` : sql`exists (select 1 from ${getTableAsAliasSQL(aliasedTarget)} where ${condition})`;
+  return mode === "none" ? sql`not exists (select 1 from ${fromClause} where ${condition})` : sql`exists (select 1 from ${fromClause} where ${condition})`;
 };
 var extractRelationFilter = (parentTable, relationName, relEntry, value, ctx) => {
   const relation = relEntry.relation ?? relEntry;
   if (is3(relation, One2)) {
     return buildRelationExists(parentTable, relationName, relEntry, value, "some", ctx);
   }
+  const relationMatchModes = ["some", "none", "every"];
   const variants = [];
-  for (const mode of ["some", "none", "every"]) {
-    const inner = value[mode];
+  for (const [mode, inner] of Object.entries(value)) {
     if (inner === void 0 || inner === null) {
       continue;
     }
+    if (!relationMatchModes.includes(mode)) {
+      throw new GraphQLError3(`WHERE ${relationName}: Unknown relation filter key: ${mode}`);
+    }
     const extracted = buildRelationExists(parentTable, relationName, relEntry, inner, mode, ctx);
     if (extracted) {
       variants.push(extracted);
@@ -1310,26 +1620,8 @@ var extractRelationFilter = (parentTable, relationName, relEntry, value, ctx) =>
   return variants.length ? variants.length > 1 ? and(...variants) : variants[0] : void 0;
 };
 var extractFilters = (table, tableName, filters, relationCtx) => {
-  if (!filters.OR?.length) {
-    delete filters.OR;
-  }
-  const entries = Object.entries(filters);
-  if (!entries.length) {
-    return;
-  }
-  if (filters.OR) {
-    if (entries.length > 1) {
-      throw new GraphQLError3(`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, relationCtx);
-      if (extracted) {
-        variants2.push(extracted);
-      }
-    }
-    return variants2.length ? variants2.length > 1 ? or(...variants2) : variants2[0] : void 0;
-  }
+  const { OR, AND, NOT, ...fieldFilters } = filters;
+  const entries = Object.entries(fieldFilters);
   const columns = getColumns(table);
   const relations = relationCtx?.relationMap[relationCtx.tableKey];
   const variants = [];
@@ -1338,11 +1630,40 @@ var extractFilters = (table, tableName, filters, relationCtx) => {
       continue;
     }
     const column = columns[fieldName];
-    const extracted = column ? extractFiltersColumn(column, fieldName, operators) : relations?.[fieldName] && relationCtx ? extractRelationFilter(table, fieldName, relations[fieldName], operators, relationCtx) : void 0;
+    if (!column && !(relations?.[fieldName] && relationCtx)) {
+      throw new GraphQLError3(`WHERE ${tableName}: Unknown filter key: ${fieldName}`);
+    }
+    const extracted = column ? extractFiltersColumn(column, fieldName, operators) : extractRelationFilter(table, fieldName, relations[fieldName], operators, relationCtx);
     if (extracted) {
       variants.push(extracted);
     }
   }
+  if (AND?.length) {
+    for (const variant of AND) {
+      const extracted = extractFilters(table, tableName, variant, relationCtx);
+      if (extracted) {
+        variants.push(extracted);
+      }
+    }
+  }
+  if (NOT) {
+    const extracted = extractFilters(table, tableName, NOT, relationCtx);
+    if (extracted) {
+      variants.push(not(extracted));
+    }
+  }
+  if (OR?.length) {
+    const orVariants = [];
+    for (const variant of OR) {
+      const extracted = extractFilters(table, tableName, variant, relationCtx);
+      if (extracted) {
+        orVariants.push(extracted);
+      }
+    }
+    if (orVariants.length) {
+      variants.push(orVariants.length > 1 ? or(...orVariants) : orVariants[0]);
+    }
+  }
   return variants.length ? variants.length > 1 ? and(...variants) : variants[0] : void 0;
 };
 var extractRelationsParamsInner = (relationMap, tables, tableName, typeName, originField, typeNameMapper, _isInitial = false, filterCtx) => {
@@ -1384,7 +1705,7 @@ var extractRelationsParamsInner = (relationMap, tables, tableName, typeName, ori
     } : void 0;
     const hasPagination = offset != null || limit != null;
     const pkNames = targetPkNames ?? [];
-    thisRecord.orderBy = relationArgs?.orderBy ? (aliasedTable2) => extractOrderBy(aliasedTable2, relationArgs.orderBy) : hasPagination && pkNames.length ? (aliasedTable2) => primaryKeyOrderExprs(aliasedTable2, pkNames) : void 0;
+    thisRecord.orderBy = relationArgs?.orderBy ? (aliasedTable2) => extractOrderBy(aliasedTable2, relationArgs.orderBy, relationFilterCtx(filterCtx, targetTableName)) : hasPagination && pkNames.length ? (aliasedTable2) => primaryKeyOrderExprs(aliasedTable2, pkNames) : void 0;
     thisRecord.offset = offset;
     thisRecord.limit = limit;
     const relWith = relationField ? extractRelationsParamsInner(
@@ -1625,7 +1946,9 @@ var selectDistinctKeys = async (params) => {
   }
   const orderEntries = orderBy ? orderByEntries(orderBy) : [];
   const windowOrder = [
-    ...orderEntries.map(([column, direction]) => direction === "asc" ? asc(cols[column]) : desc(cols[column])),
+    ...orderEntries.flatMap(
+      ([column, direction, nulls]) => orderExpressions(cols[column], direction, nulls, cols[column])
+    ),
     ...primaryKeyOrderExprs(table, pkNames)
   ];
   const rowNumber = sql`row_number() over (partition by ${sql.join(partitionCols, sql`, `)} order by ${sql.join(
@@ -1634,7 +1957,9 @@ var selectDistinctKeys = async (params) => {
   )})`.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" ? asc(sub[column]) : desc(sub[column])),
+    ...orderEntries.flatMap(
+      ([column, direction, nulls]) => orderExpressions(sub[column], direction, nulls, cols[column])
+    ),
     ...pkNames.filter((name) => sub[name]).map((name) => asc(sub[name]))
   ];
   let query = db.select(Object.fromEntries(pkNames.map((name) => [name, sub[name]]))).from(sub).where(eq(sub[DISTINCT_RN], 1)).orderBy(...outerOrder);
@@ -1725,6 +2050,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";
@@ -1732,19 +2058,38 @@ var computeResolverFieldNames = (tableName, typeNameMapper, prefixes, suffixes)
   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)}`;
+  const writeSingleSuffix = suffixes.single === "" ? "Single" : suffixes.single;
+  const updateSingleFieldName = `${updateFieldName}${writeSingleSuffix}`;
+  const deleteSingleFieldName = `${deleteFieldName}${writeSingleSuffix}`;
   return {
     typeName,
     listFieldName,
     singleFieldName,
     aggregateFieldName,
+    groupByFieldName,
     createArrayFieldName,
     createSingleFieldName,
     upsertArrayFieldName,
     upsertSingleFieldName,
     updateFieldName,
-    deleteFieldName
+    updateSingleFieldName,
+    deleteFieldName,
+    deleteSingleFieldName
   };
 };
+var extractRequiredFilters = (table, tableName, where, fieldName, relationCtx) => {
+  const filters = where ? extractFilters(table, tableName, where, relationCtx) : void 0;
+  if (!filters) {
+    throw new GraphQLError3(`${fieldName} requires a 'where' argument with at least one filter!`);
+  }
+  return filters;
+};
+var assertSingleMatch = async (executor, table, filters, fieldName) => {
+  const matched = await executor.select({ found: sql`1` }).from(table).where(filters).limit(2);
+  if (matched.length > 1) {
+    throw new GraphQLError3(`${fieldName}: 'where' matched more than one row \u2014 nothing was written!`);
+  }
+};
 var selectArrayArgs = (orderArgs, filterArgs, distinctEnum) => ({
   offset: { type: GraphQLInt2 },
   limit: { type: GraphQLInt2 },
@@ -1803,9 +2148,9 @@ var runRelationalSelect = async (opts) => {
     // drizzle-orm v1 RQB calls orderBy/where with the aliased table proxy — use it
     // directly so column refs match the CTE alias.
     orderBy: distinctKeys ? (aliasedTable2) => [
-      ...orderBy ? extractOrderBy(aliasedTable2, orderBy) : [],
+      ...orderBy ? extractOrderBy(aliasedTable2, orderBy, relationFilterCtx(filterCtx, tableName)) : [],
       ...primaryKeyOrderExprs(aliasedTable2, pkNames)
-    ] : orderBy ? (aliasedTable2) => extractOrderBy(aliasedTable2, orderBy) : needsDefaultOrder && pkNames?.length ? (aliasedTable2) => primaryKeyOrderExprs(aliasedTable2, pkNames) : void 0,
+    ] : orderBy ? (aliasedTable2) => extractOrderBy(aliasedTable2, orderBy, relationFilterCtx(filterCtx, tableName)) : 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,
@@ -1892,7 +2237,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 +2250,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 {
-  GraphQLFloat as GraphQLFloat2,
+  GraphQLError as GraphQLError4,
+  GraphQLFloat as GraphQLFloat3,
+  GraphQLInputObjectType as GraphQLInputObjectType3,
   GraphQLInt as GraphQLInt3,
   GraphQLList as GraphQLList3,
   GraphQLNonNull as GraphQLNonNull3,
@@ -1970,7 +2323,7 @@ var generateAggregateTypes = (table, tableName, typeName, cacheCtx) => {
       fields[op] = {
         type: new GraphQLObjectType3({
           name: `${typeName}${capitalize(op)}Aggregate`,
-          fields: Object.fromEntries(Object.keys(numeric).map((columnName) => [columnName, { type: GraphQLFloat2 }]))
+          fields: Object.fromEntries(Object.keys(numeric).map((columnName) => [columnName, { type: GraphQLFloat3 }]))
         })
       };
     }
@@ -2034,9 +2387,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 +2527,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: GraphQLFloat3 }]))
+});
+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 +2799,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 +2847,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,
@@ -2341,13 +2872,13 @@ var generateUpsert = (db, table, baseType, onConflictType, fieldName, single) =>
     args: queryArgs
   };
 };
-var generateUpdate = (db, tableName, table, setArgs, filterArgs, fieldName, filterCtx) => {
+var generateUpdate = (db, tableName, table, setArgs, filterArgs, fieldName, single, requireWhere, filterCtx) => {
   const queryArgs = {
     set: {
       type: new GraphQLNonNull4(setArgs)
     },
     where: {
-      type: filterArgs
+      type: single || requireWhere ? new GraphQLNonNull4(filterArgs) : filterArgs
     }
   };
   return {
@@ -2357,12 +2888,16 @@ 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 relationCtx = relationFilterCtx(filterCtx, tableName);
+        const filters = single || requireWhere ? extractRequiredFilters(table, tableName, where, fieldName, relationCtx) : where ? extractFilters(table, tableName, where, relationCtx) : void 0;
         const executor = resolveExecutor(db, context);
+        if (single) {
+          await assertSingleMatch(executor, table, filters, fieldName);
+        }
         let query = executor.update(table).set(input);
-        if (where) {
-          const filters = extractFilters(table, tableName, where, relationFilterCtx(filterCtx, tableName));
+        if (filters) {
           query = query.where(filters);
         }
         await query;
@@ -2374,10 +2909,10 @@ var generateUpdate = (db, tableName, table, setArgs, filterArgs, fieldName, filt
     args: queryArgs
   };
 };
-var generateDelete = (db, tableName, table, filterArgs, fieldName, filterCtx) => {
+var generateDelete = (db, tableName, table, filterArgs, fieldName, single, requireWhere, filterCtx) => {
   const queryArgs = {
     where: {
-      type: filterArgs
+      type: single || requireWhere ? new GraphQLNonNull4(filterArgs) : filterArgs
     }
   };
   return {
@@ -2385,10 +2920,14 @@ var generateDelete = (db, tableName, table, filterArgs, fieldName, filterCtx) =>
     resolver: async (_source, args, context, _info) => {
       try {
         const { where } = args;
+        const relationCtx = relationFilterCtx(filterCtx, tableName);
+        const filters = single || requireWhere ? extractRequiredFilters(table, tableName, where, fieldName, relationCtx) : where ? extractFilters(table, tableName, where, relationCtx) : void 0;
         const executor = resolveExecutor(db, context);
+        if (single) {
+          await assertSingleMatch(executor, table, filters, fieldName);
+        }
         let query = executor.delete(table);
-        if (where) {
-          const filters = extractFilters(table, tableName, where, relationFilterCtx(filterCtx, tableName));
+        if (filters) {
           query = query.where(filters);
         }
         await query;
@@ -2471,12 +3010,15 @@ var generateSchemaData = (db, schema, relations, options) => {
       listFieldName,
       singleFieldName,
       aggregateFieldName,
+      groupByFieldName,
       createArrayFieldName,
       createSingleFieldName,
       upsertArrayFieldName,
       upsertSingleFieldName,
       updateFieldName,
-      deleteFieldName
+      updateSingleFieldName,
+      deleteFieldName,
+      deleteSingleFieldName
     } = computeResolverFieldNames(tableName, typeNameMapper, prefixes, suffixes);
     const selectArrGenerated = generateSelectArray(
       db,
@@ -2521,9 +3063,41 @@ var generateSchemaData = (db, schema, relations, options) => {
       updateInput,
       tableFilters,
       updateFieldName,
+      false,
+      features.requireWhere,
+      filterCtx
+    ) : void 0;
+    const updateSingleGenerated = features.update ? generateUpdate(
+      db,
+      tableName,
+      schema[tableName],
+      updateInput,
+      tableFilters,
+      updateSingleFieldName,
+      true,
+      features.requireWhere,
+      filterCtx
+    ) : void 0;
+    const deleteGenerated = features.delete ? generateDelete(
+      db,
+      tableName,
+      schema[tableName],
+      tableFilters,
+      deleteFieldName,
+      false,
+      features.requireWhere,
+      filterCtx
+    ) : void 0;
+    const deleteSingleGenerated = features.delete ? generateDelete(
+      db,
+      tableName,
+      schema[tableName],
+      tableFilters,
+      deleteSingleFieldName,
+      true,
+      features.requireWhere,
       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,
@@ -2534,6 +3108,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,13 +3141,23 @@ 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,
       upsertArrGenerated,
       upsertSingleGenerated,
       updateGenerated,
-      deleteGenerated
+      updateSingleGenerated,
+      deleteGenerated,
+      deleteSingleGenerated
     ]) {
       if (generated) {
         mutations[generated.name] = {
@@ -2584,6 +3182,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 +3208,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";
@@ -2675,7 +3277,7 @@ var generateSelectArray2 = (db, tableName, tables, relationMap, orderArgs, filte
         }
         if (orderBy) {
           q = q.orderBy(
-            ...extractOrderBy(table, orderBy),
+            ...extractOrderBy(table, orderBy, relationFilterCtx(filterCtx, tableName)),
             ...distinctKeys ? primaryKeyOrderExprs(table, pkNames) : []
           );
         } else if ((distinctKeys || offset != null || limit != null) && pkNames.length) {
@@ -2736,7 +3338,7 @@ var generateSelectSingle2 = (db, tableName, tables, relationMap, orderArgs, filt
           q = q.where(extractFilters(table, tableName, where, relationFilterCtx(filterCtx, tableName)));
         }
         if (orderBy) {
-          q = q.orderBy(...extractOrderBy(table, orderBy));
+          q = q.orderBy(...extractOrderBy(table, orderBy, relationFilterCtx(filterCtx, tableName)));
         } else if (pkNames.length) {
           q = q.orderBy(...primaryKeyOrderExprs(table, pkNames));
         }
@@ -2767,7 +3369,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 +3459,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({
@@ -2896,13 +3498,13 @@ var generateUpsert2 = (db, tableName, table, tables, relationMap, baseType, onCo
     args: queryArgs
   };
 };
-var generateUpdate2 = (db, tableName, table, tables, relationMap, setArgs, filterArgs, fieldName, typeName, typeNameMapper, filterCtx) => {
+var generateUpdate2 = (db, tableName, table, tables, relationMap, setArgs, filterArgs, fieldName, typeName, single, requireWhere, typeNameMapper, filterCtx) => {
   const queryArgs = {
     set: {
       type: new GraphQLNonNull5(setArgs)
     },
     where: {
-      type: filterArgs
+      type: single || requireWhere ? new GraphQLNonNull5(filterArgs) : filterArgs
     }
   };
   const pkNames = pgPrimaryKeyPropNames(table);
@@ -2926,18 +3528,28 @@ 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 relationCtx = relationFilterCtx(filterCtx, tableName);
+        const filters = single || requireWhere ? extractRequiredFilters(table, tableName, where, fieldName, relationCtx) : where ? extractFilters(table, tableName, where, relationCtx) : void 0;
         const executor = resolveExecutor(db, context);
+        if (single) {
+          await assertSingleMatch(executor, table, filters, fieldName);
+        }
         let query = executor.update(table).set(input);
-        if (where) {
-          const filters = extractFilters(table, tableName, where, relationFilterCtx(filterCtx, tableName));
+        if (filters) {
           query = query.where(filters);
         }
         query = query.returning(columns);
         const result = await query;
+        if (single && result.length > 1) {
+          throw new GraphQLError6(`${fieldName}: 'where' matched more than one row!`);
+        }
+        if (single && !result[0]) {
+          return void 0;
+        }
         const enriched = hasRelations ? await eagerLoadMutationRelations(executor, tableName, result, pkNames, withParams) : result;
-        return remapToGraphQLArrayOutput(enriched, tableName, table, relationMap);
+        return single ? remapToGraphQLSingleOutput(enriched[0], tableName, table, relationMap) : remapToGraphQLArrayOutput(enriched, tableName, table, relationMap);
       } catch (e) {
         throw toGraphQLError(e);
       }
@@ -2945,10 +3557,10 @@ var generateUpdate2 = (db, tableName, table, tables, relationMap, setArgs, filte
     args: queryArgs
   };
 };
-var generateDelete2 = (db, tableName, table, filterArgs, fieldName, typeName, filterCtx, selectionCtx) => {
+var generateDelete2 = (db, tableName, table, filterArgs, fieldName, typeName, single, requireWhere, filterCtx, selectionCtx) => {
   const queryArgs = {
     where: {
-      type: filterArgs
+      type: single || requireWhere ? new GraphQLNonNull5(filterArgs) : filterArgs
     }
   };
   return {
@@ -2964,14 +3576,24 @@ var generateDelete2 = (db, tableName, table, filterArgs, fieldName, typeName, fi
           table,
           selectionCtx
         );
+        const relationCtx = relationFilterCtx(filterCtx, tableName);
+        const filters = single || requireWhere ? extractRequiredFilters(table, tableName, where, fieldName, relationCtx) : where ? extractFilters(table, tableName, where, relationCtx) : void 0;
         const executor = resolveExecutor(db, context);
+        if (single) {
+          await assertSingleMatch(executor, table, filters, fieldName);
+        }
         let query = executor.delete(table);
-        if (where) {
-          const filters = extractFilters(table, tableName, where, relationFilterCtx(filterCtx, tableName));
+        if (filters) {
           query = query.where(filters);
         }
         query = query.returning(columns);
         const result = await query;
+        if (single && result.length > 1) {
+          throw new GraphQLError6(`${fieldName}: 'where' matched more than one row!`);
+        }
+        if (single) {
+          return result[0] ? remapToGraphQLSingleOutput(result[0], tableName, table) : void 0;
+        }
         return remapToGraphQLArrayOutput(result, tableName, table);
       } catch (e) {
         throw toGraphQLError(e);
@@ -3047,12 +3669,15 @@ function generateSchemaData2(db, schema, relations, options) {
       listFieldName,
       singleFieldName,
       aggregateFieldName,
+      groupByFieldName,
       createArrayFieldName,
       createSingleFieldName,
       upsertArrayFieldName,
       upsertSingleFieldName,
       updateFieldName,
-      deleteFieldName
+      updateSingleFieldName,
+      deleteFieldName,
+      deleteSingleFieldName
     } = computeResolverFieldNames(tableName, typeNameMapper, prefixes, suffixes);
     const selectArrGenerated = generateSelectArray2(
       db,
@@ -3151,6 +3776,23 @@ function generateSchemaData2(db, schema, relations, options) {
       tableFilters,
       updateFieldName,
       typeName,
+      false,
+      features.requireWhere,
+      typeNameMapper,
+      filterCtx
+    ) : void 0;
+    const updateSingleGenerated = features.update ? generateUpdate2(
+      db,
+      tableName,
+      schema[tableName],
+      tables,
+      eagerRelations,
+      updateInput,
+      tableFilters,
+      updateSingleFieldName,
+      typeName,
+      true,
+      features.requireWhere,
       typeNameMapper,
       filterCtx
     ) : void 0;
@@ -3161,6 +3803,20 @@ function generateSchemaData2(db, schema, relations, options) {
       tableFilters,
       deleteFieldName,
       typeName,
+      false,
+      features.requireWhere,
+      filterCtx,
+      { tableName, relationMap: namedRelations, tables }
+    ) : void 0;
+    const deleteSingleGenerated = features.delete ? generateDelete2(
+      db,
+      tableName,
+      schema[tableName],
+      tableFilters,
+      deleteSingleFieldName,
+      typeName,
+      true,
+      features.requireWhere,
       filterCtx,
       { tableName, relationMap: namedRelations, tables }
     ) : void 0;
@@ -3174,6 +3830,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 +3863,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,
@@ -3228,6 +3906,13 @@ function generateSchemaData2(db, schema, relations, options) {
         resolve: updateGenerated.resolver
       };
     }
+    if (updateSingleGenerated) {
+      mutations[updateSingleGenerated.name] = {
+        type: singleTableItemOutput,
+        args: updateSingleGenerated.args,
+        resolve: updateSingleGenerated.resolver
+      };
+    }
     if (deleteGenerated) {
       mutations[deleteGenerated.name] = {
         type: arrTableItemOutput,
@@ -3235,6 +3920,13 @@ function generateSchemaData2(db, schema, relations, options) {
         resolve: deleteGenerated.resolver
       };
     }
+    if (deleteSingleGenerated) {
+      mutations[deleteSingleGenerated.name] = {
+        type: singleTableItemOutput,
+        args: deleteSingleGenerated.args,
+        resolve: deleteSingleGenerated.resolver
+      };
+    }
     const activeInputs = [
       // The insert input types the upsert mutations too, so either feature keeps it.
       ...features.insert || onConflictInput ? [insertInput] : [],
@@ -3251,6 +3943,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 +3969,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 +4068,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 +4158,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({
@@ -3501,13 +4197,13 @@ var generateUpsert3 = (db, tableName, table, tables, relationMap, baseType, onCo
     args: queryArgs
   };
 };
-var generateUpdate3 = (db, tableName, table, tables, relationMap, setArgs, filterArgs, fieldName, typeName, typeNameMapper, filterCtx) => {
+var generateUpdate3 = (db, tableName, table, tables, relationMap, setArgs, filterArgs, fieldName, typeName, single, requireWhere, typeNameMapper, filterCtx) => {
   const queryArgs = {
     set: {
       type: new GraphQLNonNull6(setArgs)
     },
     where: {
-      type: filterArgs
+      type: single || requireWhere ? new GraphQLNonNull6(filterArgs) : filterArgs
     }
   };
   const pkNames = sqlitePrimaryKeyPropNames(table);
@@ -3531,18 +4227,28 @@ 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 relationCtx = relationFilterCtx(filterCtx, tableName);
+        const filters = single || requireWhere ? extractRequiredFilters(table, tableName, where, fieldName, relationCtx) : where ? extractFilters(table, tableName, where, relationCtx) : void 0;
         const executor = resolveExecutor(db, context);
+        if (single) {
+          await assertSingleMatch(executor, table, filters, fieldName);
+        }
         let query = executor.update(table).set(input);
-        if (where) {
-          const filters = extractFilters(table, tableName, where, relationFilterCtx(filterCtx, tableName));
+        if (filters) {
           query = query.where(filters);
         }
         query = query.returning(columns);
         const result = await query;
+        if (single && result.length > 1) {
+          throw new GraphQLError7(`${fieldName}: 'where' matched more than one row!`);
+        }
+        if (single && !result[0]) {
+          return void 0;
+        }
         const enriched = hasRelations ? await eagerLoadMutationRelations(executor, tableName, result, pkNames, withParams) : result;
-        return remapToGraphQLArrayOutput(enriched, tableName, table, relationMap);
+        return single ? remapToGraphQLSingleOutput(enriched[0], tableName, table, relationMap) : remapToGraphQLArrayOutput(enriched, tableName, table, relationMap);
       } catch (e) {
         throw toGraphQLError(e);
       }
@@ -3550,10 +4256,10 @@ var generateUpdate3 = (db, tableName, table, tables, relationMap, setArgs, filte
     args: queryArgs
   };
 };
-var generateDelete3 = (db, tableName, table, filterArgs, fieldName, typeName, filterCtx, selectionCtx) => {
+var generateDelete3 = (db, tableName, table, filterArgs, fieldName, typeName, single, requireWhere, filterCtx, selectionCtx) => {
   const queryArgs = {
     where: {
-      type: filterArgs
+      type: single || requireWhere ? new GraphQLNonNull6(filterArgs) : filterArgs
     }
   };
   return {
@@ -3569,14 +4275,24 @@ var generateDelete3 = (db, tableName, table, filterArgs, fieldName, typeName, fi
           table,
           selectionCtx
         );
+        const relationCtx = relationFilterCtx(filterCtx, tableName);
+        const filters = single || requireWhere ? extractRequiredFilters(table, tableName, where, fieldName, relationCtx) : where ? extractFilters(table, tableName, where, relationCtx) : void 0;
         const executor = resolveExecutor(db, context);
+        if (single) {
+          await assertSingleMatch(executor, table, filters, fieldName);
+        }
         let query = executor.delete(table);
-        if (where) {
-          const filters = extractFilters(table, tableName, where, relationFilterCtx(filterCtx, tableName));
+        if (filters) {
           query = query.where(filters);
         }
         query = query.returning(columns);
         const result = await query;
+        if (single && result.length > 1) {
+          throw new GraphQLError7(`${fieldName}: 'where' matched more than one row!`);
+        }
+        if (single) {
+          return result[0] ? remapToGraphQLSingleOutput(result[0], tableName, table) : void 0;
+        }
         return remapToGraphQLArrayOutput(result, tableName, table);
       } catch (e) {
         throw toGraphQLError(e);
@@ -3653,12 +4369,15 @@ var generateSchemaData3 = (db, schema, relations, options) => {
       listFieldName,
       singleFieldName,
       aggregateFieldName,
+      groupByFieldName,
       createArrayFieldName,
       createSingleFieldName,
       upsertArrayFieldName,
       upsertSingleFieldName,
       updateFieldName,
-      deleteFieldName
+      updateSingleFieldName,
+      deleteFieldName,
+      deleteSingleFieldName
     } = computeResolverFieldNames(tableName, typeNameMapper, prefixes, suffixes);
     const selectArrGenerated = generateSelectArray3(
       db,
@@ -3757,6 +4476,23 @@ var generateSchemaData3 = (db, schema, relations, options) => {
       tableFilters,
       updateFieldName,
       typeName,
+      false,
+      features.requireWhere,
+      typeNameMapper,
+      filterCtx
+    ) : void 0;
+    const updateSingleGenerated = features.update ? generateUpdate3(
+      db,
+      tableName,
+      schema[tableName],
+      tables,
+      eagerRelations,
+      updateInput,
+      tableFilters,
+      updateSingleFieldName,
+      typeName,
+      true,
+      features.requireWhere,
       typeNameMapper,
       filterCtx
     ) : void 0;
@@ -3767,6 +4503,20 @@ var generateSchemaData3 = (db, schema, relations, options) => {
       tableFilters,
       deleteFieldName,
       typeName,
+      false,
+      features.requireWhere,
+      filterCtx,
+      { tableName, relationMap: namedRelations, tables }
+    ) : void 0;
+    const deleteSingleGenerated = features.delete ? generateDelete3(
+      db,
+      tableName,
+      schema[tableName],
+      tableFilters,
+      deleteSingleFieldName,
+      typeName,
+      true,
+      features.requireWhere,
       filterCtx,
       { tableName, relationMap: namedRelations, tables }
     ) : void 0;
@@ -3780,6 +4530,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 +4563,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,
@@ -3834,6 +4606,13 @@ var generateSchemaData3 = (db, schema, relations, options) => {
         resolve: updateGenerated.resolver
       };
     }
+    if (updateSingleGenerated) {
+      mutations[updateSingleGenerated.name] = {
+        type: singleTableItemOutput,
+        args: updateSingleGenerated.args,
+        resolve: updateSingleGenerated.resolver
+      };
+    }
     if (deleteGenerated) {
       mutations[deleteGenerated.name] = {
         type: arrTableItemOutput,
@@ -3841,6 +4620,13 @@ var generateSchemaData3 = (db, schema, relations, options) => {
         resolve: deleteGenerated.resolver
       };
     }
+    if (deleteSingleGenerated) {
+      mutations[deleteSingleGenerated.name] = {
+        type: singleTableItemOutput,
+        args: deleteSingleGenerated.args,
+        resolve: deleteSingleGenerated.resolver
+      };
+    }
     const activeInputs = [
       // The insert input types the upsert mutations too, so either feature keeps it.
       ...features.insert || onConflictInput ? [insertInput] : [],
@@ -3857,6 +4643,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,12 +4689,14 @@ 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,
     update: config?.features?.update ?? true,
     delete: config?.features?.delete ?? true,
-    upsert: config?.features?.upsert ?? false
+    upsert: config?.features?.upsert ?? false,
+    requireWhere: config?.features?.requireWhere ?? false
   };
   const complexityConfig = config?.complexity ?? true;
   const complexity = complexityConfig === false ? void 0 : {
@@ -3977,6 +4769,7 @@ export {
   GraphQLBigIntString,
   GraphQLDate,
   GraphQLDateTime,
+  GraphQLDecimalString,
   GraphQLJSON,
   GraphQLUUID,
   buildSchema,