feathers-utils 2.0.0-9 → 2.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "feathers-utils",
-  "version": "2.0.0-9",
+  "version": "2.1.0",
   "description": "Some utils for projects using '@feathersjs/feathers'",
   "author": "fratzinger",
   "repository": {
@@ -8,23 +8,19 @@
     "url": "https://github.com/fratzinger/feathers-utils"
   },
   "engines": {
-    "node": ">= 14"
+    "node": ">= 16"
   },
   "homepage": "https://github.com/fratzinger/feathers-utils",
   "license": "MIT",
-  "main": "dist/index.js",
-  "module": "dist/esm/index.js",
-  "types": "dist/index.d.ts",
+  "type": "module",
   "exports": {
     ".": {
-      "import": "./dist/esm/index.js",
-      "require": "./dist/index.js",
-      "types": "./dist/index.d.ts"
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
     }
   },
-  "directories": {
-    "dist": "dist"
-  },
+  "main": "./dist/index.cjs",
+  "types": "./dist/index.d.ts",
   "files": [
     "CHANGELOG.md",
     "LICENSE",
@@ -34,44 +30,45 @@
     "dist/**"
   ],
   "scripts": {
-    "build": "shx rm -rf dist/ && npm run tsc",
-    "tsc": "tsc -p tsconfig.json && tsc -p tsconfig-esm.json",
+    "build": "unbuild",
     "version": "npm run build",
     "release": "np",
-    "test": "cross-env NODE_ENV=test TS_NODE_PROJECT='tsconfig.test.json' mocha --require ts-node/register 'test/**/*.test.ts' --timeout 5000",
-    "coverage": "nyc npm run test",
+    "test": "vitest run",
+    "vitest": "vitest",
+    "coverage": "vitest run --coverage",
     "lint": "eslint . --ext .js,.jsx,.ts,.tsx"
   },
   "dependencies": {
-    "@feathersjs/adapter-commons": "5.0.0-pre.33",
-    "@feathersjs/errors": "5.0.0-pre.33",
-    "@feathersjs/feathers": "5.0.0-pre.33",
-    "feathers-hooks-common": "^7.0.0-pre.1",
-    "lodash": "^4.17.21",
-    "type-fest": "^3.2.0"
+    "@feathersjs/adapter-commons": "5.0.0",
+    "@feathersjs/commons": "^5.0.0",
+    "@feathersjs/errors": "5.0.0",
+    "@feathersjs/feathers": "5.0.0",
+    "fast-equals": "^5.0.1",
+    "feathers-hooks-common": "^7.0.0",
+    "lodash": "^4.17.21"
   },
   "devDependencies": {
-    "@feathersjs/memory": "^5.0.0-pre.33",
+    "@feathersjs/memory": "^5.0.0",
     "@istanbuljs/nyc-config-typescript": "^1.0.2",
-    "@types/lodash": "^4.14.189",
-    "@types/mocha": "^10.0.0",
-    "@types/node": "^18.11.9",
-    "@typescript-eslint/eslint-plugin": "^5.44.0",
-    "@typescript-eslint/parser": "^5.44.0",
+    "@types/lodash": "^4.14.191",
+    "@types/mocha": "^10.0.1",
+    "@types/node": "^18.14.1",
+    "@typescript-eslint/eslint-plugin": "^5.53.0",
+    "@typescript-eslint/parser": "^5.53.0",
+    "@vitest/coverage-c8": "^0.29.1",
     "cross-env": "^7.0.3",
-    "eslint": "^8.28.0",
-    "eslint-config-prettier": "^8.5.0",
-    "eslint-import-resolver-typescript": "^3.5.2",
-    "eslint-plugin-import": "^2.26.0",
+    "eslint": "^8.34.0",
+    "eslint-config-prettier": "^8.6.0",
+    "eslint-import-resolver-typescript": "^3.5.3",
+    "eslint-plugin-import": "^2.27.5",
     "eslint-plugin-prettier": "^4.2.1",
-    "eslint-plugin-security": "^1.5.0",
-    "feathers-memory": "^4.1.0",
-    "mocha": "^10.1.0",
-    "np": "^7.6.2",
+    "eslint-plugin-security": "^1.7.1",
+    "np": "^7.6.3",
     "nyc": "^15.1.0",
-    "prettier": "^2.8.0",
+    "prettier": "^2.8.4",
     "shx": "^0.3.4",
-    "ts-node": "^10.9.1",
-    "typescript": "^4.9.3"
+    "typescript": "^4.9.5",
+    "unbuild": "^1.1.2",
+    "vitest": "^0.29.1"
   }
 }

package/src/filters/object.ts

@@ -1,6 +1,6 @@
 import type { FilterQueryOptions } from "@feathersjs/adapter-commons";
 import { validateQueryProperty } from "../utils/validateQueryProperty";
-import _isObject from "lodash/isObject";
+import _isObject from "lodash/isObject.js";
 
 const filterQueryObject =
   (key: string) =>

package/src/hooks/forEach.ts

@@ -0,0 +1,47 @@
+import { shouldSkip } from "../utils/shouldSkip";
+
+import type { ReturnAsyncHook, Promisable } from "../typesInternal";
+import type { HookContext } from "@feathersjs/feathers";
+import type { GetItemsIsArrayOptions } from "../utils/getItemsIsArray";
+import { getItemsIsArray } from "../utils/getItemsIsArray";
+
+export interface HookForEachOptions {
+  wait?: "sequential" | "parallel" | false
+  items?: GetItemsIsArrayOptions["from"]
+}
+
+export const forEach = (
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  actionPerItem: (item: any, context: HookContext) => Promisable<any>, 
+  _options?: HookForEachOptions
+): ReturnAsyncHook => {
+  const options: Required<HookForEachOptions> = {
+    wait: "parallel",
+    items: "automatic",
+    ..._options
+  };
+
+  return async (context: HookContext): Promise<HookContext> => {
+    if (shouldSkip("runForItems", context)) { return context; }
+
+    const { items } =  getItemsIsArray(context, { from: options.items });
+
+    const promises: Promise<any>[] = [];
+
+    for (const item of items) {
+      const promise = actionPerItem(item, context);
+
+      if (options.wait === "sequential") {
+        await promise;
+      } else {
+        promises.push(promise);
+      }
+    }
+
+    if (options.wait === "parallel") {
+      await Promise.all(promises);
+    }
+
+    return context;
+  };
+};

package/src/hooks/index.ts

@@ -1,6 +1,9 @@
 export * from "./checkMulti";
 export * from "./createRelated";
+export * from "./forEach";
 export * from "./onDelete";
+export * from "./parseFields";
 export * from "./removeRelated";
 export * from "./runPerItem";
 export * from "./setData";
+

package/src/hooks/makeSequelizeQuery.ts_

@@ -1,7 +1,7 @@
-import _get from "lodash/get";
-import _isObject from "lodash/isObject";
-import _transform from "lodash/transform";
-import _intersection from "lodash/intersection";
+import _get from "lodash/get.js";
+import _isObject from "lodash/isObject.js";
+import _transform from "lodash/transform.js";
+import _intersection from "lodash/intersection.js";
 import { HookContext, Query } from "@feathersjs/feathers";
 
 import { Model } from "sequelize";

package/src/hooks/parseFields.ts

@@ -0,0 +1,27 @@
+import type { HookContext } from "@feathersjs/feathers";
+import { getItemsIsArray } from "../utils/getItemsIsArray";
+
+/**
+ * Parse fields to date or number
+ * skips undefined fields
+ */
+export const parseFields = (type: "date" | "number", options: { fields: string[] }) => (context: HookContext) => {
+  const { items } = getItemsIsArray(context);
+  
+  items.forEach(item => {
+    options.fields.forEach(field => {
+      // ignore undefined fields
+      if (!(field in item)) {
+        return;
+      }
+  
+      if (type === "date") {
+        item[field] = new Date(item[field]);
+      } else if (type === "number") {
+        item[field] = Number(item[field]);
+      }
+    });
+  });
+
+  return context;
+};

package/src/hooks/runPerItem.ts

@@ -11,12 +11,10 @@ const makeOptions = (
   options?: HookRunPerItemOptions
 ): Required<HookRunPerItemOptions> => {
   options = options || {};
-  return Object.assign(
-    {
-      wait: true,
-    },
-    options
-  );
+  return {
+    wait: true,
+    ...options,
+  };
 };
 
 /**

package/src/hooks/setData.ts

@@ -27,11 +27,10 @@ export function setData<H extends HookContext = HookContext>(
   to: PropertyPath,
   _options?: HookSetDataOptions
 ) {
-  const options: Required<HookSetDataOptions> = Object.assign(
-    {},
-    defaultOptions,
-    _options
-  );
+  const options: Required<HookSetDataOptions> = {
+    ...defaultOptions,
+    ..._options,
+  };
   return (context: H) => {
     if (shouldSkip("setData", context)) {
       return context;

package/src/index.ts

@@ -5,3 +5,4 @@ export * from "./utils";
 export * from "./filters";
 
 export * from "./types";
+export * from "./utility-types";

package/src/typesInternal.ts

@@ -1,6 +1,13 @@
 // here are types that are not meant to be exported!
 // just for internal use of this package
 
+import { HookContext } from "@feathersjs/feathers/lib";
+
 export type MaybeArray<T> = T | T[];
 export type Promisable<T> = T | Promise<T>;
 export type Path = Array<string | number>;
+
+export type HookType = "before" | "after" | "error";
+export type ServiceMethodName = "find" | "get" | "create" | "update" | "patch" | "remove";
+export type ReturnSyncHook = (context: HookContext) => HookContext
+export type ReturnAsyncHook = (context: HookContext) => Promise<HookContext>

package/src/utility-types/index.ts

@@ -0,0 +1,116 @@
+import type { Application, Id } from "@feathersjs/feathers";
+
+type Single<T> = T extends Array<infer U> ? U : T;
+type AsArray<T> = T extends any[] ? T : [T];
+
+export type InferCreateData<S> = S extends {
+  create: (data: infer D, params: any) => any;
+}
+  ? D
+  : never;
+
+export type InferCreateDataSingle<S> = Single<InferCreateData<S>>;
+
+export type InferUpdateData<S> = S extends {
+  update: (id: any, data: infer D, params: any) => any;
+}
+  ? D
+  : never;
+
+export type InferPatchData<S> = S extends {
+  patch: (id: any, data: infer D, params: any) => any;
+}
+  ? D
+  : never;
+
+export type InferGetResult<S> = S extends {
+  get: (id: any, params: any) => infer R;
+}
+  ? Awaited<R>
+  : never;
+
+export type InferFindResult<S> = S extends {
+  find: (params: any) => infer R;
+}
+  ? Awaited<R>
+  : never;
+
+export type InferCreateResult<S, D = unknown> = S extends {
+  create: (data: any, params: any) => infer R;
+}
+  ? D extends any[]
+    ? AsArray<Awaited<R>>
+    : D extends InferCreateDataSingle<S>
+      ? Single<Awaited<R>>
+      : Awaited<R>
+  : never;
+
+export type InferCreateResultSingle<S> = Single<InferCreateResult<S>>;
+
+export type InferUpdateResult<S> = S extends {
+  update: (id: any, data: any, params: any) => infer R;
+}
+  ? Awaited<R>
+  : never;
+
+export type InferPatchResult<S, IdOrNullable = any> = S extends {
+  patch: (id: Id, data: any, params: any) => infer R;
+}
+  ? IdOrNullable extends Id
+    ? Single<Awaited<R>>
+    : IdOrNullable extends null
+      ? AsArray<Awaited<R>>
+      : Awaited<R>
+  : never;
+
+export type InferRemoveResult<S, IdOrNullable = any> = S extends {
+  remove: (id: IdOrNullable, params: any) => infer R;
+}
+  ? IdOrNullable extends Id
+    ? Single<Awaited<R>>
+    : IdOrNullable extends null
+      ? AsArray<Awaited<R>>
+      : Awaited<R>
+  : never;
+
+export type GetService<App extends Application, Path extends string> = App["services"][Path];
+
+export type InferGetResultFromPath<App extends Application, Path extends string> = InferGetResult<GetService<App, Path>>;
+export type InferFindResultFromPath<App extends Application, Path extends string> = InferFindResult<GetService<App, Path>>;
+
+export type InferCreateDataFromPath<App extends Application, Path extends string> = InferCreateData<GetService<App, Path>>
+export type InferCreateDataSingleFromPath<App extends Application, Path extends string> = InferCreateDataSingle<GetService<App, Path>>;
+
+export type InferCreateResultFromPath<App extends Application, Path extends string, D = unknown> = InferCreateResult<GetService<App, Path>, D>;
+export type InferCreateResultSingleFromPath<App extends Application, Path extends string> = InferCreateResultSingle<GetService<App, Path>>;
+
+export type InferUpdateDataFromPath<App extends Application, Path extends string> = InferUpdateData<GetService<App, Path>>
+export type InferPatchDataFromPath<App extends Application, Path extends string> = InferPatchData<GetService<App, Path>>
+
+export type InferUpdateResultFromPath<App extends Application, Path extends string> = InferUpdateResult<GetService<App, Path>>;
+export type InferPatchResultFromPath<App extends Application, Path extends string, IdOrNullable = any> = InferPatchResult<GetService<App, Path>, IdOrNullable>;
+
+export type InferRemoveResultFromPath<App extends Application, Path extends string, IdOrNullable = any> = InferRemoveResult<GetService<App, Path>, IdOrNullable>;
+
+export type InferDataFromPath<App extends Application, Path extends string, Method extends "create" | "update" | "patch"> = Method extends "create"
+  ? InferCreateDataFromPath<App, Path>
+  : Method extends "update"
+    ? InferUpdateDataFromPath<App, Path>
+    : Method extends "patch"
+      ? InferPatchDataFromPath<App, Path>
+      : never;
+
+export type InferResultFromPath<App extends Application, Path extends string, Method extends "get" | "find" | "create" | "update" | "patch" | "remove"> = Method extends "get"
+  ? InferGetResultFromPath<App, Path>
+  : Method extends "find"
+    ? InferFindResultFromPath<App, Path>
+    : Method extends "create"
+      ? InferCreateResultFromPath<App, Path>
+      : Method extends "update"
+        ? InferUpdateResultFromPath<App, Path>
+        : Method extends "patch"
+          ? InferPatchResultFromPath<App, Path>
+          : Method extends "remove"
+            ? InferRemoveResultFromPath<App, Path>
+            : never;
+            

package/src/utils/getItemsIsArray.ts

@@ -1,22 +1,38 @@
 import type { HookContext } from "@feathersjs/feathers";
 
+export type GetItemsIsArrayOptions = {
+  from: "data" | "result" | "automatic"
+}
+
 export interface GetItemsIsArrayResult<T = any> {
-  items: T[];
-  isArray: boolean;
+  items: T[]
+  isArray: boolean
 }
 
-/**
- * util to get items from context, return it as an array, no matter if it is an array or not
- * uses `context.result` if existent. uses `context.data` otherwise
- */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 export const getItemsIsArray = <T = any, H extends HookContext = HookContext>(
-  context: H
+  context: H,
+  options?: GetItemsIsArrayOptions
 ): GetItemsIsArrayResult<T> => {
-  let itemOrItems = context.result !== undefined ? context.result : context.data;
-  itemOrItems =
-    itemOrItems && context.method === "find"
-      ? itemOrItems.data || itemOrItems
+  const {
+    from = "automatic"
+  } = options || {};
+
+  let itemOrItems;
+
+  if (from === "automatic") {
+    itemOrItems = context.type === "before" 
+      ? context.data 
+      : context.result;
+    itemOrItems = itemOrItems && context.method === "find" 
+      ? (itemOrItems.data || itemOrItems) 
       : itemOrItems;
+  } else if (from === "data") {
+    itemOrItems = context.data;
+  } else if (from === "result") {
+    itemOrItems = context.result;
+  }
+  
   const isArray = Array.isArray(itemOrItems);
   return {
     items: isArray ? itemOrItems : itemOrItems != null ? [itemOrItems] : [],

package/src/utils/getPaginate.ts

@@ -1,5 +1,6 @@
 import type { PaginationOptions } from "@feathersjs/adapter-commons";
 import type { HookContext } from "@feathersjs/feathers";
+import { hasOwnProperty } from "./internal.utils";
 
 /**
  * util to get paginate options from context
@@ -10,7 +11,7 @@ import type { HookContext } from "@feathersjs/feathers";
 export const getPaginate = <H extends HookContext = HookContext>(
   context: H
 ): PaginationOptions | undefined => {
-  if (Object.prototype.hasOwnProperty.call(context.params, "paginate")) {
+  if (hasOwnProperty(context.params, "paginate")) {
     return (context.params.paginate as PaginationOptions) || undefined;
   }
 

package/src/utils/internal.utils.ts

@@ -0,0 +1,6 @@
+export const hasOwnProperty = (
+  obj: Record<string, unknown>,
+  ...keys: string[]
+): boolean => {
+  return keys.some((x) => Object.prototype.hasOwnProperty.call(obj, x));
+};

package/src/utils/mergeQuery/mergeQuery.ts

@@ -2,30 +2,39 @@ import _merge from "lodash/merge.js";
 import _isEmpty from "lodash/isEmpty.js";
 import type { Query } from "@feathersjs/feathers";
 import {
+  areQueriesOverlapping,
   handleArray,
   handleCircular,
+  isQueryMoreExplicitThanQuery,
   makeDefaultOptions,
   moveProperty,
 } from "./utils";
 import type { MergeQueryOptions } from "./types";
 import { filterQuery } from "../filterQuery";
-
-export function mergeQuery<T>(
+import { hasOwnProperty } from "../internal.utils";
+
+/**
+ * Merges two queries into one.
+ * @param target Query to be merged into
+ * @param source Query to be merged from
+ * @param _options
+ * @returns Query
+ */
+export function mergeQuery<T = any>(
   target: Query,
   source: Query,
-  options?: Partial<MergeQueryOptions<T>>
+  _options?: Partial<MergeQueryOptions<T>>
 ): Query {
-  const fullOptions = makeDefaultOptions(options);
+  const options = makeDefaultOptions(_options);
   const { filters: targetFilters, query: targetQuery } = filterQuery(target, {
-    operators: fullOptions.operators,
-    filters: fullOptions.filters,
-    service: fullOptions.service,
+    operators: options.operators,
+    filters: options.filters,
+    service: options.service,
   });
 
-  moveProperty(targetFilters, targetQuery, "$or");
-  moveProperty(targetFilters, targetQuery, "$and");
+  moveProperty(targetFilters, targetQuery, "$or", "$and");
 
-  if (target.$limit) {
+  if ("$limit" in target) {
     targetFilters.$limit = target.$limit;
   }
 
@@ -34,13 +43,12 @@ export function mergeQuery<T>(
     filters: sourceFilters,
     query: sourceQuery,
   } = filterQuery(source, {
-    operators: fullOptions.operators,
-    filters: fullOptions.filters,
-    service: fullOptions.service,
+    operators: options.operators,
+    filters: options.filters,
+    service: options.service,
   });
 
-  moveProperty(sourceFilters, sourceQuery, "$or");
-  moveProperty(sourceFilters, sourceQuery, "$and");
+  moveProperty(sourceFilters, sourceQuery, "$or", "$and");
 
   if (source.$limit) {
     sourceFilters.$limit = source.$limit;
@@ -50,37 +58,64 @@ export function mergeQuery<T>(
 
   if (
     target &&
-    !Object.prototype.hasOwnProperty.call(target, "$limit") &&
-    Object.prototype.hasOwnProperty.call(targetFilters, "$limit")
+    !hasOwnProperty(target, "$limit") &&
+    hasOwnProperty(targetFilters, "$limit")
   ) {
     delete targetFilters.$limit;
   }
 
   if (
     source &&
-    !Object.prototype.hasOwnProperty.call(source, "$limit") &&
-    Object.prototype.hasOwnProperty.call(sourceFilters, "$limit")
+    !hasOwnProperty(source, "$limit") &&
+    hasOwnProperty(sourceFilters, "$limit")
   ) {
     delete sourceFilters.$limit;
   }
 
-  handleArray(targetFilters, sourceFilters, ["$select"], fullOptions);
+  handleArray(targetFilters, sourceFilters, ["$select"], options);
   // remaining filters
   delete sourceFilters["$select"];
   _merge(targetFilters, sourceFilters);
 
   //#endregion
 
+  const subsetQuery = isQueryMoreExplicitThanQuery(targetQuery, sourceQuery);
+
+  if (
+    options.defaultHandle === "intersect" &&
+    !!subsetQuery &&
+    !hasOwnProperty(targetQuery, "$or", "$and") &&
+    !hasOwnProperty(sourceQuery, "$or", "$and")
+  ) {
+    return {
+      ...targetFilters,
+      ...subsetQuery,
+    };
+  }
+
+  if (
+    options.defaultHandle === "intersect" &&
+    !areQueriesOverlapping(targetQuery, sourceQuery) &&
+    !hasOwnProperty(targetQuery, "$or", "$and") &&
+    !hasOwnProperty(sourceQuery, "$or", "$and")
+  ) {
+    return {
+      ...targetFilters,
+      ...targetQuery,
+      ...sourceQuery,
+    };
+  }
+
   //#region '$or' / '$and'
 
   if (
-    options?.useLogicalConjunction &&
+    options.useLogicalConjunction &&
     (options.defaultHandle === "combine" ||
       options.defaultHandle === "intersect") &&
     !_isEmpty(targetQuery)
   ) {
     const logicalOp = options.defaultHandle === "combine" ? "$or" : "$and";
-    if (Object.prototype.hasOwnProperty.call(sourceQuery, logicalOp)) {
+    if (hasOwnProperty(sourceQuery, logicalOp)) {
       // omit '$or'/'$and' and put all other props into '$or'/'$and'
       const andOr = sourceQuery[logicalOp] as unknown[];
       delete sourceQuery[logicalOp];
@@ -96,9 +131,11 @@ export function mergeQuery<T>(
   const keys = Object.keys(sourceQuery);
   for (let i = 0, n = keys.length; i < n; i++) {
     const key = keys[i];
-    handleCircular(targetQuery, sourceQuery, [key], fullOptions);
+    handleCircular(targetQuery, sourceQuery, [key], options);
   }
-  const result = Object.assign({}, targetFilters, targetQuery) as Query;
 
-  return result;
+  return {
+    ...targetFilters,
+    ...targetQuery,
+  };
 }