feathers-utils 10.2.0 → 10.4.0

package/dist/{utils-BAIcSl7u.mjs → utils-sTvj8-Jy.mjs}

@@ -1,6 +1,6 @@
-import { r as toArray } from "./internal.utils-BMzV_-xp.mjs";
-import { d as isPaginated, m as isContext, p as isMulti } from "./predicates-puYa4nkf.mjs";
-import { a as getResultIsArray, o as getDataIsArray } from "./mutate-result.util-Dqzepn1M.mjs";
+import { a as flattenOrBranches, c as isEmptyObject, o as flattenAndBranches, r as toArray, s as dedupeBranches } from "./internal.utils-CWuBYzpQ.mjs";
+import { d as isPaginated, m as isContext, p as isMulti } from "./predicates-CR4O2nSr.mjs";
+import { a as getResultIsArray, o as getDataIsArray } from "./mutate-result.util-mxvMl6bw.mjs";
 import { dequal } from "dequal";
 import * as feathers from "@feathersjs/feathers";
 //#region src/utils/sort-query-properties/sort-query-properties.util.ts
@@ -89,58 +89,13 @@ const addSkip = (context, hooks) => {
 	}
 };
 //#endregion
-//#region src/utils/chunk-find/chunk-find.util.ts
-/**
-* Use `for await` to iterate over chunks (pages) of results from a `find` method.
-*
-* This function is useful for processing large datasets in batches without loading everything into memory at once.
-* It uses pagination to fetch results in chunks, yielding each page's data array.
-*
-* @example
-* ```ts
-* import { chunkFind } from 'feathers-utils/utils'
-*
-* const app = feathers()
-*
-* // Assuming 'users' service has many records
-* for await (const users of chunkFind(app, 'users', {
-*  params: { query: { active: true }, // Custom query parameters
-* } })) {
-*  console.log(users) // Process each chunk of user records
-* }
-* ```
-*
-* @see https://utils.feathersjs.com/utils/chunk-find.html
-*/
-async function* chunkFind(app, servicePath, options) {
-	const service = app.service(servicePath);
-	if (!service || !("find" in service)) throw new Error(`Service '${servicePath}' does not have a 'find' method.`);
-	const params = {
-		...options?.params,
-		query: {
-			...options?.params?.query ?? {},
-			$limit: options?.params?.query?.$limit ?? 10,
-			$skip: options?.params?.query?.$skip ?? 0
-		},
-		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;
-		yield result.data;
-		params.query.$skip = (params.query.$skip ?? 0) + result.data.length;
-	} while (result.total > params.query.$skip);
-}
-//#endregion
 //#region src/utils/add-to-query/add-to-query.util.ts
 /**
 * Safely merges properties into a Feathers query object. If a property already exists
 * with a different value, it wraps both in a `$and` array to preserve both conditions.
-* If the exact same key-value pair already exists, no changes are made.
+* If the exact same key-value pair already exists, no changes are made. When the added
+* query is itself a pure `$and` (`{ $and: [...] }`), its branches are flattened into the
+* target's `$and` rather than nested.
 *
 * @example
 * ```ts
@@ -165,6 +120,15 @@ function addToQuery(targetQuery, query) {
 		return entries.every(([property, value]) => property in targetQuery && dequal(targetQuery[property], value));
 	}
 	if (isAlreadyInQuery(targetQuery, entries)) return targetQuery;
+	if (entries.length === 1 && Array.isArray(query.$and)) {
+		const existing = targetQuery.$and ?? [];
+		const newBranches = query.$and.filter((branch) => !existing.some((q) => dequal(q, branch)));
+		if (newBranches.length === 0) return targetQuery;
+		return {
+			...targetQuery,
+			$and: [...existing, ...newBranches]
+		};
+	}
 	if (!targetQuery.$and) return {
 		...targetQuery,
 		$and: [{ ...query }]
@@ -200,6 +164,53 @@ function checkContext(context, typeOrOptions, methods, label = "anonymous") {
 	}
 }
 //#endregion
+//#region src/utils/chunk-find/chunk-find.util.ts
+/**
+* Use `for await` to iterate over chunks (pages) of results from a `find` method.
+*
+* This function is useful for processing large datasets in batches without loading everything into memory at once.
+* It uses pagination to fetch results in chunks, yielding each page's data array.
+*
+* @example
+* ```ts
+* import { chunkFind } from 'feathers-utils/utils'
+*
+* const app = feathers()
+*
+* // Assuming 'users' service has many records
+* for await (const users of chunkFind(app, 'users', {
+*  params: { query: { active: true }, // Custom query parameters
+* } })) {
+*  console.log(users) // Process each chunk of user records
+* }
+* ```
+*
+* @see https://utils.feathersjs.com/utils/chunk-find.html
+*/
+async function* chunkFind(app, servicePath, options) {
+	const service = app.service(servicePath);
+	if (!service || !("find" in service)) throw new Error(`Service '${servicePath}' does not have a 'find' method.`);
+	const params = {
+		...options?.params,
+		query: {
+			...options?.params?.query ?? {},
+			$limit: options?.params?.query?.$limit ?? 10,
+			$skip: options?.params?.query?.$skip ?? 0
+		},
+		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;
+		yield result.data;
+		params.query.$skip = (params.query.$skip ?? 0) + result.data.length;
+	} while (result.total > params.query.$skip);
+}
+//#endregion
 //#region src/utils/context-to-json/context-to-json.util.ts
 /**
 * Converts a FeathersJS HookContext to a plain JSON object by calling `toJSON()` if available.
@@ -315,6 +326,253 @@ async function* iterateFind(app, servicePath, options) {
 	} while (result.total > params.query.$skip);
 }
 //#endregion
+//#region src/utils/simplify-query/merge-and-branches-up.ts
+/**
+* `$and` is an implicit AND with the rest of the query, so ALL of its branches can
+* be merged up into the parent at once — as long as no key would be set to two
+* different values (across the branches or the existing keys). On any such collision
+* the `$and` is kept intact. Internal helper for {@link simplifyQuery}.
+*/
+function mergeAndBranchesUp(result, enabled) {
+	if (!enabled || !Array.isArray(result.$and) || result.$and.length === 0) return result;
+	const rest = { ...result };
+	delete rest.$and;
+	const seen = new Map(Object.entries(rest));
+	for (const branch of result.$and) for (const [key, value] of Object.entries(branch)) {
+		if (seen.has(key) && !dequal(seen.get(key), value)) return result;
+		seen.set(key, value);
+	}
+	return Object.assign(rest, ...result.$and);
+}
+//#endregion
+//#region src/utils/simplify-query/merge-or-branch-up.ts
+/**
+* `$or` is a disjunction, so only a *single* branch can be merged up (an `$or` of
+* one is just that branch) — and only when no key would collide. This is the key
+* asymmetry with `$and` ({@link mergeAndBranchesUp}). Internal helper for
+* {@link simplifyQuery}.
+*/
+function mergeOrBranchUp(result, enabled) {
+	if (!enabled || !Array.isArray(result.$or) || result.$or.length !== 1) return result;
+	const branch = result.$or[0];
+	const rest = { ...result };
+	delete rest.$or;
+	for (const key of Object.keys(branch)) if (key in rest && !dequal(rest[key], branch[key])) return result;
+	return {
+		...rest,
+		...branch
+	};
+}
+//#endregion
+//#region src/utils/simplify-query/simplify-query.util.ts
+/**
+* Normalizes the logical structure of a Feathers query without changing what it
+* matches: empty `$and`/`$or` are dropped, duplicate branches removed, nested
+* same-operator branches hoisted (`$and`-in-`$and`, pure `$or`-in-`$or`), and
+* branches merged up into the parent where it is safe — all of an `$and` when no
+* key collides, a single-branch `$or`. Runs recursively. Inputs are not mutated;
+* a query with nothing to simplify is returned unchanged.
+*
+* @param query the query to simplify (a falsy query is returned as-is)
+* @param options
+* @returns the simplified query
+*
+* @example
+* ```ts
+* import { simplifyQuery } from 'feathers-utils/utils'
+*
+* // non-colliding $and branches (here also a hoisted nested $and) merge up
+* simplifyQuery({ $and: [{ id: 1 }, { $and: [{ status: 'a' }] }] })
+* // => { id: 1, status: 'a' }
+*
+* simplifyQuery({ $or: [{ id: 1 }] })
+* // => { id: 1 }
+*
+* // a colliding key keeps the $and intact
+* simplifyQuery({ $and: [{ price: { $gt: 1 } }, { price: { $lt: 9 } }] })
+* // => { $and: [{ price: { $gt: 1 } }, { price: { $lt: 9 } }] }
+* ```
+*
+* @see https://utils.feathersjs.com/utils/simplify-query.html
+*/
+function simplifyQuery(query, options = {}) {
+	const { replaceAnd = true, replaceOr = true } = options;
+	return simplify(query, replaceAnd, replaceOr);
+}
+function simplify(query, replaceAnd, replaceOr) {
+	if (!query || typeof query !== "object" || Array.isArray(query)) return query;
+	const hasAnd = Array.isArray(query.$and);
+	const hasOr = Array.isArray(query.$or);
+	if (!hasAnd && !hasOr) return query;
+	const { $and, $or, ...rest } = query;
+	const result = { ...rest };
+	if (hasAnd) {
+		const branches = dedupeBranches(flattenAndBranches($and.map((b) => simplify(b, true, true))));
+		if (branches.length > 0) result.$and = branches;
+	}
+	if (hasOr) {
+		const simplified = $or.map((b) => simplify(b, true, true));
+		if (!simplified.some(isEmptyObject)) {
+			const branches = dedupeBranches(flattenOrBranches(simplified));
+			if (branches.length > 0) result.$or = branches;
+		}
+	}
+	return mergeOrBranchUp(mergeAndBranchesUp(result, replaceAnd), replaceOr);
+}
+//#endregion
+//#region src/utils/merge-query/extract-query-filters.ts
+/**
+* Splits a query into its special filters ($select, $limit, $skip, $sort) and the
+* remaining query body. Internal helper for {@link mergeQuery} — not part of the
+* public API.
+*/
+function extractQueryFilters(providedQuery) {
+	providedQuery ??= {};
+	const { $select, $limit, $skip, $sort, ...query } = providedQuery;
+	const result = { query };
+	if ("$select" in providedQuery) result.$select = $select;
+	if ("$limit" in providedQuery) result.$limit = $limit;
+	if ("$skip" in providedQuery) result.$skip = $skip;
+	if ("$sort" in providedQuery) result.$sort = $sort;
+	return result;
+}
+//#endregion
+//#region src/utils/merge-query/logical-branches.ts
+/**
+* Returns the branches of a logical-only query (a query whose single key is `op`),
+* or `null` when the query is not purely `{ [op]: [...] }`. Internal helper for
+* {@link mergeQuery}.
+*/
+function logicalBranches(query, op) {
+	const keys = Object.keys(query);
+	if (keys.length === 1 && keys[0] === op && Array.isArray(query[op])) return query[op];
+	return null;
+}
+//#endregion
+//#region src/utils/merge-query/has-conflict.ts
+/**
+* Two query bodies conflict when they share at least one key whose values are not
+* deep-equal. Internal helper for {@link mergeQuery}.
+*/
+function hasConflict(target, source) {
+	for (const key of Object.keys(target)) if (key in source && !dequal(target[key], source[key])) return true;
+	return false;
+}
+//#endregion
+//#region src/utils/merge-query/merge-query-bodies.ts
+/**
+* Merges two query bodies (filters already removed) according to the mode.
+* Internal helper for {@link mergeQuery}.
+*
+* - `target` / `source`: precedence merge (that side wins on conflict).
+* - `combine`: the two bodies always become branches of a single `$or`.
+* - `intersect`: non-conflicting bodies merge flat; on conflict they become
+*   branches of a single `$and`.
+*
+* Logical-only bodies (`{ $or: [...] }` for combine, `{ $and: [...] }` for
+* intersect) are flattened into the result and their branches de-duplicated.
+*/
+function mergeQueryBodies(target, source, mode) {
+	if (mode === "target") return {
+		...source,
+		...target
+	};
+	if (mode === "source") return {
+		...target,
+		...source
+	};
+	if (isEmptyObject(target)) return { ...source };
+	if (isEmptyObject(source)) return { ...target };
+	const op = mode === "combine" ? "$or" : "$and";
+	const targetBranches = logicalBranches(target, op);
+	const sourceBranches = logicalBranches(source, op);
+	if (op === "$and" && !targetBranches && !sourceBranches && !hasConflict(target, source)) return {
+		...target,
+		...source
+	};
+	const collected = [...targetBranches ?? [target], ...sourceBranches ?? [source]];
+	const branches = dedupeBranches(op === "$and" ? flattenAndBranches(collected) : collected);
+	if (branches.length === 0) return {};
+	if (branches.length === 1) return { ...branches[0] };
+	return { [op]: branches };
+}
+//#endregion
+//#region src/utils/merge-query/merge-select.ts
+/**
+* Merges two `$select` filters according to the mode: `combine` → union,
+* `intersect` → intersection, `target`/`source` → that side. When only one side
+* provides a `$select`, that one is used. Internal helper for {@link mergeQuery}.
+*/
+function mergeSelect(target, source, mode) {
+	if (target === void 0) return source;
+	if (source === void 0) return target;
+	if (mode === "target") return target;
+	if (mode === "source") return source;
+	const targetArr = Array.isArray(target) ? target : [target];
+	const sourceArr = Array.isArray(source) ? source : [source];
+	if (mode === "combine") return [...new Set([...targetArr, ...sourceArr])];
+	return targetArr.filter((value) => sourceArr.includes(value));
+}
+//#endregion
+//#region src/utils/merge-query/merge-query.util.ts
+/**
+* Properties are combined with a logical operator rather than merged at the value
+* level, so the result is always a valid query: `combine` always wraps the two
+* queries in `$or` (broaden — OR has no flat form), while `intersect` merges
+* non-conflicting properties flat and wraps conflicts in `$and` (narrow). The
+* special filters `$select`, `$limit`, `$skip` and `$sort` are merged separately.
+* Inputs are never mutated.
+*
+* This is well suited to merging a client-provided query with a server-side
+* restriction inside a hook.
+*
+* @param target Query to be merged into
+* @param source Query to be merged from
+* @param options
+* @returns the merged query
+*
+* @example
+* ```ts
+* import { mergeQuery } from 'feathers-utils/utils'
+*
+* // combine (default): the two queries always become an $or
+* mergeQuery({ id: 1 }, { id: 2 })
+* // => { $or: [{ id: 1 }, { id: 2 }] }
+*
+* mergeQuery({ status: 'active' }, { authorId: 5 })
+* // => { $or: [{ status: 'active' }, { authorId: 5 }] }
+* ```
+*
+* @example
+* ```ts
+* // intersect: non-conflicting properties merge flat, conflicts become an $and
+* mergeQuery({ status: 'active' }, { authorId: 5 }, { mode: 'intersect' })
+* // => { status: 'active', authorId: 5 }
+*
+* mergeQuery({ id: 1 }, { id: 2 }, { mode: 'intersect' })
+* // => { $and: [{ id: 1 }, { id: 2 }] }
+* ```
+*
+* @see https://utils.feathersjs.com/utils/merge-query.html
+*/
+function mergeQuery(target, source, options) {
+	const mode = options?.mode ?? "combine";
+	const targetFilters = extractQueryFilters(simplifyQuery(target));
+	const sourceFilters = extractQueryFilters(simplifyQuery(source));
+	const result = mergeQueryBodies(targetFilters.query, sourceFilters.query, mode);
+	const $select = mergeSelect(targetFilters.$select, sourceFilters.$select, mode);
+	if ($select !== void 0) result.$select = $select;
+	if ("$limit" in sourceFilters) result.$limit = sourceFilters.$limit;
+	else if ("$limit" in targetFilters) result.$limit = targetFilters.$limit;
+	if ("$skip" in sourceFilters) result.$skip = sourceFilters.$skip;
+	else if ("$skip" in targetFilters) result.$skip = targetFilters.$skip;
+	if ("$sort" in targetFilters || "$sort" in sourceFilters) result.$sort = {
+		...targetFilters.$sort,
+		...sourceFilters.$sort
+	};
+	return result;
+}
+//#endregion
 //#region src/utils/patch-batch/patch-batch.util.ts
 /**
 * Deterministic, key-order-independent serialization used to group items with
@@ -378,162 +636,6 @@ function patchBatch(items, options) {
 	});
 }
 //#endregion
-//#region src/utils/skip-result/skip-result.util.ts
-/**
-* Sets `context.result` to an appropriate empty value based on the hook method.
-* Returns an empty paginated object for paginated `find`, an empty array for multi
-* operations, or `null` for single-item operations. Does nothing if a result already exists.
-*
-* @example
-* ```ts
-* import { skipResult } from 'feathers-utils/utils'
-*
-* // In a before hook to skip the actual database call:
-* skipResult(context)
-* ```
-*
-* @see https://utils.feathersjs.com/utils/skip-result.html
-*/
-const skipResult = (context) => {
-	if (context.result) return context;
-	if (isMulti(context)) if (context.method === "find" && isPaginated(context)) context.result = {
-		total: 0,
-		skip: 0,
-		limit: 0,
-		data: []
-	};
-	else context.result = [];
-	else context.result = null;
-	return context;
-};
-//#endregion
-//#region src/utils/to-paginated/to-paginated.util.ts
-/**
-* Ensures a result is in Feathers paginated format (`{ total, limit, skip, data }`).
-* If the input is already paginated, it is returned as-is. If it is a plain array,
-* it is wrapped in a paginated object with `total` and `limit` set to the array length.
-*
-* @example
-* ```ts
-* import { toPaginated } from 'feathers-utils/utils'
-*
-* const paginated = toPaginated([{ id: 1 }, { id: 2 }])
-* // => { total: 2, limit: 2, skip: 0, data: [{ id: 1 }, { id: 2 }] }
-* ```
-*
-* @see https://utils.feathersjs.com/utils/to-paginated.html
-*/
-function toPaginated(result) {
-	if (Array.isArray(result)) return {
-		total: result.length,
-		limit: result.length,
-		skip: 0,
-		data: result
-	};
-	return result;
-}
-//#endregion
-//#region src/utils/transform-params/transform-params.util.ts
-/**
-* Safely applies a `transformParams` function to a params object.
-* If no function is provided, the original params are returned unchanged.
-* The function receives a shallow copy of params, so the original is not mutated.
-*
-* @example
-* ```ts
-* import { transformParams } from 'feathers-utils/utils'
-*
-* const params = transformParams(context.params, (p) => { delete p.provider; return p })
-* ```
-*
-* @see https://utils.feathersjs.com/utils/transform-params.html
-*/
-const transformParams = (params, fn) => {
-	if (!fn) return params;
-	return fn({ ...params }) ?? params;
-};
-//#endregion
-//#region src/utils/wait-for-service-event/wait-for-service-event.util.ts
-/**
-* Wait for a service event to fire and resolve with the emitted record. Useful
-* in tests to await the result of an asynchronous service event, a bit like
-* `promisify` for Feathers events.
-*
-* Curried: bind the `app` (and optional defaults) once, then call the returned
-* function per service/event. Resolves with a `[data, { event, context }]`
-* tuple: `data` is typed as the service's record type, and `event` is the union
-* of the requested events.
-*
-* Feathers emits events as `emit(event, record, context)` and fires one event
-* per record, so each resolution carries a single record and its `HookContext`.
-*
-* @example
-* ```ts
-* import { waitForServiceEvent } from 'feathers-utils/utils'
-*
-* const app = feathers()
-* const waitForEvent = waitForServiceEvent(app)
-*
-* // Wait for the next `users` record to be created.
-* const [user] = await waitForEvent('users', 'created')
-*
-* // Wait for a specific record, with a custom timeout and filter.
-* const [data, { event }] = await waitForEvent(
-*   'users',
-*   ['created', 'patched'],
-*   { filter: (user) => user.email === 'jane@example.com', timeout: 1000 },
-* )
-* ```
-*
-* @see https://utils.feathersjs.com/utils/wait-for-service-event.html
-*/
-function waitForServiceEvent(app, defaultOptions) {
-	return function waitForEvent(servicePath, eventOrEvents, options) {
-		const events = Array.isArray(eventOrEvents) ? eventOrEvents : [eventOrEvents];
-		const timeout = options?.timeout ?? defaultOptions?.timeout ?? 5e3;
-		const filter = options?.filter;
-		const signal = options?.signal ?? defaultOptions?.signal;
-		const service = app.service(servicePath);
-		return new Promise((resolve, reject) => {
-			let timer;
-			const listeners = events.map((event) => {
-				const listener = (data, context) => {
-					if (filter && !filter(data, context)) return;
-					cleanup();
-					resolve([data, {
-						event,
-						context
-					}]);
-				};
-				return [event, listener];
-			});
-			const abortError = () => signal?.reason ?? /* @__PURE__ */ new Error(`Aborted waiting for event "${events.join(", ")}" on service "${String(servicePath)}"`);
-			const onAbort = () => {
-				cleanup();
-				reject(abortError());
-			};
-			function cleanup() {
-				if (timer) {
-					clearTimeout(timer);
-					timer = void 0;
-				}
-				for (const [event, listener] of listeners) service.off(event, listener);
-				signal?.removeEventListener("abort", onAbort);
-			}
-			if (signal?.aborted) {
-				reject(abortError());
-				return;
-			}
-			if (timeout !== false) timer = setTimeout(() => {
-				cleanup();
-				reject(/* @__PURE__ */ new Error(`Timeout waiting for event "${events.join(", ")}" on service "${String(servicePath)}"`));
-			}, timeout);
-			signal?.addEventListener("abort", onAbort, { once: true });
-			for (const [event, listener] of listeners) service.on(event, listener);
-		});
-	};
-}
-//#endregion
 //#region src/utils/walk-query/walk-query.util.ts
 const _walkQueryUtil = (query, walker, state, options) => {
 	const stop = () => {
@@ -711,6 +813,162 @@ const queryDefaults = (query, defaults) => {
 	return addToQuery(source, toAdd);
 };
 //#endregion
+//#region src/utils/skip-result/skip-result.util.ts
+/**
+* Sets `context.result` to an appropriate empty value based on the hook method.
+* Returns an empty paginated object for paginated `find`, an empty array for multi
+* operations, or `null` for single-item operations. Does nothing if a result already exists.
+*
+* @example
+* ```ts
+* import { skipResult } from 'feathers-utils/utils'
+*
+* // In a before hook to skip the actual database call:
+* skipResult(context)
+* ```
+*
+* @see https://utils.feathersjs.com/utils/skip-result.html
+*/
+const skipResult = (context) => {
+	if (context.result) return context;
+	if (isMulti(context)) if (context.method === "find" && isPaginated(context)) context.result = {
+		total: 0,
+		skip: 0,
+		limit: 0,
+		data: []
+	};
+	else context.result = [];
+	else context.result = null;
+	return context;
+};
+//#endregion
+//#region src/utils/to-paginated/to-paginated.util.ts
+/**
+* Ensures a result is in Feathers paginated format (`{ total, limit, skip, data }`).
+* If the input is already paginated, it is returned as-is. If it is a plain array,
+* it is wrapped in a paginated object with `total` and `limit` set to the array length.
+*
+* @example
+* ```ts
+* import { toPaginated } from 'feathers-utils/utils'
+*
+* const paginated = toPaginated([{ id: 1 }, { id: 2 }])
+* // => { total: 2, limit: 2, skip: 0, data: [{ id: 1 }, { id: 2 }] }
+* ```
+*
+* @see https://utils.feathersjs.com/utils/to-paginated.html
+*/
+function toPaginated(result) {
+	if (Array.isArray(result)) return {
+		total: result.length,
+		limit: result.length,
+		skip: 0,
+		data: result
+	};
+	return result;
+}
+//#endregion
+//#region src/utils/transform-params/transform-params.util.ts
+/**
+* Safely applies a `transformParams` function to a params object.
+* If no function is provided, the original params are returned unchanged.
+* The function receives a shallow copy of params, so the original is not mutated.
+*
+* @example
+* ```ts
+* import { transformParams } from 'feathers-utils/utils'
+*
+* const params = transformParams(context.params, (p) => { delete p.provider; return p })
+* ```
+*
+* @see https://utils.feathersjs.com/utils/transform-params.html
+*/
+const transformParams = (params, fn) => {
+	if (!fn) return params;
+	return fn({ ...params }) ?? params;
+};
+//#endregion
+//#region src/utils/wait-for-service-event/wait-for-service-event.util.ts
+/**
+* Wait for a service event to fire and resolve with the emitted record. Useful
+* in tests to await the result of an asynchronous service event, a bit like
+* `promisify` for Feathers events.
+*
+* Curried: bind the `app` (and optional defaults) once, then call the returned
+* function per service/event. Resolves with a `[data, { event, context }]`
+* tuple: `data` is typed as the service's record type, and `event` is the union
+* of the requested events.
+*
+* Feathers emits events as `emit(event, record, context)` and fires one event
+* per record, so each resolution carries a single record and its `HookContext`.
+*
+* @example
+* ```ts
+* import { waitForServiceEvent } from 'feathers-utils/utils'
+*
+* const app = feathers()
+* const waitForEvent = waitForServiceEvent(app)
+*
+* // Wait for the next `users` record to be created.
+* const [user] = await waitForEvent('users', 'created')
+*
+* // Wait for a specific record, with a custom timeout and filter.
+* const [data, { event }] = await waitForEvent(
+*   'users',
+*   ['created', 'patched'],
+*   { filter: (user) => user.email === 'jane@example.com', timeout: 1000 },
+* )
+* ```
+*
+* @see https://utils.feathersjs.com/utils/wait-for-service-event.html
+*/
+function waitForServiceEvent(app, defaultOptions) {
+	return function waitForEvent(servicePath, eventOrEvents, options) {
+		const events = Array.isArray(eventOrEvents) ? eventOrEvents : [eventOrEvents];
+		const timeout = options?.timeout ?? defaultOptions?.timeout ?? 5e3;
+		const filter = options?.filter;
+		const signal = options?.signal ?? defaultOptions?.signal;
+		const service = app.service(servicePath);
+		return new Promise((resolve, reject) => {
+			let timer;
+			const listeners = events.map((event) => {
+				const listener = (data, context) => {
+					if (filter && !filter(data, context)) return;
+					cleanup();
+					resolve([data, {
+						event,
+						context
+					}]);
+				};
+				return [event, listener];
+			});
+			const abortError = () => signal?.reason ?? /* @__PURE__ */ new Error(`Aborted waiting for event "${events.join(", ")}" on service "${String(servicePath)}"`);
+			const onAbort = () => {
+				cleanup();
+				reject(abortError());
+			};
+			function cleanup() {
+				if (timer) {
+					clearTimeout(timer);
+					timer = void 0;
+				}
+				for (const [event, listener] of listeners) service.off(event, listener);
+				signal?.removeEventListener("abort", onAbort);
+			}
+			if (signal?.aborted) {
+				reject(abortError());
+				return;
+			}
+			if (timeout !== false) timer = setTimeout(() => {
+				cleanup();
+				reject(/* @__PURE__ */ new Error(`Timeout waiting for event "${events.join(", ")}" on service "${String(servicePath)}"`));
+			}, timeout);
+			signal?.addEventListener("abort", onAbort, { once: true });
+			for (const [event, listener] of listeners) service.on(event, listener);
+		});
+	};
+}
+//#endregion
 //#region src/utils/zip-data-result/zip-data-result.util.ts
 /**
 * Pairs each item in `context.data` with its corresponding item in `context.result` by index.
@@ -749,6 +1007,6 @@ function zipDataResult(context, options) {
 	return result;
 }
 //#endregion
-export { addSkip as _, waitForServiceEvent as a, skipResult as c, getExposedMethods as d, defineHooks as f, chunkFind as g, addToQuery as h, walkQuery as i, patchBatch as l, checkContext as m, queryDefaults as n, transformParams as o, contextToJson as p, queryHasProperty as r, toPaginated as s, zipDataResult as t, iterateFind as u, sortQueryProperties as v };
+export { checkContext as _, skipResult as a, sortQueryProperties as b, walkQuery as c, simplifyQuery as d, iterateFind as f, chunkFind as g, contextToJson as h, toPaginated as i, patchBatch as l, defineHooks as m, waitForServiceEvent as n, queryDefaults as o, getExposedMethods as p, transformParams as r, queryHasProperty as s, zipDataResult as t, mergeQuery as u, addToQuery as v, addSkip as y };
 
-//# sourceMappingURL=utils-BAIcSl7u.mjs.map
+//# sourceMappingURL=utils-sTvj8-Jy.mjs.map