feathers-utils 2.0.0-2 → 2.0.0-4

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

@@ -0,0 +1,272 @@
+import { Forbidden } from "@feathersjs/errors";
+import _get from "lodash/get.js";
+import _has from "lodash/has.js";
+import _isEmpty from "lodash/isEmpty.js";
+import _isEqual from "lodash/isEqual.js";
+import _set from "lodash/set.js";
+import _uniqWith from "lodash/uniqWith.js";
+import { mergeArrays } from "./mergeArrays";
+export const hasOwnProperty = (obj, key) => {
+    return Object.prototype.hasOwnProperty.call(obj, key);
+};
+export 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);
+}
+export 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);
+    }
+}
+export 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 moveProperty(source, target, key) {
+    if (!Object.prototype.hasOwnProperty.call(source, key)) {
+        return;
+    }
+    target[key] = source[key];
+    delete source[key];
+}
+export function getParentProp(target, path) {
+    if (path.length <= 1) {
+        return target;
+    }
+    const pathOneUp = path.slice(0, -1);
+    return _get(target, pathOneUp);
+}
+export 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);
+    }
+}
+export 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);
+    }
+}
+export function arrayWithoutDuplicates(target) {
+    if (!target || !Array.isArray(target)) {
+        return target;
+    }
+    return _uniqWith(target, _isEqual);
+}

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

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

package/dist/esm/utils/pushSet.js

@@ -10,7 +10,7 @@ export const pushSet = (obj, path, val, options) => {
         return arr;
     }
     else {
-        if (options.unique && arr.some(x => _isEqual(x, val))) {
+        if (options.unique && arr.some((x) => _isEqual(x, val))) {
             return arr;
         }
         arr.push(val);

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

@@ -1,2 +1,2 @@
 import type { HookContext } from "@feathersjs/feathers";
-export declare const setResultEmpty: (context: HookContext) => HookContext;
+export declare const setResultEmpty: <H extends HookContext<import("@feathersjs/feathers").Application<any, any>, any> = HookContext<import("@feathersjs/feathers").Application<any, any>, any>>(context: H) => H;

package/dist/esm/utils/setResultEmpty.js

@@ -11,7 +11,7 @@ export const setResultEmpty = (context) => {
                 total: 0,
                 skip: 0,
                 limit: 0,
-                data: []
+                data: [],
             };
         }
         else {

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

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

package/dist/esm/utils/validateQueryProperty.js

@@ -15,6 +15,6 @@ export const validateQueryProperty = (query, operators = []) => {
         }
     }
     return {
-        ...query
+        ...query,
     };
 };

package/dist/filters/array.d.ts

@@ -1,2 +1,2 @@
 import type { FilterQueryOptions } from "@feathersjs/adapter-commons";
-export declare const filterArray: () => (arr: any, { operators }: FilterQueryOptions) => any;
+export declare const filterArray: (key: string) => (arr: any, { operators }: FilterQueryOptions) => any;

package/dist/filters/array.js

@@ -2,9 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.filterArray = void 0;
 const validateQueryProperty_1 = require("../utils/validateQueryProperty");
-const filterArray = () => (arr, { operators }) => {
+const filterArray = (key) => (arr, { operators }) => {
     if (arr && !Array.isArray(arr)) {
-        throw new Error("Invalid query parameter $and. It has to be an array");
+        throw new Error(`Invalid query parameter '${key}'. It has to be an array`);
     }
     if (Array.isArray(arr)) {
         return arr.map((current) => (0, validateQueryProperty_1.validateQueryProperty)(current, operators));

package/dist/filters/object.d.ts

@@ -0,0 +1,2 @@
+import type { FilterQueryOptions } from "@feathersjs/adapter-commons";
+export declare const filterObject: (key: string) => (obj: any, { operators }: FilterQueryOptions) => import("@feathersjs/feathers/lib").Query;

package/dist/filters/object.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.filterObject = void 0;
+const validateQueryProperty_1 = require("../utils/validateQueryProperty");
+const isObject_1 = __importDefault(require("lodash/isObject"));
+const filterObject = (key) => (obj, { operators }) => {
+    if (obj && !(0, isObject_1.default)(obj)) {
+        throw new Error(`Invalid query parameter: '${key}'. It has to be an object`);
+    }
+    return (0, validateQueryProperty_1.validateQueryProperty)(obj, operators);
+};
+exports.filterObject = filterObject;

package/dist/hooks/checkMulti.d.ts

@@ -1,2 +1,2 @@
-import type { ReturnSyncHook } from "../types";
-export declare function checkMulti(): ReturnSyncHook;
+import type { HookContext } from "@feathersjs/feathers";
+export declare function checkMulti<H extends HookContext = HookContext>(): (context: H) => H;

package/dist/hooks/createRelated.d.ts

@@ -1,3 +1,9 @@
 import type { HookContext } from "@feathersjs/feathers";
-import type { CreateRelatedOptions } from "../types";
-export declare function createRelated<S = Record<string, any>>({ service, multi, data, createItemsInDataArraySeparately }: CreateRelatedOptions<S>): (context: HookContext) => Promise<HookContext>;
+import type { Promisable } from "../typesInternal";
+export interface CreateRelatedOptions<S = Record<string, any>> {
+    service: keyof S;
+    multi?: boolean;
+    data: (item: any, context: HookContext) => Promisable<Record<string, any>>;
+    createItemsInDataArraySeparately?: boolean;
+}
+export declare function createRelated<S = Record<string, any>, H extends HookContext = HookContext>({ service, multi, data, createItemsInDataArraySeparately, }: CreateRelatedOptions<S>): (context: H) => Promise<H>;

package/dist/hooks/createRelated.js

@@ -12,15 +12,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createRelated = void 0;
 const feathers_hooks_common_1 = require("feathers-hooks-common");
 const getItemsIsArray_1 = require("../utils/getItemsIsArray");
-function createRelated({ service, multi = true, data, createItemsInDataArraySeparately = true }) {
+function createRelated({ service, multi = true, data, createItemsInDataArraySeparately = true, }) {
     if (!service || !data) {
         throw "initialize hook 'createRelated' completely!";
     }
     return (context) => __awaiter(this, void 0, void 0, function* () {
-        // @ts-expect-error wait for feathers-hooks-common to update
         (0, feathers_hooks_common_1.checkContext)(context, "after", undefined, "createRelated");
         const { items } = (0, getItemsIsArray_1.getItemsIsArray)(context);
-        let dataToCreate = (yield Promise.all(items.map((item) => __awaiter(this, void 0, void 0, function* () { return data(item, context); })))).filter(x => !!x);
+        let dataToCreate = (yield Promise.all(items.map((item) => __awaiter(this, void 0, void 0, function* () { return data(item, context); })))).filter((x) => !!x);
         if (createItemsInDataArraySeparately) {
             dataToCreate = dataToCreate.flat();
         }

package/dist/hooks/onDelete.d.ts

@@ -1,3 +1,9 @@
 import type { HookContext } from "@feathersjs/feathers";
-import type { OnDeleteOptions } from "../types";
-export declare function onDelete<S = Record<string, any>>(service: keyof S, { keyThere, keyHere, onDelete, blocking }: OnDeleteOptions): (context: HookContext) => Promise<HookContext>;
+export declare type OnDeleteAction = "cascade" | "set null";
+export interface OnDeleteOptions {
+    keyThere: string;
+    keyHere: string;
+    onDelete: OnDeleteAction;
+    blocking?: boolean;
+}
+export declare function onDelete<S = Record<string, any>, H extends HookContext = HookContext>(service: keyof S, { keyThere, keyHere, onDelete, blocking, }: OnDeleteOptions): (context: H) => Promise<H>;

package/dist/hooks/onDelete.js

@@ -12,7 +12,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.onDelete = void 0;
 const feathers_hooks_common_1 = require("feathers-hooks-common");
 const getItemsIsArray_1 = require("../utils/getItemsIsArray");
-function onDelete(service, { keyThere, keyHere = "id", onDelete = "cascade", blocking = true }) {
+function onDelete(service, { keyThere, keyHere = "id", onDelete = "cascade", blocking = true, }) {
     if (!service || !keyThere) {
         throw "initialize hook 'removeRelated' completely!";
     }
@@ -20,10 +20,9 @@ function onDelete(service, { keyThere, keyHere = "id", onDelete = "cascade", blo
         throw "onDelete must be 'cascade' or 'set null'";
     }
     return (context) => __awaiter(this, void 0, void 0, function* () {
-        // @ts-expect-error wait for feathers-hooks-common to update
         (0, feathers_hooks_common_1.checkContext)(context, "after", "remove", "onDelete");
         const { items } = (0, getItemsIsArray_1.getItemsIsArray)(context);
-        let ids = items.map(x => x[keyHere]).filter(x => !!x);
+        let ids = items.map((x) => x[keyHere]).filter((x) => !!x);
         ids = [...new Set(ids)];
         if (!ids || ids.length <= 0) {
             return context;
@@ -31,10 +30,10 @@ function onDelete(service, { keyThere, keyHere = "id", onDelete = "cascade", blo
         const params = {
             query: {
                 [keyThere]: {
-                    $in: ids
-                }
+                    $in: ids,
+                },
             },
-            paginate: false
+            paginate: false,
         };
         let promise;
         if (onDelete === "cascade") {
@@ -42,7 +41,9 @@ function onDelete(service, { keyThere, keyHere = "id", onDelete = "cascade", blo
         }
         else if (onDelete === "set null") {
             const data = { [keyThere]: null };
-            promise = context.app.service(service).patch(null, data, params);
+            promise = context.app
+                .service(service)
+                .patch(null, data, params);
         }
         if (blocking) {
             yield promise;

package/dist/hooks/removeRelated.d.ts

@@ -1,3 +1,8 @@
 import type { HookContext } from "@feathersjs/feathers";
-import type { RemoveRelatedOptions } from "../types";
-export declare function removeRelated<S = Record<string, any>>({ service, keyThere, keyHere, blocking }: RemoveRelatedOptions<S>): (context: HookContext) => Promise<HookContext>;
+export interface RemoveRelatedOptions<S = Record<string, any>> {
+    service: keyof S;
+    keyThere: string;
+    keyHere: string;
+    blocking?: boolean;
+}
+export declare function removeRelated<S = Record<string, any>, H extends HookContext = HookContext>({ service, keyThere, keyHere, blocking, }: RemoveRelatedOptions<S>): (context: H) => Promise<H>;

package/dist/hooks/removeRelated.js

@@ -12,27 +12,28 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.removeRelated = void 0;
 const feathers_hooks_common_1 = require("feathers-hooks-common");
 const getItemsIsArray_1 = require("../utils/getItemsIsArray");
-function removeRelated({ service, keyThere, keyHere = "id", blocking = true }) {
+function removeRelated({ service, keyThere, keyHere = "id", blocking = true, }) {
     if (!service || !keyThere) {
         throw "initialize hook 'removeRelated' completely!";
     }
     return (context) => __awaiter(this, void 0, void 0, function* () {
-        // @ts-expect-error wait for feathers-hooks-common to update
         (0, feathers_hooks_common_1.checkContext)(context, "after", "remove", "removeRelated");
         const { items } = (0, getItemsIsArray_1.getItemsIsArray)(context);
-        let ids = items.map(x => x[keyHere]).filter(x => !!x);
+        let ids = items.map((x) => x[keyHere]).filter((x) => !!x);
         ids = [...new Set(ids)];
         if (!ids || ids.length <= 0) {
             return context;
         }
         // feathers does not accept `paginate: false` for remove, but some adapters need it to work properly
-        const promise = context.app.service(service).remove(null, {
+        const promise = context.app
+            .service(service)
+            .remove(null, {
             query: {
                 [keyThere]: {
-                    $in: ids
-                }
+                    $in: ids,
+                },
             },
-            paginate: false
+            paginate: false,
         });
         if (blocking) {
             yield promise;

package/dist/hooks/runPerItem.d.ts

@@ -1,3 +1,6 @@
-import type { HookRunPerItemOptions, ReturnAsyncHook, Promisable } from "../types";
 import type { HookContext } from "@feathersjs/feathers";
-export declare const runPerItem: (actionPerItem: (item: any, context: HookContext) => Promisable<any>, _options?: HookRunPerItemOptions) => ReturnAsyncHook;
+import type { Promisable } from "../typesInternal";
+export interface HookRunPerItemOptions {
+    wait?: boolean;
+}
+export declare const runPerItem: <H extends HookContext<import("@feathersjs/feathers").Application<any, any>, any> = HookContext<import("@feathersjs/feathers").Application<any, any>, any>>(actionPerItem: (item: any, context: H) => Promisable<any>, _options?: HookRunPerItemOptions) => (context: H) => Promise<H>;

package/dist/hooks/runPerItem.js

@@ -15,7 +15,7 @@ const getItemsIsArray_1 = require("../utils/getItemsIsArray");
 const makeOptions = (options) => {
     options = options || {};
     return Object.assign({
-        wait: true
+        wait: true,
     }, options);
 };
 const runPerItem = (

package/dist/hooks/setData.d.ts

@@ -1,3 +1,8 @@
+import type { HookContext } from "@feathersjs/feathers";
 import type { PropertyPath } from "lodash";
-import type { HookSetDataOptions, ReturnSyncHook } from "../types";
-export declare function setData(from: PropertyPath, to: PropertyPath, _options?: HookSetDataOptions): ReturnSyncHook;
+import type { PredicateWithContext } from "../types";
+export interface HookSetDataOptions {
+    allowUndefined?: boolean;
+    overwrite?: boolean | PredicateWithContext;
+}
+export declare function setData<H extends HookContext = HookContext>(from: PropertyPath, to: PropertyPath, _options?: HookSetDataOptions): (context: H) => H;

package/dist/hooks/setData.js

@@ -11,7 +11,7 @@ const errors_1 = require("@feathersjs/errors");
 const getItemsIsArray_1 = require("../utils/getItemsIsArray");
 const defaultOptions = {
     allowUndefined: false,
-    overwrite: true
+    overwrite: true,
 };
 function setData(from, to, _options) {
     const options = Object.assign({}, defaultOptions, _options);
@@ -22,7 +22,8 @@ function setData(from, to, _options) {
             if (!((_a = context.params) === null || _a === void 0 ? void 0 : _a.provider) || options.allowUndefined === true) {
                 return context;
             }
-            if (!options.overwrite && items.every((item) => (0, has_js_1.default)(item, to))) {
+            if (!options.overwrite &&
+                items.every((item) => (0, has_js_1.default)(item, to))) {
                 return context;
             }
             throw new errors_1.Forbidden(`Expected field ${from.toString()} not available`);

package/dist/index.d.ts

@@ -1,36 +1,21 @@
-import { checkMulti } from "./hooks/checkMulti";
-import { setData } from "./hooks/setData";
-import { runPerItem } from "./hooks/runPerItem";
-export declare const hooks: {
-    checkMulti: typeof checkMulti;
-    setData: typeof setData;
-    runPerItem: (actionPerItem: (item: any, context: import("@feathersjs/feathers/lib").HookContext<import("@feathersjs/feathers/lib").Application<any, any>, any>) => any, _options?: import("./types").HookRunPerItemOptions | undefined) => import("./types").ReturnAsyncHook;
-};
-export { checkMulti };
-export { createRelated } from "./hooks/createRelated";
-export { setData };
-export { removeRelated } from "./hooks/removeRelated";
-export { runPerItem };
-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 { 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 { filterQuery } from "./utils/filterQuery";
-export { getItemsIsArray } from "./utils/getItemsIsArray";
-export { onDelete } from "./hooks/onDelete";
-export { shouldSkip } from "./utils/shouldSkip";
-export { validateQueryProperty } from "./utils/validateQueryProperty";
+export * from "./hooks/checkMulti";
+export * from "./hooks/createRelated";
+export * from "./hooks/onDelete";
+export * from "./hooks/removeRelated";
+export * from "./hooks/runPerItem";
+export * from "./hooks/setData";
+export * from "./mixins/debounce-mixin";
+export * from "./utils/isMulti";
+export * from "./utils/getPaginate";
+export * from "./utils/isPaginated";
+export * from "./utils/mergeQuery";
+export * from "./utils/pushSet";
+export * from "./utils/setResultEmpty";
+export * from "./utils/filterQuery";
+export * from "./utils/getItemsIsArray";
+export * from "./utils/shouldSkip";
+export * from "./utils/markHookForSkip";
+export * from "./utils/validateQueryProperty";
 export { filterArray } from "./filters/array";
+export { filterObject } from "./filters/object";
 export * from "./types";