feathers-utils 2.0.0 → 2.1.0

package/dist/index.cjs

@@ -5,10 +5,11 @@ const _merge = require('lodash/merge.js');
 const _isEmpty = require('lodash/isEmpty.js');
 const _get = require('lodash/get.js');
 const _has = require('lodash/has.js');
-const _isEqual = require('lodash/isEqual.js');
 const _set = require('lodash/set.js');
 const _uniqWith = require('lodash/uniqWith.js');
+const fastEquals = require('fast-equals');
 const adapterCommons = require('@feathersjs/adapter-commons');
+const _isEqual = require('lodash/isEqual.js');
 const commons = require('@feathersjs/commons');
 const feathersHooksCommon = require('feathers-hooks-common');
 const _debounce = require('lodash/debounce.js');
@@ -53,9 +54,10 @@ function mergeArrays(targetArr, sourceArr, handle, prependKey, actionOnEmptyInte
   return void 0;
 }
 
-const hasOwnProperty = (obj, key) => {
-  return Object.prototype.hasOwnProperty.call(obj, key);
+const hasOwnProperty = (obj, ...keys) => {
+  return keys.some((x) => Object.prototype.hasOwnProperty.call(obj, x));
 };
+
 function handleArray(target, source, key, options) {
   const targetVal = _get(target, key);
   const sourceVal = _get(source, key);
@@ -120,7 +122,7 @@ function handleCircular(target, source, prependKey, options) {
   };
   const targetVal = getTargetVal();
   const sourceVal = getSourceVal();
-  if (_isEqual(targetVal, sourceVal)) {
+  if (fastEquals.deepEqual(targetVal, sourceVal)) {
     return;
   }
   if (defaultHandle === "source") {
@@ -156,17 +158,17 @@ function handleCircular(target, source, prependKey, options) {
       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)) {
+      if ($in.length === 1 && fastEquals.deepEqual($in[0], otherVal)) {
         _set(target, prependKey, otherVal);
         return;
       } else if (defaultHandle === "combine") {
-        if (!$in.some((x) => _isEqual(x, otherVal))) {
+        if (!$in.some((x) => fastEquals.deepEqual(x, otherVal))) {
           $in.push(otherVal);
         }
         _set(target, `${prependKey}.$in`, $in);
         return;
       } else if (defaultHandle === "intersect") {
-        if ($in.some((x) => _isEqual(x, otherVal))) {
+        if ($in.some((x) => fastEquals.deepEqual(x, otherVal))) {
           _set(target, prependKey, otherVal);
         } else {
           actionOnEmptyIntersect(target, source, prependKey);
@@ -183,7 +185,7 @@ function handleCircular(target, source, prependKey, options) {
     if (key === "$or") {
       if (defaultHandle === "combine") {
         const newVals = sourceVal.filter(
-          (x) => !targetVal.some((y) => _isEqual(x, y))
+          (x) => !targetVal.some((y) => fastEquals.deepEqual(x, y))
         );
         targetVal.push(...newVals);
       } else if (defaultHandle === "intersect") {
@@ -217,7 +219,7 @@ function handleCircular(target, source, prependKey, options) {
         return;
       } else if (defaultHandle === "intersect") {
         const newVals = sourceVal.filter(
-          (x) => !targetVal.some((y) => _isEqual(x, y))
+          (x) => !targetVal.some((y) => fastEquals.deepEqual(x, y))
         );
         targetVal.push(...newVals);
         return;
@@ -230,7 +232,7 @@ function handleCircular(target, source, prependKey, options) {
         return;
       } else if (defaultHandle === "intersect") {
         const $in = targetVal.filter(
-          (x) => sourceVal.some((y) => _isEqual(x, y))
+          (x) => sourceVal.some((y) => fastEquals.deepEqual(x, y))
         );
         if ($in.length === 0) {
           actionOnEmptyIntersect(target, source, prependKey);
@@ -257,13 +259,10 @@ function handleCircular(target, source, prependKey, options) {
   }
 }
 function makeDefaultOptions$1(options) {
-  options = options || {};
-  options.defaultHandle = options.defaultHandle || "combine";
-  options.useLogicalConjunction = Object.prototype.hasOwnProperty.call(
-    options,
-    "useLogicalConjunction"
-  ) ? options.useLogicalConjunction : false;
-  options.actionOnEmptyIntersect = options.actionOnEmptyIntersect || (() => {
+  options ?? (options = {});
+  options.defaultHandle ?? (options.defaultHandle = "combine");
+  options.useLogicalConjunction ?? (options.useLogicalConjunction = false);
+  options.actionOnEmptyIntersect ?? (options.actionOnEmptyIntersect = () => {
     throw new errors.Forbidden("You're not allowed to make this request");
   });
   options.handle = options.handle || {};
@@ -272,12 +271,14 @@ function makeDefaultOptions$1(options) {
   }
   return options;
 }
-function moveProperty(source, target, key) {
-  if (!Object.prototype.hasOwnProperty.call(source, key)) {
-    return;
-  }
-  target[key] = source[key];
-  delete source[key];
+function moveProperty(from, to, ...keys) {
+  keys.forEach((key) => {
+    if (!hasOwnProperty(from, key)) {
+      return;
+    }
+    to[key] = from[key];
+    delete from[key];
+  });
 }
 function getParentProp(target, path) {
   if (path.length <= 1) {
@@ -311,7 +312,41 @@ function arrayWithoutDuplicates(target) {
   if (!target || !Array.isArray(target)) {
     return target;
   }
-  return _uniqWith(target, _isEqual);
+  return _uniqWith(target, fastEquals.deepEqual);
+}
+function isQueryMoreExplicitThanQuery(target, source) {
+  if (!target || !source) {
+    return;
+  }
+  const targetKeys = Object.keys(target);
+  const sourceKeys = Object.keys(source);
+  if (!sourceKeys.length) {
+    return target;
+  }
+  if (!targetKeys.length) {
+    return source;
+  }
+  if (targetKeys.every((key) => fastEquals.deepEqual(target[key], source[key]))) {
+    return source;
+  }
+  if (sourceKeys.every((key) => fastEquals.deepEqual(target[key], source[key]))) {
+    return target;
+  }
+  return;
+}
+function areQueriesOverlapping(target, source) {
+  if (!target || !source) {
+    return false;
+  }
+  const targetKeys = Object.keys(target);
+  const sourceKeys = Object.keys(source);
+  if (!sourceKeys.length || !targetKeys.length) {
+    return false;
+  }
+  if (targetKeys.some((x) => sourceKeys.includes(x)) || sourceKeys.some((x) => targetKeys.includes(x))) {
+    return true;
+  }
+  return false;
 }
 
 function filterQuery(query, _options) {
@@ -337,16 +372,15 @@ function filterQuery(query, _options) {
   return adapterCommons.filterQuery(query, options);
 }
 
-function mergeQuery(target, source, options) {
-  const fullOptions = makeDefaultOptions$1(options);
+function mergeQuery(target, source, _options) {
+  const options = makeDefaultOptions$1(_options);
   const { filters: targetFilters, query: targetQuery } = filterQuery(target, {
-    operators: fullOptions.operators,
-    filters: fullOptions.filters,
-    service: fullOptions.service
+    operators: options.operators,
+    filters: options.filters,
+    service: options.service
   });
-  moveProperty(targetFilters, targetQuery, "$or");
-  moveProperty(targetFilters, targetQuery, "$and");
-  if (target.$limit) {
+  moveProperty(targetFilters, targetQuery, "$or", "$and");
+  if ("$limit" in target) {
     targetFilters.$limit = target.$limit;
   }
   let {
@@ -354,27 +388,40 @@ function mergeQuery(target, source, options) {
     filters: sourceFilters,
     query: sourceQuery
   } = filterQuery(source, {
-    operators: fullOptions.operators,
-    filters: fullOptions.filters,
-    service: fullOptions.service
+    operators: options.operators,
+    filters: options.filters,
+    service: options.service
   });
-  moveProperty(sourceFilters, sourceQuery, "$or");
-  moveProperty(sourceFilters, sourceQuery, "$and");
+  moveProperty(sourceFilters, sourceQuery, "$or", "$and");
   if (source.$limit) {
     sourceFilters.$limit = source.$limit;
   }
-  if (target && !Object.prototype.hasOwnProperty.call(target, "$limit") && Object.prototype.hasOwnProperty.call(targetFilters, "$limit")) {
+  if (target && !hasOwnProperty(target, "$limit") && hasOwnProperty(targetFilters, "$limit")) {
     delete targetFilters.$limit;
   }
-  if (source && !Object.prototype.hasOwnProperty.call(source, "$limit") && Object.prototype.hasOwnProperty.call(sourceFilters, "$limit")) {
+  if (source && !hasOwnProperty(source, "$limit") && hasOwnProperty(sourceFilters, "$limit")) {
     delete sourceFilters.$limit;
   }
-  handleArray(targetFilters, sourceFilters, ["$select"], fullOptions);
+  handleArray(targetFilters, sourceFilters, ["$select"], options);
   delete sourceFilters["$select"];
   _merge(targetFilters, sourceFilters);
-  if (options?.useLogicalConjunction && (options.defaultHandle === "combine" || options.defaultHandle === "intersect") && !_isEmpty(targetQuery)) {
+  const subsetQuery = isQueryMoreExplicitThanQuery(targetQuery, sourceQuery);
+  if (options.defaultHandle === "intersect" && !!subsetQuery && !hasOwnProperty(targetQuery, "$or", "$and") && !hasOwnProperty(sourceQuery, "$or", "$and")) {
+    return {
+      ...targetFilters,
+      ...subsetQuery
+    };
+  }
+  if (options.defaultHandle === "intersect" && !areQueriesOverlapping(targetQuery, sourceQuery) && !hasOwnProperty(targetQuery, "$or", "$and") && !hasOwnProperty(sourceQuery, "$or", "$and")) {
+    return {
+      ...targetFilters,
+      ...targetQuery,
+      ...sourceQuery
+    };
+  }
+  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)) {
+    if (hasOwnProperty(sourceQuery, logicalOp)) {
       const andOr = sourceQuery[logicalOp];
       delete sourceQuery[logicalOp];
       andOr.push(sourceQuery);
@@ -386,10 +433,12 @@ function mergeQuery(target, source, options) {
   const keys = Object.keys(sourceQuery);
   for (let i = 0, n = keys.length; i < n; i++) {
     const key = keys[i];
-    handleCircular(targetQuery, sourceQuery, [key], fullOptions);
+    handleCircular(targetQuery, sourceQuery, [key], options);
   }
-  const result = Object.assign({}, targetFilters, targetQuery);
-  return result;
+  return {
+    ...targetFilters,
+    ...targetQuery
+  };
 }
 
 const getItemsIsArray = (context, options) => {
@@ -413,7 +462,7 @@ const getItemsIsArray = (context, options) => {
 };
 
 const getPaginate = (context) => {
-  if (Object.prototype.hasOwnProperty.call(context.params, "paginate")) {
+  if (hasOwnProperty(context.params, "paginate")) {
     return context.params.paginate || void 0;
   }
   if (context.params.paginate === false) {
@@ -717,12 +766,10 @@ function removeRelated({
 
 const makeOptions = (options) => {
   options = options || {};
-  return Object.assign(
-    {
-      wait: true
-    },
-    options
-  );
+  return {
+    wait: true,
+    ...options
+  };
 };
 const runPerItem = (actionPerItem, _options) => {
   const options = makeOptions(_options);
@@ -746,11 +793,10 @@ const defaultOptions = {
   overwrite: true
 };
 function setData(from, to, _options) {
-  const options = Object.assign(
-    {},
-    defaultOptions,
-    _options
-  );
+  const options = {
+    ...defaultOptions,
+    ..._options
+  };
   return (context) => {
     if (shouldSkip("setData", context)) {
       return context;

package/dist/index.d.ts

@@ -145,7 +145,14 @@ interface MergeQueryOptions<T> extends FilterQueryOptions<T> {
 
 declare function mergeArrays<T>(targetArr: T[], sourceArr: T[], handle: Handle, prependKey?: Path, actionOnEmptyIntersect?: ActionOnEmptyIntersect): T[] | undefined;
 
-declare function mergeQuery<T>(target: Query, source: Query, options?: Partial<MergeQueryOptions<T>>): Query;
+/**
+ * Merges two queries into one.
+ * @param target Query to be merged into
+ * @param source Query to be merged from
+ * @param _options
+ * @returns Query
+ */
+declare function mergeQuery<T = any>(target: Query, source: Query, _options?: Partial<MergeQueryOptions<T>>): Query;
 
 /**
  * util to get paginate options from context

package/dist/index.mjs

@@ -3,10 +3,11 @@ import _merge from 'lodash/merge.js';
 import _isEmpty from 'lodash/isEmpty.js';
 import _get from 'lodash/get.js';
 import _has from 'lodash/has.js';
-import _isEqual from 'lodash/isEqual.js';
 import _set from 'lodash/set.js';
 import _uniqWith from 'lodash/uniqWith.js';
+import { deepEqual } from 'fast-equals';
 import { filterQuery as filterQuery$1 } from '@feathersjs/adapter-commons';
+import _isEqual from 'lodash/isEqual.js';
 import { _ } from '@feathersjs/commons';
 import { checkContext } from 'feathers-hooks-common';
 import _debounce from 'lodash/debounce.js';
@@ -51,9 +52,10 @@ function mergeArrays(targetArr, sourceArr, handle, prependKey, actionOnEmptyInte
   return void 0;
 }
 
-const hasOwnProperty = (obj, key) => {
-  return Object.prototype.hasOwnProperty.call(obj, key);
+const hasOwnProperty = (obj, ...keys) => {
+  return keys.some((x) => Object.prototype.hasOwnProperty.call(obj, x));
 };
+
 function handleArray(target, source, key, options) {
   const targetVal = _get(target, key);
   const sourceVal = _get(source, key);
@@ -118,7 +120,7 @@ function handleCircular(target, source, prependKey, options) {
   };
   const targetVal = getTargetVal();
   const sourceVal = getSourceVal();
-  if (_isEqual(targetVal, sourceVal)) {
+  if (deepEqual(targetVal, sourceVal)) {
     return;
   }
   if (defaultHandle === "source") {
@@ -154,17 +156,17 @@ function handleCircular(target, source, prependKey, options) {
       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)) {
+      if ($in.length === 1 && deepEqual($in[0], otherVal)) {
         _set(target, prependKey, otherVal);
         return;
       } else if (defaultHandle === "combine") {
-        if (!$in.some((x) => _isEqual(x, otherVal))) {
+        if (!$in.some((x) => deepEqual(x, otherVal))) {
           $in.push(otherVal);
         }
         _set(target, `${prependKey}.$in`, $in);
         return;
       } else if (defaultHandle === "intersect") {
-        if ($in.some((x) => _isEqual(x, otherVal))) {
+        if ($in.some((x) => deepEqual(x, otherVal))) {
           _set(target, prependKey, otherVal);
         } else {
           actionOnEmptyIntersect(target, source, prependKey);
@@ -181,7 +183,7 @@ function handleCircular(target, source, prependKey, options) {
     if (key === "$or") {
       if (defaultHandle === "combine") {
         const newVals = sourceVal.filter(
-          (x) => !targetVal.some((y) => _isEqual(x, y))
+          (x) => !targetVal.some((y) => deepEqual(x, y))
         );
         targetVal.push(...newVals);
       } else if (defaultHandle === "intersect") {
@@ -215,7 +217,7 @@ function handleCircular(target, source, prependKey, options) {
         return;
       } else if (defaultHandle === "intersect") {
         const newVals = sourceVal.filter(
-          (x) => !targetVal.some((y) => _isEqual(x, y))
+          (x) => !targetVal.some((y) => deepEqual(x, y))
         );
         targetVal.push(...newVals);
         return;
@@ -228,7 +230,7 @@ function handleCircular(target, source, prependKey, options) {
         return;
       } else if (defaultHandle === "intersect") {
         const $in = targetVal.filter(
-          (x) => sourceVal.some((y) => _isEqual(x, y))
+          (x) => sourceVal.some((y) => deepEqual(x, y))
         );
         if ($in.length === 0) {
           actionOnEmptyIntersect(target, source, prependKey);
@@ -255,13 +257,10 @@ function handleCircular(target, source, prependKey, options) {
   }
 }
 function makeDefaultOptions$1(options) {
-  options = options || {};
-  options.defaultHandle = options.defaultHandle || "combine";
-  options.useLogicalConjunction = Object.prototype.hasOwnProperty.call(
-    options,
-    "useLogicalConjunction"
-  ) ? options.useLogicalConjunction : false;
-  options.actionOnEmptyIntersect = options.actionOnEmptyIntersect || (() => {
+  options ?? (options = {});
+  options.defaultHandle ?? (options.defaultHandle = "combine");
+  options.useLogicalConjunction ?? (options.useLogicalConjunction = false);
+  options.actionOnEmptyIntersect ?? (options.actionOnEmptyIntersect = () => {
     throw new Forbidden("You're not allowed to make this request");
   });
   options.handle = options.handle || {};
@@ -270,12 +269,14 @@ function makeDefaultOptions$1(options) {
   }
   return options;
 }
-function moveProperty(source, target, key) {
-  if (!Object.prototype.hasOwnProperty.call(source, key)) {
-    return;
-  }
-  target[key] = source[key];
-  delete source[key];
+function moveProperty(from, to, ...keys) {
+  keys.forEach((key) => {
+    if (!hasOwnProperty(from, key)) {
+      return;
+    }
+    to[key] = from[key];
+    delete from[key];
+  });
 }
 function getParentProp(target, path) {
   if (path.length <= 1) {
@@ -309,7 +310,41 @@ function arrayWithoutDuplicates(target) {
   if (!target || !Array.isArray(target)) {
     return target;
   }
-  return _uniqWith(target, _isEqual);
+  return _uniqWith(target, deepEqual);
+}
+function isQueryMoreExplicitThanQuery(target, source) {
+  if (!target || !source) {
+    return;
+  }
+  const targetKeys = Object.keys(target);
+  const sourceKeys = Object.keys(source);
+  if (!sourceKeys.length) {
+    return target;
+  }
+  if (!targetKeys.length) {
+    return source;
+  }
+  if (targetKeys.every((key) => deepEqual(target[key], source[key]))) {
+    return source;
+  }
+  if (sourceKeys.every((key) => deepEqual(target[key], source[key]))) {
+    return target;
+  }
+  return;
+}
+function areQueriesOverlapping(target, source) {
+  if (!target || !source) {
+    return false;
+  }
+  const targetKeys = Object.keys(target);
+  const sourceKeys = Object.keys(source);
+  if (!sourceKeys.length || !targetKeys.length) {
+    return false;
+  }
+  if (targetKeys.some((x) => sourceKeys.includes(x)) || sourceKeys.some((x) => targetKeys.includes(x))) {
+    return true;
+  }
+  return false;
 }
 
 function filterQuery(query, _options) {
@@ -335,16 +370,15 @@ function filterQuery(query, _options) {
   return filterQuery$1(query, options);
 }
 
-function mergeQuery(target, source, options) {
-  const fullOptions = makeDefaultOptions$1(options);
+function mergeQuery(target, source, _options) {
+  const options = makeDefaultOptions$1(_options);
   const { filters: targetFilters, query: targetQuery } = filterQuery(target, {
-    operators: fullOptions.operators,
-    filters: fullOptions.filters,
-    service: fullOptions.service
+    operators: options.operators,
+    filters: options.filters,
+    service: options.service
   });
-  moveProperty(targetFilters, targetQuery, "$or");
-  moveProperty(targetFilters, targetQuery, "$and");
-  if (target.$limit) {
+  moveProperty(targetFilters, targetQuery, "$or", "$and");
+  if ("$limit" in target) {
     targetFilters.$limit = target.$limit;
   }
   let {
@@ -352,27 +386,40 @@ function mergeQuery(target, source, options) {
     filters: sourceFilters,
     query: sourceQuery
   } = filterQuery(source, {
-    operators: fullOptions.operators,
-    filters: fullOptions.filters,
-    service: fullOptions.service
+    operators: options.operators,
+    filters: options.filters,
+    service: options.service
   });
-  moveProperty(sourceFilters, sourceQuery, "$or");
-  moveProperty(sourceFilters, sourceQuery, "$and");
+  moveProperty(sourceFilters, sourceQuery, "$or", "$and");
   if (source.$limit) {
     sourceFilters.$limit = source.$limit;
   }
-  if (target && !Object.prototype.hasOwnProperty.call(target, "$limit") && Object.prototype.hasOwnProperty.call(targetFilters, "$limit")) {
+  if (target && !hasOwnProperty(target, "$limit") && hasOwnProperty(targetFilters, "$limit")) {
     delete targetFilters.$limit;
   }
-  if (source && !Object.prototype.hasOwnProperty.call(source, "$limit") && Object.prototype.hasOwnProperty.call(sourceFilters, "$limit")) {
+  if (source && !hasOwnProperty(source, "$limit") && hasOwnProperty(sourceFilters, "$limit")) {
     delete sourceFilters.$limit;
   }
-  handleArray(targetFilters, sourceFilters, ["$select"], fullOptions);
+  handleArray(targetFilters, sourceFilters, ["$select"], options);
   delete sourceFilters["$select"];
   _merge(targetFilters, sourceFilters);
-  if (options?.useLogicalConjunction && (options.defaultHandle === "combine" || options.defaultHandle === "intersect") && !_isEmpty(targetQuery)) {
+  const subsetQuery = isQueryMoreExplicitThanQuery(targetQuery, sourceQuery);
+  if (options.defaultHandle === "intersect" && !!subsetQuery && !hasOwnProperty(targetQuery, "$or", "$and") && !hasOwnProperty(sourceQuery, "$or", "$and")) {
+    return {
+      ...targetFilters,
+      ...subsetQuery
+    };
+  }
+  if (options.defaultHandle === "intersect" && !areQueriesOverlapping(targetQuery, sourceQuery) && !hasOwnProperty(targetQuery, "$or", "$and") && !hasOwnProperty(sourceQuery, "$or", "$and")) {
+    return {
+      ...targetFilters,
+      ...targetQuery,
+      ...sourceQuery
+    };
+  }
+  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)) {
+    if (hasOwnProperty(sourceQuery, logicalOp)) {
       const andOr = sourceQuery[logicalOp];
       delete sourceQuery[logicalOp];
       andOr.push(sourceQuery);
@@ -384,10 +431,12 @@ function mergeQuery(target, source, options) {
   const keys = Object.keys(sourceQuery);
   for (let i = 0, n = keys.length; i < n; i++) {
     const key = keys[i];
-    handleCircular(targetQuery, sourceQuery, [key], fullOptions);
+    handleCircular(targetQuery, sourceQuery, [key], options);
   }
-  const result = Object.assign({}, targetFilters, targetQuery);
-  return result;
+  return {
+    ...targetFilters,
+    ...targetQuery
+  };
 }
 
 const getItemsIsArray = (context, options) => {
@@ -411,7 +460,7 @@ const getItemsIsArray = (context, options) => {
 };
 
 const getPaginate = (context) => {
-  if (Object.prototype.hasOwnProperty.call(context.params, "paginate")) {
+  if (hasOwnProperty(context.params, "paginate")) {
     return context.params.paginate || void 0;
   }
   if (context.params.paginate === false) {
@@ -715,12 +764,10 @@ function removeRelated({
 
 const makeOptions = (options) => {
   options = options || {};
-  return Object.assign(
-    {
-      wait: true
-    },
-    options
-  );
+  return {
+    wait: true,
+    ...options
+  };
 };
 const runPerItem = (actionPerItem, _options) => {
   const options = makeOptions(_options);
@@ -744,11 +791,10 @@ const defaultOptions = {
   overwrite: true
 };
 function setData(from, to, _options) {
-  const options = Object.assign(
-    {},
-    defaultOptions,
-    _options
-  );
+  const options = {
+    ...defaultOptions,
+    ..._options
+  };
   return (context) => {
     if (shouldSkip("setData", context)) {
       return context;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "feathers-utils",
-  "version": "2.0.0",
+  "version": "2.1.0",
   "description": "Some utils for projects using '@feathersjs/feathers'",
   "author": "fratzinger",
   "repository": {
@@ -43,6 +43,7 @@
     "@feathersjs/commons": "^5.0.0",
     "@feathersjs/errors": "5.0.0",
     "@feathersjs/feathers": "5.0.0",
+    "fast-equals": "^5.0.1",
     "feathers-hooks-common": "^7.0.0",
     "lodash": "^4.17.21"
   },

package/src/hooks/runPerItem.ts

@@ -11,12 +11,10 @@ const makeOptions = (
   options?: HookRunPerItemOptions
 ): Required<HookRunPerItemOptions> => {
   options = options || {};
-  return Object.assign(
-    {
-      wait: true,
-    },
-    options
-  );
+  return {
+    wait: true,
+    ...options,
+  };
 };
 
 /**

package/src/hooks/setData.ts

@@ -27,11 +27,10 @@ export function setData<H extends HookContext = HookContext>(
   to: PropertyPath,
   _options?: HookSetDataOptions
 ) {
-  const options: Required<HookSetDataOptions> = Object.assign(
-    {},
-    defaultOptions,
-    _options
-  );
+  const options: Required<HookSetDataOptions> = {
+    ...defaultOptions,
+    ..._options,
+  };
   return (context: H) => {
     if (shouldSkip("setData", context)) {
       return context;

package/src/utils/getPaginate.ts

@@ -1,5 +1,6 @@
 import type { PaginationOptions } from "@feathersjs/adapter-commons";
 import type { HookContext } from "@feathersjs/feathers";
+import { hasOwnProperty } from "./internal.utils";
 
 /**
  * util to get paginate options from context
@@ -10,7 +11,7 @@ import type { HookContext } from "@feathersjs/feathers";
 export const getPaginate = <H extends HookContext = HookContext>(
   context: H
 ): PaginationOptions | undefined => {
-  if (Object.prototype.hasOwnProperty.call(context.params, "paginate")) {
+  if (hasOwnProperty(context.params, "paginate")) {
     return (context.params.paginate as PaginationOptions) || undefined;
   }
 

package/src/utils/internal.utils.ts

@@ -0,0 +1,6 @@
+export const hasOwnProperty = (
+  obj: Record<string, unknown>,
+  ...keys: string[]
+): boolean => {
+  return keys.some((x) => Object.prototype.hasOwnProperty.call(obj, x));
+};

package/src/utils/mergeQuery/mergeQuery.ts

@@ -2,30 +2,39 @@ import _merge from "lodash/merge.js";
 import _isEmpty from "lodash/isEmpty.js";
 import type { Query } from "@feathersjs/feathers";
 import {
+  areQueriesOverlapping,
   handleArray,
   handleCircular,
+  isQueryMoreExplicitThanQuery,
   makeDefaultOptions,
   moveProperty,
 } from "./utils";
 import type { MergeQueryOptions } from "./types";
 import { filterQuery } from "../filterQuery";
-
-export function mergeQuery<T>(
+import { hasOwnProperty } from "../internal.utils";
+
+/**
+ * Merges two queries into one.
+ * @param target Query to be merged into
+ * @param source Query to be merged from
+ * @param _options
+ * @returns Query
+ */
+export function mergeQuery<T = any>(
   target: Query,
   source: Query,
-  options?: Partial<MergeQueryOptions<T>>
+  _options?: Partial<MergeQueryOptions<T>>
 ): Query {
-  const fullOptions = makeDefaultOptions(options);
+  const options = makeDefaultOptions(_options);
   const { filters: targetFilters, query: targetQuery } = filterQuery(target, {
-    operators: fullOptions.operators,
-    filters: fullOptions.filters,
-    service: fullOptions.service,
+    operators: options.operators,
+    filters: options.filters,
+    service: options.service,
   });
 
-  moveProperty(targetFilters, targetQuery, "$or");
-  moveProperty(targetFilters, targetQuery, "$and");
+  moveProperty(targetFilters, targetQuery, "$or", "$and");
 
-  if (target.$limit) {
+  if ("$limit" in target) {
     targetFilters.$limit = target.$limit;
   }
 
@@ -34,13 +43,12 @@ export function mergeQuery<T>(
     filters: sourceFilters,
     query: sourceQuery,
   } = filterQuery(source, {
-    operators: fullOptions.operators,
-    filters: fullOptions.filters,
-    service: fullOptions.service,
+    operators: options.operators,
+    filters: options.filters,
+    service: options.service,
   });
 
-  moveProperty(sourceFilters, sourceQuery, "$or");
-  moveProperty(sourceFilters, sourceQuery, "$and");
+  moveProperty(sourceFilters, sourceQuery, "$or", "$and");
 
   if (source.$limit) {
     sourceFilters.$limit = source.$limit;
@@ -50,37 +58,64 @@ export function mergeQuery<T>(
 
   if (
     target &&
-    !Object.prototype.hasOwnProperty.call(target, "$limit") &&
-    Object.prototype.hasOwnProperty.call(targetFilters, "$limit")
+    !hasOwnProperty(target, "$limit") &&
+    hasOwnProperty(targetFilters, "$limit")
   ) {
     delete targetFilters.$limit;
   }
 
   if (
     source &&
-    !Object.prototype.hasOwnProperty.call(source, "$limit") &&
-    Object.prototype.hasOwnProperty.call(sourceFilters, "$limit")
+    !hasOwnProperty(source, "$limit") &&
+    hasOwnProperty(sourceFilters, "$limit")
   ) {
     delete sourceFilters.$limit;
   }
 
-  handleArray(targetFilters, sourceFilters, ["$select"], fullOptions);
+  handleArray(targetFilters, sourceFilters, ["$select"], options);
   // remaining filters
   delete sourceFilters["$select"];
   _merge(targetFilters, sourceFilters);
 
   //#endregion
 
+  const subsetQuery = isQueryMoreExplicitThanQuery(targetQuery, sourceQuery);
+
+  if (
+    options.defaultHandle === "intersect" &&
+    !!subsetQuery &&
+    !hasOwnProperty(targetQuery, "$or", "$and") &&
+    !hasOwnProperty(sourceQuery, "$or", "$and")
+  ) {
+    return {
+      ...targetFilters,
+      ...subsetQuery,
+    };
+  }
+
+  if (
+    options.defaultHandle === "intersect" &&
+    !areQueriesOverlapping(targetQuery, sourceQuery) &&
+    !hasOwnProperty(targetQuery, "$or", "$and") &&
+    !hasOwnProperty(sourceQuery, "$or", "$and")
+  ) {
+    return {
+      ...targetFilters,
+      ...targetQuery,
+      ...sourceQuery,
+    };
+  }
+
   //#region '$or' / '$and'
 
   if (
-    options?.useLogicalConjunction &&
+    options.useLogicalConjunction &&
     (options.defaultHandle === "combine" ||
       options.defaultHandle === "intersect") &&
     !_isEmpty(targetQuery)
   ) {
     const logicalOp = options.defaultHandle === "combine" ? "$or" : "$and";
-    if (Object.prototype.hasOwnProperty.call(sourceQuery, logicalOp)) {
+    if (hasOwnProperty(sourceQuery, logicalOp)) {
       // omit '$or'/'$and' and put all other props into '$or'/'$and'
       const andOr = sourceQuery[logicalOp] as unknown[];
       delete sourceQuery[logicalOp];
@@ -96,9 +131,11 @@ export function mergeQuery<T>(
   const keys = Object.keys(sourceQuery);
   for (let i = 0, n = keys.length; i < n; i++) {
     const key = keys[i];
-    handleCircular(targetQuery, sourceQuery, [key], fullOptions);
+    handleCircular(targetQuery, sourceQuery, [key], options);
   }
-  const result = Object.assign({}, targetFilters, targetQuery) as Query;
 
-  return result;
+  return {
+    ...targetFilters,
+    ...targetQuery,
+  };
 }

package/src/utils/mergeQuery/utils.ts

@@ -2,20 +2,15 @@ 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 type { Path } from "../../typesInternal";
 import { mergeArrays } from "./mergeArrays";
 import type { Handle, MergeQueryOptions } from "./types";
-
-export const hasOwnProperty = (
-  obj: Record<string, unknown>,
-  key: string
-): boolean => {
-  return Object.prototype.hasOwnProperty.call(obj, key);
-};
+import { deepEqual as _isEqual } from "fast-equals";
+import type { Query } from "@feathersjs/feathers";
+import { hasOwnProperty } from "../internal.utils";
 
 export function handleArray<T>(
   target: Record<string, unknown>,
@@ -265,19 +260,12 @@ export function handleCircular<T>(
 export function makeDefaultOptions<T>(
   options?: Partial<MergeQueryOptions<T>>
 ): MergeQueryOptions<T> {
-  options = options || ({} as MergeQueryOptions<T>);
-  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 ??= {} as MergeQueryOptions<T>;
+  options.defaultHandle ??= "combine";
+  options.useLogicalConjunction ??= false;
+  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";
@@ -286,15 +274,17 @@ export function makeDefaultOptions<T>(
 }
 
 export function moveProperty(
-  source: Record<string, any>,
-  target: Record<string, any>,
-  key: string
+  from: Record<string, any>,
+  to: Record<string, any>,
+  ...keys: string[]
 ): void {
-  if (!Object.prototype.hasOwnProperty.call(source, key)) {
-    return;
-  }
-  target[key] = source[key];
-  delete source[key];
+  keys.forEach((key) => {
+    if (!hasOwnProperty(from, key)) {
+      return;
+    }
+    to[key] = from[key];
+    delete from[key];
+  });
 }
 
 export function getParentProp(target: Record<string, unknown>, path: Path) {
@@ -338,5 +328,68 @@ export function arrayWithoutDuplicates<T>(target: T[]): T[] {
   if (!target || !Array.isArray(target)) {
     return target;
   }
+
   return _uniqWith(target, _isEqual);
 }
+
+/**
+ * Checks if one query is a superset of the target query
+ * @param target The target query
+ * @param source The source query
+ * @returns The query that is the superset of the other query, returns undefined otherwise
+ */
+export function isQueryMoreExplicitThanQuery(
+  target: Query,
+  source: Query
+): Query | undefined {
+  if (!target || !source) {
+    return;
+  }
+
+  const targetKeys = Object.keys(target);
+  const sourceKeys = Object.keys(source);
+
+  // sourceQuery: {}; targetQuery: { something }
+  if (!sourceKeys.length) {
+    return target;
+  }
+
+  // sourceQuery: { something }; targetQuery: {}
+  if (!targetKeys.length) {
+    return source;
+  }
+
+  if (targetKeys.every((key) => _isEqual(target[key], source[key]))) {
+    // every property of target is exactly in source
+    return source;
+  }
+
+  if (sourceKeys.every((key) => _isEqual(target[key], source[key]))) {
+    // every property of source is exactly in target
+    return target;
+  }
+
+  return;
+}
+
+export function areQueriesOverlapping(target: Query, source: Query): boolean {
+  if (!target || !source) {
+    return false;
+  }
+
+  const targetKeys = Object.keys(target);
+  const sourceKeys = Object.keys(source);
+
+  if (!sourceKeys.length || !targetKeys.length) {
+    return false;
+  }
+
+  if (
+    targetKeys.some((x) => sourceKeys.includes(x)) ||
+    sourceKeys.some((x) => targetKeys.includes(x))
+  ) {
+    return true;
+  }
+
+  return false;
+}