feathers-utils 2.0.0-0 → 2.0.0-2

package/dist/utils/mergeQuery/index.js

@@ -4,13 +4,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.mergeQuery = void 0;
-const get_1 = __importDefault(require("lodash/get"));
-const has_1 = __importDefault(require("lodash/has"));
-const isEmpty_1 = __importDefault(require("lodash/isEmpty"));
-const isEqual_1 = __importDefault(require("lodash/isEqual"));
-const merge_1 = __importDefault(require("lodash/merge"));
-const set_1 = __importDefault(require("lodash/set"));
-const uniqWith_1 = __importDefault(require("lodash/uniqWith"));
+const get_js_1 = __importDefault(require("lodash/get.js"));
+const has_js_1 = __importDefault(require("lodash/has.js"));
+const isEmpty_js_1 = __importDefault(require("lodash/isEmpty.js"));
+const isEqual_js_1 = __importDefault(require("lodash/isEqual.js"));
+const merge_js_1 = __importDefault(require("lodash/merge.js"));
+const set_js_1 = __importDefault(require("lodash/set.js"));
+const uniqWith_js_1 = __importDefault(require("lodash/uniqWith.js"));
 const mergeArrays_1 = require("./mergeArrays");
 const filterQuery_1 = require("../filterQuery");
 const errors_1 = require("@feathersjs/errors");
@@ -18,14 +18,14 @@ const hasOwnProperty = (obj, key) => {
     return Object.prototype.hasOwnProperty.call(obj, key);
 };
 function handleArray(target, source, key, options) {
-    const targetVal = (0, get_1.default)(target, key);
-    const sourceVal = (0, get_1.default)(source, key);
+    const targetVal = (0, get_js_1.default)(target, key);
+    const sourceVal = (0, get_js_1.default)(source, key);
     if (!sourceVal && !targetVal) {
         return;
     }
-    const handle = (0, get_1.default)(options, ["handle", ...key], options.defaultHandle);
+    const handle = (0, get_js_1.default)(options, ["handle", ...key], options.defaultHandle);
     const arr = (0, mergeArrays_1.mergeArrays)(targetVal, sourceVal, handle, key, options.actionOnEmptyIntersect);
-    (0, set_1.default)(target, key, arr);
+    (0, set_js_1.default)(target, key, arr);
 }
 function handleCircular(target, source, prependKey, options) {
     if (target === null || target === void 0 ? void 0 : target.$or) {
@@ -52,11 +52,11 @@ function handleCircular(target, source, prependKey, options) {
             delete source.$and;
         }
     }
-    if (!(0, has_1.default)(source, prependKey)) {
+    if (!(0, has_js_1.default)(source, prependKey)) {
         return;
     }
-    if (!(0, has_1.default)(target, prependKey)) {
-        (0, set_1.default)(target, prependKey, (0, get_1.default)(source, prependKey));
+    if (!(0, has_js_1.default)(target, prependKey)) {
+        (0, set_js_1.default)(target, prependKey, (0, get_js_1.default)(source, prependKey));
         return;
     }
     const { defaultHandle, actionOnEmptyIntersect } = options;
@@ -64,22 +64,22 @@ function handleCircular(target, source, prependKey, options) {
         return;
     }
     const getTargetVal = () => {
-        return (prependKey.length > 0) ? (0, get_1.default)(target, prependKey) : target;
+        return (prependKey.length > 0) ? (0, get_js_1.default)(target, prependKey) : target;
     };
     const getSourceVal = () => {
-        return (prependKey.length > 0) ? (0, get_1.default)(source, prependKey) : source;
+        return (prependKey.length > 0) ? (0, get_js_1.default)(source, prependKey) : source;
     };
     const targetVal = getTargetVal();
     const sourceVal = getSourceVal();
-    if ((0, isEqual_1.default)(targetVal, sourceVal)) {
+    if ((0, isEqual_js_1.default)(targetVal, sourceVal)) {
         return;
     }
     if (defaultHandle === "source") {
-        (0, set_1.default)(target, prependKey, sourceVal);
+        (0, set_js_1.default)(target, prependKey, sourceVal);
         return;
     }
     if (targetVal === null || sourceVal === null) {
-        (0, set_1.default)(target, prependKey, sourceVal);
+        (0, set_js_1.default)(target, prependKey, sourceVal);
         return;
     }
     const typeOfTargetVal = typeof targetVal;
@@ -87,7 +87,7 @@ function handleCircular(target, source, prependKey, options) {
         if (defaultHandle === "intersect") {
             actionOnEmptyIntersect(target, source, prependKey);
         }
-        (0, set_1.default)(target, prependKey, sourceVal);
+        (0, set_js_1.default)(target, prependKey, sourceVal);
         return;
     }
     const typeOfSourceVal = typeof sourceVal;
@@ -96,7 +96,7 @@ function handleCircular(target, source, prependKey, options) {
     if (isTargetSimple || isSourceSimple) {
         if (isTargetSimple && isSourceSimple) {
             if (defaultHandle === "combine") {
-                (0, set_1.default)(target, prependKey, { $in: [...new Set([targetVal, sourceVal])] });
+                (0, set_js_1.default)(target, prependKey, { $in: [...new Set([targetVal, sourceVal])] });
                 return;
             }
             else if (defaultHandle === "intersect") {
@@ -110,20 +110,20 @@ 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 && (0, isEqual_1.default)($in[0], otherVal)) {
-                (0, set_1.default)(target, prependKey, otherVal);
+            if ($in.length === 1 && (0, isEqual_js_1.default)($in[0], otherVal)) {
+                (0, set_js_1.default)(target, prependKey, otherVal);
                 return;
             }
             else if (defaultHandle === "combine") {
-                if (!$in.some((x) => (0, isEqual_1.default)(x, otherVal))) {
+                if (!$in.some((x) => (0, isEqual_js_1.default)(x, otherVal))) {
                     $in.push(otherVal);
                 }
-                (0, set_1.default)(target, `${prependKey}.$in`, $in);
+                (0, set_js_1.default)(target, `${prependKey}.$in`, $in);
                 return;
             }
             else if (defaultHandle === "intersect") {
-                if ($in.some((x) => (0, isEqual_1.default)(x, otherVal))) {
-                    (0, set_1.default)(target, prependKey, otherVal);
+                if ($in.some((x) => (0, isEqual_js_1.default)(x, otherVal))) {
+                    (0, set_js_1.default)(target, prependKey, otherVal);
                 }
                 else {
                     actionOnEmptyIntersect(target, source, prependKey);
@@ -139,7 +139,7 @@ function handleCircular(target, source, prependKey, options) {
         const key = prependKey[prependKey.length - 1];
         if (key === "$or") {
             if (defaultHandle === "combine") {
-                const newVals = sourceVal.filter((x) => !targetVal.some((y) => (0, isEqual_1.default)(x, y)));
+                const newVals = sourceVal.filter((x) => !targetVal.some((y) => (0, isEqual_js_1.default)(x, y)));
                 targetVal.push(...newVals);
             }
             else if (defaultHandle === "intersect") {
@@ -176,7 +176,7 @@ function handleCircular(target, source, prependKey, options) {
                 return;
             }
             else if (defaultHandle === "intersect") {
-                const newVals = sourceVal.filter((x) => !targetVal.some((y) => (0, isEqual_1.default)(x, y)));
+                const newVals = sourceVal.filter((x) => !targetVal.some((y) => (0, isEqual_js_1.default)(x, y)));
                 targetVal.push(...newVals);
                 return;
             }
@@ -185,29 +185,29 @@ function handleCircular(target, source, prependKey, options) {
             if (defaultHandle === "combine") {
                 let $in = targetVal.concat(sourceVal);
                 $in = [...new Set($in)];
-                (0, set_1.default)(target, prependKey, $in);
+                (0, set_js_1.default)(target, prependKey, $in);
                 return;
             }
             else if (defaultHandle === "intersect") {
-                const $in = targetVal.filter((x) => sourceVal.some((y) => (0, isEqual_1.default)(x, y)));
+                const $in = targetVal.filter((x) => sourceVal.some((y) => (0, isEqual_js_1.default)(x, y)));
                 if ($in.length === 0) {
                     actionOnEmptyIntersect(target, source, prependKey);
                 }
                 else if ($in.length === 1) {
-                    (0, set_1.default)(target, prependKey.slice(0, -1), $in[0]);
+                    (0, set_js_1.default)(target, prependKey.slice(0, -1), $in[0]);
                     return;
                 }
                 else {
-                    (0, set_1.default)(target, prependKey, $in);
+                    (0, set_js_1.default)(target, prependKey, $in);
                 }
             }
             return;
         }
-        (0, set_1.default)(target, prependKey, sourceVal);
+        (0, set_js_1.default)(target, prependKey, sourceVal);
         return;
     }
     if (typeOfTargetVal !== "object" || typeOfSourceVal !== "object") {
-        (0, set_1.default)(target, prependKey, sourceVal);
+        (0, set_js_1.default)(target, prependKey, sourceVal);
         return;
     }
     // both are objects
@@ -233,12 +233,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];
+}
 function mergeQuery(target, source, options) {
     const fullOptions = makeDefaultOptions(options);
     const { filters: targetFilters, query: targetQuery } = (0, filterQuery_1.filterQuery)(target, {
         operators: fullOptions.operators,
         service: fullOptions.service
     });
+    moveProperty(targetFilters, targetQuery, "$or");
+    moveProperty(targetFilters, targetQuery, "$and");
     if (target.$limit) {
         targetFilters.$limit = target.$limit;
     }
@@ -248,6 +257,8 @@ 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;
     }
@@ -265,13 +276,13 @@ function mergeQuery(target, source, options) {
     handleArray(targetFilters, sourceFilters, ["$select"], fullOptions);
     // remaining filters
     delete sourceFilters["$select"];
-    (0, merge_1.default)(targetFilters, sourceFilters);
+    (0, merge_js_1.default)(targetFilters, sourceFilters);
     //#endregion
     //#region '$or' / '$and'
     if ((options === null || options === void 0 ? void 0 : options.useLogicalConjunction) &&
         (options.defaultHandle === "combine" ||
             options.defaultHandle === "intersect") &&
-        !(0, isEmpty_1.default)(targetQuery)) {
+        !(0, isEmpty_js_1.default)(targetQuery)) {
         const logicalOp = (options.defaultHandle === "combine")
             ? "$or"
             : "$and";
@@ -301,13 +312,13 @@ function getParentProp(target, path) {
         return target;
     }
     const pathOneUp = path.slice(0, -1);
-    return (0, get_1.default)(target, pathOneUp);
+    return (0, get_js_1.default)(target, pathOneUp);
 }
 function cleanOr(target) {
     if (!target || !Array.isArray(target) || target.length <= 0) {
         return target;
     }
-    if (target.some(x => (0, isEmpty_1.default)(x))) {
+    if (target.some(x => (0, isEmpty_js_1.default)(x))) {
         return undefined;
     }
     else {
@@ -318,11 +329,11 @@ function cleanAnd(target) {
     if (!target || !Array.isArray(target) || target.length <= 0) {
         return target;
     }
-    if (target.every(x => (0, isEmpty_1.default)(x))) {
+    if (target.every(x => (0, isEmpty_js_1.default)(x))) {
         return undefined;
     }
     else {
-        target = target.filter(x => !(0, isEmpty_1.default)(x));
+        target = target.filter(x => !(0, isEmpty_js_1.default)(x));
         return arrayWithoutDuplicates(target);
     }
 }
@@ -330,5 +341,5 @@ function arrayWithoutDuplicates(target) {
     if (!target || !Array.isArray(target)) {
         return target;
     }
-    return (0, uniqWith_1.default)(target, isEqual_1.default);
+    return (0, uniqWith_js_1.default)(target, isEqual_js_1.default);
 }

package/dist/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/utils/pushSet.js

@@ -4,19 +4,19 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.pushSet = void 0;
-const isEqual_1 = __importDefault(require("lodash/isEqual"));
-const get_1 = __importDefault(require("lodash/get"));
-const set_1 = __importDefault(require("lodash/set"));
+const isEqual_js_1 = __importDefault(require("lodash/isEqual.js"));
+const get_js_1 = __importDefault(require("lodash/get.js"));
+const set_js_1 = __importDefault(require("lodash/set.js"));
 const pushSet = (obj, path, val, options) => {
     options = options || {};
-    let arr = (0, get_1.default)(obj, path);
+    let arr = (0, get_js_1.default)(obj, path);
     if (!arr || !Array.isArray(arr)) {
         arr = [val];
-        (0, set_1.default)(obj, path, arr);
+        (0, set_js_1.default)(obj, path, arr);
         return arr;
     }
     else {
-        if (options.unique && arr.some(x => (0, isEqual_1.default)(x, val))) {
+        if (options.unique && arr.some(x => (0, isEqual_js_1.default)(x, val))) {
             return arr;
         }
         arr.push(val);

package/dist/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/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/utils/validateQueryProperty.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateQueryProperty = void 0;
+const commons_1 = require("@feathersjs/commons");
+const errors_1 = require("@feathersjs/errors");
+const isPlainObject = (value) => commons_1._.isObject(value) && value.constructor === {}.constructor;
+const validateQueryProperty = (query, operators = []) => {
+    if (!isPlainObject(query)) {
+        return query;
+    }
+    for (const key of Object.keys(query)) {
+        if (key.startsWith("$") && !operators.includes(key)) {
+            throw new errors_1.BadRequest(`Invalid query parameter ${key}`, query);
+        }
+        const value = query[key];
+        if (isPlainObject(value)) {
+            query[key] = (0, exports.validateQueryProperty)(value, operators);
+        }
+    }
+    return Object.assign({}, query);
+};
+exports.validateQueryProperty = validateQueryProperty;

package/package.json

@@ -1,12 +1,15 @@
 {
   "name": "feathers-utils",
-  "version": "2.0.0-0",
+  "version": "2.0.0-2",
   "description": "Some utils for projects using '@feathersjs/feathers'",
   "author": "fratzinger",
   "repository": {
     "type": "git",
     "url": "https://github.com/fratzinger/feathers-utils"
   },
+  "engines": {
+    "node": ">= 14"
+  },
   "homepage": "https://github.com/fratzinger/feathers-utils",
   "license": "MIT",
   "main": "dist/",
@@ -21,6 +24,14 @@
   "directories": {
     "dist": "dist"
   },
+  "files": [
+    "CHANGELOG.md",
+    "LICENSE",
+    "README.md",
+    "src/**",
+    "lib/**",
+    "dist/**"
+  ],
   "scripts": {
     "build": "shx rm -rf dist/ && npm run tsc",
     "tsc": "tsc -p tsconfig.json && tsc -p tsconfig-esm.json",
@@ -31,29 +42,32 @@
     "lint": "eslint . --ext .js,.jsx,.ts,.tsx"
   },
   "dependencies": {
-    "@feathersjs/adapter-commons": "5.0.0-pre.15",
-    "@feathersjs/errors": "5.0.0-pre.15",
-    "@feathersjs/feathers": "5.0.0-pre.15",
-    "feathers-hooks-common": "^5.0.6",
+    "@feathersjs/adapter-commons": "5.0.0-pre.29",
+    "@feathersjs/errors": "5.0.0-pre.29",
+    "@feathersjs/feathers": "5.0.0-pre.29",
+    "feathers-hooks-common": "^6.1.5",
     "lodash": "^4.17.21",
-    "type-fest": "^2.5.4"
+    "type-fest": "^2.19.0"
   },
   "devDependencies": {
-    "@istanbuljs/nyc-config-typescript": "^1.0.1",
-    "@types/lodash": "^4.14.168",
-    "@types/mocha": "^8.2.2",
-    "@types/node": "^15.0.1",
-    "@typescript-eslint/eslint-plugin": "^4.22.0",
-    "@typescript-eslint/parser": "^4.22.0",
+    "@feathersjs/memory": "^5.0.0-pre.20",
+    "@istanbuljs/nyc-config-typescript": "^1.0.2",
+    "@types/lodash": "^4.14.185",
+    "@types/mocha": "^9.1.1",
+    "@types/node": "^18.7.18",
+    "@typescript-eslint/eslint-plugin": "^5.37.0",
+    "@typescript-eslint/parser": "^5.37.0",
     "cross-env": "^7.0.3",
-    "eslint": "^7.25.0",
-    "eslint-plugin-security": "^1.4.0",
+    "eslint": "^8.23.1",
+    "eslint-import-resolver-typescript": "^3.5.1",
+    "eslint-plugin-import": "^2.26.0",
+    "eslint-plugin-security": "^1.5.0",
     "feathers-memory": "^4.1.0",
-    "mocha": "^8.3.2",
-    "np": "^7.5.0",
+    "mocha": "^10.0.0",
+    "np": "^7.6.2",
     "nyc": "^15.1.0",
-    "shx": "^0.3.3",
-    "ts-node": "^9.1.1",
-    "typescript": "^4.2.4"
+    "shx": "^0.3.4",
+    "ts-node": "^10.9.1",
+    "typescript": "^4.8.3"
   }
 }

package/src/filters/array.ts

@@ -0,0 +1,14 @@
+import type { FilterQueryOptions } from "@feathersjs/adapter-commons";
+import { validateQueryProperty } from "../utils/validateQueryProperty";
+
+export const filterArray = () => (arr: any, { operators }: FilterQueryOptions) => {
+  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/src/hooks/checkMulti.ts

@@ -3,8 +3,10 @@ import { shouldSkip } from "../utils/shouldSkip";
 import { isMulti } from "../utils/isMulti";
 
 import type { HookContext } from "@feathersjs/feathers";
+import type { ReturnSyncHook } from "../types";
 
-export function checkMulti(): ((context: HookContext) => HookContext) {
+export function checkMulti(
+): ReturnSyncHook {
   return (context: HookContext): HookContext => {
     if (shouldSkip("checkMulti", context)) { return context; }
     const { service, method } = context;

package/src/hooks/createRelated.ts

@@ -0,0 +1,45 @@
+import type { HookContext } from "@feathersjs/feathers";
+import { checkContext } from "feathers-hooks-common";
+import type { CreateRelatedOptions } from "../types";
+import { getItemsIsArray } from "../utils/getItemsIsArray";
+
+export function createRelated<S = Record<string, any>>({
+  service,
+  multi = true,
+  data,
+  createItemsInDataArraySeparately = true
+}: CreateRelatedOptions<S>) {
+  if (!service || !data) {
+    throw "initialize hook 'createRelated' completely!";
+  }
+  return async (context: HookContext): Promise<HookContext> => {
+    // @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 as string).create(dataToCreate);
+    } else {
+      await Promise.all(
+        dataToCreate.map(async item => 
+          context.app.service(service as string).create(item)
+        )
+      );
+    }
+
+    return context;
+  };
+}

package/src/hooks/onDelete.ts

@@ -0,0 +1,56 @@
+import type { HookContext } from "@feathersjs/feathers";
+import { checkContext } from "feathers-hooks-common";
+import type { OnDeleteOptions } from "../types";
+import { getItemsIsArray } from "../utils/getItemsIsArray";
+
+export function onDelete<S = Record<string, any>>(
+  service: keyof S,
+  {
+    keyThere,
+    keyHere = "id",
+    onDelete = "cascade",
+    blocking = true
+  }: OnDeleteOptions) {
+  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: HookContext): Promise<HookContext> => {
+    // @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 as string).remove(null, params);
+    } else if (onDelete === "set null") {
+      const data = { [keyThere]: null };
+      promise = context.app.service(service as string).patch(null, data, params);
+    }
+
+    if (blocking) {
+      await promise;
+    }
+
+    return context;
+  };
+}

package/src/hooks/removeRelated.ts

@@ -0,0 +1,42 @@
+import type { HookContext, Params, Query } from "@feathersjs/feathers";
+import { checkContext } from "feathers-hooks-common";
+import type { RemoveRelatedOptions } from "../types";
+import { getItemsIsArray } from "../utils/getItemsIsArray";
+
+export function removeRelated<S = Record<string, any>>({
+  service,
+  keyThere,
+  keyHere = "id",
+  blocking = true
+}: RemoveRelatedOptions<S>) {
+  if (!service || !keyThere) {
+    throw "initialize hook 'removeRelated' completely!";
+  }
+  return async (context: HookContext): Promise<HookContext> => {
+    // @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: Promise<any> = context.app.service(service as string).remove(null, {
+      query: {
+        [keyThere]: {
+          $in: ids
+        }
+      },
+      paginate: false
+    } as Params<Query>);
+
+    if (blocking) {
+      await promise;
+    }
+
+    return context;
+  };
+}

package/src/hooks/runPerItem.ts

@@ -1,13 +1,11 @@
-import { getItems } from "feathers-hooks-common";
-
 import { shouldSkip } from "../utils/shouldSkip";
 
-import type { HookRunPerItemOptions } from "../types";
+import type { HookRunPerItemOptions, ReturnAsyncHook, Promisable } from "../types";
 import type { HookContext } from "@feathersjs/feathers";
-import type { Promisable } from "type-fest";
+import { getItemsIsArray } from "../utils/getItemsIsArray";
 
 const makeOptions = (
-  options: HookRunPerItemOptions
+  options?: HookRunPerItemOptions
 ): Required<HookRunPerItemOptions> => {
   options = options || {};
   return Object.assign({
@@ -16,16 +14,15 @@ const makeOptions = (
 };
 
 export const runPerItem = (
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   actionPerItem: (item: any, context: HookContext) => Promisable<any>, 
-  options: HookRunPerItemOptions
-): ((context: HookContext) => Promise<HookContext>) => {
-  options = makeOptions(options);
+  _options?: HookRunPerItemOptions
+): ReturnAsyncHook => {
+  const options = makeOptions(_options);
   return async (context: HookContext): Promise<HookContext> => {
     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: unknown) => {
       await actionPerItem(item, context);