tsoa

node_modules/@tsoa/runtime/dist/routeGeneration/templates/express/expressTemplateService.d.ts

@@ -0,0 +1,29 @@
+import { Request as ExRequest, Response as ExResponse, NextFunction as ExNext } from 'express';
+import { Controller } from '../../../interfaces/controller';
+import { TsoaRoute } from '../../tsoa-route';
+import { TemplateService } from '../templateService';
+type ExpressApiHandlerParameters = {
+    methodName: string;
+    controller: Controller | object;
+    response: ExResponse;
+    next: ExNext;
+    validatedArgs: any[];
+    successStatus?: number;
+};
+type ExpressValidationArgsParameters = {
+    args: Record<string, TsoaRoute.ParameterSchema>;
+    request: ExRequest;
+    response: ExResponse;
+};
+type ExpressReturnHandlerParameters = {
+    response: ExResponse;
+    headers: any;
+    statusCode?: number;
+    data?: any;
+};
+export declare class ExpressTemplateService extends TemplateService<ExpressApiHandlerParameters, ExpressValidationArgsParameters, ExpressReturnHandlerParameters> {
+    apiHandler(params: ExpressApiHandlerParameters): Promise<void>;
+    getValidatedArgs(params: ExpressValidationArgsParameters): any[];
+    protected returnHandler(params: ExpressReturnHandlerParameters): void;
+}
+export {};

node_modules/@tsoa/runtime/dist/routeGeneration/templates/express/expressTemplateService.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExpressTemplateService = void 0;
+const templateHelpers_1 = require("../../templateHelpers");
+const templateService_1 = require("../templateService");
+class ExpressTemplateService extends templateService_1.TemplateService {
+    async apiHandler(params) {
+        const { methodName, controller, response, validatedArgs, successStatus, next } = params;
+        try {
+            const data = await this.buildPromise(methodName, controller, validatedArgs);
+            let statusCode = successStatus;
+            let headers;
+            if (this.isController(controller)) {
+                headers = controller.getHeaders();
+                statusCode = controller.getStatus() || statusCode;
+            }
+            this.returnHandler({ response, headers, statusCode, data });
+        }
+        catch (error) {
+            return next(error);
+        }
+    }
+    getValidatedArgs(params) {
+        const { args, request, response } = params;
+        const fieldErrors = {};
+        const values = Object.values(args).map(param => {
+            const name = param.name;
+            switch (param.in) {
+                case 'request':
+                    return request;
+                case 'request-prop': {
+                    const descriptor = Object.getOwnPropertyDescriptor(request, name);
+                    const value = descriptor ? descriptor.value : undefined;
+                    return this.validationService.ValidateParam(param, value, name, fieldErrors, false, undefined);
+                }
+                case 'query':
+                    return this.validationService.ValidateParam(param, request.query[name], name, fieldErrors, false, undefined);
+                case 'queries':
+                    return this.validationService.ValidateParam(param, request.query, name, fieldErrors, false, undefined);
+                case 'path':
+                    return this.validationService.ValidateParam(param, request.params[name], name, fieldErrors, false, undefined);
+                case 'header':
+                    return this.validationService.ValidateParam(param, request.header(name), name, fieldErrors, false, undefined);
+                case 'body': {
+                    const bodyFieldErrors = {};
+                    const bodyArgs = this.validationService.ValidateParam(param, request.body, name, bodyFieldErrors, true, undefined);
+                    Object.keys(bodyFieldErrors).forEach(key => {
+                        fieldErrors[key] = { message: bodyFieldErrors[key].message };
+                    });
+                    return bodyArgs;
+                }
+                case 'body-prop': {
+                    const bodyPropFieldErrors = {};
+                    const bodyPropArgs = this.validationService.ValidateParam(param, request.body?.[name], name, bodyPropFieldErrors, true, 'body.');
+                    Object.keys(bodyPropFieldErrors).forEach(key => {
+                        fieldErrors[key] = { message: bodyPropFieldErrors[key].message };
+                    });
+                    return bodyPropArgs;
+                }
+                case 'formData': {
+                    const files = Object.values(args).filter(p => p.dataType === 'file' || (p.dataType === 'array' && p.array && p.array.dataType === 'file'));
+                    if ((param.dataType === 'file' || (param.dataType === 'array' && param.array && param.array.dataType === 'file')) && files.length > 0) {
+                        const requestFiles = request.files;
+                        const fileArgs = this.validationService.ValidateParam(param, requestFiles?.[name], name, fieldErrors, false, undefined);
+                        if (param.dataType === 'array') {
+                            return fileArgs;
+                        }
+                        return Array.isArray(fileArgs) && fileArgs.length === 1 ? fileArgs[0] : fileArgs;
+                    }
+                    return this.validationService.ValidateParam(param, request.body?.[name], name, fieldErrors, false, undefined);
+                }
+                case 'res':
+                    return (status, data, headers) => {
+                        this.returnHandler({ response, headers, statusCode: status, data });
+                    };
+            }
+        });
+        if (Object.keys(fieldErrors).length > 0) {
+            throw new templateHelpers_1.ValidateError(fieldErrors, '');
+        }
+        return values;
+    }
+    returnHandler(params) {
+        const { response, statusCode, data } = params;
+        let { headers } = params;
+        headers = headers || {};
+        if (response.headersSent) {
+            return;
+        }
+        Object.keys(headers).forEach((name) => {
+            response.set(name, headers[name]);
+        });
+        // Check if the response is marked to be JSON
+        const isJsonResponse = response.get('Content-Type')?.includes('json') || false;
+        if (data && typeof data.pipe === 'function' && data.readable && typeof data._read === 'function') {
+            response.status(statusCode || 200);
+            data.pipe(response);
+        }
+        else if (data !== undefined && (data !== null || isJsonResponse)) {
+            // allow null response when it is a json response
+            if (typeof data === 'number' || isJsonResponse) {
+                // express treats number data as status code so use the json method instead
+                // or if the response was marked as json then use the json so for example strings are quoted
+                response.status(statusCode || 200).json(data);
+            }
+            else {
+                // do not use json for every type since internally the send will invoke json if needed
+                // but for string data it will not quote it, so we can send string as plain/text data
+                response.status(statusCode || 200).send(data);
+            }
+        }
+        else {
+            response.status(statusCode || 204).end();
+        }
+    }
+}
+exports.ExpressTemplateService = ExpressTemplateService;
+//# sourceMappingURL=expressTemplateService.js.map

node_modules/@tsoa/runtime/dist/routeGeneration/templates/hapi/hapiTemplateService.d.ts

@@ -0,0 +1,36 @@
+import { Request as HRequest, ResponseToolkit as HResponse } from '@hapi/hapi';
+import { Controller } from '../../../interfaces/controller';
+import { TsoaRoute } from '../../tsoa-route';
+import { TemplateService } from '../templateService';
+import { AdditionalProps } from '../../additionalProps';
+type HapiApiHandlerParameters = {
+    methodName: string;
+    controller: Controller | object;
+    h: HResponse;
+    validatedArgs: any[];
+    successStatus?: number;
+};
+type HapiValidationArgsParameters = {
+    args: Record<string, TsoaRoute.ParameterSchema>;
+    request: HRequest;
+    h: HResponse;
+};
+type HapiReturnHandlerParameters = {
+    h: HResponse;
+    headers: any;
+    statusCode?: number;
+    data?: any;
+};
+export declare class HapiTemplateService extends TemplateService<HapiApiHandlerParameters, HapiValidationArgsParameters, HapiReturnHandlerParameters> {
+    protected readonly models: TsoaRoute.Models;
+    protected readonly config: AdditionalProps;
+    private readonly hapi;
+    constructor(models: TsoaRoute.Models, config: AdditionalProps, hapi: {
+        boomify: CallableFunction;
+        isBoom: CallableFunction;
+    });
+    apiHandler(params: HapiApiHandlerParameters): Promise<any>;
+    getValidatedArgs(params: HapiValidationArgsParameters): any[];
+    protected returnHandler(params: HapiReturnHandlerParameters): any;
+}
+export {};

node_modules/@tsoa/runtime/dist/routeGeneration/templates/hapi/hapiTemplateService.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HapiTemplateService = void 0;
+const templateHelpers_1 = require("../../templateHelpers");
+const templateService_1 = require("../templateService");
+const hapiTsoaResponsed = Symbol('@tsoa:template_service:hapi:responsed');
+class HapiTemplateService extends templateService_1.TemplateService {
+    constructor(models, config, hapi) {
+        super(models, config);
+        this.models = models;
+        this.config = config;
+        this.hapi = hapi;
+    }
+    async apiHandler(params) {
+        const { methodName, controller, h, validatedArgs, successStatus } = params;
+        try {
+            const data = await this.buildPromise(methodName, controller, validatedArgs);
+            let statusCode = successStatus;
+            let headers;
+            if (this.isController(controller)) {
+                headers = controller.getHeaders();
+                statusCode = controller.getStatus() || statusCode;
+            }
+            return this.returnHandler({ h, headers, statusCode, data });
+        }
+        catch (error) {
+            if (this.hapi.isBoom(error)) {
+                throw error;
+            }
+            const boomErr = this.hapi.boomify(error instanceof Error ? error : new Error(error.message));
+            boomErr.output.statusCode = error.status || 500;
+            boomErr.output.payload = {
+                name: error.name,
+                message: error.message,
+            };
+            throw boomErr;
+        }
+    }
+    getValidatedArgs(params) {
+        const { args, request, h } = params;
+        const errorFields = {};
+        const values = Object.values(args).map(param => {
+            const name = param.name;
+            switch (param.in) {
+                case 'request':
+                    return request;
+                case 'request-prop': {
+                    const descriptor = Object.getOwnPropertyDescriptor(request, name);
+                    const value = descriptor ? descriptor.value : undefined;
+                    return this.validationService.ValidateParam(param, value, name, errorFields, false, undefined);
+                }
+                case 'query':
+                    return this.validationService.ValidateParam(param, request.query[name], name, errorFields, false, undefined);
+                case 'queries':
+                    return this.validationService.ValidateParam(param, request.query, name, errorFields, false, undefined);
+                case 'path':
+                    return this.validationService.ValidateParam(param, request.params[name], name, errorFields, false, undefined);
+                case 'header':
+                    return this.validationService.ValidateParam(param, request.headers[name], name, errorFields, false, undefined);
+                case 'body': {
+                    const bodyFieldErrors = {};
+                    const result = this.validationService.ValidateParam(param, request.payload, name, bodyFieldErrors, true, undefined);
+                    Object.keys(bodyFieldErrors).forEach(key => {
+                        errorFields[key] = { message: bodyFieldErrors[key].message };
+                    });
+                    return result;
+                }
+                case 'body-prop': {
+                    const descriptor = Object.getOwnPropertyDescriptor(request.payload, name);
+                    const value = descriptor ? descriptor.value : undefined;
+                    const bodyFieldErrors = {};
+                    const result = this.validationService.ValidateParam(param, value, name, bodyFieldErrors, true, 'body.');
+                    Object.keys(bodyFieldErrors).forEach(key => {
+                        errorFields[key] = { message: bodyFieldErrors[key].message };
+                    });
+                    return result;
+                }
+                case 'formData': {
+                    const descriptor = Object.getOwnPropertyDescriptor(request.payload, name);
+                    const value = descriptor ? descriptor.value : undefined;
+                    return this.validationService.ValidateParam(param, value, name, errorFields, false, undefined);
+                }
+                case 'res':
+                    return (status, data, headers) => {
+                        this.returnHandler({ h, headers, statusCode: status, data });
+                    };
+            }
+        });
+        if (Object.keys(errorFields).length > 0) {
+            throw new templateHelpers_1.ValidateError(errorFields, '');
+        }
+        return values;
+    }
+    returnHandler(params) {
+        const { h, statusCode, data } = params;
+        let { headers } = params;
+        headers = headers || {};
+        const tsoaResponsed = Object.getOwnPropertyDescriptor(h, hapiTsoaResponsed);
+        if (tsoaResponsed) {
+            return tsoaResponsed.value;
+        }
+        const response = data !== null && data !== undefined ? h.response(data).code(200) : h.response().code(204);
+        Object.keys(headers).forEach((name) => {
+            response.header(name, headers[name]);
+        });
+        if (statusCode) {
+            response.code(statusCode);
+        }
+        Object.defineProperty(h, hapiTsoaResponsed, {
+            value: response,
+            writable: false,
+        });
+        return response;
+    }
+}
+exports.HapiTemplateService = HapiTemplateService;
+//# sourceMappingURL=hapiTemplateService.js.map

node_modules/@tsoa/runtime/dist/routeGeneration/templates/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./templateService";
+export * from "./express/expressTemplateService";
+export * from "./hapi/hapiTemplateService";
+export * from "./koa/koaTemplateService";

node_modules/@tsoa/runtime/dist/routeGeneration/templates/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./templateService"), exports);
+__exportStar(require("./express/expressTemplateService"), exports);
+__exportStar(require("./hapi/hapiTemplateService"), exports);
+__exportStar(require("./koa/koaTemplateService"), exports);
+//# sourceMappingURL=index.js.map

node_modules/@tsoa/runtime/dist/routeGeneration/templates/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/routeGeneration/templates/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,oDAAkC;AAClC,mEAAiD;AACjD,6DAA2C;AAC3C,2DAAyC"}

node_modules/@tsoa/runtime/dist/routeGeneration/templates/koa/koaTemplateService.d.ts

@@ -0,0 +1,29 @@
+import type { Context, Next } from 'koa';
+import { Controller } from '../../../interfaces/controller';
+import { TsoaRoute } from '../../tsoa-route';
+import { TemplateService } from '../templateService';
+type KoaApiHandlerParameters = {
+    methodName: string;
+    controller: Controller | object;
+    context: Context;
+    validatedArgs: any[];
+    successStatus?: number;
+};
+type KoaValidationArgsParameters = {
+    args: Record<string, TsoaRoute.ParameterSchema>;
+    context: Context;
+    next: Next;
+};
+type KoaReturnHandlerParameters = {
+    context: Context;
+    next?: Next;
+    headers: any;
+    statusCode?: number;
+    data?: any;
+};
+export declare class KoaTemplateService extends TemplateService<KoaApiHandlerParameters, KoaValidationArgsParameters, KoaReturnHandlerParameters> {
+    apiHandler(params: KoaApiHandlerParameters): Promise<any>;
+    getValidatedArgs(params: KoaValidationArgsParameters): any[];
+    protected returnHandler(params: KoaReturnHandlerParameters): Promise<any> | Context | undefined;
+}
+export {};

node_modules/@tsoa/runtime/dist/routeGeneration/templates/koa/koaTemplateService.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KoaTemplateService = void 0;
+const templateHelpers_1 = require("../../templateHelpers");
+const templateService_1 = require("../templateService");
+const koaTsoaResponsed = Symbol('@tsoa:template_service:koa:is_responsed');
+class KoaTemplateService extends templateService_1.TemplateService {
+    async apiHandler(params) {
+        const { methodName, controller, context, validatedArgs, successStatus } = params;
+        try {
+            const data = await this.buildPromise(methodName, controller, validatedArgs);
+            let statusCode = successStatus;
+            let headers;
+            if (this.isController(controller)) {
+                headers = controller.getHeaders();
+                statusCode = controller.getStatus() || statusCode;
+            }
+            return this.returnHandler({ context, headers, statusCode, data });
+        }
+        catch (error) {
+            context.status = error.status || 500;
+            context.throw(context.status, error.message, error);
+        }
+    }
+    getValidatedArgs(params) {
+        const { args, context, next } = params;
+        const errorFields = {};
+        const values = Object.values(args).map(param => {
+            const name = param.name;
+            switch (param.in) {
+                case 'request':
+                    return context.request;
+                case 'request-prop': {
+                    const descriptor = Object.getOwnPropertyDescriptor(context.request, name);
+                    const value = descriptor ? descriptor.value : undefined;
+                    return this.validationService.ValidateParam(param, value, name, errorFields, false, undefined);
+                }
+                case 'query':
+                    return this.validationService.ValidateParam(param, context.request.query[name], name, errorFields, false, undefined);
+                case 'queries':
+                    return this.validationService.ValidateParam(param, context.request.query, name, errorFields, false, undefined);
+                case 'path':
+                    return this.validationService.ValidateParam(param, context.params[name], name, errorFields, false, undefined);
+                case 'header':
+                    return this.validationService.ValidateParam(param, context.request.headers[name], name, errorFields, false, undefined);
+                case 'body': {
+                    const descriptor = Object.getOwnPropertyDescriptor(context.request, 'body');
+                    const value = descriptor ? descriptor.value : undefined;
+                    const bodyFieldErrors = {};
+                    const result = this.validationService.ValidateParam(param, value, name, bodyFieldErrors, true, undefined);
+                    Object.keys(bodyFieldErrors).forEach((key) => {
+                        errorFields[key] = { message: bodyFieldErrors[key].message };
+                    });
+                    return result;
+                }
+                case 'body-prop': {
+                    const descriptor = Object.getOwnPropertyDescriptor(context.request, 'body');
+                    const value = descriptor ? descriptor.value[name] : undefined;
+                    const bodyFieldErrors = {};
+                    const result = this.validationService.ValidateParam(param, value, name, bodyFieldErrors, true, 'body.');
+                    Object.keys(bodyFieldErrors).forEach((key) => {
+                        errorFields[key] = { message: bodyFieldErrors[key].message };
+                    });
+                    return result;
+                }
+                case 'formData': {
+                    const files = Object.values(args).filter(p => p.dataType === 'file' || (p.dataType === 'array' && p.array && p.array.dataType === 'file'));
+                    const contextRequest = context.request;
+                    if ((param.dataType === 'file' || (param.dataType === 'array' && param.array && param.array.dataType === 'file')) && files.length > 0) {
+                        const fileArgs = this.validationService.ValidateParam(param, contextRequest.files?.[name], name, errorFields, false, undefined);
+                        if (param.dataType === 'array') {
+                            return fileArgs;
+                        }
+                        return Array.isArray(fileArgs) && fileArgs.length === 1 ? fileArgs[0] : fileArgs;
+                    }
+                    return this.validationService.ValidateParam(param, contextRequest.body?.[name], name, errorFields, false, undefined);
+                }
+                case 'res':
+                    return async (status, data, headers) => {
+                        await this.returnHandler({ context, headers, statusCode: status, data, next });
+                    };
+            }
+        });
+        if (Object.keys(errorFields).length > 0) {
+            throw new templateHelpers_1.ValidateError(errorFields, '');
+        }
+        return values;
+    }
+    returnHandler(params) {
+        const { context, next, statusCode, data } = params;
+        let { headers } = params;
+        headers = headers || {};
+        const isResponsed = Object.getOwnPropertyDescriptor(context.response, koaTsoaResponsed);
+        if (!context.headerSent && !isResponsed) {
+            if (data !== null && data !== undefined) {
+                context.body = data;
+                context.status = 200;
+            }
+            else {
+                context.status = 204;
+            }
+            if (statusCode) {
+                context.status = statusCode;
+            }
+            context.set(headers);
+            Object.defineProperty(context.response, koaTsoaResponsed, {
+                value: true,
+                writable: false,
+            });
+            return next ? next() : context;
+        }
+        return undefined;
+    }
+}
+exports.KoaTemplateService = KoaTemplateService;
+//# sourceMappingURL=koaTemplateService.js.map

node_modules/@tsoa/runtime/dist/routeGeneration/templates/templateService.d.ts

@@ -0,0 +1,15 @@
+import { Controller } from '../../interfaces/controller';
+import { TsoaRoute } from '../tsoa-route';
+import { ValidationService } from '../templateHelpers';
+import { AdditionalProps } from '../additionalProps';
+export declare abstract class TemplateService<ApiHandlerParameters, ValidationArgsParameters, ReturnHandlerParameters> {
+    protected readonly models: TsoaRoute.Models;
+    protected readonly config: AdditionalProps;
+    protected validationService: ValidationService;
+    constructor(models: TsoaRoute.Models, config: AdditionalProps);
+    abstract apiHandler(params: ApiHandlerParameters): Promise<any>;
+    abstract getValidatedArgs(params: ValidationArgsParameters): any[];
+    protected abstract returnHandler(params: ReturnHandlerParameters): any;
+    protected isController(object: Controller | object): object is Controller;
+    protected buildPromise(methodName: string, controller: Controller | object, validatedArgs: any): Promise<PropertyDescriptor>;
+}

node_modules/@tsoa/runtime/dist/routeGeneration/templates/templateService.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TemplateService = void 0;
+const templateHelpers_1 = require("../templateHelpers");
+class TemplateService {
+    constructor(models, config) {
+        this.models = models;
+        this.config = config;
+        this.validationService = new templateHelpers_1.ValidationService(models, config);
+    }
+    isController(object) {
+        return 'getHeaders' in object && 'getStatus' in object && 'setStatus' in object;
+    }
+    buildPromise(methodName, controller, validatedArgs) {
+        const prototype = Object.getPrototypeOf(controller);
+        const descriptor = Object.getOwnPropertyDescriptor(prototype, methodName);
+        return descriptor.value.apply(controller, validatedArgs);
+    }
+}
+exports.TemplateService = TemplateService;
+//# sourceMappingURL=templateService.js.map

node_modules/@tsoa/runtime/dist/routeGeneration/templates/templateService.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"templateService.js","sourceRoot":"","sources":["../../../src/routeGeneration/templates/templateService.ts"],"names":[],"mappings":";;;AAEA,wDAAuD;AAGvD,MAAsB,eAAe;IAGnC,YACqB,MAAwB,EACxB,MAAuB;QADvB,WAAM,GAAN,MAAM,CAAkB;QACxB,WAAM,GAAN,MAAM,CAAiB;QAE1C,IAAI,CAAC,iBAAiB,GAAG,IAAI,mCAAiB,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjE,CAAC;IAQS,YAAY,CAAC,MAA2B;QAChD,OAAO,YAAY,IAAI,MAAM,IAAI,WAAW,IAAI,MAAM,IAAI,WAAW,IAAI,MAAM,CAAC;IAClF,CAAC;IAES,YAAY,CAAC,UAAkB,EAAE,UAA+B,EAAE,aAAkB;QAC5F,MAAM,SAAS,GAAG,MAAM,CAAC,cAAc,CAAC,UAAU,CAAC,CAAC;QACpD,MAAM,UAAU,GAAG,MAAM,CAAC,wBAAwB,CAAC,SAAS,EAAE,UAAU,CAAC,CAAC;QAC1E,OAAQ,UAAW,CAAC,KAA2C,CAAC,KAAK,CAAC,UAAU,EAAE,aAAa,CAAC,CAAC;IACnG,CAAC;CACF;AAzBD,0CAyBC"}