feat(policies): adding addStatement function

this new function provides a way to add a new statement in each Policy instance re #35
roggervalf · Dec 5, 2020 · fc2697f · fc2697f
1 parent 6d9135e
commit fc2697f
Show file tree

Hide file tree

Showing 10 changed files with 208 additions and 25 deletions.
diff --git a/dist/main.d.ts b/dist/main.d.ts
@@ -189,22 +189,23 @@ declare class ResourceBased<T extends object> extends Statement<T> {
     private matchNotResources;
 }
 
-declare class Policy<T extends object> {
+declare abstract class Policy<T extends object, U> {
     protected context?: T;
     protected conditionResolver?: ConditionResolver;
     constructor({ context, conditionResolver }: MatchConditionInterface<T>);
-    setContext(this: Policy<T>, context: T): void;
-    getContext(this: Policy<T>): T | undefined;
-    setConditionResolver(this: Policy<T>, conditionResolver: ConditionResolver): void;
-    getConditionResolver(this: Policy<T>): ConditionResolver | undefined;
+    setContext(this: Policy<T, U>, context: T): void;
+    getContext(this: Policy<T, U>): T | undefined;
+    setConditionResolver(this: Policy<T, U>, conditionResolver: ConditionResolver): void;
+    getConditionResolver(this: Policy<T, U>): ConditionResolver | undefined;
+    abstract getStatements(this: Policy<T, U>): U[];
 }
 
 interface ActionBasedPolicyInterface<T extends object> {
     statements: ActionBasedType[];
     conditionResolver?: ConditionResolver;
     context?: T;
 }
-declare class ActionBasedPolicy<T extends object> extends Policy<T> {
+declare class ActionBasedPolicy<T extends object> extends Policy<T, ActionBasedType> {
     private denyStatements;
     private allowStatements;
     private statements;
@@ -221,7 +222,7 @@ interface IdentityBasedPolicyInterface<T extends object> {
     conditionResolver?: ConditionResolver;
     context?: T;
 }
-declare class IdentityBasedPolicy<T extends object> extends Policy<T> {
+declare class IdentityBasedPolicy<T extends object> extends Policy<T, IdentityBasedType> {
     private denyStatements;
     private allowStatements;
     private statements;
@@ -237,7 +238,7 @@ interface ResourceBasedPolicyInterface<T extends object> {
     conditionResolver?: ConditionResolver;
     context?: T;
 }
-declare class ResourceBasedPolicy<T extends object> extends Policy<T> {
+declare class ResourceBasedPolicy<T extends object> extends Policy<T, ResourceBasedType> {
     private denyStatements;
     private allowStatements;
     private statements;

diff --git a/dist/main.es.js.map b/dist/main.es.js.map
diff --git a/dist/main.js.map b/dist/main.js.map
diff --git a/src/ActionBasedPolicy.test.ts b/src/ActionBasedPolicy.test.ts
@@ -39,7 +39,48 @@ describe('ActionBasedPolicy Class', () => {
     });
   });
 
-  describe('when get statements', () => {
+  describe('when addStatement is called', () => {
+    describe('when adding an statement with effect as allow', () => {
+      it('adds a new ActionBased statement', () => {
+        const statements = [
+          {
+            action: 'read'
+          }
+        ];
+        const newStatement = {
+          action: 'write'
+        };
+
+        const policy = new ActionBasedPolicy({ statements });
+        policy.addStatement(newStatement);
+        const exportedStatements = policy.getStatements();
+
+        expect(exportedStatements).toMatchObject([...statements, newStatement]);
+      });
+    });
+
+    describe('when adding an statement with effect as deny', () => {
+      it('adds a new ActionBased statement', () => {
+        const statements = [
+          {
+            action: 'read'
+          }
+        ];
+        const newStatement = {
+          effect: 'deny' as const,
+          action: 'write'
+        };
+
+        const policy = new ActionBasedPolicy({ statements });
+        policy.addStatement(newStatement);
+        const exportedStatements = policy.getStatements();
+
+        expect(exportedStatements).toMatchObject([...statements, newStatement]);
+      });
+    });
+  });
+
+  describe('when getStatements is called', () => {
     it('returns those statements', () => {
       const statements = [
         {

diff --git a/src/ActionBasedPolicy.ts b/src/ActionBasedPolicy.ts
@@ -13,7 +13,10 @@ export interface ActionBasedPolicyInterface<T extends object> {
   context?: T;
 }
 
-export class ActionBasedPolicy<T extends object> extends Policy<T> {
+export class ActionBasedPolicy<T extends object> extends Policy<
+  T,
+  ActionBasedType
+> {
   private denyStatements: ActionBased<T>[];
   private allowStatements: ActionBased<T>[];
   private statements: ActionBasedType[];
@@ -36,6 +39,16 @@ export class ActionBasedPolicy<T extends object> extends Policy<T> {
     );
   }
 
+  addStatement(this: ActionBasedPolicy<T>, statement: ActionBasedType): void {
+    const statementInstance = new ActionBased(statement);
+    if (statementInstance.effect === 'allow') {
+      this.allowStatements.push(statementInstance);
+    } else {
+      this.denyStatements.push(statementInstance);
+    }
+    this.statements.push(statementInstance.getStatement());
+  }
+
   getStatements(this: ActionBasedPolicy<T>): ActionBasedType[] {
     return this.statements;
   }

diff --git a/src/IdentityBasedPolicy.test.ts b/src/IdentityBasedPolicy.test.ts
@@ -30,7 +30,53 @@ describe('IdentityBasedPolicy Class', () => {
     });
   });
 
-  describe('when get statements', () => {
+  describe('when addStatement is called', () => {
+    describe('when adding an statement with effect as allow', () => {
+      it('adds a new IdentityBased statement', () => {
+        const statements = [
+          {
+            resource: ['books:horror:*'],
+            action: ['read']
+          }
+        ];
+        const newStatement = {
+          effect: 'allow' as const,
+          resource: ['books:horror:*'],
+          action: 'write'
+        };
+
+        const policy = new IdentityBasedPolicy({ statements });
+        policy.addStatement(newStatement);
+        const exportedStatements = policy.getStatements();
+
+        expect(exportedStatements).toMatchObject([...statements, newStatement]);
+      });
+    });
+
+    describe('when adding an statement with effect as deny', () => {
+      it('adds a new IdentityBased statement', () => {
+        const statements = [
+          {
+            resource: ['books:horror:*'],
+            action: ['read']
+          }
+        ];
+        const newStatement = {
+          effect: 'deny' as const,
+          resource: ['books:horror:*'],
+          action: 'write'
+        };
+
+        const policy = new IdentityBasedPolicy({ statements });
+        policy.addStatement(newStatement);
+        const exportedStatements = policy.getStatements();
+
+        expect(exportedStatements).toMatchObject([...statements, newStatement]);
+      });
+    });
+  });
+
+  describe('when getStatements is called', () => {
     it('returns those statements', () => {
       const statements = [
         {
@@ -46,7 +92,7 @@ describe('IdentityBasedPolicy Class', () => {
     });
   });
 
-  describe('when getContext', () => {
+  describe('when getContext is called', () => {
     it('returns context attribute', () => {
       const context = { user: { age: 31 } };
       const statements = [
@@ -61,7 +107,7 @@ describe('IdentityBasedPolicy Class', () => {
     });
   });
 
-  describe('when setContext', () => {
+  describe('when setContext is called', () => {
     it('sets context attribute', () => {
       const context = { user: { age: 31 } };
       const statements = [

diff --git a/src/IdentityBasedPolicy.ts b/src/IdentityBasedPolicy.ts
@@ -12,7 +12,10 @@ interface IdentityBasedPolicyInterface<T extends object> {
   context?: T;
 }
 
-export class IdentityBasedPolicy<T extends object> extends Policy<T> {
+export class IdentityBasedPolicy<T extends object> extends Policy<
+  T,
+  IdentityBasedType
+> {
   private denyStatements: IdentityBased<T>[];
   private allowStatements: IdentityBased<T>[];
   private statements: IdentityBasedType[];
@@ -35,6 +38,19 @@ export class IdentityBasedPolicy<T extends object> extends Policy<T> {
     );
   }
 
+  addStatement(
+    this: IdentityBasedPolicy<T>,
+    statement: IdentityBasedType
+  ): void {
+    const statementInstance = new IdentityBased(statement);
+    if (statementInstance.effect === 'allow') {
+      this.allowStatements.push(statementInstance);
+    } else {
+      this.denyStatements.push(statementInstance);
+    }
+    this.statements.push(statementInstance.getStatement());
+  }
+
   getStatements(this: IdentityBasedPolicy<T>): IdentityBasedType[] {
     return this.statements;
   }

diff --git a/src/Policy.ts b/src/Policy.ts
@@ -1,6 +1,6 @@
 import { MatchConditionInterface, ConditionResolver } from './types';
 
-abstract class Policy<T extends object> {
+abstract class Policy<T extends object, U> {
   protected context?: T;
   protected conditionResolver?: ConditionResolver;
 
@@ -9,24 +9,26 @@ abstract class Policy<T extends object> {
     this.conditionResolver = conditionResolver;
   }
 
-  setContext(this: Policy<T>, context: T): void {
+  setContext(this: Policy<T, U>, context: T): void {
     this.context = context;
   }
 
-  getContext(this: Policy<T>): T | undefined {
+  getContext(this: Policy<T, U>): T | undefined {
     return this.context;
   }
 
   setConditionResolver(
-    this: Policy<T>,
+    this: Policy<T, U>,
     conditionResolver: ConditionResolver
   ): void {
     this.conditionResolver = conditionResolver;
   }
 
-  getConditionResolver(this: Policy<T>): ConditionResolver | undefined {
+  getConditionResolver(this: Policy<T, U>): ConditionResolver | undefined {
     return this.conditionResolver;
   }
+
+  abstract getStatements(this: Policy<T, U>): U[];
 }
 
 export { Policy };
diff --git a/src/ResourceBasedPolicy.test.ts b/src/ResourceBasedPolicy.test.ts
@@ -32,7 +32,55 @@ describe('ResourceBasedPolicy Class', () => {
     });
   });
 
-  describe('when get statements', () => {
+  describe('when addStatement is called', () => {
+    describe('when adding an statement with effect as allow', () => {
+      it('adds a new ResourceBased statement', () => {
+        const statements = [
+          {
+            principal: 'andre',
+            resource: ['books:horror:*'],
+            action: ['read']
+          }
+        ];
+        const newStatement = {
+          effect: 'allow' as const,
+          resource: ['books:horror:*'],
+          action: 'write'
+        };
+
+        const policy = new ResourceBasedPolicy({ statements });
+        policy.addStatement(newStatement);
+        const exportedStatements = policy.getStatements();
+
+        expect(exportedStatements).toMatchObject([...statements, newStatement]);
+      });
+    });
+
+    describe('when adding an statement with effect as deny', () => {
+      it('adds a new ResourceBased statement', () => {
+        const statements = [
+          {
+            principal: 'andre',
+            resource: ['books:horror:*'],
+            action: ['read']
+          }
+        ];
+        const newStatement = {
+          effect: 'deny' as const,
+          resource: ['books:horror:*'],
+          action: 'write'
+        };
+
+        const policy = new ResourceBasedPolicy({ statements });
+        policy.addStatement(newStatement);
+        const exportedStatements = policy.getStatements();
+
+        expect(exportedStatements).toMatchObject([...statements, newStatement]);
+      });
+    });
+  });
+
+  describe('when getStatements is called', () => {
     it('returns those statements', () => {
       const statements = [
         {
@@ -48,7 +96,7 @@ describe('ResourceBasedPolicy Class', () => {
     });
   });
 
-  describe('when getConditionResolver', () => {
+  describe('when getConditionResolver is called', () => {
     it('returns conditionResolver attribute', () => {
       const conditionResolver = {
         greaterThan: (data: number, expected: number): boolean => {
@@ -68,7 +116,7 @@ describe('ResourceBasedPolicy Class', () => {
     });
   });
 
-  describe('when setConditionResolver', () => {
+  describe('when setConditionResolver is called', () => {
     it('sets conditionResolver attribute', () => {
       const conditionResolver = {
         greaterThan: (data: number, expected: number): boolean => {

diff --git a/src/ResourceBasedPolicy.ts b/src/ResourceBasedPolicy.ts
@@ -12,7 +12,10 @@ interface ResourceBasedPolicyInterface<T extends object> {
   context?: T;
 }
 
-export class ResourceBasedPolicy<T extends object> extends Policy<T> {
+export class ResourceBasedPolicy<T extends object> extends Policy<
+  T,
+  ResourceBasedType
+> {
   private denyStatements: ResourceBased<T>[];
   private allowStatements: ResourceBased<T>[];
   private statements: ResourceBasedType[];
@@ -35,6 +38,19 @@ export class ResourceBasedPolicy<T extends object> extends Policy<T> {
     );
   }
 
+  addStatement(
+    this: ResourceBasedPolicy<T>,
+    statement: ResourceBasedType
+  ): void {
+    const statementInstance = new ResourceBased(statement);
+    if (statementInstance.effect === 'allow') {
+      this.allowStatements.push(statementInstance);
+    } else {
+      this.denyStatements.push(statementInstance);
+    }
+    this.statements.push(statementInstance.getStatement());
+  }
+
   getStatements(this: ResourceBasedPolicy<T>): ResourceBasedType[] {
     return this.statements;
   }