feathers-utils 10.0.0-rc.8 → 10.0.0

package/dist/guards.mjs

@@ -25,7 +25,7 @@
 function hasQuery(params) {
 	return !!params.query;
 }
-
 //#endregion
 export { hasQuery };
+
 //# sourceMappingURL=guards.mjs.map

package/dist/guards.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"guards.mjs","names":[],"sources":["../src/guards/has-query/has-query.guard.ts"],"sourcesContent":["import type { Params } from '@feathersjs/feathers'\nimport type { RequiredQuery } from '../../utility-types/required-query.js'\n\n/**\n * Type guard to check if the `query` property of `Params` is present and non-nullable.\n *\n * @param params - The `Params` object to check.\n * @returns `true` if `params.query` is present and non-nullable, otherwise `false`.\n *\n * @see https://utils.feathersjs.com/guards/has-query.html\n *\n * @example\n * ```ts\n * import { hasQuery } from 'feathers-utils/guards'\n *\n * function example(params: Params) {\n *   // `params.query` is optional and can be undefined at this point\n *   if (!hasQuery(params)) {\n *     return;\n *   }\n *\n *   // TypeScript now knows that params.query is present and non-nullable\n *   // You can safely access params.query here without additional checks\n * }\n * ```\n */\nexport function hasQuery<P extends Params>(\n  params: P,\n): params is RequiredQuery<P> {\n  return !!params.query\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AA0BA,SAAgB,SACd,QAC4B;AAC5B,QAAO,CAAC,CAAC,OAAO"}
+{"version":3,"file":"guards.mjs","names":[],"sources":["../src/guards/has-query/has-query.guard.ts"],"sourcesContent":["import type { Params } from '@feathersjs/feathers'\nimport type { RequiredQuery } from '../../utility-types/required-query.js'\n\n/**\n * Type guard to check if the `query` property of `Params` is present and non-nullable.\n *\n * @param params - The `Params` object to check.\n * @returns `true` if `params.query` is present and non-nullable, otherwise `false`.\n *\n * @see https://utils.feathersjs.com/guards/has-query.html\n *\n * @example\n * ```ts\n * import { hasQuery } from 'feathers-utils/guards'\n *\n * function example(params: Params) {\n *   // `params.query` is optional and can be undefined at this point\n *   if (!hasQuery(params)) {\n *     return;\n *   }\n *\n *   // TypeScript now knows that params.query is present and non-nullable\n *   // You can safely access params.query here without additional checks\n * }\n * ```\n */\nexport function hasQuery<P extends Params>(\n  params: P,\n): params is RequiredQuery<P> {\n  return !!params.query\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AA0BA,SAAgB,SACd,QAC4B;CAC5B,OAAO,CAAC,CAAC,OAAO"}

package/dist/hook-context-aHkq1h0N.d.mts

@@ -0,0 +1,51 @@
+import { HookContext, NextFunction, Paginated, Params } from "@feathersjs/feathers";
+
+//#region src/internal.utils.d.ts
+type MaybeArray<T> = T | readonly T[];
+type UnpackMaybeArray<T> = T extends readonly (infer E)[] ? E : T;
+type Promisable<T> = T | Promise<T>;
+type KeyOf<T> = Extract<keyof T, string>;
+type UnwrapArray<T> = T extends Array<infer U> ? U : T;
+type IsAny<T> = 0 extends 1 & T ? true : false;
+type AnyFallback<T, Fallback> = IsAny<T> extends true ? Fallback : T;
+type NeverFallback<Never, Fallback> = [Never] extends [never] ? Fallback : Never;
+type KeyOfOrDotNotation<D> = KeyOf<D> | `${KeyOf<D>}.${string}`;
+//#endregion
+//#region src/types.d.ts
+declare const hookTypes: readonly ["around", "before", "after", "error"];
+type HookType$1 = (typeof hookTypes)[number];
+declare const methodNames: readonly ["find", "get", "create", "update", "patch", "remove"];
+type MethodName = (typeof methodNames)[number] | ({} & string);
+type TransportName = 'socketio' | 'rest' | 'external' | 'server';
+type ContextFunctionSync<T, H extends HookContext = HookContext> = (context: H) => T;
+type ContextFunctionAsync<T, H extends HookContext = HookContext> = (context: H) => Promise<T>;
+type ContextFunction<T, H extends HookContext = HookContext> = (context: H) => T | Promise<T>;
+type PredicateContextSync<H extends HookContext = HookContext> = (context: H) => boolean;
+type PredicateContextAsync<H extends HookContext = HookContext> = (context: H) => Promise<boolean>;
+type PredicateFn<H extends HookContext = HookContext> = (context: H) => boolean | Promise<boolean>;
+type PredicateItemWithContext<T = any> = (item: T, context: HookContext) => boolean;
+type TransformerFn<T = Record<string, any>, H extends HookContext = HookContext> = (item: T, options: {
+  context: H;
+  i: number;
+}) => Promisable<T | undefined | void>;
+type TransformerInputFn<T = Record<string, any>, H extends HookContext = HookContext> = (item: T, options: {
+  context: H;
+  i: number;
+}) => Promisable<any>;
+type FieldKey<T> = (keyof T & string) | `${Extract<keyof T, string>}.${string}`;
+type StringFieldKey<T> = { [K in keyof T & string]: T[K] extends string | null | undefined ? K : never }[keyof T & string] | `${Extract<keyof T, string>}.${string}`;
+type DefaultsInput<T extends Record<string, any>> = { [K in keyof T & string]?: T[K] | (() => T[K]) } & { [K in `${Extract<keyof T, string>}.${string}`]?: unknown };
+declare type HookFunction<H extends HookContext = HookContext> = (context: H, next?: NextFunction) => Promise<H | void> | H | void;
+type TransformParamsFn<P extends Params = Params> = (params: P) => P | void;
+type DispatchOption = boolean | 'both';
+//#endregion
+//#region src/utility-types/unwrap-paginated.d.ts
+type UnwrapPaginated<R> = R extends Paginated<infer D> ? D : R;
+type UnwrapPaginatedOrArray<T> = T extends Paginated<infer D> ? D : T extends any[] ? T[number] : T;
+//#endregion
+//#region src/utility-types/hook-context.d.ts
+type ResultSingleHookContext<H extends HookContext> = UnwrapPaginatedOrArray<NonNullable<H['result']>>;
+type DataSingleHookContext<H extends HookContext> = UnwrapArray<NonNullable<H['data']>>;
+//#endregion
+export { Promisable as A, hookTypes as C, KeyOfOrDotNotation as D, KeyOf as E, UnwrapArray as M, MaybeArray as O, TransportName as S, AnyFallback as T, PredicateItemWithContext as _, ContextFunction as a, TransformerFn as b, DefaultsInput as c, HookFunction as d, HookType$1 as f, PredicateFn as g, PredicateContextSync as h, UnwrapPaginatedOrArray as i, UnpackMaybeArray as j, NeverFallback as k, DispatchOption as l, PredicateContextAsync as m, ResultSingleHookContext as n, ContextFunctionAsync as o, MethodName as p, UnwrapPaginated as r, ContextFunctionSync as s, DataSingleHookContext as t, FieldKey as u, StringFieldKey as v, methodNames as w, TransformerInputFn as x, TransformParamsFn as y };
+//# sourceMappingURL=hook-context-aHkq1h0N.d.mts.map

package/dist/{traverse.hook-BLSSwn5l.mjs → hooks-DPFxxjBu.mjs}

@@ -1,20 +1,24 @@
-import { f as isMulti, l as isProvider, m as every, t as throwIf } from "./throw-if.hook-DRNssJBV.mjs";
-import { a as traverse$1, i as isPromise, r as toArray, t as early } from "./internal.utils-EIZPRZzm.mjs";
-import { d as checkContext, f as addToQuery, r as transformParams, u as contextToJson } from "./zip-data-result.util-BSKwCFF9.mjs";
-import { i as getDataIsArray, r as getResultIsArray } from "./mutate-result.util-BxXb39DP.mjs";
-import { r as transformData } from "./transform-result.hook-DM0S5rkk.mjs";
+import { g as every, p as isMulti, t as throwIf, u as isProvider } from "./predicates-CT08opkD.mjs";
+import { d as checkContext, f as addToQuery, h as sortQueryProperties, r as transformParams, u as contextToJson } from "./utils-1I_iPZkV.mjs";
+import { a as traverse$1, i as isPromise, r as toArray, t as early } from "./internal.utils-BWQ25nOd.mjs";
+import { i as getDataIsArray, r as getResultIsArray } from "./mutate-result.util-CCBWix-G.mjs";
+import { r as transformData } from "./transform-result.hook-CevWK5TA.mjs";
+import "./resolve-Cx9osy8O.mjs";
 import isObject from "lodash/isObject.js";
 import { copy } from "fast-copy";
-import { BadRequest, Forbidden, MethodNotAllowed } from "@feathersjs/errors";
+import { BadRequest, Forbidden, MethodNotAllowed, TooManyRequests } from "@feathersjs/errors";
 import _get from "lodash/get.js";
 import _has from "lodash/has.js";
 import _omit from "lodash/omit.js";
 import _set from "lodash/set.js";
 import _setWith from "lodash/setWith.js";
 import _clone from "lodash/clone.js";
-
 //#region src/hooks/cache/cache-utils.ts
 const stableStringify = (obj) => {
+	if (obj.query) obj = {
+		...obj,
+		query: sortQueryProperties(obj.query)
+	};
 	return JSON.stringify(obj, (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) => {
@@ -24,7 +28,6 @@ const stableStringify = (obj) => {
 		return value;
 	});
 };
-
 //#endregion
 //#region src/hooks/cache/cache.hook.ts
 /**
@@ -76,13 +79,17 @@ var ContextCacheMap = class {
 	map;
 	delimiter = ":";
 	options;
+	log;
+	serialize;
 	constructor(options) {
 		this.map = options.map;
 		this.options = options;
+		this.log = options.logger;
+		this.serialize = options.serialize ?? stableStringify;
 	}
 	stringifyCacheKey(context) {
 		if (context.method !== "get" && context.method !== "find") throw new Error(`Cache can only be used with 'get' or 'find' methods, not '${context.method}'`);
-		const stringifiedParams = stableStringify(this.options.transformParams(context.params ?? {}));
+		const stringifiedParams = this.serialize(this.options.transformParams(context.params ?? {}));
 		return `${context.id ?? "null"}${this.delimiter}${stringifiedParams}`;
 	}
 	getCachedId(key) {
@@ -102,7 +109,19 @@ var ContextCacheMap = class {
 	async get(context) {
 		const key = this.stringifyCacheKey(context);
 		const result = this.map.get(key);
-		if (result) return copy(result);
+		if (result) {
+			this.log?.({
+				type: "hit",
+				method: context.method,
+				key
+			});
+			return copy(result);
+		}
+		this.log?.({
+			type: "miss",
+			method: context.method,
+			key
+		});
 	}
 	/**
 	* Called after get() and find()
@@ -111,6 +130,11 @@ var ContextCacheMap = class {
 	*/
 	async set(context) {
 		const key = this.stringifyCacheKey(context);
+		this.log?.({
+			type: "set",
+			method: context.method,
+			key
+		});
 		return this.map.set(key, copy(context.result));
 	}
 	async clear(context) {
@@ -118,23 +142,38 @@ var ContextCacheMap = class {
 		const promises = [];
 		const itemIds = results.map((item) => this.getId(item, context)).filter(Boolean);
 		if (!itemIds.length) {
+			this.log?.({
+				type: "clear",
+				method: context.method
+			});
 			await this.map.clear();
 			return context;
 		}
 		for (const key of this.map.keys()) {
 			const cachedId = this.getCachedId(key);
 			if (cachedId === "null") {
+				this.log?.({
+					type: "invalidate",
+					method: context.method,
+					key
+				});
 				promises.push(this.map.delete(key));
 				continue;
 			}
 			if (context.method === "create") continue;
-			for (const itemId of itemIds) if (cachedId === itemId) promises.push(this.map.delete(key));
+			for (const itemId of itemIds) if (cachedId === itemId) {
+				this.log?.({
+					type: "invalidate",
+					method: context.method,
+					key
+				});
+				promises.push(this.map.delete(key));
+			}
 		}
 		await Promise.all(promises);
 		return context;
 	}
 };
-
 //#endregion
 //#region src/hooks/check-multi/check-multi.hook.ts
 /**
@@ -156,13 +195,13 @@ var ContextCacheMap = class {
 function checkMulti(options) {
 	return (context, next) => {
 		const { service, method } = context;
-		if (!service.allowsMulti || !isMulti(context) || method === "find") return context;
-		if (!service.allowsMulti(method)) throw options?.error ? options.error(context) : new MethodNotAllowed(`Can not ${method} multiple entries`);
-		if (next) return next();
-		return context;
+		if (!service.allowsMulti || !isMulti(context) || method === "find" || service.allowsMulti(method)) {
+			if (next) return next();
+			return context;
+		}
+		throw options?.error ? options.error(context) : new MethodNotAllowed(`Can not ${method} multiple entries`);
 	};
 }
-
 //#endregion
 //#region src/hooks/check-required/check-required.hook.ts
 /**
@@ -184,11 +223,15 @@ function checkMulti(options) {
 function checkRequired(fieldNames) {
 	const fieldNamesArray = toArray(fieldNames);
 	return (context, next) => {
-		checkContext(context, ["before", "around"], [
-			"create",
-			"update",
-			"patch"
-		], "checkRequired");
+		checkContext(context, {
+			type: ["before", "around"],
+			method: [
+				"create",
+				"update",
+				"patch"
+			],
+			label: "checkRequired"
+		});
 		const { data } = getDataIsArray(context);
 		for (let i = 0; i < data.length; i++) {
 			const item = data[i];
@@ -202,7 +245,6 @@ function checkRequired(fieldNames) {
 		if (next) return next();
 	};
 }
-
 //#endregion
 //#region src/hooks/create-related/create-related.hook.ts
 /**
@@ -225,7 +267,11 @@ function checkRequired(fieldNames) {
 */
 function createRelated(options) {
 	return async (context, next) => {
-		checkContext(context, ["after", "around"], ["create"], "createRelated");
+		checkContext(context, {
+			type: ["after", "around"],
+			method: ["create"],
+			label: "createRelated"
+		});
 		if (next) await next();
 		const { result } = getResultIsArray(context);
 		const entries = Array.isArray(options) ? options : [options];
@@ -238,7 +284,6 @@ function createRelated(options) {
 		}));
 	};
 }
-
 //#endregion
 //#region src/hooks/debug/debug.hook.ts
 /**
@@ -274,7 +319,6 @@ const debug = (msg, ...fieldNames) => async (context, next) => {
 	});
 	if (context.error) console.log("error", context.error);
 };
-
 //#endregion
 //#region src/hooks/disable-pagination/disable-pagination.hook.ts
 /**
@@ -295,7 +339,11 @@ const debug = (msg, ...fieldNames) => async (context, next) => {
 * @see https://utils.feathersjs.com/hooks/disable-pagination.html
 */
 const disablePagination = () => (context, next) => {
-	checkContext(context, ["before", "around"], ["find"], "disablePagination");
+	checkContext(context, {
+		type: ["before", "around"],
+		method: ["find"],
+		label: "disablePagination"
+	});
 	const $limit = context.params?.query?.$limit;
 	if ($limit === "-1" || $limit === -1) {
 		context.params.paginate = false;
@@ -304,7 +352,6 @@ const disablePagination = () => (context, next) => {
 	if (next) return next();
 	return context;
 };
-
 //#endregion
 //#region src/hooks/disallow/disallow.hook.ts
 /**
@@ -330,17 +377,20 @@ const disallow = (transports) => {
 	const transportsArr = toArray(transports);
 	return (context, next) => {
 		if (!transports) throw new MethodNotAllowed("Method not allowed");
-		if (isProvider(...transportsArr)(context)) throw new MethodNotAllowed(`Provider '${context.params.provider}' can not call '${context.method}'. (disallow)`);
+		if (isProvider(...transportsArr)(context)) throw new MethodNotAllowed(`Provider '${context.params.provider}' can not call '${context.method}' on '${context.path}'. (disallow)`);
 		if (next) return next().then(() => context);
 	};
 };
-
 //#endregion
 //#region src/hooks/on-delete/on-delete.hook.ts
 const onDelete = (options) => {
 	const optionsMulti = Array.isArray(options) ? options : [options];
 	return async (context, next) => {
-		checkContext(context, ["after", "around"], "remove", "onDelete");
+		checkContext(context, {
+			type: ["after", "around"],
+			method: "remove",
+			label: "onDelete"
+		});
 		if (next) await next();
 		const { result } = getResultIsArray(context);
 		if (!result.length) return;
@@ -367,11 +417,9 @@ const onDelete = (options) => {
 		if (promises.length) await Promise.all(promises);
 	};
 };
-
 //#endregion
 //#region src/hooks/params-for-server/params-for-from-shared.ts
 const FROM_CLIENT_FOR_SERVER_DEFAULT_KEY = "_$client";
-
 //#endregion
 //#region src/hooks/params-for-server/params-for-server.hook.ts
 /**
@@ -413,7 +461,6 @@ const paramsForServer = (whitelist, options) => {
 		return context;
 	};
 };
-
 //#endregion
 //#region src/hooks/params-from-client/params-from-client.hook.ts
 /**
@@ -437,7 +484,10 @@ const paramsFromClient = (whitelist, options) => {
 	const whitelistArr = toArray(whitelist);
 	const { keyToHide = FROM_CLIENT_FOR_SERVER_DEFAULT_KEY } = options || {};
 	return (context, next) => {
-		if (!context.params?.query?.[keyToHide] || typeof context.params.query[keyToHide] !== "object") return context;
+		if (!context.params?.query?.[keyToHide] || typeof context.params.query[keyToHide] !== "object") {
+			if (next) return next();
+			return context;
+		}
 		const params = {
 			...context.params,
 			query: {
@@ -458,7 +508,6 @@ const paramsFromClient = (whitelist, options) => {
 		return context;
 	};
 };
-
 //#endregion
 //#region src/hooks/prevent-changes/prevent-changes.hook.ts
 /**
@@ -486,11 +535,51 @@ const preventChanges = (fieldNames, options) => {
 			const name = fieldNamesArr[i];
 			if (_has(item, name)) throw typeof options.error === "function" ? options.error(item, name) : new BadRequest(`Field ${String(name)} may not be patched. (preventChanges)`);
 		}
-		else item = _omit(item, fieldNamesArr);
+		else return _omit(item, fieldNamesArr);
 		return item;
 	});
 };
-
+//#endregion
+//#region src/hooks/rate-limit/rate-limit.hook.ts
+/**
+* Rate limits service method calls using `rate-limiter-flexible`.
+* You provide a pre-configured `RateLimiterAbstract` instance
+* (Memory, Redis, Mongo, etc.) and the hook consumes points per request.
+*
+* @example
+* ```ts
+* import { rateLimit } from 'feathers-utils/hooks'
+* import { RateLimiterMemory } from 'rate-limiter-flexible'
+*
+* const rateLimiter = new RateLimiterMemory({ points: 10, duration: 1 })
+*
+* app.service('users').hooks({
+*   before: { find: [rateLimit(rateLimiter)] }
+* })
+* ```
+*
+* @see https://utils.feathersjs.com/hooks/rate-limit.html
+*/
+const rateLimit = (rateLimiter, options) => {
+	const key = options?.key ?? ((context) => context.path);
+	const points = options?.points ?? (() => 1);
+	return async (context, next) => {
+		checkContext(context, {
+			type: ["before", "around"],
+			label: "rateLimit"
+		});
+		const resolvedKey = await key(context);
+		const resolvedPoints = await points(context);
+		try {
+			const res = await rateLimiter.consume(resolvedKey, resolvedPoints);
+			context.params.rateLimit = res;
+		} catch (res) {
+			context.params.rateLimit = res;
+			throw new TooManyRequests("Too many requests", { rateLimitRes: res });
+		}
+		if (next) return await next();
+	};
+};
 //#endregion
 //#region src/hooks/set-data/set-data.hook.ts
 /**
@@ -515,8 +604,14 @@ function setData(from, to, options) {
 		const { data } = getDataIsArray(context);
 		const contextJson = contextToJson(context);
 		if (!_has(contextJson, from)) {
-			if (!context.params?.provider || allowUndefined === true) return context;
-			if (!overwrite && data.every((item) => _has(item, to))) return context;
+			if (!context.params?.provider || allowUndefined === true) {
+				if (next) return next();
+				return context;
+			}
+			if (!overwrite && data.every((item) => _has(item, to))) {
+				if (next) return next();
+				return context;
+			}
 			throw options?.error ? options.error(context, from) : new Forbidden(`Expected field ${from.toString()} not available`);
 		}
 		const val = _get(contextJson, from);
@@ -529,7 +624,6 @@ function setData(from, to, options) {
 		return context;
 	};
 }
-
 //#endregion
 //#region src/hooks/set-field/set-field.hook.ts
 /**
@@ -550,17 +644,22 @@ function setData(from, to, options) {
 */
 const setField = ({ as, from, allowUndefined = false, error }) => (context, next) => {
 	const { params } = context;
-	checkContext(context, ["before", "around"], null, "setField");
+	checkContext(context, {
+		type: ["before", "around"],
+		label: "setField"
+	});
 	const value = _get(context, from);
 	if (value === void 0) {
-		if (!params.provider || allowUndefined) return context;
+		if (!params.provider || allowUndefined) {
+			if (next) return next();
+			return context;
+		}
 		throw error ? error(context, from) : new Forbidden(`Expected field ${as} not available`);
 	}
 	context = _setWith(context, as, value, _clone);
 	if (next) return next();
 	return context;
 };
-
 //#endregion
 //#region src/hooks/set-result/set-result.hook.ts
 /**
@@ -605,11 +704,10 @@ function setResult(from, to, options) {
 		return forResultOrDispatch(context, !!options?.dispatch);
 	};
 	return (context, next) => {
-		if (next) next().then(() => fn(context));
+		if (next) return next().then(() => fn(context));
 		return fn(context);
 	};
 }
-
 //#endregion
 //#region src/hooks/set-slug/set-slug.hook.ts
 /**
@@ -639,7 +737,6 @@ const setSlug = (slug, fieldName) => {
 		return context;
 	};
 };
-
 //#endregion
 //#region src/hooks/soft-delete/soft-delete.hook.ts
 /**
@@ -663,7 +760,10 @@ const setSlug = (slug, fieldName) => {
 const softDelete = (options) => {
 	if (!options?.deletedQuery || !options?.removeData) throw new Error("You must provide `deletedQuery` and `removeData` options to the softDelete hook.");
 	return async (context, next) => {
-		checkContext(context, ["before", "around"], null, "softDelete");
+		checkContext(context, {
+			type: ["before", "around"],
+			label: "softDelete"
+		});
 		const { disableSoftDeleteKey = "disableSoftDelete" } = options;
 		if (context.params[disableSoftDeleteKey]) return early(context, next);
 		const { deletedQuery, removeData } = options;
@@ -689,52 +789,60 @@ const getValue = (value, ...args) => {
 	if (typeof value === "function") return value(...args);
 	return value;
 };
-
 //#endregion
-//#region src/hooks/stash-before/stash-before.hook.ts
+//#region src/hooks/stashable/stashable.hook.ts
+const defaultStashFunc = (context) => {
+	const isMulti = context.id == null;
+	const params = {
+		...context.params,
+		_stashable: true,
+		...isMulti ? { paginate: false } : {}
+	};
+	return isMulti ? context.service.find(params) : context.service.get(context.id, params);
+};
 /**
-* Stashes the current value of a record into `params.before` prior to mutation.
-* Performs a `get` (single item) or `find` (multi) call to retrieve the existing state.
-* Useful in `update`, `patch`, or `remove` hooks when you need the original data for comparison.
+* Stashes the pre-mutation state of a record into `context.params`.
+* Eagerly starts the fetch but exposes a memoized function — calling it
+* multiple times only hits the database once.
+* Use in `before` hooks on `update`, `patch`, or `remove` methods.
 *
 * @example
 * ```ts
-* import { stashBefore } from 'feathers-utils/hooks'
+* import { stashable } from 'feathers-utils/hooks'
 *
 * app.service('users').hooks({
-*   before: { patch: [stashBefore()] }
+*   before: { patch: [stashable()] }
 * })
-* // Access via: context.params.before
+*
+* // In a later hook (before or after):
+* const before = await context.params.stashed()
 * ```
 *
-* @see https://utils.feathersjs.com/hooks/stash-before.html
+* @see https://utils.feathersjs.com/hooks/stashable.html
 */
-function stashBefore(fieldName) {
-	const beforeField = fieldName || "before";
-	return async (context, next) => {
-		if (context.params.disableStashBefore) return context;
-		checkContext(context, ["before", "around"], [
-			"update",
-			"patch",
-			"remove"
-		], "stashBefore");
-		const isMulti = context.id == null;
-		const params = {
-			...context.params,
-			disableStashBefore: true,
-			...isMulti ? { paginate: false } : {}
-		};
-		await (!isMulti ? context.service.get(context.id, params) : context.service.find(params)).then((result) => {
-			context.params[beforeField] = result;
-			return context;
-		}).catch(() => {
+function stashable(options) {
+	const propName = options?.propName ?? "stashed";
+	const stashFunc = options?.stashFunc ?? defaultStashFunc;
+	return ((context, next) => {
+		if (context.params._stashable) {
+			if (next) return next();
 			return context;
+		}
+		checkContext(context, {
+			type: ["before", "around"],
+			method: [
+				"update",
+				"patch",
+				"remove"
+			],
+			label: "stashable"
 		});
-		if (next) return await next();
+		const promise = stashFunc(context).catch(() => void 0);
+		context.params[propName] = () => promise;
+		if (next) return next();
 		return context;
-	};
+	});
 }
-
 //#endregion
 //#region src/hooks/throw-if-is-multi/throw-if-is-multi.hook.ts
 const defaultError$1 = (context) => new BadRequest(`Cannot perform multi operation on method '${context.method}'`);
@@ -755,7 +863,6 @@ const defaultError$1 = (context) => new BadRequest(`Cannot perform multi operati
 * @see https://utils.feathersjs.com/hooks/throw-if-is-multi.html
 */
 const throwIfIsMulti = (options) => throwIf(every(every(isMulti, (context) => context.method !== "find"), options?.filter), { error: options?.error ?? defaultError$1 });
-
 //#endregion
 //#region src/hooks/throw-if-is-provider/throw-if-is-provider.hook.ts
 const defaultError = (context) => new MethodNotAllowed(`Provider '${context.params.provider}' can not call '${context.method}'.`);
@@ -778,7 +885,6 @@ const defaultError = (context) => new MethodNotAllowed(`Provider '${context.para
 const throwIfIsProvider = (transports, options) => {
 	return throwIf(every(isProvider(...toArray(transports)), options?.filter), { error: options?.error ?? defaultError });
 };
-
 //#endregion
 //#region src/hooks/traverse/traverse.hook.ts
 /**
@@ -804,7 +910,7 @@ const traverse = ({ transformer, getObject }) => (context, next) => {
 	if (next) return next();
 	return context;
 };
-
 //#endregion
-export { createRelated as _, softDelete as a, cache as b, setField as c, paramsFromClient as d, paramsForServer as f, debug as g, disablePagination as h, stashBefore as i, setData as l, disallow as m, throwIfIsProvider as n, setSlug as o, onDelete as p, throwIfIsMulti as r, setResult as s, traverse as t, preventChanges as u, checkRequired as v, checkMulti as y };
-//# sourceMappingURL=traverse.hook-BLSSwn5l.mjs.map
+export { debug as _, softDelete as a, checkMulti as b, setField as c, preventChanges as d, paramsFromClient as f, disablePagination as g, disallow as h, stashable as i, setData as l, onDelete as m, throwIfIsProvider as n, setSlug as o, paramsForServer as p, throwIfIsMulti as r, setResult as s, traverse as t, rateLimit as u, createRelated as v, cache as x, checkRequired as y };
+
+//# sourceMappingURL=hooks-DPFxxjBu.mjs.map