!feat(utils): optimizeBatchPatch with Record (#26)

Author: fratzinger

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>;

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],
+    ]);
+  });
 }