@vantreeseba/drizzle-graphql 4.2.0 → 5.1.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,11 +806,15 @@ 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)"
     }
   }
 });
-var resolveGenericFilterName = (column, columnName, columnGraphQLType) => {
-  if (columnName === "id" || columnName.endsWith("Id")) {
+var resolveGenericFilterName = (column, columnGraphQLType) => {
+  if (columnGraphQLType.type === GraphQLUUID) {
     return "Id";
   }
   if (columnGraphQLType.type === GraphQLBoolean2) {
@@ -762,27 +823,50 @@ 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") {
     return "DateTime";
   }
+  if (columnGraphQLType.type === GraphQLInt2) {
+    return "Int";
+  }
+  if (columnGraphQLType.type === GraphQLFloat2) {
+    return "Float";
+  }
   return "String";
 };
+var FILTERS_WITHOUT_STRING_OPS = /* @__PURE__ */ new Set(["Id", "Int", "Float", "BigInt", "Decimal"]);
 var generateColumnFilterValues = (column, tableName, columnName, cacheCtx) => {
   const columnGraphQLType = drizzleColumnToGraphQLType(column, columnName, tableName, true, false, true);
-  const genericName = resolveGenericFilterName(column, columnName, columnGraphQLType);
+  const genericName = resolveGenericFilterName(column, 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 = FILTERS_WITHOUT_STRING_OPS.has(genericName);
   const baseFields = {
     eq: { type: colType, description: colDesc },
     ne: { type: colType, description: colDesc },
@@ -790,31 +874,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 +981,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 +1066,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 +1103,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 +1126,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 +1212,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 +1354,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];
   }
-  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!`);
+  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`);
+  }
+  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 +1457,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 +1468,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 +1520,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 +1627,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 +1637,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 +1712,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 +1953,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 +1964,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);
@@ -1733,6 +2065,9 @@ 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,
@@ -1744,9 +2079,24 @@ var computeResolverFieldNames = (tableName, typeNameMapper, prefixes, suffixes)
     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 },
@@ -1805,9 +2155,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,
@@ -1922,7 +2272,7 @@ import {
 } from "drizzle-orm";
 import {
   GraphQLError as GraphQLError4,
-  GraphQLFloat as GraphQLFloat2,
+  GraphQLFloat as GraphQLFloat3,
   GraphQLInputObjectType as GraphQLInputObjectType3,
   GraphQLInt as GraphQLInt3,
   GraphQLList as GraphQLList3,
@@ -1980,7 +2330,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 }]))
         })
       };
     }
@@ -2216,7 +2566,7 @@ var generateGroupByEnum = (table, tableName, typeName) => {
 var aggregateNumberFilter = new GraphQLInputObjectType3({
   name: "AggregateNumberFilter",
   description: "Compares an aggregated value. Several operators in one filter are ANDed together.",
-  fields: Object.fromEntries(Object.keys(HAVING_OPS).map((op) => [op, { type: GraphQLFloat2 }]))
+  fields: Object.fromEntries(Object.keys(HAVING_OPS).map((op) => [op, { type: GraphQLFloat3 }]))
 });
 var generateHavingInput = (table, tableName, typeName) => {
   const { numeric, orderable, all } = classifyAggregateColumns(table, tableName);
@@ -2529,13 +2879,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 {
@@ -2547,10 +2897,14 @@ var generateUpdate = (db, tableName, table, setArgs, filterArgs, fieldName, filt
         if (!Object.keys(input).length) {
           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;
@@ -2562,10 +2916,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 {
@@ -2573,10 +2927,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;
@@ -2665,7 +3023,9 @@ var generateSchemaData = (db, schema, relations, options) => {
       upsertArrayFieldName,
       upsertSingleFieldName,
       updateFieldName,
-      deleteFieldName
+      updateSingleFieldName,
+      deleteFieldName,
+      deleteSingleFieldName
     } = computeResolverFieldNames(tableName, typeNameMapper, prefixes, suffixes);
     const selectArrGenerated = generateSelectArray(
       db,
@@ -2710,9 +3070,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,
@@ -2770,7 +3162,9 @@ var generateSchemaData = (db, schema, relations, options) => {
       upsertArrGenerated,
       upsertSingleGenerated,
       updateGenerated,
-      deleteGenerated
+      updateSingleGenerated,
+      deleteGenerated,
+      deleteSingleGenerated
     ]) {
       if (generated) {
         mutations[generated.name] = {
@@ -2890,7 +3284,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) {
@@ -2951,7 +3345,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));
         }
@@ -3111,13 +3505,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);
@@ -3143,16 +3537,26 @@ var generateUpdate2 = (db, tableName, table, tables, relationMap, setArgs, filte
         if (!Object.keys(input).length) {
           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);
       }
@@ -3160,10 +3564,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 {
@@ -3179,14 +3583,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);
@@ -3268,7 +3682,9 @@ function generateSchemaData2(db, schema, relations, options) {
       upsertArrayFieldName,
       upsertSingleFieldName,
       updateFieldName,
-      deleteFieldName
+      updateSingleFieldName,
+      deleteFieldName,
+      deleteSingleFieldName
     } = computeResolverFieldNames(tableName, typeNameMapper, prefixes, suffixes);
     const selectArrGenerated = generateSelectArray2(
       db,
@@ -3367,6 +3783,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;
@@ -3377,6 +3810,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;
@@ -3466,6 +3913,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,
@@ -3473,6 +3927,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] : [],
@@ -3743,13 +4204,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);
@@ -3775,16 +4236,26 @@ var generateUpdate3 = (db, tableName, table, tables, relationMap, setArgs, filte
         if (!Object.keys(input).length) {
           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);
       }
@@ -3792,10 +4263,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 {
@@ -3811,14 +4282,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);
@@ -3901,7 +4382,9 @@ var generateSchemaData3 = (db, schema, relations, options) => {
       upsertArrayFieldName,
       upsertSingleFieldName,
       updateFieldName,
-      deleteFieldName
+      updateSingleFieldName,
+      deleteFieldName,
+      deleteSingleFieldName
     } = computeResolverFieldNames(tableName, typeNameMapper, prefixes, suffixes);
     const selectArrGenerated = generateSelectArray3(
       db,
@@ -4000,6 +4483,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;
@@ -4010,6 +4510,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;
@@ -4099,6 +4613,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,
@@ -4106,6 +4627,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] : [],
@@ -4174,7 +4702,8 @@ var buildSchema = (db, config) => {
     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 : {
@@ -4247,6 +4776,7 @@ export {
   GraphQLBigIntString,
   GraphQLDate,
   GraphQLDateTime,
+  GraphQLDecimalString,
   GraphQLJSON,
   GraphQLUUID,
   buildSchema,