@vantreeseba/drizzle-graphql 6.0.0 → 7.1.0

package/dist/index.js

@@ -18,7 +18,7 @@ import {
   desc,
   eq,
   extractExtendedColumnType as extractExtendedColumnType2,
-  getColumns,
+  getColumns as getColumns2,
   getTableAsAliasSQL,
   gt,
   gte,
@@ -38,17 +38,17 @@ import {
   One as One2,
   or,
   relationsFilterToSQL,
-  sql
+  sql as sql2
 } from "drizzle-orm";
 import {
   GraphQLBoolean as GraphQLBoolean2,
   GraphQLEnumType as GraphQLEnumType2,
-  GraphQLError as GraphQLError3,
-  GraphQLFloat as GraphQLFloat2,
-  GraphQLInputObjectType as GraphQLInputObjectType2,
-  GraphQLInt as GraphQLInt2,
-  GraphQLList as GraphQLList2,
-  GraphQLNonNull as GraphQLNonNull2,
+  GraphQLError as GraphQLError4,
+  GraphQLFloat as GraphQLFloat3,
+  GraphQLInputObjectType as GraphQLInputObjectType3,
+  GraphQLInt as GraphQLInt3,
+  GraphQLList as GraphQLList3,
+  GraphQLNonNull as GraphQLNonNull3,
   GraphQLObjectType as GraphQLObjectType2,
   GraphQLString as GraphQLString2
 } from "graphql";
@@ -602,6 +602,131 @@ var remapFromGraphQLArrayInput = (queryInput, table) => {
   return queryInput;
 };
 
+// src/util/builders/field-updates.ts
+import { getColumns, sql } from "drizzle-orm";
+import {
+  GraphQLError as GraphQLError3,
+  GraphQLFloat as GraphQLFloat2,
+  GraphQLInputObjectType as GraphQLInputObjectType2,
+  GraphQLInt as GraphQLInt2,
+  GraphQLList as GraphQLList2,
+  GraphQLNonNull as GraphQLNonNull2
+} from "graphql";
+var NUMERIC_SCALARS = /* @__PURE__ */ new Set([
+  GraphQLInt2,
+  GraphQLFloat2,
+  GraphQLBigIntString,
+  GraphQLDecimalString
+]);
+var NON_LIST_ARRAY_COLUMNS = /* @__PURE__ */ new Set(["PgVector", "PgGeometry", "PgBytea"]);
+var kindCache = /* @__PURE__ */ new WeakMap();
+var fieldUpdateKind = (column, columnName, tableName) => {
+  const cached = kindCache.get(column);
+  if (cached) {
+    return cached;
+  }
+  let kind = "none";
+  if (!getColumnScalarOverride(column, true)) {
+    const { type } = drizzleColumnToGraphQLType(column, columnName, tableName, true, false, true);
+    if (NUMERIC_SCALARS.has(type)) {
+      kind = "numeric";
+    } else if (type instanceof GraphQLList2 && !NON_LIST_ARRAY_COLUMNS.has(column.columnType)) {
+      kind = "list";
+    }
+  }
+  kindCache.set(column, kind);
+  return kind;
+};
+var inputCache = /* @__PURE__ */ new Map();
+var namedFieldUpdateInput = (name, fields, description) => {
+  const cached = inputCache.get(name);
+  if (cached) {
+    return cached;
+  }
+  const input = new GraphQLInputObjectType2({ name, description, fields: fields() });
+  inputCache.set(name, input);
+  return input;
+};
+var fieldUpdateInputType = (column, columnName, tableName) => {
+  const kind = fieldUpdateKind(column, columnName, tableName);
+  if (kind === "none") {
+    return void 0;
+  }
+  const { type } = drizzleColumnToGraphQLType(column, columnName, tableName, true, false, true);
+  if (kind === "numeric") {
+    const scalar = type;
+    return namedFieldUpdateInput(
+      `${scalar.name}FieldUpdate`,
+      () => ({
+        set: { type: scalar, description: "Replace the current value with this one" },
+        increment: { type: scalar, description: "Add this to the current value (SQL `column + value`)" },
+        decrement: { type: scalar, description: "Subtract this from the current value (SQL `column - value`)" },
+        multiply: { type: scalar, description: "Multiply the current value by this (SQL `column * value`)" },
+        divide: {
+          type: scalar,
+          description: "Divide the current value by this (SQL `column / value`), rounding as the database does"
+        }
+      }),
+      `An update to a ${scalar.name} column: exactly one of these operations`
+    );
+  }
+  const list = type;
+  const element = list.ofType;
+  const elementName = element instanceof GraphQLNonNull2 ? String(element.ofType) : String(element);
+  return namedFieldUpdateInput(
+    `${elementName}ListFieldUpdate`,
+    () => ({
+      set: { type: list, description: "Replace the current array with this one" },
+      push: { type: list, description: "Append these elements to the current array" }
+    }),
+    `An update to a ${elementName} array column: exactly one of these operations`
+  );
+};
+var OPERATIONS = ["set", "increment", "decrement", "multiply", "divide", "push"];
+var singleOperation = (value, columnName) => {
+  const given = OPERATIONS.filter((operation) => value[operation] !== void 0);
+  if (given.length === 1) {
+    return [given[0], value[given[0]]];
+  }
+  throw new GraphQLError3(
+    given.length ? `Field '${columnName}' takes exactly one update operation, but ${given.length} were given (${given.join(", ")}).` : `Field '${columnName}' was given no update operation. Pass exactly one of ${OPERATIONS.join(", ")}.`
+  );
+};
+var splitFieldUpdateOperations = (values, table, tableName) => {
+  const cols = getColumns(table);
+  const columns = {};
+  const expressions = {};
+  for (const [columnName, value] of Object.entries(values)) {
+    const column = cols[columnName];
+    if (!column || value === null || value === void 0) {
+      columns[columnName] = value;
+      continue;
+    }
+    const isOperations = typeof value === "object" && !Array.isArray(value) && !(value instanceof Date);
+    if (!isOperations || fieldUpdateKind(column, columnName, tableName) === "none") {
+      columns[columnName] = value;
+      continue;
+    }
+    const [operation, operand] = singleOperation(value, columnName);
+    if (operation === "set") {
+      columns[columnName] = operand;
+      continue;
+    }
+    const param = sql.param(remapFromGraphQLCore(operand, column, columnName), column);
+    expressions[columnName] = operation === "increment" ? sql`${column} + ${param}` : operation === "decrement" ? sql`${column} - ${param}` : operation === "multiply" ? sql`${column} * ${param}` : operation === "divide" ? sql`${column} / ${param}` : (
+      // `push`: array concatenation, which is the only dialect-specific operation
+      // here — and arrays are a PostgreSQL column type to begin with.
+      sql`${column} || ${param}`
+    );
+  }
+  return { columns, expressions };
+};
+var remapUpdateInput = (values, table, tableName) => {
+  const { columns, expressions } = splitFieldUpdateOperations(values, table, tableName);
+  const remapped = remapFromGraphQLSingleInput(columns, table);
+  return Object.keys(expressions).length ? { ...remapped, ...expressions } : remapped;
+};
+
 // src/util/builders/common.ts
 var rqbCrashTypes = ["SQLiteBigInt", "SQLiteBlobJson", "SQLiteBlobBuffer"];
 var resolveTypeName = (name, typeNameMapper) => {
@@ -664,9 +789,9 @@ var extractRelationJoinColumns = (relEntry, parentTable, targetTable) => {
   }
   const sourceCol = sourceColumns[0];
   const targetCol = targetColumns[0];
-  const parentCols = getColumns(parentTable);
+  const parentCols = getColumns2(parentTable);
   const localColPropName = Object.entries(parentCols).find(([, c]) => c === sourceCol)?.[0];
-  const targetCols = getColumns(targetTable);
+  const targetCols = getColumns2(targetTable);
   const foreignColPropName = Object.entries(targetCols).find(([, c]) => c === targetCol)?.[0];
   if (!localColPropName || !foreignColPropName) {
     return void 0;
@@ -748,7 +873,7 @@ var collectRootMutationKeys = (selectionSet, fragments, variables, known, keys,
   }
   return true;
 };
-var abortedBatchError = () => new GraphQLError3(
+var abortedBatchError = () => new GraphQLError4(
   "Drizzle-GraphQL Error: Mutation was not executed because an earlier mutation in the same request failed and the shared transaction was rolled back."
 );
 var openSharedTx = (db, context, txCtx, stateKey, expected) => {
@@ -806,7 +931,7 @@ var openSharedTx = (db, context, txCtx, stateKey, expected) => {
       }
       timer = setTimeout(() => {
         state.abort(
-          new GraphQLError3(
+          new GraphQLError4(
             `Drizzle-GraphQL Error: Shared mutation transaction timed out after ${txCtx.timeoutMs}ms waiting for the remaining mutation fields; rolling back.`
           )
         );
@@ -888,14 +1013,14 @@ var runMutation = async (db, context, info, txCtx, body) => {
   return runOnSharedTx(state, body);
 };
 var batchedPaginatedRelationQuery = async (db, targetTable, foreignCol, whereCondition, orderByArg, limit, offset, pkNames, orderCtx) => {
-  const cols = getColumns(targetTable);
+  const cols = getColumns2(targetTable);
   const orderExprs = [
     ...orderByArg ? extractOrderBy(targetTable, orderByArg, orderCtx) : [],
     ...primaryKeyOrderExprs(targetTable, pkNames)
   ];
-  const orderClause = orderExprs.length ? sql` order by ${sql.join(orderExprs, sql`, `)}` : sql``;
+  const orderClause = orderExprs.length ? sql2` order by ${sql2.join(orderExprs, sql2`, `)}` : sql2``;
   const RN = "__drizzle_graphql_rn";
-  const rowNumber = sql`row_number() over (partition by ${foreignCol}${orderClause})`.as(RN);
+  const rowNumber = sql2`row_number() over (partition by ${foreignCol}${orderClause})`.as(RN);
   const sub = db.select({ ...cols, [RN]: rowNumber }).from(targetTable).where(whereCondition).as("__paginated");
   const lower = offset ?? 0;
   const windowConds = [gt(sub[RN], lower)];
@@ -908,7 +1033,7 @@ var batchedPaginatedRelationQuery = async (db, targetTable, foreignCol, whereCon
   }
   return rows;
 };
-var createRelationResolverFactory = (db, tables, filterCtx) => ({ tableName, relationName, relEntry, isOne }) => {
+var createRelationResolverFactory = (db, tables, nullOrdering, filterCtx, limits) => ({ tableName, relationName, relEntry, isOne }) => {
   const parentTable = tables[tableName];
   const targetTableName = relEntry.targetTableName;
   const targetTable = tables[targetTableName];
@@ -920,8 +1045,9 @@ var createRelationResolverFactory = (db, tables, filterCtx) => ({ tableName, rel
     return void 0;
   }
   const { localColPropName, foreignCol, foreignColPropName } = joinCols;
+  const limitPolicy = isOne ? void 0 : limits?.(targetTableName);
   const targetPkNames = relEntry.targetPkNames ?? [];
-  return async (parent, args, context) => {
+  return async (parent, args, context, info) => {
     if (parent[relationName] !== void 0) {
       return parent[relationName];
     }
@@ -929,21 +1055,66 @@ var createRelationResolverFactory = (db, tables, filterCtx) => ({ tableName, rel
     if (localValue == null) {
       return isOne ? null : [];
     }
-    const { where: whereArg, orderBy: orderByArg, limit, offset } = args ?? {};
+    const { where: whereArg, orderBy: orderByArg, limit: requestedLimit, offset, after } = args ?? {};
+    const limit = applyLimitPolicy(requestedLimit, limitPolicy, `${tableName}.${relationName}`);
+    const distinct = (args ?? {}).distinct?.length ? (args ?? {}).distinct : void 0;
+    const cursorSelected = !isOne && !!info && selectsCursorField(info, targetTable);
+    let cursorEntries;
+    if (!isOne && (after != null || cursorSelected)) {
+      if (after != null && distinct) {
+        throw new GraphQLError4("'after' cannot be combined with 'distinct'.");
+      }
+      if (orderByHasRelationEntry(orderByArg)) {
+        if (after != null) {
+          throw new GraphQLError4(
+            "'after' cannot be combined with an orderBy that orders through a relation \u2014 a related row's value cannot be encoded into a cursor."
+          );
+        }
+      } else if (!targetPkNames.length) {
+        if (after != null) {
+          throw new GraphQLError4(
+            `Table ${targetTableName} has no primary key, so cursor pagination cannot be used on it.`
+          );
+        }
+      } else {
+        cursorEntries = cursorOrderingEntries(orderByArg, targetPkNames);
+      }
+    }
+    const cursorValues = after != null && cursorEntries ? decodeCursor(after, cursorEntries) : void 0;
     const argsKey = JSON.stringify({
       where: whereArg ?? null,
       orderBy: orderByArg ?? null,
       limit: limit ?? null,
-      offset: offset ?? null
+      offset: offset ?? null,
+      after: after ?? null,
+      distinct: distinct ?? null,
+      cursor: cursorEntries ? 1 : 0
     });
     const loaderKey = `${tableName}::${relationName}::${argsKey}`;
     const loader = getOrCreateLoader(context, loaderKey, async (parentIds) => {
       const executor = resolveExecutor(db, context);
       const uniqueIds = [...new Set(parentIds)];
-      const whereCondition = and(
+      let whereCondition = and(
         inArray(foreignCol, uniqueIds),
-        whereArg ? extractFilters(targetTable, targetTableName, whereArg, relationFilterCtx(filterCtx, targetTableName)) : void 0
+        whereArg ? extractFilters(targetTable, targetTableName, whereArg, relationFilterCtx(filterCtx, targetTableName)) : void 0,
+        cursorValues ? buildCursorCondition(targetTable, cursorEntries, cursorValues, nullOrdering) : void 0
       );
+      if (distinct) {
+        const keys = await selectDistinctKeys({
+          db: executor,
+          table: targetTable,
+          tableName: targetTableName,
+          distinct,
+          pkNames: targetPkNames,
+          where: whereCondition,
+          orderBy: orderByArg,
+          partitionBy: [foreignCol]
+        });
+        if (!keys.length) {
+          return parentIds.map(() => isOne ? null : []);
+        }
+        whereCondition = and(whereCondition, primaryKeyRestriction(targetTable, targetPkNames, keys));
+      }
       let rows;
       if (limit != null || offset != null) {
         rows = await batchedPaginatedRelationQuery(
@@ -959,11 +1130,15 @@ var createRelationResolverFactory = (db, tables, filterCtx) => ({ tableName, rel
         );
       } else {
         let q = executor.select().from(targetTable).where(whereCondition);
-        if (orderByArg) {
-          q = q.orderBy(...extractOrderBy(targetTable, orderByArg, relationFilterCtx(filterCtx, targetTableName)));
+        const orderExprs = cursorEntries ? cursorOrderExprs(targetTable, cursorEntries) : orderByArg ? extractOrderBy(targetTable, orderByArg, relationFilterCtx(filterCtx, targetTableName)) : [];
+        if (orderExprs.length) {
+          q = q.orderBy(...orderExprs);
         }
         rows = await q;
       }
+      if (cursorEntries) {
+        attachRowCursors(rows, cursorEntries);
+      }
       if (isOne) {
         const byKey = new Map(rows.map((row) => [String(row[foreignColPropName]), row]));
         remapToGraphQLArrayOutput(rows, targetTableName, targetTable);
@@ -989,15 +1164,47 @@ var columnDocs = (docs, column, tableName, columnName) => {
 };
 var inputFieldDocs = (docs, column, tableName, columnName, fieldType) => {
   const resolved = columnDocs(docs, column, tableName, columnName);
-  if (resolved.deprecationReason !== void 0 && fieldType instanceof GraphQLNonNull2) {
+  if (resolved.deprecationReason !== void 0 && fieldType instanceof GraphQLNonNull3) {
     const { deprecationReason: _dropped, ...rest } = resolved;
     return rest;
   }
   return resolved;
 };
-var listFieldComplexity = (options) => ({ args, childComplexity }) => {
+var applyLimitPolicy = (limit, policy, fieldName) => {
+  if (!policy) {
+    return limit ?? void 0;
+  }
+  const { defaultLimit, maxLimit, clampToMax } = policy;
+  if (limit == null) {
+    const fallback = defaultLimit ?? maxLimit;
+    if (fallback === void 0) {
+      return void 0;
+    }
+    return maxLimit === void 0 ? fallback : Math.min(fallback, maxLimit);
+  }
+  if (maxLimit !== void 0 && limit > maxLimit) {
+    if (clampToMax) {
+      return maxLimit;
+    }
+    throw new GraphQLError4(`${fieldName}: 'limit' of ${limit} exceeds the maximum of ${maxLimit}.`);
+  }
+  return limit;
+};
+var resolveLimitPolicy = (global, table) => {
+  const defaultLimit = table?.defaultLimit ?? global?.defaultLimit;
+  const maxLimit = table?.maxLimit ?? global?.maxLimit;
+  if (defaultLimit === void 0 && maxLimit === void 0) {
+    return void 0;
+  }
+  return { defaultLimit, maxLimit, clampToMax: table?.clampToMax ?? global?.clampToMax ?? false };
+};
+var listFieldComplexity = (options, policy) => ({ args, childComplexity }) => {
   const limit = args["limit"];
-  const rows = typeof limit === "number" && limit > 0 ? limit : options.defaultListSize;
+  const requested = typeof limit === "number" && limit > 0 ? limit : void 0;
+  let rows = requested ?? policy?.defaultLimit ?? options.defaultListSize;
+  if (policy?.maxLimit !== void 0) {
+    rows = Math.min(rows, policy.maxLimit);
+  }
   return rows * Math.max(childComplexity, 1);
 };
 var aggregateFieldComplexity = (options) => ({ childComplexity }) => options.aggregateCost + childComplexity;
@@ -1010,7 +1217,7 @@ var relationJoinColumns = (tree, table, selectionCtx) => {
   if (!relations) {
     return [];
   }
-  const tableColumns = getColumns(table);
+  const tableColumns = getColumns2(table);
   const needed = [];
   for (const fieldData of Object.values(tree)) {
     if (tableColumns[fieldData.name]) {
@@ -1029,7 +1236,7 @@ var relationJoinColumns = (tree, table, selectionCtx) => {
   return needed;
 };
 var extractSelectedColumnsFromTree = (tree, table, selectionCtx) => {
-  const tableColumns = getColumns(table);
+  const tableColumns = getColumns2(table);
   const treeEntries = Object.entries(tree);
   const selectedColumns = [];
   for (const [_fieldName, fieldData] of treeEntries) {
@@ -1049,7 +1256,7 @@ var extractSelectedColumnsFromTree = (tree, table, selectionCtx) => {
   return Object.fromEntries(selectedColumns);
 };
 var extractSelectedColumnsFromTreeSQLFormat = (tree, table, selectionCtx) => {
-  const tableColumns = getColumns(table);
+  const tableColumns = getColumns2(table);
   const treeEntries = Object.entries(tree);
   const selectedColumns = [];
   for (const [_fieldName, fieldData] of treeEntries) {
@@ -1082,11 +1289,11 @@ var orderNulls = new GraphQLEnumType2({
     }
   }
 });
-var innerOrder = new GraphQLInputObjectType2({
+var innerOrder = new GraphQLInputObjectType3({
   name: "InnerOrder",
   fields: {
     direction: {
-      type: new GraphQLNonNull2(
+      type: new GraphQLNonNull3(
         new GraphQLEnumType2({
           name: "OrderDirection",
           description: "Order by direction",
@@ -1104,7 +1311,7 @@ var innerOrder = new GraphQLInputObjectType2({
       )
     },
     priority: {
-      type: new GraphQLNonNull2(GraphQLInt2),
+      type: new GraphQLNonNull3(GraphQLInt3),
       description: "Priority of current field"
     },
     nulls: {
@@ -1130,9 +1337,9 @@ var resolveGenericFilterDescriptor = (column, columnGraphQLType) => {
   if (columnGraphQLType.type === GraphQLJSON) {
     return { name: "JSON", kind: "json" };
   }
-  if (columnGraphQLType.type instanceof GraphQLList2) {
+  if (columnGraphQLType.type instanceof GraphQLList3) {
     let element = columnGraphQLType.type.ofType;
-    if (element instanceof GraphQLNonNull2) {
+    if (element instanceof GraphQLNonNull3) {
       element = element.ofType;
     }
     return { name: `${element.name}Array`, kind: "array" };
@@ -1156,10 +1363,10 @@ var resolveGenericFilterDescriptor = (column, columnGraphQLType) => {
   if (ct === "PgTimestamp" || ct === "PgTimestampString" || ct === "PgDate") {
     return { name: "DateTime", kind: "scalar" };
   }
-  if (columnGraphQLType.type === GraphQLInt2) {
+  if (columnGraphQLType.type === GraphQLInt3) {
     return { name: "Int", kind: "scalar" };
   }
-  if (columnGraphQLType.type === GraphQLFloat2) {
+  if (columnGraphQLType.type === GraphQLFloat3) {
     return { name: "Float", kind: "scalar" };
   }
   return { name: "String", kind: "scalar" };
@@ -1183,10 +1390,10 @@ var IN_ARRAY_DESCRIPTION = "Matches any one of these values (SQL `IN`)";
 var NOT_IN_ARRAY_DESCRIPTION = "Matches none of these values (SQL `NOT IN`)";
 var arrayFilterFields = (colType, colArr) => {
   let element = colType.ofType;
-  if (element instanceof GraphQLNonNull2) {
+  if (element instanceof GraphQLNonNull3) {
     element = element.ofType;
   }
-  const elementList = new GraphQLList2(new GraphQLNonNull2(element));
+  const elementList = new GraphQLList3(new GraphQLNonNull3(element));
   return {
     eq: { type: colType, description: "The whole array equals this array" },
     ne: { type: colType, description: "The whole array differs from this array" },
@@ -1203,8 +1410,8 @@ var arrayFilterFields = (colType, colArr) => {
 var FILTERS_WITHOUT_STRING_OPS = /* @__PURE__ */ new Set(["Id", "Int", "Float", "BigInt", "Decimal"]);
 var BUILTIN_FILTER_SCALARS = /* @__PURE__ */ new Set([
   GraphQLString2,
-  GraphQLInt2,
-  GraphQLFloat2,
+  GraphQLInt3,
+  GraphQLFloat3,
   GraphQLBoolean2,
   GraphQLBigIntString,
   GraphQLDecimalString,
@@ -1231,7 +1438,7 @@ var generateColumnFilterValues = (column, tableName, columnName, cacheCtx) => {
     return cached;
   }
   const colType = columnGraphQLType.type;
-  const colArr = new GraphQLList2(new GraphQLNonNull2(colType));
+  const colArr = new GraphQLList3(new GraphQLNonNull3(colType));
   const customOverrideFilter = inputOverride !== void 0 && !BUILTIN_FILTER_SCALARS.has(inputOverride);
   const underlying = extractExtendedColumnType2(column);
   const omitStringOps = customOverrideFilter ? underlying.type !== "string" || underlying.constraint === "numeric" : FILTERS_WITHOUT_STRING_OPS.has(genericName);
@@ -1277,16 +1484,16 @@ var generateColumnFilterValues = (column, tableName, columnName, cacheCtx) => {
     isNull: { type: GraphQLBoolean2, description: "When true, matches rows where the column is NULL" },
     isNotNull: { type: GraphQLBoolean2, description: "When true, matches rows where the column is not NULL" }
   };
-  const mainType = new GraphQLInputObjectType2({
+  const mainType = new GraphQLInputObjectType3({
     name: `${genericName}Filter`,
     fields: () => ({
       ...baseFields,
       OR: {
-        type: new GraphQLList2(new GraphQLNonNull2(mainType)),
+        type: new GraphQLList3(new GraphQLNonNull3(mainType)),
         description: "At least one branch matches; ANDed with any sibling operators"
       },
       AND: {
-        type: new GraphQLList2(new GraphQLNonNull2(mainType)),
+        type: new GraphQLList3(new GraphQLNonNull3(mainType)),
         description: "Every branch matches"
       },
       NOT: {
@@ -1305,7 +1512,7 @@ var generateTableOrderCached = (table) => {
   }
   let remapped = {};
   try {
-    const columns = getColumns(table);
+    const columns = getColumns2(table);
     const columnEntries = Object.entries(columns);
     remapped = Object.fromEntries(
       columnEntries.map(([columnName, _columnDescription]) => [columnName, { type: innerOrder }])
@@ -1319,7 +1526,7 @@ var generateTableFilterValuesCached = (table, tableName, cacheCtx) => {
   if (cacheCtx.filterFieldCache.has(table)) {
     return cacheCtx.filterFieldCache.get(table);
   }
-  const columns = getColumns(table);
+  const columns = getColumns2(table);
   const columnEntries = Object.entries(columns);
   const remapped = Object.fromEntries(
     columnEntries.map(([columnName, column]) => [
@@ -1340,7 +1547,7 @@ var generateTableSelectTypeFieldsCached = (table, tableName, cacheCtx) => {
   if (cacheCtx.selectFieldCache.has(table)) {
     return cacheCtx.selectFieldCache.get(table);
   }
-  const columns = getColumns(table);
+  const columns = getColumns2(table);
   const columnEntries = Object.entries(columns);
   const remapped = Object.fromEntries(
     columnEntries.map(([columnName, column]) => [
@@ -1395,7 +1602,7 @@ var generateTableOrderTypeCached = (table, tableName, typeNameMapper, cacheCtx,
   if (cacheCtx.orderTypeCache.has(table)) {
     return cacheCtx.orderTypeCache.get(table);
   }
-  const order = new GraphQLInputObjectType2({
+  const order = new GraphQLInputObjectType3({
     name: `${resolveTypeName(tableName, typeNameMapper)}OrderBy`,
     fields: () => {
       const orderColumns = generateTableOrderCached(table);
@@ -1413,7 +1620,7 @@ var generateListRelationFilterCached = (targetTable, targetTableName, cacheCtx,
   if (cached) {
     return cached;
   }
-  const listFilter = new GraphQLInputObjectType2({
+  const listFilter = new GraphQLInputObjectType3({
     name: `${resolveTypeName(targetTableName, typeNameMapper)}ListRelationFilter`,
     fields: () => {
       const targetFilters = generateTableFilterTypeCached(
@@ -1483,16 +1690,16 @@ var generateTableFilterTypeCached = (table, tableName, cacheCtx, typeNameMapper,
       ...generateRelationFilterFields(tableName, cacheCtx, typeNameMapper, filterColumns, relationMap, tables)
     };
   };
-  const filters = new GraphQLInputObjectType2({
+  const filters = new GraphQLInputObjectType3({
     name: `${resolveTypeName(tableName, typeNameMapper)}Filters`,
     fields: () => ({
       ...buildFields(),
       OR: {
-        type: new GraphQLList2(new GraphQLNonNull2(filters)),
+        type: new GraphQLList3(new GraphQLNonNull3(filters)),
         description: "At least one branch matches; ANDed with any sibling fields"
       },
       AND: {
-        type: new GraphQLList2(new GraphQLNonNull2(filters)),
+        type: new GraphQLList3(new GraphQLNonNull3(filters)),
         description: "Every branch matches"
       },
       NOT: {
@@ -1600,7 +1807,7 @@ var generateSelectFields = (tables, tableName, relationMap, fromTableName, fromR
         rawRelationFields.push([
           relationName,
           {
-            type: isRequired ? new GraphQLNonNull2(relType) : relType,
+            type: isRequired ? new GraphQLNonNull3(relType) : relType,
             args: {
               where: { type: relSelectData.filters }
             },
@@ -1610,19 +1817,29 @@ var generateSelectFields = (tables, tableName, relationMap, fromTableName, fromR
         ]);
         continue;
       }
+      const targetDistinctEnum = cacheCtx.features.distinct ? generateDistinctEnum(tables[targetTableName], resolveTypeName(targetTableName, typeNameMapper)) : void 0;
       rawRelationFields.push([
         relationName,
         {
-          type: new GraphQLNonNull2(new GraphQLList2(new GraphQLNonNull2(relType))),
+          type: new GraphQLNonNull3(new GraphQLList3(new GraphQLNonNull3(relType))),
           args: {
             where: { type: relSelectData.filters },
             orderBy: { type: relSelectData.order },
-            offset: { type: GraphQLInt2 },
-            limit: { type: GraphQLInt2 }
+            offset: { type: GraphQLInt3 },
+            limit: { type: GraphQLInt3 },
+            after: {
+              type: GraphQLString2,
+              description: "Keyset pagination: only return related rows strictly after this cursor (a row's `cursor` field from a previous page of this relation, under the same orderBy)."
+            },
+            ...targetDistinctEnum ? { distinct: { type: new GraphQLList3(new GraphQLNonNull3(targetDistinctEnum)) } } : {}
           },
           resolve,
           ...relationDocs,
-          ...cacheCtx.complexity ? { extensions: { complexity: listFieldComplexity(cacheCtx.complexity) } } : {}
+          ...cacheCtx.complexity ? {
+            extensions: {
+              complexity: listFieldComplexity(cacheCtx.complexity, cacheCtx.limits?.(targetTableName))
+            }
+          } : {}
         }
       ]);
       const aggregateFieldName = `${relationName}Aggregate`;
@@ -1636,7 +1853,7 @@ var generateSelectFields = (tables, tableName, relationMap, fromTableName, fromR
           rawRelationFields.push([
             aggregateFieldName,
             {
-              type: new GraphQLNonNull2(relationAggregate.type),
+              type: new GraphQLNonNull3(relationAggregate.type),
               args: {
                 where: { type: relSelectData.filters }
               },
@@ -1688,7 +1905,7 @@ var generateTableTypes = (tableName, tables, relationMap, withReturning, relatio
     relationAggregateFactory
   );
   const table = tables[tableName];
-  const columns = getColumns(table);
+  const columns = getColumns2(table);
   const columnEntries = Object.entries(columns);
   const relaxedColumns = nestedWrites?.relaxedColumns(tableName);
   const insertFields = Object.fromEntries(
@@ -1710,18 +1927,17 @@ var generateTableTypes = (tableName, tables, relationMap, withReturning, relatio
   const updateFields = Object.fromEntries(
     columnEntries.map(([columnName, column]) => {
       const converted = drizzleColumnToGraphQLType(column, columnName, tableName, true, false, true);
-      return [
-        columnName,
-        { ...converted, ...inputFieldDocs(cacheCtx.docs, column, tableName, columnName, converted.type) }
-      ];
+      const operations = cacheCtx.features.fieldUpdateOperations ? fieldUpdateInputType(column, columnName, tableName) : void 0;
+      const field = operations ? { ...converted, type: operations } : converted;
+      return [columnName, { ...field, ...inputFieldDocs(cacheCtx.docs, column, tableName, columnName, field.type) }];
     })
   );
   const typeName = resolveTypeName(tableName, typeNameMapper);
-  const insertInput = new GraphQLInputObjectType2({
+  const insertInput = new GraphQLInputObjectType3({
     name: `${capitalize(insertPrefix)}${typeName}Input`,
     fields: nestedWrites ? () => ({ ...insertFields, ...nestedWrites.createFields(tableName, typeName) }) : insertFields
   });
-  const updateInput = new GraphQLInputObjectType2({
+  const updateInput = new GraphQLInputObjectType3({
     name: `${capitalize(updatePrefix)}${typeName}Input`,
     fields: nestedWrites ? () => ({ ...updateFields, ...nestedWrites.updateFields(tableName, typeName) }) : updateFields
   });
@@ -1730,10 +1946,10 @@ var generateTableTypes = (tableName, tables, relationMap, withReturning, relatio
     description: cacheCtx.docs.describeTable?.(tableName),
     fields: { ...tableFields, ...relationFields }
   });
-  const selectArrOutput = new GraphQLNonNull2(new GraphQLList2(new GraphQLNonNull2(selectSingleOutput)));
+  const selectArrOutput = new GraphQLNonNull3(new GraphQLList3(new GraphQLNonNull3(selectSingleOutput)));
   const arrTableItemOutput = withReturning ? (
     //     ? new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(singleTableItemOutput!)))
-    new GraphQLNonNull2(new GraphQLList2(new GraphQLNonNull2(selectSingleOutput)))
+    new GraphQLNonNull3(new GraphQLList3(new GraphQLNonNull3(selectSingleOutput)))
   ) : void 0;
   const inputs = {
     insertInput,
@@ -1758,7 +1974,7 @@ var generateTableTypes = (tableName, tables, relationMap, withReturning, relatio
 };
 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`);
+    throw new GraphQLError4(`ORDER BY ${column}: ordering through a relation is not supported in this query`);
   }
   return [column, config.direction, config.nulls ?? void 0];
 });
@@ -1769,16 +1985,16 @@ var orderExpressions = (expr, direction, nulls, dialectColumn) => {
   }
   const isMySql = (dialectColumn.columnType ?? "").startsWith("MySql");
   if (isMySql) {
-    const nullsKey = nulls === "first" ? desc(sql`(${expr} is null)`) : asc(sql`(${expr} is null)`);
+    const nullsKey = nulls === "first" ? desc(sql2`(${expr} is null)`) : asc(sql2`(${expr} is null)`);
     return [nullsKey, directed];
   }
-  return [nulls === "first" ? sql`${directed} nulls first` : sql`${directed} nulls last`];
+  return [nulls === "first" ? sql2`${directed} nulls first` : sql2`${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`);
+    throw new GraphQLError4(`ORDER BY ${relationName}: Relation cannot be used for ordering`);
   }
   ctx.aliases ??= { n: 0 };
   const aliasedTarget = aliasedTable(targetTable, `dgql_ord_${ctx.aliases.n++}`);
@@ -1795,7 +2011,7 @@ var extendRelationOrderChain = (parentTable, relationName, relEntry, ctx, chain)
   };
 };
 var collectOrderEntries = (table, tableKey, orderArgs, ctx, chain, out) => {
-  const columns = getColumns(table);
+  const columns = getColumns2(table);
   const relations = ctx?.relationMap[tableKey];
   for (const [key, config] of Object.entries(orderArgs)) {
     if (config === null || config === void 0) {
@@ -1804,7 +2020,7 @@ var collectOrderEntries = (table, tableKey, orderArgs, ctx, chain, out) => {
     const column = columns[key];
     if (column) {
       out.push({
-        expression: chain ? sql`(select ${column} from ${sql.join(chain.fromParts, sql`, `)} where ${and(...chain.conditions)})` : column,
+        expression: chain ? sql2`(select ${column} from ${sql2.join(chain.fromParts, sql2`, `)} where ${and(...chain.conditions)})` : column,
         column,
         direction: config.direction,
         nulls: config.nulls ?? void 0,
@@ -1814,7 +2030,7 @@ var collectOrderEntries = (table, tableKey, orderArgs, ctx, chain, out) => {
     }
     const relEntry = relations?.[key];
     if (!relEntry || !ctx) {
-      throw new GraphQLError3(`ORDER BY ${key}: Unknown column or relation`);
+      throw new GraphQLError4(`ORDER BY ${key}: Unknown column or relation`);
     }
     const nextChain = extendRelationOrderChain(chain?.table ?? table, key, relEntry, ctx, chain);
     collectOrderEntries(nextChain.table, relEntry.targetTableName, config, ctx, nextChain, out);
@@ -1837,21 +2053,21 @@ var safeLikeOps = {
 };
 var safeLikeCondition = (column, pattern, insensitive) => {
   if (!insensitive) {
-    return sql`${column} like ${pattern} escape ${LIKE_ESCAPE_CHAR}`;
+    return sql2`${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}`;
+  return isPg ? sql2`${column} ilike ${pattern} escape ${LIKE_ESCAPE_CHAR}` : sql2`lower(${column}) like ${pattern.toLowerCase()} escape ${LIKE_ESCAPE_CHAR}`;
 };
 var isJsonColumn2 = (column) => (column.columnType ?? "").includes("Json");
 var jsonContains = (column, columnName, value) => {
   const serialized = JSON.stringify(value);
   switch (columnDialect(column)) {
     case "pg":
-      return column.columnType === "PgJson" ? sql`${column}::jsonb @> ${serialized}::jsonb` : sql`${column} @> ${serialized}::jsonb`;
+      return column.columnType === "PgJson" ? sql2`${column}::jsonb @> ${serialized}::jsonb` : sql2`${column} @> ${serialized}::jsonb`;
     case "mysql":
-      return sql`json_contains(${column}, ${serialized})`;
+      return sql2`json_contains(${column}, ${serialized})`;
     default:
-      throw new GraphQLError3(`WHERE ${columnName}: Operator 'contains' is not supported for this dialect!`);
+      throw new GraphQLError4(`WHERE ${columnName}: Operator 'contains' is not supported for this dialect!`);
   }
 };
 var extractFiltersColumn = (column, columnName, operators) => {
@@ -1882,7 +2098,7 @@ var extractFiltersColumn = (column, columnName, operators) => {
       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!`);
+        throw new GraphQLError4(`WHERE ${columnName}: Unable to use operator ${operatorName} with an empty array!`);
       }
       const arrayValue = operatorValue.map((val) => remapFromGraphQLCore(val, column, columnName));
       variants.push(arrayValueOps[operatorName](column, arrayValue));
@@ -1890,15 +2106,15 @@ var extractFiltersColumn = (column, columnName, operators) => {
       variants.push(arrayContains(column, [operatorValue]));
     } else if (operatorName in arrayMembershipOps) {
       if (!operatorValue.length) {
-        throw new GraphQLError3(`WHERE ${columnName}: Unable to use operator ${operatorName} with an empty array!`);
+        throw new GraphQLError4(`WHERE ${columnName}: Unable to use operator ${operatorName} with an empty array!`);
       }
       variants.push(arrayMembershipOps[operatorName](column, operatorValue));
     } else if (operatorName === "isEmpty") {
-      variants.push(sql`cardinality(${column}) = 0`);
+      variants.push(sql2`cardinality(${column}) = 0`);
     } else if (operatorName in nullableOps) {
       variants.push(nullableOps[operatorName](column));
     } else {
-      throw new GraphQLError3(`WHERE ${columnName}: Unknown operator: ${operatorName}`);
+      throw new GraphQLError4(`WHERE ${columnName}: Unknown operator: ${operatorName}`);
     }
   }
   if (AND?.length) {
@@ -1934,23 +2150,23 @@ var buildRelationJoinCondition = (parentTable, relation, aliasedTarget, relation
   const sourceColumns = relation.sourceColumns;
   const targetColumns = relation.targetColumns;
   if (!sourceColumns?.length || sourceColumns.length !== targetColumns?.length) {
-    throw new GraphQLError3(`WHERE ${relationName}: Relation cannot be used as a filter`);
+    throw new GraphQLError4(`WHERE ${relationName}: Relation cannot be used as a filter`);
   }
-  const parentColumns = Object.values(getColumns(parentTable));
-  const targetColumnsByName = Object.values(getColumns(aliasedTarget));
+  const parentColumns = Object.values(getColumns2(parentTable));
+  const targetColumnsByName = Object.values(getColumns2(aliasedTarget));
   const conditions = [];
   for (let i = 0; i < sourceColumns.length; i++) {
     const localColumn = parentColumns.find((c) => c.name === sourceColumns[i].name);
     const foreignColumn = targetColumnsByName.find((c) => c.name === targetColumns[i].name);
     if (!localColumn || !foreignColumn) {
-      throw new GraphQLError3(`WHERE ${relationName}: Relation cannot be used as a filter`);
+      throw new GraphQLError4(`WHERE ${relationName}: Relation cannot be used as a filter`);
     }
     conditions.push(eq(localColumn, foreignColumn));
   }
   return conditions.length > 1 ? and(...conditions) : conditions[0];
 };
 var resolveJunctionColumn = (aliasedThrough, junctionRef, relationName) => {
-  const throughColumns = getColumns(aliasedThrough);
+  const throughColumns = getColumns2(aliasedThrough);
   const key = junctionRef?._?.key;
   const byKey = key ? throughColumns[key] : void 0;
   if (byKey) {
@@ -1959,7 +2175,7 @@ var resolveJunctionColumn = (aliasedThrough, junctionRef, relationName) => {
   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`);
+    throw new GraphQLError4(`WHERE ${relationName}: Relation cannot be used as a filter`);
   }
   return byName;
 };
@@ -1968,15 +2184,15 @@ var buildThroughJoinConditions = (parentTable, relation, aliasedThrough, aliased
   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`);
+    throw new GraphQLError4(`WHERE ${relationName}: Relation cannot be used as a filter`);
   }
-  const parentColumns = Object.values(getColumns(parentTable));
-  const targetTableColumns = Object.values(getColumns(aliasedTarget));
+  const parentColumns = Object.values(getColumns2(parentTable));
+  const targetTableColumns = Object.values(getColumns2(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`);
+      throw new GraphQLError4(`WHERE ${relationName}: Relation cannot be used as a filter`);
     }
     correlationConditions.push(eq(localColumn, resolveJunctionColumn(aliasedThrough, through.source[i], relationName)));
   }
@@ -1984,7 +2200,7 @@ var buildThroughJoinConditions = (parentTable, relation, aliasedThrough, aliased
   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`);
+      throw new GraphQLError4(`WHERE ${relationName}: Relation cannot be used as a filter`);
     }
     junctionJoinConditions.push(
       eq(resolveJunctionColumn(aliasedThrough, through.target[i], relationName), foreignColumn)
@@ -2000,7 +2216,7 @@ var buildRelationExists = (parentTable, relationName, relEntry, innerFilters, mo
   const targetTable = ctx.tables[targetTableName];
   const relation = relEntry.relation ?? relEntry;
   if (!targetTable) {
-    throw new GraphQLError3(`WHERE ${relationName}: Relation cannot be used as a filter`);
+    throw new GraphQLError4(`WHERE ${relationName}: Relation cannot be used as a filter`);
   }
   ctx.aliases ??= { n: 0 };
   const aliases = ctx.aliases;
@@ -2017,7 +2233,7 @@ var buildRelationExists = (parentTable, relationName, relEntry, innerFilters, mo
       aliasedTarget,
       relationName
     );
-    fromClause = sql`${getTableAsAliasSQL(aliasedTarget)} inner join ${getTableAsAliasSQL(aliasedThrough)} on ${junctionJoin}`;
+    fromClause = sql2`${getTableAsAliasSQL(aliasedTarget)} inner join ${getTableAsAliasSQL(aliasedThrough)} on ${junctionJoin}`;
     joinCondition = correlation;
   } else {
     fromClause = getTableAsAliasSQL(aliasedTarget);
@@ -2029,10 +2245,10 @@ var buildRelationExists = (parentTable, relationName, relEntry, innerFilters, mo
     if (!inner) {
       return void 0;
     }
-    return sql`not exists (select 1 from ${fromClause} where ${and(joinCondition, relationWhere, not(inner))})`;
+    return sql2`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 ${fromClause} where ${condition})` : sql`exists (select 1 from ${fromClause} where ${condition})`;
+  return mode === "none" ? sql2`not exists (select 1 from ${fromClause} where ${condition})` : sql2`exists (select 1 from ${fromClause} where ${condition})`;
 };
 var extractRelationFilter = (parentTable, relationName, relEntry, value, ctx) => {
   const relation = relEntry.relation ?? relEntry;
@@ -2046,7 +2262,7 @@ var extractRelationFilter = (parentTable, relationName, relEntry, value, ctx) =>
       continue;
     }
     if (!relationMatchModes.includes(mode)) {
-      throw new GraphQLError3(`WHERE ${relationName}: Unknown relation filter key: ${mode}`);
+      throw new GraphQLError4(`WHERE ${relationName}: Unknown relation filter key: ${mode}`);
     }
     const extracted = buildRelationExists(parentTable, relationName, relEntry, inner, mode, ctx);
     if (extracted) {
@@ -2058,7 +2274,7 @@ var extractRelationFilter = (parentTable, relationName, relEntry, value, ctx) =>
 var extractFilters = (table, tableName, filters, relationCtx) => {
   const { OR, AND, NOT, ...fieldFilters } = filters;
   const entries = Object.entries(fieldFilters);
-  const columns = getColumns(table);
+  const columns = getColumns2(table);
   const relations = relationCtx?.relationMap[relationCtx.tableKey];
   const variants = [];
   for (const [fieldName, operators] of entries) {
@@ -2067,7 +2283,7 @@ var extractFilters = (table, tableName, filters, relationCtx) => {
     }
     const column = columns[fieldName];
     if (!column && !(relations?.[fieldName] && relationCtx)) {
-      throw new GraphQLError3(`WHERE ${tableName}: Unknown filter key: ${fieldName}`);
+      throw new GraphQLError4(`WHERE ${tableName}: Unknown filter key: ${fieldName}`);
     }
     const extracted = column ? extractFiltersColumn(column, fieldName, operators) : extractRelationFilter(table, fieldName, relations[fieldName], operators, relationCtx);
     if (extracted) {
@@ -2102,7 +2318,7 @@ var extractFilters = (table, tableName, filters, relationCtx) => {
   }
   return variants.length ? variants.length > 1 ? and(...variants) : variants[0] : void 0;
 };
-var extractRelationsParamsInner = (relationMap, tables, tableName, typeName, originField, typeNameMapper, _isInitial = false, filterCtx) => {
+var extractRelationsParamsInner = (relationMap, tables, tableName, typeName, originField, typeNameMapper, _isInitial = false, filterCtx, limits) => {
   const relationsForTable = relationMap[tableName];
   if (!relationsForTable) {
     return void 0;
@@ -2131,6 +2347,10 @@ var extractRelationsParamsInner = (relationMap, tables, tableName, typeName, ori
     if (!relFieldSelection) {
       continue;
     }
+    const eagerArgs = field.args;
+    if (!is3(relEntry.relation ?? relEntry, One2) && (eagerArgs?.after != null || !!eagerArgs?.distinct?.length || isCursorFieldSelected(relFieldSelection, tables[targetTableName]))) {
+      continue;
+    }
     const columns = extractSelectedColumnsFromTree(relFieldSelection, tables[targetTableName], {
       tableName: targetTableName,
       relationMap,
@@ -2142,7 +2362,7 @@ var extractRelationsParamsInner = (relationMap, tables, tableName, typeName, ori
     const relationField = Object.values(baseField).find((e) => e.name === relName);
     const relationArgs = relationField?.args;
     const offset = relationArgs?.offset ?? void 0;
-    const limit = relationArgs?.limit ?? void 0;
+    const limit = is3(relEntry.relation, One2) ? relationArgs?.limit ?? void 0 : applyLimitPolicy(relationArgs?.limit, limits?.(targetTableName), `${tableName}.${relName}`);
     const relWhere = relationArgs?.where;
     thisRecord.where = relWhere ? {
       RAW: (aliasedTable2) => extractFilters(aliasedTable2, relName, relWhere, relationFilterCtx(filterCtx, targetTableName))
@@ -2160,18 +2380,29 @@ var extractRelationsParamsInner = (relationMap, tables, tableName, typeName, ori
       relationField,
       typeNameMapper,
       false,
-      filterCtx
+      filterCtx,
+      limits
     ) : void 0;
     thisRecord.with = relWith;
     args[relName] = thisRecord;
   }
   return args;
 };
-var extractRelationsParams = (relationMap, tables, tableName, info, typeName, typeNameMapper, filterCtx) => {
+var extractRelationsParams = (relationMap, tables, tableName, info, typeName, typeNameMapper, filterCtx, limits) => {
   if (!info) {
     return void 0;
   }
-  return extractRelationsParamsInner(relationMap, tables, tableName, typeName, info, typeNameMapper, true, filterCtx);
+  return extractRelationsParamsInner(
+    relationMap,
+    tables,
+    tableName,
+    typeName,
+    info,
+    typeNameMapper,
+    true,
+    filterCtx,
+    limits
+  );
 };
 var pruneNonEagerRelations = (relationMap, shouldEagerLoad) => {
   const out = {};
@@ -2183,7 +2414,7 @@ var pruneNonEagerRelations = (relationMap, shouldEagerLoad) => {
   return out;
 };
 var getPrimaryKeyPropNames = (table, compositePkColumnNames) => {
-  const cols = getColumns(table);
+  const cols = getColumns2(table);
   const entries = Object.entries(cols);
   const inlinePks = entries.filter(([, c]) => c.primary).map(([k]) => k);
   if (inlinePks.length) {
@@ -2199,7 +2430,7 @@ var getPrimaryKeyPropNames = (table, compositePkColumnNames) => {
   return [];
 };
 var withPrimaryKeyColumns = (columns, table, pkNames) => {
-  const allCols = getColumns(table);
+  const allCols = getColumns2(table);
   for (const pk of pkNames) {
     if (!(pk in columns) && allCols[pk]) {
       columns[pk] = allCols[pk];
@@ -2212,7 +2443,7 @@ var getPrimaryKeyPropNamesFromConfig = (table, getTableConfig4) => {
   return getPrimaryKeyPropNames(table, compositePkColumnNames);
 };
 var primaryKeyOrderExprs = (table, pkNames) => {
-  const cols = getColumns(table);
+  const cols = getColumns2(table);
   return pkNames.map((n) => cols[n]).filter(Boolean).map((col) => asc(col));
 };
 var CURSOR_FIELD_NAME = "cursor";
@@ -2229,7 +2460,7 @@ var cursorOrderingEntries = (orderBy, pkNames) => {
   return entries;
 };
 var cursorOrderExprs = (table, entries) => {
-  const cols = getColumns(table);
+  const cols = getColumns2(table);
   return entries.flatMap(
     ([column, direction, nulls]) => orderExpressions(cols[column], direction, nulls ?? void 0, cols[column])
   );
@@ -2266,10 +2497,10 @@ var decodeCursor = (after, entries) => {
   try {
     payload = JSON.parse(Buffer.from(after, "base64url").toString("utf8"));
   } catch (_e) {
-    throw new GraphQLError3("Invalid cursor: unable to decode it. Pass a cursor returned by a previous page.");
+    throw new GraphQLError4("Invalid cursor: unable to decode it. Pass a cursor returned by a previous page.");
   }
   if (!payload || typeof payload !== "object" || !Array.isArray(payload.o) || !Array.isArray(payload.v) || payload.o.length !== payload.v.length) {
-    throw new GraphQLError3("Invalid cursor: malformed payload. Pass a cursor returned by a previous page.");
+    throw new GraphQLError4("Invalid cursor: malformed payload. Pass a cursor returned by a previous page.");
   }
   const matchesOrdering = payload.o.length === entries.length && payload.o.every(
     (entry, i) => Array.isArray(entry) && entry[0] === entries[i][0] && entry[1] === entries[i][1] && // The nulls override changes where NULLs sort, so it is part of the ordering identity.
@@ -2277,20 +2508,20 @@ var decodeCursor = (after, entries) => {
     (entry[2] ?? null) === (entries[i][2] ?? null)
   );
   if (!matchesOrdering) {
-    throw new GraphQLError3(
+    throw new GraphQLError4(
       "Invalid cursor: it was issued for a different ordering. Pass the same orderBy the cursor's page used."
     );
   }
   return payload.v.map(decodeCursorValue);
 };
 var buildCursorCondition = (table, entries, values, nullOrdering) => {
-  const cols = getColumns(table);
+  const cols = getColumns2(table);
   const disjuncts = [];
   const equalities = [];
   entries.forEach(([column, direction, nulls], i) => {
     const col = cols[column];
     if (!col) {
-      throw new GraphQLError3(`Invalid cursor: unknown column '${column}'.`);
+      throw new GraphQLError4(`Invalid cursor: unknown column '${column}'.`);
     }
     const value = values[i];
     const nullsSortLast = nulls != null ? nulls === "last" : direction === "asc" === (nullOrdering === "nulls-largest");
@@ -2307,7 +2538,7 @@ var buildCursorCondition = (table, entries, values, nullOrdering) => {
     equalities.push(value === null || value === void 0 ? isNull(col) : eq(col, value));
   });
   if (!disjuncts.length) {
-    return sql`1 = 0`;
+    return sql2`1 = 0`;
   }
   return disjuncts.length > 1 ? or(...disjuncts) : disjuncts[0];
 };
@@ -2315,11 +2546,33 @@ var isCursorFieldSelected = (tree, table) => {
   if (!tree) {
     return false;
   }
-  if (getColumns(table)[CURSOR_FIELD_NAME]) {
+  if (getColumns2(table)[CURSOR_FIELD_NAME]) {
     return false;
   }
   return Object.values(tree).some((field) => field.name === CURSOR_FIELD_NAME);
 };
+var selectsCursorField = (info, table) => {
+  if (getColumns2(table)[CURSOR_FIELD_NAME]) {
+    return false;
+  }
+  const visited = /* @__PURE__ */ new Set();
+  const walk = (selections) => selections.some((selection) => {
+    if (selection.kind === "Field") {
+      return selection.name.value === CURSOR_FIELD_NAME;
+    }
+    if (selection.kind === "InlineFragment") {
+      return walk(selection.selectionSet.selections);
+    }
+    const name = selection.name?.value;
+    if (!name || visited.has(name)) {
+      return false;
+    }
+    visited.add(name);
+    const fragment = info.fragments?.[name];
+    return fragment ? walk(fragment.selectionSet.selections) : false;
+  });
+  return (info.fieldNodes ?? []).some((node) => !!node.selectionSet && walk(node.selectionSet.selections));
+};
 var attachRowCursors = (rows, entries) => {
   for (const row of rows) {
     row[ROW_CURSOR_PROP] = encodeCursor(entries, row);
@@ -2327,7 +2580,7 @@ var attachRowCursors = (rows, entries) => {
 };
 var rowCursorResolver = (source) => source?.[ROW_CURSOR_PROP] ?? null;
 var getUniqueColumnSets = (table, getTableConfig4) => {
-  const cols = getColumns(table);
+  const cols = getColumns2(table);
   const propNameByColumnName = new Map(Object.entries(cols).map(([propName, col]) => [col.name, propName]));
   const toPropNames = (columnNames) => {
     const propNames = [];
@@ -2372,7 +2625,7 @@ var generateColumnEnum = (table, enumName, description, predicate = () => true)
   if (cached) {
     return cached;
   }
-  const columnNames = Object.entries(getColumns(table)).filter(([columnName, column]) => predicate(column, columnName)).map(([columnName]) => columnName);
+  const columnNames = Object.entries(getColumns2(table)).filter(([columnName, column]) => predicate(column, columnName)).map(([columnName]) => columnName);
   if (!columnNames.length) {
     return void 0;
   }
@@ -2414,7 +2667,7 @@ var generateOnConflictInput = (params) => {
       description: "Whether a conflicting row is overwritten or left alone. Defaults to UPDATE."
     },
     update: {
-      type: new GraphQLList2(new GraphQLNonNull2(updateEnum)),
+      type: new GraphQLList3(new GraphQLNonNull3(updateEnum)),
       description: "Columns to overwrite on conflict. Defaults to every column the request supplied, minus the conflict target. Columns the request did not supply cannot be listed here \u2014 there would be no value to write."
     }
   };
@@ -2430,7 +2683,7 @@ var generateOnConflictInput = (params) => {
       return void 0;
     }
     fields["target"] = {
-      type: new GraphQLList2(new GraphQLNonNull2(targetEnum)),
+      type: new GraphQLList3(new GraphQLNonNull3(targetEnum)),
       description: "The unique column set a conflict is detected on. Must match one of the table\u2019s unique constraints exactly. Defaults to the primary key."
     };
     fields["where"] = {
@@ -2438,7 +2691,7 @@ var generateOnConflictInput = (params) => {
       description: "Only overwrite conflicting rows that match this filter. Others are left alone."
     };
   }
-  return new GraphQLInputObjectType2({
+  return new GraphQLInputObjectType3({
     name: `${typeName}OnConflict`,
     description: `Conflict handling for an upsert of ${typeName}`,
     fields
@@ -2446,18 +2699,18 @@ var generateOnConflictInput = (params) => {
 };
 var resolveConflictPlan = (params) => {
   const { table, values, onConflict, pkNames, uniqueSets, excludedRef, withTarget, buildWhere } = params;
-  const columns = getColumns(table);
+  const columns = getColumns2(table);
   let target;
   if (withTarget) {
     const targetNames2 = onConflict?.target?.length ? onConflict.target : [...pkNames];
     if (!targetNames2.length) {
-      throw new GraphQLError3(
+      throw new GraphQLError4(
         "Unable to upsert: no conflict target was given and this table has no primary key. Pass onConflict.target."
       );
     }
     const requested = [...targetNames2].sort().join(",");
     if (!uniqueSets.some((set2) => [...set2].sort().join(",") === requested)) {
-      throw new GraphQLError3(
+      throw new GraphQLError4(
         `Unable to upsert: [${targetNames2.join(", ")}] is not a unique constraint on this table. Valid conflict targets: ${uniqueSets.map((set2) => `[${set2.join(", ")}]`).join(", ")}.`
       );
     }
@@ -2472,7 +2725,7 @@ var resolveConflictPlan = (params) => {
   if (onConflict?.update?.length) {
     const unsupplied = onConflict.update.filter((name) => !supplied.has(name));
     if (unsupplied.length) {
-      throw new GraphQLError3(
+      throw new GraphQLError4(
         `Unable to upsert: onConflict.update lists ${unsupplied.join(", ")}, which the values do not supply.`
       );
     }
@@ -2487,18 +2740,19 @@ var resolveConflictPlan = (params) => {
   const setWhere = onConflict?.where && buildWhere ? buildWhere(onConflict.where) : void 0;
   return { action: "UPDATE", target, set, setWhere };
 };
-var excludedColumnRef = (columnName) => sql`excluded.${sql.identifier(columnName)}`;
-var mysqlValuesColumnRef = (columnName) => sql`values(${sql.identifier(columnName)})`;
+var excludedColumnRef = (columnName) => sql2`excluded.${sql2.identifier(columnName)}`;
+var mysqlValuesColumnRef = (columnName) => sql2`values(${sql2.identifier(columnName)})`;
 var selectDistinctKeys = async (params) => {
-  const { db, table, tableName, distinct, pkNames, where, orderBy, limit, offset } = params;
-  const cols = getColumns(table);
+  const { db, table, tableName, distinct, pkNames, where, orderBy, limit, offset, partitionBy } = params;
+  const cols = getColumns2(table);
   if (!pkNames.length) {
-    throw new GraphQLError3(`Table ${tableName} has no primary key, so 'distinct' cannot be applied to it.`);
+    throw new GraphQLError4(`Table ${tableName} has no primary key, so 'distinct' cannot be applied to it.`);
   }
-  const partitionCols = distinct.map((name) => cols[name]).filter(Boolean);
-  if (!partitionCols.length) {
-    throw new GraphQLError3(`No known columns were given to 'distinct' on ${tableName}.`);
+  const requestedCols = distinct.map((name) => cols[name]).filter(Boolean);
+  if (!requestedCols.length) {
+    throw new GraphQLError4(`No known columns were given to 'distinct' on ${tableName}.`);
   }
+  const partitionCols = [...partitionBy ?? [], ...requestedCols];
   const orderEntries = orderBy ? orderByEntries(orderBy) : [];
   const windowOrder = [
     ...orderEntries.flatMap(
@@ -2506,9 +2760,9 @@ var selectDistinctKeys = async (params) => {
     ),
     ...primaryKeyOrderExprs(table, pkNames)
   ];
-  const rowNumber = sql`row_number() over (partition by ${sql.join(partitionCols, sql`, `)} order by ${sql.join(
+  const rowNumber = sql2`row_number() over (partition by ${sql2.join(partitionCols, sql2`, `)} order by ${sql2.join(
     windowOrder,
-    sql`, `
+    sql2`, `
   )})`.as(DISTINCT_RN);
   const sub = db.select({ ...cols, [DISTINCT_RN]: rowNumber }).from(table).where(where).as("__dgql_distinct");
   const outerOrder = [
@@ -2527,7 +2781,7 @@ var selectDistinctKeys = async (params) => {
   return await query;
 };
 var primaryKeyRestriction = (table, pkNames, keys) => {
-  const cols = getColumns(table);
+  const cols = getColumns2(table);
   if (pkNames.length === 1) {
     const name = pkNames[0];
     return inArray(
@@ -2539,7 +2793,16 @@ var primaryKeyRestriction = (table, pkNames, keys) => {
 };
 var prepareMutationRelationColumns = (params) => {
   const { relationMap, tables, tableName, typeName, typeNameMapper, table, pkNames, parsedInfo } = params;
-  const withParams = relationMap[tableName] ? extractRelationsParams(relationMap, tables, tableName, parsedInfo, typeName, typeNameMapper) : void 0;
+  const withParams = relationMap[tableName] ? extractRelationsParams(
+    relationMap,
+    tables,
+    tableName,
+    parsedInfo,
+    typeName,
+    typeNameMapper,
+    void 0,
+    params.limits
+  ) : void 0;
   const hasRelations = !!(withParams && Object.keys(withParams).length);
   const baseColumns = extractSelectedColumnsFromTreeSQLFormat(parsedInfo.fieldsByTypeName[typeName], table, {
     tableName,
@@ -2550,17 +2813,17 @@ var prepareMutationRelationColumns = (params) => {
   return { columns, hasRelations, withParams };
 };
 var toGraphQLError = (e) => {
-  if (e instanceof GraphQLError3) {
+  if (e instanceof GraphQLError4) {
     return e;
   }
-  return e instanceof Error ? new GraphQLError3(e.message, { originalError: e }) : e;
+  return e instanceof Error ? new GraphQLError4(e.message, { originalError: e }) : e;
 };
 var defaultErrorMapper = (error) => {
-  if (error instanceof GraphQLError3 && !error.originalError) {
+  if (error instanceof GraphQLError4 && !error.originalError) {
     return error;
   }
-  return new GraphQLError3("Internal server error", {
-    originalError: error instanceof GraphQLError3 ? error.originalError ?? error : error instanceof Error ? error : null,
+  return new GraphQLError4("Internal server error", {
+    originalError: error instanceof GraphQLError4 ? error.originalError ?? error : error instanceof Error ? error : null,
     extensions: { code: "INTERNAL_SERVER_ERROR" }
   });
 };
@@ -2617,6 +2880,9 @@ var computeResolverFieldNames = (tableName, typeNameMapper, prefixes, suffixes)
   const writeSingleSuffix = suffixes.single === "" ? "Single" : suffixes.single;
   const updateSingleFieldName = `${updateFieldName}${writeSingleSuffix}`;
   const deleteSingleFieldName = `${deleteFieldName}${writeSingleSuffix}`;
+  const pluralNoun = mapped ? capitalize(mapped.plural) : capitalize(tableName);
+  const updateCountFieldName = `${prefixes.update}${pluralNoun}Count`;
+  const deleteCountFieldName = `${prefixes.delete}${pluralNoun}Count`;
   return {
     typeName,
     listFieldName,
@@ -2630,13 +2896,15 @@ var computeResolverFieldNames = (tableName, typeNameMapper, prefixes, suffixes)
     updateFieldName,
     updateManyFieldName,
     updateSingleFieldName,
+    updateCountFieldName,
     deleteFieldName,
-    deleteSingleFieldName
+    deleteSingleFieldName,
+    deleteCountFieldName
   };
 };
 var generateUpdateManyInput = (params) => {
   const { typeName, updatePrefix, updateInput, tableFilters } = params;
-  return new GraphQLInputObjectType2({
+  return new GraphQLInputObjectType3({
     name: `${capitalize(updatePrefix)}${typeName}ManyInput`,
     description: `One entry of a batch update of ${typeName}: the rows \`where\` matches get this entry's \`set\` applied.`,
     fields: {
@@ -2645,7 +2913,7 @@ var generateUpdateManyInput = (params) => {
         description: "Rows this entry updates. An omitted filter updates every row."
       },
       set: {
-        type: new GraphQLNonNull2(updateInput)
+        type: new GraphQLNonNull3(updateInput)
       }
     }
   });
@@ -2653,29 +2921,101 @@ var generateUpdateManyInput = (params) => {
 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!`);
+    throw new GraphQLError4(`${fieldName} requires a 'where' argument with at least one filter!`);
   }
   return filters;
 };
+var rowsAffected = (result, fieldName) => {
+  const asNumber = (value) => typeof value === "number" ? value : typeof value === "bigint" ? Number(value) : void 0;
+  if (result && typeof result === "object") {
+    for (const key of ["rowCount", "affectedRows", "rowsAffected", "changes", "count"]) {
+      const value = asNumber(result[key]);
+      if (value !== void 0) {
+        return value;
+      }
+    }
+    const header = Array.isArray(result) ? result[0] : void 0;
+    const affected = header && typeof header === "object" ? asNumber(header.affectedRows) : void 0;
+    if (affected !== void 0) {
+      return affected;
+    }
+  }
+  throw new GraphQLError4(`${fieldName}: the driver did not report how many rows the write affected.`);
+};
 var assertSingleMatch = async (executor, table, filters, fieldName) => {
-  const matched = await executor.select({ found: sql`1` }).from(table).where(filters).limit(2);
+  const matched = await executor.select({ found: sql2`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!`);
-  }
+    throw new GraphQLError4(`${fieldName}: 'where' matched more than one row \u2014 nothing was written!`);
+  }
+};
+var generateWriteCount = ({
+  db,
+  tableName,
+  table,
+  kind,
+  setArgs,
+  filterArgs,
+  fieldName,
+  requireWhere,
+  filterCtx,
+  txCtx,
+  nested
+}) => {
+  const queryArgs = {
+    ...setArgs ? { set: { type: new GraphQLNonNull3(setArgs) } } : {},
+    where: {
+      type: requireWhere ? new GraphQLNonNull3(filterArgs) : filterArgs
+    }
+  };
+  return {
+    name: fieldName,
+    resolver: async (_source, args, context, info) => {
+      try {
+        return await runMutation(db, context, info, txCtx, async (executor) => {
+          const { where, set } = args;
+          const relationCtx = relationFilterCtx(filterCtx, tableName);
+          const filters = requireWhere ? extractRequiredFilters(table, tableName, where, fieldName, relationCtx) : where ? extractFilters(table, tableName, where, relationCtx) : void 0;
+          let query;
+          if (kind === "delete") {
+            query = executor.delete(table);
+          } else {
+            const entry = nested?.enabled(tableName) ? nested.split(tableName, set) : void 0;
+            if (entry && nested.hasOps(entry.ops)) {
+              throw new GraphQLError4(
+                `${fieldName} does not support nested writes \u2014 use ${fieldName.slice(0, -"Count".length)} instead.`
+              );
+            }
+            const values = remapUpdateInput(entry ? entry.columns : set, table, tableName);
+            if (!Object.keys(values).length) {
+              throw new GraphQLError4("Unable to update with no values specified!");
+            }
+            query = executor.update(table).set(values);
+          }
+          if (filters) {
+            query = query.where(filters);
+          }
+          return rowsAffected(await query, fieldName);
+        });
+      } catch (e) {
+        throw toGraphQLError(e);
+      }
+    },
+    args: queryArgs
+  };
 };
 var selectArrayArgs = (orderArgs, filterArgs, distinctEnum) => ({
-  offset: { type: GraphQLInt2 },
-  limit: { type: GraphQLInt2 },
+  offset: { type: GraphQLInt3 },
+  limit: { type: GraphQLInt3 },
   orderBy: { type: orderArgs },
   where: { type: filterArgs },
   after: {
     type: GraphQLString2,
     description: "Keyset pagination: only return rows strictly after this cursor (a row's `cursor` field from a previous page, under the same orderBy)."
   },
-  ...distinctEnum ? { distinct: { type: new GraphQLList2(new GraphQLNonNull2(distinctEnum)) } } : {}
+  ...distinctEnum ? { distinct: { type: new GraphQLList3(new GraphQLNonNull3(distinctEnum)) } } : {}
 });
 var selectSingleArgs = (orderArgs, filterArgs) => ({
-  offset: { type: GraphQLInt2 },
+  offset: { type: GraphQLInt3 },
   orderBy: { type: orderArgs },
   where: { type: filterArgs }
 });
@@ -2702,17 +3042,17 @@ var runRelationalSelect = async (opts) => {
   let cursorEntries;
   if (!single && (after != null || cursorSelected)) {
     if (after != null && distinct) {
-      throw new GraphQLError3("'after' cannot be combined with 'distinct'.");
+      throw new GraphQLError4("'after' cannot be combined with 'distinct'.");
     }
     if (orderByHasRelationEntry(orderBy)) {
       if (after != null) {
-        throw new GraphQLError3(
+        throw new GraphQLError4(
           "'after' cannot be combined with an orderBy that orders through a relation \u2014 a related row's value cannot be encoded into a cursor."
         );
       }
     } else if (!pkNames?.length) {
       if (after != null) {
-        throw new GraphQLError3(`Table ${tableName} has no primary key, so cursor pagination cannot be used on it.`);
+        throw new GraphQLError4(`Table ${tableName} has no primary key, so cursor pagination cannot be used on it.`);
       }
     } else {
       cursorEntries = cursorOrderingEntries(orderBy, pkNames);
@@ -2766,7 +3106,16 @@ var runRelationalSelect = async (opts) => {
         ) : void 0
       )
     } : void 0,
-    with: relationMap[tableName] ? extractRelationsParams(relationMap, tables, tableName, parsedInfo, typeName, typeNameMapper, filterCtx) : void 0
+    with: relationMap[tableName] ? extractRelationsParams(
+      relationMap,
+      tables,
+      tableName,
+      parsedInfo,
+      typeName,
+      typeNameMapper,
+      filterCtx,
+      opts.limits
+    ) : void 0
   };
   if (single) {
     const result2 = await queryBase.findFirst(params);
@@ -2809,20 +3158,20 @@ var eagerLoadMutationRelations = async (db, tableName, rows, pkNames, withParams
     whereRaw = (aliased) => inArray(aliased[pkName], ids);
   } else {
     whereRaw = (aliased) => {
-      const lhs = sql.join(
-        pkNames.map((n) => sql`${aliased[n]}`),
-        sql`, `
+      const lhs = sql2.join(
+        pkNames.map((n) => sql2`${aliased[n]}`),
+        sql2`, `
       );
-      const tuples = sql.join(
+      const tuples = sql2.join(
         keyableRows.map(
-          (row) => sql`(${sql.join(
-            pkNames.map((n) => sql`${row[n]}`),
-            sql`, `
+          (row) => sql2`(${sql2.join(
+            pkNames.map((n) => sql2`${row[n]}`),
+            sql2`, `
           )})`
         ),
-        sql`, `
+        sql2`, `
       );
-      return sql`(${lhs}) in (${tuples})`;
+      return sql2`(${lhs}) in (${tuples})`;
     };
   }
   let enriched;
@@ -2857,9 +3206,10 @@ import { is as is4, One as One3 } from "drizzle-orm";
 import { getTableConfig, MySqlTable } from "drizzle-orm/mysql-core";
 import {
   GraphQLBoolean as GraphQLBoolean3,
-  GraphQLError as GraphQLError5,
-  GraphQLList as GraphQLList4,
-  GraphQLNonNull as GraphQLNonNull4,
+  GraphQLError as GraphQLError6,
+  GraphQLInt as GraphQLInt5,
+  GraphQLList as GraphQLList5,
+  GraphQLNonNull as GraphQLNonNull5,
   GraphQLObjectType as GraphQLObjectType4
 } from "graphql";
 import { parseResolveInfo as parseResolveInfo2 } from "graphql-parse-resolve-info";
@@ -2872,7 +3222,7 @@ import {
   countDistinct,
   eq as eq2,
   extractExtendedColumnType as extractExtendedColumnType3,
-  getColumns as getColumns2,
+  getColumns as getColumns3,
   gt as gt2,
   gte as gte2,
   inArray as inArray2,
@@ -2884,12 +3234,12 @@ import {
   sum
 } from "drizzle-orm";
 import {
-  GraphQLError as GraphQLError4,
-  GraphQLFloat as GraphQLFloat3,
-  GraphQLInputObjectType as GraphQLInputObjectType3,
-  GraphQLInt as GraphQLInt3,
-  GraphQLList as GraphQLList3,
-  GraphQLNonNull as GraphQLNonNull3,
+  GraphQLError as GraphQLError5,
+  GraphQLFloat as GraphQLFloat4,
+  GraphQLInputObjectType as GraphQLInputObjectType4,
+  GraphQLInt as GraphQLInt4,
+  GraphQLList as GraphQLList4,
+  GraphQLNonNull as GraphQLNonNull4,
   GraphQLObjectType as GraphQLObjectType3
 } from "graphql";
 import { parseResolveInfo } from "graphql-parse-resolve-info";
@@ -2908,11 +3258,11 @@ var classifyAggregateColumns = (table, tableName) => {
   const numeric = {};
   const orderable = {};
   const all = {};
-  for (const [columnName, column] of Object.entries(getColumns2(table))) {
+  for (const [columnName, column] of Object.entries(getColumns3(table))) {
     all[columnName] = column;
     const converted = drizzleColumnToGraphQLType(column, columnName, tableName, true, false, false);
     const gqlType = converted.type;
-    if (gqlType instanceof GraphQLList3 || gqlType instanceof GraphQLObjectType3) {
+    if (gqlType instanceof GraphQLList4 || gqlType instanceof GraphQLObjectType3) {
       continue;
     }
     const { type: dataType, constraint } = extractExtendedColumnType3(column);
@@ -2936,14 +3286,14 @@ var generateAggregateTypes = (table, tableName, typeName, cacheCtx) => {
   }
   const { numeric, orderable, all } = classifyAggregateColumns(table, tableName);
   const fields = {
-    count: { type: new GraphQLNonNull3(GraphQLInt3) }
+    count: { type: new GraphQLNonNull4(GraphQLInt4) }
   };
   if (Object.keys(numeric).length) {
     for (const op of ["avg", "sum"]) {
       fields[op] = {
         type: new GraphQLObjectType3({
           name: `${typeName}${capitalize(op)}Aggregate`,
-          fields: Object.fromEntries(Object.keys(numeric).map((columnName) => [columnName, { type: GraphQLFloat3 }]))
+          fields: Object.fromEntries(Object.keys(numeric).map((columnName) => [columnName, { type: GraphQLFloat4 }]))
         })
       };
     }
@@ -2973,7 +3323,7 @@ var generateAggregateTypes = (table, tableName, typeName, cacheCtx) => {
       type: new GraphQLObjectType3({
         name: `${typeName}${capitalize(op)}Aggregate`,
         fields: Object.fromEntries(
-          columnNames.map((columnName) => [columnName, { type: new GraphQLNonNull3(GraphQLInt3) }])
+          columnNames.map((columnName) => [columnName, { type: new GraphQLNonNull4(GraphQLInt4) }])
         )
       })
     };
@@ -3001,7 +3351,7 @@ var aggregateTarget = (table, tableName, typeName) => {
   return {
     tableName,
     typeName,
-    columns: getColumns2(table),
+    columns: getColumns3(table),
     dateTimeColumns: new Set(
       Object.entries(orderable).filter(([, { converted }]) => converted.typeLabel === "DateTime").map(([columnName]) => columnName)
     )
@@ -3152,7 +3502,7 @@ var HAVING_OPS = { eq: eq2, ne: ne2, gt: gt2, gte: gte2, lt: lt2, lte: lte2 };
 var groupableColumns = (table, tableName) => {
   const { orderable } = classifyAggregateColumns(table, tableName);
   const groupable = { ...orderable };
-  for (const [columnName, column] of Object.entries(getColumns2(table))) {
+  for (const [columnName, column] of Object.entries(getColumns3(table))) {
     if (groupable[columnName]) {
       continue;
     }
@@ -3176,10 +3526,10 @@ var generateGroupByEnum = (table, tableName, typeName) => {
     (_column, columnName) => Boolean(groupable[columnName])
   );
 };
-var aggregateNumberFilter = new GraphQLInputObjectType3({
+var aggregateNumberFilter = new GraphQLInputObjectType4({
   name: "AggregateNumberFilter",
   description: "Compares an aggregated value. Several operators in one filter are ANDed together.",
-  fields: Object.fromEntries(Object.keys(HAVING_OPS).map((op) => [op, { type: GraphQLFloat3 }]))
+  fields: Object.fromEntries(Object.keys(HAVING_OPS).map((op) => [op, { type: GraphQLFloat4 }]))
 });
 var generateHavingInput = (table, tableName, typeName) => {
   const { numeric, orderable, all } = classifyAggregateColumns(table, tableName);
@@ -3200,13 +3550,13 @@ var generateHavingInput = (table, tableName, typeName) => {
       continue;
     }
     fields[op] = {
-      type: new GraphQLInputObjectType3({
+      type: new GraphQLInputObjectType4({
         name: `${typeName}${capitalize(op)}Having`,
         fields: Object.fromEntries(columnNames.map((columnName) => [columnName, { type: aggregateNumberFilter }]))
       })
     };
   }
-  return new GraphQLInputObjectType3({
+  return new GraphQLInputObjectType4({
     name: `${typeName}Having`,
     description: `Filters ${typeName} groups by their aggregated values`,
     fields
@@ -3236,7 +3586,7 @@ var generateGroupByType = (table, tableName, typeName, cacheCtx) => {
   );
   return new GraphQLObjectType3({
     name: `${typeName}GroupBy`,
-    fields: { group: { type: new GraphQLNonNull3(keysType) }, ...aggregateFields }
+    fields: { group: { type: new GraphQLNonNull4(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));
@@ -3269,11 +3619,11 @@ var buildHavingCondition = (having, columns) => {
 var generateGroupBy = (db, tableName, table, typeName, fieldName, filterArgs, groupByEnum, havingInput, filterCtx) => {
   const target = aggregateTarget(table, tableName, typeName);
   const groupable = groupableColumns(table, tableName);
-  const columns = getColumns2(table);
+  const columns = getColumns3(table);
   const rootTypeName = `${typeName}GroupBy`;
   const queryArgs = {
     groupBy: {
-      type: new GraphQLNonNull3(new GraphQLList3(new GraphQLNonNull3(groupByEnum))),
+      type: new GraphQLNonNull4(new GraphQLList4(new GraphQLNonNull4(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." },
@@ -3285,12 +3635,12 @@ var generateGroupBy = (db, tableName, table, typeName, fieldName, filterArgs, gr
       try {
         const requestedKeys = [...new Set(args.groupBy ?? [])];
         if (!requestedKeys.length) {
-          throw new GraphQLError4("At least one column to group by is required!");
+          throw new GraphQLError5("At least one column to group by is required!");
         }
         const keyColumns = requestedKeys.map((columnName) => {
           const groupableColumn = groupable[columnName];
           if (!groupableColumn) {
-            throw new GraphQLError4(`Cannot group ${typeName} by ${columnName}!`);
+            throw new GraphQLError5(`Cannot group ${typeName} by ${columnName}!`);
           }
           return [columnName, groupableColumn.column];
         });
@@ -3327,7 +3677,7 @@ var generateGroupBy = (db, tableName, table, typeName, fieldName, filterArgs, gr
 };
 
 // src/util/builders/mysql.ts
-var generateSelectArray = (db, tableName, tables, relationMap, orderArgs, filterArgs, fieldName, typeName, typeNameMapper, filterCtx, distinctEnabled = true) => {
+var generateSelectArray = (db, tableName, tables, relationMap, orderArgs, filterArgs, fieldName, typeName, typeNameMapper, filterCtx, distinctEnabled = true, limits) => {
   const queryBase = db.query[tableName];
   if (!queryBase) {
     throw new Error(
@@ -3335,6 +3685,7 @@ var generateSelectArray = (db, tableName, tables, relationMap, orderArgs, filter
     );
   }
   const table = tables[tableName];
+  const limitPolicy = limits?.(tableName);
   const pkNames = mysqlPrimaryKeyPropNames(table);
   const queryArgs = selectArrayArgs(
     orderArgs,
@@ -3357,8 +3708,10 @@ var generateSelectArray = (db, tableName, tables, relationMap, orderArgs, filter
           typeNameMapper,
           parsedInfo,
           ...args,
+          limit: applyLimitPolicy(args.limit, limitPolicy, fieldName),
           single: false,
           filterCtx,
+          limits,
           pkNames,
           db: executor,
           // MySQL sorts NULLs as the smallest values (first in ASC).
@@ -3371,7 +3724,7 @@ var generateSelectArray = (db, tableName, tables, relationMap, orderArgs, filter
     args: queryArgs
   };
 };
-var generateSelectSingle = (db, tableName, tables, relationMap, orderArgs, filterArgs, fieldName, typeName, typeNameMapper, filterCtx) => {
+var generateSelectSingle = (db, tableName, tables, relationMap, orderArgs, filterArgs, fieldName, typeName, typeNameMapper, filterCtx, limits) => {
   const queryBase = db.query[tableName];
   if (!queryBase) {
     throw new Error(
@@ -3399,6 +3752,7 @@ var generateSelectSingle = (db, tableName, tables, relationMap, orderArgs, filte
           ...args,
           single: true,
           filterCtx,
+          limits,
           pkNames,
           db: executor
         });
@@ -3412,7 +3766,7 @@ var generateSelectSingle = (db, tableName, tables, relationMap, orderArgs, filte
 var generateInsertArray = (db, _tableName, table, baseType, fieldName, txCtx) => {
   const queryArgs = {
     values: {
-      type: new GraphQLNonNull4(new GraphQLList4(new GraphQLNonNull4(baseType)))
+      type: new GraphQLNonNull5(new GraphQLList5(new GraphQLNonNull5(baseType)))
     }
   };
   return {
@@ -3422,7 +3776,7 @@ var generateInsertArray = (db, _tableName, table, baseType, fieldName, txCtx) =>
         return await runMutation(db, context, info, txCtx, async (executor) => {
           const input = remapFromGraphQLArrayInput(args.values, table);
           if (!input.length) {
-            throw new GraphQLError5("No values were provided!");
+            throw new GraphQLError6("No values were provided!");
           }
           await executor.insert(table).values(input);
           return { isSuccess: true };
@@ -3437,7 +3791,7 @@ var generateInsertArray = (db, _tableName, table, baseType, fieldName, txCtx) =>
 var generateInsertSingle = (db, _tableName, table, baseType, fieldName, txCtx) => {
   const queryArgs = {
     values: {
-      type: new GraphQLNonNull4(baseType)
+      type: new GraphQLNonNull5(baseType)
     }
   };
   return {
@@ -3459,7 +3813,7 @@ var generateInsertSingle = (db, _tableName, table, baseType, fieldName, txCtx) =
 var generateUpsert = (db, table, baseType, onConflictType, fieldName, single, txCtx) => {
   const queryArgs = {
     values: {
-      type: single ? new GraphQLNonNull4(baseType) : new GraphQLNonNull4(new GraphQLList4(new GraphQLNonNull4(baseType)))
+      type: single ? new GraphQLNonNull5(baseType) : new GraphQLNonNull5(new GraphQLList5(new GraphQLNonNull5(baseType)))
     },
     onConflict: {
       type: onConflictType,
@@ -3474,7 +3828,7 @@ var generateUpsert = (db, table, baseType, onConflictType, fieldName, single, tx
         return await runMutation(db, context, info, txCtx, async (executor) => {
           const input = single ? [remapFromGraphQLSingleInput(args.values, table)] : remapFromGraphQLArrayInput(args.values, table);
           if (!input.length) {
-            throw new GraphQLError5("No values were provided!");
+            throw new GraphQLError6("No values were provided!");
           }
           const plan = resolveConflictPlan({
             table,
@@ -3502,10 +3856,10 @@ var generateUpsert = (db, table, baseType, onConflictType, fieldName, single, tx
 var generateUpdate = (db, tableName, table, setArgs, filterArgs, fieldName, single, requireWhere, filterCtx, txCtx) => {
   const queryArgs = {
     set: {
-      type: new GraphQLNonNull4(setArgs)
+      type: new GraphQLNonNull5(setArgs)
     },
     where: {
-      type: single || requireWhere ? new GraphQLNonNull4(filterArgs) : filterArgs
+      type: single || requireWhere ? new GraphQLNonNull5(filterArgs) : filterArgs
     }
   };
   return {
@@ -3514,9 +3868,9 @@ var generateUpdate = (db, tableName, table, setArgs, filterArgs, fieldName, sing
       try {
         return await runMutation(db, context, info, txCtx, async (executor) => {
           const { where, set } = args;
-          const input = remapFromGraphQLSingleInput(set, table);
+          const input = remapUpdateInput(set, table, tableName);
           if (!Object.keys(input).length) {
-            throw new GraphQLError5("Unable to update with no values specified!");
+            throw new GraphQLError6("Unable to update with no values specified!");
           }
           const relationCtx = relationFilterCtx(filterCtx, tableName);
           const filters = single || requireWhere ? extractRequiredFilters(table, tableName, where, fieldName, relationCtx) : where ? extractFilters(table, tableName, where, relationCtx) : void 0;
@@ -3540,7 +3894,7 @@ var generateUpdate = (db, tableName, table, setArgs, filterArgs, fieldName, sing
 var generateUpdateMany = (db, tableName, table, updateManyInput, fieldName, filterCtx, txCtx) => {
   const queryArgs = {
     updates: {
-      type: new GraphQLNonNull4(new GraphQLList4(new GraphQLNonNull4(updateManyInput)))
+      type: new GraphQLNonNull5(new GraphQLList5(new GraphQLNonNull5(updateManyInput)))
     }
   };
   return {
@@ -3550,12 +3904,12 @@ var generateUpdateMany = (db, tableName, table, updateManyInput, fieldName, filt
         return await runMutation(db, context, info, txCtx, async (executor) => {
           const { updates } = args;
           if (!updates.length) {
-            throw new GraphQLError5("No updates were provided!");
+            throw new GraphQLError6("No updates were provided!");
           }
           const entries = updates.map(({ where, set }) => {
-            const input = remapFromGraphQLSingleInput(set, table);
+            const input = remapUpdateInput(set, table, tableName);
             if (!Object.keys(input).length) {
-              throw new GraphQLError5("Unable to update with no values specified!");
+              throw new GraphQLError6("Unable to update with no values specified!");
             }
             return {
               set: input,
@@ -3583,7 +3937,7 @@ var generateUpdateMany = (db, tableName, table, updateManyInput, fieldName, filt
 var generateDelete = (db, tableName, table, filterArgs, fieldName, single, requireWhere, filterCtx, txCtx) => {
   const queryArgs = {
     where: {
-      type: single || requireWhere ? new GraphQLNonNull4(filterArgs) : filterArgs
+      type: single || requireWhere ? new GraphQLNonNull5(filterArgs) : filterArgs
     }
   };
   return {
@@ -3613,7 +3967,7 @@ var generateDelete = (db, tableName, table, filterArgs, fieldName, single, requi
 };
 var mysqlPrimaryKeyPropNames = (table) => getPrimaryKeyPropNamesFromConfig(table, getTableConfig);
 var generateSchemaData = (db, schema, relations, options) => {
-  const { relationsDepthLimit, prefixes, suffixes, typeNameMapper, shouldEagerLoad, features, complexity } = options;
+  const { relationsDepthLimit, prefixes, suffixes, typeNameMapper, shouldEagerLoad, features, complexity, limits } = options;
   const rawSchema = schema;
   const schemaEntries = Object.entries(rawSchema);
   const tableEntries = schemaEntries.filter(([_key, value]) => is4(value, MySqlTable));
@@ -3634,7 +3988,13 @@ var generateSchemaData = (db, schema, relations, options) => {
   attachTargetPrimaryKeys(namedRelations, tables, mysqlPrimaryKeyPropNames);
   const eagerRelations = pruneNonEagerRelations(namedRelations, shouldEagerLoad);
   const filterCtx = { tables, relationMap: namedRelations };
-  const resolverFactory = createRelationResolverFactory(db, tables, filterCtx);
+  const resolverFactory = createRelationResolverFactory(
+    db,
+    tables,
+    "nulls-smallest",
+    filterCtx,
+    limits
+  );
   const cacheCtx = {
     genericFilterCache: /* @__PURE__ */ new Map(),
     objectTypeCache: /* @__PURE__ */ new Map(),
@@ -3648,7 +4008,9 @@ var generateSchemaData = (db, schema, relations, options) => {
     listRelationFilterCache: /* @__PURE__ */ new Map(),
     aggregateTypeCache: /* @__PURE__ */ new Map(),
     complexity,
-    docs: options.docs ?? {}
+    limits,
+    docs: options.docs ?? {},
+    features
   };
   const relationAggregateFactory = features.relationAggregates ? createRelationAggregateFactory(db, tables, cacheCtx, typeNameMapper, filterCtx) : void 0;
   const queries = {};
@@ -3676,7 +4038,7 @@ var generateSchemaData = (db, schema, relations, options) => {
     name: "MutationReturn",
     fields: {
       isSuccess: {
-        type: new GraphQLNonNull4(GraphQLBoolean3)
+        type: new GraphQLNonNull5(GraphQLBoolean3)
       }
     }
   });
@@ -3701,8 +4063,10 @@ var generateSchemaData = (db, schema, relations, options) => {
       updateFieldName,
       updateManyFieldName,
       updateSingleFieldName,
+      updateCountFieldName,
       deleteFieldName,
-      deleteSingleFieldName
+      deleteSingleFieldName,
+      deleteCountFieldName
     } = computeResolverFieldNames(tableName, typeNameMapper, prefixes, suffixes);
     const selectArrGenerated = generateSelectArray(
       db,
@@ -3715,7 +4079,8 @@ var generateSchemaData = (db, schema, relations, options) => {
       typeName,
       typeNameMapper,
       filterCtx,
-      features.distinct
+      features.distinct,
+      limits
     );
     const selectSingleGenerated = generateSelectSingle(
       db,
@@ -3727,7 +4092,8 @@ var generateSchemaData = (db, schema, relations, options) => {
       singleFieldName,
       typeName,
       typeNameMapper,
-      filterCtx
+      filterCtx,
+      limits
     );
     const insertArrGenerated = features.insert ? generateInsertArray(
       db,
@@ -3826,6 +4192,29 @@ var generateSchemaData = (db, schema, relations, options) => {
       filterCtx,
       mutationTxCtx
     ) : void 0;
+    const updateCountGenerated = features.update && features.countMutations ? generateWriteCount({
+      db,
+      tableName,
+      table: schema[tableName],
+      kind: "update",
+      setArgs: updateInput,
+      filterArgs: tableFilters,
+      fieldName: updateCountFieldName,
+      requireWhere: features.requireWhere,
+      filterCtx,
+      txCtx: mutationTxCtx
+    }) : void 0;
+    const deleteCountGenerated = features.delete && features.countMutations ? generateWriteCount({
+      db,
+      tableName,
+      table: schema[tableName],
+      kind: "delete",
+      filterArgs: tableFilters,
+      fieldName: deleteCountFieldName,
+      requireWhere: features.requireWhere,
+      filterCtx,
+      txCtx: mutationTxCtx
+    }) : void 0;
     const aggregateType = features.aggregates ? generateAggregateTypes(schema[tableName], tableName, typeName, cacheCtx) : void 0;
     const aggregateGenerated = features.aggregates ? generateAggregate(
       db,
@@ -3854,7 +4243,7 @@ var generateSchemaData = (db, schema, relations, options) => {
       type: selectArrOutput,
       args: selectArrGenerated.args,
       resolve: selectArrGenerated.resolver,
-      ...complexity ? { extensions: { complexity: listFieldComplexity(complexity) } } : {}
+      ...complexity ? { extensions: { complexity: listFieldComplexity(complexity, limits?.(tableName)) } } : {}
     };
     queries[selectSingleGenerated.name] = {
       type: selectSingleOutput,
@@ -3863,7 +4252,7 @@ var generateSchemaData = (db, schema, relations, options) => {
     };
     if (aggregateGenerated && aggregateType) {
       queries[aggregateGenerated.name] = {
-        type: new GraphQLNonNull4(aggregateType),
+        type: new GraphQLNonNull5(aggregateType),
         args: aggregateGenerated.args,
         resolve: aggregateGenerated.resolver,
         ...complexity ? { extensions: { complexity: aggregateFieldComplexity(complexity) } } : {}
@@ -3871,7 +4260,7 @@ var generateSchemaData = (db, schema, relations, options) => {
     }
     if (groupByGenerated && groupByType) {
       queries[groupByGenerated.name] = {
-        type: new GraphQLNonNull4(new GraphQLList4(new GraphQLNonNull4(groupByType))),
+        type: new GraphQLNonNull5(new GraphQLList5(new GraphQLNonNull5(groupByType))),
         args: groupByGenerated.args,
         resolve: groupByGenerated.resolver,
         ...complexity ? { extensions: { complexity: aggregateFieldComplexity(complexity) } } : {}
@@ -3896,6 +4285,22 @@ var generateSchemaData = (db, schema, relations, options) => {
         };
       }
     }
+    if (updateCountGenerated) {
+      mutations[updateCountGenerated.name] = {
+        type: new GraphQLNonNull5(GraphQLInt5),
+        args: updateCountGenerated.args,
+        resolve: updateCountGenerated.resolver,
+        description: "How many rows the update touched. The rows themselves are not read back, which is the point of this mutation."
+      };
+    }
+    if (deleteCountGenerated) {
+      mutations[deleteCountGenerated.name] = {
+        type: new GraphQLNonNull5(GraphQLInt5),
+        args: deleteCountGenerated.args,
+        resolve: deleteCountGenerated.resolver,
+        description: "How many rows the delete removed. The rows themselves are not read back, which is the point of this mutation."
+      };
+    }
     const activeInputs = [
       // The insert input types the upsert mutations too, so either feature keeps it.
       ...features.insert || onConflictInput ? [insertInput] : [],
@@ -3940,23 +4345,24 @@ var generateSchemaData = (db, schema, relations, options) => {
 };
 
 // src/util/builders/pg.ts
-import { and as and4, getColumns as getColumns4, is as is6, One as One5 } from "drizzle-orm";
+import { and as and4, getColumns as getColumns5, is as is6, One as One5 } from "drizzle-orm";
 import { getTableConfig as getTableConfig2, PgTable } from "drizzle-orm/pg-core";
 import {
-  GraphQLError as GraphQLError7,
-  GraphQLList as GraphQLList6,
-  GraphQLNonNull as GraphQLNonNull6
+  GraphQLError as GraphQLError8,
+  GraphQLInt as GraphQLInt6,
+  GraphQLList as GraphQLList7,
+  GraphQLNonNull as GraphQLNonNull7
 } from "graphql";
 import { parseResolveInfo as parseResolveInfo3 } from "graphql-parse-resolve-info";
 
 // src/util/builders/nested-writes.ts
-import { and as and3, eq as eq3, getColumns as getColumns3, is as is5, One as One4 } from "drizzle-orm";
+import { and as and3, eq as eq3, getColumns as getColumns4, is as is5, One as One4 } from "drizzle-orm";
 import {
   GraphQLBoolean as GraphQLBoolean4,
-  GraphQLError as GraphQLError6,
-  GraphQLInputObjectType as GraphQLInputObjectType4,
-  GraphQLList as GraphQLList5,
-  GraphQLNonNull as GraphQLNonNull5
+  GraphQLError as GraphQLError7,
+  GraphQLInputObjectType as GraphQLInputObjectType5,
+  GraphQLList as GraphQLList6,
+  GraphQLNonNull as GraphQLNonNull6
 } from "graphql";
 var isOptionalOnInsert = (column) => !column.notNull || !!column.hasDefault || !!column.defaultFn;
 var buildNestedWritePlans = (tables, relationMap, resolveUniqueSets, resolvePrimaryKeys, extractJoinColumns) => {
@@ -4001,7 +4407,7 @@ var buildNestedWritePlans = (tables, relationMap, resolveUniqueSets, resolvePrim
         continue;
       }
       const { localColPropName, foreignCol, foreignColPropName } = joinColumns;
-      const localCol = getColumns3(table)[localColPropName];
+      const localCol = getColumns4(table)[localColPropName];
       if (!localCol) {
         continue;
       }
@@ -4057,12 +4463,12 @@ var createNestedWriteTypes = (params) => {
     }
     const omitted = plan.fkSide === "child" ? plan.foreignColPropName : void 0;
     const fields = Object.fromEntries(
-      Object.entries(getColumns3(plan.targetTable)).filter(([columnName]) => columnName !== omitted).map(([columnName, column]) => [
+      Object.entries(getColumns4(plan.targetTable)).filter(([columnName]) => columnName !== omitted).map(([columnName, column]) => [
         columnName,
         drizzleColumnToGraphQLType(column, columnName, plan.targetTableName, false, true, true)
       ])
     );
-    const type = new GraphQLInputObjectType4({
+    const type = new GraphQLInputObjectType5({
       name: `${capitalize(insertPrefix)}${typeName}${capitalize(plan.relationName)}Input`,
       description: omitted === void 0 ? `A new ${resolveTypeName(plan.targetTableName, typeNameMapper)} row for ${typeName}.${plan.relationName}` : `A new ${resolveTypeName(plan.targetTableName, typeNameMapper)} row for ${typeName}.${plan.relationName}. \`${omitted}\` is set from the ${typeName} row this is written with.`,
       fields
@@ -4071,7 +4477,7 @@ var createNestedWriteTypes = (params) => {
     return type;
   };
   const targetFilters = (plan) => cacheCtx.filterTypeCache.get(plan.targetTable);
-  const listOf = (type) => new GraphQLList5(new GraphQLNonNull5(type));
+  const listOf = (type) => new GraphQLList6(new GraphQLNonNull6(type));
   const wrapperType = (tableName, typeName, plan, forUpdate) => {
     const key = `${tableName}.${plan.relationName}.${forUpdate ? "update" : "create"}`;
     const cached = wrapperCache.get(key);
@@ -4115,7 +4521,7 @@ var createNestedWriteTypes = (params) => {
         }
       }
     }
-    const type = new GraphQLInputObjectType4({
+    const type = new GraphQLInputObjectType5({
       name: `${typeName}${capitalize(plan.relationName)}Nested${forUpdate ? "Update" : "Create"}Input`,
       description: `Writes through ${typeName}.${plan.relationName}`,
       fields
@@ -4165,7 +4571,7 @@ var createNestedWriteRuntime = (params) => {
       relationFilterCtx(filterCtx, plan.targetTableName)
     );
     if (!condition) {
-      throw new GraphQLError6(
+      throw new GraphQLError7(
         `Drizzle-GraphQL Error: '${operation}' on '${plan.relationName}' needs a filter that selects rows \u2014 it was given one that matches everything.`
       );
     }
@@ -4174,7 +4580,7 @@ var createNestedWriteRuntime = (params) => {
   const assertSingleOperation = (plan, op) => {
     const supplied = ["create", "connect", "disconnect"].filter((key) => op[key] !== void 0 && op[key] !== null);
     if (supplied.length > 1) {
-      throw new GraphQLError6(
+      throw new GraphQLError7(
         `Drizzle-GraphQL Error: '${plan.relationName}' takes one of ${supplied.join(", ")} at a time \u2014 it holds a single row.`
       );
     }
@@ -4204,7 +4610,7 @@ var createNestedWriteRuntime = (params) => {
       if (!tablePlans) {
         return columns;
       }
-      const allColumns = getColumns3(table);
+      const allColumns = getColumns4(table);
       for (const relationName of Object.keys(ops)) {
         const plan = tablePlans[relationName];
         if (plan?.fkSide === "child" && !(plan.localColPropName in columns) && allColumns[plan.localColPropName]) {
@@ -4230,7 +4636,7 @@ var createNestedWriteRuntime = (params) => {
           const inserted = await executor.insert(plan.targetTable).values(values).returning();
           const created = inserted[0];
           if (!created) {
-            throw new GraphQLError6(
+            throw new GraphQLError7(
               `Drizzle-GraphQL Error: 'create' on '${relationName}' inserted no row, so there is nothing to attach.`
             );
           }
@@ -4238,7 +4644,7 @@ var createNestedWriteRuntime = (params) => {
         } else if (op["connect"] !== void 0) {
           const rows = await executor.select().from(plan.targetTable).where(conditionOf(plan, op["connect"], "connect"));
           if (rows.length !== 1) {
-            throw new GraphQLError6(
+            throw new GraphQLError7(
               `Drizzle-GraphQL Error: 'connect' on '${relationName}' matched ${rows.length} rows \u2014 it attaches a single row, so its filter must match exactly one.`
             );
           }
@@ -4265,7 +4671,7 @@ var createNestedWriteRuntime = (params) => {
         for (const parentRow of parentRows) {
           const key = parentRow?.[plan.localColPropName];
           if (key === void 0 || key === null) {
-            throw new GraphQLError6(
+            throw new GraphQLError7(
               `Drizzle-GraphQL Error: cannot write through '${relationName}': the ${tableName} row has no '${plan.localColPropName}' value to attach to.`
             );
           }
@@ -4333,9 +4739,10 @@ var updateWithNestedOps = async (params) => {
 };
 
 // src/util/builders/pg.ts
-var generateSelectArray2 = (db, tableName, tables, relationMap, orderArgs, filterArgs, fieldName, typeName, typeNameMapper, filterCtx, distinctEnabled = true) => {
+var generateSelectArray2 = (db, tableName, tables, relationMap, orderArgs, filterArgs, fieldName, typeName, typeNameMapper, filterCtx, distinctEnabled = true, limits) => {
   const queryBase = db.query[tableName];
   const table = tables[tableName];
+  const limitPolicy = limits?.(tableName);
   const pkNames = pgPrimaryKeyPropNames(table);
   const queryArgs = selectArrayArgs(
     orderArgs,
@@ -4348,6 +4755,7 @@ var generateSelectArray2 = (db, tableName, tables, relationMap, orderArgs, filte
       try {
         const parsedInfo = parseResolveInfo3(info, { deep: true });
         const { executor, queryBase: requestQueryBase } = resolveQueryExecutor(db, context, tableName, queryBase);
+        const limit = applyLimitPolicy(args.limit, limitPolicy, fieldName);
         if (requestQueryBase) {
           return await runRelationalSelect({
             queryBase: requestQueryBase,
@@ -4359,15 +4767,17 @@ var generateSelectArray2 = (db, tableName, tables, relationMap, orderArgs, filte
             typeNameMapper,
             parsedInfo,
             ...args,
+            limit,
             single: false,
             filterCtx,
+            limits,
             pkNames,
             db: executor,
             // PostgreSQL sorts NULLs as the largest values (last in ASC).
             nullOrdering: "nulls-largest"
           });
         }
-        const { offset, limit, orderBy, where, distinct, after } = args;
+        const { offset, orderBy, where, distinct, after } = args;
         const selectedColumnsSql = extractSelectedColumnsFromTreeSQLFormat(
           parsedInfo.fieldsByTypeName[typeName],
           table,
@@ -4377,24 +4787,24 @@ var generateSelectArray2 = (db, tableName, tables, relationMap, orderArgs, filte
         let cursorEntries;
         if (after != null || cursorSelected) {
           if (after != null && distinct?.length) {
-            throw new GraphQLError7("'after' cannot be combined with 'distinct'.");
+            throw new GraphQLError8("'after' cannot be combined with 'distinct'.");
           }
           if (orderByHasRelationEntry(orderBy)) {
             if (after != null) {
-              throw new GraphQLError7(
+              throw new GraphQLError8(
                 "'after' cannot be combined with an orderBy that orders through a relation \u2014 a related row's value cannot be encoded into a cursor."
               );
             }
           } else if (!pkNames.length) {
             if (after != null) {
-              throw new GraphQLError7(
+              throw new GraphQLError8(
                 `Table ${tableName} has no primary key, so cursor pagination cannot be used on it.`
               );
             }
           } else {
             cursorEntries = cursorOrderingEntries(orderBy, pkNames);
             if (cursorSelected) {
-              const allColumns = getColumns4(table);
+              const allColumns = getColumns5(table);
               for (const [column] of cursorEntries) {
                 selectedColumnsSql[column] ??= allColumns[column];
               }
@@ -4457,7 +4867,7 @@ var generateSelectArray2 = (db, tableName, tables, relationMap, orderArgs, filte
     args: queryArgs
   };
 };
-var generateSelectSingle2 = (db, tableName, tables, relationMap, orderArgs, filterArgs, fieldName, typeName, typeNameMapper, filterCtx) => {
+var generateSelectSingle2 = (db, tableName, tables, relationMap, orderArgs, filterArgs, fieldName, typeName, typeNameMapper, filterCtx, limits) => {
   const queryBase = db.query[tableName];
   const queryArgs = selectSingleArgs(orderArgs, filterArgs);
   const table = tables[tableName];
@@ -4481,6 +4891,7 @@ var generateSelectSingle2 = (db, tableName, tables, relationMap, orderArgs, filt
             ...args,
             single: true,
             filterCtx,
+            limits,
             pkNames,
             db: executor
           });
@@ -4514,10 +4925,10 @@ var generateSelectSingle2 = (db, tableName, tables, relationMap, orderArgs, filt
   };
 };
 var pgPrimaryKeyPropNames = (table) => getPrimaryKeyPropNamesFromConfig(table, getTableConfig2);
-var generateInsertArray2 = (db, tableName, table, tables, relationMap, baseType, fieldName, typeName, typeNameMapper, conflictDoNothing = false, txCtx, nested) => {
+var generateInsertArray2 = (db, tableName, table, tables, relationMap, baseType, fieldName, typeName, typeNameMapper, conflictDoNothing = false, txCtx, nested, limits) => {
   const queryArgs = {
     values: {
-      type: new GraphQLNonNull6(new GraphQLList6(new GraphQLNonNull6(baseType)))
+      type: new GraphQLNonNull7(new GraphQLList7(new GraphQLNonNull7(baseType)))
     }
   };
   const pkNames = pgPrimaryKeyPropNames(table);
@@ -4527,7 +4938,7 @@ var generateInsertArray2 = (db, tableName, table, tables, relationMap, baseType,
       try {
         return await runMutation(db, context, info, txCtx, async (executor) => {
           if (!args.values.length) {
-            throw new GraphQLError7("No values were provided!");
+            throw new GraphQLError8("No values were provided!");
           }
           const entries = nested?.enabled(tableName) ? args.values.map((values) => nested.split(tableName, values)) : void 0;
           const nestedEntries = entries?.some((entry) => nested.hasOps(entry.ops)) ? entries : void 0;
@@ -4543,7 +4954,8 @@ var generateInsertArray2 = (db, tableName, table, tables, relationMap, baseType,
             typeNameMapper,
             table,
             pkNames,
-            parsedInfo
+            parsedInfo,
+            limits
           });
           const returning = nestedEntries ? nested.withJoinColumns(tableName, mergedOps(nestedEntries), { ...columns }, table) : columns;
           const runInsert = async (target, values) => {
@@ -4571,10 +4983,10 @@ var generateInsertArray2 = (db, tableName, table, tables, relationMap, baseType,
     args: queryArgs
   };
 };
-var generateInsertSingle2 = (db, tableName, table, tables, relationMap, baseType, fieldName, typeName, typeNameMapper, conflictDoNothing = false, txCtx, nested) => {
+var generateInsertSingle2 = (db, tableName, table, tables, relationMap, baseType, fieldName, typeName, typeNameMapper, conflictDoNothing = false, txCtx, nested, limits) => {
   const queryArgs = {
     values: {
-      type: new GraphQLNonNull6(baseType)
+      type: new GraphQLNonNull7(baseType)
     }
   };
   const pkNames = pgPrimaryKeyPropNames(table);
@@ -4597,7 +5009,8 @@ var generateInsertSingle2 = (db, tableName, table, tables, relationMap, baseType
             typeNameMapper,
             table,
             pkNames,
-            parsedInfo
+            parsedInfo,
+            limits
           });
           const returning = nestedEntry ? nested.withJoinColumns(tableName, nestedEntry.ops, { ...columns }, table) : columns;
           const runInsert = async (target, values) => {
@@ -4616,6 +5029,9 @@ var generateInsertSingle2 = (db, tableName, table, tables, relationMap, baseType
             write: runInsert
           }) : await runInsert(executor, input);
           if (!result[0]) {
+            if (!conflictDoNothing) {
+              throw new GraphQLError8(`${fieldName}: the insert returned no row.`);
+            }
             return void 0;
           }
           const enriched = hasRelations ? await eagerLoadMutationRelations(executor, tableName, result, pkNames, withParams) : result;
@@ -4628,10 +5044,10 @@ var generateInsertSingle2 = (db, tableName, table, tables, relationMap, baseType
     args: queryArgs
   };
 };
-var generateUpsert2 = (db, tableName, table, tables, relationMap, baseType, onConflictType, uniqueSets, fieldName, typeName, single, typeNameMapper, filterCtx, txCtx, nested) => {
+var generateUpsert2 = (db, tableName, table, tables, relationMap, baseType, onConflictType, uniqueSets, fieldName, typeName, single, typeNameMapper, filterCtx, txCtx, nested, limits) => {
   const queryArgs = {
     values: {
-      type: single ? new GraphQLNonNull6(baseType) : new GraphQLNonNull6(new GraphQLList6(new GraphQLNonNull6(baseType)))
+      type: single ? new GraphQLNonNull7(baseType) : new GraphQLNonNull7(new GraphQLList7(new GraphQLNonNull7(baseType)))
     },
     onConflict: {
       type: onConflictType,
@@ -4646,7 +5062,7 @@ var generateUpsert2 = (db, tableName, table, tables, relationMap, baseType, onCo
         return await runMutation(db, context, info, txCtx, async (executor) => {
           const supplied = single ? [args.values] : args.values;
           if (!supplied.length) {
-            throw new GraphQLError7("No values were provided!");
+            throw new GraphQLError8("No values were provided!");
           }
           const entries = nested?.enabled(tableName) ? supplied.map((values) => nested.split(tableName, values)) : void 0;
           const nestedEntries = entries?.some((entry) => nested.hasOps(entry.ops)) ? entries : void 0;
@@ -4660,7 +5076,8 @@ var generateUpsert2 = (db, tableName, table, tables, relationMap, baseType, onCo
             typeNameMapper,
             table,
             pkNames,
-            parsedInfo
+            parsedInfo,
+            limits
           });
           const returning = nestedEntries ? nested.withJoinColumns(tableName, mergedOps(nestedEntries), { ...columns }, table) : columns;
           const runUpsert = async (target, values) => {
@@ -4699,13 +5116,13 @@ var generateUpsert2 = (db, tableName, table, tables, relationMap, baseType, onCo
     args: queryArgs
   };
 };
-var generateUpdate2 = (db, tableName, table, tables, relationMap, setArgs, filterArgs, fieldName, typeName, single, requireWhere, typeNameMapper, filterCtx, txCtx, nested) => {
+var generateUpdate2 = (db, tableName, table, tables, relationMap, setArgs, filterArgs, fieldName, typeName, single, requireWhere, typeNameMapper, filterCtx, txCtx, nested, limits) => {
   const queryArgs = {
     set: {
-      type: new GraphQLNonNull6(setArgs)
+      type: new GraphQLNonNull7(setArgs)
     },
     where: {
-      type: single || requireWhere ? new GraphQLNonNull6(filterArgs) : filterArgs
+      type: single || requireWhere ? new GraphQLNonNull7(filterArgs) : filterArgs
     }
   };
   const pkNames = pgPrimaryKeyPropNames(table);
@@ -4726,13 +5143,14 @@ var generateUpdate2 = (db, tableName, table, tables, relationMap, setArgs, filte
             typeNameMapper,
             table,
             pkNames,
-            parsedInfo
+            parsedInfo,
+            limits
           });
           const entry = nested?.enabled(tableName) ? nested.split(tableName, set) : void 0;
           const nestedOps = entry && nested.hasOps(entry.ops) ? entry.ops : void 0;
-          const input = remapFromGraphQLSingleInput(entry ? entry.columns : set, table);
+          const input = remapUpdateInput(entry ? entry.columns : set, table, tableName);
           if (!Object.keys(input).length && !nestedOps) {
-            throw new GraphQLError7("Unable to update with no values specified!");
+            throw new GraphQLError8("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;
@@ -4758,7 +5176,7 @@ var generateUpdate2 = (db, tableName, table, tables, relationMap, setArgs, filte
             write: runUpdate
           }) : await runUpdate(executor, input);
           if (single && result.length > 1) {
-            throw new GraphQLError7(`${fieldName}: 'where' matched more than one row!`);
+            throw new GraphQLError8(`${fieldName}: 'where' matched more than one row!`);
           }
           if (single && !result[0]) {
             return void 0;
@@ -4773,10 +5191,10 @@ var generateUpdate2 = (db, tableName, table, tables, relationMap, setArgs, filte
     args: queryArgs
   };
 };
-var generateUpdateMany2 = (db, tableName, table, tables, relationMap, updateManyInput, fieldName, typeName, typeNameMapper, filterCtx, txCtx, nested) => {
+var generateUpdateMany2 = (db, tableName, table, tables, relationMap, updateManyInput, fieldName, typeName, typeNameMapper, filterCtx, txCtx, nested, limits) => {
   const queryArgs = {
     updates: {
-      type: new GraphQLNonNull6(new GraphQLList6(new GraphQLNonNull6(updateManyInput)))
+      type: new GraphQLNonNull7(new GraphQLList7(new GraphQLNonNull7(updateManyInput)))
     }
   };
   const pkNames = pgPrimaryKeyPropNames(table);
@@ -4787,7 +5205,7 @@ var generateUpdateMany2 = (db, tableName, table, tables, relationMap, updateMany
         return await runMutation(db, context, info, txCtx, async (executor) => {
           const { updates } = args;
           if (!updates.length) {
-            throw new GraphQLError7("No updates were provided!");
+            throw new GraphQLError8("No updates were provided!");
           }
           const parsedInfo = parseResolveInfo3(info, {
             deep: true
@@ -4800,14 +5218,15 @@ var generateUpdateMany2 = (db, tableName, table, tables, relationMap, updateMany
             typeNameMapper,
             table,
             pkNames,
-            parsedInfo
+            parsedInfo,
+            limits
           });
           const entries = updates.map(({ where, set }) => {
             const split = nested?.enabled(tableName) ? nested.split(tableName, set) : void 0;
             const ops = split && nested.hasOps(split.ops) ? split.ops : void 0;
-            const input = remapFromGraphQLSingleInput(split ? split.columns : set, table);
+            const input = remapUpdateInput(split ? split.columns : set, table, tableName);
             if (!Object.keys(input).length && !ops) {
-              throw new GraphQLError7("Unable to update with no values specified!");
+              throw new GraphQLError8("Unable to update with no values specified!");
             }
             return {
               set: input,
@@ -4866,7 +5285,7 @@ var generateUpdateMany2 = (db, tableName, table, tables, relationMap, updateMany
 var generateDelete2 = (db, tableName, table, filterArgs, fieldName, typeName, single, requireWhere, filterCtx, selectionCtx, txCtx) => {
   const queryArgs = {
     where: {
-      type: single || requireWhere ? new GraphQLNonNull6(filterArgs) : filterArgs
+      type: single || requireWhere ? new GraphQLNonNull7(filterArgs) : filterArgs
     }
   };
   return {
@@ -4895,7 +5314,7 @@ var generateDelete2 = (db, tableName, table, filterArgs, fieldName, typeName, si
           query = query.returning(columns);
           const result = await query;
           if (single && result.length > 1) {
-            throw new GraphQLError7(`${fieldName}: 'where' matched more than one row!`);
+            throw new GraphQLError8(`${fieldName}: 'where' matched more than one row!`);
           }
           if (single) {
             return result[0] ? remapToGraphQLSingleOutput(result[0], tableName, table) : void 0;
@@ -4918,7 +5337,8 @@ function generateSchemaData2(db, schema, relations, options) {
     typeNameMapper,
     shouldEagerLoad,
     features,
-    complexity
+    complexity,
+    limits
   } = options;
   const schemaEntries = Object.entries(schema);
   const tableEntries = schemaEntries.filter(([_key, value]) => is6(value, PgTable));
@@ -4934,7 +5354,13 @@ function generateSchemaData2(db, schema, relations, options) {
   attachTargetPrimaryKeys(namedRelations, tables, pgPrimaryKeyPropNames);
   const eagerRelations = pruneNonEagerRelations(namedRelations, shouldEagerLoad);
   const filterCtx = { tables, relationMap: namedRelations };
-  const resolverFactory = createRelationResolverFactory(db, tables, filterCtx);
+  const resolverFactory = createRelationResolverFactory(
+    db,
+    tables,
+    "nulls-largest",
+    filterCtx,
+    limits
+  );
   const cacheCtx = {
     genericFilterCache: /* @__PURE__ */ new Map(),
     objectTypeCache: /* @__PURE__ */ new Map(),
@@ -4948,7 +5374,9 @@ function generateSchemaData2(db, schema, relations, options) {
     listRelationFilterCache: /* @__PURE__ */ new Map(),
     aggregateTypeCache: /* @__PURE__ */ new Map(),
     complexity,
-    docs: options.docs ?? {}
+    limits,
+    docs: options.docs ?? {},
+    features
   };
   const nestedPlans = features.nestedWrites ? buildNestedWritePlans(
     tables,
@@ -5000,8 +5428,10 @@ function generateSchemaData2(db, schema, relations, options) {
       updateFieldName,
       updateManyFieldName,
       updateSingleFieldName,
+      updateCountFieldName,
       deleteFieldName,
-      deleteSingleFieldName
+      deleteSingleFieldName,
+      deleteCountFieldName
     } = computeResolverFieldNames(tableName, typeNameMapper, prefixes, suffixes);
     const selectArrGenerated = generateSelectArray2(
       db,
@@ -5014,7 +5444,8 @@ function generateSchemaData2(db, schema, relations, options) {
       typeName,
       typeNameMapper,
       filterCtx,
-      features.distinct
+      features.distinct,
+      limits
     );
     const selectSingleGenerated = generateSelectSingle2(
       db,
@@ -5026,7 +5457,8 @@ function generateSchemaData2(db, schema, relations, options) {
       singleFieldName,
       typeName,
       typeNameMapper,
-      filterCtx
+      filterCtx,
+      limits
     );
     const insertArrGenerated = features.insert ? generateInsertArray2(
       db,
@@ -5040,7 +5472,8 @@ function generateSchemaData2(db, schema, relations, options) {
       typeNameMapper,
       conflictDoNothing,
       mutationTxCtx,
-      nestedRuntime
+      nestedRuntime,
+      limits
     ) : void 0;
     const insertSingleGenerated = features.insert ? generateInsertSingle2(
       db,
@@ -5054,7 +5487,8 @@ function generateSchemaData2(db, schema, relations, options) {
       typeNameMapper,
       conflictDoNothing,
       mutationTxCtx,
-      nestedRuntime
+      nestedRuntime,
+      limits
     ) : void 0;
     const uniqueSets = features.upsert ? getUniqueColumnSets(schema[tableName], getTableConfig2) : [];
     const onConflictInput = features.upsert ? generateOnConflictInput({
@@ -5079,7 +5513,8 @@ function generateSchemaData2(db, schema, relations, options) {
       typeNameMapper,
       filterCtx,
       mutationTxCtx,
-      nestedRuntime
+      nestedRuntime,
+      limits
     ) : void 0;
     const upsertSingleGenerated = onConflictInput ? generateUpsert2(
       db,
@@ -5096,7 +5531,8 @@ function generateSchemaData2(db, schema, relations, options) {
       typeNameMapper,
       filterCtx,
       mutationTxCtx,
-      nestedRuntime
+      nestedRuntime,
+      limits
     ) : void 0;
     const updateGenerated = features.update ? generateUpdate2(
       db,
@@ -5113,7 +5549,8 @@ function generateSchemaData2(db, schema, relations, options) {
       typeNameMapper,
       filterCtx,
       mutationTxCtx,
-      nestedRuntime
+      nestedRuntime,
+      limits
     ) : void 0;
     const updateSingleGenerated = features.update ? generateUpdate2(
       db,
@@ -5130,7 +5567,8 @@ function generateSchemaData2(db, schema, relations, options) {
       typeNameMapper,
       filterCtx,
       mutationTxCtx,
-      nestedRuntime
+      nestedRuntime,
+      limits
     ) : void 0;
     const updateManyInput = features.update && features.updateMany ? generateUpdateManyInput({ typeName, updatePrefix: prefixes.update, updateInput, tableFilters }) : void 0;
     const updateManyGenerated = updateManyInput ? generateUpdateMany2(
@@ -5145,7 +5583,8 @@ function generateSchemaData2(db, schema, relations, options) {
       typeNameMapper,
       filterCtx,
       mutationTxCtx,
-      nestedRuntime
+      nestedRuntime,
+      limits
     ) : void 0;
     const deleteGenerated = features.delete ? generateDelete2(
       db,
@@ -5173,6 +5612,30 @@ function generateSchemaData2(db, schema, relations, options) {
       { tableName, relationMap: namedRelations, tables },
       mutationTxCtx
     ) : void 0;
+    const updateCountGenerated = features.update && features.countMutations ? generateWriteCount({
+      db,
+      tableName,
+      table: schema[tableName],
+      kind: "update",
+      setArgs: updateInput,
+      filterArgs: tableFilters,
+      fieldName: updateCountFieldName,
+      requireWhere: features.requireWhere,
+      filterCtx,
+      txCtx: mutationTxCtx,
+      nested: nestedRuntime
+    }) : void 0;
+    const deleteCountGenerated = features.delete && features.countMutations ? generateWriteCount({
+      db,
+      tableName,
+      table: schema[tableName],
+      kind: "delete",
+      filterArgs: tableFilters,
+      fieldName: deleteCountFieldName,
+      requireWhere: features.requireWhere,
+      filterCtx,
+      txCtx: mutationTxCtx
+    }) : void 0;
     const aggregateType = features.aggregates ? generateAggregateTypes(schema[tableName], tableName, typeName, cacheCtx) : void 0;
     const aggregateGenerated = features.aggregates ? generateAggregate(
       db,
@@ -5201,7 +5664,7 @@ function generateSchemaData2(db, schema, relations, options) {
       type: selectArrOutput,
       args: selectArrGenerated.args,
       resolve: selectArrGenerated.resolver,
-      ...complexity ? { extensions: { complexity: listFieldComplexity(complexity) } } : {}
+      ...complexity ? { extensions: { complexity: listFieldComplexity(complexity, limits?.(tableName)) } } : {}
     };
     queries[selectSingleGenerated.name] = {
       type: selectSingleOutput,
@@ -5210,7 +5673,7 @@ function generateSchemaData2(db, schema, relations, options) {
     };
     if (aggregateGenerated && aggregateType) {
       queries[aggregateGenerated.name] = {
-        type: new GraphQLNonNull6(aggregateType),
+        type: new GraphQLNonNull7(aggregateType),
         args: aggregateGenerated.args,
         resolve: aggregateGenerated.resolver,
         ...complexity ? { extensions: { complexity: aggregateFieldComplexity(complexity) } } : {}
@@ -5218,7 +5681,7 @@ function generateSchemaData2(db, schema, relations, options) {
     }
     if (groupByGenerated && groupByType) {
       queries[groupByGenerated.name] = {
-        type: new GraphQLNonNull6(new GraphQLList6(new GraphQLNonNull6(groupByType))),
+        type: new GraphQLNonNull7(new GraphQLList7(new GraphQLNonNull7(groupByType))),
         args: groupByGenerated.args,
         resolve: groupByGenerated.resolver,
         ...complexity ? { extensions: { complexity: aggregateFieldComplexity(complexity) } } : {}
@@ -5233,7 +5696,9 @@ function generateSchemaData2(db, schema, relations, options) {
     }
     if (insertSingleGenerated) {
       mutations[insertSingleGenerated.name] = {
-        type: singleTableItemOutput,
+        // An insert either returns the row it inserted or throws — the one path to `null` is
+        // `conflictDoNothing` swallowing the insert, so the field is nullable only there.
+        type: conflictDoNothing ? singleTableItemOutput : new GraphQLNonNull7(singleTableItemOutput),
         args: insertSingleGenerated.args,
         resolve: insertSingleGenerated.resolver
       };
@@ -5261,10 +5726,13 @@ function generateSchemaData2(db, schema, relations, options) {
     }
     if (updateManyGenerated) {
       mutations[updateManyGenerated.name] = {
-        // Nullable items: a no-match entry yields `null` in its slot.
-        type: new GraphQLNonNull6(new GraphQLList6(singleTableItemOutput)),
+        type: new GraphQLNonNull7(new GraphQLList7(singleTableItemOutput)),
         args: updateManyGenerated.args,
-        resolve: updateManyGenerated.resolver
+        resolve: updateManyGenerated.resolver,
+        // The nullable element is deliberate, and the reason this mutation's return type
+        // differs from every sibling's: the result is aligned with the input, one slot per
+        // entry, so an entry that matched nothing has to be able to say so.
+        description: "Each entry's updated rows, in entry order. An entry whose `where` matched no rows contributes `null` in its slot; an entry that matched several contributes each of its rows."
       };
     }
     if (updateSingleGenerated) {
@@ -5288,6 +5756,22 @@ function generateSchemaData2(db, schema, relations, options) {
         resolve: deleteSingleGenerated.resolver
       };
     }
+    if (updateCountGenerated) {
+      mutations[updateCountGenerated.name] = {
+        type: new GraphQLNonNull7(GraphQLInt6),
+        args: updateCountGenerated.args,
+        resolve: updateCountGenerated.resolver,
+        description: "How many rows the update touched. The rows themselves are not read back, which is the point of this mutation."
+      };
+    }
+    if (deleteCountGenerated) {
+      mutations[deleteCountGenerated.name] = {
+        type: new GraphQLNonNull7(GraphQLInt6),
+        args: deleteCountGenerated.args,
+        resolve: deleteCountGenerated.resolver,
+        description: "How many rows the delete removed. The rows themselves are not read back, which is the point of this mutation."
+      };
+    }
     const activeInputs = [
       // The insert input types the upsert mutations too, so either feature keeps it.
       ...features.insert || onConflictInput ? [insertInput] : [],
@@ -5336,12 +5820,13 @@ function generateSchemaData2(db, schema, relations, options) {
 import { is as is7, One as One6 } from "drizzle-orm";
 import { getTableConfig as getTableConfig3, SQLiteTable } from "drizzle-orm/sqlite-core";
 import {
-  GraphQLError as GraphQLError8,
-  GraphQLList as GraphQLList7,
-  GraphQLNonNull as GraphQLNonNull7
+  GraphQLError as GraphQLError9,
+  GraphQLInt as GraphQLInt7,
+  GraphQLList as GraphQLList8,
+  GraphQLNonNull as GraphQLNonNull8
 } from "graphql";
 import { parseResolveInfo as parseResolveInfo4 } from "graphql-parse-resolve-info";
-var generateSelectArray3 = (db, tableName, tables, relationMap, orderArgs, filterArgs, fieldName, typeName, typeNameMapper, filterCtx, distinctEnabled = true) => {
+var generateSelectArray3 = (db, tableName, tables, relationMap, orderArgs, filterArgs, fieldName, typeName, typeNameMapper, filterCtx, distinctEnabled = true, limits) => {
   const queryBase = db.query[tableName];
   if (!queryBase) {
     throw new Error(
@@ -5349,6 +5834,7 @@ var generateSelectArray3 = (db, tableName, tables, relationMap, orderArgs, filte
     );
   }
   const table = tables[tableName];
+  const limitPolicy = limits?.(tableName);
   const pkNames = sqlitePrimaryKeyPropNames(table);
   const queryArgs = selectArrayArgs(
     orderArgs,
@@ -5371,8 +5857,10 @@ var generateSelectArray3 = (db, tableName, tables, relationMap, orderArgs, filte
           typeNameMapper,
           parsedInfo,
           ...args,
+          limit: applyLimitPolicy(args.limit, limitPolicy, fieldName),
           single: false,
           filterCtx,
+          limits,
           pkNames,
           db: executor,
           // SQLite sorts NULLs as the smallest values (first in ASC).
@@ -5385,7 +5873,7 @@ var generateSelectArray3 = (db, tableName, tables, relationMap, orderArgs, filte
     args: queryArgs
   };
 };
-var generateSelectSingle3 = (db, tableName, tables, relationMap, orderArgs, filterArgs, fieldName, typeName, typeNameMapper, filterCtx) => {
+var generateSelectSingle3 = (db, tableName, tables, relationMap, orderArgs, filterArgs, fieldName, typeName, typeNameMapper, filterCtx, limits) => {
   const queryBase = db.query[tableName];
   if (!queryBase) {
     throw new Error(
@@ -5413,6 +5901,7 @@ var generateSelectSingle3 = (db, tableName, tables, relationMap, orderArgs, filt
           ...args,
           single: true,
           filterCtx,
+          limits,
           pkNames,
           db: executor
         });
@@ -5424,10 +5913,10 @@ var generateSelectSingle3 = (db, tableName, tables, relationMap, orderArgs, filt
   };
 };
 var sqlitePrimaryKeyPropNames = (table) => getPrimaryKeyPropNamesFromConfig(table, getTableConfig3);
-var generateInsertArray3 = (db, tableName, table, tables, relationMap, baseType, fieldName, typeName, typeNameMapper, conflictDoNothing = false, txCtx, nested) => {
+var generateInsertArray3 = (db, tableName, table, tables, relationMap, baseType, fieldName, typeName, typeNameMapper, conflictDoNothing = false, txCtx, nested, limits) => {
   const queryArgs = {
     values: {
-      type: new GraphQLNonNull7(new GraphQLList7(new GraphQLNonNull7(baseType)))
+      type: new GraphQLNonNull8(new GraphQLList8(new GraphQLNonNull8(baseType)))
     }
   };
   const pkNames = sqlitePrimaryKeyPropNames(table);
@@ -5437,7 +5926,7 @@ var generateInsertArray3 = (db, tableName, table, tables, relationMap, baseType,
       try {
         return await runMutation(db, context, info, txCtx, async (executor) => {
           if (!args.values.length) {
-            throw new GraphQLError8("No values were provided!");
+            throw new GraphQLError9("No values were provided!");
           }
           const entries = nested?.enabled(tableName) ? args.values.map((values) => nested.split(tableName, values)) : void 0;
           const nestedEntries = entries?.some((entry) => nested.hasOps(entry.ops)) ? entries : void 0;
@@ -5453,7 +5942,8 @@ var generateInsertArray3 = (db, tableName, table, tables, relationMap, baseType,
             typeNameMapper,
             table,
             pkNames,
-            parsedInfo
+            parsedInfo,
+            limits
           });
           const returning = nestedEntries ? nested.withJoinColumns(tableName, mergedOps(nestedEntries), { ...columns }, table) : columns;
           const runInsert = async (target, values) => {
@@ -5481,10 +5971,10 @@ var generateInsertArray3 = (db, tableName, table, tables, relationMap, baseType,
     args: queryArgs
   };
 };
-var generateInsertSingle3 = (db, tableName, table, tables, relationMap, baseType, fieldName, typeName, typeNameMapper, conflictDoNothing = false, txCtx, nested) => {
+var generateInsertSingle3 = (db, tableName, table, tables, relationMap, baseType, fieldName, typeName, typeNameMapper, conflictDoNothing = false, txCtx, nested, limits) => {
   const queryArgs = {
     values: {
-      type: new GraphQLNonNull7(baseType)
+      type: new GraphQLNonNull8(baseType)
     }
   };
   const pkNames = sqlitePrimaryKeyPropNames(table);
@@ -5507,7 +5997,8 @@ var generateInsertSingle3 = (db, tableName, table, tables, relationMap, baseType
             typeNameMapper,
             table,
             pkNames,
-            parsedInfo
+            parsedInfo,
+            limits
           });
           const returning = nestedEntry ? nested.withJoinColumns(tableName, nestedEntry.ops, { ...columns }, table) : columns;
           const runInsert = async (target, values) => {
@@ -5526,6 +6017,9 @@ var generateInsertSingle3 = (db, tableName, table, tables, relationMap, baseType
             write: runInsert
           }) : await runInsert(executor, input);
           if (!result[0]) {
+            if (!conflictDoNothing) {
+              throw new GraphQLError9(`${fieldName}: the insert returned no row.`);
+            }
             return void 0;
           }
           const enriched = hasRelations ? await eagerLoadMutationRelations(executor, tableName, result, pkNames, withParams) : result;
@@ -5538,10 +6032,10 @@ var generateInsertSingle3 = (db, tableName, table, tables, relationMap, baseType
     args: queryArgs
   };
 };
-var generateUpsert3 = (db, tableName, table, tables, relationMap, baseType, onConflictType, uniqueSets, fieldName, typeName, single, typeNameMapper, filterCtx, txCtx, nested) => {
+var generateUpsert3 = (db, tableName, table, tables, relationMap, baseType, onConflictType, uniqueSets, fieldName, typeName, single, typeNameMapper, filterCtx, txCtx, nested, limits) => {
   const queryArgs = {
     values: {
-      type: single ? new GraphQLNonNull7(baseType) : new GraphQLNonNull7(new GraphQLList7(new GraphQLNonNull7(baseType)))
+      type: single ? new GraphQLNonNull8(baseType) : new GraphQLNonNull8(new GraphQLList8(new GraphQLNonNull8(baseType)))
     },
     onConflict: {
       type: onConflictType,
@@ -5556,7 +6050,7 @@ var generateUpsert3 = (db, tableName, table, tables, relationMap, baseType, onCo
         return await runMutation(db, context, info, txCtx, async (executor) => {
           const supplied = single ? [args.values] : args.values;
           if (!supplied.length) {
-            throw new GraphQLError8("No values were provided!");
+            throw new GraphQLError9("No values were provided!");
           }
           const entries = nested?.enabled(tableName) ? supplied.map((values) => nested.split(tableName, values)) : void 0;
           const nestedEntries = entries?.some((entry) => nested.hasOps(entry.ops)) ? entries : void 0;
@@ -5570,7 +6064,8 @@ var generateUpsert3 = (db, tableName, table, tables, relationMap, baseType, onCo
             typeNameMapper,
             table,
             pkNames,
-            parsedInfo
+            parsedInfo,
+            limits
           });
           const returning = nestedEntries ? nested.withJoinColumns(tableName, mergedOps(nestedEntries), { ...columns }, table) : columns;
           const runUpsert = async (target, values) => {
@@ -5609,13 +6104,13 @@ var generateUpsert3 = (db, tableName, table, tables, relationMap, baseType, onCo
     args: queryArgs
   };
 };
-var generateUpdate3 = (db, tableName, table, tables, relationMap, setArgs, filterArgs, fieldName, typeName, single, requireWhere, typeNameMapper, filterCtx, txCtx, nested) => {
+var generateUpdate3 = (db, tableName, table, tables, relationMap, setArgs, filterArgs, fieldName, typeName, single, requireWhere, typeNameMapper, filterCtx, txCtx, nested, limits) => {
   const queryArgs = {
     set: {
-      type: new GraphQLNonNull7(setArgs)
+      type: new GraphQLNonNull8(setArgs)
     },
     where: {
-      type: single || requireWhere ? new GraphQLNonNull7(filterArgs) : filterArgs
+      type: single || requireWhere ? new GraphQLNonNull8(filterArgs) : filterArgs
     }
   };
   const pkNames = sqlitePrimaryKeyPropNames(table);
@@ -5636,13 +6131,14 @@ var generateUpdate3 = (db, tableName, table, tables, relationMap, setArgs, filte
             typeNameMapper,
             table,
             pkNames,
-            parsedInfo
+            parsedInfo,
+            limits
           });
           const entry = nested?.enabled(tableName) ? nested.split(tableName, set) : void 0;
           const nestedOps = entry && nested.hasOps(entry.ops) ? entry.ops : void 0;
-          const input = remapFromGraphQLSingleInput(entry ? entry.columns : set, table);
+          const input = remapUpdateInput(entry ? entry.columns : set, table, tableName);
           if (!Object.keys(input).length && !nestedOps) {
-            throw new GraphQLError8("Unable to update with no values specified!");
+            throw new GraphQLError9("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;
@@ -5668,7 +6164,7 @@ var generateUpdate3 = (db, tableName, table, tables, relationMap, setArgs, filte
             write: runUpdate
           }) : await runUpdate(executor, input);
           if (single && result.length > 1) {
-            throw new GraphQLError8(`${fieldName}: 'where' matched more than one row!`);
+            throw new GraphQLError9(`${fieldName}: 'where' matched more than one row!`);
           }
           if (single && !result[0]) {
             return void 0;
@@ -5683,10 +6179,10 @@ var generateUpdate3 = (db, tableName, table, tables, relationMap, setArgs, filte
     args: queryArgs
   };
 };
-var generateUpdateMany3 = (db, tableName, table, tables, relationMap, updateManyInput, fieldName, typeName, typeNameMapper, filterCtx, txCtx, nested) => {
+var generateUpdateMany3 = (db, tableName, table, tables, relationMap, updateManyInput, fieldName, typeName, typeNameMapper, filterCtx, txCtx, nested, limits) => {
   const queryArgs = {
     updates: {
-      type: new GraphQLNonNull7(new GraphQLList7(new GraphQLNonNull7(updateManyInput)))
+      type: new GraphQLNonNull8(new GraphQLList8(new GraphQLNonNull8(updateManyInput)))
     }
   };
   const pkNames = sqlitePrimaryKeyPropNames(table);
@@ -5697,7 +6193,7 @@ var generateUpdateMany3 = (db, tableName, table, tables, relationMap, updateMany
         return await runMutation(db, context, info, txCtx, async (executor) => {
           const { updates } = args;
           if (!updates.length) {
-            throw new GraphQLError8("No updates were provided!");
+            throw new GraphQLError9("No updates were provided!");
           }
           const parsedInfo = parseResolveInfo4(info, {
             deep: true
@@ -5710,14 +6206,15 @@ var generateUpdateMany3 = (db, tableName, table, tables, relationMap, updateMany
             typeNameMapper,
             table,
             pkNames,
-            parsedInfo
+            parsedInfo,
+            limits
           });
           const entries = updates.map(({ where, set }) => {
             const split = nested?.enabled(tableName) ? nested.split(tableName, set) : void 0;
             const ops = split && nested.hasOps(split.ops) ? split.ops : void 0;
-            const input = remapFromGraphQLSingleInput(split ? split.columns : set, table);
+            const input = remapUpdateInput(split ? split.columns : set, table, tableName);
             if (!Object.keys(input).length && !ops) {
-              throw new GraphQLError8("Unable to update with no values specified!");
+              throw new GraphQLError9("Unable to update with no values specified!");
             }
             return {
               set: input,
@@ -5804,7 +6301,7 @@ var generateUpdateMany3 = (db, tableName, table, tables, relationMap, updateMany
 var generateDelete3 = (db, tableName, table, filterArgs, fieldName, typeName, single, requireWhere, filterCtx, selectionCtx, txCtx) => {
   const queryArgs = {
     where: {
-      type: single || requireWhere ? new GraphQLNonNull7(filterArgs) : filterArgs
+      type: single || requireWhere ? new GraphQLNonNull8(filterArgs) : filterArgs
     }
   };
   return {
@@ -5833,7 +6330,7 @@ var generateDelete3 = (db, tableName, table, filterArgs, fieldName, typeName, si
           query = query.returning(columns);
           const result = await query;
           if (single && result.length > 1) {
-            throw new GraphQLError8(`${fieldName}: 'where' matched more than one row!`);
+            throw new GraphQLError9(`${fieldName}: 'where' matched more than one row!`);
           }
           if (single) {
             return result[0] ? remapToGraphQLSingleOutput(result[0], tableName, table) : void 0;
@@ -5856,7 +6353,8 @@ var generateSchemaData3 = (db, schema, relations, options) => {
     typeNameMapper,
     shouldEagerLoad,
     features,
-    complexity
+    complexity,
+    limits
   } = options;
   const rawSchema = schema;
   const schemaEntries = Object.entries(rawSchema);
@@ -5873,7 +6371,13 @@ var generateSchemaData3 = (db, schema, relations, options) => {
   attachTargetPrimaryKeys(namedRelations, tables, sqlitePrimaryKeyPropNames);
   const eagerRelations = pruneNonEagerRelations(namedRelations, shouldEagerLoad);
   const filterCtx = { tables, relationMap: namedRelations };
-  const resolverFactory = createRelationResolverFactory(db, tables, filterCtx);
+  const resolverFactory = createRelationResolverFactory(
+    db,
+    tables,
+    "nulls-smallest",
+    filterCtx,
+    limits
+  );
   const cacheCtx = {
     genericFilterCache: /* @__PURE__ */ new Map(),
     objectTypeCache: /* @__PURE__ */ new Map(),
@@ -5887,7 +6391,9 @@ var generateSchemaData3 = (db, schema, relations, options) => {
     listRelationFilterCache: /* @__PURE__ */ new Map(),
     aggregateTypeCache: /* @__PURE__ */ new Map(),
     complexity,
-    docs: options.docs ?? {}
+    limits,
+    docs: options.docs ?? {},
+    features
   };
   if (features.nestedWrites && db.resultKind === "sync") {
     throw new Error(
@@ -5949,8 +6455,10 @@ var generateSchemaData3 = (db, schema, relations, options) => {
       updateFieldName,
       updateManyFieldName,
       updateSingleFieldName,
+      updateCountFieldName,
       deleteFieldName,
-      deleteSingleFieldName
+      deleteSingleFieldName,
+      deleteCountFieldName
     } = computeResolverFieldNames(tableName, typeNameMapper, prefixes, suffixes);
     const selectArrGenerated = generateSelectArray3(
       db,
@@ -5963,7 +6471,8 @@ var generateSchemaData3 = (db, schema, relations, options) => {
       typeName,
       typeNameMapper,
       filterCtx,
-      features.distinct
+      features.distinct,
+      limits
     );
     const selectSingleGenerated = generateSelectSingle3(
       db,
@@ -5975,7 +6484,8 @@ var generateSchemaData3 = (db, schema, relations, options) => {
       singleFieldName,
       typeName,
       typeNameMapper,
-      filterCtx
+      filterCtx,
+      limits
     );
     const insertArrGenerated = features.insert ? generateInsertArray3(
       db,
@@ -5989,7 +6499,8 @@ var generateSchemaData3 = (db, schema, relations, options) => {
       typeNameMapper,
       conflictDoNothing,
       mutationTxCtx,
-      nestedRuntime
+      nestedRuntime,
+      limits
     ) : void 0;
     const insertSingleGenerated = features.insert ? generateInsertSingle3(
       db,
@@ -6003,7 +6514,8 @@ var generateSchemaData3 = (db, schema, relations, options) => {
       typeNameMapper,
       conflictDoNothing,
       mutationTxCtx,
-      nestedRuntime
+      nestedRuntime,
+      limits
     ) : void 0;
     const uniqueSets = features.upsert ? getUniqueColumnSets(schema[tableName], getTableConfig3) : [];
     const onConflictInput = features.upsert ? generateOnConflictInput({
@@ -6028,7 +6540,8 @@ var generateSchemaData3 = (db, schema, relations, options) => {
       typeNameMapper,
       filterCtx,
       mutationTxCtx,
-      nestedRuntime
+      nestedRuntime,
+      limits
     ) : void 0;
     const upsertSingleGenerated = onConflictInput ? generateUpsert3(
       db,
@@ -6045,7 +6558,8 @@ var generateSchemaData3 = (db, schema, relations, options) => {
       typeNameMapper,
       filterCtx,
       mutationTxCtx,
-      nestedRuntime
+      nestedRuntime,
+      limits
     ) : void 0;
     const updateGenerated = features.update ? generateUpdate3(
       db,
@@ -6062,7 +6576,8 @@ var generateSchemaData3 = (db, schema, relations, options) => {
       typeNameMapper,
       filterCtx,
       mutationTxCtx,
-      nestedRuntime
+      nestedRuntime,
+      limits
     ) : void 0;
     const updateSingleGenerated = features.update ? generateUpdate3(
       db,
@@ -6079,7 +6594,8 @@ var generateSchemaData3 = (db, schema, relations, options) => {
       typeNameMapper,
       filterCtx,
       mutationTxCtx,
-      nestedRuntime
+      nestedRuntime,
+      limits
     ) : void 0;
     const updateManyInput = features.update && features.updateMany ? generateUpdateManyInput({ typeName, updatePrefix: prefixes.update, updateInput, tableFilters }) : void 0;
     const updateManyGenerated = updateManyInput ? generateUpdateMany3(
@@ -6094,7 +6610,8 @@ var generateSchemaData3 = (db, schema, relations, options) => {
       typeNameMapper,
       filterCtx,
       mutationTxCtx,
-      nestedRuntime
+      nestedRuntime,
+      limits
     ) : void 0;
     const deleteGenerated = features.delete ? generateDelete3(
       db,
@@ -6122,6 +6639,30 @@ var generateSchemaData3 = (db, schema, relations, options) => {
       { tableName, relationMap: namedRelations, tables },
       mutationTxCtx
     ) : void 0;
+    const updateCountGenerated = features.update && features.countMutations ? generateWriteCount({
+      db,
+      tableName,
+      table: schema[tableName],
+      kind: "update",
+      setArgs: updateInput,
+      filterArgs: tableFilters,
+      fieldName: updateCountFieldName,
+      requireWhere: features.requireWhere,
+      filterCtx,
+      txCtx: mutationTxCtx,
+      nested: nestedRuntime
+    }) : void 0;
+    const deleteCountGenerated = features.delete && features.countMutations ? generateWriteCount({
+      db,
+      tableName,
+      table: schema[tableName],
+      kind: "delete",
+      filterArgs: tableFilters,
+      fieldName: deleteCountFieldName,
+      requireWhere: features.requireWhere,
+      filterCtx,
+      txCtx: mutationTxCtx
+    }) : void 0;
     const aggregateType = features.aggregates ? generateAggregateTypes(schema[tableName], tableName, typeName, cacheCtx) : void 0;
     const aggregateGenerated = features.aggregates ? generateAggregate(
       db,
@@ -6150,7 +6691,7 @@ var generateSchemaData3 = (db, schema, relations, options) => {
       type: selectArrOutput,
       args: selectArrGenerated.args,
       resolve: selectArrGenerated.resolver,
-      ...complexity ? { extensions: { complexity: listFieldComplexity(complexity) } } : {}
+      ...complexity ? { extensions: { complexity: listFieldComplexity(complexity, limits?.(tableName)) } } : {}
     };
     queries[selectSingleGenerated.name] = {
       type: selectSingleOutput,
@@ -6159,7 +6700,7 @@ var generateSchemaData3 = (db, schema, relations, options) => {
     };
     if (aggregateGenerated && aggregateType) {
       queries[aggregateGenerated.name] = {
-        type: new GraphQLNonNull7(aggregateType),
+        type: new GraphQLNonNull8(aggregateType),
         args: aggregateGenerated.args,
         resolve: aggregateGenerated.resolver,
         ...complexity ? { extensions: { complexity: aggregateFieldComplexity(complexity) } } : {}
@@ -6167,7 +6708,7 @@ var generateSchemaData3 = (db, schema, relations, options) => {
     }
     if (groupByGenerated && groupByType) {
       queries[groupByGenerated.name] = {
-        type: new GraphQLNonNull7(new GraphQLList7(new GraphQLNonNull7(groupByType))),
+        type: new GraphQLNonNull8(new GraphQLList8(new GraphQLNonNull8(groupByType))),
         args: groupByGenerated.args,
         resolve: groupByGenerated.resolver,
         ...complexity ? { extensions: { complexity: aggregateFieldComplexity(complexity) } } : {}
@@ -6182,7 +6723,9 @@ var generateSchemaData3 = (db, schema, relations, options) => {
     }
     if (insertSingleGenerated) {
       mutations[insertSingleGenerated.name] = {
-        type: singleTableItemOutput,
+        // An insert either returns the row it inserted or throws — the one path to `null` is
+        // `conflictDoNothing` swallowing the insert, so the field is nullable only there.
+        type: conflictDoNothing ? singleTableItemOutput : new GraphQLNonNull8(singleTableItemOutput),
         args: insertSingleGenerated.args,
         resolve: insertSingleGenerated.resolver
       };
@@ -6210,10 +6753,13 @@ var generateSchemaData3 = (db, schema, relations, options) => {
     }
     if (updateManyGenerated) {
       mutations[updateManyGenerated.name] = {
-        // Nullable items: a no-match entry yields `null` in its slot.
-        type: new GraphQLNonNull7(new GraphQLList7(singleTableItemOutput)),
+        type: new GraphQLNonNull8(new GraphQLList8(singleTableItemOutput)),
         args: updateManyGenerated.args,
-        resolve: updateManyGenerated.resolver
+        resolve: updateManyGenerated.resolver,
+        // The nullable element is deliberate, and the reason this mutation's return type
+        // differs from every sibling's: the result is aligned with the input, one slot per
+        // entry, so an entry that matched nothing has to be able to say so.
+        description: "Each entry's updated rows, in entry order. An entry whose `where` matched no rows contributes `null` in its slot; an entry that matched several contributes each of its rows."
       };
     }
     if (updateSingleGenerated) {
@@ -6237,6 +6783,22 @@ var generateSchemaData3 = (db, schema, relations, options) => {
         resolve: deleteSingleGenerated.resolver
       };
     }
+    if (updateCountGenerated) {
+      mutations[updateCountGenerated.name] = {
+        type: new GraphQLNonNull8(GraphQLInt7),
+        args: updateCountGenerated.args,
+        resolve: updateCountGenerated.resolver,
+        description: "How many rows the update touched. The rows themselves are not read back, which is the point of this mutation."
+      };
+    }
+    if (deleteCountGenerated) {
+      mutations[deleteCountGenerated.name] = {
+        type: new GraphQLNonNull8(GraphQLInt7),
+        args: deleteCountGenerated.args,
+        resolve: deleteCountGenerated.resolver,
+        description: "How many rows the delete removed. The rows themselves are not read back, which is the point of this mutation."
+      };
+    }
     const activeInputs = [
       // The insert input types the upsert mutations too, so either feature keeps it.
       ...features.insert || onConflictInput ? [insertInput] : [],
@@ -6314,6 +6876,8 @@ var buildSchema = (db, config) => {
     delete: config?.features?.delete ?? true,
     upsert: config?.features?.upsert ?? false,
     nestedWrites: config?.features?.nestedWrites ?? false,
+    fieldUpdateOperations: config?.features?.fieldUpdateOperations ?? false,
+    countMutations: config?.features?.countMutations ?? false,
     requireWhere: config?.features?.requireWhere ?? false
   };
   const complexityConfig = config?.complexity ?? true;
@@ -6323,6 +6887,33 @@ var buildSchema = (db, config) => {
   };
   const transactionsOpt = config?.transactions;
   const transactions = transactionsOpt === void 0 || transactionsOpt === "none" ? void 0 : { timeoutMs: (transactionsOpt === "auto" ? void 0 : transactionsOpt.timeoutMs) ?? 3e4 };
+  const limitsConfig = config?.limits;
+  if (limitsConfig) {
+    const check = (policy, where) => {
+      for (const key of ["defaultLimit", "maxLimit"]) {
+        const value = policy[key];
+        if (value === void 0) {
+          continue;
+        }
+        if (!Number.isInteger(value) || value < 1) {
+          throw new Error(`Drizzle-GraphQL Error: config.limits${where}.${key} must be a positive integer.`);
+        }
+      }
+    };
+    check(limitsConfig, "");
+    for (const [tableName, policy] of Object.entries(limitsConfig.tables ?? {})) {
+      check(policy, `.tables.${tableName}`);
+    }
+  }
+  const limitPolicyCache = /* @__PURE__ */ new Map();
+  const limits = limitsConfig ? (tableName) => {
+    if (limitPolicyCache.has(tableName)) {
+      return limitPolicyCache.get(tableName);
+    }
+    const resolved = resolveLimitPolicy(limitsConfig, limitsConfig.tables?.[tableName]);
+    limitPolicyCache.set(tableName, resolved);
+    return resolved;
+  } : void 0;
   const eagerOpt = config?.eagerLoadRelations;
   const shouldEagerLoad = eagerOpt === void 0 || eagerOpt === true ? () => true : eagerOpt === false ? () => false : eagerOpt;
   if (!typeNameMapper && suffixes.list === suffixes.single) {
@@ -6355,6 +6946,7 @@ var buildSchema = (db, config) => {
     mapColumnType: config?.mapColumnType,
     enumNameMapper: config?.enumNameMapper,
     transactions,
+    limits,
     docs: {
       describeColumn: config?.describeColumn,
       describeTable: config?.describeTable,