feathers-utils 5.0.2 → 5.2.0

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

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

package/src/hooks/index.ts

@@ -6,3 +6,4 @@ export * from "./parseFields";
 export * from "./removeRelated";
 export * from "./runPerItem";
 export * from "./setData";
+export * from "./from-client-for-server";

package/src/hooks/setData.ts

@@ -76,3 +76,512 @@ export function setData<H extends HookContext = HookContext>(
     return context;
   };
 }
+
+if (import.meta.vitest) {
+  const { describe, it, assert, expect } = import.meta.vitest;
+
+  it("sets userId for single item", function () {
+    const methodsByType = {
+      before: ["create", "update", "patch", "remove"],
+      after: ["find", "get", "create", "update", "patch", "remove"],
+    };
+    Object.keys(methodsByType).forEach((type) => {
+      methodsByType[type].forEach((method) => {
+        const context = {
+          method,
+          type,
+          params: {
+            user: {
+              id: 1,
+            },
+          },
+        } as HookContext;
+
+        const dataOrResult = type === "before" ? "data" : "result";
+        context[dataOrResult] = {};
+
+        const result = setData("params.user.id", "userId")(context);
+        assert.strictEqual(
+          result[dataOrResult].userId,
+          1,
+          `'${type}/${method}': ${dataOrResult} has 'userId:1'`,
+        );
+      });
+    });
+  });
+
+  it("overwrites userId for single item", function () {
+    const methodsByType = {
+      before: ["create", "update", "patch", "remove"],
+      after: ["find", "get", "create", "update", "patch", "remove"],
+    };
+    Object.keys(methodsByType).forEach((type) => {
+      methodsByType[type].forEach((method) => {
+        const context = {
+          method,
+          type,
+          params: {
+            user: {
+              id: 1,
+            },
+          },
+        } as HookContext;
+
+        const dataOrResult = type === "before" ? "data" : "result";
+        context[dataOrResult] = { userId: 2 };
+
+        const result = setData("params.user.id", "userId")(context);
+        assert.strictEqual(
+          result[dataOrResult].userId,
+          1,
+          `'${type}/${method}': ${dataOrResult} has 'userId:1'`,
+        );
+      });
+    });
+  });
+
+  it("sets userId for multiple items", function () {
+    const methodsByType = {
+      before: ["create", "update", "patch", "remove"],
+      after: ["find", "get", "create", "update", "patch", "remove"],
+    };
+    Object.keys(methodsByType).forEach((type) => {
+      methodsByType[type].forEach((method) => {
+        const context = {
+          method,
+          type,
+          params: {
+            user: {
+              id: 1,
+            },
+          },
+        } as HookContext;
+
+        const dataOrResult = type === "before" ? "data" : "result";
+        context[dataOrResult] = [{}, {}, {}];
+
+        const result = setData("params.user.id", "userId")(context);
+        result[dataOrResult].forEach((item) => {
+          assert.strictEqual(
+            item.userId,
+            1,
+            `'${type}/${method}': ${dataOrResult} has 'userId:1'`,
+          );
+        });
+      });
+    });
+  });
+
+  it("overwrites userId for multiple items", function () {
+    const methodsByType = {
+      before: ["create", "update", "patch", "remove"],
+      after: ["find", "get", "create", "update", "patch", "remove"],
+    };
+    Object.keys(methodsByType).forEach((type) => {
+      methodsByType[type].forEach((method) => {
+        const context = {
+          method,
+          type,
+          params: {
+            user: {
+              id: 1,
+            },
+          },
+        } as HookContext;
+
+        const dataOrResult = type === "before" ? "data" : "result";
+        context[dataOrResult] = [{ userId: 2 }, {}, { userId: "abc" }];
+
+        const result = setData("params.user.id", "userId")(context);
+        result[dataOrResult].forEach((item) => {
+          assert.strictEqual(
+            item.userId,
+            1,
+            `'${type}/${method}': ${dataOrResult} has 'userId:1'`,
+          );
+        });
+      });
+    });
+  });
+
+  it("does not change createdById if 'params.user.id' is not provided", function () {
+    const methodsByType = {
+      before: ["create", "update", "patch", "remove"],
+      after: ["find", "get", "create", "update", "patch", "remove"],
+    };
+    Object.keys(methodsByType).forEach((type) => {
+      methodsByType[type].forEach((method) => {
+        const context = {
+          method,
+          type,
+          params: {},
+        } as HookContext;
+
+        const dataOrResult = type === "before" ? "data" : "result";
+        context[dataOrResult] = { userId: 2 };
+
+        const result = setData("params.user.id", "userId")(context);
+
+        assert.strictEqual(
+          result[dataOrResult].userId,
+          2,
+          `'${type}/${method}': ${dataOrResult} has 'userId:2'`,
+        );
+      });
+    });
+  });
+
+  it("throws if 'external' is set and context.user.id is undefined", function () {
+    const methodsByType = {
+      before: ["create", "update", "patch", "remove"],
+      after: ["find", "get", "create", "update", "patch", "remove"],
+    };
+    Object.keys(methodsByType).forEach((type) => {
+      methodsByType[type].forEach((method) => {
+        const context = {
+          method,
+          type,
+          params: {
+            provider: "socket.io",
+          },
+        } as HookContext;
+
+        const dataOrResult = type === "before" ? "data" : "result";
+        context[dataOrResult] = {};
+
+        expect(() => setData("params.user.id", "userId")(context)).toThrow(
+          Forbidden,
+        );
+      });
+    });
+  });
+
+  it("passes if 'external' and 'allowUndefined: true'", function () {
+    const methodsByType = {
+      before: ["create", "update", "patch", "remove"],
+      after: ["find", "get", "create", "update", "patch", "remove"],
+    };
+    Object.keys(methodsByType).forEach((type) => {
+      methodsByType[type].forEach((method) => {
+        const context = {
+          method,
+          type,
+          provider: "socket.io",
+          params: {},
+          data: {},
+        } as unknown as HookContext;
+
+        assert.doesNotThrow(
+          () =>
+            setData("params.user.id", "userId", { allowUndefined: true })(
+              context,
+            ),
+          `'${type}/${method}': passes`,
+        );
+      });
+    });
+  });
+
+  it("passes if 'external' is set and context.user.id is undefined but overwrite: false", function () {
+    const methodsByType = {
+      before: ["create", "update", "patch", "remove"],
+      after: ["find", "get", "create", "update", "patch", "remove"],
+    };
+    Object.keys(methodsByType).forEach((type) => {
+      methodsByType[type].forEach((method) => {
+        const context = {
+          method,
+          type,
+          params: {
+            provider: "socket.io",
+          },
+        } as unknown as HookContext;
+
+        const dataOrResult = type === "before" ? "data" : "result";
+        context[dataOrResult] = { userId: 1 };
+
+        assert.doesNotThrow(
+          () =>
+            setData("params.user.id", "userId", { overwrite: false })(context),
+          `'${type}/${method}': passes`,
+        );
+      });
+    });
+  });
+
+  describe("overwrite: false", function () {
+    it("sets userId for single item", function () {
+      const methodsByType = {
+        before: ["create", "update", "patch", "remove"],
+        after: ["find", "get", "create", "update", "patch", "remove"],
+      };
+      Object.keys(methodsByType).forEach((type) => {
+        methodsByType[type].forEach((method) => {
+          const context = {
+            method,
+            type,
+            params: {
+              user: {
+                id: 1,
+              },
+            },
+          } as unknown as HookContext;
+
+          const dataOrResult = type === "before" ? "data" : "result";
+          context[dataOrResult] = {};
+
+          const result = setData("params.user.id", "userId", {
+            overwrite: false,
+          })(context);
+          assert.strictEqual(
+            result[dataOrResult].userId,
+            1,
+            `'${type}/${method}': ${dataOrResult} has 'userId:1'`,
+          );
+        });
+      });
+    });
+
+    it("does not overwrite userId for single item", function () {
+      const methodsByType = {
+        before: ["create", "update", "patch", "remove"],
+        after: ["find", "get", "create", "update", "patch", "remove"],
+      };
+      Object.keys(methodsByType).forEach((type) => {
+        methodsByType[type].forEach((method) => {
+          const context = {
+            method,
+            type,
+            params: {
+              user: {
+                id: 1,
+              },
+            },
+          } as unknown as HookContext;
+
+          const dataOrResult = type === "before" ? "data" : "result";
+          context[dataOrResult] = { userId: 2 };
+
+          const result = setData("params.user.id", "userId", {
+            overwrite: false,
+          })(context);
+          assert.strictEqual(
+            result[dataOrResult].userId,
+            2,
+            `'${type}/${method}': ${dataOrResult} has 'userId:2'`,
+          );
+        });
+      });
+    });
+
+    it("sets userId for multiple items", function () {
+      const methodsByType = {
+        before: ["create", "update", "patch", "remove"],
+        after: ["find", "get", "create", "update", "patch", "remove"],
+      };
+      Object.keys(methodsByType).forEach((type) => {
+        methodsByType[type].forEach((method) => {
+          const context = {
+            method,
+            type,
+            params: {
+              user: {
+                id: 1,
+              },
+            },
+          } as unknown as HookContext;
+
+          const dataOrResult = type === "before" ? "data" : "result";
+          context[dataOrResult] = [{}, {}, {}];
+
+          const result = setData("params.user.id", "userId", {
+            overwrite: false,
+          })(context);
+          result[dataOrResult].forEach((item) => {
+            assert.strictEqual(
+              item.userId,
+              1,
+              `${type}/${method}': ${dataOrResult} has 'userId:1'`,
+            );
+          });
+        });
+      });
+    });
+
+    it("overwrites userId for multiple items", function () {
+      const methodsByType = {
+        before: ["create", "update", "patch", "remove"],
+        after: ["find", "get", "create", "update", "patch", "remove"],
+      };
+      Object.keys(methodsByType).forEach((type) => {
+        methodsByType[type].forEach((method) => {
+          const context = {
+            method,
+            type,
+            params: {
+              user: {
+                id: 1,
+              },
+            },
+          } as unknown as HookContext;
+
+          const dataOrResult = type === "before" ? "data" : "result";
+          context[dataOrResult] = [{ userId: 0 }, {}, { userId: 2 }];
+
+          const result = setData("params.user.id", "userId", {
+            overwrite: false,
+          })(context);
+          result[dataOrResult].forEach((item, i) => {
+            assert.strictEqual(
+              item.userId,
+              i,
+              `${type}/${method}': ${dataOrResult} has 'userId:${i}`,
+            );
+          });
+        });
+      });
+    });
+  });
+
+  describe("overwrite: predicate", function () {
+    it("overwrites userId for multiple items per predicate", function () {
+      const methodsByType = {
+        before: ["create", "update", "patch", "remove"],
+        after: ["find", "get", "create", "update", "patch", "remove"],
+      };
+      Object.keys(methodsByType).forEach((type) => {
+        methodsByType[type].forEach((method) => {
+          const context = {
+            method,
+            type,
+            params: {
+              user: {
+                id: 1,
+              },
+            },
+          } as unknown as HookContext;
+
+          const dataOrResult = type === "before" ? "data" : "result";
+          context[dataOrResult] = [{ userId: 2 }, {}, { userId: "abc" }];
+
+          const result = setData("params.user.id", "userId", {
+            overwrite: () => true,
+          })(context);
+          result[dataOrResult].forEach((item) => {
+            assert.strictEqual(
+              item.userId,
+              1,
+              `'${type}/${method}': ${dataOrResult} has 'userId:1'`,
+            );
+          });
+        });
+      });
+    });
+
+    it("does not overwrite userId for single item by predicate", function () {
+      const methodsByType = {
+        before: ["create", "update", "patch", "remove"],
+        after: ["find", "get", "create", "update", "patch", "remove"],
+      };
+      Object.keys(methodsByType).forEach((type) => {
+        methodsByType[type].forEach((method) => {
+          const context = {
+            method,
+            type,
+            params: {
+              user: {
+                id: 1,
+              },
+            },
+          } as unknown as HookContext;
+
+          const dataOrResult = type === "before" ? "data" : "result";
+          context[dataOrResult] = { userId: 2 };
+
+          const result = setData("params.user.id", "userId", {
+            overwrite: (item) => item.userId == null,
+          })(context);
+          assert.strictEqual(
+            result[dataOrResult].userId,
+            2,
+            `'${type}/${method}': ${dataOrResult} has 'userId:2'`,
+          );
+        });
+      });
+    });
+
+    it("predicate based on context", function () {
+      const methodsByType = {
+        before: ["create", "update", "patch", "remove"],
+        after: ["find", "get", "create", "update", "patch", "remove"],
+      };
+      Object.keys(methodsByType).forEach((type) => {
+        methodsByType[type].forEach((method) => {
+          const context = {
+            method,
+            type,
+            params: {
+              user: {
+                id: 1,
+              },
+            },
+          } as unknown as HookContext;
+
+          const dataOrResult = type === "before" ? "data" : "result";
+          context[dataOrResult] = { userId: 2 };
+
+          const result = setData("params.user.id", "userId", {
+            overwrite: (item, context) => context.type === "before",
+          })(context);
+          if (type === "before") {
+            assert.strictEqual(
+              result[dataOrResult].userId,
+              1,
+              `'${type}/${method}': ${dataOrResult} has 'userId:1'`,
+            );
+          } else {
+            assert.strictEqual(
+              result[dataOrResult].userId,
+              2,
+              `'${type}/${method}': ${dataOrResult} has 'userId:2'`,
+            );
+          }
+        });
+      });
+    });
+
+    it("overwrites userId for multiple items by predicate", function () {
+      const methodsByType = {
+        before: ["create", "update", "patch", "remove"],
+        after: ["find", "get", "create", "update", "patch", "remove"],
+      };
+      Object.keys(methodsByType).forEach((type) => {
+        methodsByType[type].forEach((method) => {
+          const context = {
+            method,
+            type,
+            params: {
+              user: {
+                id: 1,
+              },
+            },
+          } as unknown as HookContext;
+
+          const dataOrResult = type === "before" ? "data" : "result";
+          context[dataOrResult] = [{ userId: 0 }, {}, { userId: 2 }];
+
+          const result = setData("params.user.id", "userId", {
+            overwrite: (item) => item.userId == null,
+          })(context);
+          result[dataOrResult].forEach((item, i) => {
+            assert.strictEqual(
+              item.userId,
+              i,
+              `${type}/${method}': ${dataOrResult} has 'userId:${i}`,
+            );
+          });
+        });
+      });
+    });
+  });
+}

package/src/mixins/debounce-mixin/DebouncedStore.ts

@@ -3,15 +3,7 @@ import _debounce from "lodash/debounce.js";
 import type { DebouncedFunc } from "lodash";
 import type { Application, Id } from "@feathersjs/feathers";
 import type { DebouncedFunctionApp, DebouncedStoreOptions } from "./types";
-
-export const makeDefaultOptions = (): DebouncedStoreOptions => {
-  return {
-    leading: false,
-    maxWait: undefined,
-    trailing: true,
-    wait: 100,
-  };
-};
+import { makeDefaultOptions } from "./utils";
 
 export type DebouncedService<T = any> = T & {
   debouncedStore: DebouncedStore;

package/src/mixins/debounce-mixin/debounceMixin.ts

@@ -1,6 +1,7 @@
 import type { Application } from "@feathersjs/feathers/lib";
-import { DebouncedStore, makeDefaultOptions } from "./DebouncedStore";
+import { DebouncedStore } from "./DebouncedStore";
 import type { DebouncedStoreOptions, InitDebounceMixinOptions } from "./types";
+import { makeDefaultOptions } from "./utils";
 
 export function debounceMixin(
   options?: Partial<InitDebounceMixinOptions>,

package/src/mixins/debounce-mixin/utils.ts

@@ -0,0 +1,10 @@
+import type { DebouncedStoreOptions } from "./types";
+
+export const makeDefaultOptions = (): DebouncedStoreOptions => {
+  return {
+    leading: false,
+    maxWait: undefined,
+    trailing: true,
+    wait: 100,
+  };
+};

package/src/types.ts

@@ -2,6 +2,7 @@ import type { HookContext } from "@feathersjs/feathers";
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export type Predicate<T = any> = (item: T) => boolean;
+
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export type PredicateWithContext<T = any> = (
   item: T,

package/src/utils/_utils.internal.ts

@@ -0,0 +1,16 @@
+export const hasOwnProperty = (
+  obj: Record<string, unknown>,
+  ...keys: string[]
+): boolean => {
+  return keys.some((x) => Object.prototype.hasOwnProperty.call(obj, x));
+};
+
+export const isObject = (item: unknown): boolean =>
+  !!item && typeof item === "object" && !Array.isArray(item);
+
+export const isPlainObject = (value: unknown): boolean =>
+  isObject(value) && value.constructor === {}.constructor;
+
+export const isEmpty = (obj: unknown): boolean =>
+  [Object, Array].includes((obj || {}).constructor as any) &&
+  !Object.keys(obj || {}).length;