self review addressed adn more tests

hariombalhara · hariombalhara · commit e954268cf123 · 2025-07-28T15:13:33.000+05:30
diff --git a/packages/lib/raqb/findTeamMembersMatchingAttributeLogic.test.ts b/packages/lib/raqb/findTeamMembersMatchingAttributeLogic.test.ts
@@ -1210,4 +1210,44 @@ describe("findTeamMembersMatchingAttributeLogic", () => {
       expect(troubleshooter).not.toBeUndefined();
     });
   });
+
+  it("should handle non-existent option IDs gracefully", async () => {
+    const LocationAttribute = {
+      id: "location-attr",
+      name: "Location",
+      type: "SINGLE_SELECT" as const,
+      slug: "location",
+      options: [{ id: "ny-opt", value: "New York", slug: "new-york" }],
+    };
+
+    mockAttributesScenario({
+      attributes: [LocationAttribute],
+      teamMembersWithAttributeOptionValuePerAttribute: [
+        { userId: 1, attributes: { [LocationAttribute.id]: "New York" } },
+      ],
+    });
+
+    const attributesQueryValue = buildSelectTypeFieldQueryValue({
+      rules: [
+        {
+          raqbFieldId: LocationAttribute.id,
+          value: ["non-existent-id"], // Non-existent option ID
+          operator: "select_equals",
+        },
+      ],
+    }) as AttributesQueryValue;
+
+    const { teamMembersMatchingAttributeLogic: result } = await findTeamMembersMatchingAttributeLogic({
+      dynamicFieldValueOperands: {
+        fields: [],
+        response: {},
+      },
+      attributesQueryValue,
+      teamId: 1,
+      orgId,
+    });
+
+    // Should not match anyone as the option ID doesn't exist
+    expect(result).toEqual([]);
+  });
 });
diff --git a/packages/lib/raqb/resolveQueryValue.test.ts b/packages/lib/raqb/resolveQueryValue.test.ts
@@ -1571,4 +1571,175 @@ describe("resolveQueryValue", () => {
       })
     );
   });
+
+  it("should handle field templates in deeply nested object structures", () => {
+    const queryValue = {
+      children1: {
+        rule1: {
+          type: "rule",
+          properties: {
+            field: "complex",
+            metadata: {
+              level1: {
+                value: "{field:city}",
+                level2: {
+                  items: ["{field:location}"],
+                  level3: {
+                    nested: [["{field:city}"]],
+                    static: "preserved",
+                  },
+                },
+              },
+            },
+            value: ["test"],
+          },
+        },
+      },
+    } as unknown as AttributesQueryValue;
+
+    const result = resolveQueryValue({
+      queryValue,
+      dynamicFieldValueOperands: {
+        fields: mockFields,
+        response: {
+          city: { value: "Mumbai", label: "Mumbai" },
+          location: { value: ["Delhi", "Chennai"], label: "Delhi, Chennai" },
+        },
+      },
+      attributes: mockAttributes,
+    });
+
+    // Verify all nested properties are preserved with templates resolved
+    const props = result.children1?.rule1.properties as any;
+    expect(props.metadata.level1.level2.level3.static).toBe("preserved");
+    expect(props.metadata.level1.value).toBe("mumbai");
+    expect(props.metadata.level1.level2.items).toEqual(["delhi", "chennai"]);
+    expect(props.metadata.level1.level2.level3.nested).toEqual([["mumbai"]]);
+    expect(props.value).toEqual(["test"]);
+  });
+
+  it("should handle extremely deep object nesting without stack overflow", () => {
+    let deepObj: any = { value: "{field:city}" };
+    for (let i = 0; i < 100; i++) {
+      deepObj = { nested: deepObj, level: i };
+    }
+
+    const queryValue = {
+      children1: {
+        rule1: {
+          type: "rule",
+          properties: deepObj,
+        },
+      },
+    } as unknown as AttributesQueryValue;
+
+    const result = resolveQueryValue({
+      queryValue,
+      dynamicFieldValueOperands: {
+        fields: mockFields,
+        response: {
+          city: { value: "Mumbai", label: "Mumbai" },
+        },
+      },
+      attributes: mockAttributes,
+    });
+
+    // Navigate to deepest level to verify it was processed
+    let current = result.children1?.rule1.properties as any;
+    for (let i = 99; i >= 0; i--) {
+      expect(current.level).toBe(i);
+      current = current.nested;
+    }
+    expect(current.value).toBe("mumbai");
+  });
+
+  it("should preserve all JavaScript primitive types in nested structures", () => {
+    const queryValue = {
+      children1: {
+        rule1: {
+          type: "rule",
+          properties: {
+            stringField: "{field:city}",
+            numberField: 42,
+            bigintField: 9007199254740991,
+            booleanField: true,
+            nullField: null,
+            nested: {
+              array: ["{field:location}", 123, false, null],
+              decimal: 3.14159,
+              negative: -100,
+              zero: 0,
+              emptyString: "",
+              specialChars: "!@#$%^&*()",
+            },
+          },
+        },
+      },
+    } as unknown as AttributesQueryValue;
+
+    const result = resolveQueryValue({
+      queryValue,
+      dynamicFieldValueOperands: {
+        fields: mockFields,
+        response: {
+          city: { value: "Mumbai", label: "Mumbai" },
+          location: { value: ["Delhi"], label: "Delhi" },
+        },
+      },
+      attributes: mockAttributes,
+    });
+
+    const props = result.children1?.rule1.properties as any;
+    expect(props.stringField).toBe("mumbai");
+    expect(props.numberField).toBe(42);
+    expect(props.bigintField).toBe(9007199254740991);
+    expect(props.booleanField).toBe(true);
+    expect(props.nullField).toBeNull();
+    expect(props.nested.array).toEqual(["delhi", 123, false, null]);
+    expect(props.nested.decimal).toBe(3.14159);
+    expect(props.nested.negative).toBe(-100);
+    expect(props.nested.zero).toBe(0);
+    expect(props.nested.emptyString).toBe("");
+    expect(props.nested.specialChars).toBe("!@#$%^&*()");
+  });
+
+  it("should process field templates within objects inside arrays", () => {
+    const queryValue = {
+      children1: {
+        rule1: {
+          type: "rule",
+          properties: {
+            value: [
+              { id: 1, city: "{field:city}" },
+              { id: 2, locations: ["{field:location}"] },
+              { id: 3, nested: { value: [["{field:city}"]] } },
+            ],
+          },
+        },
+      },
+    } as unknown as AttributesQueryValue;
+
+    const result = resolveQueryValue({
+      queryValue,
+      dynamicFieldValueOperands: {
+        fields: mockFields,
+        response: {
+          city: { value: "Mumbai", label: "Mumbai" },
+          location: { value: ["Delhi", "Chennai"], label: "Delhi, Chennai" },
+        },
+      },
+      attributes: mockAttributes,
+    });
+
+    const props = result.children1?.rule1.properties as any;
+    expect(props.value[0]).toEqual({ id: 1, city: "mumbai" });
+    expect(props.value[1]).toEqual({
+      id: 2,
+      locations: ["delhi", "chennai"],
+    });
+    expect(props.value[2]).toEqual({
+      id: 3,
+      nested: { value: [["mumbai"]] },
+    });
+  });
 });
diff --git a/packages/lib/raqb/resolveQueryValue.ts b/packages/lib/raqb/resolveQueryValue.ts
@@ -8,10 +8,20 @@ import { caseInsensitive } from "./utils";
 // Type for JSON values that can be in the query
 type JsonValue = string | number | boolean | null | JsonValue[] | { [key: string]: JsonValue };
 
+type MinimalField = {
+  type: string;
+  options?: {
+    id: string | null;
+    label: string;
+  }[];
+};
+
+type FieldResponseValue = dynamicFieldValueOperandsResponse[keyof dynamicFieldValueOperandsResponse]["value"];
+
 const moduleLogger = logger.getSubLogger({ prefix: ["raqb/resolveQueryValue"] });
 
 /**
- * Replace attribute option Ids with the attribute option label(compatible to be matched with form field value)
+ * Replace "Attribute Options' Ids" with "Attribute Options' Labels". It makes the query value compatible to be matched with 'Value of Field' operand
  */
 const replaceAttributeOptionIdsWithOptionLabel = ({
   queryValue,
@@ -38,14 +48,8 @@ function getFieldResponseValueAsLabel({
   field,
   fieldResponseValue,
 }: {
-  fieldResponseValue: dynamicFieldValueOperandsResponse[keyof dynamicFieldValueOperandsResponse]["value"];
-  field: {
-    type: string;
-    options?: {
-      id: string | null;
-      label: string;
-    }[];
-  };
+  fieldResponseValue: FieldResponseValue;
+  field: MinimalField;
 }) {
   const nonNumberFieldResponseValue =
     typeof fieldResponseValue === "number" ? fieldResponseValue.toString() : fieldResponseValue;
@@ -67,17 +71,22 @@ function getFieldResponseValueAsLabel({
     if (foundOptionById) {
       return foundOptionById.label;
     } else {
-      return idOrLabel.toString();
+      return idOrLabel;
     }
   }
 }
 
 /**
- * Resolves field template placeholders ({field:fieldId}) in a JSON string with actual values from form responses.
- * Handles arrays properly for JSONLogic compatibility by spreading array values when needed.
+ * Resolves query values by:
+ * 1. Converting attribute option IDs to their lowercase labels
+ * 2. Replacing field template placeholders (e.g., "{field:location}") with actual field values
  *
- * @param queryValueString - JSON string containing RAQB query with field template placeholders like {field:fieldId}
- * @param dynamicFieldValueOperands - Optional object containing fields metadata and user's form responses
+ * Important: When a field template resolves to an array value, the array items are flattened
+ * into the parent array. For example:
+ * - Input: [["{{field:location}}", "Delhi"]] where location = ["New York", "Amsterdam"]
+ * - Output: [["new york", "amsterdam", "Delhi"]] (flattened into single array)
+ * @param queryValue - JSON string containing RAQB query with field template placeholders like {field:fieldId}
+ * @param dynamicFieldValueOperands - Optional object containing fields metadata and user's form field responses
  * @param dynamicFieldValueOperands.fields - Array of field definitions with id, type, label, etc.
  * @param dynamicFieldValueOperands.response - Object mapping field IDs to their response values
  *
@@ -96,8 +105,8 @@ function getFieldResponseValueAsLabel({
  *             "operator": "multiselect_some_in",
  *             "value": [
  *               [
- *                 "{field:0bf77a89-2bd0-4df7-9648-758014ba3189}",
- *                 "899c846d-7c02-43dc-9057-c3f8c118d41f"
+ *                 "{field:0bf77a89-2bd0-4df7-9648-758014ba3189}", // 'Value of field' is stored like this and we call it a 'field template'
+ *                 "899c846d-7c02-43dc-9057-c3f8c118d41f" // A regular attribute option id
  *               ]
  *             ],
  *             "valueSrc": [
@@ -186,10 +195,12 @@ export const resolveQueryValue = ({
     return caseInsensitive(resolvedValue);
   };
 
-  // Process an array that might contain field templates. We keep it generic to handle any updates to the queryValue from the RAQB automatically
+  // Process an array that might contain field templates. We keep it generic instead of typing it as QueryValue to handle any property where the queryValue can have a field template
+  // Note: When a field template resolves to an array, its items are flattened into the parent array
   const processArray = (arr: JsonValue[]): JsonValue[] => {
     const hasFieldTemplate = arr.some((item) => typeof item === "string" && isFieldTemplate(item));
 
+    // Short circuit if there are no field templates
     if (!hasFieldTemplate) {
       return arr.map((item) => processAnyValue(item));
     }
@@ -199,9 +210,13 @@ export const resolveQueryValue = ({
       if (typeof item === "string" && isFieldTemplate(item)) {
         const processed = processStringValue(item);
         if (Array.isArray(processed)) {
-          // [{field:location}, Delhi] -> becomes [New York, Amsterdam, Delhi]. New York and Amsterdam are the values of the field `location`
+          // Flattening behavior: Array values from field templates are spread into parent array
+          // Example: ["{field:location}", "Delhi"] where location = ["New York", "Amsterdam"]
+          // Result: ["New York", "Amsterdam", "Delhi"] (items flattened)
+          // This is intentional to merge field values at the same array level
           result.push(...processed);
         } else {
+          // [{field:location}, Delhi] -> becomes [New York, Delhi]. New York was the response for the field `location`
           result.push(processed);
         }
       } else {
