@vantreeseba/drizzle-graphql 5.2.0 → 5.4.0

package/dist/index.cjs

@@ -1013,6 +1013,13 @@ var generateTableSelectTypeFieldsCached = (table, tableName) => {
       drizzleColumnToGraphQLType(columnDescription, columnName, tableName)
     ])
   );
+  if (!remapped[CURSOR_FIELD_NAME]) {
+    remapped[CURSOR_FIELD_NAME] = {
+      type: import_graphql4.GraphQLString,
+      description: "Opaque cursor of this row's position in the query's ordering. Pass it as `after` to resume from here. Only set on rows returned by a list query.",
+      resolve: rowCursorResolver
+    };
+  }
   fieldMap.set(table, remapped);
   return remapped;
 };
@@ -1840,6 +1847,117 @@ var primaryKeyOrderExprs = (table, pkNames) => {
   const cols = (0, import_drizzle_orm3.getColumns)(table);
   return pkNames.map((n) => cols[n]).filter(Boolean).map((col) => (0, import_drizzle_orm3.asc)(col));
 };
+var CURSOR_FIELD_NAME = "cursor";
+var ROW_CURSOR_PROP = "__drizzle_graphql_cursor";
+var orderByHasRelationEntry = (orderBy) => !!orderBy && Object.values(orderBy).some((config) => config && typeof config === "object" && config.direction === void 0);
+var cursorOrderingEntries = (orderBy, pkNames) => {
+  const entries = orderBy ? orderByEntries(orderBy) : [];
+  const seen = new Set(entries.map(([column]) => column));
+  for (const pk of pkNames) {
+    if (!seen.has(pk)) {
+      entries.push([pk, "asc"]);
+    }
+  }
+  return entries;
+};
+var cursorOrderExprs = (table, entries) => {
+  const cols = (0, import_drizzle_orm3.getColumns)(table);
+  return entries.flatMap(
+    ([column, direction, nulls]) => orderExpressions(cols[column], direction, nulls ?? void 0, cols[column])
+  );
+};
+var encodeCursorValue = (value) => {
+  if (value instanceof Date) {
+    return { $type: "date", value: value.toISOString() };
+  }
+  if (typeof value === "bigint") {
+    return { $type: "bigint", value: value.toString() };
+  }
+  return value;
+};
+var decodeCursorValue = (value) => {
+  if (value && typeof value === "object" && typeof value.$type === "string") {
+    if (value.$type === "date") {
+      return new Date(value.value);
+    }
+    if (value.$type === "bigint") {
+      return BigInt(value.value);
+    }
+  }
+  return value;
+};
+var encodeCursor = (entries, row) => {
+  const payload = {
+    o: entries,
+    v: entries.map(([column]) => encodeCursorValue(row[column] ?? null))
+  };
+  return Buffer.from(JSON.stringify(payload), "utf8").toString("base64url");
+};
+var decodeCursor = (after, entries) => {
+  let payload;
+  try {
+    payload = JSON.parse(Buffer.from(after, "base64url").toString("utf8"));
+  } catch (_e) {
+    throw new import_graphql4.GraphQLError("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 import_graphql4.GraphQLError("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.
+    // JSON round-trips undefined as null — compare the normalized forms.
+    (entry[2] ?? null) === (entries[i][2] ?? null)
+  );
+  if (!matchesOrdering) {
+    throw new import_graphql4.GraphQLError(
+      "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 = (0, import_drizzle_orm3.getColumns)(table);
+  const disjuncts = [];
+  const equalities = [];
+  entries.forEach(([column, direction, nulls], i) => {
+    const col = cols[column];
+    if (!col) {
+      throw new import_graphql4.GraphQLError(`Invalid cursor: unknown column '${column}'.`);
+    }
+    const value = values[i];
+    const nullsSortLast = nulls != null ? nulls === "last" : direction === "asc" === (nullOrdering === "nulls-largest");
+    let strictlyAfter;
+    if (value === null || value === void 0) {
+      strictlyAfter = nullsSortLast ? void 0 : (0, import_drizzle_orm3.isNotNull)(col);
+    } else {
+      const comparison = direction === "asc" ? (0, import_drizzle_orm3.gt)(col, value) : (0, import_drizzle_orm3.lt)(col, value);
+      strictlyAfter = nullsSortLast ? (0, import_drizzle_orm3.or)(comparison, (0, import_drizzle_orm3.isNull)(col)) : comparison;
+    }
+    if (strictlyAfter) {
+      disjuncts.push(equalities.length ? (0, import_drizzle_orm3.and)(...equalities, strictlyAfter) : strictlyAfter);
+    }
+    equalities.push(value === null || value === void 0 ? (0, import_drizzle_orm3.isNull)(col) : (0, import_drizzle_orm3.eq)(col, value));
+  });
+  if (!disjuncts.length) {
+    return import_drizzle_orm3.sql`1 = 0`;
+  }
+  return disjuncts.length > 1 ? (0, import_drizzle_orm3.or)(...disjuncts) : disjuncts[0];
+};
+var isCursorFieldSelected = (tree, table) => {
+  if (!tree) {
+    return false;
+  }
+  if ((0, import_drizzle_orm3.getColumns)(table)[CURSOR_FIELD_NAME]) {
+    return false;
+  }
+  return Object.values(tree).some((field) => field.name === CURSOR_FIELD_NAME);
+};
+var attachRowCursors = (rows, entries) => {
+  for (const row of rows) {
+    row[ROW_CURSOR_PROP] = encodeCursor(entries, row);
+  }
+};
+var rowCursorResolver = (source) => source?.[ROW_CURSOR_PROP] ?? null;
 var getUniqueColumnSets = (table, getTableConfig4) => {
   const cols = (0, import_drizzle_orm3.getColumns)(table);
   const propNameByColumnName = new Map(Object.entries(cols).map(([propName, col]) => [col.name, propName]));
@@ -2126,6 +2244,7 @@ var computeResolverFieldNames = (tableName, typeNameMapper, prefixes, suffixes)
   const upsertArrayFieldName = `${upsertPrefix}${mapped ? capitalize(mapped.plural) : capitalize(tableName)}`;
   const upsertSingleFieldName = mapped ? `${upsertPrefix}${capitalize(mapped.singular)}` : `${upsertPrefix}${capitalize(tableName)}${suffixes.single}`;
   const updateFieldName = `${prefixes.update}${mapped ? capitalize(mapped.singular) : capitalize(tableName)}`;
+  const updateManyFieldName = `${prefixes.update}${mapped ? capitalize(mapped.plural) : capitalize(tableName)}Many`;
   const deleteFieldName = `${prefixes.delete}${mapped ? capitalize(mapped.singular) : capitalize(tableName)}`;
   const writeSingleSuffix = suffixes.single === "" ? "Single" : suffixes.single;
   const updateSingleFieldName = `${updateFieldName}${writeSingleSuffix}`;
@@ -2141,11 +2260,28 @@ var computeResolverFieldNames = (tableName, typeNameMapper, prefixes, suffixes)
     upsertArrayFieldName,
     upsertSingleFieldName,
     updateFieldName,
+    updateManyFieldName,
     updateSingleFieldName,
     deleteFieldName,
     deleteSingleFieldName
   };
 };
+var generateUpdateManyInput = (params) => {
+  const { typeName, updatePrefix, updateInput, tableFilters } = params;
+  return new import_graphql4.GraphQLInputObjectType({
+    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: {
+      where: {
+        type: tableFilters,
+        description: "Rows this entry updates. An omitted filter updates every row."
+      },
+      set: {
+        type: new import_graphql4.GraphQLNonNull(updateInput)
+      }
+    }
+  });
+};
 var extractRequiredFilters = (table, tableName, where, fieldName, relationCtx) => {
   const filters = where ? extractFilters(table, tableName, where, relationCtx) : void 0;
   if (!filters) {
@@ -2164,6 +2300,10 @@ var selectArrayArgs = (orderArgs, filterArgs, distinctEnum) => ({
   limit: { type: import_graphql4.GraphQLInt },
   orderBy: { type: orderArgs },
   where: { type: filterArgs },
+  after: {
+    type: import_graphql4.GraphQLString,
+    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 import_graphql4.GraphQLList(new import_graphql4.GraphQLNonNull(distinctEnum)) } } : {}
 });
 var selectSingleArgs = (orderArgs, filterArgs) => ({
@@ -2186,9 +2326,31 @@ var runRelationalSelect = async (opts) => {
     where,
     single,
     filterCtx,
-    pkNames
+    pkNames,
+    after
   } = opts;
   const distinct = opts.distinct?.length ? opts.distinct : void 0;
+  const cursorSelected = !single && isCursorFieldSelected(parsedInfo.fieldsByTypeName[typeName], table);
+  let cursorEntries;
+  if (!single && (after != null || cursorSelected)) {
+    if (after != null && distinct) {
+      throw new import_graphql4.GraphQLError("'after' cannot be combined with 'distinct'.");
+    }
+    if (orderByHasRelationEntry(orderBy)) {
+      if (after != null) {
+        throw new import_graphql4.GraphQLError(
+          "'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 import_graphql4.GraphQLError(`Table ${tableName} has no primary key, so cursor pagination cannot be used on it.`);
+      }
+    } else {
+      cursorEntries = cursorOrderingEntries(orderBy, pkNames);
+    }
+  }
+  const cursorValues = after != null && cursorEntries ? decodeCursor(after, cursorEntries) : void 0;
   const needsDefaultOrder = single || offset != null || opts.limit != null;
   let distinctKeys;
   if (distinct) {
@@ -2219,9 +2381,21 @@ var runRelationalSelect = async (opts) => {
     orderBy: distinctKeys ? (aliasedTable2) => [
       ...orderBy ? extractOrderBy(aliasedTable2, orderBy, relationFilterCtx(filterCtx, tableName)) : [],
       ...primaryKeyOrderExprs(aliasedTable2, pkNames)
-    ] : orderBy ? (aliasedTable2) => extractOrderBy(aliasedTable2, orderBy, relationFilterCtx(filterCtx, tableName)) : needsDefaultOrder && pkNames?.length ? (aliasedTable2) => primaryKeyOrderExprs(aliasedTable2, pkNames) : void 0,
-    where: distinctKeys ? { RAW: (aliasedTable2) => primaryKeyRestriction(aliasedTable2, pkNames, distinctKeys) } : where ? {
-      RAW: (aliasedTable2) => extractFilters(aliasedTable2, tableName, where, relationFilterCtx(filterCtx, tableName))
+    ] : cursorEntries ? (
+      // Cursor pagination needs a total order: the request's orderBy plus the PK tiebreak,
+      // exactly the ordering the cursor encodes and the keyset predicate compares against.
+      (aliasedTable2) => cursorOrderExprs(aliasedTable2, cursorEntries)
+    ) : orderBy ? (aliasedTable2) => extractOrderBy(aliasedTable2, orderBy, relationFilterCtx(filterCtx, tableName)) : needsDefaultOrder && pkNames?.length ? (aliasedTable2) => primaryKeyOrderExprs(aliasedTable2, pkNames) : void 0,
+    where: distinctKeys ? { RAW: (aliasedTable2) => primaryKeyRestriction(aliasedTable2, pkNames, distinctKeys) } : where || cursorValues ? {
+      RAW: (aliasedTable2) => (0, import_drizzle_orm3.and)(
+        where ? extractFilters(aliasedTable2, tableName, where, relationFilterCtx(filterCtx, tableName)) : void 0,
+        cursorValues ? buildCursorCondition(
+          aliasedTable2,
+          cursorEntries,
+          cursorValues,
+          opts.nullOrdering ?? "nulls-smallest"
+        ) : void 0
+      )
     } : void 0,
     with: relationMap[tableName] ? extractRelationsParams(relationMap, tables, tableName, parsedInfo, typeName, typeNameMapper, filterCtx) : void 0
   };
@@ -2229,8 +2403,16 @@ var runRelationalSelect = async (opts) => {
     const result2 = await queryBase.findFirst(params);
     return result2 ? remapToGraphQLSingleOutput(result2, tableName, table, relationMap) : void 0;
   }
+  if (cursorEntries && cursorSelected) {
+    for (const [column] of cursorEntries) {
+      params.columns[column] = true;
+    }
+  }
   params.limit = distinctKeys ? void 0 : opts.limit;
   const result = await queryBase.findMany(params);
+  if (cursorEntries && cursorSelected) {
+    attachRowCursors(result, cursorEntries);
+  }
   return remapToGraphQLArrayOutput(result, tableName, table, relationMap);
 };
 var eagerLoadMutationRelations = async (db, tableName, rows, pkNames, withParams) => {
@@ -2778,7 +2960,9 @@ var generateSelectArray = (db, tableName, tables, relationMap, orderArgs, filter
           single: false,
           filterCtx,
           pkNames,
-          db: executor
+          db: executor,
+          // MySQL sorts NULLs as the smallest values (first in ASC).
+          nullOrdering: "nulls-smallest"
         });
       } catch (e) {
         throw toGraphQLError(e);
@@ -2947,6 +3131,48 @@ var generateUpdate = (db, tableName, table, setArgs, filterArgs, fieldName, sing
     args: queryArgs
   };
 };
+var generateUpdateMany = (db, tableName, table, updateManyInput, fieldName, filterCtx) => {
+  const queryArgs = {
+    updates: {
+      type: new import_graphql6.GraphQLNonNull(new import_graphql6.GraphQLList(new import_graphql6.GraphQLNonNull(updateManyInput)))
+    }
+  };
+  return {
+    name: fieldName,
+    resolver: async (_source, args, context, _info) => {
+      try {
+        const { updates } = args;
+        if (!updates.length) {
+          throw new import_graphql6.GraphQLError("No updates were provided!");
+        }
+        const entries = updates.map(({ where, set }) => {
+          const input = remapFromGraphQLSingleInput(set, table);
+          if (!Object.keys(input).length) {
+            throw new import_graphql6.GraphQLError("Unable to update with no values specified!");
+          }
+          return {
+            set: input,
+            filters: where ? extractFilters(table, tableName, where, relationFilterCtx(filterCtx, tableName)) : void 0
+          };
+        });
+        const executor = resolveExecutor(db, context);
+        await executor.transaction(async (tx) => {
+          for (const entry of entries) {
+            let query = tx.update(table).set(entry.set);
+            if (entry.filters) {
+              query = query.where(entry.filters);
+            }
+            await query;
+          }
+        });
+        return { isSuccess: true };
+      } catch (e) {
+        throw toGraphQLError(e);
+      }
+    },
+    args: queryArgs
+  };
+};
 var generateDelete = (db, tableName, table, filterArgs, fieldName, single, requireWhere, filterCtx) => {
   const queryArgs = {
     where: {
@@ -3054,6 +3280,7 @@ var generateSchemaData = (db, schema, relations, options) => {
       upsertArrayFieldName,
       upsertSingleFieldName,
       updateFieldName,
+      updateManyFieldName,
       updateSingleFieldName,
       deleteFieldName,
       deleteSingleFieldName
@@ -3116,6 +3343,15 @@ var generateSchemaData = (db, schema, relations, options) => {
       features.requireWhere,
       filterCtx
     ) : void 0;
+    const updateManyInput = features.update && features.updateMany ? generateUpdateManyInput({ typeName, updatePrefix: prefixes.update, updateInput, tableFilters }) : void 0;
+    const updateManyGenerated = updateManyInput ? generateUpdateMany(
+      db,
+      tableName,
+      schema[tableName],
+      updateManyInput,
+      updateManyFieldName,
+      filterCtx
+    ) : void 0;
     const deleteGenerated = features.delete ? generateDelete(
       db,
       tableName,
@@ -3193,6 +3429,7 @@ var generateSchemaData = (db, schema, relations, options) => {
       upsertArrGenerated,
       upsertSingleGenerated,
       updateGenerated,
+      updateManyGenerated,
       updateSingleGenerated,
       deleteGenerated,
       deleteSingleGenerated
@@ -3210,6 +3447,7 @@ var generateSchemaData = (db, schema, relations, options) => {
       ...features.insert || onConflictInput ? [insertInput] : [],
       ...onConflictInput ? [onConflictInput] : [],
       ...features.update ? [updateInput] : [],
+      ...updateManyInput ? [updateManyInput] : [],
       tableFilters,
       tableOrder
     ];
@@ -3276,16 +3514,48 @@ var generateSelectArray2 = (db, tableName, tables, relationMap, orderArgs, filte
             single: false,
             filterCtx,
             pkNames,
-            db: executor
+            db: executor,
+            // PostgreSQL sorts NULLs as the largest values (last in ASC).
+            nullOrdering: "nulls-largest"
           });
         }
-        const { offset, limit, orderBy, where, distinct } = args;
+        const { offset, limit, orderBy, where, distinct, after } = args;
         const selectedColumnsSql = extractSelectedColumnsFromTreeSQLFormat(
           parsedInfo.fieldsByTypeName[typeName],
           table,
           { tableName, relationMap, tables }
         );
-        const whereSql = where ? extractFilters(table, tableName, where, relationFilterCtx(filterCtx, tableName)) : void 0;
+        const cursorSelected = isCursorFieldSelected(parsedInfo.fieldsByTypeName[typeName], table);
+        let cursorEntries;
+        if (after != null || cursorSelected) {
+          if (after != null && distinct?.length) {
+            throw new import_graphql7.GraphQLError("'after' cannot be combined with 'distinct'.");
+          }
+          if (orderByHasRelationEntry(orderBy)) {
+            if (after != null) {
+              throw new import_graphql7.GraphQLError(
+                "'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 import_graphql7.GraphQLError(
+                `Table ${tableName} has no primary key, so cursor pagination cannot be used on it.`
+              );
+            }
+          } else {
+            cursorEntries = cursorOrderingEntries(orderBy, pkNames);
+            if (cursorSelected) {
+              const allColumns = (0, import_drizzle_orm6.getColumns)(table);
+              for (const [column] of cursorEntries) {
+                selectedColumnsSql[column] ??= allColumns[column];
+              }
+            }
+          }
+        }
+        const cursorCondition = after != null && cursorEntries ? buildCursorCondition(table, cursorEntries, decodeCursor(after, cursorEntries), "nulls-largest") : void 0;
+        const baseWhereSql = where ? extractFilters(table, tableName, where, relationFilterCtx(filterCtx, tableName)) : void 0;
+        const whereSql = cursorCondition ? (0, import_drizzle_orm6.and)(baseWhereSql, cursorCondition) : baseWhereSql;
         let distinctKeys;
         if (distinct?.length) {
           distinctKeys = await selectDistinctKeys({
@@ -3309,7 +3579,9 @@ var generateSelectArray2 = (db, tableName, tables, relationMap, orderArgs, filte
         } else if (whereSql) {
           q = q.where(whereSql);
         }
-        if (orderBy) {
+        if (cursorEntries && !distinctKeys) {
+          q = q.orderBy(...cursorOrderExprs(table, cursorEntries));
+        } else if (orderBy) {
           q = q.orderBy(
             ...extractOrderBy(table, orderBy, relationFilterCtx(filterCtx, tableName)),
             ...distinctKeys ? primaryKeyOrderExprs(table, pkNames) : []
@@ -3325,7 +3597,11 @@ var generateSelectArray2 = (db, tableName, tables, relationMap, orderArgs, filte
             q = q.limit(limit);
           }
         }
-        return remapToGraphQLArrayOutput(await q, tableName, table, relationMap);
+        const rows = await q;
+        if (cursorEntries && cursorSelected) {
+          attachRowCursors(rows, cursorEntries);
+        }
+        return remapToGraphQLArrayOutput(rows, tableName, table, relationMap);
       } catch (e) {
         throw toGraphQLError(e);
       }
@@ -3591,6 +3867,78 @@ var generateUpdate2 = (db, tableName, table, tables, relationMap, setArgs, filte
     args: queryArgs
   };
 };
+var generateUpdateMany2 = (db, tableName, table, tables, relationMap, updateManyInput, fieldName, typeName, typeNameMapper, filterCtx) => {
+  const queryArgs = {
+    updates: {
+      type: new import_graphql7.GraphQLNonNull(new import_graphql7.GraphQLList(new import_graphql7.GraphQLNonNull(updateManyInput)))
+    }
+  };
+  const pkNames = pgPrimaryKeyPropNames(table);
+  return {
+    name: fieldName,
+    resolver: async (_source, args, context, info) => {
+      try {
+        const { updates } = args;
+        if (!updates.length) {
+          throw new import_graphql7.GraphQLError("No updates were provided!");
+        }
+        const parsedInfo = (0, import_graphql_parse_resolve_info3.parseResolveInfo)(info, {
+          deep: true
+        });
+        const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
+          relationMap,
+          tables,
+          tableName,
+          typeName,
+          typeNameMapper,
+          table,
+          pkNames,
+          parsedInfo
+        });
+        const entries = updates.map(({ where, set }) => {
+          const input = remapFromGraphQLSingleInput(set, table);
+          if (!Object.keys(input).length) {
+            throw new import_graphql7.GraphQLError("Unable to update with no values specified!");
+          }
+          return {
+            set: input,
+            filters: where ? extractFilters(table, tableName, where, relationFilterCtx(filterCtx, tableName)) : void 0
+          };
+        });
+        const executor = resolveExecutor(db, context);
+        const perEntry = await executor.transaction(async (tx) => {
+          const results = [];
+          for (const entry of entries) {
+            let query = tx.update(table).set(entry.set);
+            if (entry.filters) {
+              query = query.where(entry.filters);
+            }
+            results.push(await query.returning(columns));
+          }
+          return results;
+        });
+        const flatRows = perEntry.flat();
+        const enriched = hasRelations ? await eagerLoadMutationRelations(executor, tableName, flatRows, pkNames, withParams) : flatRows;
+        const output = [];
+        let offset = 0;
+        for (const rows of perEntry) {
+          if (!rows.length) {
+            output.push(null);
+            continue;
+          }
+          for (let i = 0; i < rows.length; i++) {
+            output.push(remapToGraphQLSingleOutput(enriched[offset + i], tableName, table, relationMap));
+          }
+          offset += rows.length;
+        }
+        return output;
+      } catch (e) {
+        throw toGraphQLError(e);
+      }
+    },
+    args: queryArgs
+  };
+};
 var generateDelete2 = (db, tableName, table, filterArgs, fieldName, typeName, single, requireWhere, filterCtx, selectionCtx) => {
   const queryArgs = {
     where: {
@@ -3709,6 +4057,7 @@ function generateSchemaData2(db, schema, relations, options) {
       upsertArrayFieldName,
       upsertSingleFieldName,
       updateFieldName,
+      updateManyFieldName,
       updateSingleFieldName,
       deleteFieldName,
       deleteSingleFieldName
@@ -3830,6 +4179,19 @@ function generateSchemaData2(db, schema, relations, options) {
       typeNameMapper,
       filterCtx
     ) : void 0;
+    const updateManyInput = features.update && features.updateMany ? generateUpdateManyInput({ typeName, updatePrefix: prefixes.update, updateInput, tableFilters }) : void 0;
+    const updateManyGenerated = updateManyInput ? generateUpdateMany2(
+      db,
+      tableName,
+      schema[tableName],
+      tables,
+      eagerRelations,
+      updateManyInput,
+      updateManyFieldName,
+      typeName,
+      typeNameMapper,
+      filterCtx
+    ) : void 0;
     const deleteGenerated = features.delete ? generateDelete2(
       db,
       tableName,
@@ -3940,6 +4302,14 @@ function generateSchemaData2(db, schema, relations, options) {
         resolve: updateGenerated.resolver
       };
     }
+    if (updateManyGenerated) {
+      mutations[updateManyGenerated.name] = {
+        // Nullable items: a no-match entry yields `null` in its slot.
+        type: new import_graphql7.GraphQLNonNull(new import_graphql7.GraphQLList(singleTableItemOutput)),
+        args: updateManyGenerated.args,
+        resolve: updateManyGenerated.resolver
+      };
+    }
     if (updateSingleGenerated) {
       mutations[updateSingleGenerated.name] = {
         type: singleTableItemOutput,
@@ -3966,6 +4336,7 @@ function generateSchemaData2(db, schema, relations, options) {
       ...features.insert || onConflictInput ? [insertInput] : [],
       ...onConflictInput ? [onConflictInput] : [],
       ...features.update ? [updateInput] : [],
+      ...updateManyInput ? [updateManyInput] : [],
       tableFilters,
       tableOrder
     ];
@@ -4037,7 +4408,9 @@ var generateSelectArray3 = (db, tableName, tables, relationMap, orderArgs, filte
           single: false,
           filterCtx,
           pkNames,
-          db: executor
+          db: executor,
+          // SQLite sorts NULLs as the smallest values (first in ASC).
+          nullOrdering: "nulls-smallest"
         });
       } catch (e) {
         throw toGraphQLError(e);
@@ -4286,6 +4659,91 @@ var generateUpdate3 = (db, tableName, table, tables, relationMap, setArgs, filte
     args: queryArgs
   };
 };
+var generateUpdateMany3 = (db, tableName, table, tables, relationMap, updateManyInput, fieldName, typeName, typeNameMapper, filterCtx) => {
+  const queryArgs = {
+    updates: {
+      type: new import_graphql8.GraphQLNonNull(new import_graphql8.GraphQLList(new import_graphql8.GraphQLNonNull(updateManyInput)))
+    }
+  };
+  const pkNames = sqlitePrimaryKeyPropNames(table);
+  return {
+    name: fieldName,
+    resolver: async (_source, args, context, info) => {
+      try {
+        const { updates } = args;
+        if (!updates.length) {
+          throw new import_graphql8.GraphQLError("No updates were provided!");
+        }
+        const parsedInfo = (0, import_graphql_parse_resolve_info4.parseResolveInfo)(info, {
+          deep: true
+        });
+        const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
+          relationMap,
+          tables,
+          tableName,
+          typeName,
+          typeNameMapper,
+          table,
+          pkNames,
+          parsedInfo
+        });
+        const entries = updates.map(({ where, set }) => {
+          const input = remapFromGraphQLSingleInput(set, table);
+          if (!Object.keys(input).length) {
+            throw new import_graphql8.GraphQLError("Unable to update with no values specified!");
+          }
+          return {
+            set: input,
+            filters: where ? extractFilters(table, tableName, where, relationFilterCtx(filterCtx, tableName)) : void 0
+          };
+        });
+        const runEntry = (tx, entry) => {
+          let query = tx.update(table).set(entry.set);
+          if (entry.filters) {
+            query = query.where(entry.filters);
+          }
+          return query.returning(columns).all();
+        };
+        const executor = resolveExecutor(db, context);
+        const perEntry = await executor.transaction((tx) => {
+          const first = runEntry(tx, entries[0]);
+          if (typeof first?.then === "function") {
+            return (async () => {
+              const results2 = [await first];
+              for (let i = 1; i < entries.length; i++) {
+                results2.push(await runEntry(tx, entries[i]));
+              }
+              return results2;
+            })();
+          }
+          const results = [first];
+          for (let i = 1; i < entries.length; i++) {
+            results.push(runEntry(tx, entries[i]));
+          }
+          return results;
+        });
+        const flatRows = perEntry.flat();
+        const enriched = hasRelations ? await eagerLoadMutationRelations(executor, tableName, flatRows, pkNames, withParams) : flatRows;
+        const output = [];
+        let offset = 0;
+        for (const rows of perEntry) {
+          if (!rows.length) {
+            output.push(null);
+            continue;
+          }
+          for (let i = 0; i < rows.length; i++) {
+            output.push(remapToGraphQLSingleOutput(enriched[offset + i], tableName, table, relationMap));
+          }
+          offset += rows.length;
+        }
+        return output;
+      } catch (e) {
+        throw toGraphQLError(e);
+      }
+    },
+    args: queryArgs
+  };
+};
 var generateDelete3 = (db, tableName, table, filterArgs, fieldName, typeName, single, requireWhere, filterCtx, selectionCtx) => {
   const queryArgs = {
     where: {
@@ -4405,6 +4863,7 @@ var generateSchemaData3 = (db, schema, relations, options) => {
       upsertArrayFieldName,
       upsertSingleFieldName,
       updateFieldName,
+      updateManyFieldName,
       updateSingleFieldName,
       deleteFieldName,
       deleteSingleFieldName
@@ -4526,6 +4985,19 @@ var generateSchemaData3 = (db, schema, relations, options) => {
       typeNameMapper,
       filterCtx
     ) : void 0;
+    const updateManyInput = features.update && features.updateMany ? generateUpdateManyInput({ typeName, updatePrefix: prefixes.update, updateInput, tableFilters }) : void 0;
+    const updateManyGenerated = updateManyInput ? generateUpdateMany3(
+      db,
+      tableName,
+      schema[tableName],
+      tables,
+      eagerRelations,
+      updateManyInput,
+      updateManyFieldName,
+      typeName,
+      typeNameMapper,
+      filterCtx
+    ) : void 0;
     const deleteGenerated = features.delete ? generateDelete3(
       db,
       tableName,
@@ -4636,6 +5108,14 @@ var generateSchemaData3 = (db, schema, relations, options) => {
         resolve: updateGenerated.resolver
       };
     }
+    if (updateManyGenerated) {
+      mutations[updateManyGenerated.name] = {
+        // Nullable items: a no-match entry yields `null` in its slot.
+        type: new import_graphql8.GraphQLNonNull(new import_graphql8.GraphQLList(singleTableItemOutput)),
+        args: updateManyGenerated.args,
+        resolve: updateManyGenerated.resolver
+      };
+    }
     if (updateSingleGenerated) {
       mutations[updateSingleGenerated.name] = {
         type: singleTableItemOutput,
@@ -4662,6 +5142,7 @@ var generateSchemaData3 = (db, schema, relations, options) => {
       ...features.insert || onConflictInput ? [insertInput] : [],
       ...onConflictInput ? [onConflictInput] : [],
       ...features.update ? [updateInput] : [],
+      ...updateManyInput ? [updateManyInput] : [],
       tableFilters,
       tableOrder
     ];
@@ -4724,6 +5205,7 @@ var buildSchema = (db, config) => {
     distinct: config?.features?.distinct ?? true,
     insert: config?.features?.insert ?? true,
     update: config?.features?.update ?? true,
+    updateMany: config?.features?.updateMany ?? true,
     delete: config?.features?.delete ?? true,
     upsert: config?.features?.upsert ?? false,
     requireWhere: config?.features?.requireWhere ?? false