feathers-utils 5.1.0 → 6.0.0

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

@@ -22,3 +22,5 @@ export type ReturnSyncHook<H extends HookContext = HookContext> = (
 export type ReturnAsyncHook<H extends HookContext = HookContext> = (
   context: H,
 ) => Promise<H>;
+
+export type KeyOf<T> = Extract<keyof T, string>;

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;

package/src/utils/deflattenQuery.ts

@@ -0,0 +1,109 @@
+import type { Query } from "@feathersjs/feathers";
+import _set from "lodash/set.js";
+import { isObject } from "./_utils.internal";
+
+export function deflattenQuery(query: Query) {
+  const result: Query = {};
+
+  Object.keys(query).forEach((key) => {
+    const value = query[key];
+
+    if (Array.isArray(value)) {
+      _set(result, key, value.map(deflattenQuery));
+      return;
+    }
+
+    if (isObject(value)) {
+      _set(result, key, deflattenQuery(value));
+      return;
+    }
+
+    _set(result, key, query[key]);
+  });
+
+  return result;
+}
+
+if (import.meta.vitest) {
+  const { describe, it, expect } = import.meta.vitest;
+
+  describe("deflattenQuery", () => {
+    it("should deflatten a query", () => {
+      expect(
+        deflattenQuery({
+          a: 1,
+          "b.c": 1,
+          "b.d": 1,
+          "e.f.g": 1,
+        }),
+      ).toEqual({
+        a: 1,
+        b: {
+          c: 1,
+          d: 1,
+        },
+        e: {
+          f: {
+            g: 1,
+          },
+        },
+      });
+    });
+  });
+
+  it("should handle operators", () => {
+    expect(
+      deflattenQuery({
+        "a.b": 1,
+        c: {
+          $gt: 1,
+          $lte: 1,
+        },
+      }),
+    ).toEqual({
+      a: {
+        b: 1,
+      },
+      c: {
+        $gt: 1,
+        $lte: 1,
+      },
+    });
+  });
+
+  it("should handle $or / $and", () => {
+    expect(
+      deflattenQuery({
+        "a.b": 1,
+        $and: [
+          {
+            "c.d": 1,
+          },
+        ],
+        $or: [
+          {
+            "e.f": 1,
+          },
+        ],
+      }),
+    ).toEqual({
+      a: {
+        b: 1,
+      },
+      $and: [
+        {
+          c: {
+            d: 1,
+          },
+        },
+      ],
+      $or: [
+        {
+          e: {
+            f: 1,
+          },
+        },
+      ],
+    });
+  });
+}