@loopback/rest 5.0.1 → 5.2.0

package/dist/rest.server.js

@@ -6,7 +6,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createBodyParserBinding = exports.RestServer = void 0;
 const tslib_1 = require("tslib");
-const context_1 = require("@loopback/context");
 const core_1 = require("@loopback/core");
 const express_1 = require("@loopback/express");
 const http_server_1 = require("@loopback/http-server");
@@ -15,6 +14,7 @@ const assert_1 = tslib_1.__importStar(require("assert"));
 const cors_1 = tslib_1.__importDefault(require("cors"));
 const debug_1 = tslib_1.__importDefault(require("debug"));
 const express_2 = tslib_1.__importDefault(require("express"));
+const fs_1 = tslib_1.__importDefault(require("fs"));
 const js_yaml_1 = require("js-yaml");
 const lodash_1 = require("lodash");
 const strong_error_handler_1 = require("strong-error-handler");
@@ -54,624 +54,651 @@ const SequenceActions = keys_1.RestBindings.SequenceActions;
  * const server = await app.get('servers.foo');
  * ```
  */
-let RestServer = /** @class */ (() => {
-    let RestServer = class RestServer extends express_1.BaseMiddlewareRegistry {
-        /**
-         *
-         * Creates an instance of RestServer.
-         *
-         * @param app - The application instance (injected via
-         * CoreBindings.APPLICATION_INSTANCE).
-         * @param config - The configuration options (injected via
-         * RestBindings.CONFIG).
-         *
+let RestServer = class RestServer extends express_1.BaseMiddlewareRegistry {
+    /**
+     *
+     * Creates an instance of RestServer.
+     *
+     * @param app - The application instance (injected via
+     * CoreBindings.APPLICATION_INSTANCE).
+     * @param config - The configuration options (injected via
+     * RestBindings.CONFIG).
+     *
+     */
+    constructor(app, config = {}) {
+        var _a;
+        super(app);
+        /*
+         * Registry of external routes & static assets
          */
-        constructor(app, config = {}) {
-            var _a;
-            super(app);
-            /*
-             * Registry of external routes & static assets
-             */
-            this._externalRoutes = new router_1.ExternalExpressRoutes();
-            this.config = resolveRestServerConfig(config);
-            this.bind(keys_1.RestBindings.PORT).to(this.config.port);
-            this.bind(keys_1.RestBindings.HOST).to(config.host);
-            this.bind(keys_1.RestBindings.PATH).to(config.path);
-            this.bind(keys_1.RestBindings.PROTOCOL).to((_a = config.protocol) !== null && _a !== void 0 ? _a : 'http');
-            this.bind(keys_1.RestBindings.HTTPS_OPTIONS).to(config);
-            if (config.requestBodyParser) {
-                this.bind(keys_1.RestBindings.REQUEST_BODY_PARSER_OPTIONS).to(config.requestBodyParser);
-            }
-            if (config.sequence) {
-                this.sequence(config.sequence);
-            }
-            if (config.router) {
-                this.bind(keys_1.RestBindings.ROUTER_OPTIONS).to(config.router);
-            }
-            this.basePath(config.basePath);
-            this.bind(keys_1.RestBindings.BASE_PATH).toDynamicValue(() => this._basePath);
-            this.bind(keys_1.RestBindings.HANDLER).toDynamicValue(() => this.httpHandler);
-        }
-        get OASEnhancer() {
-            this._setupOASEnhancerIfNeeded();
-            return this._OASEnhancer;
-        }
-        get requestHandler() {
-            if (this._requestHandler == null) {
-                this._setupRequestHandlerIfNeeded();
-            }
-            return this._requestHandler;
-        }
-        get httpHandler() {
-            this._setupHandlerIfNeeded();
-            return this._httpHandler;
-        }
-        get listening() {
-            return this._httpServer ? this._httpServer.listening : false;
+        this._externalRoutes = new router_1.ExternalExpressRoutes();
+        this.config = resolveRestServerConfig(config);
+        this.bind(keys_1.RestBindings.PORT).to(this.config.port);
+        this.bind(keys_1.RestBindings.HOST).to(config.host);
+        this.bind(keys_1.RestBindings.PATH).to(config.path);
+        this.bind(keys_1.RestBindings.PROTOCOL).to((_a = config.protocol) !== null && _a !== void 0 ? _a : 'http');
+        this.bind(keys_1.RestBindings.HTTPS_OPTIONS).to(config);
+        if (config.requestBodyParser) {
+            this.bind(keys_1.RestBindings.REQUEST_BODY_PARSER_OPTIONS).to(config.requestBodyParser);
+        }
+        if (config.sequence) {
+            this.sequence(config.sequence);
+        }
+        if (config.router) {
+            this.bind(keys_1.RestBindings.ROUTER_OPTIONS).to(config.router);
+        }
+        this.basePath(config.basePath);
+        this.bind(keys_1.RestBindings.BASE_PATH).toDynamicValue(() => this._basePath);
+        this.bind(keys_1.RestBindings.HANDLER).toDynamicValue(() => this.httpHandler);
+    }
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    get OASEnhancer() {
+        this._setupOASEnhancerIfNeeded();
+        return this._OASEnhancer;
+    }
+    get requestHandler() {
+        if (this._requestHandler == null) {
+            this._setupRequestHandlerIfNeeded();
         }
-        /**
-         * 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'.
-         */
-        get url() {
-            let serverUrl = this.rootUrl;
-            if (!serverUrl)
-                return serverUrl;
-            serverUrl = serverUrl + (this._basePath || '');
+        return this._requestHandler;
+    }
+    get httpHandler() {
+        this._setupHandlerIfNeeded();
+        return this._httpHandler;
+    }
+    get listening() {
+        return this._httpServer ? this._httpServer.listening : false;
+    }
+    /**
+     * 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'.
+     */
+    get url() {
+        let serverUrl = this.rootUrl;
+        if (!serverUrl)
             return serverUrl;
+        serverUrl = serverUrl + (this._basePath || '');
+        return serverUrl;
+    }
+    /**
+     * The root url for the server without the basePath. For example, the value
+     * will be 'http://localhost:3000' regardless of the `basePath`.
+     */
+    get rootUrl() {
+        var _a;
+        return (_a = this._httpServer) === null || _a === void 0 ? void 0 : _a.url;
+    }
+    _setupOASEnhancerIfNeeded() {
+        if (this._OASEnhancer != null)
+            return;
+        this.add(core_1.createBindingFromClass(openapi_v3_1.OASEnhancerService, {
+            key: openapi_v3_1.OASEnhancerBindings.OAS_ENHANCER_SERVICE,
+        }));
+        this._OASEnhancer = this.getSync(openapi_v3_1.OASEnhancerBindings.OAS_ENHANCER_SERVICE);
+    }
+    _setupRequestHandlerIfNeeded() {
+        if (this._expressApp != null)
+            return;
+        this._expressApp = express_2.default();
+        this._applyExpressSettings();
+        this._requestHandler = this._expressApp;
+        // Allow CORS support for all endpoints so that users
+        // can test with online SwaggerUI instance
+        this.expressMiddleware(cors_1.default, this.config.cors, {
+            injectConfiguration: false,
+            key: 'middleware.cors',
+            group: 'cors',
+        });
+        // Set up endpoints for OpenAPI spec/ui
+        this._setupOpenApiSpecEndpoints();
+        // Mount our router & request handler
+        this._expressApp.use(this._basePath, (req, res, next) => {
+            this._handleHttpRequest(req, res).catch(next);
+        });
+        // Mount our error handler
+        this._expressApp.use(this._unexpectedErrorHandler());
+    }
+    /**
+     * Get an Express handler for unexpected errors
+     */
+    _unexpectedErrorHandler() {
+        const handleUnExpectedError = (err, req, res, next) => {
+            // Handle errors reported by Express middleware such as CORS
+            // First try to use the `REJECT` action
+            this.get(SequenceActions.REJECT, { optional: true })
+                .then(reject => {
+                if (reject) {
+                    // TODO(rfeng): There is a possibility that the error is thrown
+                    // from the `REJECT` action in the sequence
+                    return reject({ request: req, response: res }, err);
+                }
+                // Use strong-error handler directly
+                strong_error_handler_1.writeErrorToResponse(err, req, res);
+            })
+                .catch(unexpectedErr => next(unexpectedErr));
+        };
+        return handleUnExpectedError;
+    }
+    /**
+     * Apply express settings.
+     */
+    _applyExpressSettings() {
+        assertExists(this._expressApp, 'this._expressApp');
+        const settings = this.config.expressSettings;
+        for (const key in settings) {
+            this._expressApp.set(key, settings[key]);
+        }
+        if (this.config.router && typeof this.config.router.strict === 'boolean') {
+            this._expressApp.set('strict routing', this.config.router.strict);
         }
-        /**
-         * The root url for the server without the basePath. For example, the value
-         * will be 'http://localhost:3000' regardless of the `basePath`.
-         */
-        get rootUrl() {
-            return this._httpServer && this._httpServer.url;
-        }
-        _setupOASEnhancerIfNeeded() {
-            if (this._OASEnhancer != null)
-                return;
-            this.add(context_1.createBindingFromClass(openapi_v3_1.OASEnhancerService, {
-                key: openapi_v3_1.OASEnhancerBindings.OAS_ENHANCER_SERVICE,
-            }));
-            this._OASEnhancer = this.getSync(openapi_v3_1.OASEnhancerBindings.OAS_ENHANCER_SERVICE);
-        }
-        _setupRequestHandlerIfNeeded() {
-            if (this._expressApp != null)
-                return;
-            this._expressApp = express_2.default();
-            this._applyExpressSettings();
-            this._requestHandler = this._expressApp;
-            // Allow CORS support for all endpoints so that users
-            // can test with online SwaggerUI instance
-            this.expressMiddleware(cors_1.default, this.config.cors, {
-                injectConfiguration: false,
-                key: 'middleware.cors',
-                group: 'cors',
-            });
-            // Set up endpoints for OpenAPI spec/ui
-            this._setupOpenApiSpecEndpoints();
-            // Mount our router & request handler
-            this._expressApp.use(this._basePath, (req, res, next) => {
-                this._handleHttpRequest(req, res).catch(next);
-            });
-            // Mount our error handler
-            this._expressApp.use(this._unexpectedErrorHandler());
-        }
-        /**
-         * Get an Express handler for unexpected errors
-         */
-        _unexpectedErrorHandler() {
-            const handleUnExpectedError = (err, req, res, next) => {
-                // Handle errors reported by Express middleware such as CORS
-                // First try to use the `REJECT` action
-                this.get(SequenceActions.REJECT, { optional: true })
-                    .then(reject => {
-                    if (reject) {
-                        // TODO(rfeng): There is a possibility that the error is thrown
-                        // from the `REJECT` action in the sequence
-                        return reject({ request: req, response: res }, err);
-                    }
-                    // Use strong-error handler directly
-                    strong_error_handler_1.writeErrorToResponse(err, req, res);
-                })
-                    .catch(unexpectedErr => next(unexpectedErr));
-            };
-            return handleUnExpectedError;
-        }
-        /**
-         * Apply express settings.
-         */
-        _applyExpressSettings() {
-            assertExists(this._expressApp, 'this._expressApp');
-            const settings = this.config.expressSettings;
-            for (const key in settings) {
-                this._expressApp.set(key, settings[key]);
-            }
-            if (this.config.router && typeof this.config.router.strict === 'boolean') {
-                this._expressApp.set('strict routing', this.config.router.strict);
-            }
-        }
-        /**
-         * Mount /openapi.json, /openapi.yaml for specs and /swagger-ui, /explorer
-         * to redirect to externally hosted API explorer
-         */
-        _setupOpenApiSpecEndpoints() {
-            assertExists(this._expressApp, 'this._expressApp');
-            if (this.config.openApiSpec.disabled)
-                return;
-            const router = express_2.default.Router();
-            const mapping = this.config.openApiSpec.endpointMapping;
-            // Serving OpenAPI spec
-            for (const p in mapping) {
-                this.addOpenApiSpecEndpoint(p, mapping[p], router);
+    }
+    /**
+     * Mount /openapi.json, /openapi.yaml for specs and /swagger-ui, /explorer
+     * to redirect to externally hosted API explorer
+     */
+    _setupOpenApiSpecEndpoints() {
+        assertExists(this._expressApp, 'this._expressApp');
+        if (this.config.openApiSpec.disabled)
+            return;
+        const router = express_2.default.Router();
+        const mapping = this.config.openApiSpec.endpointMapping;
+        // Serving OpenAPI spec
+        for (const p in mapping) {
+            this.addOpenApiSpecEndpoint(p, mapping[p], router);
+        }
+        const explorerPaths = ['/swagger-ui', '/explorer'];
+        router.get(explorerPaths, (req, res, next) => this._redirectToSwaggerUI(req, res, next));
+        this.expressMiddleware('middleware.apiSpec.defaults', router, {
+            group: 'apiSpec',
+        });
+    }
+    /**
+     * Add a new non-controller endpoint hosting a form of the OpenAPI spec.
+     *
+     * @param path Path at which to host the copy of the OpenAPI
+     * @param form Form that should be rendered from that path
+     */
+    addOpenApiSpecEndpoint(path, form, router) {
+        if (router == null) {
+            const key = `middleware.apiSpec.${path}.${form}`;
+            if (this.contains(key)) {
+                throw new Error(`The path ${path} is already configured for OpenApi hosting`);
             }
-            const explorerPaths = ['/swagger-ui', '/explorer'];
-            router.get(explorerPaths, (req, res, next) => this._redirectToSwaggerUI(req, res, next));
-            this.expressMiddleware('middleware.apiSpec.defaults', router, {
+            const newRouter = express_2.default.Router();
+            newRouter.get(path, (req, res) => this._serveOpenApiSpec(req, res, form));
+            this.expressMiddleware(() => newRouter, {}, {
+                injectConfiguration: false,
+                key: `middleware.apiSpec.${path}.${form}`,
                 group: 'apiSpec',
             });
         }
-        /**
-         * Add a new non-controller endpoint hosting a form of the OpenAPI spec.
-         *
-         * @param path Path at which to host the copy of the OpenAPI
-         * @param form Form that should be rendered from that path
-         */
-        addOpenApiSpecEndpoint(path, form, router) {
-            if (router == null) {
-                const key = `middleware.apiSpec.${path}.${form}`;
-                if (this.contains(key)) {
-                    throw new Error(`The path ${path} is already configured for OpenApi hosting`);
-                }
-                const newRouter = express_2.default.Router();
-                newRouter.get(path, (req, res) => this._serveOpenApiSpec(req, res, form));
-                this.expressMiddleware(() => newRouter, {}, {
-                    injectConfiguration: false,
-                    key: `middleware.apiSpec.${path}.${form}`,
-                    group: 'apiSpec',
-                });
-            }
-            else {
-                router.get(path, (req, res) => this._serveOpenApiSpec(req, res, form));
-            }
-        }
-        _handleHttpRequest(request, response) {
-            return this.httpHandler.handleRequest(request, response);
-        }
-        _setupHandlerIfNeeded() {
-            if (this._httpHandler)
-                return;
-            // Watch for binding events
-            // See https://github.com/strongloop/loopback-next/issues/433
-            const routesObserver = {
-                filter: binding => context_1.filterByKey(keys_1.RestBindings.API_SPEC.key)(binding) ||
-                    (context_1.filterByKey(/^(controllers|routes)\..+/)(binding) &&
-                        // Exclude controller routes to avoid circular events
-                        !context_1.filterByTag(keys_1.RestTags.CONTROLLER_ROUTE)(binding)),
-                observe: () => {
-                    // Rebuild the HttpHandler instance whenever a controller/route was
-                    // added/deleted.
-                    this._createHttpHandler();
-                },
-            };
-            this._routesEventSubscription = this.subscribe(routesObserver);
-            this._createHttpHandler();
+        else {
+            router.get(path, (req, res) => this._serveOpenApiSpec(req, res, form));
         }
+    }
+    _handleHttpRequest(request, response) {
+        return this.httpHandler.handleRequest(request, response);
+    }
+    _setupHandlerIfNeeded() {
+        if (this._httpHandler)
+            return;
+        // Watch for binding events
+        // See https://github.com/strongloop/loopback-next/issues/433
+        const routesObserver = {
+            filter: binding => core_1.filterByKey(keys_1.RestBindings.API_SPEC.key)(binding) ||
+                (core_1.filterByKey(/^(controllers|routes)\..+/)(binding) &&
+                    // Exclude controller routes to avoid circular events
+                    !core_1.filterByTag(keys_1.RestTags.CONTROLLER_ROUTE)(binding)),
+            observe: () => {
+                // Rebuild the HttpHandler instance whenever a controller/route was
+                // added/deleted.
+                this._createHttpHandler();
+            },
+        };
+        this._routesEventSubscription = this.subscribe(routesObserver);
+        this._createHttpHandler();
+    }
+    /**
+     * Create an instance of HttpHandler and populates it with routes
+     */
+    _createHttpHandler() {
         /**
-         * Create an instance of HttpHandler and populates it with routes
+         * Check if there is custom router in the context
          */
-        _createHttpHandler() {
-            /**
-             * Check if there is custom router in the context
-             */
-            const router = this.getSync(keys_1.RestBindings.ROUTER, { optional: true });
-            const routingTable = new router_1.RoutingTable(router, this._externalRoutes);
-            this._httpHandler = new http_handler_1.HttpHandler(this, this.config, routingTable);
-            // Remove controller routes
-            for (const b of this.findByTag(keys_1.RestTags.CONTROLLER_ROUTE)) {
-                this.unbind(b.key);
-            }
-            for (const b of this.find(`${core_1.CoreBindings.CONTROLLERS}.*`)) {
-                const controllerName = b.key.replace(/^controllers\./, '');
-                const ctor = b.valueConstructor;
-                if (!ctor) {
-                    throw new Error(`The controller ${controllerName} was not bound via .toClass()`);
-                }
-                const apiSpec = openapi_v3_1.getControllerSpec(ctor);
-                if (!apiSpec) {
-                    // controller methods are specified through app.api() spec
-                    debug('Skipping controller %s - no API spec provided', controllerName);
-                    continue;
-                }
-                debug('Registering controller %s', controllerName);
-                if (apiSpec.components) {
-                    this._httpHandler.registerApiComponents(apiSpec.components);
-                }
-                const controllerFactory = router_1.createControllerFactoryForBinding(b.key);
-                const routes = router_1.createRoutesForController(apiSpec, ctor, controllerFactory);
-                for (const route of routes) {
-                    const binding = this.bindRoute(route);
-                    binding
-                        .tag(keys_1.RestTags.CONTROLLER_ROUTE)
-                        .tag({ [keys_1.RestTags.CONTROLLER_BINDING]: b.key });
-                }
+        const router = this.getSync(keys_1.RestBindings.ROUTER, { optional: true });
+        const routingTable = new router_1.RoutingTable(router, this._externalRoutes);
+        this._httpHandler = new http_handler_1.HttpHandler(this, this.config, routingTable);
+        // Remove controller routes
+        for (const b of this.findByTag(keys_1.RestTags.CONTROLLER_ROUTE)) {
+            this.unbind(b.key);
+        }
+        for (const b of this.find(`${core_1.CoreBindings.CONTROLLERS}.*`)) {
+            const controllerName = b.key.replace(/^controllers\./, '');
+            const ctor = b.valueConstructor;
+            if (!ctor) {
+                throw new Error(`The controller ${controllerName} was not bound via .toClass()`);
             }
-            for (const b of this.findByTag(keys_1.RestTags.REST_ROUTE)) {
-                // TODO(bajtos) should we support routes defined asynchronously?
-                const route = this.getSync(b.key);
-                this._httpHandler.registerRoute(route);
-            }
-            // TODO(bajtos) should we support API spec defined asynchronously?
-            const spec = this.getSync(keys_1.RestBindings.API_SPEC);
-            for (const path in spec.paths) {
-                for (const verb in spec.paths[path]) {
-                    const routeSpec = spec.paths[path][verb];
-                    this._setupOperation(verb, path, routeSpec);
-                }
-            }
-        }
-        _setupOperation(verb, path, spec) {
-            const handler = spec['x-operation'];
-            if (typeof handler === 'function') {
-                // Remove a field value that cannot be represented in JSON.
-                // Start by creating a shallow-copy of the spec, so that we don't
-                // modify the original spec object provided by user.
-                spec = Object.assign({}, spec);
-                delete spec['x-operation'];
-                const route = new router_1.Route(verb, path, spec, handler);
-                this._httpHandler.registerRoute(route);
-                return;
-            }
-            const controllerName = spec['x-controller-name'];
-            if (typeof controllerName === 'string') {
-                const b = this.getBinding(`controllers.${controllerName}`, {
-                    optional: true,
-                });
-                if (!b) {
-                    throw new Error(`Unknown controller ${controllerName} used by "${verb} ${path}"`);
-                }
-                const ctor = b.valueConstructor;
-                if (!ctor) {
-                    throw new Error(`The controller ${controllerName} was not bound via .toClass()`);
-                }
-                const controllerFactory = router_1.createControllerFactoryForBinding(b.key);
-                const route = new router_1.ControllerRoute(verb, path, spec, ctor, controllerFactory);
-                this._httpHandler.registerRoute(route);
-                return;
+            const apiSpec = openapi_v3_1.getControllerSpec(ctor);
+            if (!apiSpec) {
+                // controller methods are specified through app.api() spec
+                debug('Skipping controller %s - no API spec provided', controllerName);
+                continue;
             }
-            throw new Error(`There is no handler configured for operation "${verb} ${path}`);
-        }
-        async _serveOpenApiSpec(request, response, specForm) {
-            const requestContext = new request_context_1.RequestContext(request, response, this, this.config);
-            specForm = specForm !== null && specForm !== void 0 ? specForm : { version: '3.0.0', format: 'json' };
-            const specObj = await this.getApiSpec(requestContext);
-            if (specForm.format === 'json') {
-                const spec = JSON.stringify(specObj, null, 2);
-                response.setHeader('content-type', 'application/json; charset=utf-8');
-                response.end(spec, 'utf-8');
+            debug('Registering controller %s', controllerName);
+            if (apiSpec.components) {
+                this._httpHandler.registerApiComponents(apiSpec.components);
             }
-            else {
-                const yaml = js_yaml_1.safeDump(specObj, {});
-                response.setHeader('content-type', 'text/yaml; charset=utf-8');
-                response.end(yaml, 'utf-8');
+            const controllerFactory = router_1.createControllerFactoryForBinding(b.key);
+            const routes = router_1.createRoutesForController(apiSpec, ctor, controllerFactory);
+            for (const route of routes) {
+                const binding = this.bindRoute(route);
+                binding
+                    .tag(keys_1.RestTags.CONTROLLER_ROUTE)
+                    .tag({ [keys_1.RestTags.CONTROLLER_BINDING]: b.key });
             }
         }
-        async _redirectToSwaggerUI(request, response, next) {
-            const config = this.config.apiExplorer;
-            if (config.disabled) {
-                debug('Redirect to swagger-ui was disabled by configuration.');
-                next();
-                return;
+        for (const b of this.findByTag(keys_1.RestTags.REST_ROUTE)) {
+            // TODO(bajtos) should we support routes defined asynchronously?
+            const route = this.getSync(b.key);
+            this._httpHandler.registerRoute(route);
+        }
+        // TODO(bajtos) should we support API spec defined asynchronously?
+        const spec = this.getSync(keys_1.RestBindings.API_SPEC);
+        for (const path in spec.paths) {
+            for (const verb in spec.paths[path]) {
+                const routeSpec = spec.paths[path][verb];
+                this._setupOperation(verb, path, routeSpec);
             }
-            debug('Redirecting to swagger-ui from %j.', request.originalUrl);
-            const requestContext = new request_context_1.RequestContext(request, response, this, this.config);
-            const protocol = requestContext.requestedProtocol;
-            const baseUrl = protocol === 'http' ? config.httpUrl : config.url;
-            const openApiUrl = `${requestContext.requestedBaseUrl}/openapi.json`;
-            const fullUrl = `${baseUrl}?url=${openApiUrl}`;
-            response.redirect(302, fullUrl);
         }
-        /**
-         * Register a controller class with this server.
-         *
-         * @param 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
-         * ```ts
-         * class MyController {
-         * }
-         * app.controller(MyController).lock();
-         * ```
-         *
-         */
-        controller(controllerCtor) {
-            return this.bind('controllers.' + controllerCtor.name).toClass(controllerCtor);
-        }
-        route(routeOrVerb, path, spec, controllerCtorOrHandler, controllerFactory, methodName) {
-            if (typeof routeOrVerb === 'object') {
-                const r = routeOrVerb;
-                // Encode the path to escape special chars
-                return this.bindRoute(r);
-            }
-            if (!path) {
-                throw new assert_1.AssertionError({
-                    message: 'path is required for a controller-based route',
-                });
-            }
-            if (!spec) {
-                throw new assert_1.AssertionError({
-                    message: 'spec is required for a controller-based route',
-                });
-            }
-            if (arguments.length === 4) {
-                if (!controllerCtorOrHandler) {
-                    throw new assert_1.AssertionError({
-                        message: 'handler function is required for a handler-based route',
-                    });
-                }
-                return this.route(new router_1.Route(routeOrVerb, path, spec, controllerCtorOrHandler));
-            }
-            if (!controllerCtorOrHandler) {
-                throw new assert_1.AssertionError({
-                    message: 'controller is required for a controller-based route',
-                });
+    }
+    _setupOperation(verb, path, spec) {
+        const handler = spec['x-operation'];
+        if (typeof handler === 'function') {
+            // Remove a field value that cannot be represented in JSON.
+            // Start by creating a shallow-copy of the spec, so that we don't
+            // modify the original spec object provided by user.
+            spec = Object.assign({}, spec);
+            delete spec['x-operation'];
+            const route = new router_1.Route(verb, path, spec, handler);
+            this._httpHandler.registerRoute(route);
+            return;
+        }
+        const controllerName = spec['x-controller-name'];
+        if (typeof controllerName === 'string') {
+            const b = this.getBinding(`controllers.${controllerName}`, {
+                optional: true,
+            });
+            if (!b) {
+                throw new Error(`Unknown controller ${controllerName} used by "${verb} ${path}"`);
             }
-            if (!methodName) {
-                throw new assert_1.AssertionError({
-                    message: 'methodName is required for a controller-based route',
-                });
+            const ctor = b.valueConstructor;
+            if (!ctor) {
+                throw new Error(`The controller ${controllerName} was not bound via .toClass()`);
             }
-            return this.route(new router_1.ControllerRoute(routeOrVerb, path, spec, controllerCtorOrHandler, controllerFactory, methodName));
-        }
-        bindRoute(r) {
-            const namespace = keys_1.RestBindings.ROUTES;
-            const encodedPath = encodeURIComponent(r.path).replace(/\./g, '%2E');
-            return this.bind(`${namespace}.${r.verb} ${encodedPath}`)
-                .to(r)
-                .tag(keys_1.RestTags.REST_ROUTE)
-                .tag({ [keys_1.RestTags.ROUTE_VERB]: r.verb, [keys_1.RestTags.ROUTE_PATH]: r.path });
+            const controllerFactory = router_1.createControllerFactoryForBinding(b.key);
+            const route = new router_1.ControllerRoute(verb, path, spec, ctor, controllerFactory);
+            this._httpHandler.registerRoute(route);
+            return;
         }
-        /**
-         * Register a route redirecting callers to a different URL.
-         *
-         * @example
-         * ```ts
-         * server.redirect('/explorer', '/explorer/');
-         * ```
-         *
-         * @param fromPath - URL path of the redirect endpoint
-         * @param 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.
-         * @param statusCode - HTTP status code to respond with,
-         *   defaults to 303 (See Other).
-         */
-        redirect(fromPath, toPathOrUrl, statusCode) {
-            return this.route(new router_1.RedirectRoute(fromPath, this._basePath + toPathOrUrl, statusCode));
+        throw new Error(`There is no handler configured for operation "${verb} ${path}`);
+    }
+    async _serveOpenApiSpec(request, response, specForm) {
+        const requestContext = new request_context_1.RequestContext(request, response, this, this.config);
+        specForm = specForm !== null && specForm !== void 0 ? specForm : { version: '3.0.0', format: 'json' };
+        const specObj = await this.getApiSpec(requestContext);
+        if (specForm.format === 'json') {
+            const spec = JSON.stringify(specObj, null, 2);
+            response.setHeader('content-type', 'application/json; charset=utf-8');
+            response.end(spec, 'utf-8');
+        }
+        else {
+            const yaml = js_yaml_1.safeDump(specObj, {});
+            response.setHeader('content-type', 'text/yaml; charset=utf-8');
+            response.end(yaml, 'utf-8');
         }
-        /**
-         * Mount static assets to the REST server.
-         * See https://expressjs.com/en/4x/api.html#express.static
-         * @param path - The path(s) to serve the asset.
-         * See examples at https://expressjs.com/en/4x/api.html#path-examples
-         * @param rootDir - The root directory from which to serve static assets
-         * @param options - Options for serve-static
-         */
-        static(path, rootDir, options) {
-            this._externalRoutes.registerAssets(path, rootDir, options);
+    }
+    async _redirectToSwaggerUI(request, response, next) {
+        const config = this.config.apiExplorer;
+        if (config.disabled) {
+            debug('Redirect to swagger-ui was disabled by configuration.');
+            next();
+            return;
+        }
+        debug('Redirecting to swagger-ui from %j.', request.originalUrl);
+        const requestContext = new request_context_1.RequestContext(request, response, this, this.config);
+        const protocol = requestContext.requestedProtocol;
+        const baseUrl = protocol === 'http' ? config.httpUrl : config.url;
+        const openApiUrl = `${requestContext.requestedBaseUrl}/openapi.json`;
+        const fullUrl = `${baseUrl}?url=${openApiUrl}`;
+        response.redirect(302, fullUrl);
+    }
+    /**
+     * Register a controller class with this server.
+     *
+     * @param 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
+     * ```ts
+     * class MyController {
+     * }
+     * app.controller(MyController).lock();
+     * ```
+     *
+     */
+    controller(controllerCtor) {
+        return this.bind('controllers.' + controllerCtor.name).toClass(controllerCtor);
+    }
+    route(routeOrVerb, path, spec, controllerCtorOrHandler, controllerFactory, methodName) {
+        if (typeof routeOrVerb === 'object') {
+            const r = routeOrVerb;
+            // Encode the path to escape special chars
+            return this.bindRoute(r);
+        }
+        if (!path) {
+            throw new assert_1.AssertionError({
+                message: 'path is required for a controller-based route',
+            });
         }
-        /**
-         * 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).
-         *
-         * @param spec - The OpenAPI specification, as an object.
-         * @returns Binding for the spec
-         *
-         */
-        api(spec) {
-            return this.bind(keys_1.RestBindings.API_SPEC).to(spec);
+        if (!spec) {
+            throw new assert_1.AssertionError({
+                message: 'spec is required for a controller-based route',
+            });
         }
-        /**
-         * 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 the `servers` list
-         * in the returned spec will be updated to work in that context.
-         * Specifically:
-         * 1. if `config.openApi.setServersFromRequest` is enabled, the servers
-         * list will be replaced with the context base url
-         * 2. Any `servers` entries with a path of `/` will have that path
-         * replaced with `requestContext.basePath`
-         *
-         * @param requestContext - Optional context to update the `servers` list
-         * in the returned spec
-         */
-        async getApiSpec(requestContext) {
-            let spec = await this.get(keys_1.RestBindings.API_SPEC);
-            const components = this.httpHandler.getApiComponents();
-            // Apply deep clone to prevent getApiSpec() callers from
-            // accidentally modifying our internal routing data
-            spec.paths = lodash_1.cloneDeep(this.httpHandler.describeApiPaths());
-            if (components) {
-                const defs = lodash_1.cloneDeep(components);
-                spec.components = { ...spec.components, ...defs };
-            }
-            router_spec_1.assignRouterSpec(spec, this._externalRoutes.routerSpec);
-            if (requestContext) {
-                spec = this.updateSpecFromRequest(spec, requestContext);
+        if (arguments.length === 4) {
+            if (!controllerCtorOrHandler) {
+                throw new assert_1.AssertionError({
+                    message: 'handler function is required for a handler-based route',
+                });
             }
-            // Apply OAS enhancers to the OpenAPI specification
-            this.OASEnhancer.spec = spec;
-            spec = await this.OASEnhancer.applyAllEnhancers();
-            return spec;
+            return this.route(new router_1.Route(routeOrVerb, path, spec, controllerCtorOrHandler));
         }
-        /**
-         * Update or rebuild OpenAPI Spec object to be appropriate for the context of
-         * a specific request for the spec, leveraging both app config and request
-         * path information.
-         *
-         * @param spec base spec object from which to start
-         * @param requestContext request to use to infer path information
-         * @returns Updated or rebuilt spec object to use in the context of the request
-         */
-        updateSpecFromRequest(spec, requestContext) {
-            if (this.config.openApiSpec.setServersFromRequest) {
-                spec = Object.assign({}, spec);
-                spec.servers = [{ url: requestContext.requestedBaseUrl }];
-            }
-            const basePath = requestContext.basePath;
-            if (spec.servers && basePath) {
-                for (const s of spec.servers) {
-                    // Update the default server url to honor `basePath`
-                    if (s.url === '/') {
-                        s.url = basePath;
-                    }
-                }
-            }
-            return spec;
+        if (!controllerCtorOrHandler) {
+            throw new assert_1.AssertionError({
+                message: 'controller is required for a controller-based route',
+            });
         }
-        /**
-         * Configure a custom sequence class for handling incoming requests.
-         *
-         * @example
-         * ```ts
-         * class MySequence implements SequenceHandler {
-         *   constructor(
-         *     @inject('send) public send: Send)) {
-         *   }
-         *
-         *   public async handle({response}: RequestContext) {
-         *     send(response, 'hello world');
-         *   }
-         * }
-         * ```
-         *
-         * @param value - The sequence to invoke for each incoming request.
-         */
-        sequence(value) {
-            this.bind(keys_1.RestBindings.SEQUENCE).toClass(value);
+        if (!methodName) {
+            throw new assert_1.AssertionError({
+                message: 'methodName is required for a controller-based route',
+            });
         }
-        /**
-         * Configure a custom sequence function for handling incoming requests.
-         *
-         * @example
-         * ```ts
-         * app.handler(({request, response}, sequence) => {
-         *   sequence.send(response, 'hello world');
-         * });
-         * ```
-         *
-         * @param handlerFn - The handler to invoke for each incoming request.
-         */
-        handler(handlerFn) {
-            class SequenceFromFunction extends sequence_1.DefaultSequence {
-                async handle(context) {
-                    return handlerFn(context, this);
+        return this.route(new router_1.ControllerRoute(routeOrVerb, path, spec, controllerCtorOrHandler, controllerFactory, methodName));
+    }
+    bindRoute(r) {
+        const namespace = keys_1.RestBindings.ROUTES;
+        const encodedPath = encodeURIComponent(r.path).replace(/\./g, '%2E');
+        return this.bind(`${namespace}.${r.verb} ${encodedPath}`)
+            .to(r)
+            .tag(keys_1.RestTags.REST_ROUTE)
+            .tag({ [keys_1.RestTags.ROUTE_VERB]: r.verb, [keys_1.RestTags.ROUTE_PATH]: r.path });
+    }
+    /**
+     * Register a route redirecting callers to a different URL.
+     *
+     * @example
+     * ```ts
+     * server.redirect('/explorer', '/explorer/');
+     * ```
+     *
+     * @param fromPath - URL path of the redirect endpoint
+     * @param 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.
+     * @param statusCode - HTTP status code to respond with,
+     *   defaults to 303 (See Other).
+     */
+    redirect(fromPath, toPathOrUrl, statusCode) {
+        return this.route(new router_1.RedirectRoute(fromPath, this._basePath + toPathOrUrl, statusCode));
+    }
+    /**
+     * Mount static assets to the REST server.
+     * See https://expressjs.com/en/4x/api.html#express.static
+     * @param path - The path(s) to serve the asset.
+     * See examples at https://expressjs.com/en/4x/api.html#path-examples
+     * @param rootDir - The root directory from which to serve static assets
+     * @param options - Options for serve-static
+     */
+    static(path, rootDir, options) {
+        this._externalRoutes.registerAssets(path, rootDir, options);
+    }
+    /**
+     * 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).
+     *
+     * @param spec - The OpenAPI specification, as an object.
+     * @returns Binding for the spec
+     *
+     */
+    api(spec) {
+        return this.bind(keys_1.RestBindings.API_SPEC).to(spec);
+    }
+    /**
+     * 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 the `servers` list
+     * in the returned spec will be updated to work in that context.
+     * Specifically:
+     * 1. if `config.openApi.setServersFromRequest` is enabled, the servers
+     * list will be replaced with the context base url
+     * 2. Any `servers` entries with a path of `/` will have that path
+     * replaced with `requestContext.basePath`
+     *
+     * @param requestContext - Optional context to update the `servers` list
+     * in the returned spec
+     */
+    async getApiSpec(requestContext) {
+        let spec = await this.get(keys_1.RestBindings.API_SPEC);
+        const components = this.httpHandler.getApiComponents();
+        // Apply deep clone to prevent getApiSpec() callers from
+        // accidentally modifying our internal routing data
+        spec.paths = lodash_1.cloneDeep(this.httpHandler.describeApiPaths());
+        if (components) {
+            const defs = lodash_1.cloneDeep(components);
+            spec.components = { ...spec.components, ...defs };
+        }
+        router_spec_1.assignRouterSpec(spec, this._externalRoutes.routerSpec);
+        if (requestContext) {
+            spec = this.updateSpecFromRequest(spec, requestContext);
+        }
+        // Apply OAS enhancers to the OpenAPI specification
+        this.OASEnhancer.spec = spec;
+        spec = await this.OASEnhancer.applyAllEnhancers();
+        return spec;
+    }
+    /**
+     * Update or rebuild OpenAPI Spec object to be appropriate for the context of
+     * a specific request for the spec, leveraging both app config and request
+     * path information.
+     *
+     * @param spec base spec object from which to start
+     * @param requestContext request to use to infer path information
+     * @returns Updated or rebuilt spec object to use in the context of the request
+     */
+    updateSpecFromRequest(spec, requestContext) {
+        if (this.config.openApiSpec.setServersFromRequest) {
+            spec = Object.assign({}, spec);
+            spec.servers = [{ url: requestContext.requestedBaseUrl }];
+        }
+        const basePath = requestContext.basePath;
+        if (spec.servers && basePath) {
+            for (const s of spec.servers) {
+                // Update the default server url to honor `basePath`
+                if (s.url === '/') {
+                    s.url = basePath;
                 }
             }
-            this.sequence(SequenceFromFunction);
-        }
-        /**
-         * Bind a body parser to the server context
-         * @param parserClass - Body parser class
-         * @param address - Optional binding address
-         */
-        bodyParser(bodyParserClass, address) {
-            const binding = createBodyParserBinding(bodyParserClass, address);
-            this.add(binding);
-            return binding;
-        }
-        /**
-         * Configure the `basePath` for the rest server
-         * @param path - Base path
-         */
-        basePath(path = '') {
-            if (this._requestHandler != null) {
-                throw new Error('Base path cannot be set as the request handler has been created');
-            }
-            // Trim leading and trailing `/`
-            path = path.replace(/(^\/)|(\/$)/, '');
-            if (path)
-                path = '/' + path;
-            this._basePath = path;
-            this.config.basePath = path;
         }
-        /**
-         * Start this REST API's HTTP/HTTPS server.
-         */
-        async start() {
-            // Set up the Express app if not done yet
-            this._setupRequestHandlerIfNeeded();
-            // Setup the HTTP handler so that we can verify the configuration
-            // of API spec, controllers and routes at startup time.
-            this._setupHandlerIfNeeded();
-            const port = await this.get(keys_1.RestBindings.PORT);
-            const host = await this.get(keys_1.RestBindings.HOST);
-            const path = await this.get(keys_1.RestBindings.PATH);
-            const protocol = await this.get(keys_1.RestBindings.PROTOCOL);
-            const httpsOptions = await this.get(keys_1.RestBindings.HTTPS_OPTIONS);
-            if (this.config.listenOnStart === false) {
-                debug('RestServer is not listening as listenOnStart flag is set to false.');
-                return;
+        return spec;
+    }
+    /**
+     * Configure a custom sequence class for handling incoming requests.
+     *
+     * @example
+     * ```ts
+     * class MySequence implements SequenceHandler {
+     *   constructor(
+     *     @inject('send) public send: Send)) {
+     *   }
+     *
+     *   public async handle({response}: RequestContext) {
+     *     send(response, 'hello world');
+     *   }
+     * }
+     * ```
+     *
+     * @param value - The sequence to invoke for each incoming request.
+     */
+    sequence(value) {
+        this.bind(keys_1.RestBindings.SEQUENCE).toClass(value);
+    }
+    /**
+     * Configure a custom sequence function for handling incoming requests.
+     *
+     * @example
+     * ```ts
+     * app.handler(({request, response}, sequence) => {
+     *   sequence.send(response, 'hello world');
+     * });
+     * ```
+     *
+     * @param handlerFn - The handler to invoke for each incoming request.
+     */
+    handler(handlerFn) {
+        class SequenceFromFunction extends sequence_1.DefaultSequence {
+            async handle(context) {
+                return handlerFn(context, this);
             }
-            const serverOptions = {};
-            if (protocol === 'https')
-                Object.assign(serverOptions, httpsOptions);
-            Object.assign(serverOptions, { port, host, protocol, path });
-            this._httpServer = new http_server_1.HttpServer(this.requestHandler, serverOptions);
-            await this._httpServer.start();
-            this.bind(keys_1.RestBindings.PORT).to(this._httpServer.port);
-            this.bind(keys_1.RestBindings.HOST).to(this._httpServer.host);
-            this.bind(keys_1.RestBindings.URL).to(this._httpServer.url);
-            debug('RestServer listening at %s', this._httpServer.url);
         }
-        /**
-         * Stop this REST API's HTTP/HTTPS server.
-         */
-        async stop() {
-            // Kill the server instance.
-            if (!this._httpServer)
-                return;
-            await this._httpServer.stop();
-            this._httpServer = undefined;
-        }
-        /**
-         * Mount an Express router to expose additional REST endpoints handled
-         * via legacy Express-based stack.
-         *
-         * @param basePath - Path where to mount the router at, e.g. `/` or `/api`.
-         * @param router - The Express router to handle the requests.
-         * @param 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.
-         */
-        mountExpressRouter(basePath, router, spec) {
-            this._externalRoutes.mountRouter(basePath, router, spec);
-        }
-    };
-    RestServer = tslib_1.__decorate([
-        tslib_1.__param(0, context_1.inject(core_1.CoreBindings.APPLICATION_INSTANCE)),
-        tslib_1.__param(1, context_1.inject(keys_1.RestBindings.CONFIG, { optional: true })),
-        tslib_1.__metadata("design:paramtypes", [core_1.Application, Object])
-    ], RestServer);
-    return RestServer;
-})();
+        this.sequence(SequenceFromFunction);
+    }
+    /**
+     * Bind a body parser to the server context
+     * @param parserClass - Body parser class
+     * @param address - Optional binding address
+     */
+    bodyParser(bodyParserClass, address) {
+        const binding = createBodyParserBinding(bodyParserClass, address);
+        this.add(binding);
+        return binding;
+    }
+    /**
+     * Configure the `basePath` for the rest server
+     * @param path - Base path
+     */
+    basePath(path = '') {
+        if (this._requestHandler != null) {
+            throw new Error('Base path cannot be set as the request handler has been created');
+        }
+        // Trim leading and trailing `/`
+        path = path.replace(/(^\/)|(\/$)/, '');
+        if (path)
+            path = '/' + path;
+        this._basePath = path;
+        this.config.basePath = path;
+    }
+    /**
+     * Start this REST API's HTTP/HTTPS server.
+     */
+    async start() {
+        // Set up the Express app if not done yet
+        this._setupRequestHandlerIfNeeded();
+        // Setup the HTTP handler so that we can verify the configuration
+        // of API spec, controllers and routes at startup time.
+        this._setupHandlerIfNeeded();
+        const port = await this.get(keys_1.RestBindings.PORT);
+        const host = await this.get(keys_1.RestBindings.HOST);
+        const path = await this.get(keys_1.RestBindings.PATH);
+        const protocol = await this.get(keys_1.RestBindings.PROTOCOL);
+        const httpsOptions = await this.get(keys_1.RestBindings.HTTPS_OPTIONS);
+        if (this.config.listenOnStart === false) {
+            debug('RestServer is not listening as listenOnStart flag is set to false.');
+            return;
+        }
+        const serverOptions = {};
+        if (protocol === 'https')
+            Object.assign(serverOptions, httpsOptions);
+        Object.assign(serverOptions, { port, host, protocol, path });
+        this._httpServer = new http_server_1.HttpServer(this.requestHandler, serverOptions);
+        await this._httpServer.start();
+        this.bind(keys_1.RestBindings.PORT).to(this._httpServer.port);
+        this.bind(keys_1.RestBindings.HOST).to(this._httpServer.host);
+        this.bind(keys_1.RestBindings.URL).to(this._httpServer.url);
+        debug('RestServer listening at %s', this._httpServer.url);
+    }
+    /**
+     * Stop this REST API's HTTP/HTTPS server.
+     */
+    async stop() {
+        // Kill the server instance.
+        if (!this._httpServer)
+            return;
+        await this._httpServer.stop();
+        this._httpServer = undefined;
+    }
+    /**
+     * Mount an Express router to expose additional REST endpoints handled
+     * via legacy Express-based stack.
+     *
+     * @param basePath - Path where to mount the router at, e.g. `/` or `/api`.
+     * @param router - The Express router to handle the requests.
+     * @param 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.
+     */
+    mountExpressRouter(basePath, router, spec) {
+        this._externalRoutes.mountRouter(basePath, router, spec);
+    }
+    /**
+     * Export the OpenAPI spec to the given json or yaml file
+     * @param outFile - File name for the spec. The extension of the file
+     * determines the format of the file.
+     * - `yaml` or `yml`: YAML
+     * - `json` or other: JSON
+     * If the outFile is not provided or its value is `''` or `'-'`, the spec is
+     * written to the console using the `log` function.
+     * @param log - Log function, default to `console.log`
+     */
+    async exportOpenApiSpec(outFile = '', log = console.log) {
+        const spec = await this.getApiSpec();
+        if (outFile === '-' || outFile === '') {
+            const json = JSON.stringify(spec, null, 2);
+            log('%s', json);
+            return;
+        }
+        const fileName = outFile.toLowerCase();
+        if (fileName.endsWith('.yaml') || fileName.endsWith('.yml')) {
+            const yaml = js_yaml_1.safeDump(spec);
+            fs_1.default.writeFileSync(outFile, yaml, 'utf-8');
+        }
+        else {
+            const json = JSON.stringify(spec, null, 2);
+            fs_1.default.writeFileSync(outFile, json, 'utf-8');
+        }
+        log('The OpenAPI spec has been saved to %s.', outFile);
+    }
+};
+RestServer = tslib_1.__decorate([
+    tslib_1.__param(0, core_1.inject(core_1.CoreBindings.APPLICATION_INSTANCE)),
+    tslib_1.__param(1, core_1.inject(keys_1.RestBindings.CONFIG, { optional: true })),
+    tslib_1.__metadata("design:paramtypes", [core_1.Application, Object])
+], RestServer);
 exports.RestServer = RestServer;
 /**
  * An assertion type guard for TypeScript to instruct the compiler that the
@@ -689,9 +716,9 @@ function assertExists(val, name) {
  */
 function createBodyParserBinding(parserClass, key) {
     const address = key !== null && key !== void 0 ? key : `${keys_1.RestBindings.REQUEST_BODY_PARSER}.${parserClass.name}`;
-    return context_1.Binding.bind(address)
+    return core_1.Binding.bind(address)
         .toClass(parserClass)
-        .inScope(context_1.BindingScope.TRANSIENT)
+        .inScope(core_1.BindingScope.TRANSIENT)
         .tag(body_parsers_1.REQUEST_BODY_PARSER_TAG);
 }
 exports.createBodyParserBinding = createBodyParserBinding;