feat: add restoreMap function

Author: iobuhov

packages/shared/filter-commons/src/__tests__/condition-utils.spec.ts

@@ -2,7 +2,7 @@ jest.mock("mendix/filters/builders");
 
 import { AndCondition } from "mendix/filters";
 import { equals, literal } from "mendix/filters/builders";
-import { compactArray, fromCompactArray, reduceMap, tag } from "../condition-utils";
+import { compactArray, fromCompactArray, reduceMap, restoreMap, tag } from "../condition-utils";
 
 describe("condition-utils", () => {
     describe("compactArray", () => {
@@ -135,4 +135,134 @@ describe("condition-utils", () => {
             });
         });
     });
+
+    describe("restoreMap", () => {
+        it("restores map with undefined values from undefined condition", () => {
+            const originalInput = { x: undefined, y: undefined };
+            const [condition, metadata] = reduceMap(originalInput);
+
+            const restored = restoreMap(condition, metadata);
+
+            expect(restored).toEqual(originalInput);
+        });
+
+        it("restores map with single condition", () => {
+            const tagCondition = tag("test");
+            const originalInput = { a: tagCondition, b: undefined, c: undefined };
+            const [condition, metadata] = reduceMap(originalInput);
+
+            const restored = restoreMap(condition, metadata);
+
+            expect(restored).toEqual(originalInput);
+        });
+
+        it("restores map with multiple conditions", () => {
+            const tagCondition1 = tag("test1");
+            const tagCondition2 = tag("test2");
+            const originalInput = { x: tagCondition1, y: undefined, z: tagCondition2, w: undefined };
+            const [condition, metadata] = reduceMap(originalInput);
+
+            const restored = restoreMap(condition, metadata);
+
+            expect(restored).toEqual(originalInput);
+        });
+
+        it("restores empty map", () => {
+            const originalInput = {};
+            const [condition, metadata] = reduceMap(originalInput);
+
+            const restored = restoreMap(condition, metadata);
+
+            expect(restored).toEqual(originalInput);
+        });
+
+        it("restores map with mixed condition types", () => {
+            const tagCondition = tag("tag-test");
+            const equalsCondition = equals(literal("field"), literal("value"));
+            const originalInput = {
+                tag: tagCondition,
+                equals: equalsCondition,
+                empty: undefined,
+                another: undefined
+            };
+            const [condition, metadata] = reduceMap(originalInput);
+
+            const restored = restoreMap(condition, metadata);
+
+            expect(restored).toEqual(originalInput);
+        });
+
+        it("handles manual metadata for single condition case", () => {
+            const tagCondition = tag("manual-test");
+            const metadata = JSON.stringify({
+                length: 1,
+                keys: ["first", "second", "third"],
+                0: "second"
+            });
+
+            const restored = restoreMap(tagCondition, metadata);
+
+            expect(restored).toEqual({
+                first: undefined,
+                second: tagCondition,
+                third: undefined
+            });
+        });
+
+        it("handles manual metadata for multiple conditions case", () => {
+            const tagCondition1 = tag("manual1");
+            const tagCondition2 = tag("manual2");
+            const andCondition = {
+                name: "and",
+                type: "function",
+                args: [tagCondition1, tagCondition2]
+            } as AndCondition;
+            const metadata = JSON.stringify({
+                length: 2,
+                keys: ["a", "b", "c", "d"],
+                0: "a",
+                1: "c"
+            });
+
+            const restored = restoreMap(andCondition, metadata);
+
+            expect(restored).toEqual({
+                a: tagCondition1,
+                b: undefined,
+                c: tagCondition2,
+                d: undefined
+            });
+        });
+
+        it("handles edge case with undefined condition and non-zero length metadata", () => {
+            const metadata = JSON.stringify({
+                length: 1,
+                keys: ["test"],
+                0: "test"
+            });
+
+            const restored = restoreMap(undefined, metadata);
+
+            expect(restored).toEqual({
+                test: undefined
+            });
+        });
+
+        it("handles edge case with non-and condition but multiple length metadata", () => {
+            const tagCondition = tag("single");
+            const metadata = JSON.stringify({
+                length: 2,
+                keys: ["a", "b"],
+                0: "a",
+                1: "b"
+            });
+
+            const restored = restoreMap(tagCondition, metadata);
+
+            expect(restored).toEqual({
+                a: undefined,
+                b: undefined
+            });
+        });
+    });
 });

packages/shared/filter-commons/src/condition-utils.ts

@@ -171,28 +171,36 @@ export function reduceMap(input: Record<string, FilterCondition | undefined>): [
             return [and(...conditions), metaJson];
     }
 }
-/* 
+
 export function restoreMap(
     cond: FilterCondition | undefined,
     metaJson: string
 ): Record<string, FilterCondition | undefined> {
     const meta = JSON.parse(metaJson) as ReduceMapMeta;
     const result: Record<string, FilterCondition | undefined> = {};
-    const keys = Object.keys(meta).filter(key => key !== "length");
-    for (const key of keys) {
+
+    for (const key of meta.keys) {
         result[key] = undefined;
     }
 
     if (meta.length === 0) {
         return result;
     }
 
-    if (meta.length === 1) {
-        const key = keys[0];
-        result[key] = cond;
+    if (meta.length === 1 && meta[0]) {
+        result[meta[0]] = cond;
+        return result;
+    }
+
+    if (cond && isAnd(cond)) {
+        cond.args.forEach((c, i) => {
+            result[meta[i]] = c;
+        });
         return result;
     }
-} */
+
+    return result;
+}
 
 export function fromCompactArray(cond: FilterCondition): Array<FilterCondition | undefined> {
     const tag = isAnd(cond) ? cond.args[0] : cond;