feathers-utils 6.0.0 → 7.0.1

package/src/hooks/checkMulti.ts

@@ -1,32 +1,32 @@
-import { MethodNotAllowed } from "@feathersjs/errors";
-import { shouldSkip, isMulti } from "../utils";
+import { MethodNotAllowed } from '@feathersjs/errors'
+import { shouldSkip, isMulti } from '../utils/index.js'
 
-import type { HookContext } from "@feathersjs/feathers";
+import type { HookContext } from '@feathersjs/feathers'
 
 /**
  * hook to check if context is multi patch/remove and if the service allows it
  */
 export function checkMulti<H extends HookContext = HookContext>() {
   return (context: H) => {
-    if (shouldSkip("checkMulti", context)) {
-      return context;
+    if (shouldSkip('checkMulti', context)) {
+      return context
     }
 
-    const { service, method } = context;
-    if (!service.allowsMulti || !isMulti(context) || method === "find") {
-      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`);
+      throw new MethodNotAllowed(`Can not ${method} multiple entries`)
     }
 
-    return context;
-  };
+    return context
+  }
 }
 
 if (import.meta.vitest) {
-  const { it, assert } = import.meta.vitest;
+  const { it, assert } = import.meta.vitest
 
   it("passes if 'allowsMulti' not defined", function () {
     const makeContext = (type: string, method: string) =>
@@ -34,20 +34,20 @@ if (import.meta.vitest) {
         service: {},
         type,
         method,
-      }) as HookContext;
-    ["before", "after"].forEach((type) => {
-      ["find", "get", "create", "update", "patch", "remove"].forEach(
+      }) as HookContext
+    ;['before', 'after'].forEach((type) => {
+      ;['find', 'get', 'create', 'update', 'patch', 'remove'].forEach(
         (method) => {
-          const context = makeContext(type, method);
+          const context = makeContext(type, method)
 
           assert.doesNotThrow(
             () => checkMulti()(context),
             `'${type}:${method}': does not throw`,
-          );
+          )
         },
-      );
-    });
-  });
+      )
+    })
+  })
 
   it("passes if 'allowsMulti' returns true", function () {
     const makeContext = (type: string, method: string) => {
@@ -57,24 +57,28 @@ if (import.meta.vitest) {
         },
         method,
         type,
-      } as HookContext;
-      if (method === "create") {
-        type === "before" ? (context.data = []) : (context.result = []);
+      } as HookContext
+      if (method === 'create') {
+        if (type === 'before') {
+          context.data = []
+        } else {
+          context.result = []
+        }
       }
-      return context as HookContext;
-    };
-    ["before", "after"].forEach((type) => {
-      ["find", "get", "create", "update", "patch", "remove"].forEach(
+      return context as HookContext
+    }
+    ;['before', 'after'].forEach((type) => {
+      ;['find', 'get', 'create', 'update', 'patch', 'remove'].forEach(
         (method) => {
-          const context = makeContext(type, method);
+          const context = makeContext(type, method)
           assert.doesNotThrow(
             () => checkMulti()(context),
             `'${type}:${method}': does not throw`,
-          );
+          )
         },
-      );
-    });
-  });
+      )
+    })
+  })
 
   it("passes for 'find', 'get' and 'update'", function () {
     const makeContext = (type: string, method: string) =>
@@ -84,45 +88,49 @@ if (import.meta.vitest) {
         },
         type,
         method,
-      }) as HookContext;
-    ["before", "after"].forEach((type) => {
-      ["find", "get", "update"].forEach((method) => {
-        const context = makeContext(type, method);
+      }) as HookContext
+    ;['before', 'after'].forEach((type) => {
+      ;['find', 'get', 'update'].forEach((method) => {
+        const context = makeContext(type, method)
         assert.doesNotThrow(
           () => checkMulti()(context),
           `'${type}:${method}': does not throw`,
-        );
-      });
-    });
-  });
+        )
+      })
+    })
+  })
 
   it("passes if 'allowsMulti' returns false and is no multi data", function () {
     const makeContext = (type: string, method: string) => {
       const context = {
         service: {
-          allowsMulti: (method: string) => method !== "find",
+          allowsMulti: (method: string) => method !== 'find',
         },
         method,
         type,
-      } as HookContext;
-      if (method === "create") {
-        type === "before" ? (context.data = {}) : (context.result = {});
+      } as HookContext
+      if (method === 'create') {
+        if (type === 'before') {
+          context.data = {}
+        } else {
+          context.result = {}
+        }
       }
-      if (["patch", "remove"].includes(method)) {
-        context.id = 1;
+      if (['patch', 'remove'].includes(method)) {
+        context.id = 1
       }
-      return context as HookContext;
-    };
-    ["before", "after"].forEach((type) => {
-      ["create", "patch", "remove"].forEach((method) => {
-        const context = makeContext(type, method);
+      return context as HookContext
+    }
+    ;['before', 'after'].forEach((type) => {
+      ;['create', 'patch', 'remove'].forEach((method) => {
+        const context = makeContext(type, method)
         assert.doesNotThrow(
           () => checkMulti()(context),
           `'${type}:${method}': does not throw`,
-        );
-      });
-    });
-  });
+        )
+      })
+    })
+  })
 
   it("throws if 'allowsMulti' returns false and multi data", function () {
     const makeContext = (type: string, method: string) => {
@@ -132,21 +140,25 @@ if (import.meta.vitest) {
         },
         method,
         type,
-      } as HookContext;
-      if (method === "create") {
-        type === "before" ? (context.data = []) : (context.result = []);
+      } as HookContext
+      if (method === 'create') {
+        if (type === 'before') {
+          context.data = []
+        } else {
+          context.result = []
+        }
       }
-      return context as HookContext;
-    };
-    ["before", "after"].forEach((type) => {
-      ["create", "patch", "remove"].forEach((method) => {
-        const context = makeContext(type, method);
-        assert.throws(() => checkMulti()(context));
-      });
-    });
-  });
+      return context as HookContext
+    }
+    ;['before', 'after'].forEach((type) => {
+      ;['create', 'patch', 'remove'].forEach((method) => {
+        const context = makeContext(type, method)
+        assert.throws(() => checkMulti()(context))
+      })
+    })
+  })
 
-  it("can skip hook", function () {
+  it('can skip hook', function () {
     const makeContext = (type: string, method: string) => {
       const context = {
         service: {
@@ -155,23 +167,27 @@ if (import.meta.vitest) {
         method,
         type,
         params: {},
-      } as HookContext;
-      if (method === "create") {
-        type === "before" ? (context.data = []) : (context.result = []);
+      } as HookContext
+      if (method === 'create') {
+        if (type === 'before') {
+          context.data = {}
+        } else {
+          context.result = {}
+        }
       }
-      return context as HookContext;
-    };
-    ["before", "after"].forEach((type) => {
-      ["create", "patch", "remove"].forEach((method) => {
-        const context = makeContext(type, method);
+      return context as HookContext
+    }
+    ;['before', 'after'].forEach((type) => {
+      ;['create', 'patch', 'remove'].forEach((method) => {
+        const context = makeContext(type, method)
         context.params = {
-          skipHooks: ["checkMulti"],
-        };
+          skipHooks: ['checkMulti'],
+        }
         assert.doesNotThrow(
           () => checkMulti()(context),
           `'${type}:${method}': throws`,
-        );
-      });
-    });
-  });
+        )
+      })
+    })
+  })
 }

package/src/hooks/createRelated.ts

@@ -1,13 +1,13 @@
-import type { HookContext } from "@feathersjs/feathers";
-import { checkContext } from "feathers-hooks-common";
-import type { Promisable } from "../typesInternal";
-import { getItemsIsArray, shouldSkip } from "../utils";
+import type { HookContext } from '@feathersjs/feathers'
+import { checkContext } from 'feathers-hooks-common'
+import type { MaybeArray, Promisable } from '../typesInternal.js'
+import { getItemsIsArray, shouldSkip } from '../utils/index.js'
 
 export interface CreateRelatedOptions<S = Record<string, any>> {
-  service: keyof S;
-  multi?: boolean;
-  data: (item: any, context: HookContext) => Promisable<Record<string, any>>;
-  createItemsInDataArraySeparately?: boolean;
+  service: keyof S
+  multi?: boolean
+  data: (item: any, context: HookContext) => Promisable<Record<string, any>>
+  createItemsInDataArraySeparately?: boolean
 }
 
 /**
@@ -16,46 +16,46 @@ export interface CreateRelatedOptions<S = Record<string, any>> {
 export function createRelated<
   S = Record<string, any>,
   H extends HookContext = HookContext,
->({
-  service,
-  multi = true,
-  data,
-  createItemsInDataArraySeparately = true,
-}: CreateRelatedOptions<S>) {
-  if (!service || !data) {
-    throw "initialize hook 'createRelated' completely!";
-  }
+>(options: MaybeArray<CreateRelatedOptions<S>>) {
   return async (context: H) => {
-    if (shouldSkip("createRelated", context)) {
-      return context;
+    if (shouldSkip('createRelated', context)) {
+      return context
     }
 
-    checkContext(context, "after", undefined, "createRelated");
+    checkContext(context, 'after', undefined, 'createRelated')
 
-    const { items } = getItemsIsArray(context);
+    const { items } = getItemsIsArray(context)
 
-    let dataToCreate = (
-      await Promise.all(items.map(async (item) => data(item, context)))
-    ).filter((x) => !!x);
+    const entries = Array.isArray(options) ? options : [options]
 
-    if (createItemsInDataArraySeparately) {
-      dataToCreate = dataToCreate.flat();
-    }
+    await Promise.all(
+      entries.map(async (entry) => {
+        const { data, service, createItemsInDataArraySeparately, multi } = entry
 
-    if (!dataToCreate || dataToCreate.length <= 0) {
-      return context;
-    }
+        let dataToCreate = (
+          await Promise.all(items.map(async (item) => data(item, context)))
+        ).filter((x) => !!x)
 
-    if (multi) {
-      await context.app.service(service as string).create(dataToCreate);
-    } else {
-      await Promise.all(
-        dataToCreate.map(async (item) =>
-          context.app.service(service as string).create(item),
-        ),
-      );
-    }
+        if (createItemsInDataArraySeparately) {
+          dataToCreate = dataToCreate.flat()
+        }
 
-    return context;
-  };
+        if (!dataToCreate || dataToCreate.length <= 0) {
+          return context
+        }
+
+        if (multi) {
+          await context.app.service(service as string).create(dataToCreate)
+        } else {
+          await Promise.all(
+            dataToCreate.map(async (item) =>
+              context.app.service(service as string).create(item),
+            ),
+          )
+        }
+      }),
+    )
+
+    return context
+  }
 }

package/src/hooks/forEach.ts

@@ -1,71 +1,71 @@
-import { shouldSkip } from "../utils/shouldSkip";
+import { shouldSkip } from '../utils/shouldSkip.js'
 
-import type { ReturnAsyncHook, Promisable } from "../typesInternal";
-import type { HookContext } from "@feathersjs/feathers";
-import type { GetItemsIsArrayOptions } from "../utils/getItemsIsArray";
-import { getItemsIsArray } from "../utils/getItemsIsArray";
+import type { ReturnAsyncHook, Promisable } from '../typesInternal.js'
+import type { HookContext } from '@feathersjs/feathers'
+import type { GetItemsIsArrayOptions } from '../utils/getItemsIsArray.js'
+import { getItemsIsArray } from '../utils/getItemsIsArray.js'
 
 export type HookForEachOptions<T = any, H = HookContext, R = any> = {
-  wait?: "sequential" | "parallel" | false;
-  items?: GetItemsIsArrayOptions["from"];
-  forAll?: (items: T[], context: H) => Promisable<R>;
-  skip?: (context: H) => Promisable<boolean>;
-};
+  wait?: 'sequential' | 'parallel' | false
+  items?: GetItemsIsArrayOptions['from']
+  forAll?: (items: T[], context: H) => Promisable<R>
+  skip?: (context: H) => Promisable<boolean>
+}
 
 type ActionPerItem<T, H, R> = (
   item: T,
   options: {
-    context: H;
-    i: number;
-    // eslint-disable-next-line @typescript-eslint/ban-types
+    context: H
+    i: number
+    // eslint-disable-next-line @typescript-eslint/no-empty-object-type
   } & (undefined extends R ? {} : { fromAll: R }),
-) => Promisable<any>;
+) => Promisable<any>
 
 export const forEach = <H extends HookContext = HookContext, T = any, R = any>(
   actionPerItem: ActionPerItem<T, H, R>,
   options?: HookForEachOptions<T, H, R>,
 ): ReturnAsyncHook<H> => {
-  const { wait = "parallel", items: from = "automatic" } = options || {};
+  const { wait = 'parallel', items: from = 'automatic' } = options || {}
 
   return async (context: H): Promise<H> => {
-    if (shouldSkip("forEach", context)) {
-      return context;
+    if (shouldSkip('forEach', context)) {
+      return context
     }
 
     if (options?.skip && (await options.skip(context))) {
-      return context;
+      return context
     }
 
-    const { items } = getItemsIsArray(context, { from });
+    const { items } = getItemsIsArray(context, { from })
 
     const forAll = options?.forAll
       ? await options.forAll(items, context)
-      : ({} as R);
+      : ({} as R)
 
-    const promises: Promise<any>[] = [];
+    const promises: Promise<any>[] = []
 
-    let i = 0;
+    let i = 0
 
     for (const item of items) {
       const promise = actionPerItem(item, {
         context,
         i,
         ...(forAll ? { fromAll: forAll } : {}),
-      } as any);
+      } as any)
 
-      if (wait === "sequential") {
-        await promise;
+      if (wait === 'sequential') {
+        await promise
       } else {
-        promises.push(promise);
+        promises.push(promise)
       }
 
-      i++;
+      i++
     }
 
-    if (wait === "parallel") {
-      await Promise.all(promises);
+    if (wait === 'parallel') {
+      await Promise.all(promises)
     }
 
-    return context;
-  };
-};
+    return context
+  }
+}

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

@@ -1 +1 @@
-export const FROM_CLIENT_FOR_SERVER_DEFAULT_KEY = "_$client" as const;
+export const FROM_CLIENT_FOR_SERVER_DEFAULT_KEY = '_$client' as const

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

@@ -1,2 +1,2 @@
-export * from "./paramsForServer";
-export * from "./paramsFromClient";
+export * from './paramsForServer.js'
+export * from './paramsFromClient.js'

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

@@ -1,43 +1,43 @@
-import type { HookContext } from "@feathersjs/feathers";
-import { FROM_CLIENT_FOR_SERVER_DEFAULT_KEY } from "./common";
+import type { HookContext, Params, Query } from '@feathersjs/feathers'
+import { FROM_CLIENT_FOR_SERVER_DEFAULT_KEY } from './common.js'
 
 export function defineParamsForServer(keyToHide: string) {
   return function paramsForServer(...whitelist: string[]) {
     return <H extends HookContext>(context: H) => {
       // clone params on demand
-      let clonedParams;
+      let clonedParams: (Params & { query: Query }) | undefined
 
       Object.keys(context.params).forEach((key) => {
-        if (key === "query") {
-          return;
+        if (key === 'query') {
+          return
         }
 
         if (whitelist.includes(key)) {
-          if (!clonedParams) {
-            clonedParams = {
-              ...context.params,
-              query: {
-                ...context.params.query,
-              },
-            };
+          const currentParams = clonedParams ?? {
+            ...context.params,
+            query: {
+              ...context.params.query,
+            },
           }
 
-          if (!clonedParams.query[keyToHide]) {
-            clonedParams.query[keyToHide] = {};
+          if (!currentParams.query[keyToHide]) {
+            currentParams.query[keyToHide] = {}
           }
 
-          clonedParams.query[keyToHide][key] = clonedParams[key];
-          delete clonedParams[key];
+          currentParams.query[keyToHide][key] = currentParams[key]
+          delete currentParams[key]
+
+          clonedParams = currentParams
         }
-      });
+      })
 
       if (clonedParams) {
-        context.params = clonedParams;
+        context.params = clonedParams
       }
 
-      return context;
-    };
-  };
+      return context
+    }
+  }
 }
 
 /**
@@ -48,16 +48,16 @@ export function defineParamsForServer(keyToHide: string) {
  */
 export const paramsForServer = defineParamsForServer(
   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(
       paramsForServer(
-        "a",
-        "b",
+        'a',
+        'b',
       )({
         params: {
           a: 1,
@@ -74,12 +74,12 @@ if (import.meta.vitest) {
           },
         },
       },
-    });
-  });
+    })
+  })
 
-  it("should move params to query._$client and leave remaining", () => {
+  it('should move params to query._$client and leave remaining', () => {
     expect(
-      paramsForServer("a")({
+      paramsForServer('a')({
         params: {
           a: 1,
           b: 2,
@@ -95,6 +95,6 @@ if (import.meta.vitest) {
           },
         },
       },
-    });
-  });
+    })
+  })
 }