feat(stringequals): adding new predefined string operator

This operator could be used as a conditionResolver

dist/main.d.ts

@@ -132,6 +132,7 @@ declare abstract class Statement<T extends object> {
     effect: EffectBlock;
     constructor({ sid, effect, condition }: StatementInterface);
     matchConditions(this: Statement<T>, { context, conditionResolver }: MatchConditionInterface<T>): boolean;
+    private evaluateCondition;
 }
 
 declare class ActionBased<T extends object> extends Statement<T> {

src/ActionBasedPolicy.test.ts

@@ -237,6 +237,86 @@ describe('ActionBasedPolicy Class', () => {
     });
   });
 
+  describe('when condition does not exist', () => {
+    it('returns false', () => {
+      class User {
+        constructor(public info = { id: 456, age: 19 }) {}
+        get user() {
+          return this.info;
+        }
+      }
+
+      const policy = new ActionBasedPolicy({
+        statements: [
+          {
+            action: ['read']
+          },
+          {
+            action: ['write', 'update'],
+            condition: {
+              greaterThan: {
+                'user.age': 18
+              }
+            }
+          }
+        ]
+      });
+
+      expect(
+        policy.evaluate({
+          action: 'write',
+          context: { user: { id: 123, age: 17 } }
+        })
+      ).toBe(false);
+      expect(
+        policy.evaluate({
+          action: 'write',
+          context: new User()
+        })
+      ).toBe(false);
+    });
+  });
+
+  describe('when condition is predefined', () => {
+    it('returns true or false', () => {
+      class User {
+        constructor(public info = { name: 'Juan', age: 19 }) {}
+        get user() {
+          return this.info;
+        }
+      }
+
+      const policy = new ActionBasedPolicy({
+        statements: [
+          {
+            action: ['read']
+          },
+          {
+            action: ['write', 'update'],
+            condition: {
+              stringEquals: {
+                'user.name': 'Joan'
+              }
+            }
+          }
+        ]
+      });
+
+      expect(
+        policy.evaluate({
+          action: 'write',
+          context: { user: { name: 'Joan', age: 17 } }
+        })
+      ).toBe(true);
+      expect(
+        policy.evaluate({
+          action: 'write',
+          context: new User()
+        })
+      ).toBe(false);
+    });
+  });
+
   describe('can and cannot', () => {
     it('can should return false when not found and true for when matched with allow', () => {
       const policy = new ActionBasedPolicy({

src/Statement.ts

@@ -2,10 +2,12 @@ import {
   EffectBlock,
   ConditionBlock,
   StatementInterface,
-  MatchConditionInterface
+  MatchConditionInterface,
+  MatchConditionResolverInterface
 } from './types';
 import { getValueFromPath } from './utils/getValueFromPath';
 import { generateUUID } from './utils/generateUUID';
+import {operators} from './conditionOperators';
 
 abstract class Statement<T extends object> {
   protected sid: string;
@@ -27,25 +29,51 @@ abstract class Statement<T extends object> {
     { context, conditionResolver }: MatchConditionInterface<T>
   ): boolean {
     const { condition: conditions } = this;
-    return conditionResolver && conditions && context
-      ? Object.keys(conditions).every((condition) =>
-          Object.keys(conditions[condition]).every((path) => {
-            const conditionValues = conditions[condition][path];
-            if (conditionValues instanceof Array) {
-              return conditionValues.some((value) =>
-                conditionResolver[condition](
-                  getValueFromPath(context, path),
-                  value
-                )
-              );
-            }
-            return conditionResolver[condition](
-              getValueFromPath(context, path),
-              conditionValues
+
+    if(conditions && context){
+      return Object.keys(conditions).every((condition) =>
+        Object.keys(conditions[condition]).every((path) => {
+          const conditionValues = conditions[condition][path];
+          if (conditionValues instanceof Array) {
+            return conditionValues.some((value) =>
+              this.evaluateCondition({
+                context,
+                conditionResolver,
+                condition,
+                path,
+                value
+              })
             );
-          })
-        )
-      : true;
+          }
+
+          return this.evaluateCondition({
+            context,
+            conditionResolver,
+            condition,
+            path,
+            value: conditionValues
+          });
+        })
+      )
+    }
+
+    return true;
+  }
+
+  private evaluateCondition(
+    this: Statement<T>,
+    { context, conditionResolver={}, path, value, condition }: MatchConditionResolverInterface<T>
+  ): boolean {
+
+    const currentResolver= conditionResolver[condition] || operators[condition]
+
+    if(currentResolver){
+      return currentResolver(
+        getValueFromPath(context, path),
+        value
+      )
+    }
+    return false;
   }
 }
 

src/conditionOperators/index.ts

@@ -0,0 +1,6 @@
+import {stringEquals} from './string/stringEquals';
+
+export const operators: Record<string, unknown>={
+  stringEquals
+};
+

src/conditionOperators/string/stringEquals.test.ts

@@ -0,0 +1,15 @@
+import { stringEquals } from './stringEquals';
+
+describe('stringEquals', () => {
+  it('returns true', () => {
+    expect(stringEquals('secrets', 'secrets')).toBeTruthy;
+    expect(stringEquals('house', 'house')).toBeTruthy;
+    expect(stringEquals('', '')).toBeTruthy;
+  });
+
+  it('returns false', () => {
+    expect(stringEquals('secrets', 'house')).toBeFalsy;
+    expect(stringEquals('house', 'secrets')).toBeFalsy;
+    expect(stringEquals('', '1')).toBeFalsy;
+  });
+});

src/conditionOperators/string/stringEquals.ts

@@ -0,0 +1,22 @@
+/**
+ * Exact matching, case sensitive.
+ *
+ * @since 4.3.0
+ * @category String
+ * @param {string} data The value to be compared.
+ * @param {string} expected The expected value.
+ * @returns {boolean} Returns `true` if `value` is equal to `expected value`.
+ * @example
+ * ```javascript
+ * stringEquals('hi', 'hi')
+ * // => true
+ *
+ * stringEquals('hi', 'no')
+ * // => false
+ * ```
+ */
+export function stringEquals(data: string, expected: string): boolean {
+  return (
+    data === expected
+  );
+}

src/types.ts

@@ -70,6 +70,14 @@ export interface MatchConditionInterface<T extends object> {
   conditionResolver?: ConditionResolver;
 }
 
+export interface MatchConditionResolverInterface<T extends object> {
+  context: T
+  conditionResolver?: ConditionResolver;
+  path: string;
+  condition: string;
+  value: any;
+}
+
 export interface MatchActionBasedInterface<T extends object>
   extends MatchConditionInterface<T> {
   action: string;

tsconfig.json

@@ -7,7 +7,8 @@
     "outDir": "./dist",
     "strict": true,
     "noUnusedParameters": true,
-    "noImplicitThis": true
+    "noImplicitThis": true,
+    "moduleResolution": "node"
   },
   "include": ["src"],
   "exclude": [