Authentication metadata stored via Reflection API

Binding keys used by this component.

Key used to inject the authentication function into the sequence.

class MySequence implements SequenceHandler {
  constructor(
    @inject(AuthenticationBindings.AUTH_ACTION)
    protected authenticateRequest: AuthenticateFn,
    // ... other sequence action injections
  ) {}

  async handle(context: RequestContext) {
    try {
      const {request, response} = context;
      const route = this.findRoute(request);

     // Authenticate
      await this.authenticateRequest(request);

      // Authentication successful, proceed to invoke controller
      const args = await this.parseParams(request, route);
      const result = await this.invoke(route, args);
      this.send(response, result);
    } catch (err) {
      this.reject(context, err);
    }
  }
}

Key used to inject the user instance retrieved by the authentication function

class MyController { constructor( @inject(AuthenticationBindings.CURRENT_USER) private user: UserProfile, ) {}

// ... routes that may need authentication }

Key used to inject authentication metadata, which is used to determine whether a request requires authentication or not.

class MyPassportStrategyProvider implements Provider<Strategy | undefined> {
  constructor(
    @inject(AuthenticationBindings.METADATA)
    private metadata: AuthenticationMetadata,
  ) {}
  value(): ValueOrPromise<Strategy | undefined> {
    if (this.metadata) {
      const name = this.metadata.strategy;
      // logic to determine which authentication strategy to return
    }
  }
}

Key used to bind an authentication strategy to the context for the authentication function to use.

server
  .bind(AuthenticationBindings.STRATEGY)
  .toProvider(MyPassportStrategyProvider);

The key used to store log-related via @loopback/metadata and reflection.

The implementation of authenticate() sequence action.

Adapter class to invoke passport-strategy

1. provides express dependencies to the passport strategies
2. provides shimming of requests for passport authentication
3. provides lifecycle similar to express to the passport-strategy
4. provides state methods to the strategy instance see: https://github.com/jaredhanson/passport

The function to invoke the contained passport strategy.

1. Create an instance of the strategy
2. add success and failure state handlers
3. authenticate using the strategy

interface definition of a function which accepts a request and returns an authenticated user

interface definition of a user profile http://openid.net/specs/openid-connect-core-1_0.html#StandardClaims