@vantreeseba/drizzle-graphql 4.1.0 → 5.0.0

package/dist/index.cjs

@@ -33,6 +33,7 @@ __export(index_exports, {
   GraphQLBigIntString: () => GraphQLBigIntString,
   GraphQLDate: () => import_graphql_scalars.GraphQLDate,
   GraphQLDateTime: () => import_graphql_scalars.GraphQLDateTime,
+  GraphQLDecimalString: () => GraphQLDecimalString,
   GraphQLJSON: () => import_graphql_scalars.GraphQLJSON,
   GraphQLUUID: () => import_graphql_scalars.GraphQLUUID,
   buildSchema: () => buildSchema,
@@ -298,13 +299,6 @@ var remapFromGraphQLArrayInput = (queryInput, table) => {
   return queryInput;
 };
 
-// src/util/type-converter/index.ts
-var import_drizzle_orm2 = require("drizzle-orm");
-var import_mysql_core = require("drizzle-orm/mysql-core");
-var import_pg_core = require("drizzle-orm/pg-core");
-var import_sqlite_core = require("drizzle-orm/sqlite-core");
-var import_graphql3 = require("graphql");
-
 // src/util/scalars/index.ts
 var import_graphql2 = require("graphql");
 var import_graphql_scalars = require("graphql-scalars");
@@ -343,8 +337,44 @@ var GraphQLBigIntString = new import_graphql2.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 import_graphql2.GraphQLError(`Decimal cannot represent non-finite value: ${value}`);
+    }
+    return String(value);
+  }
+  if (typeof value === "string") {
+    if (!numericStringPattern.test(value)) {
+      throw new import_graphql2.GraphQLError(`Decimal cannot represent non-numeric value: "${value}"`);
+    }
+    return value;
+  }
+  throw new import_graphql2.GraphQLError(`Decimal cannot represent value: ${JSON.stringify(value)}`);
+};
+var GraphQLDecimalString = new import_graphql2.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 !== import_graphql2.Kind.STRING && ast.kind !== import_graphql2.Kind.INT && ast.kind !== import_graphql2.Kind.FLOAT) {
+      throw new import_graphql2.GraphQLError(`Decimal cannot represent a ${ast.kind}`, { nodes: ast });
+    }
+    return asNumericString(ast.value);
+  }
+});
 
 // src/util/type-converter/index.ts
+var import_drizzle_orm2 = require("drizzle-orm");
+var import_mysql_core = require("drizzle-orm/mysql-core");
+var import_pg_core = require("drizzle-orm/pg-core");
+var import_sqlite_core = require("drizzle-orm/sqlite-core");
+var import_graphql3 = require("graphql");
 var allowedNameChars = /^[a-zA-Z0-9_]+$/;
 var enumMap = /* @__PURE__ */ new WeakMap();
 var generateEnumCached = (column, columnName, tableName) => {
@@ -381,7 +411,7 @@ var geoXyInputType = new import_graphql3.GraphQLInputObjectType({
   }
 });
 var columnToGraphQLCore = (column, columnName, tableName, isInput) => {
-  const { type: baseType } = (0, import_drizzle_orm2.extractExtendedColumnType)(column);
+  const { type: baseType, constraint } = (0, import_drizzle_orm2.extractExtendedColumnType)(column);
   switch (baseType) {
     case "boolean":
       return { type: import_graphql3.GraphQLBoolean, description: "Boolean" };
@@ -400,6 +430,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 import_pg_core.PgTimestamp || column instanceof import_pg_core.PgTimestampString) {
         return { type: import_graphql_scalars.GraphQLDateTime, description: "DateTime" };
       }
@@ -409,6 +442,15 @@ var columnToGraphQLCore = (column, columnName, tableName, isInput) => {
       if (column instanceof import_pg_core.PgDateString) {
         return isInput ? { type: import_graphql3.GraphQLString, description: "Date" } : { type: import_graphql_scalars.GraphQLDate, description: "Date" };
       }
+      {
+        const dims = column.dimensions;
+        if (dims !== void 0 && dims > 0) {
+          return {
+            type: new import_graphql3.GraphQLList(new import_graphql3.GraphQLNonNull(import_graphql3.GraphQLString)),
+            description: "Array<String>"
+          };
+        }
+      }
       return { type: import_graphql3.GraphQLString, description: "String" };
     case "bigint":
       return { type: GraphQLBigIntString, description: "BigInt" };
@@ -559,10 +601,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 = (0, import_drizzle_orm3.getColumns)(targetTable);
   const orderExprs = [
-    ...orderByArg ? extractOrderBy(targetTable, orderByArg) : [],
+    ...orderByArg ? extractOrderBy(targetTable, orderByArg, orderCtx) : [],
     ...primaryKeyOrderExprs(targetTable, pkNames)
   ];
   const orderClause = orderExprs.length ? import_drizzle_orm3.sql` order by ${import_drizzle_orm3.sql.join(orderExprs, import_drizzle_orm3.sql`, `)}` : import_drizzle_orm3.sql``;
@@ -626,12 +668,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;
       }
@@ -720,6 +763,20 @@ var extractSelectedColumnsFromTreeSQLFormat = (tree, table, selectionCtx) => {
   }
   return Object.fromEntries(selectedColumns);
 };
+var orderNulls = new import_graphql4.GraphQLEnumType({
+  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 import_graphql4.GraphQLInputObjectType({
   name: "InnerOrder",
   fields: {
@@ -744,6 +801,10 @@ var innerOrder = new import_graphql4.GraphQLInputObjectType({
     priority: {
       type: new import_graphql4.GraphQLNonNull(import_graphql4.GraphQLInt),
       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)"
     }
   }
 });
@@ -757,9 +818,25 @@ var resolveGenericFilterName = (column, columnName, columnGraphQLType) => {
   if (columnGraphQLType.type instanceof import_graphql4.GraphQLEnumType) {
     return columnGraphQLType.type.name;
   }
+  if (columnGraphQLType.type === GraphQLBigIntString) {
+    return "BigInt";
+  }
+  if (columnGraphQLType.type === GraphQLDecimalString) {
+    return "Decimal";
+  }
   if (columnGraphQLType.type instanceof import_graphql4.GraphQLList) {
     const desc2 = columnGraphQLType.description ?? "";
-    return desc2.includes("Integer") ? "IntArray" : "FloatArray";
+    let inner = columnGraphQLType.type.ofType;
+    if (inner instanceof import_graphql4.GraphQLNonNull) {
+      inner = inner.ofType;
+    }
+    if (desc2.includes("Integer") || inner === import_graphql4.GraphQLInt) {
+      return "IntArray";
+    }
+    if (desc2.includes("Float") || inner === import_graphql4.GraphQLFloat) {
+      return "FloatArray";
+    }
+    return "StringArray";
   }
   const ct = column.columnType ?? "";
   if (ct === "PgTimestamp" || ct === "PgTimestampString" || ct === "PgDate") {
@@ -772,12 +849,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 import_graphql4.GraphQLList(new import_graphql4.GraphQLNonNull(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 },
@@ -785,31 +862,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: import_graphql4.GraphQLString },
       notLike: { type: import_graphql4.GraphQLString },
       ilike: { type: import_graphql4.GraphQLString },
-      notIlike: { type: import_graphql4.GraphQLString }
+      notIlike: { type: import_graphql4.GraphQLString },
+      startsWith: {
+        type: import_graphql4.GraphQLString,
+        description: "Matches values starting with the given string. `%`, `_` and `\\` are matched literally."
+      },
+      endsWith: {
+        type: import_graphql4.GraphQLString,
+        description: "Matches values ending with the given string. `%`, `_` and `\\` are matched literally."
+      },
+      contains: {
+        type: import_graphql4.GraphQLString,
+        description: "Matches values containing the given string. `%`, `_` and `\\` are matched literally."
+      },
+      iStartsWith: {
+        type: import_graphql4.GraphQLString,
+        description: "Case-insensitive `startsWith`."
+      },
+      iEndsWith: {
+        type: import_graphql4.GraphQLString,
+        description: "Case-insensitive `endsWith`."
+      },
+      iContains: {
+        type: import_graphql4.GraphQLString,
+        description: "Case-insensitive `contains`."
+      }
     },
     inArray: { type: colArr, description: `Array<${colDesc}>` },
     notInArray: { type: colArr, description: `Array<${colDesc}>` },
     isNull: { type: import_graphql4.GraphQLBoolean },
     isNotNull: { type: import_graphql4.GraphQLBoolean }
   };
-  const orType = new import_graphql4.GraphQLInputObjectType({
-    name: `${genericName}FilterOr`,
-    fields: { ...baseFields }
-  });
   const mainType = new import_graphql4.GraphQLInputObjectType({
     name: `${genericName}Filter`,
-    fields: {
+    fields: () => ({
       ...baseFields,
       OR: {
-        type: new import_graphql4.GraphQLList(new import_graphql4.GraphQLNonNull(orType))
+        type: new import_graphql4.GraphQLList(new import_graphql4.GraphQLNonNull(mainType)),
+        description: "At least one branch matches; ANDed with any sibling operators"
+      },
+      AND: {
+        type: new import_graphql4.GraphQLList(new import_graphql4.GraphQLNonNull(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();
@@ -863,19 +969,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 || !(0, import_drizzle_orm3.is)(relation, import_drizzle_orm3.One) || !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 import_graphql4.GraphQLInputObjectType({
     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) {
@@ -914,7 +1054,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] = (0, import_drizzle_orm3.is)(relation, import_drizzle_orm3.One) ? {
@@ -951,16 +1091,21 @@ var generateTableFilterTypeCached = (table, tableName, cacheCtx, typeNameMapper,
       ...generateRelationFilterFields(tableName, cacheCtx, typeNameMapper, filterColumns, relationMap, tables)
     };
   };
-  const orFilters = new import_graphql4.GraphQLInputObjectType({
-    name: `${resolveTypeName(tableName, typeNameMapper)}FiltersOr`,
-    fields: buildFields
-  });
   const filters = new import_graphql4.GraphQLInputObjectType({
     name: `${resolveTypeName(tableName, typeNameMapper)}Filters`,
     fields: () => ({
       ...buildFields(),
       OR: {
-        type: new import_graphql4.GraphQLList(new import_graphql4.GraphQLNonNull(orFilters))
+        type: new import_graphql4.GraphQLList(new import_graphql4.GraphQLNonNull(filters)),
+        description: "At least one branch matches; ANDed with any sibling fields"
+      },
+      AND: {
+        type: new import_graphql4.GraphQLList(new import_graphql4.GraphQLNonNull(filters)),
+        description: "Every branch matches"
+      },
+      NOT: {
+        type: filters,
+        description: "Negates the nested filters"
       }
     })
   });
@@ -969,7 +1114,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];
@@ -1055,10 +1200,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 import_graphql4.GraphQLNonNull(relType) : relType,
             args: {
               where: { type: relSelectData.filters }
             },
@@ -1196,28 +1342,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" ? (0, import_drizzle_orm3.asc)((0, import_drizzle_orm3.getColumns)(table)[column]) : (0, import_drizzle_orm3.desc)((0, import_drizzle_orm3.getColumns)(table)[column])
-);
-var extractFiltersColumn = (column, columnName, operators) => {
-  if (!operators.OR?.length) {
-    delete operators.OR;
+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 import_graphql4.GraphQLError(`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" ? (0, import_drizzle_orm3.asc)(expr) : (0, import_drizzle_orm3.desc)(expr);
+  if (!nulls) {
+    return [directed];
   }
-  const entries = Object.entries(operators);
-  if (operators.OR) {
-    if (entries.length > 1) {
-      throw new import_graphql4.GraphQLError(`WHERE ${columnName}: Cannot specify both fields and 'OR' in column operators!`);
+  const isMySql = (dialectColumn.columnType ?? "").startsWith("MySql");
+  if (isMySql) {
+    const nullsKey = nulls === "first" ? (0, import_drizzle_orm3.desc)(import_drizzle_orm3.sql`(${expr} is null)`) : (0, import_drizzle_orm3.asc)(import_drizzle_orm3.sql`(${expr} is null)`);
+    return [nullsKey, directed];
+  }
+  return [nulls === "first" ? import_drizzle_orm3.sql`${directed} nulls first` : import_drizzle_orm3.sql`${directed} nulls last`];
+};
+var extendRelationOrderChain = (parentTable, relationName, relEntry, ctx, chain) => {
+  const targetTable = ctx.tables[relEntry.targetTableName];
+  const relation = relEntry.relation ?? relEntry;
+  if (!targetTable || !(0, import_drizzle_orm3.is)(relation, import_drizzle_orm3.One) || !isFilterableRelation(relation)) {
+    throw new import_graphql4.GraphQLError(`ORDER BY ${relationName}: Relation cannot be used for ordering`);
+  }
+  ctx.aliases ??= { n: 0 };
+  const aliasedTarget = (0, import_drizzle_orm3.aliasedTable)(targetTable, `dgql_ord_${ctx.aliases.n++}`);
+  const joinCondition = buildRelationJoinCondition(parentTable, relation, aliasedTarget, relationName);
+  const relationWhere = relation.where ? (0, import_drizzle_orm3.relationsFilterToSQL)(relation.isReversed ? parentTable : aliasedTarget, relation.where) : void 0;
+  return {
+    fromParts: [...chain?.fromParts ?? [], (0, import_drizzle_orm3.getTableAsAliasSQL)(aliasedTarget)],
+    conditions: [
+      ...chain?.conditions ?? [],
+      ...joinCondition ? [joinCondition] : [],
+      ...relationWhere ? [relationWhere] : []
+    ],
+    table: aliasedTarget
+  };
+};
+var collectOrderEntries = (table, tableKey, orderArgs, ctx, chain, out) => {
+  const columns = (0, import_drizzle_orm3.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 ? import_drizzle_orm3.sql`(select ${column} from ${import_drizzle_orm3.sql.join(chain.fromParts, import_drizzle_orm3.sql`, `)} where ${(0, import_drizzle_orm3.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 import_graphql4.GraphQLError(`ORDER BY ${key}: Unknown column or relation`);
     }
-    return variants2.length ? variants2.length > 1 ? (0, import_drizzle_orm3.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 import_drizzle_orm3.sql`${column} like ${pattern} escape ${LIKE_ESCAPE_CHAR}`;
+  }
+  const isPg = (column.columnType ?? "").startsWith("Pg");
+  return isPg ? import_drizzle_orm3.sql`${column} ilike ${pattern} escape ${LIKE_ESCAPE_CHAR}` : import_drizzle_orm3.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: import_drizzle_orm3.eq, ne: import_drizzle_orm3.ne, gt: import_drizzle_orm3.gt, gte: import_drizzle_orm3.gte, lt: import_drizzle_orm3.lt, lte: import_drizzle_orm3.lte };
   const stringValueOps = { like: import_drizzle_orm3.like, notLike: import_drizzle_orm3.notLike, ilike: import_drizzle_orm3.ilike, notIlike: import_drizzle_orm3.notIlike };
   const arrayValueOps = { inArray: import_drizzle_orm3.inArray, notInArray: import_drizzle_orm3.notInArray };
@@ -1232,6 +1445,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 import_graphql4.GraphQLError(`WHERE ${columnName}: Unable to use operator ${operatorName} with an empty array!`);
@@ -1240,6 +1456,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 import_graphql4.GraphQLError(`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((0, import_drizzle_orm3.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 ? (0, import_drizzle_orm3.or)(...orVariants) : orVariants[0]);
     }
   }
   return variants.length ? variants.length > 1 ? (0, import_drizzle_orm3.and)(...variants) : variants[0] : void 0;
@@ -1264,39 +1508,105 @@ var buildRelationJoinCondition = (parentTable, relation, aliasedTarget, relation
   }
   return conditions.length > 1 ? (0, import_drizzle_orm3.and)(...conditions) : conditions[0];
 };
+var resolveJunctionColumn = (aliasedThrough, junctionRef, relationName) => {
+  const throughColumns = (0, import_drizzle_orm3.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 import_graphql4.GraphQLError(`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 import_graphql4.GraphQLError(`WHERE ${relationName}: Relation cannot be used as a filter`);
+  }
+  const parentColumns = Object.values((0, import_drizzle_orm3.getColumns)(parentTable));
+  const targetTableColumns = Object.values((0, import_drizzle_orm3.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 import_graphql4.GraphQLError(`WHERE ${relationName}: Relation cannot be used as a filter`);
+    }
+    correlationConditions.push((0, import_drizzle_orm3.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 import_graphql4.GraphQLError(`WHERE ${relationName}: Relation cannot be used as a filter`);
+    }
+    junctionJoinConditions.push(
+      (0, import_drizzle_orm3.eq)(resolveJunctionColumn(aliasedThrough, through.target[i], relationName), foreignColumn)
+    );
+  }
+  return {
+    correlation: correlationConditions.length > 1 ? (0, import_drizzle_orm3.and)(...correlationConditions) : correlationConditions[0],
+    junctionJoin: junctionJoinConditions.length > 1 ? (0, import_drizzle_orm3.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 import_graphql4.GraphQLError(`WHERE ${relationName}: Relation cannot be used as a filter`);
   }
   ctx.aliases ??= { n: 0 };
   const aliases = ctx.aliases;
   const aliasedTarget = (0, import_drizzle_orm3.aliasedTable)(targetTable, `dgql_rel_${aliases.n++}`);
-  const joinCondition = buildRelationJoinCondition(parentTable, relation, aliasedTarget, relationName);
+  const throughTable = relation.throughTable;
+  let fromClause;
+  let joinCondition;
+  if (throughTable) {
+    const aliasedThrough = (0, import_drizzle_orm3.aliasedTable)(throughTable, `dgql_rel_${aliases.n++}`);
+    const { correlation, junctionJoin } = buildThroughJoinConditions(
+      parentTable,
+      relation,
+      aliasedThrough,
+      aliasedTarget,
+      relationName
+    );
+    fromClause = import_drizzle_orm3.sql`${(0, import_drizzle_orm3.getTableAsAliasSQL)(aliasedTarget)} inner join ${(0, import_drizzle_orm3.getTableAsAliasSQL)(aliasedThrough)} on ${junctionJoin}`;
+    joinCondition = correlation;
+  } else {
+    fromClause = (0, import_drizzle_orm3.getTableAsAliasSQL)(aliasedTarget);
+    joinCondition = buildRelationJoinCondition(parentTable, relation, aliasedTarget, relationName);
+  }
   const relationWhere = relation.where ? (0, import_drizzle_orm3.relationsFilterToSQL)(relation.isReversed ? parentTable : aliasedTarget, relation.where) : void 0;
   const inner = innerFilters ? extractFilters(aliasedTarget, targetTableName, innerFilters, { ...ctx, tableKey: targetTableName, aliases }) : void 0;
   if (mode === "every") {
     if (!inner) {
       return void 0;
     }
-    return import_drizzle_orm3.sql`not exists (select 1 from ${(0, import_drizzle_orm3.getTableAsAliasSQL)(aliasedTarget)} where ${(0, import_drizzle_orm3.and)(joinCondition, relationWhere, (0, import_drizzle_orm3.not)(inner))})`;
+    return import_drizzle_orm3.sql`not exists (select 1 from ${fromClause} where ${(0, import_drizzle_orm3.and)(joinCondition, relationWhere, (0, import_drizzle_orm3.not)(inner))})`;
   }
   const condition = (0, import_drizzle_orm3.and)(joinCondition, relationWhere, inner);
-  return mode === "none" ? import_drizzle_orm3.sql`not exists (select 1 from ${(0, import_drizzle_orm3.getTableAsAliasSQL)(aliasedTarget)} where ${condition})` : import_drizzle_orm3.sql`exists (select 1 from ${(0, import_drizzle_orm3.getTableAsAliasSQL)(aliasedTarget)} where ${condition})`;
+  return mode === "none" ? import_drizzle_orm3.sql`not exists (select 1 from ${fromClause} where ${condition})` : import_drizzle_orm3.sql`exists (select 1 from ${fromClause} where ${condition})`;
 };
 var extractRelationFilter = (parentTable, relationName, relEntry, value, ctx) => {
   const relation = relEntry.relation ?? relEntry;
   if ((0, import_drizzle_orm3.is)(relation, import_drizzle_orm3.One)) {
     return buildRelationExists(parentTable, relationName, relEntry, value, "some", ctx);
   }
+  const 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 import_graphql4.GraphQLError(`WHERE ${relationName}: Unknown relation filter key: ${mode}`);
+    }
     const extracted = buildRelationExists(parentTable, relationName, relEntry, inner, mode, ctx);
     if (extracted) {
       variants.push(extracted);
@@ -1305,26 +1615,8 @@ var extractRelationFilter = (parentTable, relationName, relEntry, value, ctx) =>
   return variants.length ? variants.length > 1 ? (0, import_drizzle_orm3.and)(...variants) : variants[0] : void 0;
 };
 var extractFilters = (table, tableName, filters, relationCtx) => {
-  if (!filters.OR?.length) {
-    delete filters.OR;
-  }
-  const entries = Object.entries(filters);
-  if (!entries.length) {
-    return;
-  }
-  if (filters.OR) {
-    if (entries.length > 1) {
-      throw new import_graphql4.GraphQLError(`WHERE ${tableName}: Cannot specify both fields and 'OR' in table filters!`);
-    }
-    const variants2 = [];
-    for (const variant of filters.OR) {
-      const extracted = extractFilters(table, tableName, variant, relationCtx);
-      if (extracted) {
-        variants2.push(extracted);
-      }
-    }
-    return variants2.length ? variants2.length > 1 ? (0, import_drizzle_orm3.or)(...variants2) : variants2[0] : void 0;
-  }
+  const { OR, AND, NOT, ...fieldFilters } = filters;
+  const entries = Object.entries(fieldFilters);
   const columns = (0, import_drizzle_orm3.getColumns)(table);
   const relations = relationCtx?.relationMap[relationCtx.tableKey];
   const variants = [];
@@ -1333,11 +1625,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 import_graphql4.GraphQLError(`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((0, import_drizzle_orm3.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 ? (0, import_drizzle_orm3.or)(...orVariants) : orVariants[0]);
+    }
+  }
   return variants.length ? variants.length > 1 ? (0, import_drizzle_orm3.and)(...variants) : variants[0] : void 0;
 };
 var extractRelationsParamsInner = (relationMap, tables, tableName, typeName, originField, typeNameMapper, _isInitial = false, filterCtx) => {
@@ -1379,7 +1700,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(
@@ -1620,7 +1941,9 @@ var selectDistinctKeys = async (params) => {
   }
   const orderEntries = orderBy ? orderByEntries(orderBy) : [];
   const windowOrder = [
-    ...orderEntries.map(([column, direction]) => direction === "asc" ? (0, import_drizzle_orm3.asc)(cols[column]) : (0, import_drizzle_orm3.desc)(cols[column])),
+    ...orderEntries.flatMap(
+      ([column, direction, nulls]) => orderExpressions(cols[column], direction, nulls, cols[column])
+    ),
     ...primaryKeyOrderExprs(table, pkNames)
   ];
   const rowNumber = import_drizzle_orm3.sql`row_number() over (partition by ${import_drizzle_orm3.sql.join(partitionCols, import_drizzle_orm3.sql`, `)} order by ${import_drizzle_orm3.sql.join(
@@ -1629,7 +1952,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" ? (0, import_drizzle_orm3.asc)(sub[column]) : (0, import_drizzle_orm3.desc)(sub[column])),
+    ...orderEntries.flatMap(
+      ([column, direction, nulls]) => orderExpressions(sub[column], direction, nulls, cols[column])
+    ),
     ...pkNames.filter((name) => sub[name]).map((name) => (0, import_drizzle_orm3.asc)(sub[name]))
   ];
   let query = db.select(Object.fromEntries(pkNames.map((name) => [name, sub[name]]))).from(sub).where((0, import_drizzle_orm3.eq)(sub[DISTINCT_RN], 1)).orderBy(...outerOrder);
@@ -1720,6 +2045,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";
@@ -1727,19 +2053,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 import_graphql4.GraphQLError(`${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: import_drizzle_orm3.sql`1` }).from(table).where(filters).limit(2);
+  if (matched.length > 1) {
+    throw new import_graphql4.GraphQLError(`${fieldName}: 'where' matched more than one row \u2014 nothing was written!`);
+  }
+};
 var selectArrayArgs = (orderArgs, filterArgs, distinctEnum) => ({
   offset: { type: import_graphql4.GraphQLInt },
   limit: { type: import_graphql4.GraphQLInt },
@@ -1798,9 +2143,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,
@@ -2006,9 +2351,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: [] },
@@ -2146,6 +2491,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) => {
@@ -2313,13 +2836,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 import_graphql6.GraphQLNonNull(setArgs)
     },
     where: {
-      type: filterArgs
+      type: single || requireWhere ? new import_graphql6.GraphQLNonNull(filterArgs) : filterArgs
     }
   };
   return {
@@ -2331,10 +2854,14 @@ var generateUpdate = (db, tableName, table, setArgs, filterArgs, fieldName, filt
         if (!Object.keys(input).length) {
           throw new import_graphql6.GraphQLError("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;
@@ -2346,10 +2873,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 import_graphql6.GraphQLNonNull(filterArgs) : filterArgs
     }
   };
   return {
@@ -2357,10 +2884,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;
@@ -2443,12 +2974,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,
@@ -2493,9 +3027,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,
@@ -2506,6 +3072,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,
@@ -2525,13 +3105,23 @@ var generateSchemaData = (db, schema, relations, options) => {
         ...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 [
       insertArrGenerated,
       insertSingleGenerated,
       upsertArrGenerated,
       upsertSingleGenerated,
       updateGenerated,
-      deleteGenerated
+      updateSingleGenerated,
+      deleteGenerated,
+      deleteSingleGenerated
     ]) {
       if (generated) {
         mutations[generated.name] = {
@@ -2556,6 +3146,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)) {
@@ -2643,7 +3237,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) {
@@ -2704,7 +3298,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));
         }
@@ -2864,13 +3458,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 import_graphql7.GraphQLNonNull(setArgs)
     },
     where: {
-      type: filterArgs
+      type: single || requireWhere ? new import_graphql7.GraphQLNonNull(filterArgs) : filterArgs
     }
   };
   const pkNames = pgPrimaryKeyPropNames(table);
@@ -2896,16 +3490,26 @@ var generateUpdate2 = (db, tableName, table, tables, relationMap, setArgs, filte
         if (!Object.keys(input).length) {
           throw new import_graphql7.GraphQLError("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 import_graphql7.GraphQLError(`${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);
       }
@@ -2913,10 +3517,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 import_graphql7.GraphQLNonNull(filterArgs) : filterArgs
     }
   };
   return {
@@ -2932,14 +3536,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 import_graphql7.GraphQLError(`${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);
@@ -3015,12 +3629,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,
@@ -3119,6 +3736,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;
@@ -3129,6 +3763,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;
@@ -3142,6 +3790,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,
@@ -3161,6 +3823,14 @@ function generateSchemaData2(db, schema, relations, options) {
         ...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) {
       mutations[insertArrGenerated.name] = {
         type: arrTableItemOutput,
@@ -3196,6 +3866,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,
@@ -3203,6 +3880,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] : [],
@@ -3219,6 +3903,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)) {
@@ -3465,13 +4153,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 import_graphql8.GraphQLNonNull(setArgs)
     },
     where: {
-      type: filterArgs
+      type: single || requireWhere ? new import_graphql8.GraphQLNonNull(filterArgs) : filterArgs
     }
   };
   const pkNames = sqlitePrimaryKeyPropNames(table);
@@ -3497,16 +4185,26 @@ var generateUpdate3 = (db, tableName, table, tables, relationMap, setArgs, filte
         if (!Object.keys(input).length) {
           throw new import_graphql8.GraphQLError("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 import_graphql8.GraphQLError(`${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);
       }
@@ -3514,10 +4212,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 import_graphql8.GraphQLNonNull(filterArgs) : filterArgs
     }
   };
   return {
@@ -3533,14 +4231,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 import_graphql8.GraphQLError(`${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);
@@ -3617,12 +4325,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,
@@ -3721,6 +4432,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;
@@ -3731,6 +4459,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;
@@ -3744,6 +4486,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,
@@ -3763,6 +4519,14 @@ var generateSchemaData3 = (db, schema, relations, options) => {
         ...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) {
       mutations[insertArrGenerated.name] = {
         type: arrTableItemOutput,
@@ -3798,6 +4562,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,
@@ -3805,6 +4576,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] : [],
@@ -3821,6 +4599,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)) {
@@ -3863,12 +4645,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 : {
@@ -3942,6 +4726,7 @@ var buildSchema = (db, config) => {
   GraphQLBigIntString,
   GraphQLDate,
   GraphQLDateTime,
+  GraphQLDecimalString,
   GraphQLJSON,
   GraphQLUUID,
   buildSchema,