@tsoa-next/runtime 7.1.0

package/dist/metadataGeneration/tsoa.d.ts

@@ -0,0 +1,219 @@
+import { ExtensionType } from '../decorators/extension';
+import type { Swagger } from '../swagger/swagger';
+import { Validator } from '..';
+export declare namespace Tsoa {
+    export interface Metadata {
+        controllers: Controller[];
+        referenceTypeMap: ReferenceTypeMap;
+    }
+    export interface Controller {
+        location: string;
+        methods: Method[];
+        name: string;
+        path: string;
+        produces?: string[];
+    }
+    export interface Method {
+        extensions: Extension[];
+        deprecated?: boolean;
+        description?: string;
+        method: 'get' | 'post' | 'put' | 'delete' | 'options' | 'head' | 'patch';
+        name: string;
+        parameters: Parameter[];
+        path: string;
+        produces?: string[];
+        consumes?: string;
+        type: Type;
+        tags?: string[];
+        responses: Response[];
+        successStatus?: number;
+        security: Security[];
+        summary?: string;
+        isHidden: boolean;
+        operationId?: string;
+    }
+    export interface Parameter {
+        parameterName: string;
+        example?: Array<{
+            [exampleName: string]: Swagger.Example3;
+        }>;
+        description?: string;
+        in: 'query' | 'queries' | 'header' | 'path' | 'formData' | 'body' | 'body-prop' | 'request' | 'request-prop' | 'res';
+        name: string;
+        required?: boolean;
+        type: Type;
+        default?: unknown;
+        validators: Validators;
+        deprecated: boolean;
+        exampleLabels?: Array<string | undefined>;
+        title?: string;
+        $ref?: Swagger.BaseSchema;
+    }
+    export interface ResParameter extends Response, Parameter {
+        in: 'res';
+        description: string;
+    }
+    export interface ArrayParameter extends Parameter {
+        type: ArrayType;
+        collectionFormat?: 'csv' | 'multi' | 'pipes' | 'ssv' | 'tsv';
+    }
+    type AllKeys<T> = T extends any ? keyof T : never;
+    export type ValidatorKey = AllKeys<Validator>;
+    export type SchemaValidatorKey = Exclude<ValidatorKey, `is${string}` | 'minDate' | 'maxDate'>;
+    export type Validators = Partial<Record<ValidatorKey, {
+        value?: unknown;
+        errorMsg?: string;
+    }>>;
+    export interface Security {
+        [key: string]: string[];
+    }
+    export interface Extension {
+        key: `x-${string}`;
+        value: ExtensionType | ExtensionType[];
+    }
+    export interface Response {
+        description: string;
+        name: string;
+        produces?: string[];
+        schema?: Type;
+        examples?: Array<{
+            [exampleName: string]: Swagger.Example3;
+        }>;
+        exampleLabels?: Array<string | undefined>;
+        headers?: HeaderType;
+    }
+    export interface Property {
+        default?: unknown;
+        description?: string;
+        format?: string;
+        example?: unknown;
+        name: string;
+        type: Type;
+        required: boolean;
+        validators: Validators;
+        deprecated: boolean;
+        extensions?: Extension[];
+        title?: string;
+    }
+    export type TypeStringLiteral = 'string' | 'boolean' | 'double' | 'float' | 'file' | 'integer' | 'long' | 'enum' | 'array' | 'datetime' | 'date' | 'binary' | 'buffer' | 'byte' | 'void' | 'object' | 'any' | 'refEnum' | 'refObject' | 'refAlias' | 'nestedObjectLiteral' | 'union' | 'intersection' | 'undefined' | 'tuple';
+    export type RefTypeLiteral = 'refObject' | 'refEnum' | 'refAlias';
+    export type PrimitiveTypeLiteral = Exclude<TypeStringLiteral, RefTypeLiteral | 'enum' | 'array' | 'void' | 'undefined' | 'nestedObjectLiteral' | 'union' | 'intersection' | 'tuple'>;
+    export interface TypeBase {
+        dataType: TypeStringLiteral;
+    }
+    export type PrimitiveType = StringType | BooleanType | DoubleType | FloatType | IntegerType | LongType | VoidType | UndefinedType;
+    /**
+     * This is one of the possible objects that tsoa creates that helps the code store information about the type it found in the code.
+     */
+    export type Type = PrimitiveType | ObjectsNoPropsType | EnumType | ArrayType | FileType | DateTimeType | DateType | BinaryType | BufferType | ByteType | AnyType | RefEnumType | RefObjectType | RefAliasType | NestedObjectLiteralType | UnionType | IntersectionType | TupleType;
+    export interface StringType extends TypeBase {
+        dataType: 'string';
+    }
+    export interface BooleanType extends TypeBase {
+        dataType: 'boolean';
+    }
+    /**
+     * This is the type that occurs when a developer writes `const foo: object = {}` since it can no longer have any properties added to it.
+     */
+    export interface ObjectsNoPropsType extends TypeBase {
+        dataType: 'object';
+    }
+    export interface DoubleType extends TypeBase {
+        dataType: 'double';
+    }
+    export interface FloatType extends TypeBase {
+        dataType: 'float';
+    }
+    export interface IntegerType extends TypeBase {
+        dataType: 'integer';
+    }
+    export interface LongType extends TypeBase {
+        dataType: 'long';
+    }
+    /**
+     * Not to be confused with `RefEnumType` which is a reusable enum which has a $ref name generated for it. This however, is an inline enum.
+     */
+    export interface EnumType extends TypeBase {
+        dataType: 'enum';
+        enums: Array<string | number | boolean | null>;
+    }
+    export interface ArrayType extends TypeBase {
+        dataType: 'array';
+        elementType: Type;
+    }
+    export interface DateType extends TypeBase {
+        dataType: 'date';
+    }
+    export interface FileType extends TypeBase {
+        dataType: 'file';
+    }
+    export interface DateTimeType extends TypeBase {
+        dataType: 'datetime';
+    }
+    export interface BinaryType extends TypeBase {
+        dataType: 'binary';
+    }
+    export interface BufferType extends TypeBase {
+        dataType: 'buffer';
+    }
+    export interface ByteType extends TypeBase {
+        dataType: 'byte';
+    }
+    export interface VoidType extends TypeBase {
+        dataType: 'void';
+    }
+    export interface UndefinedType extends TypeBase {
+        dataType: 'undefined';
+    }
+    export interface AnyType extends TypeBase {
+        dataType: 'any';
+    }
+    export interface NestedObjectLiteralType extends TypeBase {
+        dataType: 'nestedObjectLiteral';
+        properties: Property[];
+        additionalProperties?: Type;
+    }
+    export interface RefEnumType extends ReferenceTypeBase {
+        dataType: 'refEnum';
+        enums: Array<string | number>;
+        enumVarnames?: string[];
+    }
+    export interface RefObjectType extends ReferenceTypeBase {
+        dataType: 'refObject';
+        properties: Property[];
+        additionalProperties?: Type;
+    }
+    export interface RefAliasType extends Omit<Property, 'name' | 'required'>, ReferenceTypeBase {
+        dataType: 'refAlias';
+    }
+    export type ReferenceType = RefEnumType | RefObjectType | RefAliasType;
+    export interface ReferenceTypeBase extends TypeBase {
+        description?: string;
+        dataType: RefTypeLiteral;
+        refName: string;
+        example?: unknown;
+        deprecated: boolean;
+        title?: string;
+    }
+    export interface UnionType extends TypeBase {
+        dataType: 'union';
+        types: Type[];
+    }
+    export interface IntersectionType extends TypeBase {
+        dataType: 'intersection';
+        types: Type[];
+    }
+    export interface TupleType extends TypeBase {
+        dataType: 'tuple';
+        types: Type[];
+        restType?: Type;
+    }
+    export interface ReferenceTypeMap {
+        [refName: string]: Tsoa.ReferenceType;
+    }
+    export interface MethodsSignatureMap {
+        [signature: string]: string[];
+    }
+    export type HeaderType = Tsoa.NestedObjectLiteralType | Tsoa.RefObjectType;
+    export {};
+}

package/dist/metadataGeneration/tsoa.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=tsoa.js.map

package/dist/metadataGeneration/tsoa.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tsoa.js","sourceRoot":"","sources":["../../src/metadataGeneration/tsoa.ts"],"names":[],"mappings":""}

package/dist/routeGeneration/additionalProps.d.ts

@@ -0,0 +1,6 @@
+import { Config, RoutesConfig } from '../config';
+export interface AdditionalProps {
+    noImplicitAdditionalProperties: Exclude<Config['noImplicitAdditionalProperties'], undefined>;
+    bodyCoercion: Exclude<RoutesConfig['bodyCoercion'], undefined>;
+    maxValidationErrorSize?: number;
+}

package/dist/routeGeneration/additionalProps.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=additionalProps.js.map

package/dist/routeGeneration/additionalProps.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"additionalProps.js","sourceRoot":"","sources":["../../src/routeGeneration/additionalProps.ts"],"names":[],"mappings":""}

package/dist/routeGeneration/templateHelpers.d.ts

@@ -0,0 +1,203 @@
+import { AdditionalProps } from './additionalProps';
+import { TsoaRoute } from './tsoa-route';
+export declare function ValidateParam(property: TsoaRoute.PropertySchema, value: any, generatedModels: TsoaRoute.Models, name: string | undefined, fieldErrors: FieldErrors, isBodyParam: boolean, parent: string | undefined, config: AdditionalProps): any;
+export declare class ValidationService {
+    private readonly models;
+    private readonly config;
+    private validationStack;
+    constructor(models: TsoaRoute.Models, config: AdditionalProps);
+    ValidateParam(property: TsoaRoute.PropertySchema, rawValue: any, name: string | undefined, fieldErrors: FieldErrors, isBodyParam: boolean, parent?: string): any;
+    hasCorrectJsType(value: any, type: 'object' | 'boolean' | 'number' | 'string', isBodyParam: boolean): boolean;
+    validateNestedObjectLiteral(name: string, value: any, fieldErrors: FieldErrors, isBodyParam: boolean, nestedProperties: {
+        [name: string]: TsoaRoute.PropertySchema;
+    } | undefined, additionalProperties: TsoaRoute.PropertySchema | boolean | undefined, parent: string): any;
+    validateInt(name: string, value: any, fieldErrors: FieldErrors, isBodyParam: boolean, validators?: IntegerValidator, parent?: string): number | undefined;
+    validateFloat(name: string, value: any, fieldErrors: FieldErrors, isBodyParam: boolean, validators?: FloatValidator, parent?: string): number | undefined;
+    validateEnum(name: string, value: unknown, fieldErrors: FieldErrors, members?: Array<string | number | boolean | null>, parent?: string): unknown;
+    validateDate(name: string, value: any, fieldErrors: FieldErrors, isBodyParam: boolean, validators?: DateValidator, parent?: string): Date | undefined;
+    validateDateTime(name: string, value: any, fieldErrors: FieldErrors, isBodyParam: boolean, validators?: DateTimeValidator, parent?: string): Date | undefined;
+    validateString(name: string, value: any, fieldErrors: FieldErrors, validators?: StringValidator, parent?: string): string | undefined;
+    validateBool(name: string, value: any, fieldErrors: FieldErrors, isBodyParam: boolean, validators?: BooleanValidator, parent?: string): any;
+    validateUndefined(name: string, value: any, fieldErrors: FieldErrors, parent?: string): undefined;
+    validateArray(name: string, value: any[], fieldErrors: FieldErrors, isBodyParam: boolean, schema?: TsoaRoute.PropertySchema, validators?: ArrayValidator, parent?: string): any[] | undefined;
+    validateBuffer(_name: string, value: string): Buffer<ArrayBuffer>;
+    validateUnion(name: string, value: any, fieldErrors: FieldErrors, isBodyParam: boolean, property: TsoaRoute.PropertySchema, parent?: string): any;
+    validateIntersection(name: string, value: any, fieldErrors: FieldErrors, isBodyParam: boolean, subSchemas: TsoaRoute.PropertySchema[] | undefined, parent?: string): any;
+    private toModelLike;
+    /**
+     * combine all schemas once, ignoring order ie
+     * input: [[value1], [value2]] should be [[value1, value2]]
+     * not [[value1, value2],[value2, value1]]
+     * and
+     * input: [[value1, value2], [value3, value4], [value5, value6]] should be [
+     *   [value1, value3, value5],
+     *   [value1, value3, value6],
+     *   [value1, value4, value5],
+     *   [value1, value4, value6],
+     *   [value2, value3, value5],
+     *   [value2, value3, value6],
+     *   [value2, value4, value5],
+     *   [value2, value4, value6],
+     * ]
+     * @param modelSchemass
+     */
+    private selfIntersectionCombinations;
+    private getAllCombinations;
+    private combineProperties;
+    private getExcessPropertiesFor;
+    validateModel(input: {
+        name: string;
+        value: any;
+        modelDefinition: TsoaRoute.ModelSchema;
+        fieldErrors: FieldErrors;
+        isBodyParam: boolean;
+        parent?: string;
+    }): any;
+    /**
+     * Creates a new ValidationService instance with specific configuration
+     * @param overrides Configuration overrides
+     * @returns New ValidationService instance
+     */
+    private createChildValidationService;
+    /**
+     * Deep clones an object without using JSON.stringify/parse to avoid:
+     * 1. Loss of undefined values
+     * 2. Loss of functions
+     * 3. Conversion of dates to strings
+     * 4. Exponential escaping issues with nested objects
+     */
+    private deepClone;
+    /**
+     * Adds a summarized error to the fieldErrors object
+     * @param fieldErrors The errors object to add to
+     * @param errorKey The key for the error
+     * @param prefix The error message prefix
+     * @param subErrors Array of sub-errors to summarize
+     * @param value The value that failed validation
+     */
+    private addSummarizedError;
+    /**
+     * Summarizes validation errors to prevent extremely large error messages
+     * @param errors Array of field errors from union/intersection validation
+     * @param maxLength Maximum length of the summarized message
+     * @returns Summarized error message
+     */
+    private summarizeValidationErrors;
+}
+export interface IntegerValidator {
+    isInt?: {
+        errorMsg?: string;
+    };
+    isLong?: {
+        errorMsg?: string;
+    };
+    minimum?: {
+        value: number;
+        errorMsg?: string;
+    };
+    maximum?: {
+        value: number;
+        errorMsg?: string;
+    };
+}
+export interface FloatValidator {
+    isFloat?: {
+        errorMsg?: string;
+    };
+    isDouble?: {
+        errorMsg?: string;
+    };
+    minimum?: {
+        value: number;
+        errorMsg?: string;
+    };
+    maximum?: {
+        value: number;
+        errorMsg?: string;
+    };
+}
+export interface DateValidator {
+    isDate?: {
+        errorMsg?: string;
+    };
+    minDate?: {
+        value: string;
+        errorMsg?: string;
+    };
+    maxDate?: {
+        value: string;
+        errorMsg?: string;
+    };
+}
+export interface DateTimeValidator {
+    isDateTime?: {
+        errorMsg?: string;
+    };
+    minDate?: {
+        value: string;
+        errorMsg?: string;
+    };
+    maxDate?: {
+        value: string;
+        errorMsg?: string;
+    };
+}
+export interface StringValidator {
+    isString?: {
+        errorMsg?: string;
+    };
+    minLength?: {
+        value: number;
+        errorMsg?: string;
+    };
+    maxLength?: {
+        value: number;
+        errorMsg?: string;
+    };
+    pattern?: {
+        value: string;
+        errorMsg?: string;
+    };
+    title?: {
+        value: string;
+        errorMsg?: string;
+    };
+}
+export interface BooleanValidator {
+    isBoolean?: {
+        errorMsg?: string;
+    };
+}
+export interface ArrayValidator {
+    isArray?: {
+        errorMsg?: string;
+    };
+    minItems?: {
+        value: number;
+        errorMsg?: string;
+    };
+    maxItems?: {
+        value: number;
+        errorMsg?: string;
+    };
+    uniqueItems?: {
+        errorMsg?: string;
+    };
+}
+export type Validator = IntegerValidator | FloatValidator | DateValidator | DateTimeValidator | StringValidator | BooleanValidator | ArrayValidator;
+export interface FieldErrors {
+    [name: string]: {
+        message: string;
+        value?: any;
+    };
+}
+export interface Exception extends Error {
+    status: number;
+}
+export declare class ValidateError extends Error implements Exception {
+    fields: FieldErrors;
+    message: string;
+    status: number;
+    name: string;
+    constructor(fields: FieldErrors, message: string);
+}