Find a route matching the incoming request. Throw an error when no route was found.

Invokes a method defined in the Application Controller

OperationRetval Result from method invocation

Log information about a failed request.

Reject the request with an error.

Send the operation response back to the client.

Provides the function for parsing args in requests at runtime.

Provides the function that populates the response object with the results of the operation.

An implementation of the Application class that automatically provides an instance of a REST server. This application class is intended to be a single-server implementation. Any attempt to bind additional servers will throw an error.

Set the OpenAPI specification that defines the REST API schema for this application. All routes, parameter definitions and return types will be defined in this way.

Note that this will override any routes defined via decorators at the controller level (this function takes precedent).

Register a new Controller-based route.

class MyController {
  greet(name: string) {
    return `hello ${name}`;
  }
}
app.route('get', '/greet', operationSpec, MyController, 'greet');

Register a new route.

function greet(name: string) {
 return `hello ${name}`;
}
const route = new Route('get', '/', operationSpec, greet);
app.route(route);

A REST API server for use with Loopback. Add this server to your application by importing the RestComponent.

const app = new MyApplication();
app.component(RestComponent);

To add additional instances of RestServer to your application, use the .server function:

app.server(RestServer, 'nameOfYourServer');

By default, one instance of RestServer will be created when the RestComponent is bootstrapped. This instance can be retrieved with app.getServer(RestServer), or by calling app.get('servers.RestServer') Note that retrieving other instances of RestServer must be done using the server's name:

const server = await app.getServer('foo')
// OR
const server = await app.get('servers.foo');

Set the OpenAPI specification that defines the REST API schema for this server. All routes, parameter definitions and return types will be defined in this way.

Note that this will override any routes defined via decorators at the controller level (this function takes precedent).

Register a controller class with this server.

Get the OpenAPI specification describing the REST API provided by this application.

This method merges operations (HTTP endpoints) from the following sources:

• app.api(spec)
• app.controller(MyController)
• app.route(route)
• app.route('get', '/greet', operationSpec, MyController, 'greet')

Configure a custom sequence function for handling incoming requests.

app.handler((sequence, request, response) => {
  sequence.send(response, 'hello world');
});

Register a new Controller-based route.

class MyController {
  greet(name: string) {
    return `hello ${name}`;
  }
}
app.route('get', '/greet', operationSpec, MyController, 'greet');

Register a new route.

function greet(name: string) {
 return `hello ${name}`;
}
const route = new Route('get', '/', operationSpec, greet);
app.route(route);

Configure a custom sequence class for handling incoming requests.

class MySequence implements SequenceHandler {
  constructor(
    @inject('send) public send: Send)) {
  }

  public async handle(request: ParsedRequest, response: ServerResponse) {
    send(response, 'hello world');
  }
}

Start this REST API's HTTP/HTTPS server.

Stop this REST API's HTTP/HTTPS server.

The object format used for building the template bases of our OpenAPI spec files.

Valid configuration for the RestServer constructor.

Base implementation of RouteEntry

Construct a new route

A route backed by a controller

Construct a controller based route

Routing table

Map a request to a route

Register a controller as the route

Register a route

A route with path parameters resolved

An entry in the routing table

A handler to invoke the resolved controller method

Map an http request to a route

Update bindings for the request context

A factory function to create controller instances synchronously or asynchronously

The default implementation of SequenceHandler.

This class implements default Sequence for the LoopBack framework. Default sequence is used if user hasn't defined their own Sequence for their application.

Sequence constructor() and run() methods are invoked from [[http-handler]] when the API request comes in. User defines APIs in their Application Controller class.

User can bind their own Sequence to app as shown below

app.bind(CoreBindings.SEQUENCE).toClass(MySequence);

Constructor: Injects findRoute, invokeMethod & logError methods as promises.

Runs the default sequence. Given a request and response, running the sequence will produce a response or an error.

Default sequence executes these steps

• Finds the appropriate controller method, swagger spec and args for invocation
• Parses HTTP request to get API argument list
• Invokes the API which is defined in the Application Controller
• Writes the result from API into the HTTP response
• Error is caught and logged using 'logError' if any of the above steps in the sequence fails with an error.

A sequence handler is a class implementing sequence of actions required to handle an incoming request.

Handle the request by running the configured sequence of actions.

A sequence function is a function implementing a custom sequence of actions to handle an incoming request.