feathers-utils 1.6.1 → 2.0.0-0

package/dist/esm/utils/mergeQuery/index.js

@@ -0,0 +1,327 @@
+import _get from "lodash/get";
+import _has from "lodash/has";
+import _isEmpty from "lodash/isEmpty";
+import _isEqual from "lodash/isEqual";
+import _merge from "lodash/merge";
+import _set from "lodash/set";
+import _uniqWith from "lodash/uniqWith";
+import { mergeArrays } from "./mergeArrays";
+import { filterQuery } from "../filterQuery";
+import { Forbidden } from "@feathersjs/errors";
+const hasOwnProperty = (obj, key) => {
+    return Object.prototype.hasOwnProperty.call(obj, key);
+};
+function handleArray(target, source, key, options) {
+    const targetVal = _get(target, key);
+    const sourceVal = _get(source, key);
+    if (!sourceVal && !targetVal) {
+        return;
+    }
+    const handle = _get(options, ["handle", ...key], options.defaultHandle);
+    const arr = mergeArrays(targetVal, sourceVal, handle, key, options.actionOnEmptyIntersect);
+    _set(target, key, arr);
+}
+function handleCircular(target, source, prependKey, options) {
+    if (target?.$or) {
+        target.$or = cleanOr(target.$or);
+        if (!target.$or) {
+            delete target.$or;
+        }
+    }
+    if (source?.$or) {
+        source.$or = cleanOr(source.$or);
+        if (!source.$or) {
+            delete source.$or;
+        }
+    }
+    if (target?.$and) {
+        target.$and = cleanAnd(target.$and);
+        if (!target.$and) {
+            delete target.$and;
+        }
+    }
+    if (source?.$and) {
+        source.$and = cleanAnd(source.$and);
+        if (!source.$and) {
+            delete source.$and;
+        }
+    }
+    if (!_has(source, prependKey)) {
+        return;
+    }
+    if (!_has(target, prependKey)) {
+        _set(target, prependKey, _get(source, prependKey));
+        return;
+    }
+    const { defaultHandle, actionOnEmptyIntersect } = options;
+    if (defaultHandle === "target") {
+        return;
+    }
+    const getTargetVal = () => {
+        return (prependKey.length > 0) ? _get(target, prependKey) : target;
+    };
+    const getSourceVal = () => {
+        return (prependKey.length > 0) ? _get(source, prependKey) : source;
+    };
+    const targetVal = getTargetVal();
+    const sourceVal = getSourceVal();
+    if (_isEqual(targetVal, sourceVal)) {
+        return;
+    }
+    if (defaultHandle === "source") {
+        _set(target, prependKey, sourceVal);
+        return;
+    }
+    if (targetVal === null || sourceVal === null) {
+        _set(target, prependKey, sourceVal);
+        return;
+    }
+    const typeOfTargetVal = typeof targetVal;
+    if (["boolean"].includes(typeOfTargetVal)) {
+        if (defaultHandle === "intersect") {
+            actionOnEmptyIntersect(target, source, prependKey);
+        }
+        _set(target, prependKey, sourceVal);
+        return;
+    }
+    const typeOfSourceVal = typeof sourceVal;
+    const isTargetSimple = ["string", "number"].includes(typeOfTargetVal);
+    const isSourceSimple = ["string", "number"].includes(typeOfSourceVal);
+    if (isTargetSimple || isSourceSimple) {
+        if (isTargetSimple && isSourceSimple) {
+            if (defaultHandle === "combine") {
+                _set(target, prependKey, { $in: [...new Set([targetVal, sourceVal])] });
+                return;
+            }
+            else if (defaultHandle === "intersect") {
+                actionOnEmptyIntersect(target, source, prependKey);
+            }
+            else {
+                throw new Error("should not reach here");
+            }
+        }
+        else if (hasOwnProperty(targetVal, "$in") || hasOwnProperty(sourceVal, "$in")) {
+            const targetHasIn = hasOwnProperty(targetVal, "$in");
+            const $in = (targetHasIn) ? targetVal["$in"] : sourceVal["$in"];
+            const otherVal = (isTargetSimple) ? targetVal : sourceVal;
+            if ($in.length === 1 && _isEqual($in[0], otherVal)) {
+                _set(target, prependKey, otherVal);
+                return;
+            }
+            else if (defaultHandle === "combine") {
+                if (!$in.some((x) => _isEqual(x, otherVal))) {
+                    $in.push(otherVal);
+                }
+                _set(target, `${prependKey}.$in`, $in);
+                return;
+            }
+            else if (defaultHandle === "intersect") {
+                if ($in.some((x) => _isEqual(x, otherVal))) {
+                    _set(target, prependKey, otherVal);
+                }
+                else {
+                    actionOnEmptyIntersect(target, source, prependKey);
+                }
+                return;
+            }
+            return;
+        }
+    }
+    const isTargetArray = Array.isArray(targetVal);
+    const isSourceArray = Array.isArray(sourceVal);
+    if (isTargetArray && isSourceArray) {
+        const key = prependKey[prependKey.length - 1];
+        if (key === "$or") {
+            if (defaultHandle === "combine") {
+                const newVals = sourceVal.filter((x) => !targetVal.some((y) => _isEqual(x, y)));
+                targetVal.push(...newVals);
+            }
+            else if (defaultHandle === "intersect") {
+                // combine into "$and"
+                const targetParent = getParentProp(target, prependKey);
+                const sourceParent = getParentProp(source, prependKey);
+                targetParent.$and = targetParent.$and || [];
+                targetParent.$and.push({ $or: targetVal }, { $or: sourceVal });
+                targetParent.$and = cleanAnd(targetParent.$and);
+                if (!targetParent.$and) {
+                    delete targetParent.$and;
+                }
+                delete targetParent.$or;
+                delete sourceParent.$or;
+                handleCircular(target, source, [...prependKey, "$and"], options);
+                return;
+            }
+            return;
+        }
+        else if (key === "$and") {
+            if (defaultHandle === "combine") {
+                // combine into "$or"
+                const targetParent = getParentProp(target, prependKey);
+                const sourceParent = getParentProp(source, prependKey);
+                targetParent.$or = targetParent.$or || [];
+                targetParent.$or.push({ $and: targetVal }, { $and: sourceVal });
+                targetParent.$or = cleanOr(targetParent.$or);
+                if (!targetParent.$or) {
+                    delete targetParent.$or;
+                }
+                delete targetParent.$and;
+                delete sourceParent.$and;
+                handleCircular(target, source, [...prependKey, "$or"], options);
+                return;
+            }
+            else if (defaultHandle === "intersect") {
+                const newVals = sourceVal.filter((x) => !targetVal.some((y) => _isEqual(x, y)));
+                targetVal.push(...newVals);
+                return;
+            }
+        }
+        else if (key === "$in") {
+            if (defaultHandle === "combine") {
+                let $in = targetVal.concat(sourceVal);
+                $in = [...new Set($in)];
+                _set(target, prependKey, $in);
+                return;
+            }
+            else if (defaultHandle === "intersect") {
+                const $in = targetVal.filter((x) => sourceVal.some((y) => _isEqual(x, y)));
+                if ($in.length === 0) {
+                    actionOnEmptyIntersect(target, source, prependKey);
+                }
+                else if ($in.length === 1) {
+                    _set(target, prependKey.slice(0, -1), $in[0]);
+                    return;
+                }
+                else {
+                    _set(target, prependKey, $in);
+                }
+            }
+            return;
+        }
+        _set(target, prependKey, sourceVal);
+        return;
+    }
+    if (typeOfTargetVal !== "object" || typeOfSourceVal !== "object") {
+        _set(target, prependKey, sourceVal);
+        return;
+    }
+    // both are objects
+    const sourceKeys = Object.keys(sourceVal);
+    for (let i = 0, n = sourceKeys.length; i < n; i++) {
+        const key = sourceKeys[i];
+        handleCircular(target, source, [...prependKey, key], options);
+    }
+}
+function makeDefaultOptions(options) {
+    options = options || {};
+    options.defaultHandle = options.defaultHandle || "combine";
+    options.useLogicalConjunction =
+        (Object.prototype.hasOwnProperty.call(options, "useLogicalConjunction"))
+            ? options.useLogicalConjunction
+            : false;
+    options.actionOnEmptyIntersect = options.actionOnEmptyIntersect || (() => {
+        throw new Forbidden("You're not allowed to make this request");
+    });
+    options.handle = options.handle || {};
+    if (options.defaultHandle === "intersect") {
+        options.handle.$select = options.handle.$select || "intersectOrFull";
+    }
+    return options;
+}
+export function mergeQuery(target, source, options) {
+    const fullOptions = makeDefaultOptions(options);
+    const { filters: targetFilters, query: targetQuery } = filterQuery(target, {
+        operators: fullOptions.operators,
+        service: fullOptions.service
+    });
+    if (target.$limit) {
+        targetFilters.$limit = target.$limit;
+    }
+    let { 
+    // eslint-disable-next-line prefer-const
+    filters: sourceFilters, query: sourceQuery } = filterQuery(source, {
+        operators: fullOptions.operators,
+        service: fullOptions.service
+    });
+    if (source.$limit) {
+        sourceFilters.$limit = source.$limit;
+    }
+    //#region filters
+    if (target &&
+        !Object.prototype.hasOwnProperty.call(target, "$limit") &&
+        Object.prototype.hasOwnProperty.call(targetFilters, "$limit")) {
+        delete targetFilters.$limit;
+    }
+    if (source &&
+        !Object.prototype.hasOwnProperty.call(source, "$limit") &&
+        Object.prototype.hasOwnProperty.call(sourceFilters, "$limit")) {
+        delete sourceFilters.$limit;
+    }
+    handleArray(targetFilters, sourceFilters, ["$select"], fullOptions);
+    // remaining filters
+    delete sourceFilters["$select"];
+    _merge(targetFilters, sourceFilters);
+    //#endregion
+    //#region '$or' / '$and'
+    if (options?.useLogicalConjunction &&
+        (options.defaultHandle === "combine" ||
+            options.defaultHandle === "intersect") &&
+        !_isEmpty(targetQuery)) {
+        const logicalOp = (options.defaultHandle === "combine")
+            ? "$or"
+            : "$and";
+        if (Object.prototype.hasOwnProperty.call(sourceQuery, logicalOp)) {
+            // omit '$or'/'$and' and put all other props into '$or'/'$and'
+            const andOr = sourceQuery[logicalOp];
+            delete sourceQuery[logicalOp];
+            andOr.push(sourceQuery);
+            sourceQuery = { [logicalOp]: andOr };
+        }
+        else {
+            sourceQuery = { [logicalOp]: [sourceQuery] };
+        }
+    }
+    //#endregion
+    const keys = Object.keys(sourceQuery);
+    for (let i = 0, n = keys.length; i < n; i++) {
+        const key = keys[i];
+        handleCircular(targetQuery, sourceQuery, [key], fullOptions);
+    }
+    const result = Object.assign({}, targetFilters, targetQuery);
+    return result;
+}
+function getParentProp(target, path) {
+    if (path.length <= 1) {
+        return target;
+    }
+    const pathOneUp = path.slice(0, -1);
+    return _get(target, pathOneUp);
+}
+function cleanOr(target) {
+    if (!target || !Array.isArray(target) || target.length <= 0) {
+        return target;
+    }
+    if (target.some(x => _isEmpty(x))) {
+        return undefined;
+    }
+    else {
+        return arrayWithoutDuplicates(target);
+    }
+}
+function cleanAnd(target) {
+    if (!target || !Array.isArray(target) || target.length <= 0) {
+        return target;
+    }
+    if (target.every(x => _isEmpty(x))) {
+        return undefined;
+    }
+    else {
+        target = target.filter(x => !_isEmpty(x));
+        return arrayWithoutDuplicates(target);
+    }
+}
+function arrayWithoutDuplicates(target) {
+    if (!target || !Array.isArray(target)) {
+        return target;
+    }
+    return _uniqWith(target, _isEqual);
+}

package/dist/esm/utils/mergeQuery/mergeArrays.d.ts

@@ -0,0 +1,2 @@
+import type { Handle, ActionOnEmptyIntersect, Path } from "../../types";
+export declare function mergeArrays<T>(targetArr: T[], sourceArr: T[], handle: Handle, prependKey?: Path, actionOnEmptyIntersect?: ActionOnEmptyIntersect): T[] | undefined;

package/dist/esm/utils/mergeQuery/mergeArrays.js

@@ -0,0 +1,37 @@
+export function mergeArrays(targetArr, sourceArr, handle, prependKey, actionOnEmptyIntersect) {
+    if (!sourceArr && !targetArr) {
+        return;
+    }
+    if (handle === "target") {
+        return targetArr;
+    }
+    else if (handle === "source") {
+        return sourceArr;
+    }
+    else if (handle === "combine") {
+        if (!sourceArr || !Array.isArray(sourceArr)) {
+            return targetArr;
+        }
+        if (!targetArr || !Array.isArray(targetArr)) {
+            return sourceArr;
+        }
+        const arr = targetArr.concat(sourceArr);
+        return [...new Set(arr)];
+    }
+    else if (handle === "intersect" || handle === "intersectOrFull") {
+        const targetIsArray = !targetArr || !Array.isArray(targetArr);
+        const sourceIsArray = !sourceArr || !Array.isArray(sourceArr);
+        if ((targetIsArray || sourceIsArray) && handle === "intersect") {
+            if (actionOnEmptyIntersect) {
+                actionOnEmptyIntersect(targetArr, sourceArr, prependKey || []);
+            }
+            return;
+        }
+        if (handle === "intersectOrFull") {
+            const val = (!targetIsArray) ? targetArr : sourceArr;
+            return val;
+        }
+        return targetArr.filter(val => sourceArr.includes(val));
+    }
+    return undefined;
+}

package/dist/esm/utils/pushSet.d.ts

@@ -0,0 +1,2 @@
+import type { Path, PushSetOptions } from "../types";
+export declare const pushSet: (obj: Record<string, unknown>, path: string | Path, val: unknown, options?: PushSetOptions | undefined) => unknown[];

package/dist/esm/utils/pushSet.js

@@ -0,0 +1,19 @@
+import _isEqual from "lodash/isEqual";
+import _get from "lodash/get";
+import _set from "lodash/set";
+export const pushSet = (obj, path, val, options) => {
+    options = options || {};
+    let arr = _get(obj, path);
+    if (!arr || !Array.isArray(arr)) {
+        arr = [val];
+        _set(obj, path, arr);
+        return arr;
+    }
+    else {
+        if (options.unique && arr.some(x => _isEqual(x, val))) {
+            return arr;
+        }
+        arr.push(val);
+        return arr;
+    }
+};

package/dist/esm/utils/setResultEmpty.d.ts

@@ -0,0 +1,2 @@
+import { HookContext } from "@feathersjs/feathers";
+export declare const setResultEmpty: (context: HookContext) => HookContext;

package/dist/esm/utils/setResultEmpty.js

@@ -0,0 +1,25 @@
+import { isMulti } from "..";
+import { isPaginated } from "./isPaginated";
+export const setResultEmpty = (context) => {
+    if (context.result) {
+        return context;
+    }
+    const multi = isMulti(context);
+    if (multi) {
+        if (context.method === "find" && isPaginated(context)) {
+            context.result = {
+                total: 0,
+                skip: 0,
+                limit: 0,
+                data: []
+            };
+        }
+        else {
+            context.result = [];
+        }
+    }
+    else {
+        context.result = null;
+    }
+    return context;
+};

package/dist/esm/utils/shouldSkip.d.ts

@@ -0,0 +1,2 @@
+import type { HookContext } from "@feathersjs/feathers";
+export declare const shouldSkip: (hookName: string, context: HookContext) => boolean;

package/dist/esm/utils/shouldSkip.js

@@ -0,0 +1,29 @@
+// Kudos to @DaddyWarbucks! This is a cheeky copy of his awesome library: 'feathers-fletching'.
+// Definitely check it out! https://daddywarbucks.github.io/feathers-fletching/overview.html
+import { GeneralError } from "@feathersjs/errors";
+export const shouldSkip = (hookName, context) => {
+    if (!context.params || !context.params.skipHooks) {
+        return false;
+    }
+    const { skipHooks } = context.params;
+    if (!Array.isArray(skipHooks)) {
+        throw new GeneralError("The `skipHooks` param must be an Array of Strings");
+    }
+    const { type } = context;
+    if (skipHooks.includes(hookName)) {
+        return true;
+    }
+    if (skipHooks.includes("all")) {
+        return true;
+    }
+    if (type === "before") {
+        return (skipHooks.includes(`before:${hookName}`) || skipHooks.includes("before"));
+    }
+    if (type === "after") {
+        return (skipHooks.includes(`after:${hookName}`) || skipHooks.includes("after"));
+    }
+    if (type === "error") {
+        return (skipHooks.includes(`error:${hookName}`) || skipHooks.includes("error"));
+    }
+    return false;
+};

package/dist/hooks/checkMulti.js

@@ -6,11 +6,11 @@ const shouldSkip_1 = require("../utils/shouldSkip");
 const isMulti_1 = require("../utils/isMulti");
 function checkMulti() {
     return (context) => {
-        if (shouldSkip_1.shouldSkip("checkMulti", context)) {
+        if ((0, shouldSkip_1.shouldSkip)("checkMulti", context)) {
             return context;
         }
         const { service, method } = context;
-        if (!service.allowsMulti || !isMulti_1.isMulti(context) || method === "find") {
+        if (!service.allowsMulti || !(0, isMulti_1.isMulti)(context) || method === "find") {
             return context;
         }
         if (!service.allowsMulti(method)) {

package/dist/hooks/runPerItem.d.ts

@@ -1,3 +1,4 @@
 import type { HookRunPerItemOptions } from "../types";
 import type { HookContext } from "@feathersjs/feathers";
-export declare const runPerItem: (actionPerItem: (item: unknown, context: HookContext) => Promise<unknown>, options: HookRunPerItemOptions) => (context: HookContext) => Promise<HookContext>;
+import type { Promisable } from "type-fest";
+export declare const runPerItem: (actionPerItem: (item: any, context: HookContext) => Promisable<any>, options: HookRunPerItemOptions) => (context: HookContext) => Promise<HookContext>;

package/dist/hooks/runPerItem.js

@@ -21,10 +21,11 @@ const makeOptions = (options) => {
 const runPerItem = (actionPerItem, options) => {
     options = makeOptions(options);
     return (context) => __awaiter(void 0, void 0, void 0, function* () {
-        if (shouldSkip_1.shouldSkip("runForItems", context)) {
+        if ((0, shouldSkip_1.shouldSkip)("runForItems", context)) {
             return context;
         }
-        let items = feathers_hooks_common_1.getItems(context);
+        //@ts-expect-error type error because feathers-hooks-common is feathers@4
+        let items = (0, feathers_hooks_common_1.getItems)(context);
         items = (Array.isArray(items)) ? items : [items];
         const promises = items.map((item) => __awaiter(void 0, void 0, void 0, function* () {
             yield actionPerItem(item, context);

package/dist/hooks/setData.js

@@ -17,23 +17,24 @@ function setData(from, to, _options) {
     const options = Object.assign({}, defaultOptions, _options);
     return (context) => {
         var _a;
-        let items = feathers_hooks_common_1.getItems(context);
+        //@ts-expect-error type error because feathers-hooks-common is feathers@4
+        let items = (0, feathers_hooks_common_1.getItems)(context);
         items = (Array.isArray(items)) ? items : [items];
-        if (!has_1.default(context, from)) {
+        if (!(0, has_1.default)(context, from)) {
             if (!((_a = context.params) === null || _a === void 0 ? void 0 : _a.provider) || options.allowUndefined === true) {
                 return context;
             }
-            if (!options.overwrite && items.every((item) => has_1.default(item, to))) {
+            if (!options.overwrite && items.every((item) => (0, has_1.default)(item, to))) {
                 return context;
             }
             throw new errors_1.Forbidden(`Expected field ${from.toString()} not available`);
         }
-        const val = get_1.default(context, from);
+        const val = (0, get_1.default)(context, from);
         items.forEach((item) => {
-            if (!options.overwrite && has_1.default(item, to)) {
+            if (!options.overwrite && (0, has_1.default)(item, to)) {
                 return;
             }
-            set_1.default(item, to, val);
+            (0, set_1.default)(item, to, val);
         });
         return context;
     };

package/dist/index.d.ts

@@ -4,23 +4,26 @@ import { runPerItem } from "./hooks/runPerItem";
 export declare const hooks: {
     checkMulti: typeof checkMulti;
     setData: typeof setData;
-    runPerItem: (actionPerItem: (item: unknown, context: import("@feathersjs/feathers").HookContext<any, import("@feathersjs/feathers").Service<any>>) => Promise<unknown>, options: import("./types").HookRunPerItemOptions) => (context: import("@feathersjs/feathers").HookContext<any, import("@feathersjs/feathers").Service<any>>) => Promise<import("@feathersjs/feathers").HookContext<any, import("@feathersjs/feathers").Service<any>>>;
+    runPerItem: (actionPerItem: (item: any, context: import("@feathersjs/feathers/lib").HookContext<import("@feathersjs/feathers/lib").Application<any, any>, any>) => any, options: import("./types").HookRunPerItemOptions) => (context: import("@feathersjs/feathers/lib").HookContext<import("@feathersjs/feathers/lib").Application<any, any>, any>) => Promise<import("@feathersjs/feathers/lib").HookContext<import("@feathersjs/feathers/lib").Application<any, any>, any>>;
 };
 export { checkMulti };
 export { setData };
 export { runPerItem };
-import { debounceMixin, DebouncedStore } from "./mixins/debounce-mixin";
+import { debounceMixin, DebouncedService, DebouncedStore } from "./mixins/debounce-mixin";
 export declare const mixins: {
     debounceMixin: typeof debounceMixin;
     DebouncedStore: typeof DebouncedStore;
 };
 export { debounceMixin };
+export { DebouncedService };
 export { DebouncedStore };
-export { addHook } from "./utils/addHook";
+export { getPaginate } from "./utils/getPaginate";
 export { isMulti } from "./utils/isMulti";
+export { isPaginated } from "./utils/isPaginated";
 export { mergeQuery } from "./utils/mergeQuery/index";
 export { mergeArrays } from "./utils/mergeQuery/mergeArrays";
 export { pushSet } from "./utils/pushSet";
+export { setResultEmpty } from "./utils/setResultEmpty";
 export { markHookForSkip } from "./utils/markHookForSkip";
 export { shouldSkip } from "./utils/shouldSkip";
 export { filterQuery } from "./utils/filterQuery";

package/dist/index.js

@@ -10,7 +10,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.filterQuery = exports.shouldSkip = exports.markHookForSkip = exports.pushSet = exports.mergeArrays = exports.mergeQuery = exports.isMulti = exports.addHook = exports.DebouncedStore = exports.debounceMixin = exports.mixins = exports.runPerItem = exports.setData = exports.checkMulti = exports.hooks = void 0;
+exports.filterQuery = exports.shouldSkip = exports.markHookForSkip = exports.setResultEmpty = exports.pushSet = exports.mergeArrays = exports.mergeQuery = exports.isPaginated = exports.isMulti = exports.getPaginate = exports.DebouncedStore = exports.debounceMixin = exports.mixins = exports.runPerItem = exports.setData = exports.checkMulti = exports.hooks = void 0;
 // hooks
 const checkMulti_1 = require("./hooks/checkMulti");
 Object.defineProperty(exports, "checkMulti", { enumerable: true, get: function () { return checkMulti_1.checkMulti; } });
@@ -30,16 +30,20 @@ exports.mixins = {
     debounceMixin: debounce_mixin_1.debounceMixin,
     DebouncedStore: debounce_mixin_1.DebouncedStore
 };
-var addHook_1 = require("./utils/addHook");
-Object.defineProperty(exports, "addHook", { enumerable: true, get: function () { return addHook_1.addHook; } });
+var getPaginate_1 = require("./utils/getPaginate");
+Object.defineProperty(exports, "getPaginate", { enumerable: true, get: function () { return getPaginate_1.getPaginate; } });
 var isMulti_1 = require("./utils/isMulti");
 Object.defineProperty(exports, "isMulti", { enumerable: true, get: function () { return isMulti_1.isMulti; } });
+var isPaginated_1 = require("./utils/isPaginated");
+Object.defineProperty(exports, "isPaginated", { enumerable: true, get: function () { return isPaginated_1.isPaginated; } });
 var index_1 = require("./utils/mergeQuery/index");
 Object.defineProperty(exports, "mergeQuery", { enumerable: true, get: function () { return index_1.mergeQuery; } });
 var mergeArrays_1 = require("./utils/mergeQuery/mergeArrays");
 Object.defineProperty(exports, "mergeArrays", { enumerable: true, get: function () { return mergeArrays_1.mergeArrays; } });
 var pushSet_1 = require("./utils/pushSet");
 Object.defineProperty(exports, "pushSet", { enumerable: true, get: function () { return pushSet_1.pushSet; } });
+var setResultEmpty_1 = require("./utils/setResultEmpty");
+Object.defineProperty(exports, "setResultEmpty", { enumerable: true, get: function () { return setResultEmpty_1.setResultEmpty; } });
 var markHookForSkip_1 = require("./utils/markHookForSkip");
 Object.defineProperty(exports, "markHookForSkip", { enumerable: true, get: function () { return markHookForSkip_1.markHookForSkip; } });
 var shouldSkip_1 = require("./utils/shouldSkip");

package/dist/mixins/debounce-mixin/DebouncedStore.d.ts

@@ -1,13 +1,13 @@
 import type { DebouncedFunc } from "lodash";
 import type { Application, Id } from "@feathersjs/feathers";
-import { DebouncedFunctionApp, DebouncedStoreOptions } from "../../types";
+import type { DebouncedFunctionApp, DebouncedStoreOptions } from "../../types";
 export declare const makeDefaultOptions: () => DebouncedStoreOptions;
 export declare class DebouncedStore {
     private _app;
     private _options;
     private _isRunningById;
     _queueById: Record<string, DebouncedFunc<((id: Id, action: DebouncedFunctionApp) => void | Promise<void>)>>;
-    add: (id: Id, action: (app?: Application<{}> | undefined) => void | Promise<void>) => void | Promise<void> | undefined;
+    add: (id: Id, action: (app?: Application<any, any> | undefined) => void | Promise<void>) => void | Promise<void> | undefined;
     constructor(app: Application, options?: Partial<DebouncedStoreOptions>);
     private unbounced;
     private debounceById;

package/dist/mixins/debounce-mixin/DebouncedStore.js

@@ -26,7 +26,7 @@ exports.makeDefaultOptions = makeDefaultOptions;
 class DebouncedStore {
     constructor(app, options) {
         this._app = app;
-        this._options = Object.assign(exports.makeDefaultOptions(), options);
+        this._options = Object.assign((0, exports.makeDefaultOptions)(), options);
         this._queueById = {};
         this._isRunningById = {};
         //this._waitingById = {};
@@ -52,7 +52,7 @@ class DebouncedStore {
             if (typeof this._queueById[id] === "function") {
                 return this._queueById[id](id, action);
             }
-            this._queueById[id] = debounce_1.default((id, action) => {
+            this._queueById[id] = (0, debounce_1.default)((id, action) => {
                 this.unbounced(id, action);
             }, wait, Object.assign(Object.assign({}, options), { leading: false })); // leading required for return promise
             return this._queueById[id](id, action);

package/dist/mixins/debounce-mixin/index.d.ts

@@ -1,5 +1,8 @@
 import { DebouncedStore } from "./DebouncedStore";
-import type { Application } from "@feathersjs/feathers";
+import type { Application, FeathersService } from "@feathersjs/feathers";
 import type { InitDebounceMixinOptions } from "../../types";
+export declare type DebouncedService = FeathersService & {
+    debouncedStore?: DebouncedStore;
+};
 export declare function debounceMixin(options?: Partial<InitDebounceMixinOptions>): ((app: Application) => void);
 export { DebouncedStore };

package/dist/mixins/debounce-mixin/index.js

@@ -6,7 +6,7 @@ Object.defineProperty(exports, "DebouncedStore", { enumerable: true, get: functi
 function debounceMixin(options) {
     return (app) => {
         options = options || {};
-        const defaultOptions = Object.assign(DebouncedStore_1.makeDefaultOptions(), options === null || options === void 0 ? void 0 : options.default);
+        const defaultOptions = Object.assign((0, DebouncedStore_1.makeDefaultOptions)(), options === null || options === void 0 ? void 0 : options.default);
         app.mixins.push((service, path) => {
             // if path is on blacklist, don't add debouncedStore to service
             if ((options === null || options === void 0 ? void 0 : options.blacklist) && options.blacklist.includes(path))