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

package/.github/workflows/publish.yaml

@@ -2,7 +2,7 @@ name: Publish
 
 on:
   push:
-    branches: [ master, ci ]
+    branches: [ master, next ]
 
 env:
   GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}

package/.releaserc.yaml

@@ -1,8 +1,8 @@
 branches:
   - master
-  - name: ci
+  - name: next
     prerelease: 'alpha'
-tagFormat: "${version}"
+tagFormat: "v-${version}"
 ci: true
 preset: "angular"
 plugins:

package/docs/CHANGELOG.md

@@ -1,3 +1,79 @@
+# [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))
+
+# 1.0.0-alpha.1 (2023-10-03)
+
+
+### Features
+
+* 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)
+
+
+### Bug Fixes
+
+* fix changelog ([7c7515b](https://github.com/frontegg/entitlements-javascript-commons/commit/7c7515b78e980695506e061dc8f942669b97626f))
+
+
+### Features
+
+* 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)
+
+
+### Bug Fixes
+
+* fix alpha version ([4efb4b5](https://github.com/frontegg/entitlements-javascript-commons/commit/4efb4b5e3944caa117f8e1fa5640f3d640018d74))
+* fix changelog ([560b31a](https://github.com/frontegg/entitlements-javascript-commons/commit/560b31a00c2e14c7e0708c88f454363e537ecdce))
+
+
+### Features
+
+* 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.5 (2023-10-03)
+
+
+### Bug Fixes
+
+* fix alpha version ([4efb4b5](https://github.com/frontegg/entitlements-javascript-commons/commit/4efb4b5e3944caa117f8e1fa5640f3d640018d74))
+
+# 1.0.0-alpha.4 (2023-10-03)
+
+
+### Features
+
+* **conditions:** add condition evaluator ([#5](https://github.com/frontegg/entitlements-javascript-commons/issues/5)) ([5ca2446](https://github.com/frontegg/entitlements-javascript-commons/commit/5ca24465a76b9fa103977e5600a6d870da5520cb))
+
+# 1.0.0-alpha.3 (2023-10-03)
+
+
+### Features
+
+* **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))
+
+# 1.0.0-alpha.2 (2023-10-03)
+
+
+### Features
+
+* **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.2",
   "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, any>) => boolean;
+
+export function createConditionEvaluator(payload: CreateConditionEvaluatorPayload): ConditionEvaluator {
+  const operation = useOperation(payload.condition.op, payload.condition.value);
+
+  return (attributes: Record<string, any>) => {
+    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/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);
+  });
+});

package/src/operations/date/index.ts

@@ -0,0 +1,18 @@
+import { OperationEnum, OperationsMapper } from '../types';
+import {
+  useDateBetweenOperation,
+  useDateOnOperation,
+  useDateOnOrAfterOperation,
+  useDateOnOrBeforeOperation,
+} from './operations';
+import { BetweenDateOperationPayload, SingleDateOperationPayload } from './types';
+
+export * from './operations';
+export * from './types';
+
+export const DateOperationsMapper: OperationsMapper = {
+  [OperationEnum.On]: (value) => useDateOnOperation(value as SingleDateOperationPayload),
+  [OperationEnum.OnOrAfter]: (value) => useDateOnOrAfterOperation(value as SingleDateOperationPayload),
+  [OperationEnum.OnOrBefore]: (value) => useDateOnOrBeforeOperation(value as SingleDateOperationPayload),
+  [OperationEnum.BetweenDate]: (value) => useDateBetweenOperation(value as BetweenDateOperationPayload),
+};

package/src/operations/date/operations.spec.ts

@@ -0,0 +1,45 @@
+import {
+  useDateBetweenOperation,
+  useDateOnOperation,
+  useDateOnOrAfterOperation,
+  useDateOnOrBeforeOperation,
+} from './index';
+import { fc, test } from '@fast-check/jest';
+
+describe('Date operations', () => {
+  test.prop([fc.date(), fc.date()], { verbose: true })(
+    'should return correct validity if the dates equal',
+    (date, attribute) => {
+      const result = useDateOnOperation({ date })(attribute);
+
+      return (date.getTime() === attribute.getTime()) === result.isValid;
+    },
+  );
+
+  test.prop([fc.date(), fc.date()], { verbose: true })(
+    'should return correct validity for on or after validation for given dates',
+    (date, attribute) => {
+      const result = useDateOnOrAfterOperation({ date })(attribute);
+
+      return attribute.getTime() >= date.getTime() === result.isValid;
+    },
+  );
+
+  test.prop([fc.date(), fc.date()], { verbose: true })(
+    'should return correct validity for on or before validation for given dates',
+    (date, attribute) => {
+      const result = useDateOnOrBeforeOperation({ date })(attribute);
+
+      return attribute.getTime() <= date.getTime() === result.isValid;
+    },
+  );
+
+  test.prop([fc.date(), fc.date(), fc.date()], { verbose: true })(
+    'should return correct validity for range validation for given dates',
+    (start, end, attribute) => {
+      const result = useDateBetweenOperation({ start, end })(attribute);
+
+      return (attribute.getTime() >= start.getTime() && attribute.getTime() <= end.getTime()) === result.isValid;
+    },
+  );
+});

package/src/operations/date/operations.ts

@@ -0,0 +1,20 @@
+import { OperationHandler } from '../types';
+import { BetweenDateOperationPayload, SingleDateOperationPayload } from './types';
+
+export function useDateOnOperation(payload: SingleDateOperationPayload): OperationHandler {
+  return (attribute: Date) => ({ isValid: attribute.getTime() === payload.date.getTime() });
+}
+
+export function useDateOnOrAfterOperation(payload: SingleDateOperationPayload): OperationHandler {
+  return (attribute: Date) => ({ isValid: attribute.getTime() >= payload.date.getTime() });
+}
+
+export function useDateOnOrBeforeOperation(payload: SingleDateOperationPayload): OperationHandler {
+  return (attribute: Date) => ({ isValid: attribute.getTime() <= payload.date.getTime() });
+}
+
+export function useDateBetweenOperation(payload: BetweenDateOperationPayload): OperationHandler {
+  return (attribute: Date) => ({
+    isValid: attribute.getTime() >= payload.start.getTime() && attribute.getTime() <= payload.end.getTime(),
+  });
+}

package/src/operations/date/types.ts

@@ -0,0 +1,10 @@
+export interface SingleDateOperationPayload {
+  date: Date;
+}
+
+export interface BetweenDateOperationPayload {
+  start: Date;
+  end: Date;
+}
+
+export type DateOperationPayload = SingleDateOperationPayload | BetweenDateOperationPayload;

package/src/operations/numeric/index.ts

@@ -0,0 +1,22 @@
+import { OperationEnum, OperationsMapper } from '../types';
+import {
+  useBetweenNumericOperation,
+  useEqualsOperation,
+  useGreaterThanEqualOperation,
+  useGreaterThanOperation,
+  useLesserThanEqualOperation,
+  useLesserThanOperation,
+} from './operations';
+import { BetweenNumericOperationPayload, SingleNumericOperationPayload } from './types';
+
+export * from './operations';
+export * from './types';
+
+export const NumericOperationsMapper: OperationsMapper = {
+  [OperationEnum.Equal]: (value) => useEqualsOperation(value as SingleNumericOperationPayload),
+  [OperationEnum.GreaterThan]: (value) => useGreaterThanOperation(value as SingleNumericOperationPayload),
+  [OperationEnum.GreaterThanEqual]: (value) => useGreaterThanEqualOperation(value as SingleNumericOperationPayload),
+  [OperationEnum.LesserThan]: (value) => useLesserThanOperation(value as SingleNumericOperationPayload),
+  [OperationEnum.LesserThanEqual]: (value) => useLesserThanEqualOperation(value as SingleNumericOperationPayload),
+  [OperationEnum.BetweenNumeric]: (value) => useBetweenNumericOperation(value as BetweenNumericOperationPayload),
+};

package/src/operations/numeric/operations.spec.ts

@@ -0,0 +1,63 @@
+import {
+  useBetweenNumericOperation,
+  useEqualsOperation,
+  useGreaterThanEqualOperation,
+  useGreaterThanOperation,
+  useLesserThanOperation,
+} from './index';
+import { fc, test } from '@fast-check/jest';
+
+describe('Numeric operations', () => {
+  test.prop([fc.integer(), fc.integer()], { verbose: true })(
+    'should return true if the numbers equal',
+    (number, attribute) => {
+      const result = useEqualsOperation({ number })(attribute);
+      return (number === attribute) === result.isValid;
+    },
+  );
+
+  test.prop([fc.integer(), fc.integer()], { verbose: true })(
+    'should return correct validity value when attribute is greater than the given number',
+    (number, attribute) => {
+      const result = useGreaterThanOperation({ number })(attribute);
+
+      return attribute > number === result.isValid;
+    },
+  );
+
+  test.prop([fc.integer(), fc.integer()], { verbose: true })(
+    'should return correct validity value when attribute is greater or equals to given number',
+    (number, attribute) => {
+      const result = useGreaterThanEqualOperation({ number })(attribute);
+
+      return attribute >= number === result.isValid;
+    },
+  );
+
+  test.prop([fc.integer(), fc.integer()], { verbose: true })(
+    'should return correct validity value when attribute is lesser than then given number',
+    (number, attribute) => {
+      const result = useLesserThanOperation({ number })(attribute);
+
+      return attribute < number === result.isValid;
+    },
+  );
+
+  test.prop([fc.integer(), fc.integer()], { verbose: true })(
+    'should return correct validity value when attribute is lesser or equals to given number',
+    (number, attribute) => {
+      const result = useLesserThanOperation({ number })(attribute);
+
+      return attribute <= number === result.isValid;
+    },
+  );
+
+  test.prop([fc.integer(), fc.integer(), fc.integer()], { verbose: true })(
+    'should return correct validity value when attribute is between the given numbers',
+    (start, end, attribute) => {
+      const result = useBetweenNumericOperation({ start, end })(attribute);
+
+      return (attribute >= start && attribute <= end) === result.isValid;
+    },
+  );
+});

package/src/operations/numeric/operations.ts

@@ -0,0 +1,26 @@
+import { OperationHandler } from '../types';
+import { BetweenNumericOperationPayload, SingleNumericOperationPayload } from './types';
+
+export function useEqualsOperation(payload: SingleNumericOperationPayload): OperationHandler {
+  return (attribute: number) => ({ isValid: attribute === payload.number });
+}
+
+export function useGreaterThanOperation(payload: SingleNumericOperationPayload): OperationHandler {
+  return (attribute: number) => ({ isValid: attribute > payload.number });
+}
+
+export function useGreaterThanEqualOperation(payload: SingleNumericOperationPayload): OperationHandler {
+  return (attribute: number) => ({ isValid: attribute >= payload.number });
+}
+
+export function useLesserThanOperation(payload: SingleNumericOperationPayload): OperationHandler {
+  return (attribute: number) => ({ isValid: attribute < payload.number });
+}
+
+export function useLesserThanEqualOperation(payload: SingleNumericOperationPayload): OperationHandler {
+  return (attribute: number) => ({ isValid: attribute <= payload.number });
+}
+
+export function useBetweenNumericOperation(payload: BetweenNumericOperationPayload): OperationHandler {
+  return (attribute: number) => ({ isValid: attribute >= payload.start && attribute <= payload.end });
+}

package/src/operations/numeric/tests/operations.spec.ts

@@ -0,0 +1,64 @@
+import {
+  useBetweenNumericOperation,
+  useEqualsOperation,
+  useGreaterThanEqualOperation,
+  useGreaterThanOperation,
+  useLesserThanEqualOperation,
+  useLesserThanOperation,
+} from '../index';
+import { fc, test } from '@fast-check/jest';
+
+describe('Numeric operations', () => {
+  test.prop([fc.integer(), fc.integer()], { verbose: true })(
+    'should return true if the numbers equal',
+    (number, attribute) => {
+      const result = useEqualsOperation({ number })(attribute);
+      return (number === attribute) === result.isValid;
+    },
+  );
+
+  test.prop([fc.integer(), fc.integer()], { verbose: true })(
+    'should return correct validity value when attribute is greater than the given number',
+    (number, attribute) => {
+      const result = useGreaterThanOperation({ number })(attribute);
+
+      return attribute > number === result.isValid;
+    },
+  );
+
+  test.prop([fc.integer(), fc.integer()], { verbose: true })(
+    'should return correct validity value when attribute is greater or equals to given number',
+    (number, attribute) => {
+      const result = useGreaterThanEqualOperation({ number })(attribute);
+
+      return attribute >= number === result.isValid;
+    },
+  );
+
+  test.prop([fc.integer(), fc.integer()], { verbose: true })(
+    'should return correct validity value when attribute is lesser than then given number',
+    (number, attribute) => {
+      const result = useLesserThanOperation({ number })(attribute);
+
+      return attribute < number === result.isValid;
+    },
+  );
+
+  test.prop([fc.integer(), fc.integer()], { verbose: true })(
+    'should return correct validity value when attribute is lesser or equals to given number',
+    (number, attribute) => {
+      const result = useLesserThanEqualOperation({ number })(attribute);
+
+      return attribute <= number === result.isValid;
+    },
+  );
+
+  test.prop([fc.integer(), fc.integer(), fc.integer()], { verbose: true })(
+    'should return correct validity value when attribute is between the given numbers',
+    (start, end, attribute) => {
+      const result = useBetweenNumericOperation({ start, end })(attribute);
+
+      return (attribute >= start && attribute <= end) === result.isValid;
+    },
+  );
+});

package/src/operations/numeric/types.ts

@@ -0,0 +1,10 @@
+export interface SingleNumericOperationPayload {
+  number: number;
+}
+
+export interface BetweenNumericOperationPayload {
+  start: number;
+  end: number;
+}
+
+export type NumericOperationPayload = SingleNumericOperationPayload | BetweenNumericOperationPayload;

package/src/operations/string/index.ts

@@ -0,0 +1,20 @@
+import { OperationEnum, OperationsMapper } from '../types';
+import {
+  useContainsOperation,
+  useEndsWithOperation,
+  useInListOperation,
+  useMatchesOperation,
+  useStartsWithOperation,
+} from './operations';
+import { ListStringOperationPayload, SingleStringOperationPayload } from './types';
+
+export * from './operations';
+export * from './types';
+
+export const StringOperationsMapper: OperationsMapper = {
+  [OperationEnum.StartsWith]: (value) => useStartsWithOperation(value as ListStringOperationPayload),
+  [OperationEnum.EndsWith]: (value) => useEndsWithOperation(value as ListStringOperationPayload),
+  [OperationEnum.Contains]: (value) => useContainsOperation(value as ListStringOperationPayload),
+  [OperationEnum.InList]: (value) => useInListOperation(value as ListStringOperationPayload),
+  [OperationEnum.Matches]: (value) => useMatchesOperation(value as SingleStringOperationPayload),
+};

package/src/operations/string/operations.spec.ts

@@ -0,0 +1,38 @@
+import { useContainsOperation, useEndsWithOperation, useInListOperation, useStartsWithOperation } from './index';
+import { fc, test } from '@fast-check/jest';
+
+describe('String operations', () => {
+  test.prop([fc.array(fc.string()), fc.string()], { verbose: true })(
+    'should return correct validity if one of the strings starts with the given prefix',
+    (list, prefix) => {
+      const result = useStartsWithOperation({ list })(prefix);
+      return list.some((value) => prefix.startsWith(value)) === result.isValid;
+    },
+  );
+
+  test.prop([fc.array(fc.string()), fc.string()], { verbose: true })(
+    'should return correct validity if one of the strings ends with the given suffix',
+    (list, suffix) => {
+      const result = useEndsWithOperation({ list })(suffix);
+      return list.some((value) => suffix.endsWith(value)) === result.isValid;
+    },
+  );
+
+  test.prop([fc.array(fc.string()), fc.string()], { verbose: true })(
+    'should return correct validity if one of the strings contains with given attribute',
+    (list, included) => {
+      const result = useContainsOperation({ list })(included);
+
+      return list.some((value) => included.includes(value)) === result.isValid;
+    },
+  );
+
+  test.prop([fc.array(fc.string()), fc.string()], { verbose: true })(
+    'should return correct validity if one of the strings is in the given list',
+    (list, string) => {
+      const result = useInListOperation({ list })(string);
+
+      return list.includes(string) === result.isValid;
+    },
+  );
+});

package/src/operations/string/operations.ts

@@ -0,0 +1,32 @@
+import { OperationHandler } from '../types';
+import { ListStringOperationPayload, SingleStringOperationPayload } from './types';
+
+export function useStartsWithOperation(payload: ListStringOperationPayload): OperationHandler {
+  return (attribute: string) => ({ isValid: payload.list.some((value) => attribute.startsWith(value)) });
+}
+
+export function useEndsWithOperation(payload: ListStringOperationPayload): OperationHandler {
+  return (attribute: string) => ({ isValid: payload.list.some((value) => attribute.endsWith(value)) });
+}
+
+export function useContainsOperation(payload: ListStringOperationPayload): OperationHandler {
+  return (attribute: string) => ({ isValid: payload.list.some((value) => attribute.includes(value)) });
+}
+
+export function useInListOperation(payload: ListStringOperationPayload): OperationHandler {
+  return (attribute: string) => ({ isValid: payload.list.includes(attribute) });
+}
+
+export function useMatchesOperation(payload: SingleStringOperationPayload): OperationHandler {
+  return (attribute: string) => {
+    let expression: RegExp;
+
+    try {
+      expression = new RegExp(payload.string);
+    } catch (e) {
+      return { isValid: false };
+    }
+
+    return { isValid: expression.test(attribute) };
+  };
+}

package/src/operations/string/tests/operations.spec.ts

@@ -0,0 +1,38 @@
+import { useContainsOperation, useEndsWithOperation, useInListOperation, useStartsWithOperation } from '../index';
+import { fc, test } from '@fast-check/jest';
+
+describe('String operations', () => {
+  test.prop([fc.array(fc.string()), fc.string()], { verbose: true })(
+    'should return correct validity if one of the strings starts with the given prefix',
+    (list, prefix) => {
+      const result = useStartsWithOperation({ list })(prefix);
+      return list.some((value) => prefix.startsWith(value)) === result.isValid;
+    },
+  );
+
+  test.prop([fc.array(fc.string()), fc.string()], { verbose: true })(
+    'should return correct validity if one of the strings ends with the given suffix',
+    (list, suffix) => {
+      const result = useEndsWithOperation({ list })(suffix);
+      return list.some((value) => suffix.endsWith(value)) === result.isValid;
+    },
+  );
+
+  test.prop([fc.array(fc.string()), fc.string()], { verbose: true })(
+    'should return correct validity if one of the strings contains with given attribute',
+    (list, included) => {
+      const result = useContainsOperation({ list })(included);
+
+      return list.some((value) => included.includes(value)) === result.isValid;
+    },
+  );
+
+  test.prop([fc.array(fc.string()), fc.string()], { verbose: true })(
+    'should return correct validity if one of the strings is in the given list',
+    (list, string) => {
+      const result = useInListOperation({ list })(string);
+
+      return list.includes(string) === result.isValid;
+    },
+  );
+});

package/src/operations/string/types.ts

@@ -0,0 +1,9 @@
+export interface ListStringOperationPayload {
+  list: string[];
+}
+
+export interface SingleStringOperationPayload {
+  string: string;
+}
+
+export type StringOperationPayload = ListStringOperationPayload | SingleStringOperationPayload;

package/src/operations/types/index.ts

@@ -0,0 +1,22 @@
+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;
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type OperationHandler = (attribute: any) => OperationResult;
+export type OperationContextEnricher = (value: ConditionValue) => OperationHandler;
+export type OperationsMapper = { [key in OperationEnum]?: OperationContextEnricher };
+
+export * from './operation.enum';

package/src/operations/types/operation.enum.ts

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

package/src/rules/index.ts

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

package/src/rules/rule.evaluator.ts

@@ -0,0 +1,14 @@
+import { CreateRuleEvaluatorPayload, RuleEvaluationResultEnum, RuleEvaluator } from './types';
+import { createConditionEvaluator } from '../conditions';
+
+export function createRuleEvaluator(payload: CreateRuleEvaluatorPayload): RuleEvaluator {
+  return (attributes: Record<string, any>): RuleEvaluationResultEnum => {
+    const isRuleTreatable = payload.rule.conditions.every((condition) => {
+      const evaluator = createConditionEvaluator({ condition });
+
+      return evaluator(attributes);
+    });
+
+    return isRuleTreatable ? RuleEvaluationResultEnum.Treatable : RuleEvaluationResultEnum.Insufficient;
+  };
+}

package/src/rules/tests/rule.evaluator.spec.ts

@@ -0,0 +1,140 @@
+import { ConditionLogicEnum, Rule, RuleEvaluationResultEnum, TreatmentEnum } from '../types';
+import { createRuleEvaluator } from '../rule.evaluator';
+import { OperationEnum } from '../../operations/types';
+
+describe('RuleEvaluator', () => {
+  it('should return RuleEvaluationResultEnum.Insufficient when conditions are invalid', () => {
+    const rule: Rule = {
+      treatment: TreatmentEnum.True,
+      description: 'test',
+      conditions: [
+        {
+          attribute: 'test',
+          op: 'not supported' as any,
+          value: { list: ['test'] },
+          negate: false,
+        },
+      ],
+      conditionLogic: ConditionLogicEnum.And,
+    };
+
+    const ruleEvaluator = createRuleEvaluator({ rule });
+    const result = ruleEvaluator({});
+
+    expect(result).toEqual(RuleEvaluationResultEnum.Insufficient);
+  });
+
+  it('should return RuleEvaluationResultEnum.Insufficient when no (valid) condition passes validation', () => {
+    const rule: Rule = {
+      treatment: TreatmentEnum.True,
+      description: 'test',
+      conditions: [
+        {
+          attribute: 'attribute',
+          op: OperationEnum.StartsWith,
+          value: { list: ['test'] },
+          negate: false,
+        },
+        {
+          attribute: 'attribute',
+          op: OperationEnum.Contains,
+          value: { list: ['test'] },
+          negate: false,
+        },
+      ],
+      conditionLogic: ConditionLogicEnum.And,
+    };
+
+    const ruleEvaluator = createRuleEvaluator({ rule });
+    const result = ruleEvaluator({ attribute: '1' });
+
+    expect(result).toEqual(RuleEvaluationResultEnum.Insufficient);
+  });
+
+  it('should return RuleEvaluationResultEnum.Insufficient when some (valid) conditions pass validation', () => {
+    const rule: Rule = {
+      treatment: TreatmentEnum.True,
+      description: 'test',
+      conditions: [
+        {
+          attribute: 'attribute',
+          op: OperationEnum.StartsWith,
+          value: { list: ['test'] },
+          negate: false,
+        },
+        {
+          attribute: 'attribute',
+          op: OperationEnum.Contains,
+          value: { list: ['test'] },
+          negate: false,
+        },
+      ],
+      conditionLogic: ConditionLogicEnum.And,
+    };
+
+    const ruleEvaluator = createRuleEvaluator({ rule });
+    const result = ruleEvaluator({ attribute: 'te' });
+
+    expect(result).toEqual(RuleEvaluationResultEnum.Insufficient);
+  });
+
+  it('should return RuleEvaluationResultEnum.Treatable when all (valid) conditions pass validation', () => {
+    const rule: Rule = {
+      treatment: TreatmentEnum.True,
+      description: 'test',
+      conditions: [
+        {
+          attribute: 'attribute',
+          op: OperationEnum.InList,
+          value: { list: ['test'] },
+          negate: false,
+        },
+        {
+          attribute: 'attribute',
+          op: OperationEnum.Contains,
+          value: { list: ['test'] },
+          negate: false,
+        },
+      ],
+      conditionLogic: ConditionLogicEnum.And,
+    };
+
+    const ruleEvaluator = createRuleEvaluator({ rule });
+    const result = ruleEvaluator({ attribute: 'test' });
+
+    expect(result).toEqual(RuleEvaluationResultEnum.Treatable);
+  });
+
+  it('should return RuleEvaluationResultEnum.Treatable when all (valid) conditions pass validation', () => {
+    const rule: Rule = {
+      treatment: TreatmentEnum.True,
+      description: 'test',
+      conditions: [
+        {
+          attribute: 'attribute',
+          op: OperationEnum.InList,
+          value: { list: ['test'] },
+          negate: false,
+        },
+        {
+          attribute: 'attribute',
+          op: OperationEnum.Contains,
+          value: { list: ['not'] },
+          negate: true,
+        },
+        {
+          attribute: 'numeric',
+          op: OperationEnum.Equal,
+          value: { number: 2 },
+          negate: false,
+        },
+      ],
+      conditionLogic: ConditionLogicEnum.And,
+    };
+
+    const ruleEvaluator = createRuleEvaluator({ rule });
+    const result = ruleEvaluator({ attribute: 'test', numeric: 2 });
+
+    expect(result).toEqual(RuleEvaluationResultEnum.Treatable);
+  });
+});

package/src/rules/types.ts

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

package/src/index.spec.ts

@@ -1,5 +0,0 @@
-describe('index.ts', () => {
-  it('should be true', () => {
-    expect(true).toBe(true);
-  });
-});