@loopback/rest
- Version 14.0.7
- Published
- 617 kB
- 31 dependencies
- MIT license
Install
npm i @loopback/rest
yarn add @loopback/rest
pnpm add @loopback/rest
Overview
The REST API package for loopback-next.
Remarks
A REST server for LoopBack 4 application instances, complete with:
- new custom routing engine (special thanks to @bajtos)! - tools for defining your application routes - OpenAPI 3.0 spec (openapi.json/openapi.yaml) generation using @loopback/openapi-v3 - a default sequence implementation to manage the request and response lifecycle
Index
Variables
Functions
- assignRouterSpec()
- compareRoute()
- createBodyParserBinding()
- createControllerFactoryForBinding()
- createControllerFactoryForClass()
- createControllerFactoryForInstance()
- createResolvedRoute()
- createRoutesForController()
- getContentType()
- getParserOptions()
- getPathVariables()
- invokeBodyParserMiddleware()
- joinPath()
- normalizeParsingError()
- parseJson()
- parseOperationArgs()
- rebaseOpenApiSpec()
- sanitizeJsonParse()
- toExpressPath()
- validateApiPath()
- validateRequestBody()
- validateValueAgainstSchema()
- writeResultToResponse()
Classes
Interfaces
Type Aliases
- AjvErrorOptions
- AjvFactory
- AjvFormat
- AjvKeyword
- BodyParserFunction
- BodyParserMiddleware
- ControllerClass
- ControllerFactory
- ControllerInstance
- FindRoute
- HttpRequestListener
- InvokeMethod
- LogError
- NodeWithValue
- OperationArgs
- OperationRetval
- ParseParams
- PathParameterValues
- Reject
- RequestBody
- RequestBodyValidationOptions
- RestComponentConfig
- RestRouterOptions
- RestServerConfig
- RestServerOptions
- RestServerResolvedConfig
- RouterSpec
- SchemaValidatorCache
- Send
- SequenceFunction
Namespaces
RestBindings
- AJV_FACTORY
- API_SPEC
- BASE_PATH
- CONFIG
- ERROR_WRITER_OPTIONS
- HANDLER
- HOST
- HTTPS_OPTIONS
- INVOKE_MIDDLEWARE_SERVICE
- OPERATION_SPEC_CURRENT
- PATH
- PORT
- PROTOCOL
- REQUEST_BODY_PARSER
- REQUEST_BODY_PARSER_JSON
- REQUEST_BODY_PARSER_OPTIONS
- REQUEST_BODY_PARSER_RAW
- REQUEST_BODY_PARSER_STREAM
- REQUEST_BODY_PARSER_TEXT
- REQUEST_BODY_PARSER_URLENCODED
- ROUTER
- ROUTER_OPTIONS
- ROUTES
- SEQUENCE
- SERVER
- URL
Variables
variable DEFAULT_LIMIT
const DEFAULT_LIMIT: string;
variable ERR_NO_MULTI_SERVER
const ERR_NO_MULTI_SERVER: string;
variable REQUEST_BODY_PARSER_TAG
const REQUEST_BODY_PARSER_TAG: string;
Binding tag for request body parser extensions
variable SequenceActions
const SequenceActions: typeof RestBindings.SequenceActions;
Functions
function assignRouterSpec
assignRouterSpec: (target: RouterSpec, additions: RouterSpec) => void;
function compareRoute
compareRoute: ( route1: Pick<RouteEntry, 'verb' | 'path'>, route2: Pick<RouteEntry, 'verb' | 'path'>) => number;
Compare two routes by verb/path for sorting
Parameter route1
First route entry
Parameter route2
Second route entry
function createBodyParserBinding
createBodyParserBinding: ( parserClass: Constructor<BodyParser>, key?: BindingAddress<BodyParser>) => Binding<BodyParser>;
Create a binding for the given body parser class
Parameter parserClass
Body parser class
Parameter key
Optional binding address
function createControllerFactoryForBinding
createControllerFactoryForBinding: <T extends object>( key: string) => ControllerFactory<T>;
Create a controller factory function for a given binding key
Parameter key
Binding key
function createControllerFactoryForClass
createControllerFactoryForClass: <T extends object>( controllerCtor: Constructor<T>) => ControllerFactory<T>;
Create a controller factory function for a given class
Parameter controllerCtor
Controller class
function createControllerFactoryForInstance
createControllerFactoryForInstance: <T extends object>( controllerInst: T) => ControllerFactory<T>;
Create a controller factory function for a given instance
Parameter controllerCtor
Controller instance
function createResolvedRoute
createResolvedRoute: ( route: RouteEntry, pathParams: PathParameterValues) => ResolvedRoute;
function createRoutesForController
createRoutesForController: <T extends object>( spec: ControllerSpec, controllerCtor: Constructor<T>, controllerFactory?: ControllerFactory<T>) => ControllerRoute<T>[];
Create routes for a controller with the given spec
Parameter spec
Controller spec
Parameter controllerCtor
Controller class
Parameter controllerFactory
Controller factory
function getContentType
getContentType: (req: Request) => string | undefined;
Get the content-type header value from the request
Parameter req
Http request
function getParserOptions
getParserOptions: { (type: 'json', options: RequestBodyParserOptions): OptionsJson; (type: 'urlencoded', options: RequestBodyParserOptions): OptionsUrlencoded; (type: 'text', options: RequestBodyParserOptions): OptionsText; (type: 'raw', options: RequestBodyParserOptions): Options;};
Extract parser options based on the parser type
Parameter type
json|urlencoded|text
Parameter options
function getPathVariables
getPathVariables: (path: string) => RegExpMatchArray | null;
Get all path variables. For example,
/root/{foo}/bar
=>['foo']
function invokeBodyParserMiddleware
invokeBodyParserMiddleware: ( handle: BodyParserMiddleware, request: Request) => Promise<any>;
Parse the request body asynchronously
Parameter handle
The express middleware handler
Parameter request
Http request
function joinPath
joinPath: (basePath: string, path: string) => string;
function normalizeParsingError
normalizeParsingError: (err: HttpError) => HttpError<number>;
Normalize parsing errors as
4xx
Parameter err
function parseJson
parseJson: ( text: string, reviver?: (key: any, value: any) => any, prohibitedKeys?: string[]) => any;
Parse a json string that rejects prohibited keys
Parameter text
JSON string
Parameter reviver
Optional reviver function for
JSON.parse
Parameter prohibitedKeys
An array of keys to be rejected
function parseOperationArgs
parseOperationArgs: ( request: Request, route: ResolvedRoute, requestBodyParser?: RequestBodyParser, options?: ValidationOptions) => Promise<OperationArgs>;
Parses the request to derive arguments to be passed in for the Application controller method
Parameter request
Incoming HTTP request
Parameter route
Resolved Route
function rebaseOpenApiSpec
rebaseOpenApiSpec: <T extends OpenApiSpec>(spec: T, basePath: string) => T;
function sanitizeJsonParse
sanitizeJsonParse: ( reviver?: (key: any, value: any) => any, prohibitedKeys?: string[]) => (key: string, value: any) => any;
Factory to create a reviver function for
JSON.parse
to sanitize keysParameter reviver
Reviver function
Parameter prohibitedKeys
An array of keys to be rejected
function toExpressPath
toExpressPath: (path: string) => string;
Convert an OpenAPI path to Express (path-to-regexp) style
Parameter path
OpenAPI path with optional variables as
{var}
function validateApiPath
validateApiPath: (path?: string) => string;
Validate the path to be compatible with OpenAPI path template. No parameter modifier, custom pattern, or unnamed parameter is allowed.
function validateRequestBody
validateRequestBody: ( body: RequestBody, requestBodySpec?: RequestBodyObject, globalSchemas?: SchemasObject, options?: ValidationOptions) => Promise<void>;
Check whether the request body is valid according to the provided OpenAPI schema. The JSON schema is generated from the OpenAPI schema which is typically defined by
@requestBody()
. The validation leverages AJV schema validator.Parameter body
The request body parsed from an HTTP request.
Parameter requestBodySpec
The OpenAPI requestBody specification defined in
@requestBody()
.Parameter globalSchemas
The referenced schemas generated from
OpenAPISpec.components.schemas
.Parameter options
Request body validation options for AJV
function validateValueAgainstSchema
validateValueAgainstSchema: ( value: any, schema: SchemaObject | ReferenceObject, globalSchemas?: SchemasObject, options?: ValueValidationOptions) => Promise<any>;
Validate the value against JSON schema.
Parameter value
The data value.
Parameter schema
The JSON schema used to perform the validation.
Parameter globalSchemas
Schema references.
Parameter options
Value validation options.
function writeResultToResponse
writeResultToResponse: (response: Response, result: OperationRetval) => void;
Writes the result from Application controller method into the HTTP response
Parameter response
HTTP Response
Parameter result
Result from the API to write into HTTP Response
Classes
class BaseRoute
abstract class BaseRoute implements RouteEntry {}
Base implementation of RouteEntry
constructor
constructor(verb: string, path: string, spec: OperationObject);
Construct a new route
Parameter verb
http verb
Parameter path
http request path pattern
Parameter spec
OpenAPI operation spec
property path
readonly path: string;
property spec
readonly spec: OperationObject;
property verb
readonly verb: string;
method describe
describe: () => string;
method invokeHandler
abstract invokeHandler: ( requestContext: Context, args: OperationArgs) => Promise<OperationRetval>;
method toString
toString: () => string;
method updateBindings
abstract updateBindings: (requestContext: Context) => void;
class ControllerRoute
class ControllerRoute<T extends object> extends BaseRoute {}
A route backed by a controller
constructor
constructor( verb: string, path: string, spec: OperationObject, controllerCtor: Constructor<T>, controllerFactory?: ControllerFactory<T>, methodName?: string);
Construct a controller based route
Parameter verb
http verb
Parameter path
http request path
Parameter spec
OpenAPI operation spec
Parameter controllerCtor
Controller class
Parameter controllerFactory
A factory function to create a controller instance
Parameter methodName
Controller method name, default to
x-operation-name
method describe
describe: () => string;
method invokeHandler
invokeHandler: ( requestContext: Context, args: OperationArgs) => Promise<OperationRetval>;
method updateBindings
updateBindings: (requestContext: Context) => void;
class DefaultSequence
class DefaultSequence implements SequenceHandler {}
The default implementation of SequenceHandler.
Remarks
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.
Example 1
User can bind their own Sequence to app as shown below
app.bind(CoreBindings.SEQUENCE).toClass(MySequence);
constructor
constructor( findRoute: FindRoute, parseParams: ParseParams, invoke: InvokeMethod, send: Send, reject: Reject);
Constructor: Injects findRoute, invokeMethod & logError methods as promises.
Parameter findRoute
Finds the appropriate controller method, spec and args for invocation (injected via SequenceActions.FIND_ROUTE).
Parameter parseParams
The parameter parsing function (injected via SequenceActions.PARSE_PARAMS).
Parameter invoke
Invokes the method specified by the route (injected via SequenceActions.INVOKE_METHOD).
Parameter send
The action to merge the invoke result with the response (injected via SequenceActions.SEND)
Parameter reject
The action to take if the invoke returns a rejected promise result (injected via SequenceActions.REJECT).
property findRoute
protected findRoute: FindRoute;
property invoke
protected invoke: InvokeMethod;
property invokeMiddleware
protected invokeMiddleware: InvokeMiddleware;
Optional invoker for registered middleware in a chain. To be injected via SequenceActions.INVOKE_MIDDLEWARE.
property parseParams
protected parseParams: ParseParams;
property reject
reject: Reject;
property send
send: Send;
method handle
handle: (context: RequestContext) => Promise<void>;
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 - Executes middleware for CORS, OpenAPI spec endpoints - 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.
Parameter context
The request context: HTTP request and response objects, per-request IoC container and more.
class FindRouteMiddlewareProvider
class FindRouteMiddlewareProvider implements Provider<Middleware> {}
method value
value: () => Middleware;
class FindRouteProvider
class FindRouteProvider {}
method value
static value: (context: Context, handler: HttpHandler) => FindRoute;
class HttpHandler
class HttpHandler {}
constructor
constructor(_rootContext: Context, _serverConfig: any, _routes?: RoutingTable);
property handleRequest
handleRequest: (request: Request, response: Response) => Promise<void>;
method describeApiPaths
describeApiPaths: () => PathObject;
method findRoute
findRoute: (request: Request) => ResolvedRoute;
method getApiComponents
getApiComponents: () => ComponentsObject;
method getApiDefinitions
getApiDefinitions: () => { [schema: string]: any };
Deprecated
Use
getApiComponents
method registerApiComponents
registerApiComponents: (defs: ComponentsObject) => void;
Merge components into the OpenApi spec
Parameter defs
Components
method registerApiDefinitions
registerApiDefinitions: (defs: SchemasObject) => void;
Parameter defs
Schemas
Deprecated
Use
registerApiComponents
method registerController
registerController: <T extends object>( spec: ControllerSpec, controllerCtor: Constructor<T>, controllerFactory?: ControllerFactory<T>) => void;
method registerRoute
registerRoute: (route: RouteEntry) => void;
class InfoSpecEnhancer
class InfoSpecEnhancer implements OASEnhancer {}
An OpenAPI spec enhancer to populate
info
with application metadata (package.json).
constructor
constructor(pkg?: any);
property name
name: string;
property pkg
readonly pkg?: any;
method modifySpec
modifySpec: (spec: OpenApiSpec) => OpenApiSpec;
class InvokeMethodMiddlewareProvider
class InvokeMethodMiddlewareProvider implements Provider<Middleware> {}
method value
value: () => Middleware;
class InvokeMethodProvider
class InvokeMethodProvider {}
method value
static value: (context: Context) => InvokeMethod;
class JsonBodyParser
class JsonBodyParser implements BodyParser {}
constructor
constructor(options?: RequestBodyParserOptions);
property name
name: Symbol;
method parse
parse: (request: Request) => Promise<RequestBody>;
method supports
supports: (mediaType: string) => boolean;
class LogErrorProvider
class LogErrorProvider {}
method value
static value: () => LogError;
class MiddlewareSequence
class MiddlewareSequence implements SequenceHandler {}
A sequence implementation using middleware chains
constructor
constructor( context: Context, invokeMiddleware: InvokeMiddleware, options?: InvokeMiddlewareOptions);
Constructor: Injects
InvokeMiddleware
andInvokeMiddlewareOptions
Parameter invokeMiddleware
invoker for registered middleware in a chain. To be injected via RestBindings.INVOKE_MIDDLEWARE_SERVICE.
property defaultOptions
static defaultOptions: InvokeMiddlewareOptions;
property invokeMiddleware
readonly invokeMiddleware: InvokeMiddleware;
property options
readonly options: InvokeMiddlewareOptions;
method handle
handle: (context: RequestContext) => Promise<void>;
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 groups of middleware:
-
cors
: EnforcesCORS
-openApiSpec
: Serves OpenAPI specs -findRoute
: Finds the appropriate controller method, swagger spec and args for invocation -parseParams
: Parses HTTP request to get API argument list -invokeMethod
: Invokes the API which is defined in the Application controller methodIn front of the groups above, we have a special middleware called
sendResponse
, which first invokes downstream middleware to get a result and handles the result or error respectively.- Writes the result from API into the HTTP response (if the HTTP response has not been produced yet by the middleware chain. - Catches error logs it using 'logError' if any of the above steps in the sequence fails with an error.
Parameter context
The request context: HTTP request and response objects, per-request IoC container and more.
class ParseParamsMiddlewareProvider
class ParseParamsMiddlewareProvider implements Provider<Middleware> {}
method value
value: () => Middleware;
class ParseParamsProvider
class ParseParamsProvider {}
Provides the function for parsing args in requests at runtime.
Returns
The handler function that will parse request args.
method value
static value: ( requestBodyParser: RequestBodyParser, validationOptions: ValidationOptions | undefined, ajvFactory: AjvFactory) => ParseParams;
class RawBodyParser
class RawBodyParser implements BodyParser {}
Parsing the request body into Buffer
constructor
constructor(options?: RequestBodyParserOptions);
property name
name: Symbol;
method parse
parse: (request: Request) => Promise<RequestBody>;
method supports
supports: (mediaType: string) => boolean;
class RedirectRoute
class RedirectRoute implements RouteEntry, ResolvedRoute {}
constructor
constructor(sourcePath: string, targetLocation: string, statusCode?: number);
property path
readonly path: string;
property pathParams
readonly pathParams: PathParameterValues;
property schemas
readonly schemas: SchemasObject;
property sourcePath
readonly sourcePath: string;
property spec
readonly spec: OperationObject;
property statusCode
readonly statusCode: number;
property targetLocation
readonly targetLocation: string;
property verb
readonly verb: string;
method describe
describe: () => string;
method invokeHandler
invokeHandler: ( { response }: RequestContext, args: OperationArgs) => Promise<OperationRetval>;
method isRedirectRoute
static isRedirectRoute: (obj: any) => obj is RedirectRoute;
type guard type checker for this class
Parameter obj
method updateBindings
updateBindings: (requestContext: RequestContext) => void;
class RegExpRouter
class RegExpRouter extends BaseRouter {}
Router implementation based on regexp matching
constructor
constructor(options?: RestRouterOptions);
method addRouteWithPathVars
protected addRouteWithPathVars: (route: RouteEntry) => void;
method findRouteWithPathVars
protected findRouteWithPathVars: ( verb: string, path: string) => ResolvedRoute | undefined;
method listRoutesWithPathVars
protected listRoutesWithPathVars: () => RegExpRouteEntry[];
class RejectProvider
class RejectProvider {}
method value
static value: ( logError: LogError, errorWriterOptions?: ErrorWriterOptions) => Reject;
class RequestBodyParser
class RequestBodyParser {}
constructor
constructor(parsers?: BodyParser[], ctx?: any);
property parsers
readonly parsers: BodyParser[];
method loadRequestBodyIfNeeded
loadRequestBodyIfNeeded: ( operationSpec: OperationObject, request: Request) => Promise<RequestBody>;
class RequestContext
class RequestContext extends MiddlewareContext implements HandlerContext {}
A per-request Context combining an IoC container with handler context (request, response, etc.).
constructor
constructor( request: Request, response: Response, parent: Context, serverConfig: any, name?: string);
property basePath
readonly basePath: string;
Get the effective base path of the incoming request. This base path combines
baseUrl
provided by Express when LB4 handler is mounted on a non-root path, with thebasePath
value configured at LB4 side.
property request
readonly request: Request;
property requestedBaseUrl
readonly requestedBaseUrl: string;
Get the base URL used by the client to make the request. This URL contains the protocol, hostname, port and base path. The path of the invoked route and query string is not included.
Please note these values may be different from what we are observing at HTTP/TCP level, because reverse proxies like nginx are rewriting them.
property requestedProtocol
readonly requestedProtocol: string;
Get the protocol used by the client to make the request. Please note this protocol may be different from what we are observing at HTTP/TCP level, because reverse proxies like nginx or sidecars like Envoy are switching between protocols.
property response
readonly response: Response;
property serverConfig
readonly serverConfig: any;
method setupBindings
protected setupBindings: () => void;
class RestApplication
class RestApplication extends Application implements HttpServerLike {}
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.
constructor
constructor(parent: Context);
Create a REST application with the given parent context
Parameter parent
Parent context
constructor
constructor(config?: ApplicationConfig, parent?: Context);
Create a REST application with the given configuration and parent context
Parameter config
Application configuration
Parameter parent
Parent context
property requestHandler
readonly requestHandler: HttpRequestListener;
Handle incoming HTTP(S) request by invoking the corresponding Controller method via the configured Sequence.
Parameter req
The request.
Parameter res
The response.
Example 1
const app = new RestApplication();// setup controllers, etc.const server = http.createServer(app.requestHandler);server.listen(3000);
property restServer
readonly restServer: RestServer;
The main REST server instance providing REST API for this application.
method api
api: (spec: OpenApiSpec) => Binding;
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).
Parameter spec
The OpenAPI specification, as an object.
Returns
Binding for the api spec
method basePath
basePath: (path?: string) => void;
Configure the
basePath
for the rest serverParameter path
Base path
method bodyParser
bodyParser: ( bodyParserClass: Constructor<BodyParser>, address?: BindingAddress<BodyParser>) => Binding<BodyParser>;
Bind a body parser to the server context
Parameter parserClass
Body parser class
Parameter address
Optional binding address
method exportOpenApiSpec
exportOpenApiSpec: ( outFile?: string, log?: (message?: any, ...optionalParams: any[]) => void) => Promise<void>;
Export the OpenAPI spec to the given json or yaml file
Parameter outFile
File name for the spec. The extension of the file determines the format of the file. -
yaml
oryml
: YAML -json
or other: JSON If the outFile is not provided or its value is''
or'-'
, the spec is written to the console using thelog
function.Parameter log
Log function, default to
console.log
method expressMiddleware
expressMiddleware: { ( key: BindingAddress, middleware: ExpressRequestHandler | ExpressRequestHandler[], options?: MiddlewareBindingOptions ): Binding<Middleware>; <CFG>( middlewareFactory: ExpressMiddlewareFactory<CFG>, middlewareConfig?: CFG, options?: MiddlewareBindingOptions ): Binding<Middleware>;};
Bind an Express middleware to this server context
Parameter key
Middleware binding key
Parameter middleware
Express middleware handler function(s)
Example 1
import myExpressMiddlewareFactory from 'my-express-middleware';const myExpressMiddlewareConfig= {};const myExpressMiddleware = myExpressMiddlewareFactory(myExpressMiddlewareConfig);server.expressMiddleware('middleware.express.my', myExpressMiddleware);Bind an Express middleware to this server context
Parameter middlewareFactory
Middleware module name or factory function
Parameter middlewareConfig
Middleware config
Parameter options
Options for registration
Example 1
import myExpressMiddlewareFactory from 'my-express-middleware';const myExpressMiddlewareConfig= {};server.expressMiddleware(myExpressMiddlewareFactory, myExpressMiddlewareConfig);
method handler
handler: (handlerFn: SequenceFunction) => void;
method middleware
middleware: ( middleware: Middleware | Constructor<Provider<Middleware>>, options?: MiddlewareBindingOptions) => Binding<Middleware>;
Register a middleware function or provider class
Parameter middleware
Middleware function or provider class
Parameter options
Middleware binding options
Example 1
const log: Middleware = async (requestCtx, next) {// ...}server.middleware(log);
method mountExpressRouter
mountExpressRouter: ( basePath: string, router: ExpressRequestHandler, spec?: RouterSpec) => void;
Mount an Express router to expose additional REST endpoints handled via legacy Express-based stack.
Parameter basePath
Path where to mount the router at, e.g.
/
or/api
.Parameter router
The Express router to handle the requests.
Parameter spec
A partial OpenAPI spec describing endpoints provided by the router. LoopBack will prepend
basePath
to all endpoints automatically. This argument is optional. You can leave it out if you don't want to document the routes.
method redirect
redirect: ( fromPath: string, toPathOrUrl: string, statusCode?: number) => Binding;
Register a route redirecting callers to a different URL.
Parameter fromPath
URL path of the redirect endpoint
Parameter toPathOrUrl
Location (URL path or full URL) where to redirect to. If your server is configured with a custom
basePath
, then the base path is prepended to the target location.Parameter statusCode
HTTP status code to respond with, defaults to 303 (See Other).
Example 1
app.redirect('/explorer', '/explorer/');
method route
route: { <T extends object>( verb: string, path: string, spec: OperationObject, controllerCtor: Constructor<T>, controllerFactory: ControllerFactory<T>, methodName: string ): Binding; ( verb: string, path: string, spec: OperationObject, handler: Function ): Binding; (route: RouteEntry): Binding; ( verb: string, path: string, spec: OperationObject, handler: Function ): Binding;};
Register a new Controller-based route.
Parameter verb
HTTP verb of the endpoint
Parameter path
URL path of the endpoint
Parameter spec
The OpenAPI spec describing the endpoint (operation)
Parameter controllerCtor
Controller constructor
Parameter controllerFactory
A factory function to create controller instance
Parameter methodName
The name of the controller method
Example 1
class MyController {greet(name: string) {return `hello ${name}`;}}app.route('get', '/greet', operationSpec, MyController, 'greet');Register a new route invoking a handler function.
Parameter verb
HTTP verb of the endpoint
Parameter path
URL path of the endpoint
Parameter spec
The OpenAPI spec describing the endpoint (operation)
Parameter handler
The function to invoke with the request parameters described in the spec.
Example 1
function greet(name: string) {return `hello ${name}`;}app.route('get', '/', operationSpec, greet);Register a new route.
Parameter route
The route to add.
Example 1
function greet(name: string) {return `hello ${name}`;}const route = new Route('get', '/', operationSpec, greet);app.route(route);Register a new route.
Example 1
function greet(name: string) {return `hello ${name}`;}app.route('get', '/', operationSpec, greet);
method sequence
sequence: (sequence: Constructor<SequenceHandler>) => Binding;
method server
server: (server: Constructor<Server>, name?: string) => Binding;
method static
static: ( path: PathParams, rootDir: string, options?: ServeStaticOptions) => void;
Mount static assets to the REST server. See https://expressjs.com/en/4x/api.html#express.static
Parameter path
The path(s) to serve the asset. See examples at https://expressjs.com/en/4x/api.html#path-examples To avoid performance penalty,
/
is not allowed for now.Parameter rootDir
The root directory from which to serve static assets
Parameter options
Options for serve-static
class RestComponent
class RestComponent implements Component {}
constructor
constructor(app: Application, config?: any);
property bindings
bindings: Binding[];
Add built-in body parsers
property providers
providers: ProviderMap;
property servers
servers: { [name: string]: Constructor<Server> };
class RestServer
class RestServer extends BaseMiddlewareRegistry implements Server, HttpServerLike {}
A REST API server for use with Loopback. Add this server to your application by importing the RestComponent.
Example 1
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 callingapp.get('servers.RestServer')
Note that retrieving other instances of RestServer must be done using the server's name:const server = await app.getServer('foo')// ORconst server = await app.get('servers.foo');
constructor
constructor(app: Application, config?: any);
Creates an instance of RestServer.
Parameter app
The application instance (injected via CoreBindings.APPLICATION_INSTANCE).
Parameter config
The configuration options (injected via RestBindings.CONFIG).
property config
readonly config: any;
property httpHandler
readonly httpHandler: HttpHandler;
property httpServer
readonly httpServer: any;
property listening
readonly listening: boolean;
property OASEnhancer
readonly OASEnhancer: OASEnhancerService;
property oasEnhancerService
protected oasEnhancerService: OASEnhancerService;
Handle incoming HTTP(S) request by invoking the corresponding Controller method via the configured Sequence.
Parameter req
The request.
Parameter res
The response.
Example 1
const app = new Application();app.component(RestComponent);// setup controllers, etc.const restServer = await app.getServer(RestServer);const httpServer = http.createServer(restServer.requestHandler);httpServer.listen(3000);
property requestHandler
readonly requestHandler: HttpRequestListener;
property rootUrl
readonly rootUrl: string;
The root url for the server without the basePath. For example, the value will be 'http://localhost:3000' regardless of the
basePath
.
property url
readonly url: string;
The base url for the server, including the basePath if set. For example, the value will be 'http://localhost:3000/api' if
basePath
is set to '/api'.
method addOpenApiSpecEndpoint
addOpenApiSpecEndpoint: ( path: string, form: OpenApiSpecForm, router?: express.Router) => void;
Add a new non-controller endpoint hosting a form of the OpenAPI spec.
Parameter path
Path at which to host the copy of the OpenAPI
Parameter form
Form that should be rendered from that path
method api
api: (spec: OpenApiSpec) => Binding;
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).
Parameter spec
The OpenAPI specification, as an object.
Returns
Binding for the spec
method basePath
basePath: (path?: string) => void;
Configure the
basePath
for the rest serverParameter path
Base path
method bodyParser
bodyParser: ( bodyParserClass: Constructor<BodyParser>, address?: BindingAddress<BodyParser>) => Binding<BodyParser>;
Bind a body parser to the server context
Parameter parserClass
Body parser class
Parameter address
Optional binding address
method controller
controller: (controllerCtor: Constructor<T>) => Binding;
Register a controller class with this server.
Parameter controllerCtor
The controller class (constructor function).
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 exportOpenApiSpec
exportOpenApiSpec: ( outFile?: string, log?: (message?: any, ...optionalParams: any[]) => void) => Promise<void>;
Export the OpenAPI spec to the given json or yaml file
Parameter outFile
File name for the spec. The extension of the file determines the format of the file. -
yaml
oryml
: YAML -json
or other: JSON If the outFile is not provided or its value is''
or'-'
, the spec is written to the console using thelog
function.Parameter log
Log function, default to
console.log
method getApiSpec
getApiSpec: (requestContext?: RequestContext) => Promise<OpenApiSpec>;
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')
If the optional
requestContext
is provided, then theservers
list in the returned spec will be updated to work in that context. Specifically: 1. ifconfig.openApi.setServersFromRequest
is enabled, the servers list will be replaced with the context base url 2. Anyservers
entries with a path of/
will have that path replaced withrequestContext.basePath
Parameter requestContext
Optional context to update the
servers
list in the returned spec
method handler
handler: (handlerFn: SequenceFunction) => void;
Configure a custom sequence function for handling incoming requests.
Parameter handlerFn
The handler to invoke for each incoming request.
Example 1
app.handler(({request, response}, sequence) => {sequence.send(response, 'hello world');});
method mountExpressRouter
mountExpressRouter: ( basePath: string, router: ExpressRequestHandler, spec?: RouterSpec) => void;
Mount an Express router to expose additional REST endpoints handled via legacy Express-based stack.
Parameter basePath
Path where to mount the router at, e.g.
/
or/api
.Parameter router
The Express router to handle the requests.
Parameter spec
A partial OpenAPI spec describing endpoints provided by the router. LoopBack will prepend
basePath
to all endpoints automatically. This argument is optional. You can leave it out if you don't want to document the routes.
method redirect
redirect: ( fromPath: string, toPathOrUrl: string, statusCode?: number) => Binding;
Register a route redirecting callers to a different URL.
Parameter fromPath
URL path of the redirect endpoint
Parameter toPathOrUrl
Location (URL path or full URL) where to redirect to. If your server is configured with a custom
basePath
, then the base path is prepended to the target location.Parameter statusCode
HTTP status code to respond with, defaults to 303 (See Other).
Example 1
server.redirect('/explorer', '/explorer/');
method route
route: { <I extends object>( verb: string, path: string, spec: OperationObject, controllerCtor: Constructor<T>, controllerFactory: ControllerFactory<I>, methodName: string ): Binding; ( verb: string, path: string, spec: OperationObject, handler: Function ): Binding; (route: RouteEntry): Binding;};
Register a new Controller-based route.
Parameter verb
HTTP verb of the endpoint
Parameter path
URL path of the endpoint
Parameter spec
The OpenAPI spec describing the endpoint (operation)
Parameter controllerCtor
Controller constructor
Parameter controllerFactory
A factory function to create controller instance
Parameter methodName
The name of the controller method
Example 1
class MyController {greet(name: string) {return `hello ${name}`;}}app.route('get', '/greet', operationSpec, MyController, 'greet');Register a new route invoking a handler function.
Parameter verb
HTTP verb of the endpoint
Parameter path
URL path of the endpoint
Parameter spec
The OpenAPI spec describing the endpoint (operation)
Parameter handler
The function to invoke with the request parameters described in the spec.
Example 1
function greet(name: string) {return `hello ${name}`;}app.route('get', '/', operationSpec, greet);Register a new generic route.
Parameter route
The route to add.
Example 1
function greet(name: string) {return `hello ${name}`;}const route = new Route('get', '/', operationSpec, greet);app.route(route);
method sequence
sequence: ( sequenceClass: Constructor<SequenceHandler>) => Binding<SequenceHandler>;
Configure a custom sequence class for handling incoming requests.
Parameter sequenceClass
The sequence class to invoke for each incoming request.
Example 1
class MySequence implements SequenceHandler {constructor(@inject('send) public send: Send)) {}public async handle({response}: RequestContext) {send(response, 'hello world');}}
method start
start: () => Promise<void>;
Start this REST API's HTTP/HTTPS server.
method static
static: ( path: PathParams, rootDir: string, options?: ServeStaticOptions) => void;
Mount static assets to the REST server. See https://expressjs.com/en/4x/api.html#express.static
Parameter path
The path(s) to serve the asset. See examples at https://expressjs.com/en/4x/api.html#path-examples
Parameter rootDir
The root directory from which to serve static assets
Parameter options
Options for serve-static
method stop
stop: () => Promise<void>;
Stop this REST API's HTTP/HTTPS server.
class Route
class Route extends BaseRoute {}
constructor
constructor( verb: string, path: string, spec: OperationObject, _handler: Function);
property spec
readonly spec: OperationObject;
method describe
describe: () => string;
method invokeHandler
invokeHandler: ( requestContext: Context, args: OperationArgs) => Promise<OperationRetval>;
method updateBindings
updateBindings: (requestContext: Context) => void;
class RouteSource
class RouteSource implements InvocationSource<RouteEntry> {}
constructor
constructor(value: RouteEntry);
property type
type: string;
property value
readonly value: RouteEntry;
method toString
toString: () => string;
class RoutingTable
class RoutingTable {}
Routing table
constructor
constructor(_router?: RestRouter, _externalRoutes?: ExternalExpressRoutes);
method describeApiPaths
describeApiPaths: () => PathObject;
method find
find: (request: Request) => ResolvedRoute;
Map a request to a route
Parameter request
method registerController
registerController: <T extends object>( spec: ControllerSpec, controllerCtor: Constructor<T>, controllerFactory?: ControllerFactory<T>) => void;
Register a controller as the route
Parameter spec
Parameter controllerCtor
Parameter controllerFactory
method registerRoute
registerRoute: (route: RouteEntry) => void;
Register a route
Parameter route
A route entry
class SendProvider
class SendProvider {}
Provides the function that populates the response object with the results of the operation.
Returns
The handler function that will populate the response with operation results.
method value
static value: () => typeof writeResultToResponse;
class SendResponseMiddlewareProvider
class SendResponseMiddlewareProvider implements Provider<Middleware> {}
method value
value: () => Middleware;
class StreamBodyParser
class StreamBodyParser implements BodyParser {}
A special body parser to retain request stream as is. It will be used by explicitly setting
x-parser
to'stream'
in the request body spec.
class TextBodyParser
class TextBodyParser implements BodyParser {}
constructor
constructor(options?: RequestBodyParserOptions);
property name
name: Symbol;
method parse
parse: (request: Request) => Promise<RequestBody>;
method supports
supports: (mediaType: string) => boolean;
class Trie
class Trie<T> {}
An implementation of trie for routes. The key hierarchy is built with parts of the route path delimited by
/
property root
readonly root: Node<T>;
method create
create: (routeTemplate: string, value: T) => Node<T>;
Create a node for a given path template
Parameter pathTemplate
The path template,
Parameter value
Value of the route
method list
list: () => NodeWithValue<T>[];
List all nodes with value of the trie
method match
match: ( path: string) => (ResolvedNode<T> & { node: NodeWithValue<T> }) | undefined;
Match a route path against the trie
Parameter path
The route path, such as
/customers/c01
class TrieRouter
class TrieRouter extends BaseRouter {}
Router implementation based on trie
constructor
constructor(options?: RestRouterOptions);
method addRouteWithPathVars
protected addRouteWithPathVars: (route: RouteEntry) => void;
method findRouteWithPathVars
protected findRouteWithPathVars: ( verb: string, path: string) => ResolvedRoute | undefined;
method listRoutesWithPathVars
protected listRoutesWithPathVars: () => RouteEntry[];
class UrlEncodedBodyParser
class UrlEncodedBodyParser implements BodyParser {}
constructor
constructor(options?: RequestBodyParserOptions);
property name
name: Symbol;
method parse
parse: (request: Request) => Promise<RequestBody>;
method supports
supports: (mediaType: string) => boolean;
Interfaces
interface ApiExplorerOptions
interface ApiExplorerOptions {}
property disabled
disabled?: true;
Set this flag to disable the built-in redirect to externally hosted API Explorer UI.
property httpUrl
httpUrl?: string;
URL for the API explorer served over
http
protocol to deal with mixed content security imposed by browsers as the spec is exposed overhttp
by default. See https://github.com/loopbackio/loopback-next/issues/1603
property url
url?: string;
URL for the hosted API explorer UI default to https://loopback.io/api-explorer
interface BodyParser
interface BodyParser {}
Interface to be implemented by body parser extensions
interface HttpServerLike
interface HttpServerLike {}
property requestHandler
requestHandler: HttpRequestListener;
interface Node
interface Node<T> {}
A Node in the trie
property children
readonly children: { [key: string]: Node<T>;};
Children of the node
property key
key: string;
Key of the node
property names
names?: string[];
Names of the node if it contains named parameters
property regexp
regexp?: RegExp;
Regular expression for the template
property value
value?: T;
Value of the node
interface OpenApiSpecForm
interface OpenApiSpecForm {}
The form of OpenAPI specs to be served
interface OpenApiSpecOptions
interface OpenApiSpecOptions {}
Options to customize how OpenAPI specs are served
property consolidate
consolidate?: boolean;
Set this flag to
false
to disable OAS schema consolidation. If not set, the value defaults totrue
.
property disabled
disabled?: true;
Set this flag to disable the endpoint for OpenAPI spec
property endpointMapping
endpointMapping?: { [key: string]: OpenApiSpecForm;};
Mapping of urls to spec forms, by default: { '/openapi.json': {version: '3.0.0', format: 'json'}, '/openapi.yaml': {version: '3.0.0', format: 'yaml'}, }
property servers
servers?: ServerObject[];
Configure servers for OpenAPI spec
property setServersFromRequest
setServersFromRequest?: boolean;
A flag to force
servers
to be set from the http request for the OpenAPI spec
interface RequestBodyParserOptions
interface RequestBodyParserOptions extends Options {}
Options for request body parsing See https://github.com/expressjs/body-parser/#options
Built-in parsers retrieve their own options from the request body parser options. The parser specific properties override common ones.
property json
json?: OptionsJson;
Options for json parser
property raw
raw?: Options;
Options for raw parser
property text
text?: OptionsText;
Options for text parser
property urlencoded
urlencoded?: OptionsUrlencoded;
Options for urlencoded parser
property validation
validation?: ValidationOptions;
Validation options for AJV, see https://github.com/epoberezkin/ajv#options This setting is global for all request body parsers and it cannot be overridden inside parser specific properties such as
json
ortext
.
index signature
[name: string]: unknown;
Common options for all parsers
interface RequestWithSession
interface RequestWithSession extends Request {}
extending express request type with a session field
property session
session: Session;
interface ResolvedNode
interface ResolvedNode<T> {}
interface ResolvedRoute
interface ResolvedRoute extends RouteEntry {}
A route with path parameters resolved
property pathParams
readonly pathParams: PathParameterValues;
property schemas
readonly schemas: SchemasObject;
Server/application wide schemas shared by multiple routes, e.g. model schemas. This is a temporary workaround for missing support for $ref references, see https://github.com/loopbackio/loopback-next/issues/435
interface RestRouter
interface RestRouter {}
method add
add: (route: RouteEntry) => void;
Add a route to the router
Parameter route
A route entry
method find
find: (request: Request) => ResolvedRoute | undefined;
Find a matching route for the given http request
Parameter request
Http request
Returns
The resolved route, if not found,
undefined
is returned
method list
list: () => RouteEntry[];
List all routes
interface RestServerResolvedOptions
interface RestServerResolvedOptions {}
property apiExplorer
apiExplorer: ApiExplorerOptions;
property basePath
basePath?: string;
Base path for API/static routes
property cors
cors: cors.CorsOptions;
property expressSettings
expressSettings: { [name: string]: any;};
property listenOnStart
listenOnStart?: boolean;
Set this flag to
false
to not listen on connections when the REST server is started. It's useful to mount a LoopBack REST server as a route to the facade Express application. If not set, the value is default totrue
.
property openApiSpec
openApiSpec: OpenApiSpecOptions;
property path
path?: string;
property port
port: number;
property requestBodyParser
requestBodyParser?: RequestBodyParserOptions;
property router
router: RestRouterOptions;
property sequence
sequence?: Constructor<SequenceHandler>;
interface RouteEntry
interface RouteEntry {}
An entry in the routing table
property path
readonly path: string;
http path
property spec
readonly spec: OperationObject;
OpenAPI operation spec
property verb
readonly verb: string;
http verb
method describe
describe: () => string;
method invokeHandler
invokeHandler: ( requestContext: Context, args: OperationArgs) => Promise<OperationRetval>;
A handler to invoke the resolved controller method
Parameter requestContext
Parameter args
method updateBindings
updateBindings: (requestContext: Context) => void;
Update bindings for the request context
Parameter requestContext
interface SequenceHandler
interface SequenceHandler {}
A sequence handler is a class implementing sequence of actions required to handle an incoming request.
method handle
handle: (context: RequestContext) => Promise<void>;
Handle the request by running the configured sequence of actions.
Parameter context
The request context: HTTP request and response objects, per-request IoC container and more.
interface Session
interface Session {}
interface to set variables in user session
property profile
profile: SessionUserProfile;
index signature
[key: string]: any;
interface SessionUserProfile
interface SessionUserProfile {}
user profile to add in session
property email
email: string;
property provider
provider: string;
property token
token: string;
index signature
[attribute: string]: any;
interface ValidationOptions
interface ValidationOptions extends AjvOptions {}
Options for request body validation using AJV
property ajvErrors
ajvErrors?: AjvErrorOptions;
Enable custom error messages in JSON-Schema for AJV validator from https://github.com/epoberezkin/ajv-errors -
true
: Enableajv-errors
-AjvErrorOptions
: Enableajv-errors
with options
property ajvErrorTransformer
ajvErrorTransformer?: (errors: ErrorObject[]) => ErrorObject[];
A function that transform the
ErrorObject
s reported by AJV. This could be used for error messages customization, localization, etc.
property ajvFactory
ajvFactory?: (options: AjvOptions) => Ajv;
A factory to create Ajv instance
property ajvKeywords
ajvKeywords?: string[];
Enable additional AJV keywords from https://github.com/epoberezkin/ajv-keywords -
string[]
: Add an array of keywords fromajv-keywords
property compiledSchemaCache
compiledSchemaCache?: SchemaValidatorCache;
Custom cache for compiled schemas by AJV. This setting makes it possible to skip the default cache.
property prohibitedKeys
prohibitedKeys?: string[];
An array of keys to be rejected, such as
__proto__
.
interface ValueValidationOptions
interface ValueValidationOptions extends ValidationOptions {}
Options for any value validation using AJV
Type Aliases
type AjvErrorOptions
type AjvErrorOptions = ErrorMessageOptions;
Options for AJV errors
type AjvFactory
type AjvFactory = (options?: AjvOptions) => Ajv;
Factory function for Ajv instances
type AjvFormat
type AjvFormat<T extends string | number = string> = FormatDefinition<T> & { name: string;};
Ajv format definition with a name
type AjvKeyword
type AjvKeyword = KeywordDefinition;
Ajv keyword definition with a name
type BodyParserFunction
type BodyParserFunction = (request: Request) => Promise<RequestBody>;
Plain function for body parsing
type BodyParserMiddleware
type BodyParserMiddleware = ( request: Request, response: Response, next: (err: HttpError) => void) => void;
Express body parser function type
type ControllerClass
type ControllerClass<T extends ControllerInstance> = Constructor<T>;
Controller class
type ControllerFactory
type ControllerFactory<T extends ControllerInstance> = ( ctx: Context) => ValueOrPromise<T>;
A factory function to create controller instances synchronously or asynchronously
type ControllerInstance
type ControllerInstance = { [name: string]: any;} & object;
type FindRoute
type FindRoute = (request: Request) => ResolvedRoute;
Find a route matching the incoming request. Throw an error when no route was found.
type HttpRequestListener
type HttpRequestListener = (req: IncomingMessage, res: ServerResponse) => void;
type InvokeMethod
type InvokeMethod = ( route: RouteEntry, args: OperationArgs) => Promise<OperationRetval>;
Invokes a method defined in the Application Controller
Parameter controller
Name of end-user's application controller class which defines the methods.
Parameter method
Method name in application controller class
Parameter args
Operation arguments for the method
Returns
OperationRetval Result from method invocation
type LogError
type LogError = (err: Error, statusCode: number, request: Request) => void;
Log information about a failed request.
Parameter err
The error reported by request handling code.
Parameter statusCode
Status code of the HTTP response
Parameter request
The request that failed.
type NodeWithValue
type NodeWithValue<T> = Node<T> & { value: T;};
type OperationArgs
type OperationArgs = any[];
type OperationRetval
type OperationRetval = any;
Return value of a controller method (a function implementing an operation). This is a type alias for "any", used to distinguish operation results from other "any" typed values.
type ParseParams
type ParseParams = ( request: Request, route: ResolvedRoute) => Promise<OperationArgs>;
A function to parse OpenAPI operation parameters for a given route
type PathParameterValues
type PathParameterValues = { [key: string]: any;};
type Reject
type Reject = (handlerContext: HandlerContext, err: Error) => void;
Reject the request with an error.
Parameter handlerContext
The context object holding HTTP request, response and other data needed to handle an incoming HTTP request.
Parameter err
The error.
type RequestBody
type RequestBody = { /** * Parsed value of the request body */ value: any | undefined; /** * Is coercion required? Some forms of request such as urlencoded don't * have rich types such as number or boolean. */ coercionRequired?: boolean; /** * Resolved media type */ mediaType?: string; /** * Corresponding schema for the request body */ schema?: SchemaObject | ReferenceObject;};
Request body with metadata
type RequestBodyValidationOptions
type RequestBodyValidationOptions = ValidationOptions;
type RestComponentConfig
type RestComponentConfig = RestServerConfig;
type RestRouterOptions
type RestRouterOptions = { /** * When `true` it uses trailing slash to match. (default: `false`) * * 1. `strict` is true: * - request `/orders` matches route `/orders` but not `/orders/` * - request `/orders/` matches route `/orders/` but not `/orders` * * 2. `strict` is false (default) * - request `/orders` matches route `/orders` first and falls back to `/orders/` * - request `/orders/` matches route `/orders/` first and falls back to `/orders` * * See `strict routing` at http://expressjs.com/en/4x/api.html#app */ strict?: boolean;};
type RestServerConfig
type RestServerConfig = RestServerOptions & HttpServerOptions;
Valid configuration for the RestServer constructor.
type RestServerOptions
type RestServerOptions = Partial<RestServerResolvedOptions>;
RestServer options
type RestServerResolvedConfig
type RestServerResolvedConfig = RestServerResolvedOptions & HttpServerOptions;
type RouterSpec
type RouterSpec = Pick<OpenApiSpec, 'paths' | 'components' | 'tags'>;
type SchemaValidatorCache
type SchemaValidatorCache = WeakMap< SchemaObject | ReferenceObject, // First keyed by schema object Map<string, ValidateFunction>>;
Cache for AJV schema validators
type Send
type Send = (response: Response, result: OperationRetval) => void;
Send the operation response back to the client.
Parameter response
The response the response to send to.
Parameter result
The operation result to send.
type SequenceFunction
type SequenceFunction = ( context: RequestContext, sequence: DefaultSequence) => ValueOrPromise<void>;
A sequence function is a function implementing a custom sequence of actions to handle an incoming request.
Namespaces
namespace builtinParsers
namespace builtinParsers {}
namespace RestBindings
namespace RestBindings {}
RestServer-specific bindings
variable AJV_FACTORY
const AJV_FACTORY: BindingKey<AjvFactory>;
Binding key for AJV
variable API_SPEC
const API_SPEC: BindingKey<OpenApiSpec>;
Binding key for setting and injecting an OpenAPI spec
variable BASE_PATH
const BASE_PATH: BindingKey<string>;
Internal binding key for basePath
variable CONFIG
const CONFIG: BindingKey<any>;
Binding key for setting and injecting RestComponentConfig
variable ERROR_WRITER_OPTIONS
const ERROR_WRITER_OPTIONS: BindingKey<ErrorWriterOptions>;
Binding key for setting and injecting Reject action's error handling options.
See https://github.com/loopbackio/strong-error-handler#options for the list of available options. Please note that the flag
log
is not used by@loopback/rest
.
variable HANDLER
const HANDLER: BindingKey<HttpHandler>;
Internal binding key for http-handler
variable HOST
const HOST: BindingKey<string>;
Binding key for setting and injecting the host name of RestServer
variable HTTPS_OPTIONS
const HTTPS_OPTIONS: BindingKey<https.ServerOptions<any, any>>;
Binding key for HTTPS options
variable INVOKE_MIDDLEWARE_SERVICE
const INVOKE_MIDDLEWARE_SERVICE: BindingKey<InvokeMiddleware>;
Binding key for setting and injecting a
invokeMiddleware
function for middleware based sequence
variable OPERATION_SPEC_CURRENT
const OPERATION_SPEC_CURRENT: BindingKey<OperationObject>;
Binding key for setting and injecting an OpenAPI operation spec
variable PATH
const PATH: BindingKey<string>;
Binding key for setting and injecting the socket path of the RestServer
variable PORT
const PORT: BindingKey<number>;
Binding key for setting and injecting the port number of RestServer
variable PROTOCOL
const PROTOCOL: BindingKey<HttpProtocol>;
Binding key for setting and injecting the protocol of RestServer
variable REQUEST_BODY_PARSER
const REQUEST_BODY_PARSER: BindingKey<RequestBodyParser>;
Binding key for request body parser
variable REQUEST_BODY_PARSER_JSON
const REQUEST_BODY_PARSER_JSON: BindingKey<BodyParser>;
Binding key for request json body parser
variable REQUEST_BODY_PARSER_OPTIONS
const REQUEST_BODY_PARSER_OPTIONS: BindingKey<RequestBodyParserOptions>;
Binding key for request body parser options
variable REQUEST_BODY_PARSER_RAW
const REQUEST_BODY_PARSER_RAW: BindingKey<BodyParser>;
Binding key for request raw body parser
variable REQUEST_BODY_PARSER_STREAM
const REQUEST_BODY_PARSER_STREAM: BindingKey<BodyParser>;
Binding key for request raw body parser
variable REQUEST_BODY_PARSER_TEXT
const REQUEST_BODY_PARSER_TEXT: BindingKey<BodyParser>;
Binding key for request text body parser
variable REQUEST_BODY_PARSER_URLENCODED
const REQUEST_BODY_PARSER_URLENCODED: BindingKey<BodyParser>;
Binding key for request urlencoded body parser
variable ROUTER
const ROUTER: BindingKey<RestRouter>;
Internal binding key for rest router
variable ROUTER_OPTIONS
const ROUTER_OPTIONS: BindingKey<RestRouterOptions>;
variable ROUTES
const ROUTES: string;
Namespace for REST routes
variable SEQUENCE
const SEQUENCE: BindingKey<SequenceHandler>;
Binding key for setting and injecting a Sequence
variable SERVER
const SERVER: BindingKey<RestServer>;
Binding key for the server itself
variable URL
const URL: BindingKey<string>;
Binding key for setting and injecting the URL of RestServer
namespace RestBindings.Http
namespace RestBindings.Http {}
Request-specific bindings
variable CONTEXT
const CONTEXT: BindingKey<Context>;
Binding key for setting and injecting the http request context
variable REQUEST
const REQUEST: BindingKey<Request>;
Binding key for setting and injecting the http request
variable RESPONSE
const RESPONSE: BindingKey<Response<any, Record<string, any>>>;
Binding key for setting and injecting the http response
namespace RestBindings.Operation
namespace RestBindings.Operation {}
variable PARAMS
const PARAMS: BindingKey<OperationArgs>;
variable RETURN_VALUE
const RETURN_VALUE: BindingKey<any>;
variable ROUTE
const ROUTE: BindingKey<ResolvedRoute>;
namespace RestBindings.SequenceActions
namespace RestBindings.SequenceActions {}
Bindings for potential actions that could be used in a sequence
variable FIND_ROUTE
const FIND_ROUTE: BindingKey<FindRoute>;
Binding key for setting and injecting a route finding function
variable INVOKE_METHOD
const INVOKE_METHOD: BindingKey<InvokeMethod>;
Binding key for setting and injecting a controller route invoking function
variable INVOKE_MIDDLEWARE
const INVOKE_MIDDLEWARE: BindingKey<InvokeMiddleware>;
Binding key for setting and injecting
invokeMiddleware
function
variable LOG_ERROR
const LOG_ERROR: BindingKey<LogError>;
Binding key for setting and injecting an error logging function
variable PARSE_PARAMS
const PARSE_PARAMS: BindingKey<ParseParams>;
Binding key for setting and injecting a parameter parsing function
variable REJECT
const REJECT: BindingKey<Reject>;
Binding key for setting and injecting a bad response writing function
variable SEND
const SEND: BindingKey<Send>;
Binding key for setting and injecting a response writing function
namespace RestHttpErrors
namespace RestHttpErrors {}
variable INVALID_REQUEST_BODY_MESSAGE
const INVALID_REQUEST_BODY_MESSAGE: string;
function invalidData
invalidData: <T, Props extends object = {}>( data: T, name: string, extraProperties?: Props) => HttpErrors.HttpError & Props;
function invalidParamLocation
invalidParamLocation: (location: string) => HttpErrors.HttpError;
function invalidRequestBody
invalidRequestBody: ( details: ValidationErrorDetails[]) => HttpErrors.HttpError & { details: ValidationErrorDetails[] };
function missingRequired
missingRequired: (name: string) => HttpErrors.HttpError;
function unsupportedMediaType
unsupportedMediaType: ( contentType: string, allowedTypes?: string[]) => HttpErrors.HttpError<415> & { code: string; contentType: string; allowedMediaTypes: string[];};
interface ValidationErrorDetails
interface ValidationErrorDetails {}
An invalid request body error contains a
details
property as the machine-readable error. Each entry inerror.details
contains 4 attributes:path
,code
,info
andmessage
.ValidationErrorDetails
defines the type of each entry, which is an object. The type oferror.details
isValidationErrorDetails[]
.
namespace RestMiddlewareGroups
namespace RestMiddlewareGroups {}
Built-in middleware groups for the REST sequence
variable API_SPEC
const API_SPEC: string;
Server OpenAPI specs
variable AUTHENTICATION
const AUTHENTICATION: string;
Perform authentication
variable CORS
const CORS: string;
Enforce CORS
variable DEFAULT
const DEFAULT: string;
variable FIND_ROUTE
const FIND_ROUTE: string;
Find the route that can serve the request
variable INVOKE_METHOD
const INVOKE_METHOD: string;
Invoke the target controller method or handler function
variable MIDDLEWARE
const MIDDLEWARE: string;
Default middleware group
variable PARSE_PARAMS
const PARSE_PARAMS: string;
Parse the http request to extract parameter values for the operation
variable SEND_RESPONSE
const SEND_RESPONSE: string;
Invoke downstream middleware to get the result or catch errors so that it can produce the http response
namespace RestTags
namespace RestTags {}
Binding tags for RestServer
variable ACTION_MIDDLEWARE_CHAIN
const ACTION_MIDDLEWARE_CHAIN: string;
Legacy middleware chain for action-based REST sequence
variable AJV_FORMAT
const AJV_FORMAT: string;
variable AJV_KEYWORD
const AJV_KEYWORD: string;
variable CONTROLLER_BINDING
const CONTROLLER_BINDING: string;
Binding tag for controller route bindings to represent the controller binding key
variable CONTROLLER_ROUTE
const CONTROLLER_ROUTE: string;
Binding tag to identify controller based REST routes
variable REST_MIDDLEWARE_CHAIN
const REST_MIDDLEWARE_CHAIN: string;
variable REST_ROUTE
const REST_ROUTE: string;
Binding tag to identify REST routes
variable ROUTE_PATH
const ROUTE_PATH: string;
Binding tag for the REST route path
variable ROUTE_VERB
const ROUTE_VERB: string;
Binding tag for the REST route verb
Package Files (43)
- dist/body-parsers/body-parser.d.ts
- dist/body-parsers/body-parser.helpers.d.ts
- dist/body-parsers/body-parser.json.d.ts
- dist/body-parsers/body-parser.raw.d.ts
- dist/body-parsers/body-parser.stream.d.ts
- dist/body-parsers/body-parser.text.d.ts
- dist/body-parsers/body-parser.urlencoded.d.ts
- dist/body-parsers/types.d.ts
- dist/http-handler.d.ts
- dist/index.d.ts
- dist/keys.d.ts
- dist/parse-json.d.ts
- dist/parser.d.ts
- dist/providers/find-route.provider.d.ts
- dist/providers/invoke-method.provider.d.ts
- dist/providers/log-error.provider.d.ts
- dist/providers/parse-params.provider.d.ts
- dist/providers/reject.provider.d.ts
- dist/providers/send.provider.d.ts
- dist/request-context.d.ts
- dist/rest-http-error.d.ts
- dist/rest.application.d.ts
- dist/rest.component.d.ts
- dist/rest.server.d.ts
- dist/router/base-route.d.ts
- dist/router/controller-route.d.ts
- dist/router/external-express-routes.d.ts
- dist/router/handler-route.d.ts
- dist/router/openapi-path.d.ts
- dist/router/redirect-route.d.ts
- dist/router/regexp-router.d.ts
- dist/router/rest-router.d.ts
- dist/router/route-entry.d.ts
- dist/router/route-sort.d.ts
- dist/router/router-spec.d.ts
- dist/router/routing-table.d.ts
- dist/router/trie-router.d.ts
- dist/router/trie.d.ts
- dist/sequence.d.ts
- dist/spec-enhancers/info.spec-enhancer.d.ts
- dist/types.d.ts
- dist/validation/request-body.validator.d.ts
- dist/writer.d.ts
Dependencies (31)
- @loopback/express
- @loopback/http-server
- @loopback/openapi-v3
- @openapi-contrib/openapi-schema-to-json-schema
- @types/body-parser
- @types/cors
- @types/express
- @types/express-serve-static-core
- @types/http-errors
- @types/on-finished
- @types/serve-static
- @types/type-is
- ajv
- ajv-errors
- ajv-formats
- ajv-keywords
- body-parser
- cors
- debug
- express
- http-errors
- js-yaml
- json-schema-compare
- lodash
- on-finished
- path-to-regexp
- qs
- strong-error-handler
- tslib
- type-is
- validator
Dev Dependencies (15)
Peer Dependencies (1)
Badge
To add a badge like this oneto your package's README, use the codes available below.
You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@loopback/rest
.
- Markdown[![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@loopback/rest)
- HTML<a href="https://www.jsdocs.io/package/@loopback/rest"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>
- Updated .
Package analyzed in 7319 ms. - Missing or incorrect documentation? Open an issue for this package.