fix(types): adding this types in public functions in classes

roggervalf · Oct 30, 2020 · f182fd9 · f182fd9
1 parent d278045
commit f182fd9
Show file tree

Hide file tree

Showing 13 changed files with 137 additions and 109 deletions.
diff --git a/README.md b/README.md
@@ -1,6 +1,6 @@
 # iam-policies
 
-> [![NPM](https://img.shields.io/npm/v/iam-policies.svg)](https://www.npmjs.com/package/iam-policies) [![JavaScript Style Guide](https://img.shields.io/badge/code_style-standard-brightgreen.svg)](https://standardjs.com) [![Build Status](https://travis-ci.com/roggervalf/iam-policies.svg?branch=master)](https://travis-ci.com/github/roggervalf/iam-policies) [![NPM downloads](https://img.shields.io/npm/dm/iam-policies)](https://www.npmjs.com/package/iam-policies) [![Coverage Status](https://coveralls.io/repos/github/roggervalf/iam-policies/badge.svg?branch=master)](https://coveralls.io/github/roggervalf/iam-policies?branch=master) [![semantic-release](https://img.shields.io/badge/%20%20%F0%9F%93%A6%F0%9F%9A%80-semantic--release-e10079.svg)](https://github.com/semantic-release/semantic-release)
+> [![NPM](https://img.shields.io/npm/v/iam-policies.svg)](https://www.npmjs.com/package/iam-policies) [![code style: prettier](https://img.shields.io/badge/code_style-prettier-ff69b4.svg)](https://github.com/prettier/prettier) [![Build Status](https://travis-ci.com/roggervalf/iam-policies.svg?branch=master)](https://travis-ci.com/github/roggervalf/iam-policies) [![NPM downloads](https://img.shields.io/npm/dm/iam-policies)](https://www.npmjs.com/package/iam-policies) [![Coverage Status](https://coveralls.io/repos/github/roggervalf/iam-policies/badge.svg?branch=master)](https://coveralls.io/github/roggervalf/iam-policies?branch=master) [![semantic-release](https://img.shields.io/badge/%20%20%F0%9F%93%A6%F0%9F%9A%80-semantic--release-e10079.svg)](https://github.com/semantic-release/semantic-release)
 
 ## About
 

diff --git a/dist/main.d.ts b/dist/main.d.ts
@@ -136,16 +136,16 @@ declare class Statement {
     protected readonly condition?: ConditionBlock;
     effect: EffectBlock;
     constructor({ sid, effect, condition }: StatementInterface);
-    matchConditions({ context, conditionResolver }: MatchConditionInterface): boolean;
+    matchConditions(this: Statement, { context, conditionResolver }: MatchConditionInterface): boolean;
 }
 
 declare class ActionBased extends Statement {
     private action?;
     private notAction?;
     private statement;
     constructor(action: ActionBasedType);
-    getStatement(): ActionBasedType;
-    matches({ action, context, conditionResolver }: MatchActionBasedInterface): boolean;
+    getStatement(this: ActionBased): ActionBasedType;
+    matches(this: ActionBased, { action, context, conditionResolver }: MatchActionBasedInterface): boolean;
     private checkAndAssignActions;
     private matchActions;
     private matchNotActions;
@@ -158,8 +158,8 @@ declare class IdentityBased extends Statement {
     private notAction?;
     private statement;
     constructor(identity: IdentityBasedType);
-    getStatement(): IdentityBasedType;
-    matches({ action, resource, context, conditionResolver }: MatchIdentityBasedInterface): boolean;
+    getStatement(this: IdentityBased): IdentityBasedType;
+    matches(this: IdentityBased, { action, resource, context, conditionResolver }: MatchIdentityBasedInterface): boolean;
     private checkAndAssignActions;
     private checkAndAssignResources;
     private matchActions;
@@ -179,8 +179,8 @@ declare class ResourceBased extends Statement {
     private hasPrincipals;
     private hasResources;
     constructor(identity: ResourceBasedType);
-    getStatement(): ResourceBasedType;
-    matches({ principal, action, resource, principalType, context, conditionResolver }: MatchResourceBasedInterface): boolean;
+    getStatement(this: ResourceBased): ResourceBasedType;
+    matches(this: ResourceBased, { principal, action, resource, principalType, context, conditionResolver }: MatchResourceBasedInterface): boolean;
     private matchPrincipalAndNotPrincipal;
     private matchResourceAndNotResource;
     private checkAndAssignActions;
@@ -198,10 +198,10 @@ declare class Policy {
     protected context?: Context;
     protected conditionResolver?: ConditionResolver;
     constructor({ context, conditionResolver }: MatchConditionInterface);
-    setContext(context: Context): void;
-    getContext(): Context | undefined;
-    setConditionResolver(conditionResolver: ConditionResolver): void;
-    getConditionResolver(): ConditionResolver | undefined;
+    setContext(this: Policy, context: Context): void;
+    getContext(this: Policy): Context | undefined;
+    setConditionResolver(this: Policy, conditionResolver: ConditionResolver): void;
+    getConditionResolver(this: Policy): ConditionResolver | undefined;
 }
 
 interface ActionBasedPolicyInterface {
@@ -214,11 +214,11 @@ declare class ActionBasedPolicy extends Policy {
     private allowStatements;
     private statements;
     constructor({ statements, conditionResolver, context }: ActionBasedPolicyInterface);
-    getStatements(): ActionBasedType[];
-    evaluate({ action, context }: EvaluateActionBasedInterface): boolean;
-    can({ action, context }: EvaluateActionBasedInterface): boolean;
-    cannot({ action, context }: EvaluateActionBasedInterface): boolean;
-    generateProxy<T, U extends keyof T>(obj: unknown, options?: ProxyOptions): T | undefined;
+    getStatements(this: ActionBasedPolicy): ActionBasedType[];
+    evaluate(this: ActionBasedPolicy, { action, context }: EvaluateActionBasedInterface): boolean;
+    can(this: ActionBasedPolicy, { action, context }: EvaluateActionBasedInterface): boolean;
+    cannot(this: ActionBasedPolicy, { action, context }: EvaluateActionBasedInterface): boolean;
+    generateProxy<T, U extends keyof T>(this: ActionBasedPolicy, obj: unknown, options?: ProxyOptions): T | undefined;
 }
 
 interface IdentityBasedPolicyInterface {
@@ -231,10 +231,10 @@ declare class IdentityBasedPolicy extends Policy {
     private allowStatements;
     private statements;
     constructor({ statements, conditionResolver, context }: IdentityBasedPolicyInterface);
-    getStatements(): IdentityBasedType[];
-    evaluate({ action, resource, context }: EvaluateIdentityBasedInterface): boolean;
-    can({ action, resource, context }: EvaluateIdentityBasedInterface): boolean;
-    cannot({ action, resource, context }: EvaluateIdentityBasedInterface): boolean;
+    getStatements(this: IdentityBasedPolicy): IdentityBasedType[];
+    evaluate(this: IdentityBasedPolicy, { action, resource, context }: EvaluateIdentityBasedInterface): boolean;
+    can(this: IdentityBasedPolicy, { action, resource, context }: EvaluateIdentityBasedInterface): boolean;
+    cannot(this: IdentityBasedPolicy, { action, resource, context }: EvaluateIdentityBasedInterface): boolean;
 }
 
 interface ResourceBasedPolicyInterface {
@@ -247,10 +247,10 @@ declare class ResourceBasedPolicy extends Policy {
     private allowStatements;
     private statements;
     constructor({ statements, conditionResolver, context }: ResourceBasedPolicyInterface);
-    getStatements(): ResourceBasedType[];
-    evaluate({ principal, action, resource, principalType, context }: EvaluateResourceBasedInterface): boolean;
-    can({ principal, action, resource, principalType, context }: EvaluateResourceBasedInterface): boolean;
-    cannot({ principal, action, resource, principalType, context }: EvaluateResourceBasedInterface): boolean;
+    getStatements(this: ResourceBasedPolicy): ResourceBasedType[];
+    evaluate(this: ResourceBasedPolicy, { principal, action, resource, principalType, context }: EvaluateResourceBasedInterface): boolean;
+    can(this: ResourceBasedPolicy, { principal, action, resource, principalType, context }: EvaluateResourceBasedInterface): boolean;
+    cannot(this: ResourceBasedPolicy, { principal, action, resource, principalType, context }: EvaluateResourceBasedInterface): boolean;
 }
 
 export { ActionBased, ActionBasedPolicy, ActionBasedPolicyInterface, IdentityBased, IdentityBasedPolicy, ResourceBased, ResourceBasedPolicy, Statement, applyContext, baseGet, castPath, getValueFromPath };
diff --git a/dist/main.es.js b/dist/main.es.js
diff --git a/dist/main.js b/dist/main.js
diff --git a/src/ActionBasedPolicy.ts b/src/ActionBasedPolicy.ts
@@ -37,16 +37,22 @@ export class ActionBasedPolicy extends Policy {
     );
   }
 
-  getStatements(): ActionBasedType[] {
+  getStatements(this: ActionBasedPolicy): ActionBasedType[] {
     return this.statements;
   }
 
-  evaluate({ action, context }: EvaluateActionBasedInterface): boolean {
+  evaluate(
+    this: ActionBasedPolicy,
+    { action, context }: EvaluateActionBasedInterface
+  ): boolean {
     const args = { action, context };
     return !this.cannot(args) && this.can(args);
   }
 
-  can({ action, context }: EvaluateActionBasedInterface): boolean {
+  can(
+    this: ActionBasedPolicy,
+    { action, context }: EvaluateActionBasedInterface
+  ): boolean {
     return this.allowStatements.some((s) =>
       s.matches({
         action,
@@ -56,7 +62,10 @@ export class ActionBasedPolicy extends Policy {
     );
   }
 
-  cannot({ action, context }: EvaluateActionBasedInterface): boolean {
+  cannot(
+    this: ActionBasedPolicy,
+    { action, context }: EvaluateActionBasedInterface
+  ): boolean {
     return this.denyStatements.some((s) =>
       s.matches({
         action,
@@ -67,6 +76,7 @@ export class ActionBasedPolicy extends Policy {
   }
 
   generateProxy<T, U extends keyof T>(
+    this: ActionBasedPolicy,
     obj: unknown,
     options: ProxyOptions = {}
   ): T | undefined {

diff --git a/src/ActionBasedStatement.ts b/src/ActionBasedStatement.ts
@@ -13,15 +13,14 @@ class ActionBased extends Statement {
     this.statement = { ...action, sid: this.sid };
   }
 
-  getStatement(): ActionBasedType {
+  getStatement(this: ActionBased): ActionBasedType {
     return this.statement;
   }
 
-  matches({
-    action,
-    context,
-    conditionResolver
-  }: MatchActionBasedInterface): boolean {
+  matches(
+    this: ActionBased,
+    { action, context, conditionResolver }: MatchActionBasedInterface
+  ): boolean {
     return (
       this.matchActions(action, context) &&
       this.matchNotActions(action, context) &&

diff --git a/src/IdentityBasedPolicy.ts b/src/IdentityBasedPolicy.ts
@@ -36,20 +36,22 @@ export class IdentityBasedPolicy extends Policy {
     );
   }
 
-  getStatements(): IdentityBasedType[] {
+  getStatements(this: IdentityBasedPolicy): IdentityBasedType[] {
     return this.statements;
   }
 
-  evaluate({
-    action,
-    resource,
-    context
-  }: EvaluateIdentityBasedInterface): boolean {
+  evaluate(
+    this: IdentityBasedPolicy,
+    { action, resource, context }: EvaluateIdentityBasedInterface
+  ): boolean {
     const args = { action, resource, context };
     return !this.cannot(args) && this.can(args);
   }
 
-  can({ action, resource, context }: EvaluateIdentityBasedInterface): boolean {
+  can(
+    this: IdentityBasedPolicy,
+    { action, resource, context }: EvaluateIdentityBasedInterface
+  ): boolean {
     return this.allowStatements.some((s) =>
       s.matches({
         action,
@@ -60,11 +62,10 @@ export class IdentityBasedPolicy extends Policy {
     );
   }
 
-  cannot({
-    action,
-    resource,
-    context
-  }: EvaluateIdentityBasedInterface): boolean {
+  cannot(
+    this: IdentityBasedPolicy,
+    { action, resource, context }: EvaluateIdentityBasedInterface
+  ): boolean {
     return this.denyStatements.some((s) =>
       s.matches({
         action,

diff --git a/src/IdentityBasedStatement.ts b/src/IdentityBasedStatement.ts
@@ -20,16 +20,19 @@ class IdentityBased extends Statement {
     this.statement = { ...identity, sid: this.sid };
   }
 
-  getStatement(): IdentityBasedType {
+  getStatement(this: IdentityBased): IdentityBasedType {
     return this.statement;
   }
 
-  matches({
-    action,
-    resource,
-    context,
-    conditionResolver
-  }: MatchIdentityBasedInterface): boolean {
+  matches(
+    this: IdentityBased,
+    {
+      action,
+      resource,
+      context,
+      conditionResolver
+    }: MatchIdentityBasedInterface
+  ): boolean {
     return (
       this.matchActions(action, context) &&
       this.matchNotActions(action, context) &&

diff --git a/src/Matcher.ts b/src/Matcher.ts
@@ -19,6 +19,12 @@ export class Matcher {
     });
   }
 
+  match(this: Matcher, str: string): boolean {
+    if (this.empty) return str === '';
+
+    return this.set.some((pattern) => this.matchOne(str, pattern));
+  }
+
   private braceExpand(): string[] {
     const pattern = this.pattern;
     if (!pattern.match(/{.*}/)) {
@@ -81,12 +87,6 @@ export class Matcher {
     return expansions;
   }
 
-  match(str: string): boolean {
-    if (this.empty) return str === '';
-
-    return this.set.some((pattern) => this.matchOne(str, pattern));
-  }
-
   private matchOne(str: string, pattern: string | RegExp): boolean {
     if (typeof pattern === 'string') {
       return str === pattern;

diff --git a/src/Policy.ts b/src/Policy.ts
@@ -9,19 +9,22 @@ class Policy {
     this.conditionResolver = conditionResolver;
   }
 
-  setContext(context: Context): void {
+  setContext(this: Policy, context: Context): void {
     this.context = context;
   }
 
-  getContext(): Context | undefined {
+  getContext(this: Policy): Context | undefined {
     return this.context;
   }
 
-  setConditionResolver(conditionResolver: ConditionResolver): void {
+  setConditionResolver(
+    this: Policy,
+    conditionResolver: ConditionResolver
+  ): void {
     this.conditionResolver = conditionResolver;
   }
 
-  getConditionResolver(): ConditionResolver | undefined {
+  getConditionResolver(this: Policy): ConditionResolver | undefined {
     return this.conditionResolver;
   }
 }