feathers-utils 5.1.0 → 6.0.0

package/dist/index.mjs

@@ -1,16 +1,12 @@
 import { Forbidden, GeneralError, BadRequest, MethodNotAllowed } from '@feathersjs/errors';
-import _isEqual from 'lodash/isEqual.js';
+import { deepEqual } from 'fast-equals';
 import _get from 'lodash/get.js';
 import _set from 'lodash/set.js';
 import _merge from 'lodash/merge.js';
-import _isEmpty from 'lodash/isEmpty.js';
 import _has from 'lodash/has.js';
 import _uniqWith from 'lodash/uniqWith.js';
-import { deepEqual } from 'fast-equals';
-import { _ } from '@feathersjs/commons';
 import { checkContext } from 'feathers-hooks-common';
 import _debounce from 'lodash/debounce.js';
-import _isObject from 'lodash/isObject.js';
 
 function defineHooks(hooks) {
   return hooks;
@@ -34,6 +30,23 @@ function filterQuery(providedQuery) {
   }
   return result;
 }
+function reassembleQuery(query) {
+  const { $select, $limit, $skip, $sort, query: rest } = query;
+  const result = rest;
+  if ($select !== void 0) {
+    result.$select = $select;
+  }
+  if ($limit !== void 0) {
+    result.$limit = $limit;
+  }
+  if ($skip !== void 0) {
+    result.$skip = $skip;
+  }
+  if ($sort !== void 0) {
+    result.$sort = $sort;
+  }
+  return result;
+}
 
 const getItemsIsArray = (context, options) => {
   const { from = "automatic" } = options || {};
@@ -58,7 +71,9 @@ const getItemsIsArray = (context, options) => {
 const hasOwnProperty = (obj, ...keys) => {
   return keys.some((x) => Object.prototype.hasOwnProperty.call(obj, x));
 };
-const isPlainObject$1 = (value) => value && [void 0, Object].includes(value.constructor);
+const isObject = (item) => !!item && typeof item === "object" && !Array.isArray(item);
+const isPlainObject = (value) => isObject(value) && value.constructor === {}.constructor;
+const isEmpty = (obj) => [Object, Array].includes((obj || {}).constructor) && !Object.keys(obj || {}).length;
 
 const getPaginate = (context) => {
   if (hasOwnProperty(context.params, "paginate")) {
@@ -106,7 +121,7 @@ const pushSet = (obj, path, val, options) => {
     _set(obj, path, arr);
     return arr;
   } else {
-    if (options.unique && arr.some((x) => _isEqual(x, val))) {
+    if (options.unique && arr.some((x) => deepEqual(x, val))) {
       return arr;
     }
     arr.push(val);
@@ -389,7 +404,7 @@ function cleanOr(target) {
   if (!target || !Array.isArray(target) || target.length <= 0) {
     return target;
   }
-  if (target.some((x) => _isEmpty(x))) {
+  if (target.some((x) => isEmpty(x))) {
     return void 0;
   } else {
     return arrayWithoutDuplicates(target);
@@ -399,10 +414,10 @@ function cleanAnd(target) {
   if (!target || !Array.isArray(target) || target.length <= 0) {
     return target;
   }
-  if (target.every((x) => _isEmpty(x))) {
+  if (target.every((x) => isEmpty(x))) {
     return void 0;
   } else {
-    target = target.filter((x) => !_isEmpty(x));
+    target = target.filter((x) => !isEmpty(x));
     return arrayWithoutDuplicates(target);
   }
 }
@@ -468,7 +483,7 @@ function mergeQuery(target, source, _options) {
       ...sourceQuery
     };
   }
-  if (options.useLogicalConjunction && (options.defaultHandle === "combine" || options.defaultHandle === "intersect") && !_isEmpty(targetQuery)) {
+  if (options.useLogicalConjunction && (options.defaultHandle === "combine" || options.defaultHandle === "intersect") && !isEmpty(targetQuery)) {
     const logicalOp = options.defaultHandle === "combine" ? "$or" : "$and";
     if (hasOwnProperty(sourceQuery, logicalOp)) {
       const andOr = sourceQuery[logicalOp];
@@ -509,7 +524,7 @@ const setQueryKeySafely = (params, key, value, operator = "$eq", options) => {
     }
     return params;
   }
-  if (isPlainObject$1(params.query[key]) && !(operator in params.query[key])) {
+  if (isPlainObject(params.query[key]) && !(operator in params.query[key])) {
     params.query[key][operator] = value;
   } else {
     (_a = params.query).$and ?? (_a.$and = []);
@@ -574,9 +589,8 @@ const toJSON = (context) => {
   return context;
 };
 
-const isPlainObject = (value) => _.isObject(value) && value.constructor === {}.constructor;
 const validateQueryProperty = (query, operators = []) => {
-  if (!isPlainObject(query)) {
+  if (!isObject(query)) {
     return query;
   }
   for (const key of Object.keys(query)) {
@@ -584,7 +598,7 @@ const validateQueryProperty = (query, operators = []) => {
       throw new BadRequest(`Invalid query parameter ${key}`, query);
     }
     const value = query[key];
-    if (isPlainObject(value)) {
+    if (isObject(value)) {
       query[key] = validateQueryProperty(value, operators);
     }
   }
@@ -595,13 +609,18 @@ const validateQueryProperty = (query, operators = []) => {
 
 function optimizeBatchPatch(items, options) {
   const map = [];
-  const id = options?.id ?? "id";
-  for (const [id2, data] of items) {
-    const index = map.findIndex((item) => deepEqual(item.data, data));
+  const idKey = options?.id ?? "id";
+  for (const _data of items) {
+    const data = _data;
+    const id = _data[idKey];
+    delete data[idKey];
+    const index = map.findIndex((item) => {
+      return deepEqual(item.data, data);
+    });
     if (index === -1) {
-      map.push({ ids: [id2], data });
+      map.push({ ids: [id], data });
     } else {
-      map[index].ids.push(id2);
+      map[index].ids.push(id);
     }
   }
   return map.map(({ ids, data }) => {
@@ -610,13 +629,79 @@ function optimizeBatchPatch(items, options) {
       data,
       {
         query: {
-          [id]: { $in: ids }
+          [idKey]: { $in: ids }
         }
       }
     ];
   });
 }
 
+function flattenQuery(q) {
+  if (Array.isArray(q)) {
+    return q.map(flattenQuery);
+  }
+  if (!isObject(q)) {
+    return q;
+  }
+  const { query, $limit, $select, $skip, $sort } = filterQuery(q);
+  const res = {};
+  function step(object, options) {
+    const { prev = [], result = res } = options ?? {};
+    Object.keys(object).forEach((key) => {
+      const value = object[key];
+      if (Array.isArray(value)) {
+        const newValues = value.map(
+          (v) => step(v, {
+            result: {}
+          })
+        );
+        _set(result, [...prev, key], newValues);
+        return;
+      }
+      if (key.startsWith("$")) {
+        _set(result, [...prev, key], value);
+        return;
+      }
+      const newKey = !prev.length ? [key] : [...prev.slice(0, -1), `${prev[prev.length - 1]}.${key}`];
+      if (!isObject(value)) {
+        _set(result, newKey, value);
+        return;
+      } else {
+        step(value, {
+          prev: newKey,
+          result
+        });
+        return;
+      }
+    });
+    return result;
+  }
+  return reassembleQuery({
+    $limit,
+    $select,
+    $skip,
+    $sort,
+    query: step(query)
+  });
+}
+
+function deflattenQuery(query) {
+  const result = {};
+  Object.keys(query).forEach((key) => {
+    const value = query[key];
+    if (Array.isArray(value)) {
+      _set(result, key, value.map(deflattenQuery));
+      return;
+    }
+    if (isObject(value)) {
+      _set(result, key, deflattenQuery(value));
+      return;
+    }
+    _set(result, key, query[key]);
+  });
+  return result;
+}
+
 function checkMulti() {
   return (context) => {
     if (shouldSkip("checkMulti", context)) {
@@ -934,12 +1019,6 @@ const paramsFromClient = defineParamsFromClient(
   FROM_CLIENT_FOR_SERVER_DEFAULT_KEY
 );
 
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => {
-  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-  return value;
-};
 const makeDefaultOptions = () => {
   return {
     leading: false,
@@ -948,6 +1027,13 @@ const makeDefaultOptions = () => {
     wait: 100
   };
 };
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
 class DebouncedStore {
   constructor(app, options) {
     __publicField(this, "_app");
@@ -1040,7 +1126,7 @@ const filterArray = (...keys) => {
 };
 
 const filterQueryObject = (key) => (obj, { operators }) => {
-  if (obj && !_isObject(obj)) {
+  if (obj && !isObject(obj)) {
     throw new Error(
       `Invalid query parameter: '${key}'. It has to be an object`
     );
@@ -1055,4 +1141,4 @@ const filterObject = (...keys) => {
   return result;
 };
 
-export { DebouncedStore, checkMulti, createRelated, debounceMixin, defineHooks, defineParamsForServer, defineParamsFromClient, filterArray, filterObject, filterQuery, forEach, getItemsIsArray, getPaginate, isMulti, isPaginated, makeDefaultOptions, markHookForSkip, mergeArrays, mergeQuery, onDelete, optimizeBatchPatch, paramsForServer, paramsFromClient, parseFields, pushSet, removeRelated, runPerItem, setData, setQueryKeySafely, setResultEmpty, shouldSkip, toJSON, validateQueryProperty };
+export { DebouncedStore, checkMulti, createRelated, debounceMixin, defineHooks, defineParamsForServer, defineParamsFromClient, deflattenQuery, filterArray, filterObject, filterQuery, flattenQuery, forEach, getItemsIsArray, getPaginate, isMulti, isPaginated, markHookForSkip, mergeArrays, mergeQuery, onDelete, optimizeBatchPatch, paramsForServer, paramsFromClient, parseFields, pushSet, reassembleQuery, removeRelated, runPerItem, setData, setQueryKeySafely, setResultEmpty, shouldSkip, toJSON, validateQueryProperty };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "feathers-utils",
-  "version": "5.1.0",
+  "version": "6.0.0",
   "description": "Some utils for projects using '@feathersjs/feathers'",
   "author": "fratzinger",
   "repository": {
@@ -40,33 +40,31 @@
     "lint": "eslint . --ext .js,.jsx,.ts,.tsx"
   },
   "dependencies": {
-    "@feathersjs/feathers": "^5.0.11",
-    "@feathersjs/adapter-commons": "^5.0.11",
-    "@feathersjs/commons": "^5.0.11",
-    "@feathersjs/errors": "^5.0.11",
+    "@feathersjs/adapter-commons": "^5.0.13",
+    "@feathersjs/errors": "^5.0.13",
+    "@feathersjs/feathers": "^5.0.13",
     "fast-equals": "^5.0.1",
     "feathers-hooks-common": "^8.1.1",
     "lodash": "^4.17.21"
   },
   "devDependencies": {
-    "@feathersjs/memory": "^5.0.11",
-    "@types/lodash": "^4.14.201",
-    "@types/node": "^20.9.0",
-    "@typescript-eslint/eslint-plugin": "^6.10.0",
-    "@typescript-eslint/parser": "^6.10.0",
-    "@vitest/coverage-v8": "^0.34.6",
-    "eslint": "^8.53.0",
-    "eslint-config-prettier": "^9.0.0",
+    "@feathersjs/memory": "^5.0.13",
+    "@types/lodash": "^4.14.202",
+    "@types/node": "^20.10.6",
+    "@typescript-eslint/eslint-plugin": "^6.16.0",
+    "@typescript-eslint/parser": "^6.16.0",
+    "@vitest/coverage-v8": "^1.1.0",
+    "eslint": "^8.56.0",
+    "eslint-config-prettier": "^9.1.0",
     "eslint-import-resolver-typescript": "^3.6.1",
-    "eslint-plugin-import": "^2.29.0",
-    "eslint-plugin-prettier": "^5.0.1",
-    "eslint-plugin-security": "^1.7.1",
-    "np": "^8.0.4",
-    "prettier": "^3.1.0",
+    "eslint-plugin-import": "^2.29.1",
+    "eslint-plugin-prettier": "^5.1.2",
+    "np": "^9.2.0",
+    "prettier": "^3.1.1",
     "shx": "^0.3.4",
-    "typescript": "^5.2.2",
+    "typescript": "^5.3.3",
     "unbuild": "^2.0.0",
-    "vitest": "^0.34.6"
+    "vitest": "^1.1.0"
   },
   "peerDependencies": {
     "@feathersjs/feathers": "^5.0.0"

package/src/filters/object.ts

@@ -1,11 +1,11 @@
 import type { FilterQueryOptions } from "@feathersjs/adapter-commons";
 import { validateQueryProperty } from "../utils/validateQueryProperty";
-import _isObject from "lodash/isObject.js";
+import { isObject } from "../utils/_utils.internal";
 
 const filterQueryObject =
   (key: string) =>
   (obj: any, { operators }: FilterQueryOptions) => {
-    if (obj && !_isObject(obj)) {
+    if (obj && !isObject(obj)) {
       throw new Error(
         `Invalid query parameter: '${key}'. It has to be an object`,
       );

package/src/hooks/checkMulti.ts

@@ -24,3 +24,154 @@ export function checkMulti<H extends HookContext = HookContext>() {
     return context;
   };
 }
+
+if (import.meta.vitest) {
+  const { it, assert } = import.meta.vitest;
+
+  it("passes if 'allowsMulti' not defined", function () {
+    const makeContext = (type: string, method: string) =>
+      ({
+        service: {},
+        type,
+        method,
+      }) as HookContext;
+    ["before", "after"].forEach((type) => {
+      ["find", "get", "create", "update", "patch", "remove"].forEach(
+        (method) => {
+          const context = makeContext(type, method);
+
+          assert.doesNotThrow(
+            () => checkMulti()(context),
+            `'${type}:${method}': does not throw`,
+          );
+        },
+      );
+    });
+  });
+
+  it("passes if 'allowsMulti' returns true", function () {
+    const makeContext = (type: string, method: string) => {
+      const context = {
+        service: {
+          allowsMulti: () => true,
+        },
+        method,
+        type,
+      } as HookContext;
+      if (method === "create") {
+        type === "before" ? (context.data = []) : (context.result = []);
+      }
+      return context as HookContext;
+    };
+    ["before", "after"].forEach((type) => {
+      ["find", "get", "create", "update", "patch", "remove"].forEach(
+        (method) => {
+          const context = makeContext(type, method);
+          assert.doesNotThrow(
+            () => checkMulti()(context),
+            `'${type}:${method}': does not throw`,
+          );
+        },
+      );
+    });
+  });
+
+  it("passes for 'find', 'get' and 'update'", function () {
+    const makeContext = (type: string, method: string) =>
+      ({
+        service: {
+          allowsMulti: () => false,
+        },
+        type,
+        method,
+      }) as HookContext;
+    ["before", "after"].forEach((type) => {
+      ["find", "get", "update"].forEach((method) => {
+        const context = makeContext(type, method);
+        assert.doesNotThrow(
+          () => checkMulti()(context),
+          `'${type}:${method}': does not throw`,
+        );
+      });
+    });
+  });
+
+  it("passes if 'allowsMulti' returns false and is no multi data", function () {
+    const makeContext = (type: string, method: string) => {
+      const context = {
+        service: {
+          allowsMulti: (method: string) => method !== "find",
+        },
+        method,
+        type,
+      } as HookContext;
+      if (method === "create") {
+        type === "before" ? (context.data = {}) : (context.result = {});
+      }
+      if (["patch", "remove"].includes(method)) {
+        context.id = 1;
+      }
+      return context as HookContext;
+    };
+    ["before", "after"].forEach((type) => {
+      ["create", "patch", "remove"].forEach((method) => {
+        const context = makeContext(type, method);
+        assert.doesNotThrow(
+          () => checkMulti()(context),
+          `'${type}:${method}': does not throw`,
+        );
+      });
+    });
+  });
+
+  it("throws if 'allowsMulti' returns false and multi data", function () {
+    const makeContext = (type: string, method: string) => {
+      const context = {
+        service: {
+          allowsMulti: () => false,
+        },
+        method,
+        type,
+      } as HookContext;
+      if (method === "create") {
+        type === "before" ? (context.data = []) : (context.result = []);
+      }
+      return context as HookContext;
+    };
+    ["before", "after"].forEach((type) => {
+      ["create", "patch", "remove"].forEach((method) => {
+        const context = makeContext(type, method);
+        assert.throws(() => checkMulti()(context));
+      });
+    });
+  });
+
+  it("can skip hook", function () {
+    const makeContext = (type: string, method: string) => {
+      const context = {
+        service: {
+          allowsMulti: () => false,
+        },
+        method,
+        type,
+        params: {},
+      } as HookContext;
+      if (method === "create") {
+        type === "before" ? (context.data = []) : (context.result = []);
+      }
+      return context as HookContext;
+    };
+    ["before", "after"].forEach((type) => {
+      ["create", "patch", "remove"].forEach((method) => {
+        const context = makeContext(type, method);
+        context.params = {
+          skipHooks: ["checkMulti"],
+        };
+        assert.doesNotThrow(
+          () => checkMulti()(context),
+          `'${type}:${method}': throws`,
+        );
+      });
+    });
+  });
+}