@nmshd/typescript-rest 3.0.5

package/dist/server/model/server-types.js

@@ -0,0 +1,47 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParserType = exports.ReferencedResource = exports.ServiceContext = exports.HttpMethod = void 0;
+/**
+ * The supported HTTP methods.
+ */
+var HttpMethod;
+(function (HttpMethod) {
+    HttpMethod["GET"] = "GET";
+    HttpMethod["POST"] = "POST";
+    HttpMethod["PUT"] = "PUT";
+    HttpMethod["DELETE"] = "DELETE";
+    HttpMethod["HEAD"] = "HEAD";
+    HttpMethod["OPTIONS"] = "OPTIONS";
+    HttpMethod["PATCH"] = "PATCH";
+})(HttpMethod || (exports.HttpMethod = HttpMethod = {}));
+/**
+ * Represents the current context of the request being handled.
+ */
+class ServiceContext {
+}
+exports.ServiceContext = ServiceContext;
+/**
+ * Used to create a reference to a resource.
+ */
+class ReferencedResource {
+    /**
+     * Constructor. Receives the location of the resource.
+     * @param location To be added to the Location header on response
+     * @param statusCode the response status code to be sent
+     */
+    constructor(location, statusCode) {
+        this.location = location;
+        this.statusCode = statusCode;
+    }
+}
+exports.ReferencedResource = ReferencedResource;
+/**
+ * The types of parsers to parse the message body
+ */
+var ParserType;
+(function (ParserType) {
+    ParserType["json"] = "json";
+    ParserType["text"] = "text";
+    ParserType["raw"] = "raw";
+})(ParserType || (exports.ParserType = ParserType = {}));
+//# sourceMappingURL=server-types.js.map

package/dist/server/model/server-types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"server-types.js","sourceRoot":"","sources":["../../../src/server/model/server-types.ts"],"names":[],"mappings":"AAAA,YAAY,CAAC;;;AAwBb;;GAEG;AACH,IAAY,UAQX;AARD,WAAY,UAAU;IAClB,yBAAW,CAAA;IACX,2BAAa,CAAA;IACb,yBAAW,CAAA;IACX,+BAAiB,CAAA;IACjB,2BAAa,CAAA;IACb,iCAAmB,CAAA;IACnB,6BAAe,CAAA;AACnB,CAAC,EARW,UAAU,0BAAV,UAAU,QAQrB;AAED;;GAEG;AACH,MAAa,cAAc;CAsB1B;AAtBD,wCAsBC;AAED;;GAEG;AACH,MAAsB,kBAAkB;IAMpC;;;;OAIG;IACH,YACW,QAAgB,EAChB,UAAkB;QADlB,aAAQ,GAAR,QAAQ,CAAQ;QAChB,eAAU,GAAV,UAAU,CAAQ;IAC1B,CAAC;CACP;AAfD,gDAeC;AAwCD;;GAEG;AACH,IAAY,UAIX;AAJD,WAAY,UAAU;IAClB,2BAAa,CAAA;IACb,2BAAa,CAAA;IACb,yBAAW,CAAA;AACf,CAAC,EAJW,UAAU,0BAAV,UAAU,QAIrB"}

package/dist/server/parameter-processor.d.ts

@@ -0,0 +1,13 @@
+import { ServiceProperty } from './model/metadata';
+import { ServiceContext } from './model/server-types';
+export declare class ParameterProcessor {
+    static get(): ParameterProcessor;
+    private static instance;
+    private static defaultParamConverter;
+    private parameterMapper;
+    private debugger;
+    private constructor();
+    processParameter(context: ServiceContext, property: ServiceProperty): any;
+    private initializeParameterMappers;
+    private convertType;
+}

package/dist/server/parameter-processor.js

@@ -0,0 +1,84 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParameterProcessor = void 0;
+const debug = require("debug");
+const typescript_rest_1 = require("../typescript-rest");
+const metadata_1 = require("./model/metadata");
+const server_container_1 = require("./server-container");
+class ParameterProcessor {
+    static get() {
+        return ParameterProcessor.instance;
+    }
+    constructor() {
+        this.debugger = {
+            build: debug('typescript-rest:parameter-processor:build'),
+            runtime: debug('typescript-rest:parameter-processor:runtime')
+        };
+        this.parameterMapper = this.initializeParameterMappers();
+    }
+    processParameter(context, property) {
+        const processor = this.parameterMapper.get(property.type);
+        if (!processor) {
+            throw new typescript_rest_1.Errors.BadRequestError('Invalid parameter type');
+        }
+        return processor(context, property);
+    }
+    initializeParameterMappers() {
+        this.debugger.build('Initializing parameters processors');
+        const parameterMapper = new Map();
+        parameterMapper.set(metadata_1.ParamType.path, (context, property) => this.convertType(context.request.params[property.name], property.propertyType));
+        parameterMapper.set(metadata_1.ParamType.query, (context, property) => this.convertType(context.request.query[property.name], property.propertyType));
+        parameterMapper.set(metadata_1.ParamType.header, (context, property) => this.convertType(context.request.header(property.name), property.propertyType));
+        parameterMapper.set(metadata_1.ParamType.cookie, (context, property) => this.convertType(context.request.cookies[property.name], property.propertyType));
+        parameterMapper.set(metadata_1.ParamType.body, (context, property) => this.convertType(context.request.body, property.propertyType));
+        parameterMapper.set(metadata_1.ParamType.file, (context, property) => {
+            this.debugger.runtime('Processing file parameter');
+            const files = context.request.files
+                ? // @ts-expect-error will be an array
+                    context.request.files[property.name]
+                : null;
+            if (files && files.length > 0) {
+                return files[0];
+            }
+            return null;
+        });
+        parameterMapper.set(metadata_1.ParamType.files, (context, property) => {
+            var _a;
+            this.debugger.runtime('Processing files parameter');
+            // @ts-expect-error will be an array
+            return (_a = context.request.files) === null || _a === void 0 ? void 0 : _a[property.name];
+        });
+        parameterMapper.set(metadata_1.ParamType.form, (context, property) => this.convertType(context.request.body[property.name], property.propertyType));
+        parameterMapper.set(metadata_1.ParamType.param, (context, property) => {
+            const paramValue = context.request.body[property.name] || context.request.query[property.name];
+            return this.convertType(paramValue, property.propertyType);
+        });
+        parameterMapper.set(metadata_1.ParamType.context, (context) => context);
+        parameterMapper.set(metadata_1.ParamType.context_request, (context) => context.request);
+        parameterMapper.set(metadata_1.ParamType.context_response, (context) => context.response);
+        parameterMapper.set(metadata_1.ParamType.context_next, (context) => context.next);
+        parameterMapper.set(metadata_1.ParamType.context_accept, (context) => context.accept);
+        parameterMapper.set(metadata_1.ParamType.context_accept_language, (context) => context.language);
+        return parameterMapper;
+    }
+    convertType(paramValue, paramType) {
+        const serializedType = paramType['name'];
+        this.debugger.runtime('Processing parameter. received type: %s, received value:', serializedType, paramValue);
+        switch (serializedType) {
+            case 'Number':
+                return paramValue === undefined ? paramValue : parseFloat(paramValue);
+            case 'Boolean':
+                return paramValue === undefined ? paramValue : paramValue === 'true' || paramValue === true;
+            default:
+                let converter = server_container_1.ServerContainer.get().paramConverters.get(paramType);
+                if (!converter) {
+                    converter = ParameterProcessor.defaultParamConverter;
+                }
+                return converter(paramValue);
+        }
+    }
+}
+exports.ParameterProcessor = ParameterProcessor;
+ParameterProcessor.instance = new ParameterProcessor();
+ParameterProcessor.defaultParamConverter = (p) => p;
+//# sourceMappingURL=parameter-processor.js.map

package/dist/server/parameter-processor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parameter-processor.js","sourceRoot":"","sources":["../../src/server/parameter-processor.ts"],"names":[],"mappings":"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"}

package/dist/server/server-container.d.ts

@@ -0,0 +1,55 @@
+import * as express from 'express';
+import { ServiceClass, ServiceMethod } from './model/metadata';
+import { FileLimits, HttpMethod, ParameterConverter, ServiceAuthenticator, ServiceFactory } from './model/server-types';
+export declare class DefaultServiceFactory implements ServiceFactory {
+    create(serviceClass: any): any;
+    getTargetClass(serviceClass: Function): FunctionConstructor;
+}
+export declare class ServerContainer {
+    static get(): ServerContainer;
+    private static instance;
+    cookiesSecret: string;
+    cookiesDecoder: (val: string) => string;
+    fileDest: string;
+    fileFilter: (req: Express.Request, file: Express.Multer.File, callback: (error: Error, acceptFile: boolean) => void) => void;
+    fileLimits: FileLimits;
+    ignoreNextMiddlewares: boolean;
+    authenticator: Map<string, ServiceAuthenticator>;
+    serviceFactory: ServiceFactory;
+    paramConverters: Map<Function, ParameterConverter>;
+    router: express.Router;
+    private debugger;
+    private upload;
+    private serverClasses;
+    private paths;
+    private pathsResolved;
+    private constructor();
+    registerServiceClass(target: Function): ServiceClass;
+    registerServiceMethod(target: Function, methodName: string): ServiceMethod;
+    getPaths(): Set<string>;
+    getHttpMethods(path: string): Set<HttpMethod>;
+    buildServices(types?: Array<Function>): void;
+    private inheritParentClass;
+    private buildService;
+    private resolveAllPaths;
+    private getServiceClass;
+    private resolveProperties;
+    private resolveLanguages;
+    private resolveAccepts;
+    private resolvePath;
+    private validateTargetType;
+    private handleNotAllowedMethods;
+    private getUploader;
+    private buildServiceMiddleware;
+    private buildSecurityMiddlewares;
+    private getAuthenticator;
+    private buildAuthMiddleware;
+    private buildParserMiddlewares;
+    private buildBodyParserMiddleware;
+    private buildFilesParserMiddleware;
+    private buildFormParserMiddleware;
+    private buildJsonBodyParserMiddleware;
+    private buildTextBodyParserMiddleware;
+    private buildRawBodyParserMiddleware;
+    private buildCookieParserMiddleware;
+}

package/dist/server/server-container.js

@@ -0,0 +1,432 @@
+/* eslint-disable prefer-spread */
+'use strict';
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServerContainer = exports.DefaultServiceFactory = void 0;
+const bodyParser = require("body-parser");
+const cookieParser = require("cookie-parser");
+const debug = require("debug");
+const _ = require("lodash");
+const multer = require("multer");
+const Errors = require("./model/errors");
+const metadata_1 = require("./model/metadata");
+const server_types_1 = require("./model/server-types");
+const service_invoker_1 = require("./service-invoker");
+class DefaultServiceFactory {
+    create(serviceClass) {
+        return new serviceClass();
+    }
+    getTargetClass(serviceClass) {
+        return serviceClass;
+    }
+}
+exports.DefaultServiceFactory = DefaultServiceFactory;
+class ServerContainer {
+    static get() {
+        return ServerContainer.instance;
+    }
+    constructor() {
+        this.ignoreNextMiddlewares = false;
+        this.authenticator = new Map();
+        this.serviceFactory = new DefaultServiceFactory();
+        this.paramConverters = new Map();
+        this.debugger = {
+            build: debug('typescript-rest:server-container:build'),
+            runtime: debug('typescript-rest:server-container:runtime')
+        };
+        this.serverClasses = new Map();
+        this.paths = new Map();
+        this.pathsResolved = false;
+        // noop, make the constructor private
+    }
+    registerServiceClass(target) {
+        this.pathsResolved = false;
+        target = this.serviceFactory.getTargetClass(target);
+        if (!this.serverClasses.has(target)) {
+            this.debugger.build('Registering a new service class, %o', target);
+            this.serverClasses.set(target, new metadata_1.ServiceClass(target));
+            this.inheritParentClass(target);
+        }
+        const serviceClass = this.serverClasses.get(target);
+        return serviceClass;
+    }
+    registerServiceMethod(target, methodName) {
+        if (methodName) {
+            this.pathsResolved = false;
+            const classData = this.registerServiceClass(target);
+            if (!classData.methods.has(methodName)) {
+                this.debugger.build('Registering the rest method <%s> for the service class, %o', methodName, target);
+                classData.methods.set(methodName, new metadata_1.ServiceMethod());
+            }
+            const serviceMethod = classData.methods.get(methodName);
+            return serviceMethod;
+        }
+        return null;
+    }
+    getPaths() {
+        this.resolveAllPaths();
+        const result = new Set();
+        this.paths.forEach((value, key) => {
+            result.add(key);
+        });
+        return result;
+    }
+    getHttpMethods(path) {
+        this.resolveAllPaths();
+        const methods = this.paths.get(path);
+        return methods || new Set();
+    }
+    buildServices(types) {
+        if (types) {
+            types = types.map((type) => this.serviceFactory.getTargetClass(type));
+        }
+        this.debugger.build('Creating service endpoints for types: %o', types);
+        if (this.authenticator) {
+            this.authenticator.forEach((auth, name) => {
+                this.debugger.build('Initializing authenticator: %s', name);
+                auth.initialize(this.router);
+            });
+        }
+        this.serverClasses.forEach((classData) => {
+            if (!classData.isAbstract) {
+                classData.methods.forEach((method) => {
+                    if (this.validateTargetType(classData.targetClass, types)) {
+                        this.buildService(classData, method);
+                    }
+                });
+            }
+        });
+        this.pathsResolved = true;
+        this.handleNotAllowedMethods();
+    }
+    inheritParentClass(target) {
+        const classData = this.serverClasses.get(target);
+        const parent = Object.getPrototypeOf(classData.targetClass.prototype).constructor;
+        const parentClassData = this.getServiceClass(parent);
+        if (parentClassData) {
+            if (parentClassData.methods) {
+                parentClassData.methods.forEach((value, key) => {
+                    classData.methods.set(key, _.cloneDeep(value));
+                });
+            }
+            if (parentClassData.properties) {
+                parentClassData.properties.forEach((value, key) => {
+                    classData.properties.set(key, _.cloneDeep(value));
+                });
+            }
+            if (parentClassData.languages) {
+                classData.languages = _.union(classData.languages, parentClassData.languages);
+            }
+            if (parentClassData.accepts) {
+                classData.accepts = _.union(classData.accepts, parentClassData.accepts);
+            }
+        }
+        this.debugger.build('Service class registered with the given metadata: %o', classData);
+    }
+    buildService(serviceClass, serviceMethod) {
+        this.debugger.build('Creating service endpoint for method: %o', serviceMethod);
+        if (!serviceMethod.resolvedPath) {
+            this.resolveProperties(serviceClass, serviceMethod);
+        }
+        let args = [serviceMethod.resolvedPath];
+        args = args.concat(this.buildSecurityMiddlewares(serviceClass, serviceMethod));
+        args = args.concat(this.buildParserMiddlewares(serviceClass, serviceMethod));
+        args.push(this.buildServiceMiddleware(serviceMethod, serviceClass));
+        switch (serviceMethod.httpMethod) {
+            case server_types_1.HttpMethod.GET:
+                this.router.get.apply(this.router, args);
+                break;
+            case server_types_1.HttpMethod.POST:
+                this.router.post.apply(this.router, args);
+                break;
+            case server_types_1.HttpMethod.PUT:
+                this.router.put.apply(this.router, args);
+                break;
+            case server_types_1.HttpMethod.DELETE:
+                this.router.delete.apply(this.router, args);
+                break;
+            case server_types_1.HttpMethod.HEAD:
+                this.router.head.apply(this.router, args);
+                break;
+            case server_types_1.HttpMethod.OPTIONS:
+                this.router.options.apply(this.router, args);
+                break;
+            case server_types_1.HttpMethod.PATCH:
+                this.router.patch.apply(this.router, args);
+                break;
+            default:
+                throw Error(`Invalid http method for service [${serviceMethod.resolvedPath}]`);
+        }
+    }
+    resolveAllPaths() {
+        if (!this.pathsResolved) {
+            this.debugger.build('Building the server list of paths');
+            this.paths.clear();
+            this.serverClasses.forEach((classData) => {
+                classData.methods.forEach((method) => {
+                    if (!method.resolvedPath) {
+                        this.resolveProperties(classData, method);
+                    }
+                });
+            });
+            this.pathsResolved = true;
+        }
+    }
+    getServiceClass(target) {
+        target = this.serviceFactory.getTargetClass(target);
+        return this.serverClasses.get(target) || null;
+    }
+    resolveProperties(serviceClass, serviceMethod) {
+        this.resolveLanguages(serviceClass, serviceMethod);
+        this.resolveAccepts(serviceClass, serviceMethod);
+        this.resolvePath(serviceClass, serviceMethod);
+    }
+    resolveLanguages(serviceClass, serviceMethod) {
+        this.debugger.build('Resolving the list of acceptable languages for method %s', serviceMethod.name);
+        const resolvedLanguages = _.union(serviceClass.languages, serviceMethod.languages);
+        if (resolvedLanguages.length > 0) {
+            serviceMethod.resolvedLanguages = resolvedLanguages;
+        }
+    }
+    resolveAccepts(serviceClass, serviceMethod) {
+        this.debugger.build('Resolving the list of acceptable types for method %s', serviceMethod.name);
+        const resolvedAccepts = _.union(serviceClass.accepts, serviceMethod.accepts);
+        if (resolvedAccepts.length > 0) {
+            serviceMethod.resolvedAccepts = resolvedAccepts;
+        }
+    }
+    resolvePath(serviceClass, serviceMethod) {
+        this.debugger.build('Resolving the path for method %s', serviceMethod.name);
+        const classPath = serviceClass.path ? serviceClass.path.trim() : '';
+        let resolvedPath = _.startsWith(classPath, '/') ? classPath : '/' + classPath;
+        if (_.endsWith(resolvedPath, '/')) {
+            resolvedPath = resolvedPath.slice(0, resolvedPath.length - 1);
+        }
+        if (serviceMethod.path) {
+            const methodPath = serviceMethod.path.trim();
+            resolvedPath = resolvedPath + (_.startsWith(methodPath, '/') ? methodPath : '/' + methodPath);
+        }
+        let declaredHttpMethods = this.paths.get(resolvedPath);
+        if (!declaredHttpMethods) {
+            declaredHttpMethods = new Set();
+            this.paths.set(resolvedPath, declaredHttpMethods);
+        }
+        if (declaredHttpMethods.has(serviceMethod.httpMethod)) {
+            throw Error(`Duplicated declaration for path [${resolvedPath}], method [${serviceMethod.httpMethod}].`);
+        }
+        declaredHttpMethods.add(serviceMethod.httpMethod);
+        serviceMethod.resolvedPath = resolvedPath;
+    }
+    validateTargetType(targetClass, types) {
+        if (types && types.length > 0) {
+            return types.indexOf(targetClass) > -1;
+        }
+        return true;
+    }
+    handleNotAllowedMethods() {
+        this.debugger.build('Creating middleware to handle not allowed methods');
+        const paths = this.getPaths();
+        paths.forEach((path) => {
+            const supported = this.getHttpMethods(path);
+            const allowedMethods = new Array();
+            supported.forEach((method) => {
+                allowedMethods.push(server_types_1.HttpMethod[method]);
+            });
+            const allowed = allowedMethods.join(', ');
+            this.debugger.build('Registering middleware to validate allowed HTTP methods for path %s.', path);
+            this.debugger.build('Allowed HTTP methods [%s].', allowed);
+            this.router.all(path, (req, res, next) => {
+                if (res.headersSent || allowedMethods.indexOf(req.method) > -1) {
+                    next();
+                }
+                else {
+                    res.set('Allow', allowed);
+                    throw new Errors.MethodNotAllowedError();
+                }
+            });
+        });
+    }
+    getUploader() {
+        if (!this.upload) {
+            const options = {};
+            if (this.fileDest) {
+                options.dest = this.fileDest;
+            }
+            if (this.fileFilter) {
+                options.fileFilter = this.fileFilter;
+            }
+            if (this.fileLimits) {
+                options.limits = this.fileLimits;
+            }
+            if (options.dest) {
+                this.debugger.build('Creating a file Uploader with options: %o.', options);
+                this.upload = multer(options);
+            }
+            else {
+                this.debugger.build('Creating a file Uploader with the default options.');
+                this.upload = multer();
+            }
+        }
+        return this.upload;
+    }
+    buildServiceMiddleware(serviceMethod, serviceClass) {
+        const serviceInvoker = new service_invoker_1.ServiceInvoker(serviceClass, serviceMethod);
+        this.debugger.build('Creating the service middleware for method <%s>.', serviceMethod.name);
+        return (req, res, next) => __awaiter(this, void 0, void 0, function* () {
+            const context = new server_types_1.ServiceContext();
+            context.request = req;
+            context.response = res;
+            context.next = next;
+            yield serviceInvoker.callService(context);
+        });
+    }
+    buildSecurityMiddlewares(serviceClass, serviceMethod) {
+        const result = new Array();
+        const authenticatorMap = serviceMethod.authenticator || serviceClass.authenticator;
+        if (this.authenticator && authenticatorMap) {
+            const authenticatorNames = Object.keys(authenticatorMap);
+            for (const authenticatorName of authenticatorNames) {
+                let roles = authenticatorMap[authenticatorName];
+                this.debugger.build('Registering an authenticator middleware <%s> for method <%s>.', authenticatorName, serviceMethod.name);
+                const authenticator = this.getAuthenticator(authenticatorName);
+                result.push(authenticator.getMiddleware());
+                roles = roles.filter((role) => role !== '*');
+                if (roles.length) {
+                    this.debugger.build('Registering a role validator middleware <%s> for method <%s>.', authenticatorName, serviceMethod.name);
+                    this.debugger.build('Roles: <%j>.', roles);
+                    result.push(this.buildAuthMiddleware(authenticator, roles));
+                }
+            }
+        }
+        return result;
+    }
+    getAuthenticator(authenticatorName) {
+        if (!this.authenticator.has(authenticatorName)) {
+            throw new Error(`Invalid authenticator name ${authenticatorName}`);
+        }
+        return this.authenticator.get(authenticatorName);
+    }
+    buildAuthMiddleware(authenticator, roles) {
+        return (req, res, next) => {
+            const requestRoles = authenticator.getRoles(req, res);
+            if (this.debugger.runtime.enabled) {
+                this.debugger.runtime('Validating authentication roles: <%j>.', requestRoles);
+            }
+            if (requestRoles.some((role) => roles.indexOf(role) >= 0)) {
+                next();
+            }
+            else {
+                throw new Errors.ForbiddenError();
+            }
+        };
+    }
+    buildParserMiddlewares(serviceClass, serviceMethod) {
+        const result = new Array();
+        const bodyParserOptions = serviceMethod.bodyParserOptions || serviceClass.bodyParserOptions;
+        if (serviceMethod.mustParseCookies) {
+            this.debugger.build('Registering cookie parser middleware for method <%s>.', serviceMethod.name);
+            result.push(this.buildCookieParserMiddleware());
+        }
+        if (serviceMethod.mustParseBody) {
+            const bodyParserType = serviceMethod.bodyParserType || serviceClass.bodyParserType || server_types_1.ParserType.json;
+            this.debugger.build('Registering body %s parser middleware for method <%s>' + ' with options: %j.', server_types_1.ParserType[bodyParserType], serviceMethod.name, bodyParserOptions);
+            result.push(this.buildBodyParserMiddleware(serviceMethod, bodyParserOptions, bodyParserType));
+        }
+        if (serviceMethod.mustParseForms || serviceMethod.acceptMultiTypedParam) {
+            this.debugger.build('Registering body form parser middleware for method <%s>' + ' with options: %j.', serviceMethod.name, bodyParserOptions);
+            result.push(this.buildFormParserMiddleware(bodyParserOptions));
+        }
+        if (serviceMethod.files.length > 0) {
+            this.debugger.build('Registering file parser middleware for method <%s>.', serviceMethod.name);
+            result.push(this.buildFilesParserMiddleware(serviceMethod));
+        }
+        return result;
+    }
+    buildBodyParserMiddleware(serviceMethod, bodyParserOptions, bodyParserType) {
+        switch (bodyParserType) {
+            case server_types_1.ParserType.text:
+                return this.buildTextBodyParserMiddleware(bodyParserOptions);
+            case server_types_1.ParserType.raw:
+                return this.buildRawBodyParserMiddleware(bodyParserOptions);
+            default:
+                return this.buildJsonBodyParserMiddleware(bodyParserOptions);
+        }
+    }
+    buildFilesParserMiddleware(serviceMethod) {
+        const options = new Array();
+        serviceMethod.files.forEach((fileData) => {
+            if (fileData.singleFile) {
+                options.push({ name: fileData.name, maxCount: 1 });
+            }
+            else {
+                options.push({ name: fileData.name });
+            }
+        });
+        this.debugger.build('Creating file parser with options %j.', options);
+        return this.getUploader().fields(options);
+    }
+    buildFormParserMiddleware(bodyParserOptions) {
+        if (!bodyParserOptions) {
+            bodyParserOptions = { extended: true };
+        }
+        this.debugger.build('Creating form body parser with options %j.', bodyParserOptions);
+        const middleware = bodyParser.urlencoded(bodyParserOptions);
+        return middleware;
+    }
+    buildJsonBodyParserMiddleware(bodyParserOptions) {
+        let middleware;
+        this.debugger.build('Creating json body parser with options %j.', bodyParserOptions || {});
+        if (bodyParserOptions) {
+            middleware = bodyParser.json(bodyParserOptions);
+        }
+        else {
+            middleware = bodyParser.json();
+        }
+        return middleware;
+    }
+    buildTextBodyParserMiddleware(bodyParserOptions) {
+        let middleware;
+        this.debugger.build('Creating text body parser with options %j.', bodyParserOptions || {});
+        if (bodyParserOptions) {
+            middleware = bodyParser.text(bodyParserOptions);
+        }
+        else {
+            middleware = bodyParser.text();
+        }
+        return middleware;
+    }
+    buildRawBodyParserMiddleware(bodyParserOptions) {
+        let middleware;
+        this.debugger.build('Creating raw body parser with options %j.', bodyParserOptions || {});
+        if (bodyParserOptions) {
+            middleware = bodyParser.raw(bodyParserOptions);
+        }
+        else {
+            middleware = bodyParser.raw();
+        }
+        return middleware;
+    }
+    buildCookieParserMiddleware() {
+        const args = [];
+        if (this.cookiesSecret) {
+            args.push(this.cookiesSecret);
+        }
+        if (this.cookiesDecoder) {
+            args.push({ decode: this.cookiesDecoder });
+        }
+        this.debugger.build('Creating cookie parser with options %j.', args);
+        const middleware = cookieParser.apply(this, args);
+        return middleware;
+    }
+}
+exports.ServerContainer = ServerContainer;
+ServerContainer.instance = new ServerContainer();
+//# sourceMappingURL=server-container.js.map