@loopback/authentication-passport 2.1.9 → 2.1.13

package/CHANGELOG.md

@@ -3,6 +3,41 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [2.1.13](https://github.com/strongloop/loopback-next/compare/@loopback/authentication-passport@2.1.12...@loopback/authentication-passport@2.1.13) (2020-08-27)
+
+**Note:** Version bump only for package @loopback/authentication-passport
+
+
+
+
+
+## [2.1.12](https://github.com/strongloop/loopback-next/compare/@loopback/authentication-passport@2.1.11...@loopback/authentication-passport@2.1.12) (2020-08-19)
+
+**Note:** Version bump only for package @loopback/authentication-passport
+
+
+
+
+
+## [2.1.11](https://github.com/strongloop/loopback-next/compare/@loopback/authentication-passport@2.1.10...@loopback/authentication-passport@2.1.11) (2020-08-05)
+
+**Note:** Version bump only for package @loopback/authentication-passport
+
+
+
+
+
+## [2.1.10](https://github.com/strongloop/loopback-next/compare/@loopback/authentication-passport@2.1.9...@loopback/authentication-passport@2.1.10) (2020-07-20)
+
+
+### Bug Fixes
+
+* **docs:** fix numbering ([bb9a5ae](https://github.com/strongloop/loopback-next/commit/bb9a5ae6b74018a1ec69070d5aaaf1b29ca66647))
+
+
+
+
+
 ## [2.1.9](https://github.com/strongloop/loopback-next/compare/@loopback/authentication-passport@2.1.8...@loopback/authentication-passport@2.1.9) (2020-06-30)
 
 **Note:** Version bump only for package @loopback/authentication-passport

package/README.md

@@ -48,141 +48,142 @@ npm i passport-http @types/passport-http --save
 
 1. Create an instance of the passport strategy
 
-Taking the basic strategy exported from
-[`passport-http`](https://github.com/jaredhanson/passport-http) as an example,
-first create an instance of the basic strategy with your `verify` function.
+   Taking the basic strategy exported from
+   [`passport-http`](https://github.com/jaredhanson/passport-http) as an
+   example, first create an instance of the basic strategy with your `verify`
+   function.
 
-```ts
-// Create a file named `my-basic-auth-strategy.ts` to define your strategy below
+   ```ts
+   // Create a file named `my-basic-auth-strategy.ts` to define your strategy below
 
-import {BasicStrategy} from 'passport-http';
+   import {BasicStrategy} from 'passport-http';
 
-function verify(username: string, password: string, cb: Function) {
-  users.find(username, password, cb);
-}
-const basicStrategy = new BasicStrategy(verify);
-```
+   function verify(username: string, password: string, cb: Function) {
+     users.find(username, password, cb);
+   }
+   const basicStrategy = new BasicStrategy(verify);
+   ```
 
-It's a similar configuration as you add a strategy to a `passport` by calling
-`passport.use()`.
+   It's a similar configuration as you add a strategy to a `passport` by calling
+   `passport.use()`.
 
 2. Supply a _user profile factory_ which converts a user to a user profile. It
    must abide by the `UserProfileFactory` interface supplied by
    `@loopback/authentication@3.x`.
 
-It is shown below for your convenience.
+   It is shown below for your convenience.
 
-```ts
-export interface UserProfileFactory<U> {
-  (user: U): UserProfile;
-}
-```
+   ```ts
+   export interface UserProfileFactory<U> {
+     (user: U): UserProfile;
+   }
+   ```
 
-A default user profile factory is provided for you in the StrategyAdapter
-constructor, but it does very little. It simply returns the user model as-is.
+   A default user profile factory is provided for you in the StrategyAdapter
+   constructor, but it does very little. It simply returns the user model as-is.
 
-```ts
-private userProfileFactory: UserProfileFactory<U> = (u: unknown) => {
-      return u as UserProfile;
-},
-```
+   ```ts
+   private userProfileFactory: UserProfileFactory<U> = (u: unknown) => {
+         return u as UserProfile;
+   },
+   ```
 
-So it is recommended you provide a more meaningful mapping.
+   So it is recommended you provide a more meaningful mapping.
 
-An example of a user profile factory converting a specific user type `MyUser` to
-type `UserProfile` is shown below.
+   An example of a user profile factory converting a specific user type `MyUser`
+   to type `UserProfile` is shown below.
 
-```ts
-//In file 'my.userprofile.factory.ts'
+   ```ts
+   //In file 'my.userprofile.factory.ts'
 
-import {UserProfileFactory} from '@loopback/authentication';
-import {securityId, UserProfile} from '@loopback/security';
+   import {UserProfileFactory} from '@loopback/authentication';
+   import {securityId, UserProfile} from '@loopback/security';
 
-export const myUserProfileFactory: UserProfileFactory<MyUser> = function (
-  user: MyUser,
-): UserProfile {
-  const userProfile = {[securityId]: user.id};
-  return userProfile;
-};
-```
+   export const myUserProfileFactory: UserProfileFactory<MyUser> = function (
+     user: MyUser,
+   ): UserProfile {
+     const userProfile = {[securityId]: user.id};
+     return userProfile;
+   };
+   ```
 
 3. Apply the adapter to the strategy
 
-```ts
-// In file 'my-basic-auth-strategy.ts'
-import {BasicStrategy} from 'passport-http';
-import {UserProfileFactory} from '@loopback/authentication';
-import {securityId, UserProfile} from '@loopback/security';
-import {myUserProfileFactory} from '<path to user profile factory>';
-
-function verify(username: string, password: string, cb: Function) {
-  users.find(username, password, cb);
-}
-const basicStrategy = new BasicStrategy(verify);
-
-// Apply the adapter
-export const AUTH_STRATEGY_NAME = 'basic';
-export const basicAuthStrategy = new StrategyAdapter(
-  // The configured basic strategy instance
-  basicStrategy,
-  // Give the strategy a name
-  // You'd better define your strategy name as a constant, like
-  // `const AUTH_STRATEGY_NAME = 'basic'`.
-  // You will need to decorate the APIs later with the same name.
-  AUTH_STRATEGY_NAME,
-  // Provide a user profile factory
-  myUserProfileFactory,
-);
-```
+   ```ts
+   // In file 'my-basic-auth-strategy.ts'
+   import {BasicStrategy} from 'passport-http';
+   import {UserProfileFactory} from '@loopback/authentication';
+   import {securityId, UserProfile} from '@loopback/security';
+   import {myUserProfileFactory} from '<path to user profile factory>';
+
+   function verify(username: string, password: string, cb: Function) {
+     users.find(username, password, cb);
+   }
+   const basicStrategy = new BasicStrategy(verify);
+
+   // Apply the adapter
+   export const AUTH_STRATEGY_NAME = 'basic';
+   export const basicAuthStrategy = new StrategyAdapter(
+     // The configured basic strategy instance
+     basicStrategy,
+     // Give the strategy a name
+     // You'd better define your strategy name as a constant, like
+     // `const AUTH_STRATEGY_NAME = 'basic'`.
+     // You will need to decorate the APIs later with the same name.
+     AUTH_STRATEGY_NAME,
+     // Provide a user profile factory
+     myUserProfileFactory,
+   );
+   ```
 
 4. Register(bind) the strategy to app
 
-```ts
-import {Application, CoreTags} from '@loopback/core';
-import {AuthenticationBindings} from '@loopback/authentication';
-import {basicAuthStrategy} from './my-basic-auth-strategy';
-
-app
-  .bind('authentication.strategies.basicAuthStrategy')
-  .to(basicAuthStrategy)
-  .tag({
-    [CoreTags.EXTENSION_FOR]:
-      AuthenticationBindings.AUTHENTICATION_STRATEGY_EXTENSION_POINT_NAME,
-  });
-```
+   ```ts
+   import {Application, CoreTags} from '@loopback/core';
+   import {AuthenticationBindings} from '@loopback/authentication';
+   import {basicAuthStrategy} from './my-basic-auth-strategy';
+
+   app
+     .bind('authentication.strategies.basicAuthStrategy')
+     .to(basicAuthStrategy)
+     .tag({
+       [CoreTags.EXTENSION_FOR]:
+         AuthenticationBindings.AUTHENTICATION_STRATEGY_EXTENSION_POINT_NAME,
+     });
+   ```
 
 5. Decorate your endpoint
 
-To authenticate your request with the basic strategy, decorate your controller
-function like:
-
-```ts
-import {AUTH_STRATEGY_NAME} from './my-basic-auth-strategy';
-import {SecurityBindings, UserProfile} from '@loopback/security';
-import {authenticate} from '@loopback/authentication';
-
-class MyController {
-  constructor(
-    @inject(SecurityBindings.USER, {optional: true})
-    private user: UserProfile,
-  ) {}
-
-  // Define your strategy name as a constant so that
-  // it is consistent with the name you provide in the adapter
-  @authenticate(AUTH_STRATEGY_NAME)
-  async whoAmI(): Promise<string> {
-    return this.user.id;
-  }
-}
-```
+   To authenticate your request with the basic strategy, decorate your
+   controller function like:
+
+   ```ts
+   import {AUTH_STRATEGY_NAME} from './my-basic-auth-strategy';
+   import {SecurityBindings, UserProfile} from '@loopback/security';
+   import {authenticate} from '@loopback/authentication';
+
+   class MyController {
+     constructor(
+       @inject(SecurityBindings.USER, {optional: true})
+       private user: UserProfile,
+     ) {}
+
+     // Define your strategy name as a constant so that
+     // it is consistent with the name you provide in the adapter
+     @authenticate(AUTH_STRATEGY_NAME)
+     async whoAmI(): Promise<string> {
+       return this.user.id;
+     }
+   }
+   ```
 
 6. Add the authentication action to your sequence
 
-This part is same as registering a non-passport based strategy. Please make sure
-you follow the documentation
-[adding-an-authentication-action-to-a-custom-sequence](https://loopback.io/doc/en/lb4/Loopback-component-authentication.html#adding-an-authentication-action-to-a-custom-sequence)
-to rewrite your sequence. You can also find a sample implementation in
-[this example tutorial](https://loopback.io/doc/en/lb4/Authentication-tutorial.html#creating-a-custom-sequence-and-adding-the-authentication-action).
+   This part is same as registering a non-passport based strategy. Please make
+   sure you follow the documentation
+   [adding-an-authentication-action-to-a-custom-sequence](https://loopback.io/doc/en/lb4/Loopback-component-authentication.html#adding-an-authentication-action-to-a-custom-sequence)
+   to rewrite your sequence. You can also find a sample implementation in
+   [this example tutorial](https://loopback.io/doc/en/lb4/Authentication-tutorial.html#creating-a-custom-sequence-and-adding-the-authentication-action).
 
 ### With Provider
 
@@ -196,199 +197,206 @@ in
 
 1. Create a provider for the strategy
 
-Use `passport-http` as the example again:
-
-```ts
-// Create a file named `my-basic-auth-strategy.ts` to define your strategy below
-
-import {AuthenticationStrategy} from '@loopback/authentication';
-import {Provider} from '@loopback/core';
-
-class PassportBasicAuthProvider implements Provider<AuthenticationStrategy> {
-  value(): AuthenticationStrategy {
-    // The code that returns the converted strategy
-  }
-}
-```
-
-The Provider should have two functions:
-
-- A function that takes in the verify callback function and returns a configured
-  basic strategy. To know more about the configuration, please check
-  [the configuration guide in module `passport-http`](https://github.com/jaredhanson/passport-http#usage-of-http-basic).
-
-- A function that applies the `StrategyAdapter` to the configured basic strategy
-  instance. Then in the `value()` function, you return the converted strategy.
-
-So a full implementation of the provider is:
-
-```ts
-// In file 'providers/my-basic-auth-strategy.ts'
-
-import {BasicStrategy, BasicVerifyFunction} from 'passport-http';
-import {StrategyAdapter} from `@loopback/passport-adapter`;
-import {
-  AuthenticationStrategy,
-  AuthenticationBindings,
-} from '@loopback/authentication';
-import {Provider, inject} from '@loopback/core';
-
-export class PassportBasicAuthProvider<MyUser>
-  implements Provider<AuthenticationStrategy> {
-  constructor(
-    @inject('authentication.basic.verify')
-    private verifyFn: BasicVerifyFunction,
-    @inject(AuthenticationBindings.USER_PROFILE_FACTORY)
-    private myUserProfileFactory: UserProfileFactory<MyUser>,
-  ) {}
-
-  value(): AuthenticationStrategy {
-    const basicStrategy = this.configuredBasicStrategy(this.verifyFn);
-    return this.convertToAuthStrategy(basicStrategy);
-  }
-
-  // Takes in the verify callback function and returns a configured basic strategy.
-  configuredBasicStrategy(verifyFn: BasicVerifyFunction): BasicStrategy {
-    return new BasicStrategy(verifyFn);
-  }
-
-  // Applies the `StrategyAdapter` to the configured basic strategy instance.
-  // You'd better define your strategy name as a constant, like
-  // `const AUTH_STRATEGY_NAME = 'basic'`
-  // You will need to decorate the APIs later with the same name
-  // Pass in the user profile factory
-  convertToAuthStrategy(basic: BasicStrategy): AuthenticationStrategy {
-    return new StrategyAdapter(
-      basic,
-      AUTH_STRATEGY_NAME,
-      this.myUserProfileFactory,
-    );
-  }
-}
-```
+   Use `passport-http` as the example again:
+
+   ```ts
+   // Create a file named `my-basic-auth-strategy.ts` to define your strategy below
+
+   import {AuthenticationStrategy} from '@loopback/authentication';
+   import {Provider} from '@loopback/core';
+
+   class PassportBasicAuthProvider implements Provider<AuthenticationStrategy> {
+     value(): AuthenticationStrategy {
+       // The code that returns the converted strategy
+     }
+   }
+   ```
+
+   The Provider should have two functions:
+
+   - A function that takes in the verify callback function and returns a
+     configured basic strategy. To know more about the configuration, please
+     check
+     [the configuration guide in module `passport-http`](https://github.com/jaredhanson/passport-http#usage-of-http-basic).
+
+   - A function that applies the `StrategyAdapter` to the configured basic
+     strategy instance. Then in the `value()` function, you return the converted
+     strategy.
+
+   So a full implementation of the provider is:
+
+   ```ts
+   // In file 'providers/my-basic-auth-strategy.ts'
+
+   import {BasicStrategy, BasicVerifyFunction} from 'passport-http';
+   import {StrategyAdapter} from `@loopback/passport-adapter`;
+   import {
+     AuthenticationStrategy,
+     AuthenticationBindings,
+   } from '@loopback/authentication';
+   import {Provider, inject} from '@loopback/core';
+
+   export class PassportBasicAuthProvider<MyUser>
+     implements Provider<AuthenticationStrategy> {
+     constructor(
+       @inject('authentication.basic.verify')
+       private verifyFn: BasicVerifyFunction,
+       @inject(AuthenticationBindings.USER_PROFILE_FACTORY)
+       private myUserProfileFactory: UserProfileFactory<MyUser>,
+     ) {}
+
+     value(): AuthenticationStrategy {
+       const basicStrategy = this.configuredBasicStrategy(this.verifyFn);
+       return this.convertToAuthStrategy(basicStrategy);
+     }
+
+     // Takes in the verify callback function and returns a configured basic strategy.
+     configuredBasicStrategy(verifyFn: BasicVerifyFunction): BasicStrategy {
+       return new BasicStrategy(verifyFn);
+     }
+
+     // Applies the `StrategyAdapter` to the configured basic strategy instance.
+     // You'd better define your strategy name as a constant, like
+     // `const AUTH_STRATEGY_NAME = 'basic'`
+     // You will need to decorate the APIs later with the same name
+     // Pass in the user profile factory
+     convertToAuthStrategy(basic: BasicStrategy): AuthenticationStrategy {
+       return new StrategyAdapter(
+         basic,
+         AUTH_STRATEGY_NAME,
+         this.myUserProfileFactory,
+       );
+     }
+   }
+   ```
 
 2. Create a provider for the verify function.
 
-Here is an example provider named VerifyFunctionProvider which has a `value()`
-method that returns a function of type BasicVerifyFunction.
-
-```ts
-// In file 'providers/verifyfn.provider.ts'
-
-import {Provider} from '@loopback/core';
-import {repository} from '@loopback/repository';
-import {BasicVerifyFunction} from 'passport-http';
-import {INVALID_USER_CREDENTIALS_MESSAGE} from '../keys';
-
-export class VerifyFunctionProvider implements Provider<BasicVerifyFunction> {
-  constructor(@repository('users') private userRepo: MyUserRepository) {}
-
-  value(): BasicVerifyFunction {
-    const myThis = this;
-
-    return async function (username: string, password: string, cb: Function) {
-      let user: MyUser;
-
-      try {
-        //find user with specific username
-        const users: MyUser[] = await myThis.userRepo.find({
-          where: {username: username},
-        });
-
-        // if no user found with this username, throw an error.
-        if (users.length < 1) {
-          let error = new Error(INVALID_USER_CREDENTIALS_MESSAGE); //assign 401 in sequence
-          throw error;
-        }
-
-        //verify given password matches the user's password
-        user = users[0];
-        if (user.password !== password) {
-          let error = new Error(INVALID_USER_CREDENTIALS_MESSAGE); //assign 401 in sequence
-          throw error;
-        }
-
-        //return null for error, and the valid user
-        cb(null, user);
-      } catch (error) {
-        //return the error, and null for the user
-        cb(error, null);
-      }
-    };
-  }
-}
-```
+   Here is an example provider named VerifyFunctionProvider which has a
+   `value()` method that returns a function of type BasicVerifyFunction.
+
+   ```ts
+   // In file 'providers/verifyfn.provider.ts'
+
+   import {Provider} from '@loopback/core';
+   import {repository} from '@loopback/repository';
+   import {BasicVerifyFunction} from 'passport-http';
+   import {INVALID_USER_CREDENTIALS_MESSAGE} from '../keys';
+
+   export class VerifyFunctionProvider
+     implements Provider<BasicVerifyFunction> {
+     constructor(@repository('users') private userRepo: MyUserRepository) {}
+
+     value(): BasicVerifyFunction {
+       const myThis = this;
+
+       return async function (
+         username: string,
+         password: string,
+         cb: Function,
+       ) {
+         let user: MyUser;
+
+         try {
+           //find user with specific username
+           const users: MyUser[] = await myThis.userRepo.find({
+             where: {username: username},
+           });
+
+           // if no user found with this username, throw an error.
+           if (users.length < 1) {
+             let error = new Error(INVALID_USER_CREDENTIALS_MESSAGE); //assign 401 in sequence
+             throw error;
+           }
+
+           //verify given password matches the user's password
+           user = users[0];
+           if (user.password !== password) {
+             let error = new Error(INVALID_USER_CREDENTIALS_MESSAGE); //assign 401 in sequence
+             throw error;
+           }
+
+           //return null for error, and the valid user
+           cb(null, user);
+         } catch (error) {
+           //return the error, and null for the user
+           cb(error, null);
+         }
+       };
+     }
+   }
+   ```
 
 3. Register(bind) the providers
 
-Register **VerifyFunctionProvider** which is required by
-**PassportBasicAuthProvider**. Then register **PassportBasicAuthProvider** in
-your LoopBack application so that the authentication system can look for your
-strategy by name and invoke it.
-
-```ts
-// In the main file
-
-import {addExtension} from '@loopback/core';
-import {MyApplication} from '<path_to_your_app>';
-import {PassportBasicAuthProvider} from '<path_to_the_provider>';
-import {VerifyFunctionProvider} from '<path_to_the_provider>';
-import {
-  AuthenticationBindings,
-  AuthenticationComponent,
-} from '@loopback/authentication';
-
-const app = new MyApplication();
-
-//load the authentication component
-app.component(AuthenticationComponent);
-
-// bind the user repo
-app.bind('repositories.users').toClass(MyUserRepository);
-
-// bind the authenticated sequence (mentioned later in this document)
-app.sequence(MyAuthenticationSequence);
-
-// the verify function for passport-http
-app.bind('authentication.basic.verify').toProvider(VerifyFunctionProvider);
-
-// register PassportBasicAuthProvider as a custom authentication strategy
-addExtension(
-  app,
-  AuthenticationBindings.AUTHENTICATION_STRATEGY_EXTENSION_POINT_NAME,
-  PassportBasicAuthProvider,
-  {
-    namespace:
-      AuthenticationBindings.AUTHENTICATION_STRATEGY_EXTENSION_POINT_NAME,
-  },
-);
-```
+   Register **VerifyFunctionProvider** which is required by
+   **PassportBasicAuthProvider**. Then register **PassportBasicAuthProvider** in
+   your LoopBack application so that the authentication system can look for your
+   strategy by name and invoke it.
+
+   ```ts
+   // In the main file
+
+   import {addExtension} from '@loopback/core';
+   import {MyApplication} from '<path_to_your_app>';
+   import {PassportBasicAuthProvider} from '<path_to_the_provider>';
+   import {VerifyFunctionProvider} from '<path_to_the_provider>';
+   import {
+     AuthenticationBindings,
+     AuthenticationComponent,
+   } from '@loopback/authentication';
+
+   const app = new MyApplication();
+
+   //load the authentication component
+   app.component(AuthenticationComponent);
+
+   // bind the user repo
+   app.bind('repositories.users').toClass(MyUserRepository);
+
+   // bind the authenticated sequence (mentioned later in this document)
+   app.sequence(MyAuthenticationSequence);
+
+   // the verify function for passport-http
+   app.bind('authentication.basic.verify').toProvider(VerifyFunctionProvider);
+
+   // register PassportBasicAuthProvider as a custom authentication strategy
+   addExtension(
+     app,
+     AuthenticationBindings.AUTHENTICATION_STRATEGY_EXTENSION_POINT_NAME,
+     PassportBasicAuthProvider,
+     {
+       namespace:
+         AuthenticationBindings.AUTHENTICATION_STRATEGY_EXTENSION_POINT_NAME,
+     },
+   );
+   ```
 
 4. Decorate your endpoint
 
-To authenticate your request with the basic strategy, decorate your controller
-function like:
+   To authenticate your request with the basic strategy, decorate your
+   controller function like:
 
-```ts
-import {AUTH_STRATEGY_NAME} from './my-basic-auth-strategy';
-import {authenticate} from '@loopback/authentication';
+   ```ts
+   import {AUTH_STRATEGY_NAME} from './my-basic-auth-strategy';
+   import {authenticate} from '@loopback/authentication';
 
-class MyController {
-  constructor(@inject(SecurityBindings.USER) private user: UserProfile) {}
+   class MyController {
+     constructor(@inject(SecurityBindings.USER) private user: UserProfile) {}
 
-  // Define your strategy name as a constant so that
-  // it is consistent with the name you provide in the adapter
-  @authenticate(AUTH_STRATEGY_NAME)
-  async whoAmI(): Promise<string> {
-    return this.user.id;
-  }
-}
-```
+     // Define your strategy name as a constant so that
+     // it is consistent with the name you provide in the adapter
+     @authenticate(AUTH_STRATEGY_NAME)
+     async whoAmI(): Promise<string> {
+       return this.user.id;
+     }
+   }
+   ```
 
 5. Add the authentication action to your sequence
 
-This part is same as registering a non-passport based strategy. Please make sure
-you follow the documentation
-[adding-an-authentication-action-to-a-custom-sequence](https://loopback.io/doc/en/lb4/Loopback-component-authentication.html#adding-an-authentication-action-to-a-custom-sequence)
-to rewrite your sequence. You can also find a sample implementation in
-[this example tutorial](https://loopback.io/doc/en/lb4/Authentication-tutorial.html#creating-a-custom-sequence-and-adding-the-authentication-action).
+   This part is same as registering a non-passport based strategy. Please make
+   sure you follow the documentation
+   [adding-an-authentication-action-to-a-custom-sequence](https://loopback.io/doc/en/lb4/Loopback-component-authentication.html#adding-an-authentication-action-to-a-custom-sequence)
+   to rewrite your sequence. You can also find a sample implementation in
+   [this example tutorial](https://loopback.io/doc/en/lb4/Authentication-tutorial.html#creating-a-custom-sequence-and-adding-the-authentication-action).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loopback/authentication-passport",
-  "version": "2.1.9",
+  "version": "2.1.13",
   "description": "A package creating adapters between the passport module and @loopback/authentication",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -40,38 +40,37 @@
     "directory": "extensions/authentication-passport"
   },
   "dependencies": {
-    "@loopback/authentication": "^4.2.9",
-    "@loopback/core": "^2.9.1",
-    "@loopback/openapi-v3": "^3.4.5",
-    "@loopback/rest": "^5.2.0",
-    "@loopback/security": "^0.2.14",
+    "@loopback/authentication": "^6.0.1",
+    "@loopback/core": "^2.9.5",
+    "@loopback/rest": "^6.2.0",
+    "@loopback/security": "^0.2.18",
     "passport": "^0.4.1",
-    "tslib": "^2.0.0",
+    "tslib": "^2.0.1",
     "util-promisifyall": "^1.0.6"
   },
   "devDependencies": {
-    "@loopback/build": "^6.1.0",
-    "@loopback/eslint-config": "^8.0.3",
-    "@loopback/mock-oauth2-provider": "^0.1.3",
-    "@loopback/openapi-spec-builder": "^2.1.9",
-    "@loopback/testlab": "^3.2.0",
+    "@loopback/build": "^6.2.2",
+    "@loopback/eslint-config": "^9.0.2",
+    "@loopback/mock-oauth2-provider": "^0.1.7",
+    "@loopback/openapi-spec-builder": "^2.1.13",
+    "@loopback/testlab": "^3.2.4",
     "@types/jsonwebtoken": "^8.5.0",
-    "@types/lodash": "^4.14.157",
-    "@types/node": "^10.17.26",
-    "@types/passport": "^1.0.3",
+    "@types/lodash": "^4.14.160",
+    "@types/node": "^10.17.28",
+    "@types/passport": "^1.0.4",
     "@types/passport-http": "^0.3.8",
     "@types/passport-oauth2": "^1.4.9",
-    "@types/qs": "^6.9.3",
-    "axios": "^0.19.2",
+    "@types/qs": "^6.9.4",
+    "axios": "^0.20.0",
     "body-parser": "^1.19.0",
     "express": "^4.17.1",
     "form-data": "^3.0.0",
     "jsonwebtoken": "^8.5.1",
-    "lodash": "^4.17.15",
+    "lodash": "^4.17.20",
     "passport-http": "^0.3.0",
     "passport-oauth2": "^1.5.0",
     "qs": "^6.9.4",
     "supertest": "^4.0.2"
   },
-  "gitHead": "b89db3d3b8be6a36e63e91c2331d217fda7538de"
+  "gitHead": "a3f54273814de63819e0d8bc86509f8a737800bb"
 }