feathers-utils 10.0.1 → 10.0.2

package/dist/{unless.hook-CVD7SrZh.d.mts → unless.hook-BX0mOvdN.d.mts}

@@ -64,7 +64,7 @@ declare function iff<H extends HookContext = HookContext>(predicate: boolean | P
  * @see https://utils.feathersjs.com/hooks/skippable.html
  */
 declare const skippable: <H extends HookContext = HookContext>(innerHook: HookFunction<H>, predicate: PredicateFn<H>) => {
-  (context: H): void;
+  (context: H): H | void | Promise<H | void>;
   (context: H, next: NextFunction): Promise<void>;
 };
 //#endregion
@@ -115,4 +115,4 @@ declare const throwIf: <H extends HookContext = HookContext>(predicate: Predicat
 declare function unless<H extends HookContext = HookContext>(predicate: boolean | PredicateFn, ...hooks: HookFunction<H>[]): (this: any, ctx: H, next?: _$_feathersjs_feathers0.NextFunction) => HookContext<_$_feathersjs_feathers0.Application<any, any>, any> | Promise<any>;
 //#endregion
 export { IffHook as a, skippable as i, ThrowIfOptions as n, iff as o, throwIf as r, iffElse as s, unless as t };
-//# sourceMappingURL=unless.hook-CVD7SrZh.d.mts.map
+//# sourceMappingURL=unless.hook-BX0mOvdN.d.mts.map

package/dist/{utils-ByzrJKGQ.mjs → utils-BrvpblXB.mjs}

@@ -1,6 +1,5 @@
-import { d as isPaginated, m as isContext, p as isMulti } from "./predicates-C2SeOKGd.mjs";
-import { i as getDataIsArray, r as getResultIsArray } from "./mutate-result.util-CCBWix-G.mjs";
-import isObject from "lodash/isObject.js";
+import { d as isPaginated, m as isContext, p as isMulti } from "./predicates-BC8p_YLo.mjs";
+import { a as getResultIsArray, o as getDataIsArray } from "./mutate-result.util-B6FOkwrd.mjs";
 import { dequal } from "dequal";
 import * as feathers from "@feathersjs/feathers";
 //#region src/utils/sort-query-properties/sort-query-properties.util.ts
@@ -12,6 +11,7 @@ const arrayOperators = new Set([
 	"$in",
 	"$nin"
 ]);
+const isPlainObjectLike = (value) => value !== null && typeof value === "object";
 /**
 * Recursively normalizes a Feathers query object for order-independent comparison.
 * Sorts object keys and sorts arrays within `$or`, `$and`, `$nor`, `$not`, `$in`,
@@ -40,11 +40,17 @@ const sortQueryProperties = (query) => {
 };
 const normalize = (value) => {
 	if (Array.isArray(value)) return value.map(normalize);
-	if (!isObject(value)) return value;
+	if (!isPlainObjectLike(value)) return value;
 	const sorted = {};
 	for (const key of Object.keys(value).sort()) {
 		const val = value[key];
-		if (arrayOperators.has(key) && Array.isArray(val)) sorted[key] = val.map(normalize).sort((a, b) => JSON.stringify(a) < JSON.stringify(b) ? -1 : 1);
+		if (arrayOperators.has(key) && Array.isArray(val)) sorted[key] = val.map((el) => {
+			const normalized = normalize(el);
+			return {
+				k: JSON.stringify(normalized),
+				v: normalized
+			};
+		}).sort((a, b) => a.k < b.k ? -1 : a.k > b.k ? 1 : 0).map((entry) => entry.v);
 		else sorted[key] = normalize(val);
 	}
 	return sorted;
@@ -123,6 +129,7 @@ async function* chunkFind(app, servicePath, options) {
 	let result;
 	do {
 		result = await service.find(params);
+		if (!result.data.length) break;
 		yield result.data;
 		params.query.$skip = (params.query.$skip ?? 0) + result.data.length;
 	} while (result.total > params.query.$skip);
@@ -293,11 +300,15 @@ async function* iterateFind(app, servicePath, options) {
 			$limit: options?.params?.query?.$limit,
 			$skip: options?.params?.query?.$skip ?? 0
 		},
-		paginate: { default: options?.params?.paginate?.default ?? 10 }
+		paginate: {
+			default: options?.params?.paginate?.default ?? 10,
+			max: options?.params?.paginate?.max ?? 100
+		}
 	};
 	let result;
 	do {
 		result = await service.find(params);
+		if (!result.data.length) break;
 		for (const item of result.data) yield item;
 		params.query.$skip = (params.query.$skip ?? 0) + result.data.length;
 	} while (result.total > params.query.$skip);
@@ -305,6 +316,14 @@ async function* iterateFind(app, servicePath, options) {
 //#endregion
 //#region src/utils/patch-batch/patch-batch.util.ts
 /**
+* Deterministic, key-order-independent serialization used to group items with
+* equal patch data in O(1) per item.
+*/
+const stableKey = (value) => JSON.stringify(value, (_key, val) => val && typeof val === "object" && !Array.isArray(val) ? Object.keys(val).sort().reduce((acc, k) => {
+	acc[k] = val[k];
+	return acc;
+}, {}) : val);
+/**
 * Batch patching utility that takes an array of items to be changed and returns an array of arguments to be called with the `patch` method.
 *
 * This utility is useful when you need to patch multiple items with varying data in as few requests as possible.
@@ -330,22 +349,22 @@ async function* iterateFind(app, servicePath, options) {
 * @see https://utils.feathersjs.com/utils/patch-batch.html
 */
 function patchBatch(items, options) {
-	const map = [];
 	const idKey = options?.id ?? "id";
-	for (const _data of items) {
-		const data = _data;
-		const id = _data[idKey];
+	const groups = /* @__PURE__ */ new Map();
+	for (const item of items) {
+		const source = item;
+		const id = source[idKey];
+		const data = { ...source };
 		delete data[idKey];
-		const index = map.findIndex((item) => {
-			return dequal(item.data, data);
-		});
-		if (index === -1) map.push({
+		const key = stableKey(data);
+		const existing = groups.get(key);
+		if (existing) existing.ids.push(id);
+		else groups.set(key, {
 			ids: [id],
 			data
 		});
-		else map[index].ids.push(id);
 	}
-	return map.map(({ ids, data }) => {
+	return [...groups.values()].map(({ ids, data }) => {
 		return ids.length === 1 ? [
 			ids[0],
 			data,
@@ -452,7 +471,7 @@ const _walkQueryUtil = (query, walker, options) => {
 		}
 		query[key] = value;
 	}
-	for (const key in query) if ((key === "$or" || key === "$and" || key === "$nor" || key === "$not") && Array.isArray(query[key])) {
+	for (const key in query) if ((key === "$or" || key === "$and" || key === "$nor") && Array.isArray(query[key])) {
 		let array = query[key];
 		let copiedArray = false;
 		for (let i = 0, n = array.length; i < n; i++) {
@@ -507,7 +526,7 @@ const _walkQueryUtil = (query, walker, options) => {
 	return query;
 };
 /**
-* Walks every property of a Feathers query (including nested `$and`/`$or`/`$nor`/`$not` arrays)
+* Walks every property of a Feathers query (including nested `$and`/`$or`/`$nor` arrays)
 * and calls the `walker` function for each one. The walker receives the property name, operator,
 * value, and path, and can return a replacement value. Returns a new query only if changes were made.
 *
@@ -567,4 +586,4 @@ function zipDataResult(context, options) {
 //#endregion
 export { skipResult as a, getExposedMethods as c, checkContext as d, addToQuery as f, sortQueryProperties as h, toPaginated as i, defineHooks as l, addSkip as m, walkQuery as n, patchBatch as o, chunkFind as p, transformParams as r, iterateFind as s, zipDataResult as t, contextToJson as u };
 
-//# sourceMappingURL=utils-ByzrJKGQ.mjs.map
+//# sourceMappingURL=utils-BrvpblXB.mjs.map

package/dist/utils-BrvpblXB.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils-BrvpblXB.mjs","names":["deepEqual"],"sources":["../src/utils/sort-query-properties/sort-query-properties.util.ts","../src/utils/add-skip/add-skip.util.ts","../src/utils/chunk-find/chunk-find.util.ts","../src/utils/add-to-query/add-to-query.util.ts","../src/utils/check-context/check-context.util.ts","../src/utils/context-to-json/context-to-json.util.ts","../src/utils/define-hooks/define-hooks.util.ts","../src/feathers-cjs-fix.ts","../src/utils/get-exposed-methods/get-exposed-methods.util.ts","../src/utils/iterate-find/iterate-find.util.ts","../src/utils/patch-batch/patch-batch.util.ts","../src/utils/skip-result/skip-result.util.ts","../src/utils/to-paginated/to-paginated.util.ts","../src/utils/transform-params/transform-params.util.ts","../src/utils/walk-query/walk-query.util.ts","../src/utils/zip-data-result/zip-data-result.util.ts"],"sourcesContent":["import type { Query } from '@feathersjs/feathers'\n\nconst arrayOperators = new Set(['$or', '$and', '$nor', '$not', '$in', '$nin'])\n\nconst isPlainObjectLike = (value: unknown): value is Record<string, any> =>\n  value !== null && typeof value === 'object'\n\n/**\n * Recursively normalizes a Feathers query object for order-independent comparison.\n * Sorts object keys and sorts arrays within `$or`, `$and`, `$nor`, `$not`, `$in`,\n * and `$nin` operators so that different orderings produce the same result.\n *\n * This is useful for generating stable cache keys where\n * `{ $or: [{ a: 1 }, { b: 2 }] }` and `{ $or: [{ b: 2 }, { a: 1 }] }`\n * should be treated as equivalent.\n *\n * @example\n * ```ts\n * import { sortQueryProperties } from 'feathers-utils/utils'\n *\n * const normalized = sortQueryProperties({\n *   $or: [{ name: 'Jane' }, { name: 'John' }],\n *   age: { $in: [30, 25] },\n * })\n * // => { $or: [{ name: 'John' }, { name: 'Jane' }], age: { $in: [25, 30] } }\n * // (sorted by stable stringify comparison)\n * ```\n *\n * @see https://utils.feathersjs.com/utils/sort-query-properties.html\n */\nexport const sortQueryProperties = <Q extends Query>(query: Q): Q => {\n  return normalize(query) as Q\n}\n\nconst normalize = (value: any): any => {\n  if (Array.isArray(value)) {\n    return value.map(normalize)\n  }\n\n  if (!isPlainObjectLike(value)) {\n    return value\n  }\n\n  const sorted: Record<string, any> = {}\n\n  for (const key of Object.keys(value).sort()) {\n    const val = value[key]\n\n    if (arrayOperators.has(key) && Array.isArray(val)) {\n      // Schwartzian transform: serialize each normalized element once, sort by\n      // that key, then unwrap. Avoids the O(n log n) repeated JSON.stringify of\n      // the previous comparator (which also returned 1 for equal elements).\n      sorted[key] = val\n        .map((el) => {\n          const normalized = normalize(el)\n          return { k: JSON.stringify(normalized), v: normalized }\n        })\n        .sort((a, b) => (a.k < b.k ? -1 : a.k > b.k ? 1 : 0))\n        .map((entry) => entry.v)\n    } else {\n      sorted[key] = normalize(val)\n    }\n  }\n\n  return sorted\n}\n","import type { HookContext, HookType } from '@feathersjs/feathers'\nimport type { MaybeArray } from '../../internal.utils.js'\n\nexport type SkipHookName =\n  | 'all'\n  | HookType\n  | `${HookType}:${string}`\n  | (string & {})\n\n/**\n * Adds hook names to `context.params.skipHooks` so that `skippable`-wrapped hooks\n * will be bypassed for the current service call. Accepts a single name or an array.\n * Duplicates are automatically removed.\n *\n * @example\n * ```ts\n * import { addSkip } from 'feathers-utils/utils'\n *\n * // Inside a hook or custom code:\n * addSkip(context, 'myHook')\n * addSkip(context, ['hookA', 'hookB'])\n * ```\n *\n * @see https://utils.feathersjs.com/utils/add-skip.html\n */\nexport const addSkip = <H extends HookContext>(\n  context: H,\n  hooks: MaybeArray<SkipHookName>,\n) => {\n  const names = Array.isArray(hooks) ? hooks : [hooks]\n\n  if (context.params.skipHooks === undefined) {\n    context.params = {\n      ...context.params,\n      skipHooks: [...names],\n    }\n  } else {\n    if (!Array.isArray(context.params.skipHooks)) {\n      throw new Error('Invalid skipHooks parameter')\n    }\n\n    context.params = {\n      ...context.params,\n      skipHooks: [...new Set([...context.params.skipHooks, ...names])],\n    }\n  }\n}\n","import type { Application, Params } from '@feathersjs/feathers'\nimport type { KeyOf } from '../../internal.utils.js'\nimport type {\n  InferFindParams,\n  InferFindResultSingle,\n} from '../../utility-types/infer-service-methods.js'\n\ntype PaginateOption = { default?: number; max?: number }\n\ntype ChunkFindOptions<P extends Params = Params> = {\n  params?: P & { paginate?: PaginateOption }\n}\n\n/**\n * Use `for await` to iterate over chunks (pages) of results from a `find` method.\n *\n * This function is useful for processing large datasets in batches without loading everything into memory at once.\n * It uses pagination to fetch results in chunks, yielding each page's data array.\n *\n * @example\n * ```ts\n * import { chunkFind } from 'feathers-utils/utils'\n *\n * const app = feathers()\n *\n * // Assuming 'users' service has many records\n * for await (const users of chunkFind(app, 'users', {\n *  params: { query: { active: true }, // Custom query parameters\n * } })) {\n *  console.log(users) // Process each chunk of user records\n * }\n * ```\n *\n * @see https://utils.feathersjs.com/utils/chunk-find.html\n */\nexport async function* chunkFind<\n  Services,\n  Path extends KeyOf<Services>,\n  Service extends Services[Path] = Services[Path],\n  P extends Params = InferFindParams<Service>,\n  Item = InferFindResultSingle<Service>,\n>(\n  app: Application<Services>,\n  servicePath: Path,\n  options?: ChunkFindOptions<P>,\n): AsyncGenerator<Item[], void, unknown> {\n  const service = app.service(servicePath)\n\n  if (!service || !('find' in service)) {\n    throw new Error(`Service '${servicePath}' does not have a 'find' method.`)\n  }\n\n  const params = {\n    ...options?.params,\n    query: {\n      ...(options?.params?.query ?? {}),\n      $limit: options?.params?.query?.$limit ?? 10,\n      $skip: options?.params?.query?.$skip ?? 0,\n    },\n    paginate: {\n      default: options?.params?.paginate?.default ?? 10,\n      max: options?.params?.paginate?.max ?? 100,\n    },\n  }\n\n  let result\n\n  do {\n    result = await (service as any).find(params)\n\n    // Guard against an infinite loop: an empty page never advances $skip, so\n    // `total > $skip` could stay true forever (e.g. $limit:0, or a stale total\n    // when items are concurrently removed / filtered out by hooks).\n    if (!result.data.length) {\n      break\n    }\n\n    yield result.data\n\n    params.query.$skip = (params.query.$skip ?? 0) + result.data.length\n  } while (result.total > params.query.$skip)\n}\n","import type { Query } from '@feathersjs/feathers'\nimport { dequal as deepEqual } from 'dequal'\n\n/**\n * Safely merges properties into a Feathers query object. If a property already exists\n * with a different value, it wraps both in a `$and` array to preserve both conditions.\n * If the exact same key-value pair already exists, no changes are made.\n *\n * @example\n * ```ts\n * import { addToQuery } from 'feathers-utils/utils'\n *\n * const query = { status: 'active' }\n * addToQuery(query, { role: 'admin' })\n * // => { status: 'active', role: 'admin' }\n * ```\n *\n * @see https://utils.feathersjs.com/utils/add-to-query.html\n */\nexport function addToQuery<Q extends Query>(targetQuery: Q, query: Q): Q {\n  targetQuery ??= {} as Q\n\n  if (Object.keys(query).length === 0) {\n    return targetQuery\n  }\n\n  const entries = Object.entries(query) as [keyof Q, any][]\n\n  if (entries.every(([property]) => !(property in targetQuery))) {\n    // if none of the properties exist, merge them directly\n    return {\n      ...targetQuery,\n      ...query,\n    }\n  }\n\n  function isAlreadyInQuery(targetQuery: Q, entries: [keyof Q, any][]) {\n    return entries.every(\n      ([property, value]) =>\n        property in targetQuery && deepEqual(targetQuery[property], value),\n    )\n  }\n\n  if (isAlreadyInQuery(targetQuery, entries)) {\n    // if all properties already exist with the exact same value, do nothing\n    return targetQuery\n  }\n\n  if (!targetQuery.$and) {\n    return {\n      ...targetQuery,\n      $and: [{ ...query }],\n    }\n  }\n\n  // check if the exact same value already exists in $and\n  if (targetQuery.$and.some((q: any) => isAlreadyInQuery(q, entries))) {\n    return targetQuery\n  }\n\n  return {\n    ...targetQuery,\n    $and: [...targetQuery.$and, { ...query }],\n  }\n}\n","import type { HookContext } from '@feathersjs/feathers'\nimport type { HookType, MethodName } from '../../types.js'\nimport {\n  isContext,\n  type IsContextOptions,\n} from '../../predicates/is-context/is-context.predicate.js'\nimport type { UnpackMaybeArray } from '../../internal.utils.js'\n\ntype NarrowedContext<H extends HookContext, O> = H &\n  (O extends { path: infer P }\n    ? [P] extends [undefined | null]\n      ? unknown\n      : { path: UnpackMaybeArray<P> }\n    : unknown) &\n  (O extends { type: infer T }\n    ? [T] extends [undefined | null]\n      ? unknown\n      : { type: UnpackMaybeArray<T> }\n    : unknown) &\n  (O extends { method: infer M }\n    ? [M] extends [undefined | null]\n      ? unknown\n      : { method: UnpackMaybeArray<M> }\n    : unknown)\n\nexport type CheckContextOptions<H extends HookContext = HookContext> =\n  IsContextOptions<H> & {\n    label?: string\n  }\n\n/**\n * Validates that the hook context matches the expected type(s) and method(s).\n * Throws an error if the context is invalid, preventing hooks from running in\n * unsupported configurations. Typically used internally by other hooks.\n * Also narrows the context type based on the passed options.\n *\n * @example\n * ```ts\n * import { checkContext } from 'feathers-utils/utils'\n *\n * const myHook = (context) => {\n *   checkContext(context, ['before', 'around'], ['create', 'patch'], 'myHook')\n *   // or with options object:\n *   checkContext(context, { type: ['before', 'around'], method: ['create', 'patch'], label: 'myHook' })\n *   // context.type is now 'before' | 'around', context.method is now 'create' | 'patch'\n * }\n * ```\n *\n * @see https://utils.feathersjs.com/utils/check-context.html\n */\nexport function checkContext<\n  H extends HookContext,\n  const O extends CheckContextOptions<NoInfer<H>>,\n>(context: H, options: O): asserts context is NarrowedContext<H, O>\nexport function checkContext<\n  H extends HookContext,\n  const T extends HookType | HookType[] | null | undefined = undefined,\n  const M extends MethodName | MethodName[] | null | undefined = undefined,\n>(\n  context: H,\n  type?: T,\n  methods?: M,\n  label?: string,\n): asserts context is NarrowedContext<H, { type: T; method: M }>\nexport function checkContext<H extends HookContext = HookContext>(\n  context: H,\n  typeOrOptions?:\n    | HookType\n    | HookType[]\n    | CheckContextOptions<NoInfer<H>>\n    | null,\n  methods?: MethodName | MethodName[] | null,\n  label = 'anonymous',\n): void {\n  let options: IsContextOptions\n  let hookLabel: string\n\n  if (\n    typeOrOptions != null &&\n    typeof typeOrOptions === 'object' &&\n    !Array.isArray(typeOrOptions)\n  ) {\n    const { label: optLabel, ...rest } = typeOrOptions\n    options = rest\n    hookLabel = optLabel ?? 'anonymous'\n  } else {\n    options = {\n      method: methods ?? undefined,\n      type: typeOrOptions ?? undefined,\n    }\n    hookLabel = label\n  }\n\n  if (!isContext(options)(context)) {\n    const details: string[] = []\n\n    if (options.type != null) {\n      details.push(\n        `type: expected '${Array.isArray(options.type) ? options.type.join(\"' | '\") : options.type}' but got '${context.type}'`,\n      )\n    }\n    if (options.method != null) {\n      details.push(\n        `method: expected '${Array.isArray(options.method) ? options.method.join(\"' | '\") : options.method}' but got '${context.method}'`,\n      )\n    }\n    if (options.path != null) {\n      details.push(\n        `path: expected '${Array.isArray(options.path) ? options.path.join(\"' | '\") : options.path}' but got '${context.path}'`,\n      )\n    }\n\n    throw new Error(\n      `The '${hookLabel}' hook has invalid context (${details.join(', ')}).`,\n    )\n  }\n}\n","import type { HookContext } from '@feathersjs/feathers'\n\n/**\n * Converts a FeathersJS HookContext to a plain JSON object by calling `toJSON()` if available.\n * This is important when using lodash `get`/`has` on the context, since the HookContext\n * class uses getters that may not be enumerable.\n *\n * @example\n * ```ts\n * import { contextToJson } from 'feathers-utils/utils'\n *\n * const json = contextToJson(context)\n * console.log(json)\n * ```\n *\n * @see https://utils.feathersjs.com/utils/context-to-json.html\n */\nexport const contextToJson = (context: HookContext) => {\n  if (context.toJSON) {\n    return context.toJSON()\n  }\n  return context\n}\n","import type { Application, HookOptions } from '@feathersjs/feathers'\n\n/**\n * TypeScript helper that provides full type inference and autocompletion when defining\n * service hooks. It is an identity function that simply returns its input,\n * but enables your IDE to infer the correct hook context types.\n *\n * @example\n * ```ts\n * import { defineHooks } from 'feathers-utils/utils'\n *\n * export const userHooks = defineHooks({\n *   before: { create: [validateUser()] },\n *   after: { all: [sanitizeResult()] }\n * })\n * ```\n *\n * @see https://utils.feathersjs.com/utils/define-hooks.html\n */\nexport function defineHooks<\n  A extends Application = Application,\n  S = {\n    find: any\n    get: any\n    create: any\n    update: any\n    patch: any\n    remove: any\n  },\n  Options = HookOptions<A, S>,\n>(hooks: Options): Options {\n  return hooks\n}\n","// src/feathers.ts\nimport * as feathers from '@feathersjs/feathers'\n\n// Type-safe re-export of only what you need\nexport const SERVICE = (feathers as any).SERVICE || feathers.default?.SERVICE\n","import type { Service } from '@feathersjs/feathers'\nimport { SERVICE } from '../../feathers-cjs-fix.js'\n\n/**\n * Returns the list of method names that are publicly exposed by a Feathers service.\n * Reads the internal `[SERVICE].methods` property set during service registration.\n * Throws if the service does not have any exposed methods configured.\n *\n * @example\n * ```ts\n * import { getExposedMethods } from 'feathers-utils/utils'\n *\n * const methods = getExposedMethods(app.service('users'))\n * // => ['find', 'get', 'create', 'patch', 'remove']\n * ```\n *\n * @see https://utils.feathersjs.com/utils/get-exposed-methods.html\n */\nexport function getExposedMethods(service: Service) {\n  const result = (service as any)[SERVICE].methods\n\n  if (!result || !Array.isArray(result)) {\n    throw new Error(`Service does not have exposed methods`)\n  }\n\n  return result\n}\n","import type { Application, Params } from '@feathersjs/feathers'\nimport type { KeyOf } from '../../internal.utils.js'\nimport type {\n  InferFindParams,\n  InferFindResultSingle,\n} from '../../utility-types/infer-service-methods.js'\n\ntype PaginateOption = { default?: number; max?: number }\n\ntype IterateFindOptions<P extends Params = Params> = {\n  params?: P & { paginate?: PaginateOption }\n}\n\n/**\n * Use `for await` to iterate over the results of a `find` method.\n *\n * This function is useful for iterating over large datasets without loading everything into memory at once.\n * It uses pagination to fetch results in chunks, allowing you to process each item as it is retrieved.\n *\n * @example\n * ```ts\n * import { iterateFind } from 'feathers-utils/utils'\n *\n * const app = feathers()\n *\n * // Assuming 'users' service has many records\n * for await (const user of iterateFind(app, 'users', {\n *  params: { query: { active: true }, // Custom query parameters\n * } })) {\n *  console.log(user) // Process each user record\n * }\n * ```\n *\n * @see https://utils.feathersjs.com/utils/iterate-find.html\n */\nexport async function* iterateFind<\n  Services,\n  Path extends KeyOf<Services>,\n  Service extends Services[Path] = Services[Path],\n  P extends Params = InferFindParams<Service>,\n  Item = InferFindResultSingle<Service>,\n>(\n  app: Application<Services>,\n  servicePath: Path,\n  options?: IterateFindOptions<P>,\n): AsyncGenerator<Item, void, unknown> {\n  const service = app.service(servicePath)\n\n  if (!service || !('find' in service)) {\n    throw new Error(`Service '${servicePath}' does not have a 'find' method.`)\n  }\n\n  const params = {\n    ...options?.params,\n    query: {\n      ...(options?.params?.query ?? {}),\n      $limit: options?.params?.query?.$limit,\n      $skip: options?.params?.query?.$skip ?? 0,\n    },\n    paginate: {\n      default: options?.params?.paginate?.default ?? 10,\n      max: options?.params?.paginate?.max ?? 100,\n    },\n  }\n\n  let result\n\n  do {\n    result = await (service as any).find(params)\n\n    // Guard against an infinite loop: an empty page never advances $skip, so\n    // `total > $skip` could stay true forever (e.g. $limit:0, or a stale total\n    // when items are concurrently removed / filtered out by hooks).\n    if (!result.data.length) {\n      break\n    }\n\n    for (const item of result.data) {\n      yield item\n    }\n\n    params.query.$skip = (params.query.$skip ?? 0) + result.data.length\n  } while (result.total > params.query.$skip)\n}\n","import type { Id, Params } from '@feathersjs/feathers'\nimport type { KeyOf } from '../../internal.utils.js'\n\n/**\n * Deterministic, key-order-independent serialization used to group items with\n * equal patch data in O(1) per item.\n */\nconst stableKey = (value: any): string =>\n  JSON.stringify(value, (_key, val) =>\n    val && typeof val === 'object' && !Array.isArray(val)\n      ? Object.keys(val)\n          .sort()\n          .reduce<Record<string, any>>((acc, k) => {\n            acc[k] = val[k]\n            return acc\n          }, {})\n      : val,\n  )\n\nexport type PatchBatchOptions<IdKey extends string> = {\n  /** the key of the id property */\n  id?: IdKey\n}\n\nexport type PatchBatchResultItem<T = Record<string, unknown>, P = Params> = [\n  Id | null,\n  T,\n  P | undefined,\n]\n\n/**\n * Batch patching utility that takes an array of items to be changed and returns an array of arguments to be called with the `patch` method.\n *\n * This utility is useful when you need to patch multiple items with varying data in as few requests as possible.\n *\n * @example\n * ```ts\n * const items = [\n *   { id: 1, value: 10 },\n *   { id: 2, value: 10 },\n *   { id: 3, value: 20 },\n * ];\n *\n * const batched = patchBatch(items, { id: 'id' });\n * // batched will be:\n * // [\n * //   [null, { value: 10 }, { query: { id: { $in: [1, 2] } } }],\n * //   [3, { value: 20 }, undefined],\n * // ]\n *\n * await Promise.all(batched.map(args => service.patch(...args)));\n * ```\n *\n * @see https://utils.feathersjs.com/utils/patch-batch.html\n */\nexport function patchBatch<\n  T extends Record<string, any>,\n  IdKey extends KeyOf<T>,\n  P extends Params,\n  R extends Omit<T, IdKey> = Omit<T, IdKey>,\n>(\n  items: T[],\n  options?: PatchBatchOptions<IdKey>,\n): PatchBatchResultItem<R, P>[] {\n  const idKey = options?.id ?? 'id'\n\n  // group items with identical (id-stripped) data in O(n) via a Map keyed by a\n  // stable serialization, instead of an O(n^2) findIndex + deepEqual scan.\n  const groups = new Map<string, { ids: Id[]; data: R }>()\n\n  for (const item of items) {\n    const source = item as Record<string, any>\n    const id = source[idKey] as Id\n    // shallow copy then drop the id key, so the caller's input is never mutated.\n    const data = { ...source }\n    delete data[idKey as any]\n\n    const key = stableKey(data)\n    const existing = groups.get(key)\n\n    if (existing) {\n      existing.ids.push(id)\n    } else {\n      groups.set(key, { ids: [id], data: data as unknown as R })\n    }\n  }\n\n  return [...groups.values()].map(({ ids, data }) => {\n    return ids.length === 1\n      ? ([ids[0], data, undefined] as PatchBatchResultItem<R, P>)\n      : ([\n          null,\n          data,\n          {\n            query: {\n              [idKey]: { $in: ids },\n            },\n          },\n        ] as PatchBatchResultItem<R, P>)\n  })\n}\n","import type { HookContext } from '@feathersjs/feathers'\nimport { isMulti, isPaginated } from '../../predicates/index.js'\n\n/**\n * Sets `context.result` to an appropriate empty value based on the hook method.\n * Returns an empty paginated object for paginated `find`, an empty array for multi\n * operations, or `null` for single-item operations. Does nothing if a result already exists.\n *\n * @example\n * ```ts\n * import { skipResult } from 'feathers-utils/utils'\n *\n * // In a before hook to skip the actual database call:\n * skipResult(context)\n * ```\n *\n * @see https://utils.feathersjs.com/utils/skip-result.html\n */\nexport const skipResult = <H extends HookContext = HookContext>(context: H) => {\n  if (context.result) {\n    return context\n  }\n\n  const multi = isMulti(context)\n\n  if (multi) {\n    if (context.method === 'find' && isPaginated(context)) {\n      context.result = {\n        total: 0,\n        skip: 0,\n        limit: 0,\n        data: [],\n      }\n    } else {\n      context.result = []\n    }\n  } else {\n    context.result = null\n  }\n\n  return context\n}\n","import type { Paginated } from '@feathersjs/feathers'\n\n/**\n * Ensures a result is in Feathers paginated format (`{ total, limit, skip, data }`).\n * If the input is already paginated, it is returned as-is. If it is a plain array,\n * it is wrapped in a paginated object with `total` and `limit` set to the array length.\n *\n * @example\n * ```ts\n * import { toPaginated } from 'feathers-utils/utils'\n *\n * const paginated = toPaginated([{ id: 1 }, { id: 2 }])\n * // => { total: 2, limit: 2, skip: 0, data: [{ id: 1 }, { id: 2 }] }\n * ```\n *\n * @see https://utils.feathersjs.com/utils/to-paginated.html\n */\nexport function toPaginated<R>(result: R[] | Paginated<R>): Paginated<R> {\n  if (Array.isArray(result)) {\n    return {\n      total: result.length,\n      limit: result.length,\n      skip: 0,\n      data: result,\n    }\n  }\n  return result\n}\n","import type { Params } from '@feathersjs/feathers'\nimport type { TransformParamsFn } from '../../types.js'\n\n/**\n * Safely applies a `transformParams` function to a params object.\n * If no function is provided, the original params are returned unchanged.\n * The function receives a shallow copy of params, so the original is not mutated.\n *\n * @example\n * ```ts\n * import { transformParams } from 'feathers-utils/utils'\n *\n * const params = transformParams(context.params, (p) => { delete p.provider; return p })\n * ```\n *\n * @see https://utils.feathersjs.com/utils/transform-params.html\n */\nexport const transformParams = <P extends Params = Params>(\n  params: P,\n  fn: TransformParamsFn<P> | undefined,\n): P => {\n  if (!fn) {\n    return params\n  }\n\n  const result = fn({ ...params })\n\n  return result ?? params\n}\n","import type { Query } from '@feathersjs/feathers'\n\ntype WalkQueryOptionsInit = {\n  property?: string\n  operator?: string | undefined\n  value?: any\n  path: (string | number)[]\n}\n\nexport type WalkQueryOptions = {\n  property: string\n  operator: string | undefined\n  value: any\n  path: (string | number)[]\n}\n\nexport type WalkQueryCallback = (options: WalkQueryOptions) => any\n\nconst _walkQueryUtil = <Q extends Query>(\n  query: Q,\n  walker: WalkQueryCallback,\n  options?: WalkQueryOptionsInit | WalkQueryOptions,\n): Q => {\n  let cloned = false\n  const clonedSecond: Record<string, boolean> = {}\n  function set(key: string, value: any, secondKey?: string | number) {\n    if (!cloned) {\n      query = { ...query }\n      cloned = true\n    }\n\n    if (secondKey !== undefined) {\n      if (!clonedSecond[key]) {\n        ;(query as any)[key] = { ...query[key] }\n        clonedSecond[key] = true\n      }\n      query[key][secondKey] = value\n      return\n    }\n\n    ;(query as any)[key] = value\n  }\n\n  for (const key in query) {\n    if (\n      (key === '$or' || key === '$and' || key === '$nor') &&\n      Array.isArray(query[key])\n    ) {\n      let array = query[key]\n\n      let copiedArray = false\n\n      for (let i = 0, n = array.length; i < n; i++) {\n        const nestedQuery = array[i]\n        const transformed = _walkQueryUtil(nestedQuery, walker, {\n          ...options,\n          path: [...(options?.path || []), key, i],\n        })\n\n        if (transformed !== nestedQuery) {\n          if (!copiedArray) {\n            array = [...array] as any\n            copiedArray = true\n          }\n\n          array[i] = transformed\n        }\n      }\n\n      if (copiedArray) {\n        set(key, array)\n      }\n    } else if (\n      typeof query[key] === 'object' &&\n      query[key] !== null &&\n      !Array.isArray(query[key])\n    ) {\n      let hasOperator = false\n      for (const operator in query[key]) {\n        if (operator.startsWith('$')) {\n          hasOperator = true\n          const value = walker({\n            operator,\n            path: [...(options?.path ?? []), key],\n            property: key,\n            value: query[key][operator],\n          })\n\n          if (value !== undefined && value !== query[key][operator]) {\n            set(key, value, operator)\n          }\n        }\n      }\n\n      if (!hasOperator) {\n        const value = walker({\n          operator: undefined,\n          path: [...(options?.path ?? []), key],\n          property: key,\n          value: query[key],\n        })\n\n        if (value !== undefined && value !== query[key]) {\n          set(key, value)\n        }\n      }\n    } else {\n      const value = walker({\n        operator: undefined,\n        path: [...(options?.path ?? []), key],\n        property: key,\n        value: query[key],\n      })\n\n      if (value !== undefined && value !== query[key]) {\n        set(key, value)\n      }\n    }\n  }\n\n  return query\n}\n\n/**\n * Walks every property of a Feathers query (including nested `$and`/`$or`/`$nor` arrays)\n * and calls the `walker` function for each one. The walker receives the property name, operator,\n * value, and path, and can return a replacement value. Returns a new query only if changes were made.\n *\n * @example\n * ```ts\n * import { walkQuery } from 'feathers-utils/utils'\n *\n * const query = walkQuery({ age: { $gt: '18' } }, ({ value, operator }) => {\n *   if (operator === '$gt') return Number(value)\n * })\n * // => { age: { $gt: 18 } }\n * ```\n *\n * @see https://utils.feathersjs.com/utils/walk-query.html\n */\nexport const walkQuery = <Q extends Query>(\n  query: Q,\n  walker: WalkQueryCallback,\n): Q => {\n  return _walkQueryUtil(query, walker)\n}\n","import type { HookContext } from '@feathersjs/feathers'\nimport { getDataIsArray } from '../get-data-is-array/get-data-is-array.util.js'\nimport { getResultIsArray } from '../get-result-is-array/get-result-is-array.util.js'\nimport { checkContext } from '../check-context/check-context.util.js'\nimport type {\n  DataSingleHookContext,\n  ResultSingleHookContext,\n} from '../../utility-types/hook-context.js'\n\nexport type ZipDataResultOptions = {\n  onMismatch?: (context: HookContext) => void\n}\n\nexport type ZipDataResultItem<D, R> = {\n  data: D | undefined\n  result: R | undefined\n}\n\n/**\n * Pairs each item in `context.data` with its corresponding item in `context.result` by index.\n * Handles both single-item and array data, normalizing them into an array of `{ data, result }` pairs.\n * Only works in `after`/`around` hooks for `create`, `update`, and `patch` methods.\n *\n * @example\n * ```ts\n * import { zipDataResult } from 'feathers-utils/utils'\n *\n * const pairs = zipDataResult(context)\n * pairs.forEach(({ data, result }) => { /* process each pair *\\/ })\n * ```\n *\n * @see https://utils.feathersjs.com/utils/zip-data-result.html\n */\nexport function zipDataResult<\n  H extends HookContext,\n  D extends DataSingleHookContext<H> = DataSingleHookContext<H>,\n  R extends ResultSingleHookContext<H> = ResultSingleHookContext<H>,\n>(context: H, options?: ZipDataResultOptions): ZipDataResultItem<D, R>[] {\n  checkContext(context, ['after', 'around'], ['create', 'update', 'patch'])\n\n  const input = getDataIsArray(context)\n  const output = getResultIsArray(context)\n\n  if (\n    input.isArray &&\n    output.isArray &&\n    input.data.length !== output.result.length\n  ) {\n    options?.onMismatch?.(context)\n  }\n\n  const result: ZipDataResultItem<D, R>[] = []\n\n  const length = Math.max(input.data.length, output.result.length)\n\n  for (let i = 0; i < length; i++) {\n    const dataItem = input.isArray ? input.data.at(i) : input.data[0]\n    const resultItem = output.result.at(i)\n\n    result.push({\n      data: dataItem,\n      result: resultItem,\n    })\n  }\n\n  return result\n}\n"],"mappings":"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"}

package/dist/utils.d.mts

@@ -1,3 +1,3 @@
-import { A as SkipHookName, C as contextToJson, O as addToQuery, S as defineHooks, T as checkContext, _ as getResultIsArray, a as WalkQueryOptions, b as GetDataIsArrayReturn, c as transformParams, d as PatchBatchOptions, f as PatchBatchResultItem, g as GetResultIsArrayReturn, h as GetResultIsArrayOptions, i as WalkQueryCallback, j as addSkip, k as chunkFind, l as toPaginated, m as iterateFind, n as ZipDataResultOptions, o as walkQuery, p as patchBatch, r as zipDataResult, s as sortQueryProperties, t as ZipDataResultItem, u as skipResult, v as getPaginate, w as CheckContextOptions, x as getDataIsArray, y as getExposedMethods } from "./index-CNrzxmWo.mjs";
+import { C as GetDataIsArrayReturn, D as CheckContextOptions, E as contextToJson, M as chunkFind, N as SkipHookName, O as checkContext, P as addSkip, S as getExposedMethods, T as defineHooks, _ as iterateFind, a as WalkQueryOptions, b as getResultIsArray, c as transformParams, d as ReplaceResultOptions, f as replaceResult, g as patchBatch, h as PatchBatchResultItem, i as WalkQueryCallback, j as addToQuery, l as toPaginated, m as PatchBatchOptions, n as ZipDataResultOptions, o as walkQuery, p as replaceData, r as zipDataResult, s as sortQueryProperties, t as ZipDataResultItem, u as skipResult, v as GetResultIsArrayOptions, w as getDataIsArray, x as getPaginate, y as GetResultIsArrayReturn } from "./index-CgAuzxiv.mjs";
 import { n as mutateResult, r as mutateData, t as MutateResultOptions } from "./mutate-result.util-BIeYlqqT.mjs";
-export { CheckContextOptions, GetDataIsArrayReturn, GetResultIsArrayOptions, GetResultIsArrayReturn, MutateResultOptions, PatchBatchOptions, PatchBatchResultItem, SkipHookName, WalkQueryCallback, WalkQueryOptions, ZipDataResultItem, ZipDataResultOptions, addSkip, addToQuery, checkContext, chunkFind, contextToJson, defineHooks, getDataIsArray, getExposedMethods, getPaginate, getResultIsArray, iterateFind, mutateData, mutateResult, patchBatch, skipResult, sortQueryProperties, toPaginated, transformParams, walkQuery, zipDataResult };
+export { CheckContextOptions, GetDataIsArrayReturn, GetResultIsArrayOptions, GetResultIsArrayReturn, MutateResultOptions, PatchBatchOptions, PatchBatchResultItem, ReplaceResultOptions, SkipHookName, WalkQueryCallback, WalkQueryOptions, ZipDataResultItem, ZipDataResultOptions, addSkip, addToQuery, checkContext, chunkFind, contextToJson, defineHooks, getDataIsArray, getExposedMethods, getPaginate, getResultIsArray, iterateFind, mutateData, mutateResult, patchBatch, replaceData, replaceResult, skipResult, sortQueryProperties, toPaginated, transformParams, walkQuery, zipDataResult };

package/dist/utils.mjs

@@ -1,4 +1,4 @@
-import { f as getPaginate } from "./predicates-C2SeOKGd.mjs";
-import { a as skipResult, c as getExposedMethods, d as checkContext, f as addToQuery, h as sortQueryProperties, i as toPaginated, l as defineHooks, m as addSkip, n as walkQuery, o as patchBatch, p as chunkFind, r as transformParams, s as iterateFind, t as zipDataResult, u as contextToJson } from "./utils-ByzrJKGQ.mjs";
-import { i as getDataIsArray, n as mutateData, r as getResultIsArray, t as mutateResult } from "./mutate-result.util-CCBWix-G.mjs";
-export { addSkip, addToQuery, checkContext, chunkFind, contextToJson, defineHooks, getDataIsArray, getExposedMethods, getPaginate, getResultIsArray, iterateFind, mutateData, mutateResult, patchBatch, skipResult, sortQueryProperties, toPaginated, transformParams, walkQuery, zipDataResult };
+import { f as getPaginate } from "./predicates-BC8p_YLo.mjs";
+import { a as skipResult, c as getExposedMethods, d as checkContext, f as addToQuery, h as sortQueryProperties, i as toPaginated, l as defineHooks, m as addSkip, n as walkQuery, o as patchBatch, p as chunkFind, r as transformParams, s as iterateFind, t as zipDataResult, u as contextToJson } from "./utils-BrvpblXB.mjs";
+import { a as getResultIsArray, i as replaceData, n as replaceResult, o as getDataIsArray, r as mutateData, t as mutateResult } from "./mutate-result.util-B6FOkwrd.mjs";
+export { addSkip, addToQuery, checkContext, chunkFind, contextToJson, defineHooks, getDataIsArray, getExposedMethods, getPaginate, getResultIsArray, iterateFind, mutateData, mutateResult, patchBatch, replaceData, replaceResult, skipResult, sortQueryProperties, toPaginated, transformParams, walkQuery, zipDataResult };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "feathers-utils",
-  "version": "10.0.1",
+  "version": "10.0.2",
   "description": "Useful hooks and utils for use with feathers services.",
   "main": "./dist/index.mjs",
   "module": "./dist/index.mjs",

package/src/common/clone.ts

@@ -1,13 +1,15 @@
+import { copy } from 'fast-copy'
+
 /**
- * Deep-clones an object using `JSON.parse(JSON.stringify(...))`.
- * Simple and fast for JSON-serializable data, but does not handle
- * `Date` objects, `undefined` values, functions, or circular references.
+ * Deep-clones a value using `fast-copy`.
+ *
+ * Unlike a `JSON.parse(JSON.stringify(...))` round-trip, this correctly handles
+ * `Date`, `Map`, `Set`, `RegExp`, typed arrays, `undefined` values and circular
+ * references — all of which FeathersJS payloads routinely contain.
  *
  * @example
  * ```ts
- * const copy = clone({ name: 'Alice', nested: { value: 1 } })
+ * const copyOf = clone({ name: 'Alice', createdAt: new Date(), nested: { value: 1 } })
  * ```
  */
-export function clone(obj: any) {
-  return JSON.parse(JSON.stringify(obj))
-}
+export const clone = copy

package/src/hooks/cache/cache-utils.ts

@@ -1,30 +1,17 @@
-import isObject from 'lodash/isObject.js'
 import { sortQueryProperties } from '../../utils/sort-query-properties/sort-query-properties.util.js'
 
 export { sortQueryProperties }
 
 export const stableStringify = (obj: Record<string, any>) => {
-  if (obj.query) {
-    obj = { ...obj, query: sortQueryProperties(obj.query) }
-  }
+  // Canonicalize the whole params object once (recursive key-sort + operator-array
+  // sort). The JSON.stringify pass then only needs to reject non-JSON values
+  // instead of re-sorting and re-allocating every node.
+  const normalized = sortQueryProperties(obj as any)
 
-  return JSON.stringify(obj, (key, value) => {
+  return JSON.stringify(normalized, (_key, value) => {
     if (typeof value === 'function') {
       throw new Error('Cannot stringify non JSON value')
     }
-
-    if (isObject(value)) {
-      return Object.keys(value)
-        .sort()
-        .reduce(
-          (result, key) => {
-            result[key] = (value as any)[key]
-            return result
-          },
-          {} as Record<string, any>,
-        )
-    }
-
     return value
   })
 }

package/src/hooks/cache/cache.hook.ts

@@ -67,6 +67,16 @@ export type CacheOptions = {
    * ```
    */
   logger?: (event: CacheEvent) => void
+  /**
+   * How to clone results on store and on hit so callers can't mutate the shared
+   * cached object. Defaults to a `fast-copy` deep clone.
+   *
+   * Set to `false` to skip cloning entirely (fastest, but the caller MUST treat
+   * results as immutable), or pass a custom clone function (e.g. `structuredClone`).
+   *
+   * @default true
+   */
+  clone?: boolean | (<T>(value: T) => T)
 }
 
 /**
@@ -139,12 +149,19 @@ class ContextCacheMap {
   private options: CacheOptions
   private log: ((event: CacheEvent) => void) | undefined
   private serialize: (params: Params) => string
+  private clone: <T>(value: T) => T
 
   constructor(options: CacheOptions) {
     this.map = options.map
     this.options = options
     this.log = options.logger
     this.serialize = options.serialize ?? stableStringify
+    this.clone =
+      options.clone === false
+        ? (value) => value
+        : typeof options.clone === 'function'
+          ? options.clone
+          : copy
   }
 
   private stringifyCacheKey(context: HookContext) {
@@ -184,10 +201,10 @@ class ContextCacheMap {
    */
   async get(context: HookContext) {
     const key = this.stringifyCacheKey(context)
-    const result = this.map.get(key)
+    const result = await this.map.get(key)
     if (result) {
       this.log?.({ type: 'hit', method: context.method, key })
-      return copy(result) // Use copy to avoid mutation of the original result
+      return this.clone(result) // clone to avoid mutation of the cached result
     }
     this.log?.({ type: 'miss', method: context.method, key })
   }
@@ -200,7 +217,8 @@ class ContextCacheMap {
   async set(context: HookContext) {
     const key = this.stringifyCacheKey(context)
     this.log?.({ type: 'set', method: context.method, key })
-    return this.map.set(key, copy(context.result)) // Use copy to avoid mutation of the original result
+    // clone to avoid later mutation of the cached result
+    return this.map.set(key, this.clone(context.result))
   }
 
   // Called after create(), update(), patch(), and remove()
@@ -222,6 +240,9 @@ class ContextCacheMap {
       return context
     }
 
+    // O(1) membership instead of an O(itemIds) scan per cached key.
+    const idSet = new Set<string>(itemIds.map((id: any) => `${id}`))
+
     for (const key of this.map.keys()) {
       const cachedId = this.getCachedId(key)
       if (cachedId === 'null') {
@@ -239,12 +260,10 @@ class ContextCacheMap {
         continue
       }
 
-      for (const itemId of itemIds) {
-        if (cachedId === itemId) {
-          // If the cached id matches the item id, delete the cached get
-          this.log?.({ type: 'invalidate', method: context.method, key })
-          promises.push(this.map.delete(key))
-        }
+      if (idSet.has(cachedId)) {
+        // If the cached id matches a mutated item id, delete the cached get
+        this.log?.({ type: 'invalidate', method: context.method, key })
+        promises.push(this.map.delete(key))
       }
     }
 

package/src/hooks/disallow/disallow.hook.ts

@@ -31,7 +31,9 @@ export const disallow = <H extends HookContext = HookContext>(
   function hook(context: H): void
   function hook(context: H, next: NextFunction): Promise<void>
   function hook(context: H, next?: NextFunction): void | Promise<void> {
-    if (!transports) {
+    // No transports (undefined) or an empty list means "block completely".
+    // Fail closed for a guard hook rather than throwing a confusing internal error.
+    if (!transports || transportsArr.length === 0) {
       throw new MethodNotAllowed('Method not allowed')
     }
 

package/src/hooks/on-delete/on-delete.hook.ts

@@ -43,6 +43,12 @@ export interface OnDeleteOptions<
    * @default false
    */
   blocking?: boolean
+  /**
+   * Called when a non-blocking (`blocking: false`) related-service call rejects.
+   * Without this, fire-and-forget rejections are swallowed (but never leak as an
+   * unhandled rejection). In `blocking` mode the error is thrown to the caller instead.
+   */
+  onError?: (error: any, context: H) => void
 }
 
 /**
@@ -89,46 +95,60 @@ export const onDelete = <H extends HookContext = HookContext>(
       return
     }
 
-    const promises: Promise<any>[] = []
-
-    optionsMulti.forEach(
-      async ({ keyHere, keyThere, onDelete, service, blocking, query }) => {
-        let ids = result.map((x) => x[keyHere]).filter((x) => !!x)
-        ids = [...new Set(ids)]
-
-        if (!ids || ids.length <= 0) {
-          return
-        }
-
-        const params = {
-          query: {
-            ...query,
-            ...(ids.length === 1
-              ? { [keyThere]: ids[0] }
-              : { [keyThere]: { $in: ids } }),
-          },
-          paginate: false,
-        }
-
-        let promise: Promise<any> | undefined = undefined
-
-        if (onDelete === 'cascade') {
-          promise = context.app.service(service as string).remove(null, params)
-        } else if (onDelete === 'set null') {
-          const data = { [keyThere]: null }
-          promise = context.app
-            .service(service as string)
-            .patch(null, data, params)
-        }
-
-        if (promise && blocking) {
-          promises.push(promise)
-        }
-      },
-    )
-
-    if (promises.length) {
-      await Promise.all(promises)
+    const blockingPromises: Promise<any>[] = []
+
+    for (const {
+      keyHere,
+      keyThere,
+      onDelete,
+      service,
+      blocking,
+      query,
+      onError,
+    } of optionsMulti) {
+      let ids = result.map((x) => x[keyHere]).filter((x) => !!x)
+      ids = [...new Set(ids)]
+
+      if (!ids || ids.length <= 0) {
+        continue
+      }
+
+      const params = {
+        query: {
+          ...query,
+          ...(ids.length === 1
+            ? { [keyThere]: ids[0] }
+            : { [keyThere]: { $in: ids } }),
+        },
+        paginate: false,
+      }
+
+      let promise: Promise<any> | undefined = undefined
+
+      if (onDelete === 'cascade') {
+        promise = context.app.service(service as string).remove(null, params)
+      } else if (onDelete === 'set null') {
+        const data = { [keyThere]: null }
+        promise = context.app
+          .service(service as string)
+          .patch(null, data, params)
+      }
+
+      if (!promise) {
+        continue
+      }
+
+      if (blocking) {
+        blockingPromises.push(promise)
+      } else {
+        // fire-and-forget: always attach a catch so a rejection never becomes
+        // an unhandled promise rejection. Surface it via `onError` if provided.
+        promise.catch((error) => onError?.(error, context))
+      }
+    }
+
+    if (blockingPromises.length) {
+      await Promise.all(blockingPromises)
     }
 
     return

package/src/hooks/params-for-server/params-for-server.hook.ts

@@ -64,6 +64,10 @@ export const paramsForServer = (
 
         if (!clonedParams.query[keyToHide]) {
           clonedParams.query[keyToHide] = {}
+        } else {
+          // The shallow query copy still aliases a pre-existing key object;
+          // clone it so we don't mutate the caller's original params.
+          clonedParams.query[keyToHide] = { ...clonedParams.query[keyToHide] }
         }
 
         clonedParams.query[keyToHide][key] = clonedParams[key]

package/src/hooks/set-field/set-field.hook.ts

@@ -6,9 +6,23 @@ import type { FeathersError } from '@feathersjs/errors'
 import { Forbidden } from '@feathersjs/errors'
 import type { HookContext, NextFunction } from '@feathersjs/feathers'
 
-export interface SetFieldOptions {
-  as: string
-  from: string
+export interface SetFieldOptions<H extends HookContext = HookContext> {
+  /**
+   * The target path(s) to set. Pass an array to write the same value to several
+   * paths (e.g. multiple query keys).
+   *
+   * @example 'params.query.userId'
+   * @example ['params.query.userId', 'params.query.ownerId']
+   */
+  as: string | string[]
+  /**
+   * The source of the value: a `dot.notation` path on the context, or a function
+   * that derives the value from the context.
+   *
+   * @example 'params.user.id'
+   * @example (context) => context.params.user?.id
+   */
+  from: string | ((context: H) => unknown)
   /**
    * If set to `true`, allows the field to be undefined.
    * If the field is not available and this is `true`, the hook will not throw an error.
@@ -23,7 +37,10 @@ export interface SetFieldOptions {
    *
    * If not provided, throws a `Forbidden` error with a message indicating the missing field.
    */
-  error?: (context: HookContext, from: string) => FeathersError
+  error?: (
+    context: H,
+    from: string | ((context: H) => unknown),
+  ) => FeathersError
 }
 
 /**
@@ -47,7 +64,9 @@ export const setField = <H extends HookContext = HookContext>({
   from,
   allowUndefined = false,
   error,
-}: SetFieldOptions) => {
+}: SetFieldOptions<H>) => {
+  const targets = Array.isArray(as) ? as : [as]
+
   function hook(context: H): void
   function hook(context: H, next: NextFunction): Promise<void>
   function hook(context: H, next?: NextFunction): void | Promise<void> {
@@ -55,7 +74,8 @@ export const setField = <H extends HookContext = HookContext>({
 
     checkContext(context, { type: ['before', 'around'], label: 'setField' })
 
-    const value = _get(context, from)
+    const value =
+      typeof from === 'function' ? from(context) : _get(context, from)
 
     if (value === undefined) {
       if (!params.provider || allowUndefined) {
@@ -65,10 +85,12 @@ export const setField = <H extends HookContext = HookContext>({
 
       throw error
         ? error(context, from)
-        : new Forbidden(`Expected field ${as} not available`)
+        : new Forbidden(`Expected field ${targets.join(', ')} not available`)
     }
 
-    _setWith(context, as, value, _clone)
+    for (const target of targets) {
+      _setWith(context, target, value, _clone)
+    }
 
     if (next) return next()