[PoC][WIP, not ready for review]feat: add abstractions in authentication module

packages/authentication/package.json

@@ -25,6 +25,7 @@
     "@loopback/metadata": "^1.0.6",
     "@loopback/openapi-v3": "^1.2.1",
     "@loopback/rest": "^1.5.5",
+    "lodash": "^4.17.11",
     "passport": "^0.4.0",
     "passport-strategy": "^1.0.0"
   },

packages/authentication/src/keys.ts

@@ -8,11 +8,15 @@ import {AuthenticateFn, UserProfile} from './types';
 import {AuthenticationMetadata} from './decorators';
 import {BindingKey} from '@loopback/context';
 import {MetadataAccessor} from '@loopback/metadata';
+import {AuthenticationServices} from './services/authentication.service';
 
 /**
  * Binding keys used by this component.
  */
 export namespace AuthenticationBindings {
+  export const SERVICES = BindingKey.create<AuthenticationServices>(
+    'authentication.services',
+  );
   /**
    * Key used to bind an authentication strategy to the context for the
    * authentication function to use.
@@ -23,8 +27,8 @@ export namespace AuthenticationBindings {
    *   .toProvider(MyPassportStrategyProvider);
    * ```
    */
-  export const STRATEGY = BindingKey.create<Strategy | undefined>(
-    'authentication.strategy',
+  export const STRATEGY_RESOLVER = BindingKey.create<Strategy | undefined>(
+    'authentication.strategy.resolver',
   );
 
   /**

packages/authentication/src/providers/authentication.provider.ts → packages/authentication/src/providers/auth-action/passport/auth-action.provider.ts

@@ -6,9 +6,9 @@
 import {Getter, Provider, Setter, inject} from '@loopback/context';
 import {Request} from '@loopback/rest';
 import {Strategy} from 'passport';
-import {AuthenticationBindings} from '../keys';
-import {StrategyAdapter} from '../strategy-adapter';
-import {AuthenticateFn, UserProfile} from '../types';
+import {AuthenticationBindings} from '../../../keys';
+import {StrategyAdapter} from '../../../strategies/passport/passport-strategy-adapter';
+import {AuthenticateFn, UserProfile} from '../../../types';
 
 /**
  * @description Provider of a function which authenticates

packages/authentication/src/providers/index.ts

@@ -4,4 +4,4 @@
 // License text available at https://opensource.org/licenses/MIT
 
 export * from './auth-metadata.provider';
-export * from './authentication.provider';
+export * from './auth-action/passport/auth-action.provider';

packages/authentication/src/services/authentication.service.ts

@@ -0,0 +1,10 @@
+import {UserProfile, Credentials, AuthenticatedUser} from '../types';
+import {Entity} from '@loopback/repository';
+export interface AuthenticationServices {
+  authenticateUser<U extends Entity>(
+    credentials: Credentials,
+  ): Promise<AuthenticatedUser<U>>;
+  comparePassword<T = string>(credentialPass: T, userPass: T): Promise<boolean>;
+  generateAccessToken(user: UserProfile): Promise<string>;
+  decodeAccessToken(token: string): Promise<UserProfile | undefined>;
+}

packages/authentication/src/services/index.ts

@@ -0,0 +1 @@
+export * from './authentication.service';

packages/authentication/src/strategies/authentication-strategy.ts

@@ -0,0 +1,65 @@
+import {inject} from '@loopback/core';
+import {AuthenticationBindings} from '../keys';
+import {AuthenticationServices} from '../services';
+import {UserProfile, AuthenticatedUser, Credentials} from '../types';
+import {Entity} from '@loopback/repository';
+import {HttpErrors} from '@loopback/rest';
+import {toJSON} from '@loopback/testlab';
+import * as _ from 'lodash';
+
+/**
+ * An interface describes the common authentication strategy.
+ *
+ * An authentication strategy is usually a class with an
+ * authenticate method that verifies a user's identity and
+ * returns the corresponding user profile.
+ *
+ * Please note this file should be moved to @loopback/authentication
+ */
+export abstract class AuthenticationStrategy {
+  constructor(
+    @inject(AuthenticationBindings.SERVICES)
+    private services: AuthenticationServices,
+  ) {}
+  abstract async authenticateRequest(
+    request: Request,
+  ): Promise<UserProfile | undefined>;
+
+  async authenticateUser<U extends Entity>(
+    credentials: Credentials,
+  ): Promise<AuthenticatedUser<U>> {
+    return this.services.authenticateUser(credentials);
+  }
+
+  async comparePassword<T = string>(
+    credentialPass: T,
+    userPass: T,
+  ): Promise<boolean> {
+    return this.services.comparePassword(credentialPass, userPass);
+  }
+
+  async generateAccessToken(user: UserProfile): Promise<string> {
+    return this.services.generateAccessToken(user);
+  }
+
+  async decodeAccessToken(token: string): Promise<UserProfile | undefined> {
+    return this.services.decodeAccessToken(token);
+  }
+
+  async getAccessTokenForUser(credentials: Credentials): Promise<string> {
+    const user = await this.authenticateUser(credentials);
+    // There is no guarantee that an Entity contains field `password`
+    const userWithPassword = Object.assign({password: ''}, user);
+    const passwordMatched = await this.comparePassword(
+      credentials.password,
+      userWithPassword.password,
+    );
+    if (!passwordMatched) {
+      throw new HttpErrors.Unauthorized('The credentials are not correct.');
+    }
+
+    const userProfile = _.pick(toJSON(user), ['id', 'email', 'firstName']);
+    const token = await this.generateAccessToken(userProfile);
+    return token;
+  }
+}

packages/authentication/src/strategies/index.ts

@@ -0,0 +1,2 @@
+export * from './authentication-strategy';
+export * from './passport/passport-strategy-adapter';

packages/authentication/src/strategy-adapter.ts → packages/authentication/src/strategies/passport/passport-strategy-adapter.ts

@@ -5,7 +5,7 @@
 
 import {HttpErrors, Request} from '@loopback/rest';
 import {Strategy} from 'passport';
-import {UserProfile} from './types';
+import {UserProfile} from '../../types';
 
 const passportRequestMixin = require('passport/lib/http/request');
 

packages/authentication/src/types.ts

@@ -4,6 +4,7 @@
 // License text available at https://opensource.org/licenses/MIT
 
 import {Request} from '@loopback/rest';
+import {Entity} from '@loopback/repository';
 
 /**
  * interface definition of a function which accepts a request
@@ -22,3 +23,13 @@ export interface UserProfile {
   name?: string;
   email?: string;
 }
+
+export type Credentials = {
+  email: string;
+  password: string;
+};
+
+export type AuthenticatedUser<U extends Entity> = {
+  authenticated: boolean;
+  userInfo?: U;
+};