feathers-utils 2.0.0-0 → 2.0.0-2

package/README.md

@@ -1,11 +1,11 @@
 # feathers-utils
 
-![npm](https://img.shields.io/npm/v/feathers-utils)
-![GitHub Workflow Status](https://img.shields.io/github/workflow/status/fratzinger/feathers-utils/Node.js%20CI)
-![Code Climate maintainability](https://img.shields.io/codeclimate/maintainability/fratzinger/feathers-utils)
-![Code Climate coverage](https://img.shields.io/codeclimate/coverage/fratzinger/feathers-utils)
-![David](https://img.shields.io/david/fratzinger/feathers-casl)
-![npm](https://img.shields.io/npm/dm/feathers-utils)
+[![npm](https://img.shields.io/npm/v/feathers-utils)](https://www.npmjs.com/package/feathers-utils)
+[![GitHub Workflow Status](https://img.shields.io/github/workflow/status/fratzinger/feathers-utils/Node.js%20CI)](https://github.com/fratzinger/feathers-utils/actions/workflows/node.js.yml?query=branch%3Amain)
+[![Code Climate maintainability](https://img.shields.io/codeclimate/maintainability/fratzinger/feathers-utils)](https://codeclimate.com/github/fratzinger/feathers-utils)
+[![Code Climate coverage](https://img.shields.io/codeclimate/coverage/fratzinger/feathers-utils)](https://codeclimate.com/github/fratzinger/feathers-utils)
+[![libraries.io](https://img.shields.io/librariesio/release/npm/feathers-utils)](https://libraries.io/npm/feathers-utils)
+[![npm](https://img.shields.io/npm/dm/feathers-utils)](https://www.npmjs.com/package/feathers-utils)
 [![GitHub license](https://img.shields.io/github/license/fratzinger/feathers-utils)](https://github.com/fratzinger/feathers-utils/blob/main/LICENSE.md)
 
 
@@ -19,8 +19,12 @@ npm i feathers-utils
 
 ### Hooks
 
-- `hooks/checkMulti()`: throws if the request is **multi** data, but the service has `allowsMulti(method)` returns `false`
-- `hooks/setData({ allowUndefined: Boolean })`
+- `checkMulti`: throws if the request is **multi** data, but the service has `allowsMulti(method)` returns `false`
+- `createRelated`: simply create related items from a hook.
+- `onDelete`: simply remove/set null related items from a hook.
+- `removeRelated`: simple remove related items from a hook. Basically `cascade` at feathers level.
+- `runPerItem`: run a function for every item. Meant for `multi:true`.
+- `setData`: map properties from `context` to `data`. Something like `userId: context.params.user.id`
 
 ### Mixins
 
@@ -28,11 +32,14 @@ npm i feathers-utils
 
 ### Utils
 
-- `addHook`: add hooks to specific services
 - `filterQuery`
+- `getItemsIsArray(context)`: returns `{ items: any[], isArray: boolean }`
+- `getPaginate`
 - `isMulti(context) => Boolean`: returns true, if `find`, `create/patch/remove`: multi
+- `isPaginated`
 - `markHookForSkip`: add hookName to `context.params.skipHooks` - also see `shouldSkip`
 - `mergeQuery`: deeply merges queries
 - `mergeArrays`: merges arrays with intersection options
 - `pushSet`: if existing array: *push*, else *set*
+- `setResultEmpty`
 - `shouldSkip`: checks `context.params.skipHooks` for `'all' | '${hookName}' | '${type}:${hookName}'` - also see `markHookForSkip`

package/dist/esm/filters/array.d.ts

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

package/dist/esm/filters/array.js

@@ -0,0 +1,10 @@
+import { validateQueryProperty } from "../utils/validateQueryProperty";
+export const filterArray = () => (arr, { operators }) => {
+    if (arr && !Array.isArray(arr)) {
+        throw new Error("Invalid query parameter $and. It has to be an array");
+    }
+    if (Array.isArray(arr)) {
+        return arr.map((current) => validateQueryProperty(current, operators));
+    }
+    return arr;
+};

package/dist/esm/hooks/checkMulti.d.ts

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

package/dist/esm/hooks/createRelated.d.ts

@@ -0,0 +1,3 @@
+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>;

package/dist/esm/hooks/createRelated.js

@@ -0,0 +1,26 @@
+import { checkContext } from "feathers-hooks-common";
+import { getItemsIsArray } from "../utils/getItemsIsArray";
+export function createRelated({ service, multi = true, data, createItemsInDataArraySeparately = true }) {
+    if (!service || !data) {
+        throw "initialize hook 'createRelated' completely!";
+    }
+    return async (context) => {
+        // @ts-expect-error wait for feathers-hooks-common to update
+        checkContext(context, "after", undefined, "createRelated");
+        const { items } = getItemsIsArray(context);
+        let dataToCreate = (await Promise.all(items.map(async (item) => data(item, context)))).filter(x => !!x);
+        if (createItemsInDataArraySeparately) {
+            dataToCreate = dataToCreate.flat();
+        }
+        if (!dataToCreate || dataToCreate.length <= 0) {
+            return context;
+        }
+        if (multi) {
+            await context.app.service(service).create(dataToCreate);
+        }
+        else {
+            await Promise.all(dataToCreate.map(async (item) => context.app.service(service).create(item)));
+        }
+        return context;
+    };
+}

package/dist/esm/hooks/onDelete.d.ts

@@ -0,0 +1,3 @@
+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>;

package/dist/esm/hooks/onDelete.js

@@ -0,0 +1,40 @@
+import { checkContext } from "feathers-hooks-common";
+import { getItemsIsArray } from "../utils/getItemsIsArray";
+export function onDelete(service, { keyThere, keyHere = "id", onDelete = "cascade", blocking = true }) {
+    if (!service || !keyThere) {
+        throw "initialize hook 'removeRelated' completely!";
+    }
+    if (!["cascade", "set null"].includes(onDelete)) {
+        throw "onDelete must be 'cascade' or 'set null'";
+    }
+    return async (context) => {
+        // @ts-expect-error wait for feathers-hooks-common to update
+        checkContext(context, "after", "remove", "onDelete");
+        const { items } = getItemsIsArray(context);
+        let ids = items.map(x => x[keyHere]).filter(x => !!x);
+        ids = [...new Set(ids)];
+        if (!ids || ids.length <= 0) {
+            return context;
+        }
+        const params = {
+            query: {
+                [keyThere]: {
+                    $in: ids
+                }
+            },
+            paginate: false
+        };
+        let promise;
+        if (onDelete === "cascade") {
+            promise = context.app.service(service).remove(null, params);
+        }
+        else if (onDelete === "set null") {
+            const data = { [keyThere]: null };
+            promise = context.app.service(service).patch(null, data, params);
+        }
+        if (blocking) {
+            await promise;
+        }
+        return context;
+    };
+}

package/dist/esm/hooks/removeRelated.d.ts

@@ -0,0 +1,3 @@
+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>;

package/dist/esm/hooks/removeRelated.js

@@ -0,0 +1,30 @@
+import { checkContext } from "feathers-hooks-common";
+import { getItemsIsArray } from "../utils/getItemsIsArray";
+export function removeRelated({ service, keyThere, keyHere = "id", blocking = true }) {
+    if (!service || !keyThere) {
+        throw "initialize hook 'removeRelated' completely!";
+    }
+    return async (context) => {
+        // @ts-expect-error wait for feathers-hooks-common to update
+        checkContext(context, "after", "remove", "removeRelated");
+        const { items } = getItemsIsArray(context);
+        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, {
+            query: {
+                [keyThere]: {
+                    $in: ids
+                }
+            },
+            paginate: false
+        });
+        if (blocking) {
+            await promise;
+        }
+        return context;
+    };
+}

package/dist/esm/hooks/runPerItem.d.ts

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

package/dist/esm/hooks/runPerItem.js

@@ -1,20 +1,20 @@
-import { getItems } from "feathers-hooks-common";
 import { shouldSkip } from "../utils/shouldSkip";
+import { getItemsIsArray } from "../utils/getItemsIsArray";
 const makeOptions = (options) => {
     options = options || {};
     return Object.assign({
         wait: true
     }, options);
 };
-export const runPerItem = (actionPerItem, options) => {
-    options = makeOptions(options);
+export const runPerItem = (
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+actionPerItem, _options) => {
+    const options = makeOptions(_options);
     return async (context) => {
         if (shouldSkip("runForItems", context)) {
             return context;
         }
-        //@ts-expect-error type error because feathers-hooks-common is feathers@4
-        let items = getItems(context);
-        items = (Array.isArray(items)) ? items : [items];
+        const { items } = getItemsIsArray(context);
         const promises = items.map(async (item) => {
             await actionPerItem(item, context);
         });

package/dist/esm/hooks/setData.d.ts

@@ -1,4 +1,3 @@
-import type { HookContext } from "@feathersjs/feathers";
-import type { HookSetDataOptions } from "../types";
 import type { PropertyPath } from "lodash";
-export declare function setData(from: PropertyPath, to: PropertyPath, _options?: HookSetDataOptions): ((context: HookContext) => HookContext);
+import type { HookSetDataOptions, ReturnSyncHook } from "../types";
+export declare function setData(from: PropertyPath, to: PropertyPath, _options?: HookSetDataOptions): ReturnSyncHook;

package/dist/esm/hooks/setData.js

@@ -1,8 +1,8 @@
-import _get from "lodash/get";
-import _set from "lodash/set";
-import _has from "lodash/has";
-import { getItems } from "feathers-hooks-common";
+import _get from "lodash/get.js";
+import _set from "lodash/set.js";
+import _has from "lodash/has.js";
 import { Forbidden } from "@feathersjs/errors";
+import { getItemsIsArray } from "../utils/getItemsIsArray";
 const defaultOptions = {
     allowUndefined: false,
     overwrite: true
@@ -10,9 +10,7 @@ const defaultOptions = {
 export function setData(from, to, _options) {
     const options = Object.assign({}, defaultOptions, _options);
     return (context) => {
-        //@ts-expect-error type error because feathers-hooks-common is feathers@4
-        let items = getItems(context);
-        items = (Array.isArray(items)) ? items : [items];
+        const { items } = getItemsIsArray(context);
         if (!_has(context, from)) {
             if (!context.params?.provider || options.allowUndefined === true) {
                 return context;
@@ -24,7 +22,14 @@ export function setData(from, to, _options) {
         }
         const val = _get(context, from);
         items.forEach((item) => {
-            if (!options.overwrite && _has(item, to)) {
+            let overwrite;
+            if (typeof options.overwrite === "function") {
+                overwrite = options.overwrite(item, context);
+            }
+            else {
+                overwrite = options.overwrite;
+            }
+            if (!overwrite && _has(item, to)) {
                 return;
             }
             _set(item, to, val);

package/dist/esm/index.d.ts

@@ -4,10 +4,12 @@ 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) => (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>>;
+    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: {
@@ -25,6 +27,10 @@ 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";
+export { getItemsIsArray } from "./utils/getItemsIsArray";
+export { onDelete } from "./hooks/onDelete";
+export { shouldSkip } from "./utils/shouldSkip";
+export { validateQueryProperty } from "./utils/validateQueryProperty";
+export { filterArray } from "./filters/array";
 export * from "./types";

package/dist/esm/index.js

@@ -8,7 +8,9 @@ export const hooks = {
     runPerItem
 };
 export { checkMulti };
+export { createRelated } from "./hooks/createRelated";
 export { setData };
+export { removeRelated } from "./hooks/removeRelated";
 export { runPerItem };
 import { debounceMixin, DebouncedStore } from "./mixins/debounce-mixin";
 export const mixins = {
@@ -25,6 +27,11 @@ 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";
+export { getItemsIsArray } from "./utils/getItemsIsArray";
+export { onDelete } from "./hooks/onDelete";
+export { shouldSkip } from "./utils/shouldSkip";
+export { validateQueryProperty } from "./utils/validateQueryProperty";
+// query filters
+export { filterArray } from "./filters/array";
 export * from "./types";

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

@@ -7,7 +7,7 @@ export declare class DebouncedStore {
     private _options;
     private _isRunningById;
     _queueById: Record<string, DebouncedFunc<((id: Id, action: DebouncedFunctionApp) => void | Promise<void>)>>;
-    add: (id: Id, action: (app?: Application<any, any> | undefined) => void | Promise<void>) => void | Promise<void> | undefined;
+    add: (id: Id, action: (app?: Application) => void | Promise<void>) => void | Promise<void> | undefined;
     constructor(app: Application, options?: Partial<DebouncedStoreOptions>);
     private unbounced;
     private debounceById;

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

@@ -1,4 +1,4 @@
-import _debounce from "lodash/debounce";
+import _debounce from "lodash/debounce.js";
 export const makeDefaultOptions = () => {
     return {
         leading: false,

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

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

package/dist/esm/types.d.ts

@@ -1,13 +1,19 @@
-import type { Application } from "@feathersjs/feathers";
-import type { AdapterService } from "@feathersjs/adapter-commons";
+import type { Application, HookContext } from "@feathersjs/feathers";
+import type { AdapterBase, FilterQueryOptions as PlainFilterQueryOptions } from "@feathersjs/adapter-commons";
 export declare type Path = Array<string | number>;
+export declare type MaybeArray<T> = T | T[];
+export declare type Promisable<T> = T | Promise<T>;
 export declare type HookType = "before" | "after" | "error";
 export declare type ServiceMethodName = "find" | "get" | "create" | "update" | "patch" | "remove";
+export declare type ReturnSyncHook = (context: HookContext) => HookContext;
+export declare type ReturnAsyncHook = (context: HookContext) => Promise<HookContext>;
 export declare type Handle = "target" | "source" | "combine" | "intersect" | "intersectOrFull";
 export declare type FirstLast = "first" | "last";
+export declare type Predicate<T = any> = (item: T) => boolean;
+export declare type PredicateWithContext<T = any> = (item: T, context: HookContext) => boolean;
 export interface HookSetDataOptions {
     allowUndefined?: boolean;
-    overwrite?: boolean;
+    overwrite?: boolean | PredicateWithContext;
 }
 export interface AddHookOptions {
     types: HookType[];
@@ -19,6 +25,25 @@ export interface AddHookOptions {
 export interface HookRunPerItemOptions {
     wait?: boolean;
 }
+export interface RemoveRelatedOptions<S = Record<string, any>> {
+    service: keyof S;
+    keyThere: string;
+    keyHere: string;
+    blocking?: boolean;
+}
+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 type OnDeleteAction = "cascade" | "set null";
+export interface OnDeleteOptions {
+    keyThere: string;
+    keyHere: string;
+    onDelete: OnDeleteAction;
+    blocking?: boolean;
+}
 export interface InitDebounceMixinOptions {
     default: Partial<DebouncedStoreOptions>;
     blacklist: string[];
@@ -44,17 +69,11 @@ export interface MergeQueryOptions<T> extends FilterQueryOptions<T> {
     };
 }
 export interface FilterQueryOptions<T> {
-    service?: AdapterService<T>;
-    operators?: string[];
-    filters?: string[];
-}
-export interface PlainFilterQueryOptions {
-    operators?: string[];
-    filters?: string[];
-}
-export interface FilterQueryResult {
-    filters: Record<string, unknown>;
-    query: Record<string, unknown>;
-    paginate?: unknown;
-    [key: string]: unknown;
+    service?: AdapterBase<T>;
+    operators?: PlainFilterQueryOptions["operators"];
+    filters?: PlainFilterQueryOptions["filters"];
+}
+export interface GetItemsIsArrayOptions<T = any> {
+    items: T[];
+    isArray: boolean;
 }

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

@@ -1,3 +1,3 @@
-import type { FilterQueryOptions, FilterQueryResult } from "../types";
 import type { Query } from "@feathersjs/feathers";
-export declare function filterQuery<T>(query: Query, options?: FilterQueryOptions<T>): FilterQueryResult;
+import type { FilterQueryOptions } from "../types";
+export declare function filterQuery<T>(query: Query, _options?: FilterQueryOptions<T>): any;

package/dist/esm/utils/filterQuery.js

@@ -1,12 +1,12 @@
-import { filterQuery as plainFilterQuery } from "@feathersjs/adapter-commons";
-export function filterQuery(query, options) {
+import { filterQuery as plainFilterQuery, } from "@feathersjs/adapter-commons";
+export function filterQuery(query, _options) {
     query = query || {};
-    options = options || {};
-    if (options?.service) {
-        const { service } = options;
+    _options = _options || {};
+    const { service, ...options } = _options;
+    if (service) {
         const operators = options.operators
             ? options.operators
-            : service.options?.whitelist;
+            : service.options?.operators;
         const filters = options.filters
             ? options.filters
             : service.options?.filters;
@@ -17,7 +17,9 @@ export function filterQuery(query, options) {
         if (filters) {
             optionsForFilterQuery.filters = filters;
         }
-        if (typeof service?.filterQuery === "function") {
+        // @ts-expect-error service has no filterQuery method
+        if (service && "filterQuery" in service && typeof service.filterQuery === "function") {
+            // @ts-expect-error service has no filterQuery method
             return service.filterQuery({ query }, optionsForFilterQuery);
         }
         else {

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

@@ -0,0 +1,3 @@
+import type { HookContext } from "@feathersjs/feathers";
+import type { GetItemsIsArrayOptions } from "..";
+export declare const getItemsIsArray: <T = any>(context: HookContext) => GetItemsIsArrayOptions<T>;

package/dist/esm/utils/getItemsIsArray.js

@@ -0,0 +1,18 @@
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const getItemsIsArray = (context) => {
+    let itemOrItems = context.type === "before"
+        ? context.data
+        : context.result;
+    itemOrItems = itemOrItems && context.method === "find"
+        ? (itemOrItems.data || itemOrItems)
+        : itemOrItems;
+    const isArray = Array.isArray(itemOrItems);
+    return {
+        items: (isArray)
+            ? itemOrItems
+            : (itemOrItems != null)
+                ? [itemOrItems]
+                : [],
+        isArray
+    };
+};

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

@@ -1,4 +1,4 @@
-import { HookContext } from "@feathersjs/feathers";
+import type { HookContext } from "@feathersjs/feathers";
 interface PaginationOptions {
     default: number;
     max: number;

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

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

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

@@ -1,3 +1,3 @@
 import type { HookContext } from "@feathersjs/feathers";
-import type { HookType } from "feathers-hooks-common/types";
-export declare function markHookForSkip<T>(hookName: string, type: "all" | HookType | HookType[], context?: Partial<HookContext<T>>): Partial<HookContext<T>>;
+import type { HookType, MaybeArray } from "../types";
+export declare function markHookForSkip<T>(hookName: string, type: "all" | MaybeArray<HookType>, context?: Partial<HookContext<T>>): Partial<HookContext<T>>;

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

@@ -1,10 +1,10 @@
-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 _get from "lodash/get.js";
+import _has from "lodash/has.js";
+import _isEmpty from "lodash/isEmpty.js";
+import _isEqual from "lodash/isEqual.js";
+import _merge from "lodash/merge.js";
+import _set from "lodash/set.js";
+import _uniqWith from "lodash/uniqWith.js";
 import { mergeArrays } from "./mergeArrays";
 import { filterQuery } from "../filterQuery";
 import { Forbidden } from "@feathersjs/errors";
@@ -227,12 +227,21 @@ function makeDefaultOptions(options) {
     }
     return options;
 }
+function moveProperty(source, target, key) {
+    if (!Object.prototype.hasOwnProperty.call(source, key)) {
+        return;
+    }
+    target[key] = source[key];
+    delete source[key];
+}
 export function mergeQuery(target, source, options) {
     const fullOptions = makeDefaultOptions(options);
     const { filters: targetFilters, query: targetQuery } = filterQuery(target, {
         operators: fullOptions.operators,
         service: fullOptions.service
     });
+    moveProperty(targetFilters, targetQuery, "$or");
+    moveProperty(targetFilters, targetQuery, "$and");
     if (target.$limit) {
         targetFilters.$limit = target.$limit;
     }
@@ -242,6 +251,8 @@ export function mergeQuery(target, source, options) {
         operators: fullOptions.operators,
         service: fullOptions.service
     });
+    moveProperty(sourceFilters, sourceQuery, "$or");
+    moveProperty(sourceFilters, sourceQuery, "$and");
     if (source.$limit) {
         sourceFilters.$limit = source.$limit;
     }

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

@@ -1,2 +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[];
+export declare const pushSet: (obj: Record<string, unknown>, path: string | Path, val: unknown, options?: PushSetOptions) => unknown[];

package/dist/esm/utils/pushSet.js

@@ -1,6 +1,6 @@
-import _isEqual from "lodash/isEqual";
-import _get from "lodash/get";
-import _set from "lodash/set";
+import _isEqual from "lodash/isEqual.js";
+import _get from "lodash/get.js";
+import _set from "lodash/set.js";
 export const pushSet = (obj, path, val, options) => {
     options = options || {};
     let arr = _get(obj, path);

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

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

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

@@ -0,0 +1,2 @@
+import type { Query } from "@feathersjs/feathers";
+export declare const validateQueryProperty: (query: any, operators?: string[]) => Query;

package/dist/esm/utils/validateQueryProperty.js

@@ -0,0 +1,20 @@
+import { _ } from "@feathersjs/commons";
+import { BadRequest } from "@feathersjs/errors";
+const isPlainObject = (value) => _.isObject(value) && value.constructor === {}.constructor;
+export const validateQueryProperty = (query, operators = []) => {
+    if (!isPlainObject(query)) {
+        return query;
+    }
+    for (const key of Object.keys(query)) {
+        if (key.startsWith("$") && !operators.includes(key)) {
+            throw new BadRequest(`Invalid query parameter ${key}`, query);
+        }
+        const value = query[key];
+        if (isPlainObject(value)) {
+            query[key] = validateQueryProperty(value, operators);
+        }
+    }
+    return {
+        ...query
+    };
+};

package/dist/filters/array.d.ts

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

package/dist/filters/array.js

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

package/dist/hooks/checkMulti.d.ts

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

package/dist/hooks/createRelated.d.ts

@@ -0,0 +1,3 @@
+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>;