feathers-utils 5.1.0 → 6.0.0

package/src/utils/optimizeBatchPatch.ts

@@ -1,8 +1,10 @@
 import type { Id, Params } from "@feathersjs/feathers";
 import { deepEqual } from "fast-equals";
+import type { KeyOf } from "../typesInternal";
 
-export type OptimizeBatchPatchOptions = {
-  id?: string;
+export type OptimizeBatchPatchOptions<IdKey extends string> = {
+  /** the key of the id property */
+  id?: IdKey;
 };
 
 export type OptimizeBatchPatchResultItem<
@@ -11,18 +13,26 @@ export type OptimizeBatchPatchResultItem<
 > = [Id, T, P | undefined];
 
 export function optimizeBatchPatch<
-  T extends Record<string, unknown>,
+  T extends Record<string, any>,
+  IdKey extends KeyOf<T>,
   P extends Params,
+  R extends Omit<T, IdKey> = Omit<T, IdKey>,
 >(
-  items: Map<Id, T>,
-  options?: OptimizeBatchPatchOptions,
-): OptimizeBatchPatchResultItem<T, P>[] {
-  const map: { ids: Id[]; data: T }[] = [];
+  items: T[],
+  options?: OptimizeBatchPatchOptions<IdKey>,
+): OptimizeBatchPatchResultItem<R, P>[] {
+  const map: { ids: Id[]; data: R }[] = [];
 
-  const id = options?.id ?? "id";
+  const idKey = options?.id ?? "id";
 
-  for (const [id, data] of items) {
-    const index = map.findIndex((item) => deepEqual(item.data, data));
+  for (const _data of items) {
+    const data = _data as unknown as R;
+    const id = _data[idKey];
+    delete data[idKey as any];
+
+    const index = map.findIndex((item) => {
+      return deepEqual(item.data, data);
+    });
 
     if (index === -1) {
       map.push({ ids: [id], data });
@@ -33,34 +43,56 @@ export function optimizeBatchPatch<
 
   return map.map(({ ids, data }) => {
     return ids.length === 1
-      ? ([ids[0], data, undefined] as OptimizeBatchPatchResultItem<T, P>)
+      ? ([ids[0], data, undefined] as OptimizeBatchPatchResultItem<R, P>)
       : ([
           null,
           data,
           {
             query: {
-              [id]: { $in: ids },
+              [idKey]: { $in: ids },
             },
           },
-        ] as OptimizeBatchPatchResultItem<T, P>);
+        ] as OptimizeBatchPatchResultItem<R, P>);
   });
 }
 
 if (import.meta.vitest) {
   const { it, expect } = import.meta.vitest;
   it("optimizeBatchPatch", () => {
-    const items = new Map<Id, Record<string, unknown>>([
-      ["1", { name: "John" }],
-      ["2", { name: "Jane" }],
-      ["3", { name: "John" }],
-      ["4", { name: "Jane" }],
-      [5, { name: "Jack" }],
-    ]);
-
-    expect(optimizeBatchPatch(items)).toEqual([
+    expect(
+      optimizeBatchPatch(
+        [
+          { id: "1", name: "John" },
+          { id: "2", name: "Jane" },
+          { id: "3", name: "John" },
+          { id: "4", name: "Jane" },
+          { id: 5, name: "Jack" },
+        ],
+        { id: "id" },
+      ),
+    ).toEqual([
       [null, { name: "John" }, { query: { id: { $in: ["1", "3"] } } }],
       [null, { name: "Jane" }, { query: { id: { $in: ["2", "4"] } } }],
       [5, { name: "Jack" }, undefined],
     ]);
   });
+
+  it("optimizeBatchPatch with _id", () => {
+    expect(
+      optimizeBatchPatch(
+        [
+          { _id: "1", name: "John" },
+          { _id: "2", name: "Jane" },
+          { _id: "3", name: "John" },
+          { _id: "4", name: "Jane" },
+          { _id: 5, name: "Jack" },
+        ],
+        { id: "_id" },
+      ),
+    ).toEqual([
+      [null, { name: "John" }, { query: { _id: { $in: ["1", "3"] } } }],
+      [null, { name: "Jane" }, { query: { _id: { $in: ["2", "4"] } } }],
+      [5, { name: "Jack" }, undefined],
+    ]);
+  });
 }

package/src/utils/pushSet.ts

@@ -1,4 +1,4 @@
-import _isEqual from "lodash/isEqual.js";
+import { deepEqual as _isEqual } from "fast-equals";
 import _get from "lodash/get.js";
 import _set from "lodash/set.js";
 import type { Path } from "../typesInternal";
@@ -30,3 +30,69 @@ export const pushSet = (
     return arr;
   }
 };
+
+if (import.meta.vitest) {
+  const { describe, it, assert } = import.meta.vitest;
+
+  it("pushes to existing array", function () {
+    const obj = {
+      arr: [1],
+    };
+    pushSet(obj, ["arr"], 2);
+    assert.deepStrictEqual(obj, { arr: [1, 2] });
+  });
+
+  it("sets array for not existing", function () {
+    const obj = {};
+    pushSet(obj, ["arr"], 2);
+    assert.deepStrictEqual(obj, { arr: [2] });
+  });
+
+  it("adds existing element", function () {
+    const obj = {
+      arr: [1],
+    };
+    pushSet(obj, ["arr"], 1);
+    assert.deepStrictEqual(obj, { arr: [1, 1] });
+  });
+
+  it("skips existing element", function () {
+    const obj = {
+      arr: [1],
+    };
+    pushSet(obj, ["arr"], 1, { unique: true });
+    assert.deepStrictEqual(obj, { arr: [1] });
+  });
+
+  describe("deep dot notation", function () {
+    it("deep: pushes to existing array", function () {
+      const obj = {
+        nested: { deep: [{ arr: [1] }] },
+      };
+      pushSet(obj, ["nested", "deep", 0, "arr"], 2);
+      assert.deepStrictEqual(obj, { nested: { deep: [{ arr: [1, 2] }] } });
+    });
+
+    it("deep: sets array for not existing", function () {
+      const obj = {};
+      pushSet(obj, ["nested", "deep", 0, "arr"], 2);
+      assert.deepStrictEqual(obj, { nested: { deep: [{ arr: [2] }] } });
+    });
+
+    it("deep: adds existing element", function () {
+      const obj = {
+        nested: { deep: [{ arr: [1] }] },
+      };
+      pushSet(obj, ["nested", "deep", 0, "arr"], 1);
+      assert.deepStrictEqual(obj, { nested: { deep: [{ arr: [1, 1] }] } });
+    });
+
+    it("deep: skips existing element", function () {
+      const obj = {
+        nested: { deep: [{ arr: [1] }] },
+      };
+      pushSet(obj, ["nested", "deep", 0, "arr"], 1, { unique: true });
+      assert.deepStrictEqual(obj, { nested: { deep: [{ arr: [1] }] } });
+    });
+  });
+}

package/src/utils/setQueryKeySafely.ts

@@ -1,17 +1,17 @@
-import { isPlainObject } from "./internal.utils";
+import { isPlainObject } from "./_utils.internal";
 import type { Params } from "@feathersjs/feathers";
 
 export type SetQueryKeySafelyOptions = {
   mutate?: boolean;
 };
 
-export const setQueryKeySafely = <P extends Params = Params>(
-  params: P,
+export const setQueryKeySafely = (
+  params: Params,
   key: string,
   value: any,
   operator = "$eq",
   options?: SetQueryKeySafelyOptions,
-): P => {
+): Params => {
   const { mutate = false } = options || {};
 
   // TODO: mutate params
@@ -54,3 +54,168 @@ export const setQueryKeySafely = <P extends Params = Params>(
 
   return params;
 };
+
+if (import.meta.vitest) {
+  const { it, assert } = import.meta.vitest;
+
+  it("does not mutate by default", function () {
+    const params: Params = {
+      query: {
+        test: true,
+      },
+    };
+
+    const result = setQueryKeySafely(params, "test", false);
+    assert.deepStrictEqual(params, {
+      query: {
+        test: true,
+      },
+    });
+
+    assert.deepStrictEqual(result, {
+      query: {
+        test: true,
+        $and: [{ test: false }],
+      },
+    });
+  });
+
+  it("does not mutate explicitely", function () {
+    const params: Params = {
+      query: {
+        test: true,
+      },
+    };
+
+    const result = setQueryKeySafely(params, "test", false, "$eq", {
+      mutate: false,
+    });
+
+    assert.deepStrictEqual(params, {
+      query: {
+        test: true,
+      },
+    });
+
+    assert.deepStrictEqual(result, {
+      query: {
+        test: true,
+        $and: [{ test: false }],
+      },
+    });
+  });
+
+  it("does mutate explicitely", function () {
+    const params: Params = {
+      query: {
+        test: true,
+      },
+    };
+
+    const result = setQueryKeySafely(params, "test", false, "$eq", {
+      mutate: true,
+    });
+
+    assert.equal(params, result);
+  });
+
+  it("adds a $eq filter for non existent key", function () {
+    const params: Params = {
+      query: {},
+    };
+
+    const result = setQueryKeySafely(params, "test", true);
+    assert.deepStrictEqual(result, {
+      query: {
+        test: true,
+      },
+    });
+  });
+
+  it("adds a $ne filter for non existent key", function () {
+    const params = {
+      query: {},
+    };
+
+    const result = setQueryKeySafely(params, "test", true, "$ne");
+    assert.deepStrictEqual(result, {
+      query: {
+        test: {
+          $ne: true,
+        },
+      },
+    });
+  });
+
+  it("adds a $eq filter for existing key", function () {
+    const params: Params = {
+      query: {
+        test: true,
+      },
+    };
+
+    const result = setQueryKeySafely(params, "test", false);
+    assert.deepStrictEqual(result, {
+      query: {
+        test: true,
+        $and: [{ test: false }],
+      },
+    });
+  });
+
+  it("adds a $in filter for existing key with value", function () {
+    const params: Params = {
+      query: {
+        test: true,
+      },
+    };
+
+    const result = setQueryKeySafely(params, "test", [true], "$in");
+    assert.deepStrictEqual(result, {
+      query: {
+        test: true,
+        $and: [{ test: { $in: [true] } }],
+      },
+    });
+  });
+
+  it("adds a $in filter for existing key with object", function () {
+    const params: Params = {
+      query: {
+        test: {
+          $eq: true,
+        },
+      },
+    };
+
+    const result = setQueryKeySafely(params, "test", [true], "$in");
+    assert.deepStrictEqual(result, {
+      query: {
+        test: {
+          $eq: true,
+          $in: [true],
+        },
+      },
+    });
+  });
+
+  it("adds a $in filter for existing $in", function () {
+    const params: Params = {
+      query: {
+        test: {
+          $in: [true],
+        },
+      },
+    };
+
+    const result = setQueryKeySafely(params, "test", [false], "$in");
+    assert.deepStrictEqual(result, {
+      query: {
+        test: {
+          $in: [true],
+        },
+        $and: [{ test: { $in: [false] } }],
+      },
+    });
+  });
+}

package/src/utils/setResultEmpty.ts

@@ -31,3 +31,263 @@ export const setResultEmpty = <H extends HookContext = HookContext>(
 
   return context;
 };
+
+if (import.meta.vitest) {
+  const { it, assert } = import.meta.vitest;
+
+  const paginatedService = {
+    options: {
+      paginate: {
+        default: 10,
+        max: 50,
+      },
+    },
+  };
+
+  const nonPaginatedService = {
+    options: {
+      paginate: false,
+    },
+  };
+
+  const paramsEmpty = {};
+  const paramsPaginateFalse = { paginate: false };
+  const paramsPaginate = { paginate: { default: 10, max: 50 } };
+  const paramsAdapterPaginate = {
+    adapter: { paginate: { default: 10, max: 50 } },
+  };
+
+  it("does not overwrite result", function () {
+    ["find", "get", "create", "update", "patch", "remove"].forEach((method) => {
+      ["before", "after"].forEach((type) => {
+        [paginatedService, nonPaginatedService].forEach((service) => {
+          [paramsPaginateFalse, paramsAdapterPaginate].forEach((params) => {
+            const context = setResultEmpty({
+              method,
+              type,
+              service,
+              params,
+              result: 123,
+            } as any as HookContext);
+
+            assert.deepStrictEqual(
+              context.result,
+              123,
+              `result is not changed. '${type}:${method}': '${service}' - '${params}'`,
+            );
+          });
+        });
+      });
+    });
+  });
+
+  describe("find", function () {
+    it("sets paginated result", function () {
+      const combos = [
+        { service: paginatedService, params: paramsEmpty },
+        { service: paginatedService, params: paramsAdapterPaginate },
+        { service: nonPaginatedService, params: paramsPaginate },
+        { service: nonPaginatedService, params: paramsAdapterPaginate },
+      ];
+
+      combos.forEach(({ service, params }, i) => {
+        const { result } = setResultEmpty({
+          service,
+          params,
+          method: "find",
+        } as any as HookContext);
+        assert.deepStrictEqual(
+          result,
+          { total: 0, skip: 0, limit: 0, data: [] },
+          `'${i}': result is paginated empty`,
+        );
+      });
+    });
+
+    it("sets empty array", function () {
+      const combos = [
+        { service: paginatedService, params: paramsPaginateFalse },
+        { service: nonPaginatedService, params: paramsEmpty },
+      ];
+
+      combos.forEach(({ service, params }, i) => {
+        const { result } = setResultEmpty({
+          service,
+          params,
+          method: "find",
+        } as any as HookContext);
+        assert.deepStrictEqual(result, [], `'${i}': result is empty array`);
+      });
+    });
+  });
+
+  describe("get", function () {
+    it("sets result to null", function () {
+      const combos = [
+        { service: paginatedService, params: paramsEmpty },
+        { service: paginatedService, params: paramsAdapterPaginate },
+        { service: paginatedService, params: paramsPaginateFalse },
+        { service: nonPaginatedService, params: paramsPaginate },
+        { service: nonPaginatedService, params: paramsAdapterPaginate },
+      ];
+
+      combos.forEach(({ service, params }, i) => {
+        const { result } = setResultEmpty({
+          service,
+          params,
+          method: "get",
+        } as any as HookContext);
+        assert.deepStrictEqual(result, null, `'${i}': result is null`);
+      });
+    });
+  });
+
+  describe("create", function () {
+    it("sets result to null for single data", function () {
+      const combos = [
+        { service: paginatedService, params: paramsEmpty },
+        { service: paginatedService, params: paramsAdapterPaginate },
+        { service: paginatedService, params: paramsPaginateFalse },
+        { service: nonPaginatedService, params: paramsPaginate },
+        { service: nonPaginatedService, params: paramsAdapterPaginate },
+      ];
+
+      combos.forEach(({ service, params }, i) => {
+        const { result } = setResultEmpty({
+          service,
+          params,
+          method: "create",
+          data: { id: 1 },
+        } as any as HookContext);
+        assert.deepStrictEqual(result, null, `'${i}': result is null`);
+      });
+    });
+
+    it("sets result to empty array for array data", function () {
+      const combos = [
+        { service: paginatedService, params: paramsEmpty },
+        { service: paginatedService, params: paramsAdapterPaginate },
+        { service: paginatedService, params: paramsPaginateFalse },
+        { service: nonPaginatedService, params: paramsPaginate },
+        { service: nonPaginatedService, params: paramsAdapterPaginate },
+      ];
+
+      combos.forEach(({ service, params }, i) => {
+        const { result } = setResultEmpty({
+          service,
+          params,
+          method: "create",
+          data: [{ id: 1 }],
+          type: "before",
+        } as any as HookContext);
+        assert.deepStrictEqual(result, [], `'${i}': result is empty array`);
+      });
+    });
+  });
+
+  describe("update", function () {
+    it("sets result to null", function () {
+      const combos = [
+        { service: paginatedService, params: paramsEmpty },
+        { service: paginatedService, params: paramsAdapterPaginate },
+        { service: paginatedService, params: paramsPaginateFalse },
+        { service: nonPaginatedService, params: paramsPaginate },
+        { service: nonPaginatedService, params: paramsAdapterPaginate },
+      ];
+
+      combos.forEach(({ service, params }, i) => {
+        const { result } = setResultEmpty({
+          service,
+          params,
+          method: "update",
+          id: 1,
+        } as any as HookContext);
+        assert.deepStrictEqual(result, null, `'${i}': result is null`);
+      });
+    });
+  });
+
+  describe("patch", function () {
+    it("sets result to null for id: 1", function () {
+      const combos = [
+        { service: paginatedService, params: paramsEmpty },
+        { service: paginatedService, params: paramsAdapterPaginate },
+        { service: paginatedService, params: paramsPaginateFalse },
+        { service: nonPaginatedService, params: paramsPaginate },
+        { service: nonPaginatedService, params: paramsAdapterPaginate },
+      ];
+
+      combos.forEach(({ service, params }, i) => {
+        const { result } = setResultEmpty({
+          service,
+          params,
+          method: "patch",
+          id: 1,
+        } as any as HookContext);
+        assert.deepStrictEqual(result, null, `'${i}': result is null`);
+      });
+    });
+
+    it("sets result to empty array for id: null", function () {
+      const combos = [
+        { service: paginatedService, params: paramsEmpty },
+        { service: paginatedService, params: paramsAdapterPaginate },
+        { service: paginatedService, params: paramsPaginateFalse },
+        { service: nonPaginatedService, params: paramsPaginate },
+        { service: nonPaginatedService, params: paramsAdapterPaginate },
+      ];
+
+      combos.forEach(({ service, params }, i) => {
+        const { result } = setResultEmpty({
+          service,
+          params,
+          method: "patch",
+          id: null,
+        } as any as HookContext);
+        assert.deepStrictEqual(result, [], `'${i}': result is empty array`);
+      });
+    });
+  });
+
+  describe("remove", function () {
+    it("sets result to null for id: 1", function () {
+      const combos = [
+        { service: paginatedService, params: paramsEmpty },
+        { service: paginatedService, params: paramsAdapterPaginate },
+        { service: paginatedService, params: paramsPaginateFalse },
+        { service: nonPaginatedService, params: paramsPaginate },
+        { service: nonPaginatedService, params: paramsAdapterPaginate },
+      ];
+
+      combos.forEach(({ service, params }, i) => {
+        const { result } = setResultEmpty({
+          service,
+          params,
+          method: "remove",
+          id: 1,
+        } as any as HookContext);
+        assert.deepStrictEqual(result, null, `'${i}': result is null`);
+      });
+    });
+
+    it("sets result to empty array for id: null", function () {
+      const combos = [
+        { service: paginatedService, params: paramsEmpty },
+        { service: paginatedService, params: paramsAdapterPaginate },
+        { service: paginatedService, params: paramsPaginateFalse },
+        { service: nonPaginatedService, params: paramsPaginate },
+        { service: nonPaginatedService, params: paramsAdapterPaginate },
+      ];
+
+      combos.forEach(({ service, params }, i) => {
+        const { result } = setResultEmpty({
+          service,
+          params,
+          method: "remove",
+          id: null,
+        } as any as HookContext);
+        assert.deepStrictEqual(result, [], `'${i}': result is empty array`);
+      });
+    });
+  });
+}