fix(actionbasedstatement): throw TypeError when action and notAction …

…are present

src/ActionBasedStatement.test.ts

@@ -0,0 +1,32 @@
+import { ActionBased } from './ActionBasedStatement';
+
+describe('ActionBased Class', () => {
+  describe('when creating action based statement', () => {
+    it("doesn't throw an error", () => {
+      expect(
+        () =>
+          new ActionBased({
+            action: ['read', 'write']
+          })
+      ).not.toThrow();
+      expect(
+        () =>
+          new ActionBased({
+            notAction: ['write']
+          })
+      ).not.toThrow();
+    });
+
+    it('throws a TypeError', () => {
+      const expectedError = new TypeError(
+        'ActionBased statement should have an action or a notAction attribute, no both'
+      );
+      expect(() => {
+        new ActionBased({
+          action: ['read', 'write'],
+          notAction: 'delete'
+        });
+      }).toThrow(expectedError);
+    });
+  });
+});

src/ActionBasedStatement.ts

@@ -1,7 +1,10 @@
-import { Context, ActionBasedType, MatchActionBasedInterface } from './types';
-import { instanceOfActionBlock } from './utils/instanceOfInterfaces';
+import { ActionBasedType, Context, MatchActionBasedInterface } from './types';
+import {
+  instanceOfActionBlock,
+  instanceOfNotActionBlock
+} from './utils/instanceOfInterfaces';
 import { Matcher } from './Matcher';
-import { Statement, applyContext } from './Statement';
+import { applyContext, Statement } from './Statement';
 
 class ActionBased extends Statement {
   private action?: string[];
@@ -10,7 +13,14 @@ class ActionBased extends Statement {
 
   constructor(action: ActionBasedType) {
     super(action);
-    if (instanceOfActionBlock(action)) {
+    const hasAction = instanceOfActionBlock(action);
+    const hasNotAction = instanceOfNotActionBlock(action);
+    if (hasAction && hasNotAction) {
+      throw new TypeError(
+        'ActionBased statement should have an action or a notAction attribute, no both'
+      );
+    }
+    if (hasAction) {
       this.action =
         typeof action.action === 'string' ? [action.action] : action.action;
     } else {
@@ -40,15 +50,15 @@ class ActionBased extends Statement {
 
   private matchActions(action: string, context?: Context): boolean {
     return this.action
-      ? this.action.some(a =>
+      ? this.action.some((a) =>
           new Matcher(applyContext(a, context)).match(action)
         )
       : true;
   }
 
   private matchNotActions(action: string, context?: Context): boolean {
     return this.notAction
-      ? !this.notAction.some(a =>
+      ? !this.notAction.some((a) =>
           new Matcher(applyContext(a, context)).match(action)
         )
       : true;

src/types.ts

@@ -115,14 +115,15 @@ type ResourceBasedType = StatementInterface &
 
 export {
   ActionBasedType,
+  ActionBlock,
   IdentityBasedType,
-  ResourceBasedType,
-  PrincipalMap,
   Patterns,
+  PrincipalBlock,
+  PrincipalMap,
+  ResourceBasedType,
   ResourceBlock,
-  NotResourceBlock,
-  ActionBlock,
-  PrincipalBlock
+  NotActionBlock,
+  NotResourceBlock
 };
 
 /*

src/utils/instanceOfInterfaces.test.ts

@@ -1,7 +1,8 @@
 import {
+  instanceOfActionBlock,
   instanceOfPrincipalBlock,
   instanceOfResourceBlock,
-  instanceOfActionBlock,
+  instanceOfNotActionBlock,
   instanceOfNotResourceBlock
 } from './instanceOfInterfaces';
 
@@ -44,6 +45,18 @@ describe('Util functions', () => {
     });
   });
 
+  describe('instanceOfNotActionBlock', () => {
+    it("doesn't throw an error", () => {
+      expect(() =>
+        instanceOfNotActionBlock({
+          notAction: 'something'
+        })
+      ).not.toThrow();
+      expect(instanceOfNotActionBlock({ notAction: 'something' })).toBe(true);
+      expect(instanceOfNotActionBlock({ action: 'something' })).toBe(false);
+    });
+  });
+
   describe('instanceOfNotResourceBlock', () => {
     it("doesn't throw an error", () => {
       expect(() =>

src/utils/instanceOfInterfaces.ts

@@ -1,5 +1,6 @@
 import {
   ActionBlock,
+  NotActionBlock,
   PrincipalBlock,
   NotResourceBlock,
   ResourceBlock
@@ -13,12 +14,34 @@ import {
  * ```javascript
  * instanceOfActionBlock({ action: 'something' })
  * // => true
+ *
+ * instanceOfActionBlock({ notAction: 'something' })
+ * // => false
  * ```
  */
 export function instanceOfActionBlock(object: object): object is ActionBlock {
   return 'action' in object;
 }
 
+/**
+ * Validate if an `object` is an instance of `NotActionBlock`.
+ * @param {Object} object Object to validate
+ * @returns {boolean} Returns true if `object` has `notAction` attribute.
+ * @example
+ * ```javascript
+ * instanceOfNotActionBlock({ notAction: 'something' })
+ * // => true
+ *
+ * instanceOfNotActionBlock({ action: 'something' })
+ * // => false
+ * ```
+ */
+export function instanceOfNotActionBlock(
+  object: object
+): object is NotActionBlock {
+  return 'notAction' in object;
+}
+
 /**
  * Validate if an `object` is an instance of `PrincipalBlock`.
  * @param {Object} object Object to validate