Validator class provides a bunch of functions that perform validations on the request parameters and request body.

Return true if the value is empty, return false otherwise.

Check is a parameter required or not.

The validation executed before type coercion. Like checking absence.

RestServer-specific bindings

Request-specific bindings

Binding key for setting and injecting the http request context

Binding key for setting and injecting the http request

Binding key for setting and injecting the http response

Bindings for potential actions that could be used in a sequence

Binding key for setting and injecting a route finding function

Binding key for setting and injecting a controller route invoking function

Binding key for setting and injecting an error logging function

Binding key for setting and injecting a parameter parsing function

Binding key for setting and injecting a bad response writing function

Binding key for setting and injecting a response writing function

Binding key for setting and injecting an OpenAPI spec

Binding key for setting and injecting a wrapper function for setting values on a given context

Binding key for setting and injecting RestComponentConfig

Binding key for setting and injecting Reject action's error handling options.

See https://github.com/strongloop/strong-error-handler#options for the list of available options. Please note that the flag log is not used by @loopback/rest.

Binding key for setting and injecting a wrapper function for retrieving values from a given context

Internal binding key for http-handler

Binding key for setting and injecting the host name of RestServer

Binding key for HTTPS options

Binding key for setting and injecting the port number of RestServer

Binding key for setting and injecting the protocol of RestServer

Binding key for setting and injecting a Sequence

Binding key for setting and injecting the URL of RestServer

Provides the function for parsing args in requests at runtime.

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

A per-request Context combining an IoC container with handler context (request, response, etc.).

An invalid request body error contains a details property as the machine-readable error. Each entry in error.details contains 4 attributes: path, code, info and message. ValidationErrorDetails defines the type of each entry, which is an object. The type of error.details is ValidationErrorDetails[].

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.

Handle incoming HTTP(S) request by invoking the corresponding Controller method via the configured Sequence.

The main REST server instance providing REST API for this application.

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

Mount static assets to the REST server. See https://expressjs.com/en/4x/api.html#express.static

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(({request, response}, sequence) => {
  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({response}: RequestContext) {
    send(response, 'hello world');
  }
}

Start this REST API's HTTP/HTTPS server.

Mount static assets to the REST server. See https://expressjs.com/en/4x/api.html#express.static

Stop this REST API's HTTP/HTTPS server.

The form of OpenAPI specs to be served

Options to customize how OpenAPI specs are served

Options for RestServer configuration

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 handler context (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.

An object holding HTTP request, response and other data needed to handle an incoming HTTP request.

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.