Scheduling infrastructure for absolutely everyone.
feat: Support an array response for a field when used as `Value of Field` (#22740)
Hariom Balhara016a9660571b
diff --git a/packages/lib/raqb/findTeamMembersMatchingAttributeLogic.test.ts b/packages/lib/raqb/findTeamMembersMatchingAttributeLogic.test.tsindex 667a638945c..72a71ae5e9d 100644--- a/packages/lib/raqb/findTeamMembersMatchingAttributeLogic.test.ts+++ b/packages/lib/raqb/findTeamMembersMatchingAttributeLogic.test.ts@@ -47,6 +47,7 @@ function mockAttributesScenario({...attribute,options: attribute.options.map((option) => ({...option,+ attributeId: attribute.id,...commonOptionsProps,})),})),@@ -289,323 +290,507 @@ describe("findTeamMembersMatchingAttributeLogic", () => {);});- it("should return matching team members with a SINGLE_SELECT attribute when a static option is selected and troubleshooter should be null by default", async () => {- const Option1OfAttribute1 = { id: "opt1", value: "Option 1", slug: "option-1" };- const Attribute1 = {- id: "attr1",- name: "Attribute 1",- type: "SINGLE_SELECT" as const,- slug: "attribute-1",- options: [Option1OfAttribute1],- };+ describe("with a SINGLE_SELECT attribute", () => {+ it("when a static option is selected, troubleshooter should be null by default", async () => {+ const Option1OfAttribute1 = { id: "opt1", value: "Option 1", slug: "option-1" };+ const Attribute1 = {+ id: "attr1",+ name: "Attribute 1",+ type: "SINGLE_SELECT" as const,+ slug: "attribute-1",+ options: [Option1OfAttribute1],+ };- mockAttributesScenario({- attributes: [Attribute1],- teamMembersWithAttributeOptionValuePerAttribute: [- { userId: 1, attributes: { [Attribute1.id]: Option1OfAttribute1.value } },- ],- });+ mockAttributesScenario({+ attributes: [Attribute1],+ teamMembersWithAttributeOptionValuePerAttribute: [+ { userId: 1, attributes: { [Attribute1.id]: Option1OfAttribute1.value } },+ ],+ });- const attributesQueryValue = buildSelectTypeFieldQueryValue({- rules: [+ const attributesQueryValue = buildSelectTypeFieldQueryValue({+ rules: [+ {+ raqbFieldId: Attribute1.id,+ value: [Option1OfAttribute1.id],+ operator: "select_equals",+ },+ ],+ }) as AttributesQueryValue;++ const { teamMembersMatchingAttributeLogic: result, troubleshooter } =+ await findTeamMembersMatchingAttributeLogic({+ dynamicFieldValueOperands: {+ fields: [],+ response: {},+ },+ attributesQueryValue,+ teamId: 1,+ orgId,+ });++ expect(result).toEqual([{- raqbFieldId: Attribute1.id,- value: [Option1OfAttribute1.id],- operator: "select_equals",+ userId: 1,+ result: RaqbLogicResult.MATCH,},- ],- }) as AttributesQueryValue;+ ]);- const { teamMembersMatchingAttributeLogic: result, troubleshooter } =- await findTeamMembersMatchingAttributeLogic({- dynamicFieldValueOperands: {- fields: [],- response: {},- },- attributesQueryValue,- teamId: 1,- orgId,- });+ expect(troubleshooter).toBeUndefined();+ });- expect(result).toEqual([- {- userId: 1,- result: RaqbLogicResult.MATCH,- },- ]);+ describe("with `Value of field`", () => {+ it("when 'Value of Field' option is selected and ", async () => {+ const Option1OfAttribute1HumanReadableValue = "Option 1";+ const Option1OfField1HumanReadableValue = Option1OfAttribute1HumanReadableValue;+ const Field1Id = "field-1";- expect(troubleshooter).toBeUndefined();- });+ const Option1OfAttribute1 = {+ id: "attr-1-opt-1",+ value: Option1OfAttribute1HumanReadableValue,+ slug: "option-1",+ };- it("should return matching team members with a SINGLE_SELECT attribute when 'Value of Field' option is selected", async () => {- const Option1OfAttribute1HumanReadableValue = "Option 1";- const Option1OfField1HumanReadableValue = Option1OfAttribute1HumanReadableValue;- const Field1Id = "field-1";+ const Option1OfField1 = {+ id: "field-1-opt-1",+ label: Option1OfField1HumanReadableValue,+ };- const Option1OfAttribute1 = {- id: "attr-1-opt-1",- value: Option1OfAttribute1HumanReadableValue,- slug: "option-1",- };+ const Attribute1 = {+ id: "attr1",+ name: "Attribute 1",+ type: "SINGLE_SELECT" as const,+ slug: "attribute-1",+ options: [Option1OfAttribute1],+ };- const Option1OfField1 = {- id: "field-1-opt-1",- label: Option1OfField1HumanReadableValue,- };+ mockAttributesScenario({+ attributes: [Attribute1],+ teamMembersWithAttributeOptionValuePerAttribute: [+ { userId: 1, attributes: { [Attribute1.id]: Option1OfAttribute1.value } },+ ],+ });- const Attribute1 = {- id: "attr1",- name: "Attribute 1",- type: "SINGLE_SELECT" as const,- slug: "attribute-1",- options: [Option1OfAttribute1],- };+ const attributesQueryValue = buildSelectTypeFieldQueryValue({+ rules: [+ {+ raqbFieldId: Attribute1.id,+ value: [`{field:${Field1Id}}`],+ operator: "select_equals",+ },+ ],+ }) as AttributesQueryValue;- mockAttributesScenario({- attributes: [Attribute1],- teamMembersWithAttributeOptionValuePerAttribute: [- { userId: 1, attributes: { [Attribute1.id]: Option1OfAttribute1.value } },- ],+ const { teamMembersMatchingAttributeLogic: result } = await findTeamMembersMatchingAttributeLogic({+ dynamicFieldValueOperands: {+ fields: [+ {+ id: Field1Id,+ type: RoutingFormFieldType.SINGLE_SELECT,+ label: "Field 1",+ options: [Option1OfField1],+ },+ ],+ response: {+ [Field1Id]: {+ value: Option1OfAttribute1HumanReadableValue,+ label: Option1OfAttribute1HumanReadableValue,+ },+ },+ },+ attributesQueryValue: attributesQueryValue,+ teamId: 1,+ orgId,+ });++ expect(result).toEqual([+ {+ userId: 1,+ result: RaqbLogicResult.MATCH,+ },+ ]);+ });});- const attributesQueryValue = buildSelectTypeFieldQueryValue({- rules: [- {- raqbFieldId: Attribute1.id,- value: [`{field:${Field1Id}}`],- operator: "select_equals",- },- ],- }) as AttributesQueryValue;+ it("when 'Any in'(select_any_in) option is selected", async () => {+ const Option1OfAttribute1HumanReadableValue = "Option 1";- const { teamMembersMatchingAttributeLogic: result } = await findTeamMembersMatchingAttributeLogic({- dynamicFieldValueOperands: {- fields: [+ const Option1OfAttribute1 = {+ id: "attr-1-opt-1",+ value: Option1OfAttribute1HumanReadableValue,+ slug: "option-1",+ };++ const Option2OfAttribute1 = {+ id: "attr-1-opt-2",+ value: "Option 2",+ slug: "option-2",+ };++ const Option3OfAttribute1 = {+ id: "attr-1-opt-3",+ value: "Option 3",+ slug: "option-3",+ };++ const Attribute1 = {+ id: "attr1",+ name: "Attribute 1",+ type: "SINGLE_SELECT" as const,+ slug: "attribute-1",+ options: [Option1OfAttribute1, Option2OfAttribute1, Option3OfAttribute1],+ };++ mockAttributesScenario({+ attributes: [Attribute1],+ teamMembersWithAttributeOptionValuePerAttribute: [+ { userId: 1, attributes: { [Attribute1.id]: Option1OfAttribute1.value } },+ ],+ });++ const attributesQueryValue = buildSelectTypeFieldQueryValue({+ rules: [{- id: Field1Id,- type: RoutingFormFieldType.SINGLE_SELECT,- label: "Field 1",- options: [Option1OfField1],+ raqbFieldId: Attribute1.id,+ value: [[Option1OfAttribute1.id, Option2OfAttribute1.id]],+ operator: "select_any_in",+ valueType: ["multiselect"],},],- response: {- [Field1Id]: {- value: Option1OfAttribute1HumanReadableValue,- label: Option1OfAttribute1HumanReadableValue,- },+ }) as AttributesQueryValue;++ const { teamMembersMatchingAttributeLogic: result } = await findTeamMembersMatchingAttributeLogic({+ dynamicFieldValueOperands: {+ fields: [],+ response: {},},- },- attributesQueryValue: attributesQueryValue,- teamId: 1,- orgId,- });+ attributesQueryValue,+ teamId: 1,+ orgId,+ });- expect(result).toEqual([- {- userId: 1,- result: RaqbLogicResult.MATCH,- },- ]);+ expect(result).toEqual([+ {+ userId: 1,+ result: RaqbLogicResult.MATCH,+ },+ ]);+ });});- it("should return matching team members with a SINGLE_SELECT attribute when 'Any in'(select_any_in) option is selected", async () => {- const Option1OfAttribute1HumanReadableValue = "Option 1";+ describe("with a MULTI_SELECT attribute", () => {+ it("when 'Any in'(multiselect_some_in) option is selected and just one option is used in attribute for the user", async () => {+ const Option1OfAttribute1HumanReadableValue = "Option 1";- const Option1OfAttribute1 = {- id: "attr-1-opt-1",- value: Option1OfAttribute1HumanReadableValue,- slug: "option-1",- };+ const Option1OfAttribute1 = {+ id: "attr-1-opt-1",+ value: Option1OfAttribute1HumanReadableValue,+ slug: "option-1",+ };- const Option2OfAttribute1 = {- id: "attr-1-opt-2",- value: "Option 2",- slug: "option-2",- };+ const Option2OfAttribute1 = {+ id: "attr-1-opt-2",+ value: "Option 2",+ slug: "option-2",+ };- const Option3OfAttribute1 = {- id: "attr-1-opt-3",- value: "Option 3",- slug: "option-3",- };+ const Option3OfAttribute1 = {+ id: "attr-1-opt-3",+ value: "Option 3",+ slug: "option-3",+ };- const Attribute1 = {- id: "attr1",- name: "Attribute 1",- type: "SINGLE_SELECT" as const,- slug: "attribute-1",- options: [Option1OfAttribute1, Option2OfAttribute1, Option3OfAttribute1],- };+ const Attribute1 = {+ id: "attr1",+ name: "Attribute 1",+ type: "MULTI_SELECT" as const,+ slug: "attribute-1",+ options: [Option1OfAttribute1, Option2OfAttribute1, Option3OfAttribute1],+ };- mockAttributesScenario({- attributes: [Attribute1],- teamMembersWithAttributeOptionValuePerAttribute: [- { userId: 1, attributes: { [Attribute1.id]: Option1OfAttribute1.value } },- ],- });+ mockAttributesScenario({+ attributes: [Attribute1],+ teamMembersWithAttributeOptionValuePerAttribute: [+ // user 1 has only one option selected for the attribute+ { userId: 1, attributes: { [Attribute1.id]: Option1OfAttribute1.value } },+ ],+ });- const attributesQueryValue = buildSelectTypeFieldQueryValue({- rules: [- {- raqbFieldId: Attribute1.id,- value: [[Option1OfAttribute1.id, Option2OfAttribute1.id]],- operator: "select_any_in",- valueType: ["multiselect"],+ const attributesQueryValue = buildSelectTypeFieldQueryValue({+ rules: [+ {+ raqbFieldId: Attribute1.id,+ value: [[Option1OfAttribute1.id, Option2OfAttribute1.id]],+ operator: "multiselect_some_in",+ valueType: ["multiselect"],+ },+ ],+ }) as AttributesQueryValue;++ const { teamMembersMatchingAttributeLogic: result } = await findTeamMembersMatchingAttributeLogic({+ dynamicFieldValueOperands: {+ fields: [],+ response: {},},- ],- }) as AttributesQueryValue;+ attributesQueryValue,+ teamId: 1,+ orgId,+ });- const { teamMembersMatchingAttributeLogic: result } = await findTeamMembersMatchingAttributeLogic({- dynamicFieldValueOperands: {- fields: [],- response: {},- },- attributesQueryValue,- teamId: 1,- orgId,+ expect(result).toEqual([+ {+ userId: 1,+ result: RaqbLogicResult.MATCH,+ },+ ]);});- expect(result).toEqual([- {- userId: 1,- result: RaqbLogicResult.MATCH,- },- ]);- });+ it("when 'Any in'(multiselect_some_in) option is selected and more than one option is used in attribute for the user", async () => {+ const Option1OfAttribute1HumanReadableValue = "Option 1";- it("should return matching team members with a MULTI_SELECT attribute when 'Any in'(multiselect_some_in) option is selected and just one option is used in attribute for the user", async () => {- const Option1OfAttribute1HumanReadableValue = "Option 1";+ const Option1OfAttribute1 = {+ id: "attr-1-opt-1",+ value: Option1OfAttribute1HumanReadableValue,+ slug: "option-1",+ };- const Option1OfAttribute1 = {- id: "attr-1-opt-1",- value: Option1OfAttribute1HumanReadableValue,- slug: "option-1",- };+ const Option2OfAttribute1 = {+ id: "attr-1-opt-2",+ value: "Option 2",+ slug: "option-2",+ };- const Option2OfAttribute1 = {- id: "attr-1-opt-2",- value: "Option 2",- slug: "option-2",- };+ const Option3OfAttribute1 = {+ id: "attr-1-opt-3",+ value: "Option 3",+ slug: "option-3",+ };- const Option3OfAttribute1 = {- id: "attr-1-opt-3",- value: "Option 3",- slug: "option-3",- };+ const Attribute1 = {+ id: "attr1",+ name: "Attribute 1",+ type: "MULTI_SELECT" as const,+ slug: "attribute-1",+ options: [Option1OfAttribute1, Option2OfAttribute1, Option3OfAttribute1],+ };- const Attribute1 = {- id: "attr1",- name: "Attribute 1",- type: "MULTI_SELECT" as const,- slug: "attribute-1",- options: [Option1OfAttribute1, Option2OfAttribute1, Option3OfAttribute1],- };+ mockAttributesScenario({+ attributes: [Attribute1],+ teamMembersWithAttributeOptionValuePerAttribute: [+ {+ userId: 1,+ // user 1 has two options selected for the attribute+ attributes: { [Attribute1.id]: [Option2OfAttribute1.value, Option1OfAttribute1.value] },+ },+ ],+ });- mockAttributesScenario({- attributes: [Attribute1],- teamMembersWithAttributeOptionValuePerAttribute: [- // user 1 has only one option selected for the attribute- { userId: 1, attributes: { [Attribute1.id]: Option1OfAttribute1.value } },- ],- });+ const attributesQueryValue = buildSelectTypeFieldQueryValue({+ rules: [+ {+ raqbFieldId: Attribute1.id,+ value: [[Option1OfAttribute1.id, Option2OfAttribute1.id]],+ operator: "multiselect_some_in",+ valueType: ["multiselect"],+ },+ ],+ }) as AttributesQueryValue;- const attributesQueryValue = buildSelectTypeFieldQueryValue({- rules: [- {- raqbFieldId: Attribute1.id,- value: [[Option1OfAttribute1.id, Option2OfAttribute1.id]],- operator: "multiselect_some_in",- valueType: ["multiselect"],+ const { teamMembersMatchingAttributeLogic: result } = await findTeamMembersMatchingAttributeLogic({+ dynamicFieldValueOperands: {+ fields: [],+ response: {},},- ],- }) as AttributesQueryValue;+ attributesQueryValue,+ teamId: 1,+ orgId,+ });- const { teamMembersMatchingAttributeLogic: result } = await findTeamMembersMatchingAttributeLogic({- dynamicFieldValueOperands: {- fields: [],- response: {},- },- attributesQueryValue,- teamId: 1,- orgId,+ expect(result).toEqual([+ {+ userId: 1,+ result: RaqbLogicResult.MATCH,+ },+ ]);});- expect(result).toEqual([- {- userId: 1,- result: RaqbLogicResult.MATCH,- },- ]);- });+ describe("with `Value of field`", () => {+ it("when 'Any in'(multiselect_some_in) option is selected and more than one option is used in attribute and more than one option is selected in the field", async () => {+ const Field1Id = "location-field";+ const DelhiOption = {+ id: "delhi-opt",+ label: "Delhi",+ };+ const HaryanaOption = {+ id: "haryana-opt",+ label: "Haryana",+ };+ const MumbaiOption = {+ id: "mumbai-opt",+ label: "Mumbai",+ };- it("should return matching team members with a MULTI_SELECT attribute when 'Any in'(multiselect_some_in) option is selected and more than one option is used in attribute for the user", async () => {- const Option1OfAttribute1HumanReadableValue = "Option 1";+ const HeadquartersAttribute = {+ id: "headquarters-attr",+ name: "Headquarters",+ type: "MULTI_SELECT" as const,+ slug: "headquarters",+ options: [+ { id: "delhi-hq", value: "Delhi", slug: "delhi" },+ { id: "haryana-hq", value: "Haryana", slug: "haryana" },+ { id: "mumbai-hq", value: "Mumbai", slug: "mumbai" },+ { id: "chennai-hq", value: "Chennai", slug: "chennai" },+ ],+ };- const Option1OfAttribute1 = {- id: "attr-1-opt-1",- value: Option1OfAttribute1HumanReadableValue,- slug: "option-1",- };+ mockAttributesScenario({+ attributes: [HeadquartersAttribute],+ teamMembersWithAttributeOptionValuePerAttribute: [+ // User 1: headquarters in Delhi and Haryana+ { userId: 1, attributes: { [HeadquartersAttribute.id]: ["Delhi", "Haryana"] } },+ // User 2: headquarters only in Mumbai+ { userId: 2, attributes: { [HeadquartersAttribute.id]: ["Mumbai"] } },+ // User 3: headquarters in Chennai+ { userId: 3, attributes: { [HeadquartersAttribute.id]: ["Chennai"] } },+ ],+ });- const Option2OfAttribute1 = {- id: "attr-1-opt-2",- value: "Option 2",- slug: "option-2",- };+ const attributesQueryValue = buildSelectTypeFieldQueryValue({+ rules: [+ {+ raqbFieldId: HeadquartersAttribute.id,+ value: [[`{field:${Field1Id}}`]],+ operator: "multiselect_some_in",+ valueType: ["multiselect"],+ },+ ],+ }) as AttributesQueryValue;- const Option3OfAttribute1 = {- id: "attr-1-opt-3",- value: "Option 3",- slug: "option-3",- };+ // Test case 1: Booker selects Delhi and Mumbai+ const { teamMembersMatchingAttributeLogic: result1 } = await findTeamMembersMatchingAttributeLogic({+ dynamicFieldValueOperands: {+ fields: [+ {+ id: Field1Id,+ type: RoutingFormFieldType.MULTI_SELECT,+ label: "Location",+ options: [DelhiOption, HaryanaOption, MumbaiOption],+ },+ ],+ response: {+ [Field1Id]: { label: "Location", value: [DelhiOption.id, MumbaiOption.id] }, // Booker selected Delhi and Mumbai+ },+ },+ attributesQueryValue,+ teamId: 1,+ orgId,+ });- const Attribute1 = {- id: "attr1",- name: "Attribute 1",- type: "MULTI_SELECT" as const,- slug: "attribute-1",- options: [Option1OfAttribute1, Option2OfAttribute1, Option3OfAttribute1],- };+ // Should match users 1 and 2 (Delhi matches user 1, Mumbai matches user 2)+ expect(result1).toEqual(+ expect.arrayContaining([+ { userId: 1, result: RaqbLogicResult.MATCH },+ { userId: 2, result: RaqbLogicResult.MATCH },+ ])+ );+ expect(result1).not.toContainEqual({ userId: 3, result: RaqbLogicResult.MATCH });- mockAttributesScenario({- attributes: [Attribute1],- teamMembersWithAttributeOptionValuePerAttribute: [- {- userId: 1,- // user 1 has two options selected for the attribute- attributes: { [Attribute1.id]: [Option2OfAttribute1.value, Option1OfAttribute1.value] },- },- ],+ // Test case 2: Booker selects only Chennai+ const { teamMembersMatchingAttributeLogic: result2 } = await findTeamMembersMatchingAttributeLogic({+ dynamicFieldValueOperands: {+ fields: [+ {+ id: Field1Id,+ type: RoutingFormFieldType.MULTI_SELECT,+ label: "Location",+ options: [DelhiOption, HaryanaOption, MumbaiOption, { id: "chennai-opt", label: "Chennai" }],+ },+ ],+ response: {+ [Field1Id]: { label: "Location", value: ["chennai-opt"] }, // Booker selected only Chennai+ },+ },+ attributesQueryValue,+ teamId: 1,+ orgId,+ });++ // Should match only user 3+ expect(result2).toEqual([{ userId: 3, result: RaqbLogicResult.MATCH }]);+ });});- const attributesQueryValue = buildSelectTypeFieldQueryValue({- rules: [- {- raqbFieldId: Attribute1.id,- value: [[Option1OfAttribute1.id, Option2OfAttribute1.id]],- operator: "multiselect_some_in",- valueType: ["multiselect"],+ it("should handle field template mixed with regular values in multiselect array", async () => {+ const LocationFieldId = "location-field";+ const FixedValueId = "fixed-location-id";++ const LocationAttribute = {+ id: "location-attr",+ name: "Service Locations",+ type: "MULTI_SELECT" as const,+ slug: "service-locations",+ options: [+ { id: "delhi-loc", value: "Delhi", slug: "delhi" },+ { id: "mumbai-loc", value: "Mumbai", slug: "mumbai" },+ { id: FixedValueId, value: "Chennai", slug: "chennai" },+ ],+ };++ mockAttributesScenario({+ attributes: [LocationAttribute],+ teamMembersWithAttributeOptionValuePerAttribute: [+ // User 1: services Delhi and Chennai+ { userId: 1, attributes: { [LocationAttribute.id]: ["Delhi", "Chennai"] } },+ // User 2: services only Mumbai+ { userId: 2, attributes: { [LocationAttribute.id]: ["Mumbai"] } },+ ],+ });++ // This simulates a complex rule: Location must include field value OR Chennai (fixed)+ const attributesQueryValue = buildSelectTypeFieldQueryValue({+ rules: [+ {+ raqbFieldId: LocationAttribute.id,+ value: [[`{field:${LocationFieldId}}`, "Chennai"]], // Mixed: field template + fixed value+ operator: "multiselect_some_in",+ valueType: ["multiselect"],+ },+ ],+ }) as AttributesQueryValue;++ // When booker selects Mumbai+ const { teamMembersMatchingAttributeLogic: result } = await findTeamMembersMatchingAttributeLogic({+ dynamicFieldValueOperands: {+ fields: [+ {+ id: LocationFieldId,+ type: RoutingFormFieldType.MULTI_SELECT,+ label: "Preferred Location",+ options: [+ { id: "delhi-opt", label: "Delhi" },+ { id: "mumbai-opt", label: "Mumbai" },+ ],+ },+ ],+ response: {+ [LocationFieldId]: { value: ["Mumbai"], label: "Mumbai" }, // Booker selected Mumbai+ },},- ],- }) as AttributesQueryValue;+ attributesQueryValue,+ teamId: 1,+ orgId,+ });- const { teamMembersMatchingAttributeLogic: result } = await findTeamMembersMatchingAttributeLogic({- dynamicFieldValueOperands: {- fields: [],- response: {},- },- attributesQueryValue,- teamId: 1,- orgId,+ // Should match both users:+ // User 1: matches because they service Chennai (the fixed value)+ // User 2: matches because they service Mumbai (the field value)+ expect(result).toEqual(+ expect.arrayContaining([+ { userId: 1, result: RaqbLogicResult.MATCH },+ { userId: 2, result: RaqbLogicResult.MATCH },+ ])+ );});-- expect(result).toEqual([- {- userId: 1,- result: RaqbLogicResult.MATCH,- },- ]);});describe("Fallback", () => {@@ -1025,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/raqbUtils.test.ts b/packages/lib/raqb/raqbUtils.test.tsindex d6ecb5c9cf8..98d4c5005dd 100644--- a/packages/lib/raqb/raqbUtils.test.ts+++ b/packages/lib/raqb/raqbUtils.test.ts@@ -1,6 +1,165 @@-import { expect, describe, it } from "vitest";+import { expect, describe, it, vi } from "vitest";-import { getValueOfAttributeOption } from "./raqbUtils";+import type { AttributesQueryValue, RaqbChild } from "@calcom/lib/raqb/types";+import type { Attribute } from "@calcom/lib/service/attribute/server/getAttributes";+import { AttributeType } from "@calcom/prisma/enums";+import { RoutingFormFieldType } from "@calcom/routing-forms/lib/FieldTypes";++import { getValueOfAttributeOption, acrossQueryValueCompatiblity } from "./raqbUtils";++const { resolveQueryValue } = acrossQueryValueCompatiblity;++// Mock the getFieldResponseValueAsLabel+vi.mock("@calcom/app-store/routing-forms/lib/getFieldResponseValueAsLabel", () => ({+ getFieldResponseValueAsLabel: ({ fieldResponseValue }: { field: any; fieldResponseValue: any }) => {+ // For testing, just return the value as-is+ return fieldResponseValue;+ },+}));++// Test Data Builders for AttributesQueryValue+const createQueryValueRule = (overrides?: Partial<RaqbChild>): RaqbChild => ({+ type: "rule",+ properties: {+ field: "default-field",+ operator: "select_equals",+ value: ["default-value"],+ valueSrc: ["value"],+ valueError: [null],+ valueType: ["select"],+ },+ ...overrides,+});++const createAttributesQueryValue = (overrides?: {+ id?: string;+ type?: "group" | "switch_group";+ children1?: Record<string, RaqbChild>;+ properties?: any;+}): AttributesQueryValue => ({+ id: overrides?.id || "test-id",+ type: overrides?.type || "group",+ children1: overrides?.children1 || {},+ properties: overrides?.properties,+});++const createQueryValueWithRule = ({+ ruleId,+ field,+ operator,+ value,+ valueSrc = ["value"],+ valueError = [null],+ valueType = ["select"],+}: {+ ruleId: string;+ field: string;+ operator: string;+ value: any[];+ valueSrc?: string[];+ valueError?: (string | null)[];+ valueType?: string[];+}): AttributesQueryValue => {+ return createAttributesQueryValue({+ children1: {+ [ruleId]: createQueryValueRule({+ type: "rule",+ properties: {+ field,+ operator,+ value,+ valueSrc,+ valueError,+ valueType,+ },+ }),+ },+ });+};++const createComplexQueryValue = ({+ id,+ rules,+}: {+ id?: string;+ rules: Array<{+ ruleId: string;+ field: string;+ operator: string;+ value: any[];+ valueSrc?: string[];+ valueError?: (string | null)[];+ valueType?: string[];+ }>;+}): AttributesQueryValue => {+ const children1: Record<string, RaqbChild> = {};++ rules.forEach((rule) => {+ children1[rule.ruleId] = createQueryValueRule({+ type: "rule",+ properties: {+ field: rule.field,+ operator: rule.operator,+ value: rule.value,+ valueSrc: rule.valueSrc || ["value"],+ valueError: rule.valueError || [null],+ valueType: rule.valueType || ["select"],+ },+ });+ });++ return createAttributesQueryValue({+ id,+ children1,+ });+};++const createNestedGroupQueryValue = ({+ groups,+}: {+ groups: Array<{+ groupId: string;+ rules: Array<{+ ruleId: string;+ field: string;+ operator?: string;+ value: any[];+ valueSrc?: string[];+ valueError?: (string | null)[];+ valueType?: string[];+ }>;+ }>;+}): AttributesQueryValue => {+ const children1: Record<string, RaqbChild> = {};++ groups.forEach((group) => {+ const groupChildren: Record<string, RaqbChild> = {};++ group.rules.forEach((rule) => {+ groupChildren[rule.ruleId] = createQueryValueRule({+ type: "rule",+ properties: {+ field: rule.field,+ operator: rule.operator || "select_equals",+ value: rule.value,+ valueSrc: rule.valueSrc || ["value"],+ valueError: rule.valueError || [null],+ valueType: rule.valueType || ["select"],+ },+ });+ });++ children1[group.groupId] = {+ type: "group",+ children1: groupChildren,+ } as RaqbChild;+ });++ return createAttributesQueryValue({+ type: "group",+ children1,+ });+};describe("getValueOfAttributeOption", () => {it("should return non-array value for non-array input - It is a requirement for RAQB to not unnecessarily transform single value to an array of one item", () => {@@ -88,3 +247,1528 @@ describe("getValueOfAttributeOption", () => {expect(result).toEqual([]);});});++describe("resolveQueryValue", () => {+ const mockFields = [+ { id: "location", type: RoutingFormFieldType.MULTI_SELECT, label: "Location", options: [] },+ { id: "city", type: RoutingFormFieldType.SINGLE_SELECT, label: "City", options: [] },+ ];++ // Mock attributes for testing+ const mockAttributes: Attribute[] = [+ {+ id: "attr-1",+ name: "Location",+ slug: "location",+ type: AttributeType.MULTI_SELECT,+ options: [+ { id: "opt-1", value: "New York", slug: "new-york" },+ { id: "opt-2", value: "London", slug: "london" },+ ],+ },+ {+ id: "attr-2",+ name: "City",+ slug: "city",+ type: AttributeType.SINGLE_SELECT,+ options: [+ { id: "opt-3", value: "Mumbai", slug: "mumbai" },+ { id: "opt-4", value: "Delhi", slug: "delhi" },+ ],+ },+ ];++ describe("attribute option ID replacement", () => {+ it("should replace attribute option IDs with lowercase values", () => {+ const queryValue = createQueryValueWithRule({+ ruleId: "rule1",+ field: "attr-1",+ operator: "select_equals",+ value: ["opt-1"],+ });++ const result = resolveQueryValue({+ queryValue,+ dynamicFieldValueOperands: undefined,+ attributes: mockAttributes,+ });++ expect(result).toEqual(+ expect.objectContaining({+ children1: {+ rule1: {+ type: "rule",+ properties: expect.objectContaining({+ field: "attr-1",+ operator: "select_equals",+ value: ["new york"], // Should be lowercase+ }),+ },+ },+ })+ );+ });++ it("should replace multiple attribute option IDs in the same value array", () => {+ const queryValue = createQueryValueWithRule({+ ruleId: "rule1",+ field: "attr-1",+ operator: "multiselect_some_in",+ value: [["opt-1", "opt-2", "opt-3", "opt-4"]],+ valueType: ["multiselect"],+ });++ const result = resolveQueryValue({+ queryValue,+ dynamicFieldValueOperands: undefined,+ attributes: mockAttributes,+ });++ expect(result).toEqual(+ expect.objectContaining({+ children1: {+ rule1: {+ type: "rule",+ properties: expect.objectContaining({+ field: "attr-1",+ operator: "multiselect_some_in",+ value: [["new york", "london", "mumbai", "delhi"]],+ }),+ },+ },+ })+ );+ });++ it("should handle attribute option IDs in nested rules", () => {+ const queryValue = createComplexQueryValue({+ rules: [+ {+ ruleId: "rule1",+ field: "attr-1",+ operator: "select_equals",+ value: ["opt-1"],+ },+ {+ ruleId: "rule2",+ field: "attr-2",+ operator: "select_equals",+ value: ["opt-3"],+ },+ ],+ });++ const result = resolveQueryValue({+ queryValue,+ dynamicFieldValueOperands: undefined,+ attributes: mockAttributes,+ });++ expect(result).toEqual(+ expect.objectContaining({+ children1: {+ rule1: {+ type: "rule",+ properties: expect.objectContaining({+ value: ["new york"],+ }),+ },+ rule2: {+ type: "rule",+ properties: expect.objectContaining({+ value: ["mumbai"],+ }),+ },+ },+ })+ );+ });++ it("should replace attribute option IDs before processing field templates", () => {+ const queryValue = createQueryValueWithRule({+ ruleId: "rule1",+ field: "attr-1",+ operator: "multiselect_some_in",+ value: [["opt-1", "{field:location}"]],+ valueType: ["multiselect"],+ });++ const result = resolveQueryValue({+ queryValue,+ dynamicFieldValueOperands: {+ fields: mockFields,+ response: {+ location: { value: ["Paris"], label: "Paris" },+ },+ },+ attributes: mockAttributes,+ });++ expect(result).toEqual(+ expect.objectContaining({+ children1: {+ rule1: {+ type: "rule",+ properties: expect.objectContaining({+ value: [["new york", "paris"]], // opt-1 replaced with "new york", field template with "paris"+ }),+ },+ },+ })+ );+ });++ it("should handle attribute option IDs with special characters", () => {+ const specialAttributes: Attribute[] = [+ {+ id: "attr-special",+ name: "Special",+ slug: "special",+ type: AttributeType.SINGLE_SELECT,+ options: [+ { id: "opt-special-1", value: "São Paulo", slug: "sao-paulo" },+ { id: "opt-special-2", value: "Zürich", slug: "zurich" },+ ],+ },+ ];++ const queryValue = createQueryValueWithRule({+ ruleId: "rule1",+ field: "attr-special",+ operator: "select_equals",+ value: ["opt-special-1"],+ });++ const result = resolveQueryValue({+ queryValue,+ dynamicFieldValueOperands: undefined,+ attributes: specialAttributes,+ });++ expect(result).toEqual(+ expect.objectContaining({+ children1: {+ rule1: {+ type: "rule",+ properties: expect.objectContaining({+ value: ["são paulo"], // Should preserve special characters but be lowercase+ }),+ },+ },+ })+ );+ });++ it("should not replace IDs that don't match any attribute options", () => {+ const queryValue = createQueryValueWithRule({+ ruleId: "rule1",+ field: "attr-1",+ operator: "select_equals",+ value: ["non-existent-id", "opt-1"],+ });++ const result = resolveQueryValue({+ queryValue,+ dynamicFieldValueOperands: undefined,+ attributes: mockAttributes,+ });++ expect(result).toEqual(+ expect.objectContaining({+ children1: {+ rule1: {+ type: "rule",+ properties: expect.objectContaining({+ value: ["non-existent-id", "new york"], // Only opt-1 should be replaced+ }),+ },+ },+ })+ );+ });++ it("should handle empty attributes array", () => {+ const queryValue = createQueryValueWithRule({+ ruleId: "rule1",+ field: "attr-1",+ operator: "select_equals",+ value: ["opt-1"],+ });++ const result = resolveQueryValue({+ queryValue,+ dynamicFieldValueOperands: undefined,+ attributes: [], // No attributes+ });++ expect(result).toEqual(+ expect.objectContaining({+ children1: {+ rule1: {+ type: "rule",+ properties: expect.objectContaining({+ value: ["opt-1"], // Should remain unchanged+ }),+ },+ },+ })+ );+ });++ it("should handle attributes with no options", () => {+ const attributesWithoutOptions: Attribute[] = [+ {+ id: "attr-no-options",+ name: "No Options",+ slug: "no-options",+ type: AttributeType.TEXT,+ options: [], // Empty options array+ },+ ];++ const queryValue = createQueryValueWithRule({+ ruleId: "rule1",+ field: "attr-no-options",+ operator: "text_equals",+ value: ["some-value"],+ });++ const result = resolveQueryValue({+ queryValue,+ dynamicFieldValueOperands: undefined,+ attributes: attributesWithoutOptions,+ });++ expect(result).toEqual(+ expect.objectContaining({+ children1: {+ rule1: {+ type: "rule",+ properties: expect.objectContaining({+ value: ["some-value"], // Should remain unchanged+ }),+ },+ },+ })+ );+ });++ it("should replace option IDs in complex nested group structures", () => {+ const queryValue = createNestedGroupQueryValue({+ groups: [+ {+ groupId: "group1",+ rules: [+ {+ ruleId: "rule1",+ field: "attr-1",+ operator: "multiselect_some_in",+ value: [["opt-1", "opt-2"]],+ valueType: ["multiselect"],+ },+ {+ ruleId: "rule2",+ field: "attr-2",+ operator: "select_equals",+ value: ["opt-3"],+ },+ ],+ },+ ],+ });++ const result = resolveQueryValue({+ queryValue,+ dynamicFieldValueOperands: undefined,+ attributes: mockAttributes,+ });++ expect(result).toEqual(+ expect.objectContaining({+ children1: {+ group1: {+ type: "group",+ children1: {+ rule1: {+ type: "rule",+ properties: expect.objectContaining({+ value: [["new york", "london"]],+ }),+ },+ rule2: {+ type: "rule",+ properties: expect.objectContaining({+ value: ["mumbai"],+ }),+ },+ },+ },+ },+ })+ );+ });++ it("should handle option IDs mixed with field templates in double-nested arrays", () => {+ const queryValue = createQueryValueWithRule({+ ruleId: "rule1",+ field: "attr-1",+ operator: "multiselect_some_in",+ value: [["opt-1", "{field:city}", "opt-2", "{field:location}"]],+ valueType: ["multiselect"],+ });++ const result = resolveQueryValue({+ queryValue,+ dynamicFieldValueOperands: {+ fields: mockFields,+ response: {+ city: { value: "Tokyo", label: "Tokyo" },+ location: { value: ["Berlin", "Paris"], label: "Berlin, Paris" },+ },+ },+ attributes: mockAttributes,+ });++ expect(result).toEqual(+ expect.objectContaining({+ children1: {+ rule1: {+ type: "rule",+ properties: expect.objectContaining({+ value: [["new york", "tokyo", "london", "berlin", "paris"]],+ }),+ },+ },+ })+ );+ });+ });++ it("should handle simple field template replacement with single value", () => {+ const queryValue = createQueryValueWithRule({+ ruleId: "a8a89bba",+ field: "city",+ operator: "select_equals",+ value: ["{field:city}"],+ });++ const result = resolveQueryValue({+ queryValue,+ dynamicFieldValueOperands: {+ fields: mockFields,+ response: {+ city: { label: "Mumbai", value: "Mumbai" },+ },+ },+ attributes: mockAttributes,+ });++ expect(result).toEqual(+ expect.objectContaining({+ children1: {+ a8a89bba: {+ type: "rule",+ properties: expect.objectContaining({+ field: "city",+ operator: "select_equals",+ value: ["mumbai"],+ }),+ },+ },+ })+ );+ });++ it("should handle field template in double-nested array for multiselect", () => {+ const queryValue = createQueryValueWithRule({+ ruleId: "rule1",+ field: "location",+ operator: "multiselect_some_in",+ value: [["{field:location}"]],+ valueType: ["multiselect"],+ });++ const result = resolveQueryValue({+ queryValue,+ dynamicFieldValueOperands: {+ fields: mockFields,+ response: {+ location: { label: "Delhi", value: "Delhi" },+ },+ },+ attributes: mockAttributes,+ });++ expect(result).toEqual(+ expect.objectContaining({+ children1: {+ rule1: {+ type: "rule",+ properties: expect.objectContaining({+ field: "location",+ operator: "multiselect_some_in",+ value: [["delhi"]],+ }),+ },+ },+ })+ );+ });++ it("should handle mixed array with field template and regular values", () => {+ const queryValue = {+ children1: {+ rule1: {+ type: "rule",+ properties: {+ field: "location",+ operator: "multiselect_some_in",+ value: [["{field:location}", "Chennai"]],+ },+ },+ },+ } as unknown as AttributesQueryValue;++ const result = resolveQueryValue({+ queryValue,+ dynamicFieldValueOperands: {+ fields: mockFields,+ response: {+ location: { value: "Delhi", label: "Delhi" }, // Single value, not array+ },+ },+ attributes: mockAttributes,+ });++ expect(result).toEqual(+ expect.objectContaining({+ children1: {+ rule1: {+ type: "rule",+ properties: {+ field: "location",+ operator: "multiselect_some_in",+ value: [["delhi", "Chennai"]], // Single value replaced+ },+ },+ },+ })+ );+ });++ it("should handle multiple field templates in the same array", () => {+ const queryValue = {+ children1: {+ rule1: {+ type: "rule",+ properties: {+ field: "multifield",+ operator: "multiselect_some_in",+ value: [["{field:location}", "{field:city}"]],+ },+ },+ },+ } as unknown as AttributesQueryValue;++ const result = resolveQueryValue({+ queryValue,+ dynamicFieldValueOperands: {+ fields: mockFields,+ response: {+ location: { value: ["Delhi"], label: "Delhi" },+ city: { value: "Mumbai", label: "Mumbai" },+ },+ },+ attributes: mockAttributes,+ });++ expect(result).toEqual(+ expect.objectContaining({+ children1: {+ rule1: {+ type: "rule",+ properties: {+ field: "multifield",+ operator: "multiselect_some_in",+ value: [["delhi", "mumbai"]],+ },+ },+ },+ })+ );+ });++ it("should handle field template with no response value", () => {+ const queryValue = {+ children1: {+ rule1: {+ type: "rule",+ properties: {+ field: "location",+ operator: "select_equals",+ value: ["{field:location}"],+ },+ },+ },+ } as unknown as AttributesQueryValue;++ const result = resolveQueryValue({+ queryValue,+ dynamicFieldValueOperands: {+ fields: mockFields,+ response: {}, // No response for location field+ },+ attributes: mockAttributes,+ });++ expect(result).toEqual(+ expect.objectContaining({+ children1: {+ rule1: {+ type: "rule",+ properties: {+ field: "location",+ operator: "select_equals",+ value: ["{field:location}"], // Should remain unchanged+ },+ },+ },+ })+ );+ });++ it("should handle field template with unknown field", () => {+ const queryValue = {+ children1: {+ rule1: {+ type: "rule",+ properties: {+ field: "unknown",+ operator: "select_equals",+ value: ["{field:unknown}"],+ },+ },+ },+ } as unknown as AttributesQueryValue;++ const result = resolveQueryValue({+ queryValue,+ dynamicFieldValueOperands: {+ fields: mockFields,+ response: {+ unknown: { value: "test", label: "test" },+ },+ },+ attributes: mockAttributes,+ });++ expect(result).toEqual(+ expect.objectContaining({+ children1: {+ rule1: {+ type: "rule",+ properties: {+ field: "unknown",+ operator: "select_equals",+ value: ["{field:unknown}"], // Should remain unchanged+ },+ },+ },+ })+ );+ });++ it("should handle complex nested structure", () => {+ const queryValue = createAttributesQueryValue({+ id: "test",+ type: "group",+ children1: {+ rule1: createQueryValueRule({+ type: "rule",+ properties: {+ field: "attr1",+ operator: "multiselect_some_in",+ value: [["{field:location}", "Fixed-Value"]],+ valueType: ["multiselect"],+ },+ }),+ },+ });++ const result = resolveQueryValue({+ queryValue,+ dynamicFieldValueOperands: {+ fields: mockFields,+ response: {+ location: { value: ["Delhi", "Haryana"], label: "Delhi, Haryana" },+ },+ },+ attributes: mockAttributes,+ });++ expect(result).toEqual(+ expect.objectContaining({+ id: "test",+ type: "group",+ children1: {+ rule1: {+ type: "rule",+ properties: expect.objectContaining({+ field: "attr1",+ value: [["delhi", "haryana", "Fixed-Value"]],+ operator: "multiselect_some_in",+ }),+ },+ },+ })+ );+ });++ it("should handle empty array values", () => {+ const queryValue = {+ children1: {+ rule1: {+ type: "rule",+ properties: {+ field: "location",+ operator: "multiselect_some_in",+ value: [["{field:location}"]],+ },+ },+ },+ } as unknown as AttributesQueryValue;++ const result = resolveQueryValue({+ queryValue,+ dynamicFieldValueOperands: {+ fields: mockFields,+ response: {+ location: { value: [], label: "" }, // Empty array+ },+ },+ attributes: mockAttributes,+ });++ expect(result).toEqual(+ expect.objectContaining({+ children1: {+ rule1: {+ type: "rule",+ properties: {+ field: "location",+ operator: "multiselect_some_in",+ value: [[]], // Should be empty array+ },+ },+ },+ })+ );+ });++ it("should handle no dynamicFieldValueOperands", () => {+ const queryValue = {+ children1: {+ rule1: {+ type: "rule",+ properties: {+ field: "location",+ value: ["{field:location}"],+ },+ },+ },+ } as unknown as AttributesQueryValue;++ const result = resolveQueryValue({+ queryValue,+ dynamicFieldValueOperands: undefined,+ attributes: mockAttributes,+ });++ expect(result).toEqual(queryValue); // Should return unchanged+ });++ it("should preserve case for non-template values in mixed arrays", () => {+ const queryValue = {+ children1: {+ rule1: {+ type: "rule",+ properties: {+ field: "location",+ operator: "multiselect_some_in",+ value: [["{field:location}", "Chennai", "MUMBAI"]],+ },+ },+ },+ } as unknown as AttributesQueryValue;++ const result = resolveQueryValue({+ queryValue,+ dynamicFieldValueOperands: {+ fields: mockFields,+ response: {+ location: { value: ["Delhi"], label: "Delhi" },+ },+ },+ attributes: mockAttributes,+ });++ expect(result).toEqual(+ expect.objectContaining({+ children1: {+ rule1: {+ type: "rule",+ properties: {+ field: "location",+ operator: "multiselect_some_in",+ value: [["delhi", "Chennai", "MUMBAI"]], // Only field template value is lowercased+ },+ },+ },+ })+ );+ });++ it("should handle deeply nested field templates", () => {+ const queryValue = createNestedGroupQueryValue({+ groups: [+ {+ groupId: "group1",+ rules: [+ {+ ruleId: "rule1",+ field: "location",+ value: [["{field:location}", "Fixed1"]],+ valueType: ["multiselect"],+ },+ {+ ruleId: "rule2",+ field: "city",+ value: [["{field:city}", "Fixed2"]],+ valueType: ["multiselect"],+ },+ ],+ },+ ],+ });++ const result = resolveQueryValue({+ queryValue,+ dynamicFieldValueOperands: {+ fields: mockFields,+ response: {+ location: { value: ["Delhi", "Mumbai"], label: "Delhi, Mumbai" },+ city: { value: "Chennai", label: "Chennai" },+ },+ },+ attributes: mockAttributes,+ });++ expect(result).toEqual(+ expect.objectContaining({+ type: "group",+ children1: {+ group1: {+ type: "group",+ children1: {+ rule1: {+ type: "rule",+ properties: expect.objectContaining({+ field: "location",+ value: [["delhi", "mumbai", "Fixed1"]],+ }),+ },+ rule2: {+ type: "rule",+ properties: expect.objectContaining({+ field: "city",+ value: [["chennai", "Fixed2"]],+ }),+ },+ },+ },+ },+ })+ );+ });++ it("should handle field template with array containing special characters", () => {+ const queryValue = {+ children1: {+ rule1: {+ type: "rule",+ properties: {+ field: "location",+ value: [["{field:location}"]],+ },+ },+ },+ } as unknown as AttributesQueryValue;++ const result = resolveQueryValue({+ queryValue,+ dynamicFieldValueOperands: {+ fields: mockFields,+ response: {+ location: { value: ["New York", "São Paulo", "Zürich"], label: "New York, São Paulo, Zürich" },+ },+ },+ attributes: mockAttributes,+ });++ expect(result).toEqual(+ expect.objectContaining({+ children1: {+ rule1: {+ type: "rule",+ properties: {+ field: "location",+ value: [["new york", "são paulo", "zürich"]],+ },+ },+ },+ })+ );+ });++ it("should handle field template in arrays at different nesting levels", () => {+ const queryValue = {+ children1: {+ rule1: {+ type: "rule",+ properties: {+ field: "city",+ value: ["{field:city}"], // Single nested+ },+ },+ rule2: {+ type: "rule",+ properties: {+ field: "location",+ value: [["{field:location}"]], // Double nested+ },+ },+ rule3: {+ type: "rule",+ properties: {+ field: "city",+ value: [[["{field:city}"]]], // Triple nested+ },+ },+ },+ } as unknown as AttributesQueryValue;++ const result = resolveQueryValue({+ queryValue,+ dynamicFieldValueOperands: {+ fields: mockFields,+ response: {+ location: { value: ["Delhi"], label: "Delhi" },+ city: { value: "Mumbai", label: "Mumbai" },+ },+ },+ attributes: mockAttributes,+ });++ expect(result).toEqual(+ expect.objectContaining({+ children1: {+ rule1: {+ type: "rule",+ properties: {+ field: "city",+ value: ["mumbai"],+ },+ },+ rule2: {+ type: "rule",+ properties: {+ field: "location",+ value: [["delhi"]],+ },+ },+ rule3: {+ type: "rule",+ properties: {+ field: "city",+ value: [[["mumbai"]]],+ },+ },+ },+ })+ );+ });++ it("should handle null and undefined values gracefully", () => {+ const queryValue = {+ children1: {+ rule1: {+ type: "rule",+ properties: {+ field: "mixed",+ value: [["{field:location}", null, "{field:city}"]],+ },+ },+ },+ } as unknown as AttributesQueryValue;++ const result = resolveQueryValue({+ queryValue,+ dynamicFieldValueOperands: {+ fields: mockFields,+ response: {+ location: { value: ["Delhi"], label: "Delhi" },+ city: { value: null as any, label: "" }, // null value+ },+ },+ attributes: mockAttributes,+ });++ expect(result).toEqual(+ expect.objectContaining({+ children1: {+ rule1: {+ type: "rule",+ properties: {+ field: "mixed",+ value: [["delhi", null, "{field:city}"]], // city remains as template due to null value+ },+ },+ },+ })+ );+ });++ it("should handle numeric values from fields", () => {+ const numericFields = [+ { id: "age", type: RoutingFormFieldType.NUMBER, label: "Age", options: [] },+ { id: "count", type: RoutingFormFieldType.NUMBER, label: "Count", options: [] },+ ];++ const queryValue = {+ children1: {+ rule1: {+ type: "rule",+ properties: {+ field: "numbers",+ value: [["{field:age}", "{field:count}", 42]],+ },+ },+ },+ } as unknown as AttributesQueryValue;++ const result = resolveQueryValue({+ queryValue,+ dynamicFieldValueOperands: {+ fields: numericFields,+ response: {+ age: { value: 25, label: "25" },+ count: { value: 100, label: "100" },+ },+ },+ attributes: mockAttributes,+ });++ expect(result).toEqual(+ expect.objectContaining({+ children1: {+ rule1: {+ type: "rule",+ properties: {+ field: "numbers",+ value: [["25", "100", 42]],+ },+ },+ },+ })+ );+ });++ it("should handle very large arrays efficiently", () => {+ const largeArray = new Array(100).fill("item");+ const queryValue = {+ children1: {+ rule1: {+ type: "rule",+ properties: {+ field: "location",+ value: [["{field:location}", ...largeArray]],+ },+ },+ },+ } as unknown as AttributesQueryValue;++ const result = resolveQueryValue({+ queryValue,+ dynamicFieldValueOperands: {+ fields: mockFields,+ response: {+ location: { value: ["Delhi", "Mumbai"], label: "Delhi, Mumbai" },+ },+ },+ attributes: mockAttributes,+ });++ expect(result.children1?.rule1.properties?.value[0]).toHaveLength(102); // 2 from field + 100 items+ expect(result.children1?.rule1.properties?.value[0].slice(0, 2)).toEqual(["delhi", "mumbai"]);+ });++ it("should handle edge case with empty string field values", () => {+ const queryValue = {+ children1: {+ rule1: {+ type: "rule",+ properties: {+ field: "location",+ value: [["{field:location}"]],+ },+ },+ },+ } as unknown as AttributesQueryValue;++ const result = resolveQueryValue({+ queryValue,+ dynamicFieldValueOperands: {+ fields: mockFields,+ response: {+ location: { value: ["", " ", "Delhi"], label: ", , Delhi" }, // Empty and whitespace strings+ },+ },+ attributes: mockAttributes,+ });++ expect(result).toEqual(+ expect.objectContaining({+ children1: {+ rule1: {+ type: "rule",+ properties: {+ field: "location",+ value: [["", " ", "delhi"]],+ },+ },+ },+ })+ );+ });++ it("should handle field templates with hyphens and underscores in field names", () => {+ const specialFields = [+ { id: "field-with-dashes", type: RoutingFormFieldType.TEXT, label: "Dashed Field", options: [] },+ {+ id: "field_with_underscores",+ type: RoutingFormFieldType.TEXT,+ label: "Underscored Field",+ options: [],+ },+ ];++ const queryValue = {+ children1: {+ rule1: {+ type: "rule",+ properties: {+ field: "special",+ value: ["{field:field-with-dashes}", "{field:field_with_underscores}"],+ },+ },+ },+ } as unknown as AttributesQueryValue;++ const result = resolveQueryValue({+ queryValue,+ dynamicFieldValueOperands: {+ fields: specialFields,+ response: {+ "field-with-dashes": { value: "Value2", label: "Value2" },+ field_with_underscores: { value: "Value3", label: "Value3" },+ },+ },+ attributes: mockAttributes,+ });++ expect(result).toEqual(+ expect.objectContaining({+ children1: {+ rule1: {+ type: "rule",+ properties: {+ field: "special",+ value: ["value2", "value3"],+ },+ },+ },+ })+ );+ });++ it("should handle mixed field templates and fixed values in complex scenarios", () => {+ const queryValue = {+ children1: {+ group1: {+ type: "rule",+ properties: {+ field: "mixed1",+ value: [["{field:location}", "Fixed1", "{field:city}"]],+ },+ },+ group2: {+ type: "rule",+ properties: {+ field: "mixed2",+ value: [["Fixed2", "{field:location}"]],+ },+ },+ group3: {+ type: "rule",+ properties: {+ field: "mixed3",+ value: [["{field:city}", "{field:location}", "Fixed3", "{field:city}"]],+ },+ },+ },+ } as unknown as AttributesQueryValue;++ const result = resolveQueryValue({+ queryValue,+ dynamicFieldValueOperands: {+ fields: mockFields,+ response: {+ location: { value: ["Delhi", "Mumbai"], label: "Delhi, Mumbai" },+ city: { value: "Chennai", label: "Chennai" },+ },+ },+ attributes: mockAttributes,+ });++ expect(result).toEqual(+ expect.objectContaining({+ children1: {+ group1: {+ type: "rule",+ properties: {+ field: "mixed1",+ value: [["delhi", "mumbai", "Fixed1", "chennai"]],+ },+ },+ group2: {+ type: "rule",+ properties: {+ field: "mixed2",+ value: [["Fixed2", "delhi", "mumbai"]],+ },+ },+ group3: {+ type: "rule",+ properties: {+ field: "mixed3",+ value: [["chennai", "delhi", "mumbai", "Fixed3", "chennai"]],+ },+ },+ },+ })+ );+ });++ it("should handle field templates in different JSON value types", () => {+ const queryValue = {+ children1: {+ rule1: {+ type: "rule",+ properties: {+ field: "city",+ value: "{field:city}",+ },+ },+ rule2: {+ type: "rule",+ properties: {+ field: "city",+ value: ["{field:city}"],+ },+ },+ rule3: {+ type: "rule",+ properties: {+ field: "location",+ value: [["{field:location}"]],+ },+ },+ rule4: {+ type: "rule",+ properties: {+ field: "mixed",+ customProp: "{field:city}",+ nested: {+ value: ["{field:location}"],+ },+ },+ },+ },+ } as unknown as AttributesQueryValue;++ const result = resolveQueryValue({+ queryValue,+ dynamicFieldValueOperands: {+ fields: mockFields,+ response: {+ location: { value: ["Delhi", "Mumbai"], label: "Delhi, Mumbai" },+ city: { value: "Chennai", label: "Chennai" },+ },+ },+ attributes: mockAttributes,+ });++ expect(result).toEqual(+ expect.objectContaining({+ children1: {+ rule1: {+ type: "rule",+ properties: {+ field: "city",+ value: "chennai",+ },+ },+ rule2: {+ type: "rule",+ properties: {+ field: "city",+ value: ["chennai"],+ },+ },+ rule3: {+ type: "rule",+ properties: {+ field: "location",+ value: [["delhi", "mumbai"]],+ },+ },+ rule4: {+ type: "rule",+ properties: {+ field: "mixed",+ customProp: "chennai",+ nested: {+ value: ["delhi", "mumbai"],+ },+ },+ },+ },+ })+ );+ });++ it("should handle empty response object", () => {+ const queryValue = {+ children1: {+ rule1: {+ type: "rule",+ properties: {+ field: "location",+ value: [["{field:location}", "Fixed"]],+ },+ },+ },+ } as unknown as AttributesQueryValue;++ const result = resolveQueryValue({+ queryValue,+ dynamicFieldValueOperands: {+ fields: mockFields,+ response: {}, // Empty response+ },+ attributes: mockAttributes,+ });++ expect(result).toEqual(+ expect.objectContaining({+ children1: {+ rule1: {+ type: "rule",+ properties: {+ field: "location",+ value: [["{field:location}", "Fixed"]], // Template unchanged+ },+ },+ },+ })+ );+ });++ it("should handle response with empty field value object", () => {+ const queryValue = {+ children1: {+ rule1: {+ type: "rule",+ properties: {+ field: "location",+ value: [["{field:location}"]],+ },+ },+ },+ } as unknown as AttributesQueryValue;++ const result = resolveQueryValue({+ queryValue,+ dynamicFieldValueOperands: {+ fields: mockFields,+ response: {+ location: {} as any, // Empty object, no value property+ },+ },+ attributes: mockAttributes,+ });++ expect(result).toEqual(+ expect.objectContaining({+ children1: {+ rule1: {+ type: "rule",+ properties: {+ field: "location",+ value: [["{field:location}"]], // Template unchanged+ },+ },+ },+ })+ );+ });++ it("should handle multiple occurrences of the same field template", () => {+ const queryValue = {+ children1: {+ rule1: {+ type: "rule",+ properties: {+ field: "city",+ value: ["{field:city}"],+ },+ },+ rule2: {+ type: "rule",+ properties: {+ field: "city",+ value: ["{field:city}"],+ },+ },+ rule3: {+ type: "rule",+ properties: {+ field: "city",+ value: [["{field:city}", "{field:city}"]],+ },+ },+ },+ } as unknown as AttributesQueryValue;++ const result = resolveQueryValue({+ queryValue,+ dynamicFieldValueOperands: {+ fields: mockFields,+ response: {+ city: { value: "Mumbai", label: "Mumbai" },+ },+ },+ attributes: mockAttributes,+ });++ expect(result).toEqual(+ expect.objectContaining({+ children1: {+ rule1: {+ type: "rule",+ properties: {+ field: "city",+ value: ["mumbai"],+ },+ },+ rule2: {+ type: "rule",+ properties: {+ field: "city",+ value: ["mumbai"],+ },+ },+ rule3: {+ type: "rule",+ properties: {+ field: "city",+ value: [["mumbai", "mumbai"]],+ },+ },+ },+ })+ );+ });++ it("should handle invalid query structure gracefully", () => {+ // Test with an invalid query structure+ const invalidQueryValue = null as unknown as AttributesQueryValue;++ const result = resolveQueryValue({+ queryValue: invalidQueryValue,+ dynamicFieldValueOperands: {+ fields: mockFields,+ response: {+ city: { value: "Mumbai", label: "Mumbai" },+ },+ },+ attributes: mockAttributes,+ });++ expect(result).toBeNull();+ });++ it("should handle valid JSON that causes processing errors gracefully", () => {+ const queryValue = {+ children1: {+ rule1: {+ type: "rule",+ properties: {+ field: "nonexistent",+ value: ["{field:nonexistent}"],+ },+ },+ rule2: {+ type: "rule",+ properties: {+ field: "city",+ customField: "{field:city}",+ },+ },+ },+ } as unknown as AttributesQueryValue;++ const result = resolveQueryValue({+ queryValue,+ dynamicFieldValueOperands: {+ fields: mockFields,+ response: {+ city: { value: "Mumbai", label: "Mumbai" },+ },+ },+ attributes: mockAttributes,+ });++ // Non-existent field should remain as-is, existing field should be resolved+ expect(result).toEqual(+ expect.objectContaining({+ children1: {+ rule1: {+ type: "rule",+ properties: {+ field: "nonexistent",+ value: ["{field:nonexistent}"],+ },+ },+ rule2: {+ type: "rule",+ properties: {+ field: "city",+ customField: "mumbai",+ },+ },+ },+ })+ );+ });+});diff --git a/packages/lib/raqb/raqbUtils.ts b/packages/lib/raqb/raqbUtils.tsindex 5b72019717a..d6fdbfd6200 100644--- a/packages/lib/raqb/raqbUtils.ts+++ b/packages/lib/raqb/raqbUtils.ts@@ -4,9 +4,7 @@ import { Utils as QbUtils } from "react-awesome-query-builder";import { getQueryBuilderConfigForAttributes } from "@calcom/app-store/routing-forms/lib/getQueryBuilderConfig";import type { LocalRoute } from "@calcom/app-store/routing-forms/types/types";-import logger from "@calcom/lib/logger";-import type { dynamicFieldValueOperands, dynamicFieldValueOperandsResponse } from "@calcom/lib/raqb/types";-import type { AttributesQueryValue } from "@calcom/lib/raqb/types";+import type { dynamicFieldValueOperands } from "@calcom/lib/raqb/types";import { safeStringify } from "@calcom/lib/safeStringify";import type {AttributeOptionValueWithType,@@ -15,61 +13,13 @@ import type {} from "@calcom/lib/service/attribute/server/getAttributes";import { AttributeType } from "@calcom/prisma/enums";-const moduleLogger = logger.getSubLogger({ prefix: ["routing-forms/lib/raqbUtils"] });--function getFieldResponseValueAsLabel({- field,- fieldResponseValue,-}: {- fieldResponseValue: dynamicFieldValueOperandsResponse[keyof dynamicFieldValueOperandsResponse]["value"];- field: {- type: string;- options?: {- id: string | null;- label: string;- }[];- };-}) {- if (!field.options) {- return fieldResponseValue;- }-- const valueArray = fieldResponseValue instanceof Array ? fieldResponseValue : [fieldResponseValue];-- const chosenOptions = valueArray.map((idOrLabel) => {- const foundOptionById = field.options?.find((option) => {- return option.id === idOrLabel;- });- if (foundOptionById) {- return {- label: foundOptionById.label,- id: foundOptionById.id,- };- } else {- return {- label: idOrLabel.toString(),- id: null,- };- }- });-- return chosenOptions.map((option) => option.label);-}+import { resolveQueryValue } from "./resolveQueryValue";+import { caseInsensitive } from "./utils";function ensureArray(value: string | string[]) {return typeof value === "string" ? [value] : value;}-function caseInsensitive<T extends string | string[]>(- stringOrStringArray: T-): T extends string[] ? string[] : string {- return (- stringOrStringArray instanceof Array- ? stringOrStringArray.map((string) => string.toLowerCase())- : stringOrStringArray.toLowerCase()- ) as T extends string[] ? string[] : string;-}-export const raqbQueryValueUtils = {isQueryValueARuleGroup: function isQueryValueARuleGroup(queryValue: JsonTree): queryValue is JsonGroup {return queryValue.type === "group";@@ -144,61 +94,6 @@ export const buildStateFromQueryValue = ({};};-/**- * Replace attribute option Ids with the attribute option label(compatible to be matched with form field value)- */-const replaceAttributeOptionIdsWithOptionLabel = ({- queryValueString,- attributes,-}: {- queryValueString: string;- attributes: Attribute[];-}) => {- const allAttributesOptions = attributes.map((attribute) => attribute.options).flat();- // Because all attribute option Ids are unique, we can reliably identify them along any number of attribute options of different attributes- allAttributesOptions.forEach((attributeOption) => {- const attributeOptionId = attributeOption.id;- queryValueString = queryValueString.replace(- new RegExp(`${attributeOptionId}`, "g"),- caseInsensitive(attributeOption.value)- );- });- return queryValueString;-};--/**- * Replace {field:<fieldId>} with the field label(compatible to be matched with attribute value)- */-const replaceFieldTemplateVariableWithOptionLabel = ({- queryValueString,- dynamicFieldValueOperands,-}: {- queryValueString: string;- dynamicFieldValueOperands?: dynamicFieldValueOperands;-}) => {- if (!dynamicFieldValueOperands) {- return queryValueString;- }- const { fields, response } = dynamicFieldValueOperands;- return queryValueString.replace(/{field:([\w-]+)}/g, (match, fieldId: string) => {- const field = fields?.find((f) => f.id === fieldId);- if (!field) {- moduleLogger.debug("field not found", safeStringify({ fieldId }));- return match;- }- const fieldResponseValue = response[fieldId]?.value;- if (!fieldResponseValue) {- return match;- }- const responseValueAsLabel = getFieldResponseValueAsLabel({ field, fieldResponseValue });- moduleLogger.debug("matchingOptionLabel", safeStringify({ responseValueAsLabel, response, fieldId }));- if (responseValueAsLabel instanceof Array && responseValueAsLabel.length > 1) {- throw new Error("Array value not supported with 'Value of field'");- }- return responseValueAsLabel ? caseInsensitive(responseValueAsLabel.toString()) : match;- });-};-export function getValueOfAttributeOption(attributeOptions:| Pick<AttributeOptionValue, "isGroup" | "contains" | "value">@@ -262,17 +157,13 @@ function getAttributesQueryValue({return null;}- const attributesQueryValueCompatibleForMatchingWithFormField: AttributesQueryValue = JSON.parse(- replaceFieldTemplateVariableWithOptionLabel({- queryValueString: replaceAttributeOptionIdsWithOptionLabel({- queryValueString: JSON.stringify(attributesQueryValue),- attributes,- }),- dynamicFieldValueOperands,- })- );+ const resolvedQueryValue = resolveQueryValue({+ queryValue: attributesQueryValue,+ attributes,+ dynamicFieldValueOperands,+ });- return attributesQueryValueCompatibleForMatchingWithFormField;+ return resolvedQueryValue;}/**@@ -329,4 +220,5 @@ export const acrossQueryValueCompatiblity = {getAttributesQueryBuilderConfigHavingListofLabels,getAttributesQueryValue,getAttributesData,+ resolveQueryValue,};diff --git a/packages/lib/raqb/resolveQueryValue.test.ts b/packages/lib/raqb/resolveQueryValue.test.tsnew file mode 100644index 00000000000..d34e2a7030a--- /dev/null+++ b/packages/lib/raqb/resolveQueryValue.test.ts@@ -0,0 +1,1745 @@+import { expect, describe, it } from "vitest";++import type { AttributesQueryValue, RaqbChild } from "@calcom/lib/raqb/types";+import type { Attribute } from "@calcom/lib/service/attribute/server/getAttributes";+import { AttributeType } from "@calcom/prisma/enums";+import { RoutingFormFieldType } from "@calcom/routing-forms/lib/FieldTypes";++import { resolveQueryValue } from "./resolveQueryValue";++// Test Data Builders for AttributesQueryValue+const createQueryValueRule = (overrides?: Partial<RaqbChild>): RaqbChild => ({+ type: "rule",+ properties: {+ field: "default-field",+ operator: "select_equals",+ value: ["default-value"],+ valueSrc: ["value"],+ valueError: [null],+ valueType: ["select"],+ },+ ...overrides,+});++const createAttributesQueryValue = (overrides?: {+ id?: string;+ type?: "group" | "switch_group";+ children1?: Record<string, RaqbChild>;+ properties?: any;+}): AttributesQueryValue => ({+ id: overrides?.id || "test-id",+ type: overrides?.type || "group",+ children1: overrides?.children1 || {},+ properties: overrides?.properties,+});++const createQueryValueWithRule = ({+ ruleId,+ field,+ operator,+ value,+ valueSrc = ["value"],+ valueError = [null],+ valueType = ["select"],+}: {+ ruleId: string;+ field: string;+ operator: string;+ value: any[];+ valueSrc?: string[];+ valueError?: (string | null)[];+ valueType?: string[];+}): AttributesQueryValue => {+ return createAttributesQueryValue({+ children1: {+ [ruleId]: createQueryValueRule({+ type: "rule",+ properties: {+ field,+ operator,+ value,+ valueSrc,+ valueError,+ valueType,+ },+ }),+ },+ });+};++const createComplexQueryValue = ({+ id,+ rules,+}: {+ id?: string;+ rules: Array<{+ ruleId: string;+ field: string;+ operator: string;+ value: any[];+ valueSrc?: string[];+ valueError?: (string | null)[];+ valueType?: string[];+ }>;+}): AttributesQueryValue => {+ const children1: Record<string, RaqbChild> = {};++ rules.forEach((rule) => {+ children1[rule.ruleId] = createQueryValueRule({+ type: "rule",+ properties: {+ field: rule.field,+ operator: rule.operator,+ value: rule.value,+ valueSrc: rule.valueSrc || ["value"],+ valueError: rule.valueError || [null],+ valueType: rule.valueType || ["select"],+ },+ });+ });++ return createAttributesQueryValue({+ id,+ children1,+ });+};++const createNestedGroupQueryValue = ({+ groups,+}: {+ groups: Array<{+ groupId: string;+ rules: Array<{+ ruleId: string;+ field: string;+ operator?: string;+ value: any[];+ valueSrc?: string[];+ valueError?: (string | null)[];+ valueType?: string[];+ }>;+ }>;+}): AttributesQueryValue => {+ const children1: Record<string, RaqbChild> = {};++ groups.forEach((group) => {+ const groupChildren: Record<string, RaqbChild> = {};++ group.rules.forEach((rule) => {+ groupChildren[rule.ruleId] = createQueryValueRule({+ type: "rule",+ properties: {+ field: rule.field,+ operator: rule.operator || "select_equals",+ value: rule.value,+ valueSrc: rule.valueSrc || ["value"],+ valueError: rule.valueError || [null],+ valueType: rule.valueType || ["select"],+ },+ });+ });++ children1[group.groupId] = {+ type: "group",+ children1: groupChildren,+ } as RaqbChild;+ });++ return createAttributesQueryValue({+ type: "group",+ children1,+ });+};++describe("resolveQueryValue", () => {+ const mockFields = [+ {+ id: "location",+ type: RoutingFormFieldType.MULTI_SELECT,+ label: "Location",+ options: [+ { id: "delhi", label: "Delhi" },+ { id: "mumbai", label: "Mumbai" },+ { id: "paris", label: "Paris" },+ { id: "berlin", label: "Berlin" },+ { id: "new-york", label: "New York" },+ { id: "amsterdam", label: "Amsterdam" },+ { id: "haryana", label: "Haryana" },+ { id: "tokyo", label: "Tokyo" },+ { id: "chennai", label: "Chennai" },+ { id: "sao-paulo", label: "São Paulo" },+ { id: "zurich", label: "Zürich" },+ ],+ },+ {+ id: "city",+ type: RoutingFormFieldType.SINGLE_SELECT,+ label: "City",+ options: [+ { id: "mumbai", label: "Mumbai" },+ { id: "delhi", label: "Delhi" },+ { id: "chennai", label: "Chennai" },+ { id: "tokyo", label: "Tokyo" },+ ],+ },+ ];++ // Mock attributes for testing+ const mockAttributes: Attribute[] = [+ {+ id: "attr-1",+ name: "Location",+ slug: "location",+ type: AttributeType.MULTI_SELECT,+ options: [+ { id: "opt-1", value: "New York", slug: "new-york" },+ { id: "opt-2", value: "London", slug: "london" },+ ],+ },+ {+ id: "attr-2",+ name: "City",+ slug: "city",+ type: AttributeType.SINGLE_SELECT,+ options: [+ { id: "opt-3", value: "Mumbai", slug: "mumbai" },+ { id: "opt-4", value: "Delhi", slug: "delhi" },+ ],+ },+ ];++ describe("attribute option ID to label conversion for field matching", () => {+ /**+ * These tests verify that attribute option IDs are replaced with their lowercase labels+ * to enable comparison with form field values that are connected through "Value of Field".+ * Labels are converted to lowercase to ensure case-insensitive matching between+ * attribute options and field values.+ */+ it("converts single option ID to lowercase label", () => {+ const queryValue = createQueryValueWithRule({+ ruleId: "rule1",+ field: "attr-1",+ operator: "select_equals",+ value: ["opt-1"],+ });++ const result = resolveQueryValue({+ queryValue,+ dynamicFieldValueOperands: undefined,+ attributes: mockAttributes,+ });++ expect(result).toEqual(+ expect.objectContaining({+ children1: {+ rule1: {+ type: "rule",+ properties: expect.objectContaining({+ field: "attr-1",+ operator: "select_equals",+ value: ["new york"], // opt-1 -> "New York" -> "new york" for field matching+ }),+ },+ },+ })+ );+ });++ it("converts multiple option IDs to labels in multiselect", () => {+ const queryValue = createQueryValueWithRule({+ ruleId: "rule1",+ field: "attr-1",+ operator: "multiselect_some_in",+ value: [["opt-1", "opt-2", "opt-3", "opt-4"]],+ valueType: ["multiselect"],+ });++ const result = resolveQueryValue({+ queryValue,+ dynamicFieldValueOperands: undefined,+ attributes: mockAttributes,+ });++ expect(result).toEqual(+ expect.objectContaining({+ children1: {+ rule1: {+ type: "rule",+ properties: expect.objectContaining({+ field: "attr-1",+ operator: "multiselect_some_in",+ value: [["new york", "london", "mumbai", "delhi"]], // All IDs converted to lowercase labels+ }),+ },+ },+ })+ );+ });++ it("converts option IDs across multiple rules", () => {+ const queryValue = createComplexQueryValue({+ rules: [+ {+ ruleId: "rule1",+ field: "attr-1",+ operator: "select_equals",+ value: ["opt-1"],+ },+ {+ ruleId: "rule2",+ field: "attr-2",+ operator: "select_equals",+ value: ["opt-3"],+ },+ ],+ });++ const result = resolveQueryValue({+ queryValue,+ dynamicFieldValueOperands: undefined,+ attributes: mockAttributes,+ });++ expect(result).toEqual(+ expect.objectContaining({+ children1: {+ rule1: {+ type: "rule",+ properties: expect.objectContaining({+ value: ["new york"], // opt-1 converted to label+ }),+ },+ rule2: {+ type: "rule",+ properties: expect.objectContaining({+ value: ["mumbai"], // opt-3 converted to label+ }),+ },+ },+ })+ );+ });++ it("converts option IDs before field template resolution", () => {+ const queryValue = createQueryValueWithRule({+ ruleId: "rule1",+ field: "attr-1",+ operator: "multiselect_some_in",+ value: [["opt-1", "{field:location}"]],+ valueType: ["multiselect"],+ });++ const result = resolveQueryValue({+ queryValue,+ dynamicFieldValueOperands: {+ fields: mockFields,+ response: {+ location: { value: ["Paris"], label: "Paris" },+ },+ },+ attributes: mockAttributes,+ });++ expect(result).toEqual(+ expect.objectContaining({+ children1: {+ rule1: {+ type: "rule",+ properties: expect.objectContaining({+ value: [["new york", "paris"]], // Option ID converted first, then field template resolved+ }),+ },+ },+ })+ );+ });++ it("preserves special chars in labels while lowercasing", () => {+ const specialAttributes: Attribute[] = [+ {+ id: "attr-special",+ name: "Special",+ slug: "special",+ type: AttributeType.SINGLE_SELECT,+ options: [+ { id: "opt-special-1", value: "São Paulo", slug: "sao-paulo" },+ { id: "opt-special-2", value: "Zürich", slug: "zurich" },+ ],+ },+ ];++ const queryValue = createQueryValueWithRule({+ ruleId: "rule1",+ field: "attr-special",+ operator: "select_equals",+ value: ["opt-special-1"],+ });++ const result = resolveQueryValue({+ queryValue,+ dynamicFieldValueOperands: undefined,+ attributes: specialAttributes,+ });++ expect(result).toEqual(+ expect.objectContaining({+ children1: {+ rule1: {+ type: "rule",+ properties: expect.objectContaining({+ value: ["são paulo"], // Special chars preserved, only case changed for matching+ }),+ },+ },+ })+ );+ });++ it("keeps non-matching IDs unchanged", () => {+ const queryValue = createQueryValueWithRule({+ ruleId: "rule1",+ field: "attr-1",+ operator: "select_equals",+ value: ["non-existent-id", "opt-1"],+ });++ const result = resolveQueryValue({+ queryValue,+ dynamicFieldValueOperands: undefined,+ attributes: mockAttributes,+ });++ expect(result).toEqual(+ expect.objectContaining({+ children1: {+ rule1: {+ type: "rule",+ properties: expect.objectContaining({+ value: ["non-existent-id", "new york"], // Unknown IDs kept, valid ones converted+ }),+ },+ },+ })+ );+ });++ it("handles missing attributes gracefully", () => {+ const queryValue = createQueryValueWithRule({+ ruleId: "rule1",+ field: "attr-1",+ operator: "select_equals",+ value: ["opt-1"],+ });++ const result = resolveQueryValue({+ queryValue,+ dynamicFieldValueOperands: undefined,+ attributes: [], // No attributes+ });++ expect(result).toEqual(+ expect.objectContaining({+ children1: {+ rule1: {+ type: "rule",+ properties: expect.objectContaining({+ value: ["opt-1"], // No attributes to resolve against+ }),+ },+ },+ })+ );+ });++ it("handles attributes without options", () => {+ const attributesWithoutOptions: Attribute[] = [+ {+ id: "attr-no-options",+ name: "No Options",+ slug: "no-options",+ type: AttributeType.TEXT,+ options: [], // Empty options array+ },+ ];++ const queryValue = createQueryValueWithRule({+ ruleId: "rule1",+ field: "attr-no-options",+ operator: "text_equals",+ value: ["some-value"],+ });++ const result = resolveQueryValue({+ queryValue,+ dynamicFieldValueOperands: undefined,+ attributes: attributesWithoutOptions,+ });++ expect(result).toEqual(+ expect.objectContaining({+ children1: {+ rule1: {+ type: "rule",+ properties: expect.objectContaining({+ value: ["some-value"], // TEXT attributes don't have options to convert+ }),+ },+ },+ })+ );+ });++ it("converts IDs in nested group structures", () => {+ const queryValue = createNestedGroupQueryValue({+ groups: [+ {+ groupId: "group1",+ rules: [+ {+ ruleId: "rule1",+ field: "attr-1",+ operator: "multiselect_some_in",+ value: [["opt-1", "opt-2"]],+ valueType: ["multiselect"],+ },+ {+ ruleId: "rule2",+ field: "attr-2",+ operator: "select_equals",+ value: ["opt-3"],+ },+ ],+ },+ ],+ });++ const result = resolveQueryValue({+ queryValue,+ dynamicFieldValueOperands: undefined,+ attributes: mockAttributes,+ });++ expect(result).toEqual(+ expect.objectContaining({+ children1: {+ group1: {+ type: "group",+ children1: {+ rule1: {+ type: "rule",+ properties: expect.objectContaining({+ value: [["new york", "london"]], // opt-1, opt-2 converted to labels+ }),+ },+ rule2: {+ type: "rule",+ properties: expect.objectContaining({+ value: ["mumbai"], // opt-3 converted to label+ }),+ },+ },+ },+ },+ })+ );+ });++ it("converts IDs alongside field templates in arrays", () => {+ const queryValue = createQueryValueWithRule({+ ruleId: "rule1",+ field: "attr-1",+ operator: "multiselect_some_in",+ value: [["opt-1", "{field:city}", "opt-2", "{field:location}"]],+ valueType: ["multiselect"],+ });++ const result = resolveQueryValue({+ queryValue,+ dynamicFieldValueOperands: {+ fields: mockFields,+ response: {+ city: { value: "Tokyo", label: "Tokyo" },+ location: { value: ["Berlin", "Paris"], label: "Berlin, Paris" },+ },+ },+ attributes: mockAttributes,+ });++ expect(result).toEqual(+ expect.objectContaining({+ children1: {+ rule1: {+ type: "rule",+ properties: expect.objectContaining({+ value: [["new york", "tokyo", "london", "berlin", "paris"]], // opt-1->"new york", opt-2->"london", field templates resolved+ }),+ },+ },+ })+ );+ });+ });++ it("should handle simple field template replacement with single value", () => {+ const queryValue = createQueryValueWithRule({+ ruleId: "a8a89bba",+ field: "city",+ operator: "select_equals",+ value: ["{field:city}"],+ });++ const result = resolveQueryValue({+ queryValue,+ dynamicFieldValueOperands: {+ fields: mockFields,+ response: {+ city: { label: "Mumbai", value: "Mumbai" },+ },+ },+ attributes: mockAttributes,+ });++ expect(result).toEqual(+ expect.objectContaining({+ children1: {+ a8a89bba: {+ type: "rule",+ properties: expect.objectContaining({+ field: "city",+ operator: "select_equals",+ value: ["mumbai"],+ }),+ },+ },+ })+ );+ });++ it("should handle field template in double-nested array for multiselect", () => {+ const queryValue = createQueryValueWithRule({+ ruleId: "rule1",+ field: "location",+ operator: "multiselect_some_in",+ value: [["{field:location}"]],+ valueType: ["multiselect"],+ });++ const result = resolveQueryValue({+ queryValue,+ dynamicFieldValueOperands: {+ fields: mockFields,+ response: {+ location: { label: "Delhi", value: "Delhi" },+ },+ },+ attributes: mockAttributes,+ });++ expect(result).toEqual(+ expect.objectContaining({+ children1: {+ rule1: {+ type: "rule",+ properties: expect.objectContaining({+ field: "location",+ operator: "multiselect_some_in",+ value: [["delhi"]],+ }),+ },+ },+ })+ );+ });++ it("should handle mixed array with field template and regular values", () => {+ const queryValue = {+ children1: {+ rule1: {+ type: "rule",+ properties: {+ field: "location",+ operator: "multiselect_some_in",+ value: [["{field:location}", "Chennai"]],+ },+ },+ },+ } as unknown as AttributesQueryValue;++ const result = resolveQueryValue({+ queryValue,+ dynamicFieldValueOperands: {+ fields: mockFields,+ response: {+ location: { value: "Delhi", label: "Delhi" }, // Single value, not array+ },+ },+ attributes: mockAttributes,+ });++ expect(result).toEqual(+ expect.objectContaining({+ children1: {+ rule1: {+ type: "rule",+ properties: {+ field: "location",+ operator: "multiselect_some_in",+ value: [["delhi", "Chennai"]], // Single value replaced+ },+ },+ },+ })+ );+ });++ it("should handle multiple field templates in the same array", () => {+ const queryValue = {+ children1: {+ rule1: {+ type: "rule",+ properties: {+ field: "multifield",+ operator: "multiselect_some_in",+ value: [["{field:location}", "{field:city}"]],+ },+ },+ },+ } as unknown as AttributesQueryValue;++ const result = resolveQueryValue({+ queryValue,+ dynamicFieldValueOperands: {+ fields: mockFields,+ response: {+ location: { value: ["Delhi"], label: "Delhi" },+ city: { value: "Mumbai", label: "Mumbai" },+ },+ },+ attributes: mockAttributes,+ });++ expect(result).toEqual(+ expect.objectContaining({+ children1: {+ rule1: {+ type: "rule",+ properties: {+ field: "multifield",+ operator: "multiselect_some_in",+ value: [["delhi", "mumbai"]],+ },+ },+ },+ })+ );+ });++ it("should handle field template with no response value", () => {+ const queryValue = {+ children1: {+ rule1: {+ type: "rule",+ properties: {+ field: "location",+ operator: "select_equals",+ value: ["{field:location}"],+ },+ },+ },+ } as unknown as AttributesQueryValue;++ const result = resolveQueryValue({+ queryValue,+ dynamicFieldValueOperands: {+ fields: mockFields,+ response: {}, // No response for location field+ },+ attributes: mockAttributes,+ });++ expect(result).toEqual(+ expect.objectContaining({+ children1: {+ rule1: {+ type: "rule",+ properties: {+ field: "location",+ operator: "select_equals",+ value: ["{field:location}"], // Should remain unchanged+ },+ },+ },+ })+ );+ });++ it("should handle field template with unknown field", () => {+ const queryValue = {+ children1: {+ rule1: {+ type: "rule",+ properties: {+ field: "unknown",+ operator: "select_equals",+ value: ["{field:unknown}"],+ },+ },+ },+ } as unknown as AttributesQueryValue;++ const result = resolveQueryValue({+ queryValue,+ dynamicFieldValueOperands: {+ fields: mockFields,+ response: {+ unknown: { value: "test", label: "test" },+ },+ },+ attributes: mockAttributes,+ });++ expect(result).toEqual(+ expect.objectContaining({+ children1: {+ rule1: {+ type: "rule",+ properties: {+ field: "unknown",+ operator: "select_equals",+ value: ["{field:unknown}"], // Should remain unchanged+ },+ },+ },+ })+ );+ });++ it("should handle complex nested structure", () => {+ const queryValue = createAttributesQueryValue({+ id: "test",+ type: "group",+ children1: {+ rule1: createQueryValueRule({+ type: "rule",+ properties: {+ field: "attr1",+ operator: "multiselect_some_in",+ value: [["{field:location}", "Fixed-Value"]],+ valueType: ["multiselect"],+ },+ }),+ },+ });++ const result = resolveQueryValue({+ queryValue,+ dynamicFieldValueOperands: {+ fields: mockFields,+ response: {+ location: { value: ["Delhi", "Haryana"], label: "Delhi, Haryana" },+ },+ },+ attributes: mockAttributes,+ });++ expect(result).toEqual(+ expect.objectContaining({+ id: "test",+ type: "group",+ children1: {+ rule1: {+ type: "rule",+ properties: expect.objectContaining({+ field: "attr1",+ value: [["delhi", "haryana", "Fixed-Value"]],+ operator: "multiselect_some_in",+ }),+ },+ },+ })+ );+ });++ it("should handle empty array values", () => {+ const queryValue = {+ children1: {+ rule1: {+ type: "rule",+ properties: {+ field: "location",+ operator: "multiselect_some_in",+ value: [["{field:location}"]],+ },+ },+ },+ } as unknown as AttributesQueryValue;++ const result = resolveQueryValue({+ queryValue,+ dynamicFieldValueOperands: {+ fields: mockFields,+ response: {+ location: { value: [], label: "" }, // Empty array+ },+ },+ attributes: mockAttributes,+ });++ expect(result).toEqual(+ expect.objectContaining({+ children1: {+ rule1: {+ type: "rule",+ properties: {+ field: "location",+ operator: "multiselect_some_in",+ value: [[]], // Should be empty array+ },+ },+ },+ })+ );+ });++ it("should handle no dynamicFieldValueOperands", () => {+ const queryValue = {+ children1: {+ rule1: {+ type: "rule",+ properties: {+ field: "location",+ value: ["{field:location}"],+ },+ },+ },+ } as unknown as AttributesQueryValue;++ const result = resolveQueryValue({+ queryValue,+ dynamicFieldValueOperands: undefined,+ attributes: mockAttributes,+ });++ expect(result).toEqual(queryValue); // Should return unchanged+ });++ it("should preserve case for non-template values in mixed arrays", () => {+ const queryValue = {+ children1: {+ rule1: {+ type: "rule",+ properties: {+ field: "location",+ operator: "multiselect_some_in",+ value: [["{field:location}", "Chennai", "MUMBAI"]],+ },+ },+ },+ } as unknown as AttributesQueryValue;++ const result = resolveQueryValue({+ queryValue,+ dynamicFieldValueOperands: {+ fields: mockFields,+ response: {+ location: { value: ["Delhi"], label: "Delhi" },+ },+ },+ attributes: mockAttributes,+ });++ expect(result).toEqual(+ expect.objectContaining({+ children1: {+ rule1: {+ type: "rule",+ properties: {+ field: "location",+ operator: "multiselect_some_in",+ value: [["delhi", "Chennai", "MUMBAI"]], // Only field template value is lowercased+ },+ },+ },+ })+ );+ });++ it("should handle deeply nested field templates", () => {+ const queryValue = createNestedGroupQueryValue({+ groups: [+ {+ groupId: "group1",+ rules: [+ {+ ruleId: "rule1",+ field: "location",+ value: [["{field:location}", "Fixed1"]],+ valueType: ["multiselect"],+ },+ {+ ruleId: "rule2",+ field: "city",+ value: [["{field:city}", "Fixed2"]],+ valueType: ["multiselect"],+ },+ ],+ },+ ],+ });++ const result = resolveQueryValue({+ queryValue,+ dynamicFieldValueOperands: {+ fields: mockFields,+ response: {+ location: { value: ["Delhi", "Mumbai"], label: "Delhi, Mumbai" },+ city: { value: "Chennai", label: "Chennai" },+ },+ },+ attributes: mockAttributes,+ });++ expect(result).toEqual(+ expect.objectContaining({+ type: "group",+ children1: {+ group1: {+ type: "group",+ children1: {+ rule1: {+ type: "rule",+ properties: expect.objectContaining({+ field: "location",+ value: [["delhi", "mumbai", "Fixed1"]],+ }),+ },+ rule2: {+ type: "rule",+ properties: expect.objectContaining({+ field: "city",+ value: [["chennai", "Fixed2"]],+ }),+ },+ },+ },+ },+ })+ );+ });++ it("should handle field template with array containing special characters", () => {+ const queryValue = {+ children1: {+ rule1: {+ type: "rule",+ properties: {+ field: "location",+ value: [["{field:location}"]],+ },+ },+ },+ } as unknown as AttributesQueryValue;++ const result = resolveQueryValue({+ queryValue,+ dynamicFieldValueOperands: {+ fields: mockFields,+ response: {+ location: { value: ["New York", "São Paulo", "Zürich"], label: "New York, São Paulo, Zürich" },+ },+ },+ attributes: mockAttributes,+ });++ expect(result).toEqual(+ expect.objectContaining({+ children1: {+ rule1: {+ type: "rule",+ properties: {+ field: "location",+ value: [["new york", "são paulo", "zürich"]],+ },+ },+ },+ })+ );+ });++ it("should handle null and undefined values gracefully", () => {+ const queryValue = {+ children1: {+ rule1: {+ type: "rule",+ properties: {+ field: "mixed",+ value: [["{field:location}", null, "{field:city}"]],+ },+ },+ },+ } as unknown as AttributesQueryValue;++ const result = resolveQueryValue({+ queryValue,+ dynamicFieldValueOperands: {+ fields: mockFields,+ response: {+ location: { value: ["Delhi"], label: "Delhi" },+ city: { value: null as any, label: "" }, // null value+ },+ },+ attributes: mockAttributes,+ });++ expect(result).toEqual(+ expect.objectContaining({+ children1: {+ rule1: {+ type: "rule",+ properties: {+ field: "mixed",+ value: [["delhi", null, "{field:city}"]], // city remains as template due to null value+ },+ },+ },+ })+ );+ });++ it("should handle numeric values from fields", () => {+ const numericFields = [+ { id: "age", type: RoutingFormFieldType.NUMBER, label: "Age", options: [] },+ { id: "count", type: RoutingFormFieldType.NUMBER, label: "Count", options: [] },+ ];++ const queryValue = {+ children1: {+ rule1: {+ type: "rule",+ properties: {+ field: "numbers",+ value: [["{field:age}", "{field:count}", 42]],+ },+ },+ },+ } as unknown as AttributesQueryValue;++ const result = resolveQueryValue({+ queryValue,+ dynamicFieldValueOperands: {+ fields: numericFields,+ response: {+ age: { value: 25, label: "25" },+ count: { value: 100, label: "100" },+ },+ },+ attributes: mockAttributes,+ });++ expect(result).toEqual(+ expect.objectContaining({+ children1: {+ rule1: {+ type: "rule",+ properties: {+ field: "numbers",+ value: [["25", "100", 42]],+ },+ },+ },+ })+ );+ });++ it("should handle very large arrays efficiently", () => {+ const largeArray = new Array(100).fill("item");+ const queryValue = {+ children1: {+ rule1: {+ type: "rule",+ properties: {+ field: "location",+ value: [["{field:location}", ...largeArray]],+ },+ },+ },+ } as unknown as AttributesQueryValue;++ const result = resolveQueryValue({+ queryValue,+ dynamicFieldValueOperands: {+ fields: mockFields,+ response: {+ location: { value: ["Delhi", "Mumbai"], label: "Delhi, Mumbai" },+ },+ },+ attributes: mockAttributes,+ });++ expect(result.children1?.rule1.properties?.value[0]).toHaveLength(102); // 2 from field + 100 items+ expect(result.children1?.rule1.properties?.value[0].slice(0, 2)).toEqual(["delhi", "mumbai"]);+ });++ it("should handle edge case with empty string field values", () => {+ const queryValue = {+ children1: {+ rule1: {+ type: "rule",+ properties: {+ field: "location",+ value: [["{field:location}"]],+ },+ },+ },+ } as unknown as AttributesQueryValue;++ const result = resolveQueryValue({+ queryValue,+ dynamicFieldValueOperands: {+ fields: mockFields,+ response: {+ location: { value: ["", " ", "Delhi"], label: ", , Delhi" }, // Empty and whitespace strings+ },+ },+ attributes: mockAttributes,+ });++ expect(result).toEqual(+ expect.objectContaining({+ children1: {+ rule1: {+ type: "rule",+ properties: {+ field: "location",+ value: [["", " ", "delhi"]],+ },+ },+ },+ })+ );+ });++ it("should handle field templates with hyphens and underscores in field names", () => {+ const specialFields = [+ { id: "field-with-dashes", type: RoutingFormFieldType.TEXT, label: "Dashed Field", options: [] },+ {+ id: "field_with_underscores",+ type: RoutingFormFieldType.TEXT,+ label: "Underscored Field",+ options: [],+ },+ ];++ const queryValue = {+ children1: {+ rule1: {+ type: "rule",+ properties: {+ field: "special",+ value: ["{field:field-with-dashes}", "{field:field_with_underscores}"],+ },+ },+ },+ } as unknown as AttributesQueryValue;++ const result = resolveQueryValue({+ queryValue,+ dynamicFieldValueOperands: {+ fields: specialFields,+ response: {+ "field-with-dashes": { value: "Value2", label: "Value2" },+ field_with_underscores: { value: "Value3", label: "Value3" },+ },+ },+ attributes: mockAttributes,+ });++ expect(result).toEqual(+ expect.objectContaining({+ children1: {+ rule1: {+ type: "rule",+ properties: {+ field: "special",+ value: ["value2", "value3"],+ },+ },+ },+ })+ );+ });++ it("should handle field templates in different JSON value types", () => {+ const queryValue = {+ children1: {+ rule1: {+ type: "rule",+ properties: {+ field: "city",+ value: "{field:city}",+ },+ },+ rule2: {+ type: "rule",+ properties: {+ field: "city",+ value: ["{field:city}"],+ },+ },+ rule3: {+ type: "rule",+ properties: {+ field: "location",+ value: [["{field:location}"]],+ },+ },+ rule4: {+ type: "rule",+ properties: {+ field: "mixed",+ customProp: "{field:city}",+ nested: {+ value: ["{field:location}"],+ },+ },+ },+ },+ } as unknown as AttributesQueryValue;++ const result = resolveQueryValue({+ queryValue,+ dynamicFieldValueOperands: {+ fields: mockFields,+ response: {+ location: { value: ["Delhi", "Mumbai"], label: "Delhi, Mumbai" },+ city: { value: "Chennai", label: "Chennai" },+ },+ },+ attributes: mockAttributes,+ });++ expect(result).toEqual(+ expect.objectContaining({+ children1: {+ rule1: {+ type: "rule",+ properties: {+ field: "city",+ value: "chennai",+ },+ },+ rule2: {+ type: "rule",+ properties: {+ field: "city",+ value: ["chennai"],+ },+ },+ rule3: {+ type: "rule",+ properties: {+ field: "location",+ value: [["delhi", "mumbai"]],+ },+ },+ rule4: {+ type: "rule",+ properties: {+ field: "mixed",+ customProp: "chennai",+ nested: {+ value: ["delhi", "mumbai"],+ },+ },+ },+ },+ })+ );+ });++ it("should handle empty response object", () => {+ const queryValue = {+ children1: {+ rule1: {+ type: "rule",+ properties: {+ field: "location",+ value: [["{field:location}", "Fixed"]],+ },+ },+ },+ } as unknown as AttributesQueryValue;++ const result = resolveQueryValue({+ queryValue,+ dynamicFieldValueOperands: {+ fields: mockFields,+ response: {}, // Empty response+ },+ attributes: mockAttributes,+ });++ expect(result).toEqual(+ expect.objectContaining({+ children1: {+ rule1: {+ type: "rule",+ properties: {+ field: "location",+ value: [["{field:location}", "Fixed"]], // Template unchanged+ },+ },+ },+ })+ );+ });++ it("should handle response with empty field value object", () => {+ const queryValue = {+ children1: {+ rule1: {+ type: "rule",+ properties: {+ field: "location",+ value: [["{field:location}"]],+ },+ },+ },+ } as unknown as AttributesQueryValue;++ const result = resolveQueryValue({+ queryValue,+ dynamicFieldValueOperands: {+ fields: mockFields,+ response: {+ location: {} as any, // Empty object, no value property+ },+ },+ attributes: mockAttributes,+ });++ expect(result).toEqual(+ expect.objectContaining({+ children1: {+ rule1: {+ type: "rule",+ properties: {+ field: "location",+ value: [["{field:location}"]], // Template unchanged+ },+ },+ },+ })+ );+ });++ it("should handle multiple occurrences of the same field template", () => {+ const queryValue = {+ children1: {+ rule1: {+ type: "rule",+ properties: {+ field: "city",+ value: ["{field:city}"],+ },+ },+ rule2: {+ type: "rule",+ properties: {+ field: "city",+ value: ["{field:city}"],+ },+ },+ rule3: {+ type: "rule",+ properties: {+ field: "city",+ value: [["{field:city}", "{field:city}"]],+ },+ },+ },+ } as unknown as AttributesQueryValue;++ const result = resolveQueryValue({+ queryValue,+ dynamicFieldValueOperands: {+ fields: mockFields,+ response: {+ city: { value: "Mumbai", label: "Mumbai" },+ },+ },+ attributes: mockAttributes,+ });++ expect(result).toEqual(+ expect.objectContaining({+ children1: {+ rule1: {+ type: "rule",+ properties: {+ field: "city",+ value: ["mumbai"],+ },+ },+ rule2: {+ type: "rule",+ properties: {+ field: "city",+ value: ["mumbai"],+ },+ },+ rule3: {+ type: "rule",+ properties: {+ field: "city",+ value: [["mumbai", "mumbai"]],+ },+ },+ },+ })+ );+ });++ it("should handle invalid query structure gracefully", () => {+ // Test with an invalid query structure+ const invalidQueryValue = null as unknown as AttributesQueryValue;++ const result = resolveQueryValue({+ queryValue: invalidQueryValue,+ dynamicFieldValueOperands: {+ fields: mockFields,+ response: {+ city: { value: "Mumbai", label: "Mumbai" },+ },+ },+ attributes: mockAttributes,+ });++ expect(result).toBeNull();+ });++ it("should handle valid JSON that causes processing errors gracefully", () => {+ const queryValue = {+ children1: {+ rule1: {+ type: "rule",+ properties: {+ field: "nonexistent",+ value: ["{field:nonexistent}"],+ },+ },+ rule2: {+ type: "rule",+ properties: {+ field: "city",+ customField: "{field:city}",+ },+ },+ },+ } as unknown as AttributesQueryValue;++ const result = resolveQueryValue({+ queryValue,+ dynamicFieldValueOperands: {+ fields: mockFields,+ response: {+ city: { value: "Mumbai", label: "Mumbai" },+ },+ },+ attributes: mockAttributes,+ });++ // Non-existent field should remain as-is, existing field should be resolved+ expect(result).toEqual(+ expect.objectContaining({+ children1: {+ rule1: {+ type: "rule",+ properties: {+ field: "nonexistent",+ value: ["{field:nonexistent}"],+ },+ },+ rule2: {+ type: "rule",+ properties: {+ field: "city",+ customField: "mumbai",+ },+ },+ },+ })+ );+ });++ 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.tsnew file mode 100644index 00000000000..a6c9240cb78--- /dev/null+++ b/packages/lib/raqb/resolveQueryValue.ts@@ -0,0 +1,267 @@+import logger from "@calcom/lib/logger";+import type { dynamicFieldValueOperands, dynamicFieldValueOperandsResponse } from "@calcom/lib/raqb/types";+import type { AttributesQueryValue } from "@calcom/lib/raqb/types";+import type { Attribute } from "@calcom/lib/service/attribute/server/getAttributes";++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 Options' Ids" with "Attribute Options' Labels". It makes the query value compatible to be matched with 'Value of Field' operand+ */+const replaceAttributeOptionIdsWithOptionLabel = ({+ queryValue,+ attributes,+}: {+ queryValue: AttributesQueryValue;+ attributes: Attribute[];+}) => {+ const queryValueString = JSON.stringify(queryValue);+ let queryValueWithLabels = queryValueString;+ const allAttributesOptions = attributes.map((attribute) => attribute.options).flat();+ // Because all attribute option Ids are unique, we can reliably identify them along any number of attribute options of different attributes+ allAttributesOptions.forEach((attributeOption) => {+ const attributeOptionId = attributeOption.id;+ queryValueWithLabels = queryValueWithLabels.replace(+ new RegExp(`${attributeOptionId}`, "g"),+ caseInsensitive(attributeOption.value)+ );+ });+ return JSON.parse(queryValueWithLabels) as AttributesQueryValue;+};++function getFieldResponseValueAsLabel({+ field,+ fieldResponseValue,+}: {+ fieldResponseValue: FieldResponseValue;+ field: MinimalField;+}) {+ const nonNumberFieldResponseValue =+ typeof fieldResponseValue === "number" ? fieldResponseValue.toString() : fieldResponseValue;++ if (!field.options) {+ return nonNumberFieldResponseValue;+ }++ if (nonNumberFieldResponseValue instanceof Array) {+ return nonNumberFieldResponseValue.map(transformValue);+ }++ return transformValue(nonNumberFieldResponseValue);++ function transformValue(idOrLabel: string) {+ const foundOptionById = field.options?.find((option) => {+ return option.id === idOrLabel;+ });+ if (foundOptionById) {+ return foundOptionById.label;+ } else {+ return idOrLabel;+ }+ }+}++/**+ * 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+ *+ * 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+ *+ * @example+ * ```ts+ * resolveQueryValue({+ * queryValue: {+ * "id": "9b8ba888-0123-4456-b89a-b1984020d699",+ * "type": "group",+ * "children1": {+ * "a8a89bba-89ab-4cde-b012-31984020ebaa": {+ * "type": "rule",+ * "id": "a8a89bba-89ab-4cde-b012-31984020ebaa",+ * "properties": {+ * "field": "88be6104-d350-411d-aa0f-092b2deda257",+ * "operator": "multiselect_some_in",+ * "value": [+ * [+ * "{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": [+ * "value"+ * ],+ * "valueError": [+ * null+ * ],+ * "valueType": [+ * "multiselect"+ * ]+ * }+ * }+ * }+ * },+ * dynamicFieldValueOperands: {+ * fields: [+ * { id: "location", type: "MULTI_SELECT", label: "Location" }+ * ],+ * response: {+ * location: { value: ["Delhi", "Mumbai"] }+ * }+ * }+ * })+ * // Returns: '{"value": [["delhi", "mumbai"]], "operator": "multiselect_some_in"}'+ * ```+ */+export const resolveQueryValue = ({+ queryValue,+ dynamicFieldValueOperands,+ attributes,+}: {+ queryValue: AttributesQueryValue;+ dynamicFieldValueOperands?: dynamicFieldValueOperands;+ attributes: Attribute[];+}) => {+ const queryValueWithLabels = replaceAttributeOptionIdsWithOptionLabel({+ queryValue,+ attributes,+ });++ if (!dynamicFieldValueOperands) {+ return queryValueWithLabels;+ }+ const { fields, response } = dynamicFieldValueOperands;++ const isFieldTemplate = (str: string): boolean => {+ const trimmedStr = str.trim();+ return trimmedStr.startsWith("{field:") && trimmedStr.endsWith("}");+ };++ // Extract field ID from template string+ const extractFieldId = (template: string): string | null => {+ const trimmedTemplate = template.trim();+ if (!isFieldTemplate(trimmedTemplate)) return null;+ // Remove {field: and } to get the ID+ return trimmedTemplate.slice(7, -1);+ };++ // Resolve a field ID to its actual value+ const resolveFieldId = (fieldId: string): string | string[] | null => {+ const field = fields.find((f) => f.id === fieldId);+ if (!field || !response[fieldId]?.value) {+ // Maybe invalid fieldId+ return null;+ }++ const fieldResponseValue = response[fieldId].value;+ return getFieldResponseValueAsLabel({ field, fieldResponseValue });+ };++ // Process a string value that might be a field template and thus could be an array+ const processStringValue = (value: string): string | string[] => {+ const fieldId = extractFieldId(value);+ if (!fieldId) {+ // Regular non-field template string+ return value;+ }++ const resolvedValue = resolveFieldId(fieldId);+ if (!resolvedValue) {+ // We keep the field template look-alike as it is+ return value;+ }++ return caseInsensitive(resolvedValue);+ };++ // 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));+ }++ const result: JsonValue[] = [];+ for (const item of arr) {+ if (typeof item === "string" && isFieldTemplate(item)) {+ const processed = processStringValue(item);+ if (Array.isArray(processed)) {+ // 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 {+ result.push(processAnyValue(item));+ }+ }+ return result;+ };++ // Process any value recursively+ const processAnyValue = (value: JsonValue): JsonValue => {+ if (value instanceof Array) {+ return processArray(value);+ }++ if (typeof value === "object" && value !== null) {+ const result: { [key: string]: JsonValue } = {};+ for (const key in value) {+ result[key] = processAnyValue(value[key]);+ }+ return result;+ }++ if (typeof value === "string") {+ const processedValue = processStringValue(value);+ return processedValue;+ }++ return value;+ };++ try {+ // Even though it recursively processes the queryValue, the object(see example in `resolveQueryValue` fn signature) isn't that complex and thus the performance is not an issue+ const processed = processAnyValue(queryValueWithLabels) as AttributesQueryValue;+ return processed;+ } catch (e) {+ moduleLogger.error("Failed to resolve field templates", {+ error: e,+ queryValue: JSON.stringify(queryValueWithLabels),+ fieldsCount: fields?.length || 0,+ responseKeys: Object.keys(response || {}),+ dynamicFieldValueOperandsProvided: !!dynamicFieldValueOperands,+ });+ throw new Error(+ `Failed to resolve field templates in query value: ${e instanceof Error ? e.message : String(e)}`+ );+ }+};diff --git a/packages/lib/raqb/utils.ts b/packages/lib/raqb/utils.tsnew file mode 100644index 00000000000..6a6438871f8--- /dev/null+++ b/packages/lib/raqb/utils.ts@@ -0,0 +1,9 @@+export function caseInsensitive<T extends string | string[]>(+ stringOrStringArray: T+): T extends string[] ? string[] : string {+ return (+ stringOrStringArray instanceof Array+ ? stringOrStringArray.map((string) => string.toLowerCase())+ : stringOrStringArray.toLowerCase()+ ) as T extends string[] ? string[] : string;+}\ No newline at end of filediff --git a/packages/lib/raqb/zod.ts b/packages/lib/raqb/zod.tsindex 28fd0eef7db..ade954aba6a 100644--- a/packages/lib/raqb/zod.ts+++ b/packages/lib/raqb/zod.ts@@ -83,6 +83,40 @@ const raqbChildren1Schema = z}});});++/**+ * @example+ * ```json+ * {+ "id": "9b8ba888-0123-4456-b89a-b1984020d699",+ "type": "group",+ "children1": {+ "a8a89bba-89ab-4cde-b012-31984020ebaa": {+ "type": "rule",+ "properties": {+ "field": "88be6104-d350-411d-aa0f-092b2deda257",+ "operator": "multiselect_some_in",+ "value": [+ [+ "{field:0bf77a89-2bd0-4df7-9648-758014ba3189}",+ "899c846d-7c02-43dc-9057-c3f8c118d41f"+ ]+ ],+ "valueSrc": [+ "value"+ ],+ "valueError": [+ null+ ],+ "valueType": [+ "multiselect"+ ]+ }+ }+ }+ }+ * ```+ */export const raqbQueryValueSchema = z.union([z.object({id: z.string().optional(),