feathers-utils 2.0.0-2 → 2.0.0-4

package/dist/utils/mergeQuery/utils.js

@@ -0,0 +1,287 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.arrayWithoutDuplicates = exports.cleanAnd = exports.cleanOr = exports.getParentProp = exports.moveProperty = exports.makeDefaultOptions = exports.handleCircular = exports.handleArray = exports.hasOwnProperty = void 0;
+const errors_1 = require("@feathersjs/errors");
+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 set_js_1 = __importDefault(require("lodash/set.js"));
+const uniqWith_js_1 = __importDefault(require("lodash/uniqWith.js"));
+const mergeArrays_1 = require("./mergeArrays");
+const hasOwnProperty = (obj, key) => {
+    return Object.prototype.hasOwnProperty.call(obj, key);
+};
+exports.hasOwnProperty = hasOwnProperty;
+function handleArray(target, source, key, options) {
+    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_js_1.default)(options, ["handle", ...key], options.defaultHandle);
+    const arr = (0, mergeArrays_1.mergeArrays)(targetVal, sourceVal, handle, key, options.actionOnEmptyIntersect);
+    (0, set_js_1.default)(target, key, arr);
+}
+exports.handleArray = handleArray;
+function handleCircular(target, source, prependKey, options) {
+    if (target === null || target === void 0 ? void 0 : target.$or) {
+        target.$or = cleanOr(target.$or);
+        if (!target.$or) {
+            delete target.$or;
+        }
+    }
+    if (source === null || source === void 0 ? void 0 : source.$or) {
+        source.$or = cleanOr(source.$or);
+        if (!source.$or) {
+            delete source.$or;
+        }
+    }
+    if (target === null || target === void 0 ? void 0 : target.$and) {
+        target.$and = cleanAnd(target.$and);
+        if (!target.$and) {
+            delete target.$and;
+        }
+    }
+    if (source === null || source === void 0 ? void 0 : source.$and) {
+        source.$and = cleanAnd(source.$and);
+        if (!source.$and) {
+            delete source.$and;
+        }
+    }
+    if (!(0, has_js_1.default)(source, prependKey)) {
+        return;
+    }
+    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;
+    if (defaultHandle === "target") {
+        return;
+    }
+    const getTargetVal = () => {
+        return prependKey.length > 0 ? (0, get_js_1.default)(target, prependKey) : target;
+    };
+    const getSourceVal = () => {
+        return prependKey.length > 0 ? (0, get_js_1.default)(source, prependKey) : source;
+    };
+    const targetVal = getTargetVal();
+    const sourceVal = getSourceVal();
+    if ((0, isEqual_js_1.default)(targetVal, sourceVal)) {
+        return;
+    }
+    if (defaultHandle === "source") {
+        (0, set_js_1.default)(target, prependKey, sourceVal);
+        return;
+    }
+    if (targetVal === null || sourceVal === null) {
+        (0, set_js_1.default)(target, prependKey, sourceVal);
+        return;
+    }
+    const typeOfTargetVal = typeof targetVal;
+    if (["boolean"].includes(typeOfTargetVal)) {
+        if (defaultHandle === "intersect") {
+            actionOnEmptyIntersect(target, source, prependKey);
+        }
+        (0, set_js_1.default)(target, prependKey, sourceVal);
+        return;
+    }
+    const typeOfSourceVal = typeof sourceVal;
+    const isTargetSimple = ["string", "number"].includes(typeOfTargetVal);
+    const isSourceSimple = ["string", "number"].includes(typeOfSourceVal);
+    if (isTargetSimple || isSourceSimple) {
+        if (isTargetSimple && isSourceSimple) {
+            if (defaultHandle === "combine") {
+                (0, set_js_1.default)(target, prependKey, { $in: [...new Set([targetVal, sourceVal])] });
+                return;
+            }
+            else if (defaultHandle === "intersect") {
+                actionOnEmptyIntersect(target, source, prependKey);
+            }
+            else {
+                throw new Error("should not reach here");
+            }
+        }
+        else if ((0, exports.hasOwnProperty)(targetVal, "$in") ||
+            (0, exports.hasOwnProperty)(sourceVal, "$in")) {
+            const targetHasIn = (0, exports.hasOwnProperty)(targetVal, "$in");
+            const $in = targetHasIn ? targetVal["$in"] : sourceVal["$in"];
+            const otherVal = isTargetSimple ? targetVal : sourceVal;
+            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_js_1.default)(x, otherVal))) {
+                    $in.push(otherVal);
+                }
+                (0, set_js_1.default)(target, `${prependKey}.$in`, $in);
+                return;
+            }
+            else if (defaultHandle === "intersect") {
+                if ($in.some((x) => (0, isEqual_js_1.default)(x, otherVal))) {
+                    (0, set_js_1.default)(target, prependKey, otherVal);
+                }
+                else {
+                    actionOnEmptyIntersect(target, source, prependKey);
+                }
+                return;
+            }
+            return;
+        }
+    }
+    const isTargetArray = Array.isArray(targetVal);
+    const isSourceArray = Array.isArray(sourceVal);
+    if (isTargetArray && isSourceArray) {
+        const key = prependKey[prependKey.length - 1];
+        if (key === "$or") {
+            if (defaultHandle === "combine") {
+                const newVals = sourceVal.filter((x) => !targetVal.some((y) => (0, isEqual_js_1.default)(x, y)));
+                targetVal.push(...newVals);
+            }
+            else if (defaultHandle === "intersect") {
+                // combine into "$and"
+                const targetParent = getParentProp(target, prependKey);
+                const sourceParent = getParentProp(source, prependKey);
+                targetParent.$and = targetParent.$and || [];
+                targetParent.$and.push({ $or: targetVal }, { $or: sourceVal });
+                targetParent.$and = cleanAnd(targetParent.$and);
+                if (!targetParent.$and) {
+                    delete targetParent.$and;
+                }
+                delete targetParent.$or;
+                delete sourceParent.$or;
+                handleCircular(target, source, [...prependKey, "$and"], options);
+                return;
+            }
+            return;
+        }
+        else if (key === "$and") {
+            if (defaultHandle === "combine") {
+                // combine into "$or"
+                const targetParent = getParentProp(target, prependKey);
+                const sourceParent = getParentProp(source, prependKey);
+                targetParent.$or = targetParent.$or || [];
+                targetParent.$or.push({ $and: targetVal }, { $and: sourceVal });
+                targetParent.$or = cleanOr(targetParent.$or);
+                if (!targetParent.$or) {
+                    delete targetParent.$or;
+                }
+                delete targetParent.$and;
+                delete sourceParent.$and;
+                handleCircular(target, source, [...prependKey, "$or"], options);
+                return;
+            }
+            else if (defaultHandle === "intersect") {
+                const newVals = sourceVal.filter((x) => !targetVal.some((y) => (0, isEqual_js_1.default)(x, y)));
+                targetVal.push(...newVals);
+                return;
+            }
+        }
+        else if (key === "$in") {
+            if (defaultHandle === "combine") {
+                let $in = targetVal.concat(sourceVal);
+                $in = [...new Set($in)];
+                (0, set_js_1.default)(target, prependKey, $in);
+                return;
+            }
+            else if (defaultHandle === "intersect") {
+                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_js_1.default)(target, prependKey.slice(0, -1), $in[0]);
+                    return;
+                }
+                else {
+                    (0, set_js_1.default)(target, prependKey, $in);
+                }
+            }
+            return;
+        }
+        (0, set_js_1.default)(target, prependKey, sourceVal);
+        return;
+    }
+    if (typeOfTargetVal !== "object" || typeOfSourceVal !== "object") {
+        (0, set_js_1.default)(target, prependKey, sourceVal);
+        return;
+    }
+    // both are objects
+    const sourceKeys = Object.keys(sourceVal);
+    for (let i = 0, n = sourceKeys.length; i < n; i++) {
+        const key = sourceKeys[i];
+        handleCircular(target, source, [...prependKey, key], options);
+    }
+}
+exports.handleCircular = handleCircular;
+function makeDefaultOptions(options) {
+    options = options || {};
+    options.defaultHandle = options.defaultHandle || "combine";
+    options.useLogicalConjunction = Object.prototype.hasOwnProperty.call(options, "useLogicalConjunction")
+        ? options.useLogicalConjunction
+        : false;
+    options.actionOnEmptyIntersect =
+        options.actionOnEmptyIntersect ||
+            (() => {
+                throw new errors_1.Forbidden("You're not allowed to make this request");
+            });
+    options.handle = options.handle || {};
+    if (options.defaultHandle === "intersect") {
+        options.handle.$select = options.handle.$select || "intersectOrFull";
+    }
+    return options;
+}
+exports.makeDefaultOptions = makeDefaultOptions;
+function moveProperty(source, target, key) {
+    if (!Object.prototype.hasOwnProperty.call(source, key)) {
+        return;
+    }
+    target[key] = source[key];
+    delete source[key];
+}
+exports.moveProperty = moveProperty;
+function getParentProp(target, path) {
+    if (path.length <= 1) {
+        return target;
+    }
+    const pathOneUp = path.slice(0, -1);
+    return (0, get_js_1.default)(target, pathOneUp);
+}
+exports.getParentProp = getParentProp;
+function cleanOr(target) {
+    if (!target || !Array.isArray(target) || target.length <= 0) {
+        return target;
+    }
+    if (target.some((x) => (0, isEmpty_js_1.default)(x))) {
+        return undefined;
+    }
+    else {
+        return arrayWithoutDuplicates(target);
+    }
+}
+exports.cleanOr = cleanOr;
+function cleanAnd(target) {
+    if (!target || !Array.isArray(target) || target.length <= 0) {
+        return target;
+    }
+    if (target.every((x) => (0, isEmpty_js_1.default)(x))) {
+        return undefined;
+    }
+    else {
+        target = target.filter((x) => !(0, isEmpty_js_1.default)(x));
+        return arrayWithoutDuplicates(target);
+    }
+}
+exports.cleanAnd = cleanAnd;
+function arrayWithoutDuplicates(target) {
+    if (!target || !Array.isArray(target)) {
+        return target;
+    }
+    return (0, uniqWith_js_1.default)(target, isEqual_js_1.default);
+}
+exports.arrayWithoutDuplicates = arrayWithoutDuplicates;

package/dist/utils/pushSet.d.ts

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

package/dist/utils/pushSet.js

@@ -16,7 +16,7 @@ const pushSet = (obj, path, val, options) => {
         return arr;
     }
     else {
-        if (options.unique && arr.some(x => (0, isEqual_js_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 type { HookContext } from "@feathersjs/feathers";
-export declare const setResultEmpty: (context: HookContext) => HookContext;
+export declare const setResultEmpty: <H extends HookContext<import("@feathersjs/feathers").Application<any, any>, any> = HookContext<import("@feathersjs/feathers").Application<any, any>, any>>(context: H) => H;

package/dist/utils/setResultEmpty.js

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

package/dist/utils/shouldSkip.d.ts

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "feathers-utils",
-  "version": "2.0.0-2",
+  "version": "2.0.0-4",
   "description": "Some utils for projects using '@feathersjs/feathers'",
   "author": "fratzinger",
   "repository": {
@@ -45,7 +45,7 @@
     "@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",
+    "feathers-hooks-common": "^7.0.0-pre.0",
     "lodash": "^4.17.21",
     "type-fest": "^2.19.0"
   },
@@ -59,13 +59,16 @@
     "@typescript-eslint/parser": "^5.37.0",
     "cross-env": "^7.0.3",
     "eslint": "^8.23.1",
+    "eslint-config-prettier": "^8.5.0",
     "eslint-import-resolver-typescript": "^3.5.1",
     "eslint-plugin-import": "^2.26.0",
+    "eslint-plugin-prettier": "^4.2.1",
     "eslint-plugin-security": "^1.5.0",
     "feathers-memory": "^4.1.0",
     "mocha": "^10.0.0",
     "np": "^7.6.2",
     "nyc": "^15.1.0",
+    "prettier": "^2.7.1",
     "shx": "^0.3.4",
     "ts-node": "^10.9.1",
     "typescript": "^4.8.3"

package/src/filters/array.ts

@@ -1,14 +1,18 @@
 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");
-  }
+export const filterArray =
+  (key: string) =>
+  (arr: any, { operators }: FilterQueryOptions) => {
+    if (arr && !Array.isArray(arr)) {
+      throw new Error(
+        `Invalid query parameter '${key}'. It has to be an array`
+      );
+    }
 
-  if (Array.isArray(arr)) {
-    return arr.map((current) => validateQueryProperty(current, operators));
-  }
+    if (Array.isArray(arr)) {
+      return arr.map((current) => validateQueryProperty(current, operators));
+    }
 
-  return arr;
-};
+    return arr;
+  };

package/src/filters/object.ts

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

package/src/hooks/checkMulti.ts

@@ -3,14 +3,16 @@ import { shouldSkip } from "../utils/shouldSkip";
 import { isMulti } from "../utils/isMulti";
 
 import type { HookContext } from "@feathersjs/feathers";
-import type { ReturnSyncHook } from "../types";
 
-export function checkMulti(
-): ReturnSyncHook {
-  return (context: HookContext): HookContext => {
-    if (shouldSkip("checkMulti", context)) { return context; }
+export function checkMulti<H extends HookContext = HookContext>() {
+  return (context: H) => {
+    if (shouldSkip("checkMulti", context)) {
+      return context;
+    }
     const { service, method } = context;
-    if (!service.allowsMulti || !isMulti(context) || method === "find") { return context; }
+    if (!service.allowsMulti || !isMulti(context) || method === "find") {
+      return context;
+    }
 
     if (!service.allowsMulti(method)) {
       throw new MethodNotAllowed(`Can not ${method} multiple entries`);

package/src/hooks/createRelated.ts

@@ -1,40 +1,49 @@
 import type { HookContext } from "@feathersjs/feathers";
 import { checkContext } from "feathers-hooks-common";
-import type { CreateRelatedOptions } from "../types";
+import type { Promisable } from "../typesInternal";
 import { getItemsIsArray } from "../utils/getItemsIsArray";
 
-export function createRelated<S = Record<string, any>>({
+export interface CreateRelatedOptions<S = Record<string, any>> {
+  service: keyof S;
+  multi?: boolean;
+  data: (item: any, context: HookContext) => Promisable<Record<string, any>>;
+  createItemsInDataArraySeparately?: boolean;
+}
+
+export function createRelated<
+  S = Record<string, any>,
+  H extends HookContext = HookContext
+>({
   service,
   multi = true,
   data,
-  createItemsInDataArraySeparately = true
+  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
+  return async (context: H) => {
     checkContext(context, "after", undefined, "createRelated");
 
     const { items } = getItemsIsArray(context);
 
-    let dataToCreate = (await Promise.all(
-      items.map(async item => data(item, context))
-    )).filter(x => !!x);
+    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 (!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 => 
+        dataToCreate.map(async (item) =>
           context.app.service(service as string).create(item)
         )
       );
@@ -42,4 +51,4 @@ export function createRelated<S = Record<string, any>>({
 
     return context;
   };
-}
+}

package/src/hooks/onDelete.ts

@@ -1,16 +1,28 @@
 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>>(
+export type OnDeleteAction = "cascade" | "set null";
+
+export interface OnDeleteOptions {
+  keyThere: string;
+  keyHere: string;
+  onDelete: OnDeleteAction;
+  blocking?: boolean;
+}
+
+export function onDelete<
+  S = Record<string, any>,
+  H extends HookContext = HookContext
+>(
   service: keyof S,
   {
     keyThere,
     keyHere = "id",
     onDelete = "cascade",
-    blocking = true
-  }: OnDeleteOptions) {
+    blocking = true,
+  }: OnDeleteOptions
+) {
   if (!service || !keyThere) {
     throw "initialize hook 'removeRelated' completely!";
   }
@@ -18,24 +30,25 @@ export function onDelete<S = Record<string, any>>(
     throw "onDelete must be 'cascade' or 'set null'";
   }
 
-  return async (context: HookContext): Promise<HookContext> => {
-    // @ts-expect-error wait for feathers-hooks-common to update
+  return async (context: H) => {
     checkContext(context, "after", "remove", "onDelete");
 
     const { items } = getItemsIsArray(context);
 
-    let ids = items.map(x => x[keyHere]).filter(x => !!x);
+    let ids = items.map((x) => x[keyHere]).filter((x) => !!x);
     ids = [...new Set(ids)];
 
-    if (!ids || ids.length <= 0) { return context; }
+    if (!ids || ids.length <= 0) {
+      return context;
+    }
 
     const params = {
       query: {
         [keyThere]: {
-          $in: ids
-        }
+          $in: ids,
+        },
       },
-      paginate: false
+      paginate: false,
     };
 
     let promise;
@@ -44,7 +57,9 @@ export function onDelete<S = Record<string, any>>(
       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);
+      promise = context.app
+        .service(service as string)
+        .patch(null, data, params);
     }
 
     if (blocking) {
@@ -53,4 +68,4 @@ export function onDelete<S = Record<string, any>>(
 
     return context;
   };
-}
+}

package/src/hooks/removeRelated.ts

@@ -1,37 +1,49 @@
 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>>({
+export interface RemoveRelatedOptions<S = Record<string, any>> {
+  service: keyof S;
+  keyThere: string;
+  keyHere: string;
+  blocking?: boolean;
+}
+
+export function removeRelated<
+  S = Record<string, any>,
+  H extends HookContext = HookContext
+>({
   service,
   keyThere,
   keyHere = "id",
-  blocking = true
+  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
+  return async (context: H) => {
     checkContext(context, "after", "remove", "removeRelated");
 
     const { items } = getItemsIsArray(context);
 
-    let ids = items.map(x => x[keyHere]).filter(x => !!x);
+    let ids = items.map((x) => x[keyHere]).filter((x) => !!x);
     ids = [...new Set(ids)];
 
-    if (!ids || ids.length <= 0) { return context; }
+    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>);
+    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;
@@ -39,4 +51,4 @@ export function removeRelated<S = Record<string, any>>({
 
     return context;
   };
-}
+}