@usertour/helpers 0.0.34 → 0.0.36

package/dist/__tests__/condition.test.js

@@ -2,11 +2,12 @@ import {
   evaluateRulesConditions,
   filterConditionsByType,
   isConditionsActived
-} from "../chunk-A4KMGXB3.js";
+} from "../chunk-3UOSPZEP.js";
 import "../chunk-YYIGUZNZ.js";
 import "../chunk-PAESAL23.js";
-import "../chunk-7JXEY4A2.js";
-import "../chunk-CEK3SCQO.js";
+import "../chunk-JQWKLXW6.js";
+import "../chunk-KYDXF7SU.js";
+import "../chunk-GFH3VWOC.js";
 import "../chunk-3KG2HTZ3.js";
 import "../chunk-XEO3YXBM.js";
 
@@ -230,7 +231,8 @@ describe("evaluateRulesConditions", () => {
       operators: "and",
       actived: false,
       data: {
-        startDate: "2024-01-01",
+        startDate: "01/01/2024",
+        // MM/dd/yyyy format
         startDateHour: "00",
         startDateMinute: "00"
       }
@@ -372,6 +374,902 @@ describe("evaluateRulesConditions", () => {
     });
     expect(result[2].actived).toBe(true);
   });
+  test("should evaluate String type attribute conditions with all logic operators", async () => {
+    const conditions = [
+      {
+        id: "string-is",
+        type: "user-attr",
+        operators: "and",
+        actived: false,
+        data: {
+          attrId: "email",
+          logic: "is",
+          value: "user@example.com"
+        }
+      },
+      {
+        id: "string-not",
+        type: "user-attr",
+        operators: "and",
+        actived: false,
+        data: {
+          attrId: "name",
+          logic: "not",
+          value: "admin"
+        }
+      },
+      {
+        id: "string-contains",
+        type: "user-attr",
+        operators: "and",
+        actived: false,
+        data: {
+          attrId: "description",
+          logic: "contains",
+          value: "premium"
+        }
+      },
+      {
+        id: "string-notContain",
+        type: "user-attr",
+        operators: "and",
+        actived: false,
+        data: {
+          attrId: "title",
+          logic: "notContain",
+          value: "test"
+        }
+      },
+      {
+        id: "string-startsWith",
+        type: "user-attr",
+        operators: "and",
+        actived: false,
+        data: {
+          attrId: "path",
+          logic: "startsWith",
+          value: "/api"
+        }
+      },
+      {
+        id: "string-endsWith",
+        type: "user-attr",
+        operators: "and",
+        actived: false,
+        data: {
+          attrId: "filename",
+          logic: "endsWith",
+          value: ".pdf"
+        }
+      },
+      {
+        id: "string-empty",
+        type: "user-attr",
+        operators: "and",
+        actived: false,
+        data: {
+          attrId: "emptyString",
+          logic: "empty"
+        }
+      },
+      {
+        id: "string-any",
+        type: "user-attr",
+        operators: "and",
+        actived: false,
+        data: {
+          attrId: "hasString",
+          logic: "any"
+        }
+      }
+    ];
+    const options = {
+      clientContext: mockOptions.clientContext,
+      attributes: [
+        {
+          id: "email",
+          codeName: "email",
+          dataType: BizAttributeTypes.String,
+          bizType: AttributeBizTypes.User
+        },
+        {
+          id: "name",
+          codeName: "name",
+          dataType: BizAttributeTypes.String,
+          bizType: AttributeBizTypes.User
+        },
+        {
+          id: "description",
+          codeName: "description",
+          dataType: BizAttributeTypes.String,
+          bizType: AttributeBizTypes.User
+        },
+        {
+          id: "title",
+          codeName: "title",
+          dataType: BizAttributeTypes.String,
+          bizType: AttributeBizTypes.User
+        },
+        {
+          id: "path",
+          codeName: "path",
+          dataType: BizAttributeTypes.String,
+          bizType: AttributeBizTypes.User
+        },
+        {
+          id: "filename",
+          codeName: "filename",
+          dataType: BizAttributeTypes.String,
+          bizType: AttributeBizTypes.User
+        },
+        {
+          id: "emptyString",
+          codeName: "emptyString",
+          dataType: BizAttributeTypes.String,
+          bizType: AttributeBizTypes.User
+        },
+        {
+          id: "hasString",
+          codeName: "hasString",
+          dataType: BizAttributeTypes.String,
+          bizType: AttributeBizTypes.User
+        }
+      ],
+      userAttributes: {
+        email: "user@example.com",
+        name: "john",
+        description: "premium user account",
+        title: "Manager",
+        path: "/api/users",
+        filename: "document.pdf",
+        emptyString: "",
+        hasString: "some value"
+      },
+      typeControl: {
+        [RulesType.USER_ATTR]: true
+      }
+    };
+    const result = await evaluateRulesConditions(conditions, options);
+    expect(result[0].actived).toBe(true);
+    expect(result[1].actived).toBe(true);
+    expect(result[2].actived).toBe(true);
+    expect(result[3].actived).toBe(true);
+    expect(result[4].actived).toBe(true);
+    expect(result[5].actived).toBe(true);
+    expect(result[6].actived).toBe(true);
+    expect(result[7].actived).toBe(true);
+  });
+  test("should evaluate Number type attribute conditions with all logic operators", async () => {
+    const conditions = [
+      {
+        id: "number-is",
+        type: "user-attr",
+        operators: "and",
+        actived: false,
+        data: {
+          attrId: "age",
+          logic: "is",
+          value: 25
+        }
+      },
+      {
+        id: "number-not",
+        type: "user-attr",
+        operators: "and",
+        actived: false,
+        data: {
+          attrId: "age2",
+          logic: "not",
+          value: 30
+        }
+      },
+      {
+        id: "number-isLessThan",
+        type: "user-attr",
+        operators: "and",
+        actived: false,
+        data: {
+          attrId: "score",
+          logic: "isLessThan",
+          value: 100
+        }
+      },
+      {
+        id: "number-isLessThanOrEqualTo",
+        type: "user-attr",
+        operators: "and",
+        actived: false,
+        data: {
+          attrId: "score2",
+          logic: "isLessThanOrEqualTo",
+          value: 80
+        }
+      },
+      {
+        id: "number-isGreaterThan",
+        type: "user-attr",
+        operators: "and",
+        actived: false,
+        data: {
+          attrId: "score3",
+          logic: "isGreaterThan",
+          value: 50
+        }
+      },
+      {
+        id: "number-isGreaterThanOrEqualTo",
+        type: "user-attr",
+        operators: "and",
+        actived: false,
+        data: {
+          attrId: "score4",
+          logic: "isGreaterThanOrEqualTo",
+          value: 60
+        }
+      },
+      {
+        id: "number-between",
+        type: "user-attr",
+        operators: "and",
+        actived: false,
+        data: {
+          attrId: "price",
+          logic: "between",
+          value: 10,
+          value2: 100
+        }
+      },
+      {
+        id: "number-empty",
+        type: "user-attr",
+        operators: "and",
+        actived: false,
+        data: {
+          attrId: "emptyValue",
+          logic: "empty"
+        }
+      },
+      {
+        id: "number-any",
+        type: "user-attr",
+        operators: "and",
+        actived: false,
+        data: {
+          attrId: "hasValue",
+          logic: "any"
+        }
+      }
+    ];
+    const options = {
+      clientContext: mockOptions.clientContext,
+      attributes: [
+        {
+          id: "age",
+          codeName: "age",
+          dataType: BizAttributeTypes.Number,
+          bizType: AttributeBizTypes.User
+        },
+        {
+          id: "age2",
+          codeName: "age2",
+          dataType: BizAttributeTypes.Number,
+          bizType: AttributeBizTypes.User
+        },
+        {
+          id: "score",
+          codeName: "score",
+          dataType: BizAttributeTypes.Number,
+          bizType: AttributeBizTypes.User
+        },
+        {
+          id: "score2",
+          codeName: "score2",
+          dataType: BizAttributeTypes.Number,
+          bizType: AttributeBizTypes.User
+        },
+        {
+          id: "score3",
+          codeName: "score3",
+          dataType: BizAttributeTypes.Number,
+          bizType: AttributeBizTypes.User
+        },
+        {
+          id: "score4",
+          codeName: "score4",
+          dataType: BizAttributeTypes.Number,
+          bizType: AttributeBizTypes.User
+        },
+        {
+          id: "price",
+          codeName: "price",
+          dataType: BizAttributeTypes.Number,
+          bizType: AttributeBizTypes.User
+        },
+        {
+          id: "emptyValue",
+          codeName: "emptyValue",
+          dataType: BizAttributeTypes.Number,
+          bizType: AttributeBizTypes.User
+        },
+        {
+          id: "hasValue",
+          codeName: "hasValue",
+          dataType: BizAttributeTypes.Number,
+          bizType: AttributeBizTypes.User
+        }
+      ],
+      userAttributes: {
+        age: 25,
+        age2: 25,
+        score: 90,
+        score2: 80,
+        score3: 70,
+        score4: 60,
+        price: 50,
+        emptyValue: null,
+        hasValue: 42
+      },
+      typeControl: {
+        [RulesType.USER_ATTR]: true
+      }
+    };
+    const result = await evaluateRulesConditions(conditions, options);
+    expect(result[0].actived).toBe(true);
+    expect(result[1].actived).toBe(true);
+    expect(result[2].actived).toBe(true);
+    expect(result[3].actived).toBe(true);
+    expect(result[4].actived).toBe(true);
+    expect(result[5].actived).toBe(true);
+    expect(result[6].actived).toBe(true);
+    expect(result[7].actived).toBe(true);
+    expect(result[8].actived).toBe(true);
+  });
+  test("should evaluate Boolean type attribute conditions with all logic operators", async () => {
+    const conditions = [
+      {
+        id: "bool-true",
+        type: "user-attr",
+        operators: "and",
+        actived: false,
+        data: {
+          attrId: "isVip",
+          logic: "true"
+        }
+      },
+      {
+        id: "bool-false",
+        type: "user-attr",
+        operators: "and",
+        actived: false,
+        data: {
+          attrId: "isActive",
+          logic: "false"
+        }
+      },
+      {
+        id: "bool-empty",
+        type: "user-attr",
+        operators: "and",
+        actived: false,
+        data: {
+          attrId: "emptyBool",
+          logic: "empty"
+        }
+      },
+      {
+        id: "bool-any",
+        type: "user-attr",
+        operators: "and",
+        actived: false,
+        data: {
+          attrId: "hasBool",
+          logic: "any"
+        }
+      }
+    ];
+    const options = {
+      clientContext: mockOptions.clientContext,
+      attributes: [
+        {
+          id: "isVip",
+          codeName: "isVip",
+          dataType: BizAttributeTypes.Boolean,
+          bizType: AttributeBizTypes.User
+        },
+        {
+          id: "isActive",
+          codeName: "isActive",
+          dataType: BizAttributeTypes.Boolean,
+          bizType: AttributeBizTypes.User
+        },
+        {
+          id: "emptyBool",
+          codeName: "emptyBool",
+          dataType: BizAttributeTypes.Boolean,
+          bizType: AttributeBizTypes.User
+        },
+        {
+          id: "hasBool",
+          codeName: "hasBool",
+          dataType: BizAttributeTypes.Boolean,
+          bizType: AttributeBizTypes.User
+        }
+      ],
+      userAttributes: {
+        isVip: true,
+        isActive: false,
+        emptyBool: null,
+        hasBool: true
+      },
+      typeControl: {
+        [RulesType.USER_ATTR]: true
+      }
+    };
+    const result = await evaluateRulesConditions(conditions, options);
+    expect(result[0].actived).toBe(true);
+    expect(result[1].actived).toBe(true);
+    expect(result[2].actived).toBe(true);
+    expect(result[3].actived).toBe(true);
+  });
+  test("should evaluate List type attribute conditions with all logic operators", async () => {
+    const conditions = [
+      {
+        id: "list-includesAtLeastOne",
+        type: "user-attr",
+        operators: "and",
+        actived: false,
+        data: {
+          attrId: "tags",
+          logic: "includesAtLeastOne",
+          listValues: ["premium", "vip"]
+        }
+      },
+      {
+        id: "list-includesAll",
+        type: "user-attr",
+        operators: "and",
+        actived: false,
+        data: {
+          attrId: "roles",
+          logic: "includesAll",
+          listValues: ["admin", "editor"]
+        }
+      },
+      {
+        id: "list-notIncludesAtLeastOne",
+        type: "user-attr",
+        operators: "and",
+        actived: false,
+        data: {
+          attrId: "permissions",
+          logic: "notIncludesAtLeastOne",
+          listValues: ["delete", "modify"]
+        }
+      },
+      {
+        id: "list-notIncludesAll",
+        type: "user-attr",
+        operators: "and",
+        actived: false,
+        data: {
+          attrId: "categories",
+          logic: "notIncludesAll",
+          listValues: ["tech", "finance"]
+        }
+      },
+      {
+        id: "list-empty",
+        type: "user-attr",
+        operators: "and",
+        actived: false,
+        data: {
+          attrId: "emptyList",
+          logic: "empty"
+        }
+      },
+      {
+        id: "list-any",
+        type: "user-attr",
+        operators: "and",
+        actived: false,
+        data: {
+          attrId: "hasList",
+          logic: "any"
+        }
+      }
+    ];
+    const options = {
+      clientContext: mockOptions.clientContext,
+      attributes: [
+        {
+          id: "tags",
+          codeName: "tags",
+          dataType: BizAttributeTypes.List,
+          bizType: AttributeBizTypes.User
+        },
+        {
+          id: "roles",
+          codeName: "roles",
+          dataType: BizAttributeTypes.List,
+          bizType: AttributeBizTypes.User
+        },
+        {
+          id: "permissions",
+          codeName: "permissions",
+          dataType: BizAttributeTypes.List,
+          bizType: AttributeBizTypes.User
+        },
+        {
+          id: "categories",
+          codeName: "categories",
+          dataType: BizAttributeTypes.List,
+          bizType: AttributeBizTypes.User
+        },
+        {
+          id: "emptyList",
+          codeName: "emptyList",
+          dataType: BizAttributeTypes.List,
+          bizType: AttributeBizTypes.User
+        },
+        {
+          id: "hasList",
+          codeName: "hasList",
+          dataType: BizAttributeTypes.List,
+          bizType: AttributeBizTypes.User
+        }
+      ],
+      userAttributes: {
+        tags: ["premium", "basic"],
+        roles: ["admin", "editor", "viewer"],
+        permissions: ["read", "write"],
+        categories: ["other"],
+        emptyList: [],
+        hasList: ["item1", "item2"]
+      },
+      typeControl: {
+        [RulesType.USER_ATTR]: true
+      }
+    };
+    const result = await evaluateRulesConditions(conditions, options);
+    expect(result[0].actived).toBe(true);
+    expect(result[1].actived).toBe(true);
+    expect(result[2].actived).toBe(true);
+    expect(result[3].actived).toBe(true);
+    expect(result[4].actived).toBe(true);
+    expect(result[5].actived).toBe(true);
+  });
+  test("should evaluate DateTime type attribute conditions with all logic operators", async () => {
+    const now = /* @__PURE__ */ new Date();
+    const fiveDaysAgo = new Date(now.getTime() - 5 * 24 * 60 * 60 * 1e3);
+    const tenDaysAgo = new Date(now.getTime() - 10 * 24 * 60 * 60 * 1e3);
+    const threeDaysAgo = new Date(now.getTime() - 3 * 24 * 60 * 60 * 1e3);
+    const fifteenDaysAgo = new Date(now.getTime() - 15 * 24 * 60 * 60 * 1e3);
+    const futureDate = new Date(now.getTime() + 5 * 24 * 60 * 60 * 1e3);
+    const conditions = [
+      {
+        id: "datetime-lessThan",
+        type: "user-attr",
+        operators: "and",
+        actived: false,
+        data: {
+          attrId: "lastLogin",
+          logic: "lessThan",
+          value: 7
+        }
+      },
+      {
+        id: "datetime-exactly",
+        type: "user-attr",
+        operators: "and",
+        actived: false,
+        data: {
+          attrId: "exactDate",
+          logic: "exactly",
+          value: 3
+        }
+      },
+      {
+        id: "datetime-moreThan",
+        type: "user-attr",
+        operators: "and",
+        actived: false,
+        data: {
+          attrId: "oldDate",
+          logic: "moreThan",
+          value: 7
+        }
+      },
+      {
+        id: "datetime-before",
+        type: "user-attr",
+        operators: "and",
+        actived: false,
+        data: {
+          attrId: "createdAt",
+          logic: "before",
+          value: now.toISOString()
+        }
+      },
+      {
+        id: "datetime-on",
+        type: "user-attr",
+        operators: "and",
+        actived: false,
+        data: {
+          attrId: "onDate",
+          logic: "on",
+          value: threeDaysAgo.toISOString()
+        }
+      },
+      {
+        id: "datetime-after",
+        type: "user-attr",
+        operators: "and",
+        actived: false,
+        data: {
+          attrId: "futureDate",
+          logic: "after",
+          value: now.toISOString()
+        }
+      },
+      {
+        id: "datetime-empty",
+        type: "user-attr",
+        operators: "and",
+        actived: false,
+        data: {
+          attrId: "emptyDate",
+          logic: "empty"
+        }
+      },
+      {
+        id: "datetime-any",
+        type: "user-attr",
+        operators: "and",
+        actived: false,
+        data: {
+          attrId: "hasDate",
+          logic: "any"
+        }
+      }
+    ];
+    const options = {
+      clientContext: mockOptions.clientContext,
+      attributes: [
+        {
+          id: "lastLogin",
+          codeName: "lastLogin",
+          dataType: BizAttributeTypes.DateTime,
+          bizType: AttributeBizTypes.User
+        },
+        {
+          id: "exactDate",
+          codeName: "exactDate",
+          dataType: BizAttributeTypes.DateTime,
+          bizType: AttributeBizTypes.User
+        },
+        {
+          id: "oldDate",
+          codeName: "oldDate",
+          dataType: BizAttributeTypes.DateTime,
+          bizType: AttributeBizTypes.User
+        },
+        {
+          id: "createdAt",
+          codeName: "createdAt",
+          dataType: BizAttributeTypes.DateTime,
+          bizType: AttributeBizTypes.User
+        },
+        {
+          id: "onDate",
+          codeName: "onDate",
+          dataType: BizAttributeTypes.DateTime,
+          bizType: AttributeBizTypes.User
+        },
+        {
+          id: "futureDate",
+          codeName: "futureDate",
+          dataType: BizAttributeTypes.DateTime,
+          bizType: AttributeBizTypes.User
+        },
+        {
+          id: "emptyDate",
+          codeName: "emptyDate",
+          dataType: BizAttributeTypes.DateTime,
+          bizType: AttributeBizTypes.User
+        },
+        {
+          id: "hasDate",
+          codeName: "hasDate",
+          dataType: BizAttributeTypes.DateTime,
+          bizType: AttributeBizTypes.User
+        }
+      ],
+      userAttributes: {
+        lastLogin: fiveDaysAgo.toISOString(),
+        exactDate: threeDaysAgo.toISOString(),
+        oldDate: fifteenDaysAgo.toISOString(),
+        createdAt: tenDaysAgo.toISOString(),
+        onDate: threeDaysAgo.toISOString(),
+        futureDate: futureDate.toISOString(),
+        emptyDate: "",
+        hasDate: fiveDaysAgo.toISOString()
+      },
+      typeControl: {
+        [RulesType.USER_ATTR]: true
+      }
+    };
+    const result = await evaluateRulesConditions(conditions, options);
+    expect(result[0].actived).toBe(true);
+    expect(result[1].actived).toBe(true);
+    expect(result[2].actived).toBe(true);
+    expect(result[3].actived).toBe(true);
+    expect(result[4].actived).toBe(true);
+    expect(result[5].actived).toBe(true);
+    expect(result[6].actived).toBe(false);
+    expect(result[7].actived).toBe(true);
+  });
+  test("should evaluate mixed attribute type conditions correctly", async () => {
+    const conditions = [
+      {
+        id: "mixed-1",
+        type: "user-attr",
+        operators: "and",
+        actived: false,
+        data: {
+          attrId: "email",
+          logic: "is",
+          value: "user@example.com"
+        }
+      },
+      {
+        id: "mixed-2",
+        type: "user-attr",
+        operators: "and",
+        actived: false,
+        data: {
+          attrId: "age",
+          logic: "isGreaterThan",
+          value: 18
+        }
+      },
+      {
+        id: "mixed-3",
+        type: "user-attr",
+        operators: "and",
+        actived: false,
+        data: {
+          attrId: "isVip",
+          logic: "true"
+        }
+      },
+      {
+        id: "mixed-4",
+        type: "user-attr",
+        operators: "and",
+        actived: false,
+        data: {
+          attrId: "tags",
+          logic: "includesAtLeastOne",
+          listValues: ["premium"]
+        }
+      }
+    ];
+    const options = {
+      clientContext: mockOptions.clientContext,
+      attributes: [
+        {
+          id: "email",
+          codeName: "email",
+          dataType: BizAttributeTypes.String,
+          bizType: AttributeBizTypes.User
+        },
+        {
+          id: "age",
+          codeName: "age",
+          dataType: BizAttributeTypes.Number,
+          bizType: AttributeBizTypes.User
+        },
+        {
+          id: "isVip",
+          codeName: "isVip",
+          dataType: BizAttributeTypes.Boolean,
+          bizType: AttributeBizTypes.User
+        },
+        {
+          id: "tags",
+          codeName: "tags",
+          dataType: BizAttributeTypes.List,
+          bizType: AttributeBizTypes.User
+        }
+      ],
+      userAttributes: {
+        email: "user@example.com",
+        age: 25,
+        isVip: true,
+        tags: ["premium", "basic"]
+      },
+      typeControl: {
+        [RulesType.USER_ATTR]: true
+      }
+    };
+    const result = await evaluateRulesConditions(conditions, options);
+    expect(result[0].actived).toBe(true);
+    expect(result[1].actived).toBe(true);
+    expect(result[2].actived).toBe(true);
+    expect(result[3].actived).toBe(true);
+  });
+  test("should evaluate mixed attribute types with OR logic correctly", async () => {
+    const conditions = [
+      {
+        id: "or-1",
+        type: "user-attr",
+        operators: "or",
+        actived: false,
+        data: {
+          attrId: "email",
+          logic: "is",
+          value: "wrong@example.com"
+        }
+      },
+      {
+        id: "or-2",
+        type: "user-attr",
+        operators: "or",
+        actived: false,
+        data: {
+          attrId: "age",
+          logic: "isGreaterThan",
+          value: 18
+        }
+      },
+      {
+        id: "or-3",
+        type: "user-attr",
+        operators: "or",
+        actived: false,
+        data: {
+          attrId: "isVip",
+          logic: "false"
+        }
+      }
+    ];
+    const options = {
+      clientContext: mockOptions.clientContext,
+      attributes: [
+        {
+          id: "email",
+          codeName: "email",
+          dataType: BizAttributeTypes.String,
+          bizType: AttributeBizTypes.User
+        },
+        {
+          id: "age",
+          codeName: "age",
+          dataType: BizAttributeTypes.Number,
+          bizType: AttributeBizTypes.User
+        },
+        {
+          id: "isVip",
+          codeName: "isVip",
+          dataType: BizAttributeTypes.Boolean,
+          bizType: AttributeBizTypes.User
+        }
+      ],
+      userAttributes: {
+        email: "user@example.com",
+        age: 25,
+        isVip: true
+      },
+      typeControl: {
+        [RulesType.USER_ATTR]: true
+      }
+    };
+    const result = await evaluateRulesConditions(conditions, options);
+    expect(result[0].actived).toBe(false);
+    expect(result[1].actived).toBe(true);
+    expect(result[2].actived).toBe(false);
+  });
   test("should handle rules without ID", async () => {
     const conditions = [
       {