Merge pull request #13 from shelfio/feature/DECTREEAPI-235-fix-joiners

DECTREEAPI-235 Joiners `AND`, `OR` replaced w/ `and`, `or`

Author: DrewsAbuse

src/evaluation.test.ts

@@ -2,10 +2,10 @@ import type {Expression} from './types';
 import {expressionToRPN} from './evaluation';
 
 const baseExpression: Expression = {
-  joiner: 'AND',
+  joiner: 'and',
   rules: [
     {
-      joiner: 'OR',
+      joiner: 'or',
       rules: [
         {
           variableId: 'variable-id-c',
@@ -28,10 +28,10 @@ const baseExpression: Expression = {
 };
 
 const notBinaryExpression: Expression = {
-  joiner: 'AND',
+  joiner: 'and',
   rules: [
     {
-      joiner: 'OR',
+      joiner: 'or',
       rules: [
         {
           variableId: 'variable-id-c',
@@ -203,12 +203,12 @@ describe('expressionToRPN', () => {
 
   it('should return `[true]` for complex expression', () => {
     const complexExpression: Expression = {
-      joiner: 'AND',
+      joiner: 'and',
       rules: [
         baseExpression,
         singleRuleExpression,
         {
-          joiner: 'OR',
+          joiner: 'or',
           rules: [
             notBinaryExpression,
             {
@@ -230,12 +230,12 @@ describe('expressionToRPN', () => {
 
   it('should return `[false]` for complex expression', () => {
     const complexExpression: Expression = {
-      joiner: 'AND',
+      joiner: 'and',
       rules: [
         baseExpression,
         singleRuleExpression,
         {
-          joiner: 'AND',
+          joiner: 'and',
           rules: [
             notBinaryExpression,
             {

src/evaluation.ts

@@ -3,9 +3,9 @@ import type {JoinerParameters, RuleParameters} from './types';
 import {validateJoinerInvoke, validateRuleInvoke} from './validations';
 
 export const joinerHandlers = {
-  OR: ({left, right}: JoinerParameters) => Boolean(left || right),
-  AND: ({left, right}: JoinerParameters) => Boolean(left && right),
-  SINGLE: ({left}: JoinerParameters) => Boolean(left),
+  or: ({left, right}: JoinerParameters) => Boolean(left || right),
+  and: ({left, right}: JoinerParameters) => Boolean(left && right),
+  single: ({left}: JoinerParameters) => Boolean(left),
 };
 
 export const ruleHandlers = {
@@ -31,7 +31,7 @@ export const expressionToRPN = (
 
     validateJoinerInvoke({joiner, left, right});
 
-    rpn.push(joinerHandlers[joiner ?? 'SINGLE']({left, right}));
+    rpn.push(joinerHandlers[joiner ?? 'single']({left, right}));
 
     return rpn;
   }

src/types.ts

@@ -4,10 +4,10 @@ export type Rule = {
   value: string;
 };
 export type Expression = {
-  joiner?: 'OR' | 'AND';
+  joiner?: 'or' | 'and';
   rules: (Expression | Rule)[];
 };
 export type VariableWithValue = {id: string; value: string};
 export type JoinerParameters = {left: StackElement; right: StackElement};
-export type StackElement = boolean | 'OR' | 'AND';
+export type StackElement = boolean | Expression['joiner'];
 export type RuleParameters = {passedValue?: string; comparedValue: string};

src/validations.test.ts

@@ -4,21 +4,21 @@ describe('validateJoinerInvoke', () => {
   it('should throw error if joiner is not SINGLE and left is undefined', () => {
     expect(() =>
       validateJoinerInvoke({
-        joiner: 'AND',
+        joiner: 'and',
         left: true,
         right: undefined as any,
       })
-    ).toThrow('Invalid Joiner expression "true AND undefined"');
+    ).toThrow('Invalid Joiner expression "true and undefined"');
   });
 
   it('should throw error if joiner is not SINGLE and right is undefined', () => {
     expect(() =>
       validateJoinerInvoke({
-        joiner: 'AND',
+        joiner: 'and',
         left: undefined as any,
         right: true,
       })
-    ).toThrow('Invalid Joiner expression "undefined AND true"');
+    ).toThrow('Invalid Joiner expression "undefined and true"');
   });
 });