@frontegg/entitlements-javascript-commons 1.0.1 → 1.1.0-alpha.1

package/docs/CHANGELOG.md

@@ -1,3 +1,10 @@
+# [1.1.0-alpha.1](https://github.com/frontegg/entitlements-javascript-commons/compare/v-1.0.1...v-1.1.0-alpha.1) (2023-12-31)
+
+
+### Features
+
+* **plans:** add plan evaluator ([8bf997a](https://github.com/frontegg/entitlements-javascript-commons/commit/8bf997aad41335e7f07e7ddcd88fcaedfcd318fa))
+
 ## [1.0.1](https://github.com/frontegg/entitlements-javascript-commons/compare/v-1.0.0...v-1.0.1) (2023-11-06)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@frontegg/entitlements-javascript-commons",
-  "version": "1.0.1",
+  "version": "1.1.0-alpha.1",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/plans/index.ts

@@ -0,0 +1,2 @@
+export * from './plan.evaluator';
+export { Plan, PlanEvaluationResult } from './types';

package/src/plans/plan.evaluator.ts

@@ -0,0 +1,20 @@
+import { Rule, RuleEvaluationResultEnum, createRuleEvaluator } from '../rules';
+import { Plan, PlanEvaluationResult } from './types';
+
+export function evaluatePlan(plan: Plan, attributes: Record<string, unknown>): PlanEvaluationResult {
+  const treatableRule = findTreatableRule(plan, attributes);
+  if (treatableRule) {
+    return { treatment: treatableRule.treatment };
+  }
+
+  return { treatment: plan.defaultTreatment };
+}
+
+function findTreatableRule(plan: Plan, attributes: Record<string, unknown>): Rule | undefined {
+  return plan.rules?.find((rule) => {
+    const evaluator = createRuleEvaluator({ rule });
+    const result = evaluator(attributes);
+
+    return result === RuleEvaluationResultEnum.Treatable;
+  });
+}

package/src/plans/tests/plans.evaluator.spec.ts

@@ -0,0 +1,121 @@
+import { ConditionLogicEnum, TreatmentEnum } from '../../rules';
+import { OperationEnum } from '../../operations/types';
+import { Plan } from '../types';
+import { evaluatePlan } from '../plan.evaluator';
+
+type PlanCreator = (data?: Partial<Plan>) => Plan;
+const planFactory: PlanCreator = (data?: Partial<Plan>) => ({
+  defaultTreatment: TreatmentEnum.False,
+  ...data,
+});
+
+describe('evaluatePlan', () => {
+  describe('default treatment', () => {
+    it('should return false when no rule is valid and defaultTreatment is false', () => {
+      const plan: Plan = planFactory({
+        rules: [
+          {
+            treatment: TreatmentEnum.True,
+            conditions: [
+              {
+                attribute: 'test',
+                op: 'not supported' as any,
+                value: { list: ['test'] },
+                negate: false,
+              },
+            ],
+            conditionLogic: ConditionLogicEnum.And,
+          },
+        ],
+      });
+
+      const result = evaluatePlan(plan, {});
+
+      expect(result).toEqual({ treatment: TreatmentEnum.False });
+    });
+
+    it('should return true when no rule is valid and defaultTreatment is true', () => {
+      const plan: Plan = planFactory({
+        defaultTreatment: TreatmentEnum.True,
+        rules: [
+          {
+            treatment: TreatmentEnum.True,
+            conditions: [
+              {
+                attribute: 'test',
+                op: 'not supported' as any,
+                value: { list: ['test'] },
+                negate: false,
+              },
+            ],
+            conditionLogic: ConditionLogicEnum.And,
+          },
+        ],
+      });
+
+      const result = evaluatePlan(plan, {});
+
+      expect(result).toEqual({ treatment: TreatmentEnum.True });
+    });
+  });
+
+  describe('complete evaluation', () => {
+    it('should return false according to first treatable rule', () => {
+      const plan: Plan = planFactory({
+        rules: [
+          {
+            treatment: TreatmentEnum.False,
+            conditions: [
+              {
+                attribute: 'attribute',
+                op: OperationEnum.InList,
+                value: { list: ['test'] },
+                negate: false,
+              },
+            ],
+            conditionLogic: ConditionLogicEnum.And,
+          },
+        ],
+      });
+
+      const result = evaluatePlan(plan, { attribute: 'test' });
+
+      expect(result).toEqual({ treatment: TreatmentEnum.False });
+    });
+
+    it('should return true according to first treatable rule', () => {
+      const plan: Plan = planFactory({
+        rules: [
+          {
+            treatment: TreatmentEnum.False,
+            conditions: [
+              {
+                attribute: 'test',
+                op: 'not supported' as any,
+                value: { list: ['test'] },
+                negate: false,
+              },
+            ],
+            conditionLogic: ConditionLogicEnum.And,
+          },
+          {
+            treatment: TreatmentEnum.True,
+            conditions: [
+              {
+                attribute: 'attribute',
+                op: OperationEnum.InList,
+                value: { list: ['test'] },
+                negate: false,
+              },
+            ],
+            conditionLogic: ConditionLogicEnum.And,
+          },
+        ],
+      });
+
+      const result = evaluatePlan(plan, { attribute: 'test' });
+
+      expect(result).toEqual({ treatment: TreatmentEnum.True });
+    });
+  });
+});

package/src/plans/types.ts

@@ -0,0 +1,11 @@
+import { Rule, TreatmentEnum } from '../rules';
+
+export interface Plan {
+    defaultTreatment: TreatmentEnum;
+    rules?: Rule[];
+}
+
+export interface PlanEvaluationResult {
+    treatment: TreatmentEnum;
+  }
+