@tsoa-next/runtime 8.0.1 → 8.0.2-dev.48.4fd45317

package/dist/routeGeneration/templateHelpers.js

@@ -10,8 +10,17 @@ const validate_1 = require("../decorators/validate");
 const assertNever_1 = require("../utils/assertNever");
 const externalValidation_1 = require("./externalValidation");
 const tsoa_route_1 = require("./tsoa-route");
-function ValidateParam(property, value, generatedModels, name = '', fieldErrors, isBodyParam, parent = '', config, metadata) {
-    return new ValidationService(generatedModels, config).ValidateParam(property, value, name, fieldErrors, isBodyParam, parent, metadata);
+const objectHasOwn = Object.hasOwn;
+const normalizeValidateParamArgs = (args) => {
+    if (args.length === 1) {
+        return args[0];
+    }
+    const [property, value, generatedModels, name, fieldErrors, isBodyParam, parent, config, metadata] = args;
+    return { property, value, generatedModels, name, fieldErrors, isBodyParam, parent, config, metadata };
+};
+function ValidateParam(...args) {
+    const { property, value, generatedModels, name, fieldErrors, isBodyParam, parent, config, metadata } = normalizeValidateParamArgs(args);
+    return new ValidationService(generatedModels, config).ValidateParam(property, value, name ?? '', fieldErrors, isBodyParam, parent ?? '', metadata);
 }
 class ValidationService {
     models;
@@ -84,6 +93,98 @@ class ValidationService {
         });
         return message;
     }
+    createFieldError(message, value) {
+        return { message, value };
+    }
+    getNumericTypeErrorMessage(validators, defaultMessage, primaryValidator, _secondaryValidator) {
+        if (primaryValidator === 'isInt') {
+            const integerValidators = validators;
+            return integerValidators?.isInt?.errorMsg ?? integerValidators?.isLong?.errorMsg ?? defaultMessage;
+        }
+        const floatValidators = validators;
+        return floatValidators?.isFloat?.errorMsg ?? floatValidators?.isDouble?.errorMsg ?? defaultMessage;
+    }
+    getNumberBoundaryError(validators, numberValue, rawValue) {
+        const minimum = validators?.minimum;
+        if (minimum?.value !== undefined && minimum.value > numberValue) {
+            return this.createFieldError(minimum.errorMsg || `min ${minimum.value}`, rawValue);
+        }
+        const exclusiveMinimum = validators?.exclusiveMinimum;
+        if (exclusiveMinimum?.value !== undefined && exclusiveMinimum.value >= numberValue) {
+            return this.createFieldError(exclusiveMinimum.errorMsg || `exclusiveMin ${exclusiveMinimum.value}`, rawValue);
+        }
+        const maximum = validators?.maximum;
+        if (maximum?.value !== undefined && maximum.value < numberValue) {
+            return this.createFieldError(maximum.errorMsg || `max ${maximum.value}`, rawValue);
+        }
+        const exclusiveMaximum = validators?.exclusiveMaximum;
+        if (exclusiveMaximum?.value !== undefined && exclusiveMaximum.value <= numberValue) {
+            return this.createFieldError(exclusiveMaximum.errorMsg || `exclusiveMax ${exclusiveMaximum.value}`, rawValue);
+        }
+        return undefined;
+    }
+    getDateTypeErrorMessage(validators, key, defaultMessage) {
+        if (key === 'isDate') {
+            const dateValidators = validators;
+            return dateValidators?.isDate?.errorMsg ?? defaultMessage;
+        }
+        const dateTimeValidators = validators;
+        return dateTimeValidators?.isDateTime?.errorMsg ?? defaultMessage;
+    }
+    getDateBoundaryError(validators, dateValue, rawValue) {
+        const minDateValue = validators?.minDate?.value;
+        if (minDateValue) {
+            const minDate = new Date(minDateValue);
+            if (minDate > dateValue) {
+                return this.createFieldError(validators?.minDate?.errorMsg || `minDate '${minDateValue}'`, rawValue);
+            }
+        }
+        const maxDateValue = validators?.maxDate?.value;
+        if (maxDateValue) {
+            const maxDate = new Date(maxDateValue);
+            if (maxDate < dateValue) {
+                return this.createFieldError(validators?.maxDate?.errorMsg || `maxDate '${maxDateValue}'`, rawValue);
+            }
+        }
+        return undefined;
+    }
+    getStringValidationError(validators, stringValue, rawValue) {
+        const minLength = validators?.minLength;
+        if (minLength?.value !== undefined && minLength.value > stringValue.length) {
+            return this.createFieldError(minLength.errorMsg || `minLength ${minLength.value}`, rawValue);
+        }
+        const maxLength = validators?.maxLength;
+        if (maxLength?.value !== undefined && maxLength.value < stringValue.length) {
+            return this.createFieldError(maxLength.errorMsg || `maxLength ${maxLength.value}`, rawValue);
+        }
+        const pattern = validators?.pattern?.value;
+        if (pattern && !validator_1.default.matches(stringValue, pattern)) {
+            return this.createFieldError(validators?.pattern?.errorMsg || `Not match in '${pattern}'`, rawValue);
+        }
+        return undefined;
+    }
+    coerceBooleanValue(value, isBodyParam) {
+        if (value === true || value === false) {
+            return value;
+        }
+        if (isBodyParam && this.config.bodyCoercion !== true) {
+            return undefined;
+        }
+        if (value === undefined || value === null) {
+            return false;
+        }
+        if (typeof value !== 'string') {
+            return undefined;
+        }
+        const normalizedValue = value.toLowerCase();
+        if (normalizedValue === 'true') {
+            return true;
+        }
+        if (normalizedValue === 'false') {
+            return false;
+        }
+        return undefined;
+    }
     validateResolvedProperty({ property, value, name, fieldErrors, isBodyParam, parent, metadata, }) {
         switch (property.dataType) {
             case 'string':
@@ -258,7 +359,7 @@ class ValidationService {
             }
         });
         if (typeof additionalProperties === 'object') {
-            const keys = Object.keys(value).filter(key => typeof nestedProperties[key] === 'undefined');
+            const keys = Object.keys(value).filter(key => nestedProperties[key] === undefined);
             keys.forEach(key => {
                 const validatedProp = this.ValidateParam(additionalProperties, value[key], key, fieldErrors, isBodyParam, childPath, metadata);
                 // Add value from validator if it's not undefined or if value is required and unfedined is valid type
@@ -282,119 +383,33 @@ class ValidationService {
     }
     validateInt(name, value, fieldErrors, isBodyParam, validators, parent = '') {
         if (!this.hasCorrectJsType(value, 'number', isBodyParam) || !validator_1.default.isInt(String(value))) {
-            let message = `invalid integer number`;
-            if (validators) {
-                if (validators.isInt && validators.isInt.errorMsg) {
-                    message = validators.isInt.errorMsg;
-                }
-                if (validators.isLong && validators.isLong.errorMsg) {
-                    message = validators.isLong.errorMsg;
-                }
-            }
-            fieldErrors[parent + name] = {
-                message,
-                value,
-            };
+            fieldErrors[parent + name] = this.createFieldError(this.getNumericTypeErrorMessage(validators, `invalid integer number`, 'isInt', 'isLong'), value);
             return;
         }
         const numberValue = validator_1.default.toInt(String(value), 10);
         if (!validators) {
             return numberValue;
         }
-        if (validators.minimum && validators.minimum.value !== undefined) {
-            if (validators.minimum.value > numberValue) {
-                fieldErrors[parent + name] = {
-                    message: validators.minimum.errorMsg || `min ${validators.minimum.value}`,
-                    value,
-                };
-                return;
-            }
-        }
-        if (validators.exclusiveMinimum && validators.exclusiveMinimum.value !== undefined) {
-            if (validators.exclusiveMinimum.value >= numberValue) {
-                fieldErrors[parent + name] = {
-                    message: validators.exclusiveMinimum.errorMsg || `exclusiveMin ${validators.exclusiveMinimum.value}`,
-                    value,
-                };
-                return;
-            }
-        }
-        if (validators.maximum && validators.maximum.value !== undefined) {
-            if (validators.maximum.value < numberValue) {
-                fieldErrors[parent + name] = {
-                    message: validators.maximum.errorMsg || `max ${validators.maximum.value}`,
-                    value,
-                };
-                return;
-            }
-        }
-        if (validators.exclusiveMaximum && validators.exclusiveMaximum.value !== undefined) {
-            if (validators.exclusiveMaximum.value <= numberValue) {
-                fieldErrors[parent + name] = {
-                    message: validators.exclusiveMaximum.errorMsg || `exclusiveMax ${validators.exclusiveMaximum.value}`,
-                    value,
-                };
-                return;
-            }
+        const validationError = this.getNumberBoundaryError(validators, numberValue, value);
+        if (validationError) {
+            fieldErrors[parent + name] = validationError;
+            return;
         }
         return numberValue;
     }
     validateFloat(name, value, fieldErrors, isBodyParam, validators, parent = '') {
         if (!this.hasCorrectJsType(value, 'number', isBodyParam) || !validator_1.default.isFloat(String(value))) {
-            let message = 'invalid float number';
-            if (validators) {
-                if (validators.isFloat && validators.isFloat.errorMsg) {
-                    message = validators.isFloat.errorMsg;
-                }
-                if (validators.isDouble && validators.isDouble.errorMsg) {
-                    message = validators.isDouble.errorMsg;
-                }
-            }
-            fieldErrors[parent + name] = {
-                message,
-                value,
-            };
+            fieldErrors[parent + name] = this.createFieldError(this.getNumericTypeErrorMessage(validators, 'invalid float number', 'isFloat', 'isDouble'), value);
             return;
         }
         const numberValue = validator_1.default.toFloat(String(value));
         if (!validators) {
             return numberValue;
         }
-        if (validators.minimum && validators.minimum.value !== undefined) {
-            if (validators.minimum.value > numberValue) {
-                fieldErrors[parent + name] = {
-                    message: validators.minimum.errorMsg || `min ${validators.minimum.value}`,
-                    value,
-                };
-                return;
-            }
-        }
-        if (validators.exclusiveMinimum && validators.exclusiveMinimum.value !== undefined) {
-            if (validators.exclusiveMinimum.value >= numberValue) {
-                fieldErrors[parent + name] = {
-                    message: validators.exclusiveMinimum.errorMsg || `exclusiveMin ${validators.exclusiveMinimum.value}`,
-                    value,
-                };
-                return;
-            }
-        }
-        if (validators.maximum && validators.maximum.value !== undefined) {
-            if (validators.maximum.value < numberValue) {
-                fieldErrors[parent + name] = {
-                    message: validators.maximum.errorMsg || `max ${validators.maximum.value}`,
-                    value,
-                };
-                return;
-            }
-        }
-        if (validators.exclusiveMaximum && validators.exclusiveMaximum.value !== undefined) {
-            if (validators.exclusiveMaximum.value <= numberValue) {
-                fieldErrors[parent + name] = {
-                    message: validators.exclusiveMaximum.errorMsg || `exclusiveMax ${validators.exclusiveMaximum.value}`,
-                    value,
-                };
-                return;
-            }
+        const validationError = this.getNumberBoundaryError(validators, numberValue, value);
+        if (validationError) {
+            fieldErrors[parent + name] = validationError;
+            return;
         }
         return numberValue;
     }
@@ -406,7 +421,7 @@ class ValidationService {
             };
             return;
         }
-        const enumMatchIndex = members.map(member => String(member)).findIndex(member => validator_1.default.equals(member, String(value)));
+        const enumMatchIndex = members.findIndex(member => validator_1.default.equals(String(member), String(value)));
         if (enumMatchIndex === -1) {
             const membersInQuotes = members.map(member => (typeof member === 'string' ? `'${member}'` : String(member)));
             fieldErrors[parent + name] = {
@@ -419,137 +434,59 @@ class ValidationService {
     }
     validateDate(name, value, fieldErrors, isBodyParam, validators, parent = '') {
         if (!this.hasCorrectJsType(value, 'string', isBodyParam) || !validator_1.default.isISO8601(String(value), { strict: true })) {
-            const message = validators && validators.isDate && validators.isDate.errorMsg ? validators.isDate.errorMsg : `invalid ISO 8601 date format, i.e. YYYY-MM-DD`;
-            fieldErrors[parent + name] = {
-                message,
-                value,
-            };
+            fieldErrors[parent + name] = this.createFieldError(this.getDateTypeErrorMessage(validators, 'isDate', `invalid ISO 8601 date format, i.e. YYYY-MM-DD`), value);
             return;
         }
         const dateValue = new Date(String(value));
         if (!validators) {
             return dateValue;
         }
-        if (validators.minDate && validators.minDate.value) {
-            const minDate = new Date(validators.minDate.value);
-            if (minDate.getTime() > dateValue.getTime()) {
-                fieldErrors[parent + name] = {
-                    message: validators.minDate.errorMsg || `minDate '${validators.minDate.value}'`,
-                    value,
-                };
-                return;
-            }
-        }
-        if (validators.maxDate && validators.maxDate.value) {
-            const maxDate = new Date(validators.maxDate.value);
-            if (maxDate.getTime() < dateValue.getTime()) {
-                fieldErrors[parent + name] = {
-                    message: validators.maxDate.errorMsg || `maxDate '${validators.maxDate.value}'`,
-                    value,
-                };
-                return;
-            }
+        const validationError = this.getDateBoundaryError(validators, dateValue, value);
+        if (validationError) {
+            fieldErrors[parent + name] = validationError;
+            return;
         }
         return dateValue;
     }
     validateDateTime(name, value, fieldErrors, isBodyParam, validators, parent = '') {
         if (!this.hasCorrectJsType(value, 'string', isBodyParam) || !validator_1.default.isISO8601(String(value), { strict: true })) {
-            const message = validators && validators.isDateTime && validators.isDateTime.errorMsg ? validators.isDateTime.errorMsg : `invalid ISO 8601 datetime format, i.e. YYYY-MM-DDTHH:mm:ss`;
-            fieldErrors[parent + name] = {
-                message,
-                value,
-            };
+            fieldErrors[parent + name] = this.createFieldError(this.getDateTypeErrorMessage(validators, 'isDateTime', `invalid ISO 8601 datetime format, i.e. YYYY-MM-DDTHH:mm:ss`), value);
             return;
         }
         const datetimeValue = new Date(String(value));
         if (!validators) {
             return datetimeValue;
         }
-        if (validators.minDate && validators.minDate.value) {
-            const minDate = new Date(validators.minDate.value);
-            if (minDate.getTime() > datetimeValue.getTime()) {
-                fieldErrors[parent + name] = {
-                    message: validators.minDate.errorMsg || `minDate '${validators.minDate.value}'`,
-                    value,
-                };
-                return;
-            }
-        }
-        if (validators.maxDate && validators.maxDate.value) {
-            const maxDate = new Date(validators.maxDate.value);
-            if (maxDate.getTime() < datetimeValue.getTime()) {
-                fieldErrors[parent + name] = {
-                    message: validators.maxDate.errorMsg || `maxDate '${validators.maxDate.value}'`,
-                    value,
-                };
-                return;
-            }
+        const validationError = this.getDateBoundaryError(validators, datetimeValue, value);
+        if (validationError) {
+            fieldErrors[parent + name] = validationError;
+            return;
         }
         return datetimeValue;
     }
     validateString(name, value, fieldErrors, validators, parent = '') {
         if (typeof value !== 'string') {
-            const message = validators && validators.isString && validators.isString.errorMsg ? validators.isString.errorMsg : `invalid string value`;
-            fieldErrors[parent + name] = {
-                message,
-                value,
-            };
+            fieldErrors[parent + name] = this.createFieldError(validators?.isString?.errorMsg ?? `invalid string value`, value);
             return;
         }
         const stringValue = String(value);
         if (!validators) {
             return stringValue;
         }
-        if (validators.minLength && validators.minLength.value !== undefined) {
-            if (validators.minLength.value > stringValue.length) {
-                fieldErrors[parent + name] = {
-                    message: validators.minLength.errorMsg || `minLength ${validators.minLength.value}`,
-                    value,
-                };
-                return;
-            }
-        }
-        if (validators.maxLength && validators.maxLength.value !== undefined) {
-            if (validators.maxLength.value < stringValue.length) {
-                fieldErrors[parent + name] = {
-                    message: validators.maxLength.errorMsg || `maxLength ${validators.maxLength.value}`,
-                    value,
-                };
-                return;
-            }
-        }
-        if (validators.pattern && validators.pattern.value) {
-            if (!validator_1.default.matches(String(stringValue), validators.pattern.value)) {
-                fieldErrors[parent + name] = {
-                    message: validators.pattern.errorMsg || `Not match in '${validators.pattern.value}'`,
-                    value,
-                };
-                return;
-            }
+        const validationError = this.getStringValidationError(validators, stringValue, value);
+        if (validationError) {
+            fieldErrors[parent + name] = validationError;
+            return;
         }
         return stringValue;
     }
     validateBool(name, value, fieldErrors, isBodyParam, validators, parent = '') {
-        if (value === true || value === false) {
-            return value;
-        }
-        if (!isBodyParam || this.config.bodyCoercion === true) {
-            if (value === undefined || value === null) {
-                return false;
-            }
-            if (String(value).toLowerCase() === 'true') {
-                return true;
-            }
-            if (String(value).toLowerCase() === 'false') {
-                return false;
-            }
+        const coercedValue = this.coerceBooleanValue(value, isBodyParam);
+        if (coercedValue !== undefined) {
+            return coercedValue;
         }
-        const message = validators && validators.isBoolean && validators.isBoolean.errorMsg ? validators.isBoolean.errorMsg : `invalid boolean value`;
-        fieldErrors[parent + name] = {
-            message,
-            value,
-        };
-        return;
+        fieldErrors[parent + name] = this.createFieldError(validators?.isBoolean?.errorMsg ?? `invalid boolean value`, value);
+        return undefined;
     }
     validateUndefined(name, value, fieldErrors, parent = '') {
         if (value === undefined) {
@@ -560,7 +497,6 @@ class ValidationService {
             message,
             value,
         };
-        return;
     }
     validateArray(...args) {
         const options = this.normalizeValidateArrayArgs(args);
@@ -650,7 +586,7 @@ class ValidationService {
             message: 'invalid buffer value',
             value,
         };
-        return;
+        return undefined;
     }
     validateUnion(name, value, fieldErrors, isBodyParam, property, parent = '', metadata) {
         if (!property.subSchemas) {
@@ -663,7 +599,7 @@ class ValidationService {
             const subFieldError = {};
             // Clean value if it's not undefined or use undefined directly if it's undefined.
             // Value can be undefined if undefined is allowed datatype of the union
-            const validateableValue = value !== undefined ? this.deepClone(value) : value;
+            const validateableValue = value === undefined ? value : this.deepClone(value);
             const cleanValue = this.ValidateParam({ ...subSchema, validators: { ...property.validators, ...subSchema.validators } }, validateableValue, name, subFieldError, isBodyParam, parent, metadata);
             subFieldErrors.push(subFieldError);
             if (Object.keys(subFieldError).length === 0) {
@@ -671,7 +607,7 @@ class ValidationService {
             }
         }
         this.addSummarizedError(fieldErrors, parent + name, 'Could not match the union against any of the items. Issues: ', subFieldErrors, value);
-        return;
+        return undefined;
     }
     validateIntersection(name, value, fieldErrors, isBodyParam, subSchemas, parent = '', metadata) {
         if (!subSchemas) {
@@ -722,24 +658,20 @@ class ValidationService {
             if (schemasWithRequiredProps.length > 0) {
                 return cleanValues;
             }
-            else {
-                fieldErrors[parent + name] = {
-                    message: `Could not match intersection against any of the possible combinations: ${JSON.stringify(schemas.map(s => Object.keys(s.properties)))}`,
-                    value,
-                };
-                return;
-            }
-        }
-        if (this.isRecord(value) && schemasWithRequiredProps.length > 0 && schemasWithRequiredProps.some(schema => this.getExcessPropertiesFor(schema, Object.keys(value)).length === 0)) {
-            return cleanValues;
-        }
-        else {
             fieldErrors[parent + name] = {
                 message: `Could not match intersection against any of the possible combinations: ${JSON.stringify(schemas.map(s => Object.keys(s.properties)))}`,
                 value,
             };
             return;
         }
+        if (this.isRecord(value) && schemasWithRequiredProps.some(schema => this.getExcessPropertiesFor(schema, Object.keys(value)).length === 0)) {
+            return cleanValues;
+        }
+        fieldErrors[parent + name] = {
+            message: `Could not match intersection against any of the possible combinations: ${JSON.stringify(schemas.map(s => Object.keys(s.properties)))}`,
+            value,
+        };
+        return undefined;
     }
     toModelLike(schema) {
         if (schema.ref) {
@@ -764,14 +696,11 @@ class ValidationService {
             const modelss = schema.subSchemas.map(subSchema => this.toModelLike(subSchema));
             return this.selfIntersectionCombinations(modelss);
         }
-        else if (schema.subSchemas && schema.dataType === 'union') {
-            const modelss = schema.subSchemas.map(subSchema => this.toModelLike(subSchema));
-            return modelss.reduce((acc, models) => [...acc, ...models], []);
-        }
-        else {
-            // There are no properties to check for excess here.
-            return [{ dataType: 'refObject', properties: {}, additionalProperties: false }];
+        if (schema.subSchemas && schema.dataType === 'union') {
+            return schema.subSchemas.flatMap(subSchema => this.toModelLike(subSchema));
         }
+        // There are no properties to check for excess here.
+        return [{ dataType: 'refObject', properties: {}, additionalProperties: false }];
     }
     /**
      * combine all schemas once, ignoring order ie
@@ -810,8 +739,8 @@ class ValidationService {
                 result.push(current.slice());
                 return;
             }
-            for (let i = 0; i < arrays[index].length; i++) {
-                current.push(arrays[index][i]);
+            for (const item of arrays[index]) {
+                current.push(item);
                 combine(current, index + 1);
                 current.pop();
             }
@@ -944,7 +873,7 @@ class ValidationService {
         }
         // Handle built-in object types
         if (obj instanceof Date) {
-            return new Date(obj.getTime());
+            return new Date(obj);
         }
         if (obj instanceof RegExp) {
             // Preserve the existing instance instead of reconstructing a pattern from untrusted data.
@@ -955,13 +884,13 @@ class ValidationService {
             const clonedArray = arrayValues.map(value => this.deepClone(value));
             return clonedArray;
         }
-        if (Buffer && obj instanceof Buffer) {
+        if (obj instanceof Buffer) {
             return Buffer.from(obj);
         }
         // Handle plain objects
         const cloneObj = {};
         for (const key in obj) {
-            if (Object.prototype.hasOwnProperty.call(obj, key)) {
+            if (objectHasOwn(obj, key)) {
                 cloneObj[key] = this.deepClone(obj[key]);
             }
         }
@@ -1029,9 +958,7 @@ class ValidationService {
             }
             return result;
         }
-        else {
-            return `[${summary.join(',')}]`;
-        }
+        return `[${summary.join(',')}]`;
     }
 }
 exports.ValidationService = ValidationService;