feathers-utils 2.0.0-2 → 2.0.0-4

package/src/utils/mergeQuery/utils.ts

@@ -0,0 +1,342 @@
+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);
+};
+
+export function handleArray<T>(
+  target: Record<string, unknown>,
+  source: Record<string, unknown>,
+  key: Path,
+  options: MergeQueryOptions<T>
+): void {
+  const targetVal = _get(target, key);
+  const sourceVal = _get(source, key);
+  if (!sourceVal && !targetVal) {
+    return;
+  }
+  const handle: Handle = _get(
+    options,
+    ["handle", ...key],
+    options.defaultHandle
+  );
+  const arr = mergeArrays(
+    targetVal,
+    sourceVal,
+    handle,
+    key,
+    options.actionOnEmptyIntersect
+  );
+  _set(target, key, arr);
+}
+
+export function handleCircular<T>(
+  target: Record<string, unknown>,
+  source: Record<string, unknown>,
+  prependKey: Path,
+  options: MergeQueryOptions<T>
+): void {
+  if (target?.$or) {
+    target.$or = cleanOr(target.$or as Record<string, unknown>[]);
+    if (!target.$or) {
+      delete target.$or;
+    }
+  }
+  if (source?.$or) {
+    source.$or = cleanOr(source.$or as Record<string, unknown>[]);
+    if (!source.$or) {
+      delete source.$or;
+    }
+  }
+
+  if (target?.$and) {
+    target.$and = cleanAnd(target.$and as Record<string, unknown>[]);
+    if (!target.$and) {
+      delete target.$and;
+    }
+  }
+
+  if (source?.$and) {
+    source.$and = cleanAnd(source.$and as Record<string, unknown>[]);
+    if (!source.$and) {
+      delete source.$and;
+    }
+  }
+
+  if (!_has(source, prependKey)) {
+    return;
+  }
+
+  if (!_has(target, prependKey)) {
+    _set(target, prependKey, _get(source, prependKey));
+    return;
+  }
+
+  const { defaultHandle, actionOnEmptyIntersect } = options;
+
+  if (defaultHandle === "target") {
+    return;
+  }
+
+  const getTargetVal = () => {
+    return prependKey.length > 0 ? _get(target, prependKey) : target;
+  };
+
+  const getSourceVal = () => {
+    return prependKey.length > 0 ? _get(source, prependKey) : source;
+  };
+
+  const targetVal = getTargetVal();
+  const sourceVal = getSourceVal();
+
+  if (_isEqual(targetVal, sourceVal)) {
+    return;
+  }
+
+  if (defaultHandle === "source") {
+    _set(target, prependKey, sourceVal);
+    return;
+  }
+
+  if (targetVal === null || sourceVal === null) {
+    _set(target, prependKey, sourceVal);
+    return;
+  }
+
+  const typeOfTargetVal = typeof targetVal;
+
+  if (["boolean"].includes(typeOfTargetVal)) {
+    if (defaultHandle === "intersect") {
+      actionOnEmptyIntersect(target, source, prependKey);
+    }
+    _set(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") {
+        _set(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 (
+      hasOwnProperty(targetVal, "$in") ||
+      hasOwnProperty(sourceVal, "$in")
+    ) {
+      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)) {
+        _set(target, prependKey, otherVal);
+        return;
+      } else if (defaultHandle === "combine") {
+        if (!$in.some((x: unknown) => _isEqual(x, otherVal))) {
+          $in.push(otherVal);
+        }
+        _set(target, `${prependKey}.$in`, $in);
+        return;
+      } else if (defaultHandle === "intersect") {
+        if ($in.some((x: unknown) => _isEqual(x, otherVal))) {
+          _set(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: unknown) => !targetVal.some((y: unknown) => _isEqual(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: unknown) => !targetVal.some((y: unknown) => _isEqual(x, y))
+        );
+        targetVal.push(...newVals);
+        return;
+      }
+    } else if (key === "$in") {
+      if (defaultHandle === "combine") {
+        let $in: unknown[] = targetVal.concat(sourceVal);
+        $in = [...new Set($in)];
+        _set(target, prependKey, $in);
+        return;
+      } else if (defaultHandle === "intersect") {
+        const $in = targetVal.filter((x: unknown) =>
+          sourceVal.some((y: unknown) => _isEqual(x, y))
+        );
+        if ($in.length === 0) {
+          actionOnEmptyIntersect(target, source, prependKey);
+        } else if ($in.length === 1) {
+          _set(target, prependKey.slice(0, -1), $in[0]);
+          return;
+        } else {
+          _set(target, prependKey, $in);
+        }
+      }
+      return;
+    }
+
+    _set(target, prependKey, sourceVal);
+    return;
+  }
+
+  if (typeOfTargetVal !== "object" || typeOfSourceVal !== "object") {
+    _set(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);
+  }
+}
+
+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.handle = options.handle || {};
+  if (options.defaultHandle === "intersect") {
+    options.handle.$select = options.handle.$select || "intersectOrFull";
+  }
+  return options as MergeQueryOptions<T>;
+}
+
+export function moveProperty(
+  source: Record<string, any>,
+  target: Record<string, any>,
+  key: string
+): void {
+  if (!Object.prototype.hasOwnProperty.call(source, key)) {
+    return;
+  }
+  target[key] = source[key];
+  delete source[key];
+}
+
+export function getParentProp(target: Record<string, unknown>, path: Path) {
+  if (path.length <= 1) {
+    return target;
+  }
+  const pathOneUp = path.slice(0, -1);
+  return _get(target, pathOneUp);
+}
+
+export function cleanOr(
+  target: Record<string, unknown>[]
+): Record<string, unknown>[] | undefined {
+  if (!target || !Array.isArray(target) || target.length <= 0) {
+    return target;
+  }
+
+  if (target.some((x) => _isEmpty(x))) {
+    return undefined;
+  } else {
+    return arrayWithoutDuplicates(target);
+  }
+}
+
+export function cleanAnd(
+  target: Record<string, unknown>[]
+): Record<string, unknown>[] | undefined {
+  if (!target || !Array.isArray(target) || target.length <= 0) {
+    return target;
+  }
+
+  if (target.every((x) => _isEmpty(x))) {
+    return undefined;
+  } else {
+    target = target.filter((x) => !_isEmpty(x));
+    return arrayWithoutDuplicates(target);
+  }
+}
+
+export function arrayWithoutDuplicates<T>(target: T[]): T[] {
+  if (!target || !Array.isArray(target)) {
+    return target;
+  }
+  return _uniqWith(target, _isEqual);
+}

package/src/utils/pushSet.ts

@@ -1,13 +1,18 @@
 import _isEqual from "lodash/isEqual.js";
 import _get from "lodash/get.js";
 import _set from "lodash/set.js";
+import type { Path } from "../typesInternal";
 
-import type {
-  Path,
-  PushSetOptions
-} from "../types";
+export interface PushSetOptions {
+  unique?: boolean;
+}
 
-export const pushSet = (obj: Record<string, unknown>, path: string | Path, val: unknown, options?: PushSetOptions): unknown[] => {
+export const pushSet = (
+  obj: Record<string, unknown>,
+  path: string | Path,
+  val: unknown,
+  options?: PushSetOptions
+): unknown[] => {
   options = options || {};
   let arr = _get(obj, path);
   if (!arr || !Array.isArray(arr)) {
@@ -15,8 +20,10 @@ export const pushSet = (obj: Record<string, unknown>, path: string | Path, val:
     _set(obj, path, arr);
     return arr;
   } else {
-    if (options.unique && arr.some(x => _isEqual(x, val))) { return arr; }
+    if (options.unique && arr.some((x) => _isEqual(x, val))) {
+      return arr;
+    }
     arr.push(val);
     return arr;
   }
-};
+};

package/src/utils/setResultEmpty.ts

@@ -2,10 +2,12 @@ import type { HookContext } from "@feathersjs/feathers";
 import { isMulti } from "..";
 import { isPaginated } from "./isPaginated";
 
-export const setResultEmpty = (
-  context: HookContext
-): HookContext => {
-  if (context.result) { return context; }
+export const setResultEmpty = <H extends HookContext = HookContext>(
+  context: H
+) => {
+  if (context.result) {
+    return context;
+  }
 
   const multi = isMulti(context);
 
@@ -15,7 +17,7 @@ export const setResultEmpty = (
         total: 0,
         skip: 0,
         limit: 0,
-        data: []
+        data: [],
       };
     } else {
       context.result = [];
@@ -25,4 +27,4 @@ export const setResultEmpty = (
   }
 
   return context;
-};
+};

package/src/utils/shouldSkip.ts

@@ -5,9 +5,9 @@ import { GeneralError } from "@feathersjs/errors";
 
 import type { HookContext } from "@feathersjs/feathers";
 
-export const shouldSkip = (
-  hookName: string, 
-  context: HookContext
+export const shouldSkip = <H extends HookContext = HookContext>(
+  hookName: string,
+  context: H
 ): boolean => {
   if (!context.params || !context.params.skipHooks) {
     return false;
@@ -41,4 +41,4 @@ export const shouldSkip = (
   }
 
   return false;
-};
+};

package/src/utils/validateQueryProperty.ts

@@ -2,9 +2,13 @@ import { _ } from "@feathersjs/commons";
 import { BadRequest } from "@feathersjs/errors";
 import type { Query } from "@feathersjs/feathers";
 
-const isPlainObject = (value: any) => _.isObject(value) && value.constructor === {}.constructor;
+const isPlainObject = (value: any) =>
+  _.isObject(value) && value.constructor === {}.constructor;
 
-export const validateQueryProperty = (query: any, operators: string[] = []): Query => {
+export const validateQueryProperty = (
+  query: any,
+  operators: string[] = []
+): Query => {
   if (!isPlainObject(query)) {
     return query;
   }
@@ -22,6 +26,6 @@ export const validateQueryProperty = (query: any, operators: string[] = []): Que
   }
 
   return {
-    ...query
+    ...query,
   };
-};
+};