feathers-utils 6.0.0 → 7.0.1

package/src/hooks/from-client-for-server/paramsFromClient.ts

@@ -1,5 +1,5 @@
-import type { HookContext } from "@feathersjs/feathers";
-import { FROM_CLIENT_FOR_SERVER_DEFAULT_KEY } from "./common";
+import type { HookContext } from '@feathersjs/feathers'
+import { FROM_CLIENT_FOR_SERVER_DEFAULT_KEY } from './common.js'
 
 export function defineParamsFromClient(keyToHide: string) {
   return function paramsFromClient(
@@ -8,9 +8,9 @@ export function defineParamsFromClient(keyToHide: string) {
     return (context: HookContext): HookContext => {
       if (
         !context.params?.query?.[keyToHide] ||
-        typeof context.params.query[keyToHide] !== "object"
+        typeof context.params.query[keyToHide] !== 'object'
       ) {
-        return context;
+        return context
       }
 
       const params = {
@@ -21,40 +21,40 @@ export function defineParamsFromClient(keyToHide: string) {
             ...context.params.query[keyToHide],
           },
         },
-      };
+      }
 
-      const client = params.query[keyToHide];
+      const client = params.query[keyToHide]
 
       whitelist.forEach((key) => {
         if (key in client) {
-          params[key] = client[key];
-          delete client[key];
+          params[key] = client[key]
+          delete client[key]
         }
-      });
+      })
 
       if (Object.keys(client).length === 0) {
-        delete params.query[keyToHide];
+        delete params.query[keyToHide]
       }
 
-      context.params = params;
+      context.params = params
 
-      return context;
-    };
-  };
+      return context
+    }
+  }
 }
 
 export const paramsFromClient = defineParamsFromClient(
   FROM_CLIENT_FOR_SERVER_DEFAULT_KEY,
-);
+)
 
 if (import.meta.vitest) {
-  const { it, expect } = import.meta.vitest;
+  const { it, expect } = import.meta.vitest
 
-  it("should move params to query._$client", () => {
+  it('should move params to query._$client', () => {
     expect(
       paramsFromClient(
-        "a",
-        "b",
+        'a',
+        'b',
       )({
         params: {
           query: {
@@ -74,12 +74,12 @@ if (import.meta.vitest) {
           c: 3,
         },
       },
-    });
-  });
+    })
+  })
 
-  it("should move params to query._$client and leave remaining", () => {
+  it('should move params to query._$client and leave remaining', () => {
     expect(
-      paramsFromClient("a")({
+      paramsFromClient('a')({
         params: {
           query: {
             _$client: {
@@ -100,6 +100,6 @@ if (import.meta.vitest) {
           c: 3,
         },
       },
-    });
-  });
+    })
+  })
 }

package/src/hooks/index.ts

@@ -1,9 +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";
-export * from "./from-client-for-server";
+export * from './checkMulti.js'
+export * from './createRelated.js'
+export * from './forEach.js'
+export * from './onDelete.js'
+export * from './parseFields.js'
+export * from './removeRelated.js'
+export * from './runPerItem.js'
+export * from './setData.js'
+export * from './from-client-for-server/index.js'

package/src/hooks/onDelete.ts

@@ -1,14 +1,16 @@
-import type { HookContext } from "@feathersjs/feathers";
-import { checkContext } from "feathers-hooks-common";
-import { getItemsIsArray, shouldSkip } from "../utils";
+import type { HookContext } from '@feathersjs/feathers'
+import { checkContext } from 'feathers-hooks-common'
+import { getItemsIsArray, shouldSkip } from '../utils/index.js'
+import type { KeyOf, MaybeArray } from '../typesInternal.js'
 
-export type OnDeleteAction = "cascade" | "set null";
+export type OnDeleteAction = 'cascade' | 'set null'
 
-export interface OnDeleteOptions {
-  keyThere: string;
-  keyHere: string;
-  onDelete: OnDeleteAction;
-  blocking?: boolean;
+export interface OnDeleteOptions<Path extends string = string> {
+  service: Path
+  keyThere: string
+  keyHere: string
+  onDelete: OnDeleteAction
+  blocking?: boolean
 }
 
 /**
@@ -17,62 +19,59 @@ export interface OnDeleteOptions {
 export function onDelete<
   S = Record<string, any>,
   H extends HookContext = HookContext,
->(
-  service: keyof S,
-  {
-    keyThere,
-    keyHere = "id",
-    onDelete = "cascade",
-    blocking = true,
-  }: OnDeleteOptions,
-) {
-  if (!service || !keyThere) {
-    throw "initialize hook 'removeRelated' completely!";
-  }
-  if (!["cascade", "set null"].includes(onDelete)) {
-    throw "onDelete must be 'cascade' or 'set null'";
-  }
-
+>(options: MaybeArray<OnDeleteOptions<KeyOf<S>>>) {
   return async (context: H) => {
-    if (shouldSkip("onDelete", context)) {
-      return context;
+    if (shouldSkip('onDelete', context)) {
+      return context
     }
 
-    checkContext(context, "after", "remove", "onDelete");
+    checkContext(context, 'after', 'remove', 'onDelete')
 
-    const { items } = getItemsIsArray(context);
+    const { items } = getItemsIsArray(context)
 
-    let ids = items.map((x) => x[keyHere]).filter((x) => !!x);
-    ids = [...new Set(ids)];
+    const entries = Array.isArray(options) ? options : [options]
 
-    if (!ids || ids.length <= 0) {
-      return context;
-    }
+    const promises: Promise<any>[] = []
 
-    const params = {
-      query: {
-        [keyThere]: {
-          $in: ids,
-        },
-      },
-      paginate: false,
-    };
+    entries.forEach(
+      async ({ keyHere, keyThere, onDelete, service, blocking }) => {
+        let ids = items.map((x) => x[keyHere]).filter((x) => !!x)
+        ids = [...new Set(ids)]
 
-    let promise;
+        if (!ids || ids.length <= 0) {
+          return context
+        }
 
-    if (onDelete === "cascade") {
-      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);
-    }
+        const params = {
+          query: {
+            [keyThere]: {
+              $in: ids,
+            },
+          },
+          paginate: false,
+        }
 
-    if (blocking) {
-      await promise;
+        let promise: Promise<any> | undefined = undefined
+
+        if (onDelete === 'cascade') {
+          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)
+        }
+
+        if (blocking && promise) {
+          promises.push(promise)
+        }
+      },
+    )
+
+    if (promises.length) {
+      await Promise.all(promises)
     }
 
-    return context;
-  };
+    return context
+  }
 }

package/src/hooks/parseFields.ts

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

package/src/hooks/removeRelated.ts

@@ -1,16 +1,18 @@
-import type { HookContext, Params, Query } from "@feathersjs/feathers";
-import { checkContext } from "feathers-hooks-common";
-import { getItemsIsArray, shouldSkip } from "../utils";
+import type { HookContext, Params, Query } from '@feathersjs/feathers'
+import { checkContext } from 'feathers-hooks-common'
+import { getItemsIsArray, shouldSkip } from '../utils/index.js'
 
 export interface RemoveRelatedOptions<S = Record<string, any>> {
-  service: keyof S;
-  keyThere: string;
-  keyHere: string;
-  blocking?: boolean;
+  service: keyof S
+  keyThere: string
+  keyHere: string
+  blocking?: boolean
 }
 
 /**
  * hook to remove related items
+ *
+ * @deprecated use 'onDelete' instead
  */
 export function removeRelated<
   S = Record<string, any>,
@@ -18,26 +20,26 @@ export function removeRelated<
 >({
   service,
   keyThere,
-  keyHere = "id",
+  keyHere = 'id',
   blocking = true,
 }: RemoveRelatedOptions<S>) {
   if (!service || !keyThere) {
-    throw "initialize hook 'removeRelated' completely!";
+    throw "initialize hook 'removeRelated' completely!"
   }
   return async (context: H) => {
-    if (shouldSkip("removeRelated", context)) {
-      return context;
+    if (shouldSkip('removeRelated', context)) {
+      return context
     }
 
-    checkContext(context, "after", "remove", "removeRelated");
+    checkContext(context, 'after', 'remove', 'removeRelated')
 
-    const { items } = getItemsIsArray(context);
+    const { items } = getItemsIsArray(context)
 
-    let ids = items.map((x) => x[keyHere]).filter((x) => !!x);
-    ids = [...new Set(ids)];
+    let ids = items.map((x) => x[keyHere]).filter((x) => !!x)
+    ids = [...new Set(ids)]
 
     if (!ids || ids.length <= 0) {
-      return context;
+      return context
     }
 
     // feathers does not accept `paginate: false` for remove, but some adapters need it to work properly
@@ -50,12 +52,12 @@ export function removeRelated<
           },
         },
         paginate: false,
-      } as Params<Query>);
+      } as Params<Query>)
 
     if (blocking) {
-      await promise;
+      await promise
     }
 
-    return context;
-  };
+    return context
+  }
 }

package/src/hooks/runPerItem.ts

@@ -1,47 +1,46 @@
-import { shouldSkip, getItemsIsArray } from "../utils";
+import { shouldSkip, getItemsIsArray } from '../utils/index.js'
 
-import type { HookContext } from "@feathersjs/feathers";
-import type { Promisable } from "../typesInternal";
+import type { HookContext } from '@feathersjs/feathers'
+import type { Promisable } from '../typesInternal.js'
 
 export interface HookRunPerItemOptions {
-  wait?: boolean;
+  wait?: boolean
 }
 
 const makeOptions = (
   options?: HookRunPerItemOptions,
 ): Required<HookRunPerItemOptions> => {
-  options = options || {};
+  options = options || {}
   return {
     wait: true,
     ...options,
-  };
-};
+  }
+}
 
 /**
  * hook to run a hook for each item in the context
  * uses `context.result` if it is existent. otherwise uses context.data
  */
 export const runPerItem = <H extends HookContext = HookContext, T = any>(
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   actionPerItem: (item: T, context: H) => Promisable<any>,
   _options?: HookRunPerItemOptions,
 ) => {
-  const options = makeOptions(_options);
+  const options = makeOptions(_options)
   return async (context: H) => {
-    if (shouldSkip("runForItems", context)) {
-      return context;
+    if (shouldSkip('runForItems', context)) {
+      return context
     }
 
-    const { items } = getItemsIsArray(context);
+    const { items } = getItemsIsArray(context)
 
     const promises = items.map(async (item: T) => {
-      await actionPerItem(item, context);
-    });
+      await actionPerItem(item, context)
+    })
 
     if (options.wait) {
-      await Promise.all(promises);
+      await Promise.all(promises)
     }
 
-    return context;
-  };
-};
+    return context
+  }
+}