Class: application = new Application()

Application is the container for various types of artifacts, such as components, servers, controllers, repositories, datasources, connectors, and models.

Properties
Name Type Default Value Flags Description
options ApplicationConfig constructorProperty exported public optional

Application is the container for various types of artifacts, such as components, servers, controllers, repositories, datasources, connectors, and models.

constructor(options: ApplicationConfig) : Application

Parameters
Name Type Default Value Flags Description
options ApplicationConfig optional

Application is the container for various types of artifacts, such as components, servers, controllers, repositories, datasources, connectors, and models.

component(componentCtor: Constructor<Component>, name: undefined | string) : void

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

Parameters
Name Type Default Value Flags Description
componentCtor Constructor<Component>

The component class to add.
name undefined | string optional

Optional component name, default to the class name


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

app.component(ProductComponent);

controller(controllerCtor: ControllerClass, name: undefined | string) : Binding

Register a controller class with this application.

Returns:

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

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

Parameters
Name Type Default Value Flags Description
controllerCtor ControllerClass

The controller class (constructor function).
name undefined | string optional

Optional controller name, default to the class name

getServer(target: Constructor<T> | String) : Promise<T>

Retrieve the singleton instance for a bound constructor.

Parameters
Name Type Default Value Flags Description
target Constructor<T> | String

Application is the container for various types of artifacts, such as components, servers, controllers, repositories, datasources, connectors, and models.

server(ctor: Constructor<T>, name: undefined | string) : Binding

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.

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".

Returns:

Binding for the server class

Parameters
Name Type Default Value Flags Description
ctor Constructor<T>

Application is the container for various types of artifacts, such as components, servers, controllers, repositories, datasources, connectors, and models.
name undefined | string optional

Optional override for key name.

servers(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.

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";

Returns:

An array of bindings for the registered server classes

Parameters
Name Type Default Value Flags Description
ctors Constructor<T>[]

An array of Server constructors.

start() : Promise<void>

Start the application, and all of its registered servers.

stop() : Promise<void>

Stop the application instance and all of its registered servers.

Interface: ApplicationConfig

Configuration for application

Type alias: ControllerClass = Constructor

Interface: Component

A component declares a set of artifacts so that they cane be contributed to an application as a group

Properties
Name Type Default Value Flags Description
controllers ControllerClass[] exported optional

An array of controller classes
providers ProviderMap exported optional

A map of name/class pairs for binding providers
servers undefined | anonymous exported optional

A map of name/class pairs for servers

Interface: ProviderMap

A map of name/class pairs for binding providers

Function: mountComponent

mountComponent(app: Application, component: Component) : void

Mount a component to an Application.

Parameters
Name Type Default Value Flags Description
app Application

component Component

Namespace: CoreBindings

Namespace for core binding keys

const CoreBindings.APPLICATION_CONFIG = BindingKey.create( 'application.config', )

Binding key for application configuration

const CoreBindings.APPLICATION_INSTANCE = BindingKey.create( 'application.instance', )

Binding key for application instance itself

const CoreBindings.CONTROLLER_CLASS = BindingKey.create( 'controller.current.ctor', )

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

const CoreBindings.CONTROLLER_CURRENT = BindingKey.create('controller.current')

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

const CoreBindings.CONTROLLER_METHOD_META = "controller.method.meta"

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

const CoreBindings.CONTROLLER_METHOD_NAME = BindingKey.create( 'controller.current.operation', )

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

const CoreBindings.SERVERS = "servers"

Binding key for servers

Interface: Server

Defines the requirements to implement a Server for LoopBack applications: start() : Promise stop() : Promise It is recommended that each Server implementation creates its own child Context, which inherits from the parent Application context. This way, any Server-specific bindings will remain local to the Server instance, and will avoid polluting its parent module scope.

start() : Promise<void>

Start the server

stop() : Promise<void>

Stop the server