feathers-utils 6.0.0 → 7.0.1

package/src/utils/optimizeBatchPatch.ts

@@ -1,16 +1,16 @@
-import type { Id, Params } from "@feathersjs/feathers";
-import { deepEqual } from "fast-equals";
-import type { KeyOf } from "../typesInternal";
+import type { Id, Params } from '@feathersjs/feathers'
+import { deepEqual } from 'fast-equals'
+import type { KeyOf } from '../typesInternal.js'
 
 export type OptimizeBatchPatchOptions<IdKey extends string> = {
   /** the key of the id property */
-  id?: IdKey;
-};
+  id?: IdKey
+}
 
 export type OptimizeBatchPatchResultItem<
   T = Record<string, unknown>,
   P = Params,
-> = [Id, T, P | undefined];
+> = [Id | null, T, P | undefined]
 
 export function optimizeBatchPatch<
   T extends Record<string, any>,
@@ -21,23 +21,23 @@ export function optimizeBatchPatch<
   items: T[],
   options?: OptimizeBatchPatchOptions<IdKey>,
 ): OptimizeBatchPatchResultItem<R, P>[] {
-  const map: { ids: Id[]; data: R }[] = [];
+  const map: { ids: Id[]; data: R }[] = []
 
-  const idKey = options?.id ?? "id";
+  const idKey = options?.id ?? 'id'
 
   for (const _data of items) {
-    const data = _data as unknown as R;
-    const id = _data[idKey];
-    delete data[idKey as any];
+    const data = _data as unknown as R
+    const id = _data[idKey]
+    delete (data as any)[idKey as any]
 
     const index = map.findIndex((item) => {
-      return deepEqual(item.data, data);
-    });
+      return deepEqual(item.data, data)
+    })
 
     if (index === -1) {
-      map.push({ ids: [id], data });
+      map.push({ ids: [id], data })
     } else {
-      map[index].ids.push(id);
+      map[index].ids.push(id)
     }
   }
 
@@ -52,47 +52,47 @@ export function optimizeBatchPatch<
               [idKey]: { $in: ids },
             },
           },
-        ] as OptimizeBatchPatchResultItem<R, P>);
-  });
+        ] as OptimizeBatchPatchResultItem<R, P>)
+  })
 }
 
 if (import.meta.vitest) {
-  const { it, expect } = import.meta.vitest;
-  it("optimizeBatchPatch", () => {
+  const { it, expect } = import.meta.vitest
+  it('optimizeBatchPatch', () => {
     expect(
       optimizeBatchPatch(
         [
-          { id: "1", name: "John" },
-          { id: "2", name: "Jane" },
-          { id: "3", name: "John" },
-          { id: "4", name: "Jane" },
-          { id: 5, name: "Jack" },
+          { id: '1', name: 'John' },
+          { id: '2', name: 'Jane' },
+          { id: '3', name: 'John' },
+          { id: '4', name: 'Jane' },
+          { id: 5, name: 'Jack' },
         ],
-        { id: "id" },
+        { id: 'id' },
       ),
     ).toEqual([
-      [null, { name: "John" }, { query: { id: { $in: ["1", "3"] } } }],
-      [null, { name: "Jane" }, { query: { id: { $in: ["2", "4"] } } }],
-      [5, { name: "Jack" }, undefined],
-    ]);
-  });
+      [null, { name: 'John' }, { query: { id: { $in: ['1', '3'] } } }],
+      [null, { name: 'Jane' }, { query: { id: { $in: ['2', '4'] } } }],
+      [5, { name: 'Jack' }, undefined],
+    ])
+  })
 
-  it("optimizeBatchPatch with _id", () => {
+  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: '1', name: 'John' },
+          { _id: '2', name: 'Jane' },
+          { _id: '3', name: 'John' },
+          { _id: '4', name: 'Jane' },
+          { _id: 5, name: 'Jack' },
         ],
-        { id: "_id" },
+        { id: '_id' },
       ),
     ).toEqual([
-      [null, { name: "John" }, { query: { _id: { $in: ["1", "3"] } } }],
-      [null, { name: "Jane" }, { query: { _id: { $in: ["2", "4"] } } }],
-      [5, { name: "Jack" }, undefined],
-    ]);
-  });
+      [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,10 +1,10 @@
-import { deepEqual as _isEqual } from "fast-equals";
-import _get from "lodash/get.js";
-import _set from "lodash/set.js";
-import type { Path } from "../typesInternal";
+import { deepEqual as _isEqual } from 'fast-equals'
+import _get from 'lodash/get.js'
+import _set from 'lodash/set.js'
+import type { Path } from '../typesInternal.js'
 
 export interface PushSetOptions {
-  unique?: boolean;
+  unique?: boolean
 }
 
 /**
@@ -16,83 +16,83 @@ export const pushSet = (
   val: unknown,
   options?: PushSetOptions,
 ): unknown[] => {
-  options = options || {};
-  let arr = _get(obj, path);
+  options = options || {}
+  let arr = _get(obj, path)
   if (!arr || !Array.isArray(arr)) {
-    arr = [val];
-    _set(obj, path, arr);
-    return arr;
+    arr = [val]
+    _set(obj, path, arr)
+    return arr
   } else {
     if (options.unique && arr.some((x) => _isEqual(x, val))) {
-      return arr;
+      return arr
     }
-    arr.push(val);
-    return arr;
+    arr.push(val)
+    return arr
   }
-};
+}
 
 if (import.meta.vitest) {
-  const { describe, it, assert } = import.meta.vitest;
+  const { describe, it, assert } = import.meta.vitest
 
-  it("pushes to existing array", function () {
+  it('pushes to existing array', function () {
     const obj = {
       arr: [1],
-    };
-    pushSet(obj, ["arr"], 2);
-    assert.deepStrictEqual(obj, { arr: [1, 2] });
-  });
+    }
+    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('sets array for not existing', function () {
+    const obj = {}
+    pushSet(obj, ['arr'], 2)
+    assert.deepStrictEqual(obj, { arr: [2] })
+  })
 
-  it("adds existing element", function () {
+  it('adds existing element', function () {
     const obj = {
       arr: [1],
-    };
-    pushSet(obj, ["arr"], 1);
-    assert.deepStrictEqual(obj, { arr: [1, 1] });
-  });
+    }
+    pushSet(obj, ['arr'], 1)
+    assert.deepStrictEqual(obj, { arr: [1, 1] })
+  })
 
-  it("skips existing element", function () {
+  it('skips existing element', function () {
     const obj = {
       arr: [1],
-    };
-    pushSet(obj, ["arr"], 1, { unique: true });
-    assert.deepStrictEqual(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 () {
+  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] }] } });
-    });
+      }
+      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: 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 () {
+    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] }] } });
-    });
+      }
+      pushSet(obj, ['nested', 'deep', 0, 'arr'], 1)
+      assert.deepStrictEqual(obj, { nested: { deep: [{ arr: [1, 1] }] } })
+    })
 
-    it("deep: skips existing element", function () {
+    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] }] } });
-    });
-  });
+      }
+      pushSet(obj, ['nested', 'deep', 0, 'arr'], 1, { unique: true })
+      assert.deepStrictEqual(obj, { nested: { deep: [{ arr: [1] }] } })
+    })
+  })
 }

package/src/utils/setQueryKeySafely.ts

@@ -1,194 +1,194 @@
-import { isPlainObject } from "./_utils.internal";
-import type { Params } from "@feathersjs/feathers";
+import { isPlainObject } from './_utils.internal.js'
+import type { Params } from '@feathersjs/feathers'
 
 export type SetQueryKeySafelyOptions = {
-  mutate?: boolean;
-};
+  mutate?: boolean
+}
 
 export const setQueryKeySafely = (
   params: Params,
   key: string,
   value: any,
-  operator = "$eq",
+  operator = '$eq',
   options?: SetQueryKeySafelyOptions,
 ): Params => {
-  const { mutate = false } = options || {};
+  const { mutate = false } = options || {}
 
   // TODO: mutate params
   if (!mutate) {
-    params = structuredClone(params);
+    params = structuredClone(params)
   }
 
   if (!params.query) {
-    params.query = {};
+    params.query = {}
   }
 
   // if the key is not in the query, just add it and return
   if (!(key in params.query)) {
-    if (operator === "$eq") {
-      params.query[key] = value;
+    if (operator === '$eq') {
+      params.query[key] = value
     } else {
       params.query[key] = {
         [operator]: value,
-      };
+      }
     }
 
-    return params;
+    return params
   }
 
   if (isPlainObject(params.query[key]) && !(operator in params.query[key])) {
-    params.query[key][operator] = value;
+    params.query[key][operator] = value
   } else {
-    params.query.$and ??= [];
+    params.query.$and ??= []
 
     params.query.$and.push(
-      operator === "$eq"
+      operator === '$eq'
         ? { [key]: value }
         : {
             [key]: {
               [operator]: value,
             },
           },
-    );
+    )
   }
 
-  return params;
-};
+  return params
+}
 
 if (import.meta.vitest) {
-  const { it, assert } = import.meta.vitest;
+  const { it, assert } = import.meta.vitest
 
-  it("does not mutate by default", function () {
+  it('does not mutate by default', function () {
     const params: Params = {
       query: {
         test: true,
       },
-    };
+    }
 
-    const result = setQueryKeySafely(params, "test", false);
+    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 () {
+  it('does not mutate explicitely', function () {
     const params: Params = {
       query: {
         test: true,
       },
-    };
+    }
 
-    const result = setQueryKeySafely(params, "test", false, "$eq", {
+    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 () {
+  it('does mutate explicitely', function () {
     const params: Params = {
       query: {
         test: true,
       },
-    };
+    }
 
-    const result = setQueryKeySafely(params, "test", false, "$eq", {
+    const result = setQueryKeySafely(params, 'test', false, '$eq', {
       mutate: true,
-    });
+    })
 
-    assert.equal(params, result);
-  });
+    assert.equal(params, result)
+  })
 
-  it("adds a $eq filter for non existent key", function () {
+  it('adds a $eq filter for non existent key', function () {
     const params: Params = {
       query: {},
-    };
+    }
 
-    const result = setQueryKeySafely(params, "test", true);
+    const result = setQueryKeySafely(params, 'test', true)
     assert.deepStrictEqual(result, {
       query: {
         test: true,
       },
-    });
-  });
+    })
+  })
 
-  it("adds a $ne filter for non existent key", function () {
+  it('adds a $ne filter for non existent key', function () {
     const params = {
       query: {},
-    };
+    }
 
-    const result = setQueryKeySafely(params, "test", true, "$ne");
+    const result = setQueryKeySafely(params, 'test', true, '$ne')
     assert.deepStrictEqual(result, {
       query: {
         test: {
           $ne: true,
         },
       },
-    });
-  });
+    })
+  })
 
-  it("adds a $eq filter for existing key", function () {
+  it('adds a $eq filter for existing key', function () {
     const params: Params = {
       query: {
         test: true,
       },
-    };
+    }
 
-    const result = setQueryKeySafely(params, "test", false);
+    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 () {
+  it('adds a $in filter for existing key with value', function () {
     const params: Params = {
       query: {
         test: true,
       },
-    };
+    }
 
-    const result = setQueryKeySafely(params, "test", [true], "$in");
+    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 () {
+  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");
+    const result = setQueryKeySafely(params, 'test', [true], '$in')
     assert.deepStrictEqual(result, {
       query: {
         test: {
@@ -196,19 +196,19 @@ if (import.meta.vitest) {
           $in: [true],
         },
       },
-    });
-  });
+    })
+  })
 
-  it("adds a $in filter for existing $in", function () {
+  it('adds a $in filter for existing $in', function () {
     const params: Params = {
       query: {
         test: {
           $in: [true],
         },
       },
-    };
+    }
 
-    const result = setQueryKeySafely(params, "test", [false], "$in");
+    const result = setQueryKeySafely(params, 'test', [false], '$in')
     assert.deepStrictEqual(result, {
       query: {
         test: {
@@ -216,6 +216,6 @@ if (import.meta.vitest) {
         },
         $and: [{ test: { $in: [false] } }],
       },
-    });
-  });
+    })
+  })
 }