feathers-utils 2.0.0-8 → 2.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "feathers-utils",
-  "version": "2.0.0-8",
+  "version": "2.0.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,44 @@
     "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.29",
-    "@feathersjs/errors": "5.0.0-pre.29",
-    "@feathersjs/feathers": "5.0.0-pre.29",
-    "feathers-hooks-common": "^7.0.0-pre.0",
-    "lodash": "^4.17.21",
-    "type-fest": "^2.19.0"
+    "@feathersjs/adapter-commons": "5.0.0",
+    "@feathersjs/commons": "^5.0.0",
+    "@feathersjs/errors": "5.0.0",
+    "@feathersjs/feathers": "5.0.0",
+    "feathers-hooks-common": "^7.0.0",
+    "lodash": "^4.17.21"
   },
   "devDependencies": {
-    "@feathersjs/memory": "^5.0.0-pre.20",
+    "@feathersjs/memory": "^5.0.0",
     "@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",
+    "@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.23.1",
-    "eslint-config-prettier": "^8.5.0",
-    "eslint-import-resolver-typescript": "^3.5.1",
-    "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.0.0",
-    "np": "^7.6.2",
+    "eslint-plugin-security": "^1.7.1",
+    "np": "^7.6.3",
     "nyc": "^15.1.0",
-    "prettier": "^2.7.1",
+    "prettier": "^2.8.4",
     "shx": "^0.3.4",
-    "ts-node": "^10.9.1",
-    "typescript": "^4.8.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

@@ -21,8 +21,7 @@ const makeOptions = (
 
 /**
  * hook to run a hook for each item in the context
- * uses `context.data` in a before hook
- * uses `context.result` in an after hook
+ * uses `context.result` if it is existent. otherwise uses context.data
  */
 export const runPerItem = <H extends HookContext = HookContext>(
   // eslint-disable-next-line @typescript-eslint/no-explicit-any

package/src/hooks/setData.ts

@@ -20,7 +20,7 @@ const defaultOptions: Required<HookSetDataOptions> = {
 };
 
 /**
- * hook to set properties on `context.data` (before-hook) or `context.result` (after-hook)
+ * hook to set properties on `context.result` (if existent) or `context.data` (otherwise)
  */
 export function setData<H extends HookContext = HookContext>(
   from: PropertyPath,

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/filterQuery.ts

@@ -34,10 +34,8 @@ export function filterQuery<T>(query: Query, _options?: FilterQueryOptions<T>) {
     if (
       service &&
       "filterQuery" in service &&
-      // @ts-expect-error service is of type 'never'
       typeof service.filterQuery === "function"
     ) {
-      // @ts-expect-error service has no filterQuery method
       return service.filterQuery({ query }, optionsForFilterQuery);
     } else {
       return plainFilterQuery(query, optionsForFilterQuery);

package/src/utils/getItemsIsArray.ts

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

@@ -17,7 +17,7 @@ export const getPaginate = <H extends HookContext = HookContext>(
   if (context.params.paginate === false) {
     return undefined;
   }
-  let options = context.service.options || {};
+  let options = context.service?.options || {};
 
   options = {
     ...options,

package/src/utils/isPaginated.ts

@@ -7,7 +7,7 @@ import { getPaginate } from "./getPaginate";
 export const isPaginated = <H extends HookContext = HookContext>(
   context: H
 ): boolean => {
-  if (context.params.paginate === false) {
+  if (context.params.paginate === false || context.method !== "find") {
     return false;
   }
 

package/src/utils/shouldSkip.ts

@@ -31,24 +31,12 @@ export const shouldSkip = <
   const { type } = context;
   if (skipHooks.includes(hookName)) {
     return true;
-  }
-  if (skipHooks.includes("all")) {
+  } else if (skipHooks.includes("all")) {
+    return true;
+  } else if (skipHooks.includes(type)) {
+    return true;
+  } else if (skipHooks.includes(`${type}:${hookName}`)) {
     return true;
-  }
-  if (type === "before") {
-    return (
-      skipHooks.includes(`before:${hookName}`) || skipHooks.includes("before")
-    );
-  }
-  if (type === "after") {
-    return (
-      skipHooks.includes(`after:${hookName}`) || skipHooks.includes("after")
-    );
-  }
-  if (type === "error") {
-    return (
-      skipHooks.includes(`error:${hookName}`) || skipHooks.includes("error")
-    );
   }
 
   return false;

package/dist/esm/filters/array.d.ts

@@ -1,2 +0,0 @@
-import type { FilterQueryOptions } from "@feathersjs/adapter-commons";
-export declare const filterArray: <T extends string[]>(...keys: T) => { [key in T[number]]: (value: any, options: FilterQueryOptions) => any; };

package/dist/esm/filters/array.js

@@ -1,17 +0,0 @@
-import { validateQueryProperty } from "../utils/validateQueryProperty";
-const filterQueryArray = (key) => (arr, { operators }) => {
-    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));
-    }
-    return arr;
-};
-export const filterArray = (...keys) => {
-    const result = {};
-    for (const key of keys) {
-        result[key] = filterQueryArray(key);
-    }
-    return result;
-};

package/dist/esm/filters/index.d.ts

@@ -1,2 +0,0 @@
-export * from "./array";
-export * from "./object";

package/dist/esm/filters/index.js

@@ -1,2 +0,0 @@
-export * from "./array";
-export * from "./object";

package/dist/esm/filters/object.d.ts

@@ -1,2 +0,0 @@
-import type { FilterQueryOptions } from "@feathersjs/adapter-commons";
-export declare const filterObject: <T extends string[]>(...keys: T) => { [key in T[number]]: (value: any, options: FilterQueryOptions) => any; };

package/dist/esm/filters/object.js

@@ -1,15 +0,0 @@
-import { validateQueryProperty } from "../utils/validateQueryProperty";
-import _isObject from "lodash/isObject";
-const filterQueryObject = (key) => (obj, { operators }) => {
-    if (obj && !_isObject(obj)) {
-        throw new Error(`Invalid query parameter: '${key}'. It has to be an object`);
-    }
-    return validateQueryProperty(obj, operators);
-};
-export const filterObject = (...keys) => {
-    const result = {};
-    for (const key of keys) {
-        result[key] = filterQueryObject(key);
-    }
-    return result;
-};

package/dist/esm/hooks/checkMulti.d.ts

@@ -1,5 +0,0 @@
-import type { HookContext } from "@feathersjs/feathers";
-/**
- * hook to check if context is multi patch/remove and if the service allows it
- */
-export declare function checkMulti<H extends HookContext = HookContext>(): (context: H) => H;

package/dist/esm/hooks/checkMulti.js

@@ -1,20 +0,0 @@
-import { MethodNotAllowed } from "@feathersjs/errors";
-import { shouldSkip, isMulti } from "../utils";
-/**
- * hook to check if context is multi patch/remove and if the service allows it
- */
-export function checkMulti() {
-    return (context) => {
-        if (shouldSkip("checkMulti", context)) {
-            return context;
-        }
-        const { service, method } = context;
-        if (!service.allowsMulti || !isMulti(context) || method === "find") {
-            return context;
-        }
-        if (!service.allowsMulti(method)) {
-            throw new MethodNotAllowed(`Can not ${method} multiple entries`);
-        }
-        return context;
-    };
-}

package/dist/esm/hooks/createRelated.d.ts

@@ -1,12 +0,0 @@
-import type { HookContext } from "@feathersjs/feathers";
-import type { Promisable } from "../typesInternal";
-export interface CreateRelatedOptions<S = Record<string, any>> {
-    service: keyof S;
-    multi?: boolean;
-    data: (item: any, context: HookContext) => Promisable<Record<string, any>>;
-    createItemsInDataArraySeparately?: boolean;
-}
-/**
- * hook to create related items
- */
-export declare function createRelated<S = Record<string, any>, H extends HookContext = HookContext>({ service, multi, data, createItemsInDataArraySeparately, }: CreateRelatedOptions<S>): (context: H) => Promise<H>;

package/dist/esm/hooks/createRelated.js

@@ -1,31 +0,0 @@
-import { checkContext } from "feathers-hooks-common";
-import { getItemsIsArray, shouldSkip } from "../utils";
-/**
- * hook to create related items
- */
-export function createRelated({ service, multi = true, data, createItemsInDataArraySeparately = true, }) {
-    if (!service || !data) {
-        throw "initialize hook 'createRelated' completely!";
-    }
-    return async (context) => {
-        if (shouldSkip("createRelated", context)) {
-            return context;
-        }
-        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).create(dataToCreate);
-        }
-        else {
-            await Promise.all(dataToCreate.map(async (item) => context.app.service(service).create(item)));
-        }
-        return context;
-    };
-}

package/dist/esm/hooks/index.d.ts

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

package/dist/esm/hooks/index.js

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

package/dist/esm/hooks/onDelete.d.ts

@@ -1,12 +0,0 @@
-import type { HookContext } from "@feathersjs/feathers";
-export declare type OnDeleteAction = "cascade" | "set null";
-export interface OnDeleteOptions {
-    keyThere: string;
-    keyHere: string;
-    onDelete: OnDeleteAction;
-    blocking?: boolean;
-}
-/**
- * hook to manipulate related items on delete
- */
-export declare function onDelete<S = Record<string, any>, H extends HookContext = HookContext>(service: keyof S, { keyThere, keyHere, onDelete, blocking, }: OnDeleteOptions): (context: H) => Promise<H>;