@loopback/core

constructor

constructor(parent: Context);

• Create an application with the given parent context

  Parameter parent

  Parent context

constructor

constructor(config?: ApplicationConfig, parent?: Context);

• Create an application with the given configuration and parent context

  Parameter config

  Application configuration

  Parameter parent

  Parent context

property options

readonly options: ApplicationConfig;

property state

readonly state: string;

• Get the state of the application. The initial state is created and it can transition as follows by start and stop:

  1. start - !started -> starting -> started - started -> started (no-op) 2. stop - (started | initialized) -> stopping -> stopped - ! (started || initialized) -> stopped (no-op)

  Two types of states are expected: - stable, such as started and stopped - in process, such as booting and starting

  Operations such as start and stop can only be called at a stable state. The logic should immediately set the state to a new one indicating work in process, such as starting and stopping.

method assertInStates

protected assertInStates: (op: string, ...states: string[]) => void;

• Assert current state of the application to be one of the expected values

  Parameter op

  The operation name, such as 'boot', 'start', or 'stop'

  Parameter states

  Valid states

method assertNotInProcess

protected assertNotInProcess: (op: string) => void;

• Assert there is no other operation is in progress, i.e., the state is not *ing, such as starting or stopping.

  Parameter op

  The operation name, such as 'boot', 'start', or 'stop'

method awaitState

protected awaitState: (state: string) => Promise<void>;

method component

component: <T extends Component = Component>(
    componentCtor: Constructor<T>,
    nameOrOptions?: string | BindingFromClassOptions
) => Binding<T>;

• Add a component to this application and register extensions such as controllers, providers, and servers from the component.

  Parameter componentCtor

  The component class to add.

  Parameter nameOrOptions

  Optional component name or options, default to the class name

  Example 1

  export class ProductComponent {
    controllers = [ProductController];
    repositories = [ProductRepo, UserRepo];
    providers = {
      [AUTHENTICATION_STRATEGY]: AuthStrategy,
      [AUTHORIZATION_ROLE]: Role,
    };
  };
  
  app.component(ProductComponent);

method controller

controller: <T>(
    controllerCtor: Constructor<T>,
    nameOrOptions?: string | BindingFromClassOptions
) => Binding<T>;

• Register a controller class with this application.

  Parameter controllerCtor

  The controller class (constructor function).

  Parameter name

  Optional controller name, default to the class name

  Returns

  The newly created binding, you can use the reference to further modify the binding, e.g. lock the value to prevent further modifications.

  Example 1

  class MyController {
  }
  app.controller(MyController).lock();

method getServer

getServer: <T extends Server>(target: Constructor<T> | string) => Promise<T>;

• Retrieve the singleton instance for a bound server.

  Parameter ctor

  The constructor that was used to make the binding.

  Returns

  A Promise of server instance

method init

init: () => Promise<void>;

• Initialize the application, and all of its registered observers. The application state is checked to ensure the integrity of initialize.

  If the application is already initialized, no operation is performed.

  This method is automatically invoked by start() if the application is not initialized.

method interceptor

interceptor: (
    interceptor: Interceptor | Constructor<Provider<Interceptor>>,
    nameOrOptions?: string | InterceptorBindingOptions
) => Binding<Interceptor>;

• Register an interceptor

  Parameter interceptor

  An interceptor function or provider class

  Parameter nameOrOptions

  Binding name or options

method lifeCycleObserver

lifeCycleObserver: <T extends LifeCycleObserver>(
    ctor: Constructor<T>,
    nameOrOptions?: string | BindingFromClassOptions
) => Binding<T>;

• Register a life cycle observer class

  Parameter ctor

  A class implements LifeCycleObserver

  Parameter nameOrOptions

  Optional name or options for the life cycle observer

method onInit

onInit: (fn: () => ValueOrPromise<void>) => Binding<LifeCycleObserver>;

• Register a function to be called when the application initializes.

  This is a shortcut for adding a binding for a LifeCycleObserver implementing a init() method.

  Parameter fn

  The function to invoke, it can be synchronous (returning void) or asynchronous (returning Promise<void>).

  Returns

  The LifeCycleObserver binding created.

method onStart

onStart: (fn: () => ValueOrPromise<void>) => Binding<LifeCycleObserver>;

• Register a function to be called when the application starts.

  This is a shortcut for adding a binding for a LifeCycleObserver implementing a start() method.

  Parameter fn

  The function to invoke, it can be synchronous (returning void) or asynchronous (returning Promise<void>).

  Returns

  The LifeCycleObserver binding created.

method onStop

onStop: (fn: () => ValueOrPromise<void>) => Binding<LifeCycleObserver>;

• Register a function to be called when the application starts.

  This is a shortcut for adding a binding for a LifeCycleObserver implementing a start() method.

  Parameter fn

  The function to invoke, it can be synchronous (returning void) or asynchronous (returning Promise<void>).

  Returns

  The LifeCycleObserver binding created.

method server

server: <T extends Server>(
    ctor: Constructor<T>,
    nameOrOptions?: string | BindingFromClassOptions
) => Binding<T>;

• Bind a Server constructor to the Application's master context. Each server constructor added in this way must provide a unique prefix to prevent binding overlap.

  Parameter server

  The server constructor.

  Parameter nameOrOptions

  Optional override for name or options.

  Returns

  Binding for the server class

  Example 1

  app.server(RestServer);
  // This server constructor will be bound under "servers.RestServer".
  app.server(RestServer, "v1API");
  // This server instance will be bound under "servers.v1API".

method servers

servers: <T extends Server>(ctors: Constructor<T>[]) => Binding[];

• Bind an array of Server constructors to the Application's master context. Each server added in this way will automatically be named based on the class constructor name with the "servers." prefix.

  Parameter ctors

  An array of Server constructors.

  Returns

  An array of bindings for the registered server classes

  Remarks

  If you wish to control the binding keys for particular server instances, use the app.server function instead.

  app.servers([
   RestServer,
   GRPCServer,
  ]);
  // Creates a binding for "servers.RestServer" and a binding for
  // "servers.GRPCServer";

method service

service: <S>(
    cls: ServiceOrProviderClass<S>,
    nameOrOptions?: string | ServiceOptions
) => Binding<S>;

• Add a service to this application.

  Parameter cls

  The service or provider class

  Example 1

  // Define a class to be bound via ctx.toClass()
  @injectable({scope: BindingScope.SINGLETON})
  export class LogService {
    log(msg: string) {
      console.log(msg);
    }
  }
  
  // Define a class to be bound via ctx.toProvider()
  import {v4 as uuidv4} from 'uuid';
  export class UuidProvider implements Provider<string> {
    value() {
      return uuidv4();
    }
  }
  
  // Register the local services
  app.service(LogService);
  app.service(UuidProvider, 'uuid');
  
  export class MyController {
    constructor(
      @inject('services.uuid') private uuid: string,
      @inject('services.LogService') private log: LogService,
    ) {
    }
  
    greet(name: string) {
      this.log(`Greet request ${this.uuid} received: ${name}`);
      return `${this.uuid}: ${name}`;
    }
  }

method setMetadata

setMetadata: (metadata: ApplicationMetadata) => void;

• Set application metadata. @loopback/boot calls this method to populate the metadata from package.json.

  Parameter metadata

  Application metadata

method setState

protected setState: (state: string) => void;

• Transition the application to a new state and emit an event

  Parameter state

  The new state

method setupShutdown

protected setupShutdown: () => (signal: string) => Promise<void>;

• Set up signals that are captured to shutdown the application

method start

start: () => Promise<void>;

• Start the application, and all of its registered observers. The application state is checked to ensure the integrity of start.

  If the application is not initialized, it calls first init() to initialize the application. This only happens if start() is called for the first time.

  If the application is already started, no operation is performed.

method stop

stop: () => Promise<void>;

• Stop the application instance and all of its registered observers. The application state is checked to ensure the integrity of stop.

  If the application is already stopped or not started, no operation is performed.

constructor

constructor(
    context: Context,
    observersView: ContextView<LifeCycleObserver>,
    options?: LifeCycleObserverOptions
);

property context

protected readonly context: Context;

property observersView

protected readonly observersView: ContextView<LifeCycleObserver>;

property options

protected readonly options: LifeCycleObserverOptions;

method getObserverGroup

protected getObserverGroup: (binding: Binding<LifeCycleObserver>) => string;

• Get the group for a given life cycle observer binding

  Parameter binding

  Life cycle observer binding

method getObserverGroupsByOrder

getObserverGroupsByOrder: () => LifeCycleObserverGroup[];

• Get observer groups ordered by the group

method init

init: () => Promise<void>;

• Notify all life cycle observers by group of init

method invokeObserver

protected invokeObserver: (
    observer: LifeCycleObserver,
    event: keyof LifeCycleObserver
) => Promise<void>;

• Invoke an observer for the given event

  Parameter observer

  A life cycle observer

  Parameter event

  Event name

method notifyGroups

protected notifyGroups: (
    events: (keyof LifeCycleObserver)[],
    groups: LifeCycleObserverGroup[],
    reverse?: boolean
) => Promise<void>;

• Emit events to the observer groups

  Parameter events

  Event names

  Parameter groups

  Observer groups

method notifyObservers

protected notifyObservers: (
    observers: LifeCycleObserver[],
    bindings: Readonly<Binding<LifeCycleObserver>>[],
    event: keyof LifeCycleObserver
) => Promise<void>;

• Notify an observer group of the given event

  Parameter group

  A group of bindings for life cycle observers

  Parameter event

  Event name

method setOrderedGroups

setOrderedGroups: (groups: string[]) => void;

method sortObserverBindingsByGroup

protected sortObserverBindingsByGroup: (
    bindings: Readonly<Binding<LifeCycleObserver>>[]
) => LifeCycleObserverGroup[];

• Sort the life cycle observer bindings so that we can start/stop them in the right order. By default, we can start other observers before servers and stop them in the reverse order

  Parameter bindings

  Life cycle observer bindings

method start

start: () => Promise<void>;

• Notify all life cycle observers by group of start

method stop

stop: () => Promise<void>;

• Notify all life cycle observers by group of stop

property name

name?: string;

• Name of the application context

property shutdown

shutdown?: ShutdownOptions;

• Configuration for signals that shut down the application

index signature

[prop: string]: any;

• Other properties

property description

description: string;

property name

name: string;

property version

version: string;

index signature

[key: string]: Constructor<BoundValue>;

property bindings

bindings?: Binding[];

• An array of bindings to be aded to the application context.

  Example 1

  const bindingX = Binding.bind('x').to('Value X');
  this.bindings = [bindingX]

property classes

classes?: ClassMap;

• A map of classes to be bound to the application context.

  Example 1

  {
    'rest.body-parsers.xml': XmlBodyParser
  }

property components

components?: Constructor<Component>[];

• An array of component classes

property controllers

controllers?: ControllerClass[];

• An array of controller classes

property lifeCycleObservers

lifeCycleObservers?: Constructor<LifeCycleObserver>[];

property providers

providers?: ProviderMap;

• A map of providers to be bound to the application context

  Example 1

  {
    'authentication.strategies.ldap': LdapStrategyProvider
  }

property servers

servers?: {
    [name: string]: Constructor<Server>;
};

• A map of name/class pairs for servers

property services

services?: ServiceOrProviderClass[];

• An array of service or provider classes

index signature

[prop: string]: any;

• Other properties

method init

init: (...injectedArgs: unknown[]) => ValueOrPromise<void>;

• The method to be invoked during init. It will only be called at most once for a given application instance.

method start

start: (...injectedArgs: unknown[]) => ValueOrPromise<void>;

• The method to be invoked during start

method stop

stop: (...injectedArgs: unknown[]) => ValueOrPromise<void>;

• The method to be invoked during stop

index signature

[key: string]: Constructor<Provider<BoundValue>>;

property listening

readonly listening: boolean;

• Tells whether the server is listening for connections or not

property interface

interface?: ServiceInterface;

variable APPLICATION_CONFIG

const APPLICATION_CONFIG: BindingKey<ApplicationConfig>;

• Binding key for application configuration

variable APPLICATION_INSTANCE

const APPLICATION_INSTANCE: BindingKey<Application>;

• Binding key for application instance itself

variable APPLICATION_METADATA

const APPLICATION_METADATA: BindingKey<ApplicationMetadata>;

• Binding key for the content of package.json

variable COMPONENTS

const COMPONENTS: string;

• Binding key for components

variable CONTROLLER_CLASS

const CONTROLLER_CLASS: BindingKey<Constructor<T>>;

• Binding key for the controller class resolved in the current request context

variable CONTROLLER_CURRENT

const CONTROLLER_CURRENT: BindingKey<unknown>;

• Binding key for the controller instance resolved in the current request context

variable CONTROLLER_METHOD_META

const CONTROLLER_METHOD_META: string;

• Binding key for the controller method metadata resolved in the current request context

variable CONTROLLER_METHOD_NAME

const CONTROLLER_METHOD_NAME: BindingKey<string>;

• Binding key for the controller method resolved in the current request context

variable CONTROLLERS

const CONTROLLERS: string;

variable LIFE_CYCLE_OBSERVER_OPTIONS

const LIFE_CYCLE_OBSERVER_OPTIONS: BindingKey<LifeCycleObserverOptions>;

• Binding key for life cycle observer options

variable LIFE_CYCLE_OBSERVER_REGISTRY

const LIFE_CYCLE_OBSERVER_REGISTRY: BindingKey<LifeCycleObserverRegistry>;

• Binding key for life cycle observer options

variable LIFE_CYCLE_OBSERVERS

const LIFE_CYCLE_OBSERVERS: string;

variable SERVERS

const SERVERS: string;

• Binding key for servers

variable COMPONENT

const COMPONENT: string;

• Binding tag for components

variable CONTROLLER

const CONTROLLER: string;

• Binding tag for controllers

variable EXTENSION_FOR

const EXTENSION_FOR: string;

• Binding tag for extensions to specify name of the extension point that an extension contributes to.

variable EXTENSION_POINT

const EXTENSION_POINT: string;

• Binding tag for an extension point to specify name of the extension point

variable LIFE_CYCLE_OBSERVER

const LIFE_CYCLE_OBSERVER: string;

• Binding tag for life cycle observers

variable LIFE_CYCLE_OBSERVER_GROUP

const LIFE_CYCLE_OBSERVER_GROUP: string;

• Binding tag for group name of life cycle observers

variable SERVER

const SERVER: string;

• Binding tag for servers

variable SERVICE

const SERVICE: string;

• Binding tag for services

variable SERVICE_INTERFACE

const SERVICE_INTERFACE: string;

• Binding tag for the service interface

function list

list: (
    extensionPointName?: string,
    metadata?: InjectionMetadata
) => (
    target: Object,
    member: string | undefined,
    methodDescriptorOrParameterIndex?:
        | number
        | TypedPropertyDescriptor<any>
        | undefined
) => void;

• Inject an array of resolved extension instances for the extension point. The list is a snapshot of registered extensions when the injection is fulfilled. Extensions added or removed afterward won't impact the list.

  Parameter extensionPointName

  Name of the extension point. If not supplied, we use the name tag from the extension point binding or the class name of the extension point class. If a class needs to inject extensions from multiple extension points, use different extensionPointName for different types of extensions.

  Parameter metadata

  Optional injection metadata

  Example 1

  import {extensionPoint, extensions} from '@loopback/core';
  
  @extensionPoint(GREETER_EXTENSION_POINT_NAME)
  export class GreetingService {
   constructor(
     @extensions.list() // Inject an array of extensions for the extension point
     private greeters: Greeter[],
     // ...
  ) {
    // ...
  }

function view

view: (
    extensionPointName?: string,
    metadata?: InjectionMetadata
) => (
    target: Object,
    member: string | undefined,
    methodDescriptorOrParameterIndex?:
        | number
        | TypedPropertyDescriptor<any>
        | undefined
) => void;

• Inject a ContextView for extensions of the extension point. The view can then be listened on events such as bind, unbind, or refresh to react on changes of extensions.

  Parameter extensionPointName

  Name of the extension point. If not supplied, we use the name tag from the extension point binding or the class name of the extension point class. If a class needs to inject extensions from multiple extension points, use different extensionPointName for different types of extensions.

  Parameter metadata

  Optional injection metadata

  Example 1

  import {extensionPoint, extensions} from '@loopback/core';
  
  @extensionPoint(GREETER_EXTENSION_POINT_NAME)
  export class GreetingService {
   constructor(
     @extensions.view() // Inject a context view for extensions of the extension point
     private greetersView: ContextView<Greeter>,
     // ...
  ) {
    // ...
  }