@frontegg/entitlements-javascript-commons 1.0.0-alpha.1 → 1.0.0-alpha.3

package/dist/operations/types/index.d.ts

@@ -0,0 +1,15 @@
+import { OperationEnum } from './operation.enum';
+import { StringOperationPayload } from '../string';
+import { NumericOperationPayload } from '../numeric';
+import { DateOperationPayload } from '../date';
+import { BooleanOperationPayload } from '../boolean/types';
+export interface OperationResult {
+    isValid: boolean;
+}
+export type ConditionValue = StringOperationPayload | NumericOperationPayload | DateOperationPayload | BooleanOperationPayload;
+export type OperationHandler = (attribute: any) => OperationResult;
+export type OperationContextEnricher = (value: ConditionValue) => OperationHandler;
+export type OperationsMapper = {
+    [key in OperationEnum]?: OperationContextEnricher;
+};
+export * from './operation.enum';

package/dist/operations/types/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./operation.enum"), exports);
+//# sourceMappingURL=index.js.map

package/dist/operations/types/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/operations/types/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAqBA,mDAAiC"}

package/dist/operations/types/operation.enum.d.ts

@@ -0,0 +1,18 @@
+export declare enum OperationEnum {
+    InList = "in_list",
+    StartsWith = "starts_with",
+    EndsWith = "ends_with",
+    Contains = "contains",
+    Matches = "matches",
+    Equal = "equal",
+    GreaterThan = "greater_than",
+    GreaterThanEqual = "greater_than_equal",
+    LesserThan = "lower_than",
+    LesserThanEqual = "lower_than_equal",
+    BetweenNumeric = "between_numeric",
+    Is = "is",
+    On = "on",
+    BetweenDate = "between_date",
+    OnOrAfter = "on_or_after",
+    OnOrBefore = "on_or_before"
+}

package/dist/operations/types/operation.enum.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OperationEnum = void 0;
+var OperationEnum;
+(function (OperationEnum) {
+    // String Operations
+    OperationEnum["InList"] = "in_list";
+    OperationEnum["StartsWith"] = "starts_with";
+    OperationEnum["EndsWith"] = "ends_with";
+    OperationEnum["Contains"] = "contains";
+    OperationEnum["Matches"] = "matches";
+    // Numeric Operations
+    OperationEnum["Equal"] = "equal";
+    OperationEnum["GreaterThan"] = "greater_than";
+    OperationEnum["GreaterThanEqual"] = "greater_than_equal";
+    OperationEnum["LesserThan"] = "lower_than";
+    OperationEnum["LesserThanEqual"] = "lower_than_equal";
+    OperationEnum["BetweenNumeric"] = "between_numeric";
+    // Boolean Operations
+    OperationEnum["Is"] = "is";
+    // Date Operations
+    OperationEnum["On"] = "on";
+    OperationEnum["BetweenDate"] = "between_date";
+    OperationEnum["OnOrAfter"] = "on_or_after";
+    OperationEnum["OnOrBefore"] = "on_or_before";
+})(OperationEnum = exports.OperationEnum || (exports.OperationEnum = {}));
+//# sourceMappingURL=operation.enum.js.map

package/dist/operations/types/operation.enum.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"operation.enum.js","sourceRoot":"","sources":["../../../src/operations/types/operation.enum.ts"],"names":[],"mappings":";;;AAAA,IAAY,aAwBX;AAxBD,WAAY,aAAa;IACvB,oBAAoB;IACpB,mCAAkB,CAAA;IAClB,2CAA0B,CAAA;IAC1B,uCAAsB,CAAA;IACtB,sCAAqB,CAAA;IACrB,oCAAmB,CAAA;IAEnB,qBAAqB;IACrB,gCAAe,CAAA;IACf,6CAA4B,CAAA;IAC5B,wDAAuC,CAAA;IACvC,0CAAyB,CAAA;IACzB,qDAAoC,CAAA;IACpC,mDAAkC,CAAA;IAElC,qBAAqB;IACrB,0BAAS,CAAA;IAET,kBAAkB;IAClB,0BAAS,CAAA;IACT,6CAA4B,CAAA;IAC5B,0CAAyB,CAAA;IACzB,4CAA2B,CAAA;AAC7B,CAAC,EAxBW,aAAa,GAAb,qBAAa,KAAb,qBAAa,QAwBxB"}

package/dist/rules/index.d.ts

@@ -0,0 +1,2 @@
+export * from './types';
+export * from './rule.evaluator';

package/dist/rules/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./types"), exports);
+__exportStar(require("./rule.evaluator"), exports);
+//# sourceMappingURL=index.js.map

package/dist/rules/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/rules/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,0CAAwB;AACxB,mDAAiC"}

package/dist/rules/rule.evaluator.d.ts

@@ -0,0 +1,2 @@
+import { CreateRuleEvaluatorPayload, RuleEvaluator } from './types';
+export declare function createRuleEvaluator(payload: CreateRuleEvaluatorPayload): RuleEvaluator;

package/dist/rules/rule.evaluator.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRuleEvaluator = void 0;
+const types_1 = require("./types");
+const conditions_1 = require("../conditions");
+function createRuleEvaluator(payload) {
+    return (attributes) => {
+        const isRuleTreatable = payload.rule.conditions.every((condition) => {
+            const evaluator = (0, conditions_1.createConditionEvaluator)({ condition });
+            return evaluator(attributes);
+        });
+        return isRuleTreatable ? types_1.RuleEvaluationResultEnum.Treatable : types_1.RuleEvaluationResultEnum.Insufficient;
+    };
+}
+exports.createRuleEvaluator = createRuleEvaluator;
+//# sourceMappingURL=rule.evaluator.js.map

package/dist/rules/rule.evaluator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule.evaluator.js","sourceRoot":"","sources":["../../src/rules/rule.evaluator.ts"],"names":[],"mappings":";;;AAAA,mCAA8F;AAC9F,8CAAyD;AAEzD,SAAgB,mBAAmB,CAAC,OAAmC;IACrE,OAAO,CAAC,UAAmC,EAA4B,EAAE;QACvE,MAAM,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,SAAS,EAAE,EAAE;YAClE,MAAM,SAAS,GAAG,IAAA,qCAAwB,EAAC,EAAE,SAAS,EAAE,CAAC,CAAC;YAE1D,OAAO,SAAS,CAAC,UAAU,CAAC,CAAC;QAC/B,CAAC,CAAC,CAAC;QAEH,OAAO,eAAe,CAAC,CAAC,CAAC,gCAAwB,CAAC,SAAS,CAAC,CAAC,CAAC,gCAAwB,CAAC,YAAY,CAAC;IACtG,CAAC,CAAC;AACJ,CAAC;AAVD,kDAUC"}

package/dist/rules/types.d.ts

@@ -0,0 +1,21 @@
+import { Condition } from '../conditions';
+export interface Rule {
+    conditionLogic: ConditionLogicEnum.And;
+    conditions: Condition[];
+    treatment: TreatmentEnum;
+}
+export declare enum ConditionLogicEnum {
+    And = "and"
+}
+export declare enum TreatmentEnum {
+    True = "true",
+    False = "false"
+}
+export declare enum RuleEvaluationResultEnum {
+    Treatable = "treatable",
+    Insufficient = "insufficient"
+}
+export interface CreateRuleEvaluatorPayload {
+    rule: Rule;
+}
+export type RuleEvaluator = (attributes: Record<string, unknown>) => RuleEvaluationResultEnum;

package/dist/rules/types.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RuleEvaluationResultEnum = exports.TreatmentEnum = exports.ConditionLogicEnum = void 0;
+var ConditionLogicEnum;
+(function (ConditionLogicEnum) {
+    ConditionLogicEnum["And"] = "and";
+})(ConditionLogicEnum = exports.ConditionLogicEnum || (exports.ConditionLogicEnum = {}));
+var TreatmentEnum;
+(function (TreatmentEnum) {
+    TreatmentEnum["True"] = "true";
+    TreatmentEnum["False"] = "false";
+})(TreatmentEnum = exports.TreatmentEnum || (exports.TreatmentEnum = {}));
+var RuleEvaluationResultEnum;
+(function (RuleEvaluationResultEnum) {
+    RuleEvaluationResultEnum["Treatable"] = "treatable";
+    RuleEvaluationResultEnum["Insufficient"] = "insufficient";
+})(RuleEvaluationResultEnum = exports.RuleEvaluationResultEnum || (exports.RuleEvaluationResultEnum = {}));
+//# sourceMappingURL=types.js.map

package/dist/rules/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/rules/types.ts"],"names":[],"mappings":";;;AAQA,IAAY,kBAEX;AAFD,WAAY,kBAAkB;IAC5B,iCAAW,CAAA;AACb,CAAC,EAFW,kBAAkB,GAAlB,0BAAkB,KAAlB,0BAAkB,QAE7B;AAED,IAAY,aAGX;AAHD,WAAY,aAAa;IACvB,8BAAa,CAAA;IACb,gCAAe,CAAA;AACjB,CAAC,EAHW,aAAa,GAAb,qBAAa,KAAb,qBAAa,QAGxB;AAED,IAAY,wBAGX;AAHD,WAAY,wBAAwB;IAClC,mDAAuB,CAAA;IACvB,yDAA6B,CAAA;AAC/B,CAAC,EAHW,wBAAwB,GAAxB,gCAAwB,KAAxB,gCAAwB,QAGnC"}

package/docs/CHANGELOG.md

@@ -1,3 +1,20 @@
+# [1.0.0-alpha.3](https://github.com/frontegg/entitlements-javascript-commons/compare/v-1.0.0-alpha.2...v-1.0.0-alpha.3) (2023-10-04)
+
+
+### Features
+
+* **feature-flags:** add feature flag evaluation ([#11](https://github.com/frontegg/entitlements-javascript-commons/issues/11)) ([94679a1](https://github.com/frontegg/entitlements-javascript-commons/commit/94679a123581cd4977fd9f2087adc9e2532a638c))
+
+# [1.0.0-alpha.2](https://github.com/frontegg/entitlements-javascript-commons/compare/v-1.0.0-alpha.1...v-1.0.0-alpha.2) (2023-10-03)
+
+### Features
+
+* **rule:** add rule evaluator ([#6](https://github.com/frontegg/entitlements-javascript-commons/issues/6)) ([5fbf4da](https://github.com/frontegg/entitlements-javascript-commons/commit/5fbf4da00a3d9df2908d8899723a64b1bd80a7c2))
+* create pipeline and release infra ([16fd6d1](https://github.com/frontegg/entitlements-javascript-commons/commit/16fd6d165cff4c3ae28e2392db2480d41dd591b1))
+* **conditions:** add condition evaluator ([#5](https://github.com/frontegg/entitlements-javascript-commons/issues/5)) ([5ca2446](https://github.com/frontegg/entitlements-javascript-commons/commit/5ca24465a76b9fa103977e5600a6d870da5520cb))
+* **operations:** add numeric operations ([#3](https://github.com/frontegg/entitlements-javascript-commons/issues/3)) ([#10](https://github.com/frontegg/entitlements-javascript-commons/issues/10)) ([0b3de2f](https://github.com/frontegg/entitlements-javascript-commons/commit/0b3de2f7f1aede036ec63e4fadf898dcf5ad32a4))
+* **operations:** add string operations ([#2](https://github.com/frontegg/entitlements-javascript-commons/issues/2)) ([e2e63a7](https://github.com/frontegg/entitlements-javascript-commons/commit/e2e63a74211a723dc326918e42e2093fcca86779))
+
 # 1.0.0-alpha.1 (2023-10-03)
 
 

package/jest.config.js

@@ -0,0 +1,26 @@
+module.exports = {
+  transform: { '^.+\\.ts?$': 'ts-jest' },
+  testEnvironment: 'node',
+  testRegex: 'src/.*\\.(test|spec)?\\.(ts|tsx)$',
+  moduleFileExtensions: ['ts', 'js', 'json', 'node'],
+  rootDir: '.',
+  collectCoverageFrom: ['src/**/*.{js,ts}', '!**/node_modules/**', '!**/dist/**', '!**/vendor/**'],
+  coverageThreshold: {
+    global: {
+      statements: 17,
+      branches: 24,
+      functions: 20,
+      lines: 18,
+    },
+  },
+  reporters: [
+    'default',
+    [
+      'jest-junit',
+      {
+        outputDirectory: 'test-results',
+        outputName: 'jest-junit.xml',
+      },
+    ],
+  ],
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@frontegg/entitlements-javascript-commons",
-  "version": "1.0.0-alpha.1",
+  "version": "1.0.0-alpha.3",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -21,8 +21,8 @@
   "author": "Frontegg",
   "license": "ISC",
   "homepage": "https://github.com/frontegg/entitlements-javascript-commons",
-  "dependencies": {},
   "devDependencies": {
+    "@fast-check/jest": "^1.7.3",
     "@semantic-release/changelog": "^6.0.1",
     "@semantic-release/git": "^10.0.1",
     "@types/jest": "^29.2.0",

package/src/conditions/condition.evaluator.ts

@@ -0,0 +1,20 @@
+import { Condition } from './types';
+import { useOperation } from '../operations/components/operation.resolver';
+
+export interface CreateConditionEvaluatorPayload {
+  condition: Condition;
+}
+
+export type ConditionEvaluator = (attributes: Record<string, unknown>) => boolean;
+
+export function createConditionEvaluator(payload: CreateConditionEvaluatorPayload): ConditionEvaluator {
+  const operation = useOperation(payload.condition.op, payload.condition.value);
+
+  return (attributes: Record<string, unknown>) => {
+    const attributeKey = payload.condition.attribute;
+    const value = attributes[attributeKey];
+    const { isValid: result } = value !== undefined && operation ? operation(value) : { isValid: false };
+
+    return payload.condition.negate ? !result : result;
+  };
+}

package/src/conditions/index.ts

@@ -0,0 +1,2 @@
+export * from './condition.evaluator';
+export * from './types';

package/src/conditions/tests/condition.evaluator.spec.ts

@@ -0,0 +1,52 @@
+import { createConditionEvaluator } from '../condition.evaluator';
+import { OperationEnum } from '../../operations/types';
+
+describe('ConditionEvaluator', () => {
+  it('should return false when condition operation is undefined', () => {
+    const conditionEvaluator = createConditionEvaluator({
+      condition: { op: 'not supported' as any, value: { string: 'test' }, negate: false, attribute: 'test' },
+    });
+
+    expect(conditionEvaluator({})).toEqual(false);
+  });
+
+  it('should return false when attribute value is undefined', () => {
+    const attributeKey = 'vendorId';
+    const attributes = { [attributeKey]: undefined };
+    const conditionEvaluator = createConditionEvaluator({
+      condition: { op: OperationEnum.Contains, value: { list: ['test'] }, negate: false, attribute: attributeKey },
+    });
+
+    expect(conditionEvaluator(attributes)).toEqual(false);
+  });
+
+  it('should return false when attribute fails operation validation', () => {
+    const attributeKey = 'vendorId';
+    const attributes = { [attributeKey]: 'Vendor' };
+    const conditionEvaluator = createConditionEvaluator({
+      condition: { op: OperationEnum.Contains, value: { list: ['test'] }, negate: false, attribute: attributeKey },
+    });
+
+    expect(conditionEvaluator(attributes)).toEqual(false);
+  });
+
+  it('should return true when attribute succeeds operation validation', () => {
+    const attributeKey = 'vendorId';
+    const attributes = { [attributeKey]: 'testVendor' };
+    const conditionEvaluator = createConditionEvaluator({
+      condition: { op: OperationEnum.Contains, value: { list: ['test'] }, negate: false, attribute: attributeKey },
+    });
+
+    expect(conditionEvaluator(attributes)).toEqual(true);
+  });
+
+  it('should return false when attribute succeeds operation validation with negate', () => {
+    const attributeKey = 'vendorId';
+    const attributes = { [attributeKey]: 'testVendor' };
+    const conditionEvaluator = createConditionEvaluator({
+      condition: { op: OperationEnum.Contains, value: { list: ['test'] }, negate: true, attribute: attributeKey },
+    });
+
+    expect(conditionEvaluator(attributes)).toEqual(false);
+  });
+});

package/src/conditions/types.ts

@@ -0,0 +1,8 @@
+import { ConditionValue, OperationEnum } from '../operations/types';
+
+export interface Condition {
+  attribute: string;
+  negate: boolean;
+  op: OperationEnum;
+  value: ConditionValue;
+}

package/src/feature-flags/feature-flag.evaluator.ts

@@ -0,0 +1,27 @@
+import { FeatureFlag, FeatureFlagEvaluationResult } from './types';
+import { createRuleEvaluator, Rule, RuleEvaluationResultEnum } from '../rules';
+
+export function evaluateFeatureFlag(
+  featureFlag: FeatureFlag,
+  attributes: Record<string, unknown>,
+): FeatureFlagEvaluationResult {
+  if (!featureFlag.on) {
+    return { treatment: featureFlag.offTreatment };
+  }
+
+  const treatableRule = findTreatableRule(featureFlag, attributes);
+  if (treatableRule) {
+    return { treatment: treatableRule.treatment };
+  }
+
+  return { treatment: featureFlag.defaultTreatment };
+}
+
+function findTreatableRule(featureFlag: FeatureFlag, attributes: Record<string, unknown>): Rule | undefined {
+  return featureFlag.rules?.find((rule) => {
+    const evaluator = createRuleEvaluator({ rule });
+    const result = evaluator(attributes);
+
+    return result === RuleEvaluationResultEnum.Treatable;
+  });
+}

package/src/feature-flags/index.ts

@@ -0,0 +1 @@
+export * from './feature-flag.evaluator';

package/src/feature-flags/tests/feature-flag.evaluator.spec.ts

@@ -0,0 +1,176 @@
+import { ConditionLogicEnum, TreatmentEnum } from '../../rules';
+import { evaluateFeatureFlag } from '../feature-flag.evaluator';
+import { FeatureFlag } from '../types';
+import { OperationEnum } from '../../operations/types';
+
+type FeatureFlagCreator = (data?: Partial<FeatureFlag>) => FeatureFlag;
+const featureFlagFactory: FeatureFlagCreator = (data?: Partial<FeatureFlag>) => ({
+  on: false,
+  offTreatment: TreatmentEnum.False,
+  defaultTreatment: TreatmentEnum.False,
+  ...data,
+});
+
+describe('evaluateFeatureFlag', () => {
+  describe('off treatment', () => {
+    it('should return false when feature flag is turned off and offTreatment is false', () => {
+      const featureFlag: FeatureFlag = featureFlagFactory({
+        rules: [
+          {
+            treatment: TreatmentEnum.True,
+            conditions: [
+              {
+                attribute: 'test',
+                op: 'not supported' as any,
+                value: { list: ['test'] },
+                negate: false,
+              },
+            ],
+            conditionLogic: ConditionLogicEnum.And,
+          },
+        ],
+      });
+
+      const result = evaluateFeatureFlag(featureFlag, {});
+
+      expect(result).toEqual({ treatment: TreatmentEnum.False });
+    });
+
+    it('should return true when feature flag is turned off and offTreatment is true', () => {
+      const featureFlag: FeatureFlag = featureFlagFactory({
+        offTreatment: TreatmentEnum.True,
+        rules: [
+          {
+            treatment: TreatmentEnum.True,
+            conditions: [
+              {
+                attribute: 'test',
+                op: 'not supported' as any,
+                value: { list: ['test'] },
+                negate: false,
+              },
+            ],
+            conditionLogic: ConditionLogicEnum.And,
+          },
+        ],
+      });
+
+      const result = evaluateFeatureFlag(featureFlag, {});
+
+      expect(result).toEqual({ treatment: TreatmentEnum.True });
+    });
+  });
+
+  describe('default treatment', () => {
+    it('should return false when feature flag is turned on and no rule is valid and defaultTreatment is false', () => {
+      const featureFlag: FeatureFlag = featureFlagFactory({
+        on: true,
+        rules: [
+          {
+            treatment: TreatmentEnum.True,
+            conditions: [
+              {
+                attribute: 'test',
+                op: 'not supported' as any,
+                value: { list: ['test'] },
+                negate: false,
+              },
+            ],
+            conditionLogic: ConditionLogicEnum.And,
+          },
+        ],
+      });
+
+      const result = evaluateFeatureFlag(featureFlag, {});
+
+      expect(result).toEqual({ treatment: TreatmentEnum.False });
+    });
+
+    it('should return true when feature flag is turned on and no rule is valid and defaultTreatment is true', () => {
+      const featureFlag: FeatureFlag = featureFlagFactory({
+        on: true,
+        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 = evaluateFeatureFlag(featureFlag, {});
+
+      expect(result).toEqual({ treatment: TreatmentEnum.True });
+    });
+  });
+
+  describe('complete evaluation', () => {
+    it('should return false according to first treatable rule when feature flag is turned on', () => {
+      const featureFlag: FeatureFlag = featureFlagFactory({
+        on: true,
+        rules: [
+          {
+            treatment: TreatmentEnum.False,
+            conditions: [
+              {
+                attribute: 'attribute',
+                op: OperationEnum.InList,
+                value: { list: ['test'] },
+                negate: false,
+              },
+            ],
+            conditionLogic: ConditionLogicEnum.And,
+          },
+        ],
+      });
+
+      const result = evaluateFeatureFlag(featureFlag, { attribute: 'test' });
+
+      expect(result).toEqual({ treatment: TreatmentEnum.False });
+    });
+
+    it('should return true according to first treatable rule when feature flag is turned on', () => {
+      const featureFlag: FeatureFlag = featureFlagFactory({
+        on: true,
+        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 = evaluateFeatureFlag(featureFlag, { attribute: 'test' });
+
+      expect(result).toEqual({ treatment: TreatmentEnum.True });
+    });
+  });
+});

package/src/feature-flags/types.ts

@@ -0,0 +1,12 @@
+import { Rule, TreatmentEnum } from '../rules';
+
+export interface FeatureFlag {
+  on: boolean;
+  offTreatment: TreatmentEnum;
+  defaultTreatment: TreatmentEnum;
+  rules?: Rule[];
+}
+
+export interface FeatureFlagEvaluationResult {
+  treatment: TreatmentEnum;
+}

package/src/index.ts

@@ -1,3 +1 @@
-export const evaluateFeatureFlag = (): boolean => {
-  return false;
-};
+export { evaluateFeatureFlag } from './feature-flags';

package/src/operations/boolean/index.ts

@@ -0,0 +1,9 @@
+import { OperationEnum, OperationsMapper } from '../types';
+import { useIsOperation } from './operations';
+import { BooleanOperationPayload } from './types';
+
+export * from './operations';
+
+export const BooleanOperationsMapper: OperationsMapper = {
+  [OperationEnum.Is]: (value) => useIsOperation(value as BooleanOperationPayload),
+};

package/src/operations/boolean/operations.spec.ts

@@ -0,0 +1,13 @@
+import { fc, test } from '@fast-check/jest';
+import { useIsOperation } from './operations';
+
+describe('Boolean operations', () => {
+  test.prop([fc.boolean(), fc.boolean()], { verbose: true })(
+    'should return correct validity if the boolean values equal',
+    (boolean, attribute) => {
+      const result = useIsOperation({ boolean })(attribute);
+
+      return (attribute === boolean) === result.isValid;
+    },
+  );
+});

package/src/operations/boolean/operations.ts

@@ -0,0 +1,6 @@
+import { OperationHandler } from '../types';
+import { BooleanOperationPayload } from './types';
+
+export function useIsOperation(payload: BooleanOperationPayload): OperationHandler {
+  return (attribute: boolean) => ({ isValid: attribute === payload.boolean });
+}

package/src/operations/boolean/types.ts

@@ -0,0 +1,3 @@
+export interface BooleanOperationPayload {
+  boolean: boolean;
+}

package/src/operations/components/operation.resolver.ts

@@ -0,0 +1,18 @@
+import { ConditionValue, OperationEnum, OperationHandler, OperationsMapper } from '../types';
+import { StringOperationsMapper } from '../string';
+import { NumericOperationsMapper } from '../numeric';
+import { DateOperationsMapper } from '../date';
+import { BooleanOperationsMapper } from '../boolean';
+
+const operationEnrichersMapper: OperationsMapper = {
+  ...StringOperationsMapper,
+  ...NumericOperationsMapper,
+  ...DateOperationsMapper,
+  ...BooleanOperationsMapper,
+};
+
+export function useOperation(operation: OperationEnum, value: ConditionValue): OperationHandler | undefined {
+  const operationContextEnricher = operationEnrichersMapper[operation];
+
+  return operationContextEnricher ? operationContextEnricher(value) : undefined;
+}

package/src/operations/components/tests/operation.resolver.spec.ts

@@ -0,0 +1,8 @@
+import { useOperation } from '../operation.resolver';
+
+describe('OperationResolver', () => {
+  it('should return undefined when operation is not supported', () => {
+    const operation = useOperation('not supported' as any, { string: 'test' });
+    expect(operation).toEqual(undefined);
+  });
+});