feathers-utils 2.0.0-2 → 2.0.0-4

package/src/utils/isPaginated.ts

@@ -1,12 +1,14 @@
 import type { HookContext } from "@feathersjs/feathers";
 import { getPaginate } from "./getPaginate";
 
-export const isPaginated = (
-  context: HookContext
+export const isPaginated = <H extends HookContext = HookContext>(
+  context: H
 ): boolean => {
-  if (context.params.paginate === false) { return false; }
+  if (context.params.paginate === false) {
+    return false;
+  }
 
   const paginate = getPaginate(context);
 
   return !!paginate;
-};
+};

package/src/utils/markHookForSkip.ts

@@ -1,24 +1,26 @@
 import { pushSet } from "./pushSet";
 
 import type { HookContext } from "@feathersjs/feathers";
-import type { HookType, MaybeArray } from "../types";
+import type { HookType } from "feathers-hooks-common";
+import type { MaybeArray } from "../typesInternal";
 
-export function markHookForSkip<T>(
-  hookName: string, 
-  type: "all" | MaybeArray<HookType>, 
-  context?: Partial<HookContext<T>>
-): Partial<HookContext<T>> {
+export function markHookForSkip<H extends HookContext = HookContext>(
+  hookName: string,
+  type: "all" | MaybeArray<HookType>,
+  context?: H
+) {
+  // @ts-expect-error context is not of type 'H'
   context = context || {};
-  const params = context.params || {};
-  const types: string[] = (Array.isArray(type)) ? type : [type];
-  
-  types.forEach(t => {
-    const combinedName = (t === "all")
-      ? hookName
-      : `${type}:${hookName}`;
+  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+  const params = context!.params || {};
+  const types: string[] = Array.isArray(type) ? type : [type];
+
+  types.forEach((t) => {
+    const combinedName = t === "all" ? hookName : `${type}:${hookName}`;
     pushSet(params, ["skipHooks"], combinedName, { unique: true });
   });
-  
-  context.params = params;
+
+  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+  context!.params = params;
   return context;
-}
+}

package/src/utils/mergeQuery/index.ts

@@ -1,379 +1,3 @@
-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 _merge from "lodash/merge.js";
-import _set from "lodash/set.js";
-import _uniqWith from "lodash/uniqWith.js";
-
-import { mergeArrays } from "./mergeArrays";
-import { filterQuery } from "../filterQuery";
-
-import { Forbidden } from "@feathersjs/errors";
-
-import type { Query } from "@feathersjs/feathers";
-
-import type {
-  Handle,
-  MergeQueryOptions,
-  Path
-} from "../../types";
-
-const hasOwnProperty = (obj: Record<string, unknown>, key: string): boolean => {
-  return Object.prototype.hasOwnProperty.call(obj, key);
-};
-
-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);
-}
-
-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);
-  }
-}
-
-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>;
-}
-
-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 mergeQuery<T>(target: Query, source: Query, options?: Partial<MergeQueryOptions<T>>): Query {
-  const fullOptions = makeDefaultOptions(options);
-  const {
-    filters: targetFilters, 
-    query: targetQuery 
-  } = filterQuery(target, { 
-    operators: fullOptions.operators, 
-    service: fullOptions.service 
-  });
-
-  moveProperty(targetFilters, targetQuery, "$or");
-  moveProperty(targetFilters, targetQuery, "$and");
-
-  if (target.$limit) { targetFilters.$limit = target.$limit; }
-  
-  let {
-    // eslint-disable-next-line prefer-const
-    filters: sourceFilters, 
-    query: sourceQuery 
-  } = filterQuery(source, { 
-    operators: fullOptions.operators, 
-    service: fullOptions.service 
-  });
-
-  moveProperty(sourceFilters, sourceQuery, "$or");
-  moveProperty(sourceFilters, sourceQuery, "$and");
-
-  if (source.$limit) { sourceFilters.$limit = source.$limit; }
-
-  //#region filters
-  
-  if (
-    target && 
-    !Object.prototype.hasOwnProperty.call(target, "$limit") && 
-    Object.prototype.hasOwnProperty.call(targetFilters, "$limit")
-  ) {
-    delete targetFilters.$limit;
-  }
-
-  if (
-    source && 
-    !Object.prototype.hasOwnProperty.call(source, "$limit") && 
-    Object.prototype.hasOwnProperty.call(sourceFilters, "$limit")
-  ) {
-    delete sourceFilters.$limit;
-  }
-
-  handleArray(targetFilters, sourceFilters, ["$select"], fullOptions);
-  // remaining filters
-  delete sourceFilters["$select"];
-  _merge(targetFilters, sourceFilters);
-
-  //#endregion
-
-  //#region '$or' / '$and'
-
-  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)) {
-      // omit '$or'/'$and' and put all other props into '$or'/'$and'
-      const andOr = sourceQuery[logicalOp] as unknown[];
-      delete sourceQuery[logicalOp];
-      andOr.push(sourceQuery);
-      sourceQuery = { [logicalOp]: andOr };
-    } else {
-      sourceQuery = { [logicalOp]: [sourceQuery] };
-    }
-  }
-
-  //#endregion
-
-  const keys = Object.keys(sourceQuery);
-  for (let i = 0, n = keys.length; i < n; i++) {
-    const key = keys[i];
-    handleCircular(targetQuery, sourceQuery, [key], fullOptions);
-  }
-  const result = Object.assign({}, targetFilters, targetQuery) as Query;
-
-  return result;
-}
-
-function getParentProp(target: Record<string, unknown>, path: Path) {
-  if (path.length <= 1) { return target; }
-  const pathOneUp = path.slice(0, -1);
-  return _get(target, pathOneUp);
-}
-
-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);
-  }
-}
-
-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);
-  }
-}
-
-function arrayWithoutDuplicates<T>(target: T[]): T[] {
-  if (!target || !Array.isArray(target)) { return target; }
-  return _uniqWith(target, _isEqual);
-}
+export * from "./mergeArrays";
+export * from "./mergeQuery";
+export * from "./types";

package/src/utils/mergeQuery/mergeArrays.ts

@@ -1,24 +1,27 @@
-import type {
-  Handle,
-  ActionOnEmptyIntersect,
-  Path
-} from "../../types";
+import type { Path } from "../../typesInternal";
+import type { Handle, ActionOnEmptyIntersect } from "./types";
 
-export function mergeArrays<T> (
-  targetArr: T[], 
-  sourceArr: T[], 
-  handle: Handle, 
-  prependKey?: Path, 
+export function mergeArrays<T>(
+  targetArr: T[],
+  sourceArr: T[],
+  handle: Handle,
+  prependKey?: Path,
   actionOnEmptyIntersect?: ActionOnEmptyIntersect
-): T[]|undefined {
-  if (!sourceArr && !targetArr) { return; }
+): T[] | undefined {
+  if (!sourceArr && !targetArr) {
+    return;
+  }
   if (handle === "target") {
     return targetArr;
   } else if (handle === "source") {
     return sourceArr;
   } else if (handle === "combine") {
-    if (!sourceArr || !Array.isArray(sourceArr)) { return targetArr; }
-    if (!targetArr || !Array.isArray(targetArr)) { return sourceArr; }
+    if (!sourceArr || !Array.isArray(sourceArr)) {
+      return targetArr;
+    }
+    if (!targetArr || !Array.isArray(targetArr)) {
+      return sourceArr;
+    }
     const arr = targetArr.concat(sourceArr);
     return [...new Set(arr)];
   } else if (handle === "intersect" || handle === "intersectOrFull") {
@@ -27,17 +30,21 @@ export function mergeArrays<T> (
 
     if ((targetIsArray || sourceIsArray) && handle === "intersect") {
       if (actionOnEmptyIntersect) {
-        actionOnEmptyIntersect(targetArr as unknown, sourceArr, prependKey || []);
+        actionOnEmptyIntersect(
+          targetArr as unknown,
+          sourceArr,
+          prependKey || []
+        );
       }
       return;
     }
 
     if (handle === "intersectOrFull") {
-      const val = (!targetIsArray) ? targetArr : sourceArr;
+      const val = !targetIsArray ? targetArr : sourceArr;
       return val;
     }
 
-    return targetArr.filter(val => sourceArr.includes(val));
+    return targetArr.filter((val) => sourceArr.includes(val));
   }
   return undefined;
-}
+}

package/src/utils/mergeQuery/mergeQuery.ts

@@ -0,0 +1,102 @@
+import _merge from "lodash/merge.js";
+import _isEmpty from "lodash/isEmpty.js";
+import type { Query } from "@feathersjs/feathers";
+import {
+  handleArray,
+  handleCircular,
+  makeDefaultOptions,
+  moveProperty,
+} from "./utils";
+import type { MergeQueryOptions } from "./types";
+import { filterQuery } from "../filterQuery";
+
+export function mergeQuery<T>(
+  target: Query,
+  source: Query,
+  options?: Partial<MergeQueryOptions<T>>
+): Query {
+  const fullOptions = makeDefaultOptions(options);
+  const { filters: targetFilters, query: targetQuery } = filterQuery(target, {
+    operators: fullOptions.operators,
+    service: fullOptions.service,
+  });
+
+  moveProperty(targetFilters, targetQuery, "$or");
+  moveProperty(targetFilters, targetQuery, "$and");
+
+  if (target.$limit) {
+    targetFilters.$limit = target.$limit;
+  }
+
+  let {
+    // eslint-disable-next-line prefer-const
+    filters: sourceFilters,
+    query: sourceQuery,
+  } = filterQuery(source, {
+    operators: fullOptions.operators,
+    service: fullOptions.service,
+  });
+
+  moveProperty(sourceFilters, sourceQuery, "$or");
+  moveProperty(sourceFilters, sourceQuery, "$and");
+
+  if (source.$limit) {
+    sourceFilters.$limit = source.$limit;
+  }
+
+  //#region filters
+
+  if (
+    target &&
+    !Object.prototype.hasOwnProperty.call(target, "$limit") &&
+    Object.prototype.hasOwnProperty.call(targetFilters, "$limit")
+  ) {
+    delete targetFilters.$limit;
+  }
+
+  if (
+    source &&
+    !Object.prototype.hasOwnProperty.call(source, "$limit") &&
+    Object.prototype.hasOwnProperty.call(sourceFilters, "$limit")
+  ) {
+    delete sourceFilters.$limit;
+  }
+
+  handleArray(targetFilters, sourceFilters, ["$select"], fullOptions);
+  // remaining filters
+  delete sourceFilters["$select"];
+  _merge(targetFilters, sourceFilters);
+
+  //#endregion
+
+  //#region '$or' / '$and'
+
+  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)) {
+      // omit '$or'/'$and' and put all other props into '$or'/'$and'
+      const andOr = sourceQuery[logicalOp] as unknown[];
+      delete sourceQuery[logicalOp];
+      andOr.push(sourceQuery);
+      sourceQuery = { [logicalOp]: andOr };
+    } else {
+      sourceQuery = { [logicalOp]: [sourceQuery] };
+    }
+  }
+
+  //#endregion
+
+  const keys = Object.keys(sourceQuery);
+  for (let i = 0, n = keys.length; i < n; i++) {
+    const key = keys[i];
+    handleCircular(targetQuery, sourceQuery, [key], fullOptions);
+  }
+  const result = Object.assign({}, targetFilters, targetQuery) as Query;
+
+  return result;
+}

package/src/utils/mergeQuery/types.ts

@@ -0,0 +1,25 @@
+import type { Path } from "../../typesInternal";
+import type { FilterQueryOptions } from "../filterQuery";
+
+export type Handle =
+  | "target"
+  | "source"
+  | "combine"
+  | "intersect"
+  | "intersectOrFull";
+export type FirstLast = "first" | "last";
+
+export type ActionOnEmptyIntersect = (
+  target: unknown,
+  source: unknown,
+  prependKey: Path
+) => void;
+
+export interface MergeQueryOptions<T> extends FilterQueryOptions<T> {
+  defaultHandle: Handle;
+  actionOnEmptyIntersect: ActionOnEmptyIntersect;
+  useLogicalConjunction: boolean;
+  handle?: {
+    [key: string]: Handle;
+  };
+}