fix(chore): resolving sonar smells to improve quality gate

resolving sonar smells to improve quality gate GH-142
sourcefuse · Aug 4, 2023 · 1a454a7 · 1a454a7
1 parent 34971e9
commit 1a454a7
Show file tree

Hide file tree

Showing 21 changed files with 401 additions and 431 deletions.
diff --git a/src/strategies/SAML/saml-strategy-factory-provider.ts b/src/strategies/SAML/saml-strategy-factory-provider.ts
@@ -14,9 +14,10 @@ import {
 import {AuthErrorKeys} from '../../error-keys';
 import {Strategies} from '../../keys';
 import {VerifyFunction} from '../../types';
-export interface SamlStrategyFactory {
-  (options: SamlConfig, verifierPassed?: VerifyFunction.SamlFn): Strategy;
-}
+export type SamlStrategyFactory = (
+  options: SamlConfig,
+  verifierPassed?: VerifyFunction.SamlFn,
+) => Strategy;
 
 export class SamlStrategyFactoryProvider
   implements Provider<SamlStrategyFactory>

diff --git a/src/strategies/SAML/saml-verify.provider.ts b/src/strategies/SAML/saml-verify.provider.ts
@@ -11,10 +11,6 @@ import {VerifyFunction} from '../../types';
  * It will just throw an error saying Not Implemented
  */
 export class SamlVerifyProvider implements Provider<VerifyFunction.SamlFn> {
-  constructor() {
-    //This is intentional
-  }
-
   value(): VerifyFunction.SamlFn {
     return async (
       profile: SamlStrategy.Profile,

diff --git a/src/strategies/passport/passport-apple-oauth2/apple-auth-strategy-factory-provider.ts b/src/strategies/passport/passport-apple-oauth2/apple-auth-strategy-factory-provider.ts
@@ -12,7 +12,6 @@ import {
 import {AuthErrorKeys} from '../../../error-keys';
 import {Strategies} from '../../keys';
 import {VerifyFunction} from '../../types';
-
 import Strategy from 'passport-apple';
 export interface AppleAuthStrategyFactory {
   (
@@ -40,7 +39,7 @@ export class AppleAuthStrategyFactoryProvider
   ): Strategy {
     const verifyFn = verifierPassed ?? this.verifierAppleAuth;
     let strategy;
-    if (options && options.passReqToCallback === true) {
+    if (options?.passReqToCallback === true) {
       strategy = new Strategy(
         options,
 

diff --git a/src/strategies/passport/passport-apple-oauth2/apple-auth-verify.provider.ts b/src/strategies/passport/passport-apple-oauth2/apple-auth-verify.provider.ts
@@ -9,8 +9,6 @@ import {VerifyFunction} from '../../types';
 export class AppleAuthVerifyProvider
   implements Provider<VerifyFunction.AppleAuthFn>
 {
-  constructor() {}
-
   value(): VerifyFunction.AppleAuthFn {
     return async (
       accessToken: string,

diff --git a/src/strategies/passport/passport-azure-ad/azuread-auth-strategy-factory-provider.ts b/src/strategies/passport/passport-azure-ad/azuread-auth-strategy-factory-provider.ts
@@ -12,12 +12,10 @@ import {
   IOIDCStrategyOptionWithoutRequest,
 } from 'passport-azure-ad';
 
-export interface AzureADAuthStrategyFactory {
-  (
-    options: IOIDCStrategyOptionWithoutRequest | IOIDCStrategyOptionWithRequest,
-    verifierPassed?: VerifyFunction.AzureADAuthFn,
-  ): OIDCStrategy;
-}
+export type AzureADAuthStrategyFactory = (
+  options: IOIDCStrategyOptionWithoutRequest | IOIDCStrategyOptionWithRequest,
+  verifierPassed?: VerifyFunction.AzureADAuthFn,
+) => OIDCStrategy;
 
 export class AzureADAuthStrategyFactoryProvider
   implements Provider<AzureADAuthStrategyFactory>
@@ -31,6 +29,61 @@ export class AzureADAuthStrategyFactoryProvider
     return (options, verifier) =>
       this.getAzureADAuthStrategyVerifier(options, verifier);
   }
+  createCallbackWithReq(verifyFn: VerifyFunction.AzureADAuthFn) {
+    return async (
+      req: Request,
+      iss: string,
+      sub: string,
+      profile: IProfile,
+      accessToken: string,
+      refreshToken: string,
+      done: VerifyCallback,
+    ) => {
+      if (!profile.oid) {
+        return done(new Error('No oid found'), null);
+      }
+
+      try {
+        const user = await verifyFn(
+          accessToken,
+          refreshToken,
+          profile,
+          done,
+          req,
+        );
+        if (!user) {
+          throw new HttpErrors.Unauthorized(AuthErrorKeys.InvalidCredentials);
+        }
+        done(null, user);
+      } catch (err) {
+        done(err);
+      }
+    };
+  }
+  createCallbackWithoutReq(verifyFn: VerifyFunction.AzureADAuthFn) {
+    return async (
+      iss: string,
+      sub: string,
+      profile: IProfile,
+      accessToken: string,
+      refreshToken: string,
+      done: VerifyCallback,
+    ) => {
+      if (!profile.oid) {
+        return done(new Error('No oid found'), null);
+      }
+
+      try {
+        const user = await verifyFn(accessToken, refreshToken, profile, done);
+        if (!user) {
+          throw new HttpErrors.Unauthorized(AuthErrorKeys.InvalidCredentials);
+        }
+        done(null, user);
+      } catch (err) {
+        done(err);
+      }
+    };
+  }
 
   getAzureADAuthStrategyVerifier(
     options: IOIDCStrategyOptionWithoutRequest | IOIDCStrategyOptionWithRequest,
@@ -40,74 +93,14 @@ export class AzureADAuthStrategyFactoryProvider
     if (options && options.passReqToCallback === true) {
       return new OIDCStrategy(
         options,
-
         // eslint-disable-next-line @typescript-eslint/no-misused-promises
-        async (
-          req: Request,
-          iss: string,
-          sub: string,
-          profile: IProfile,
-          accessToken: string,
-          refreshToken: string,
-          done: VerifyCallback,
-        ) => {
-          if (!profile.oid) {
-            return done(new Error('No oid found'), null);
-          }
-
-          try {
-            const user = await verifyFn(
-              accessToken,
-              refreshToken,
-              profile,
-              done,
-              req,
-            );
-            if (!user) {
-              throw new HttpErrors.Unauthorized(
-                AuthErrorKeys.InvalidCredentials,
-              );
-            }
-            done(null, user);
-          } catch (err) {
-            done(err);
-          }
-        },
+        this.createCallbackWithReq(verifyFn),
       );
     } else if (options && options.passReqToCallback === false) {
       return new OIDCStrategy(
         options,
-
         // eslint-disable-next-line @typescript-eslint/no-misused-promises
-        async (
-          iss: string,
-          sub: string,
-          profile: IProfile,
-          accessToken: string,
-          refreshToken: string,
-          done: VerifyCallback,
-        ) => {
-          if (!profile.oid) {
-            return done(new Error('No oid found'), null);
-          }
-
-          try {
-            const user = await verifyFn(
-              accessToken,
-              refreshToken,
-              profile,
-              done,
-            );
-            if (!user) {
-              throw new HttpErrors.Unauthorized(
-                AuthErrorKeys.InvalidCredentials,
-              );
-            }
-            done(null, user);
-          } catch (err) {
-            done(err);
-          }
-        },
+        this.createCallbackWithoutReq(verifyFn),
       );
     } else {
       throw new Error('Invalid value for passReqToCallback');

diff --git a/src/strategies/passport/passport-bearer/bearer-strategy-factory-provider.ts b/src/strategies/passport/passport-bearer/bearer-strategy-factory-provider.ts
@@ -8,12 +8,10 @@ import {Strategies} from '../../keys';
 import {VerifyFunction} from '../../types';
 import {isEmpty} from 'lodash';
 
-export interface BearerStrategyFactory {
-  (
-    options?: PassportBearer.IStrategyOptions,
-    verifierPassed?: VerifyFunction.BearerFn,
-  ): PassportBearer.Strategy<VerifyFunction.BearerFn>;
-}
+export type BearerStrategyFactory = (
+  options?: PassportBearer.IStrategyOptions,
+  verifierPassed?: VerifyFunction.BearerFn,
+) => PassportBearer.Strategy<VerifyFunction.BearerFn>;
 
 export class BearerStrategyFactoryProvider
   implements Provider<BearerStrategyFactory>
@@ -28,6 +26,61 @@ export class BearerStrategyFactoryProvider
       this.getBearerStrategyVerifier(options, verifier);
   }
 
+  getBearerStrategyVerifierWithRequest(verifyFn: VerifyFunction.BearerFn) {
+    return async (
+      req: Request,
+      token: string,
+      cb: (err: Error | null, user?: IAuthUser | false) => void,
+    ) => {
+      try {
+        const user = await verifyFn(token, req);
+        if (!user) {
+          throw new HttpErrors.Unauthorized(AuthErrorKeys.TokenInvalid);
+        }
+        cb(null, user);
+      } catch (err) {
+        cb(err);
+      }
+    };
+  }
+
+  getBearerStrategyVerifierWithoutRequest(verifyFn: VerifyFunction.BearerFn) {
+    return async (
+      token: string,
+      cb: (err: Error | null, user?: IAuthUser | false) => void,
+    ) => {
+      try {
+        const user = await verifyFn(token);
+        if (!user) {
+          throw new HttpErrors.Unauthorized(AuthErrorKeys.TokenInvalid);
+        }
+        cb(null, user);
+      } catch (err) {
+        cb(err);
+      }
+    };
+  }
+  getBearerStrategyVerifierDefault(
+    verifyFn: VerifyFunction.BearerFn,
+  ): PassportBearer.Strategy<VerifyFunction.BearerFn> {
+    return new PassportBearer.Strategy(
+      // eslint-disable-next-line @typescript-eslint/no-misused-promises
+      async (
+        token: string,
+        cb: (err: Error | null, user?: IAuthUser | false) => void,
+      ) => {
+        try {
+          const user = await verifyFn(token);
+          if (!user) {
+            throw new HttpErrors.Unauthorized(AuthErrorKeys.InvalidCredentials);
+          }
+          cb(null, user);
+        } catch (err) {
+          cb(err);
+        }
+      },
+    );
+  }
   getBearerStrategyVerifier(
     options?: PassportBearer.IStrategyOptions,
     verifierPassed?: VerifyFunction.BearerFn,
@@ -37,62 +90,16 @@ export class BearerStrategyFactoryProvider
       return new PassportBearer.Strategy(
         options,
         // eslint-disable-next-line @typescript-eslint/no-misused-promises
-        async (
-          req: Request,
-          token: string,
-          cb: (err: Error | null, user?: IAuthUser | false) => void,
-        ) => {
-          try {
-            const user = await verifyFn(token, req);
-            if (!user) {
-              throw new HttpErrors.Unauthorized(AuthErrorKeys.TokenInvalid);
-            }
-            cb(null, user);
-          } catch (err) {
-            cb(err);
-          }
-        },
+        this.getBearerStrategyVerifierWithRequest(verifyFn),
       );
     } else if (!!options && !isEmpty(options)) {
       return new PassportBearer.Strategy(
         options,
-
         // eslint-disable-next-line @typescript-eslint/no-misused-promises
-        async (
-          token: string,
-          cb: (err: Error | null, user?: IAuthUser | false) => void,
-        ) => {
-          try {
-            const user = await verifyFn(token);
-            if (!user) {
-              throw new HttpErrors.Unauthorized(AuthErrorKeys.TokenInvalid);
-            }
-            cb(null, user);
-          } catch (err) {
-            cb(err);
-          }
-        },
+        this.getBearerStrategyVerifierWithoutRequest(verifyFn),
       );
     } else {
-      return new PassportBearer.Strategy(
-        // eslint-disable-next-line @typescript-eslint/no-misused-promises
-        async (
-          token: string,
-          cb: (err: Error | null, user?: IAuthUser | false) => void,
-        ) => {
-          try {
-            const user = await verifyFn(token);
-            if (!user) {
-              throw new HttpErrors.Unauthorized(
-                AuthErrorKeys.InvalidCredentials,
-              );
-            }
-            cb(null, user);
-          } catch (err) {
-            cb(err);
-          }
-        },
-      );
+      return this.getBearerStrategyVerifierDefault(verifyFn);
     }
   }
 }