@tsoa-next/runtime 7.1.0 → 7.3.1

package/dist/routeGeneration/templateHelpers.js

@@ -6,11 +6,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ValidateError = exports.ValidationService = void 0;
 exports.ValidateParam = ValidateParam;
 const validator_1 = __importDefault(require("validator"));
+const validate_1 = require("../decorators/validate");
 const assertNever_1 = require("../utils/assertNever");
+const externalValidation_1 = require("./externalValidation");
 const tsoa_route_1 = require("./tsoa-route");
-// for backwards compatibility with custom templates
-function ValidateParam(property, value, generatedModels, name = '', fieldErrors, isBodyParam, parent = '', config) {
-    return new ValidationService(generatedModels, config).ValidateParam(property, value, name, fieldErrors, isBodyParam, parent);
+function ValidateParam(property, value, generatedModels, name = '', fieldErrors, isBodyParam, parent = '', config, metadata) {
+    return new ValidationService(generatedModels, config).ValidateParam(property, value, name, fieldErrors, isBodyParam, parent, metadata);
 }
 class ValidationService {
     models;
@@ -20,36 +21,70 @@ class ValidationService {
         this.models = models;
         this.config = config;
     }
-    ValidateParam(property, rawValue, name = '', fieldErrors, isBodyParam, parent = '') {
-        let value = rawValue;
-        // If undefined is allowed type, we can move to value validation
-        if (value === undefined && property.dataType !== 'undefined') {
-            // If there's either default value or datatype is union with undefined valid, we can just set it and move to validation
-            if (property.default !== undefined || (property.dataType === 'union' && property.subSchemas?.some(p => p.dataType === 'undefined'))) {
-                value = property.default;
-            }
-            else if (property.required) {
-                // If value can be typed as undefined, there's no need to check mandatoriness here.
-                let message = `'${name}' is required`;
-                if (property.validators) {
-                    const validators = property.validators;
-                    Object.keys(validators).forEach((key) => {
-                        const errorMsg = validators[key]?.errorMsg;
-                        if (key.startsWith('is') && errorMsg) {
-                            message = errorMsg;
-                        }
-                    });
-                }
-                fieldErrors[parent + name] = {
-                    message,
-                    value,
-                };
-                return;
-            }
-            else {
-                return value;
-            }
+    isRecord(value) {
+        return typeof value === 'object' && value !== null && !Array.isArray(value);
+    }
+    buildChildPath(parent, name) {
+        const fieldPath = parent + name;
+        return fieldPath ? `${fieldPath}.` : '';
+    }
+    ValidateParam(property, rawValue, name, fieldErrors, isBodyParam, parent, metadata) {
+        const resolvedName = name ?? '';
+        const resolvedParent = parent ?? '';
+        const handledUndefined = this.handleUndefinedValue({
+            property,
+            rawValue,
+            name: resolvedName,
+            fieldErrors,
+            parent: resolvedParent,
+        });
+        if (handledUndefined.handled) {
+            return handledUndefined.value;
+        }
+        const value = handledUndefined.value;
+        if (property.validationStrategy === 'external' && property.externalValidator) {
+            return this.validateExternal(resolvedName, value, fieldErrors, property, resolvedParent, metadata);
         }
+        return this.validateResolvedProperty({
+            property,
+            value,
+            name: resolvedName,
+            fieldErrors,
+            isBodyParam,
+            parent: resolvedParent,
+            metadata,
+        });
+    }
+    handleUndefinedValue({ property, rawValue, name, fieldErrors, parent }) {
+        if (rawValue !== undefined || property.dataType === 'undefined') {
+            return { handled: false, value: rawValue };
+        }
+        if (property.default !== undefined || (property.dataType === 'union' && property.subSchemas?.some(p => p.dataType === 'undefined'))) {
+            return { handled: false, value: property.default };
+        }
+        if (property.required) {
+            fieldErrors[parent + name] = {
+                message: this.getRequiredFieldMessage(property.validators, name),
+                value: rawValue,
+            };
+            return { handled: true, value: rawValue };
+        }
+        return { handled: true, value: rawValue };
+    }
+    getRequiredFieldMessage(validators, name) {
+        let message = `'${name}' is required`;
+        if (!validators) {
+            return message;
+        }
+        Object.keys(validators).forEach((key) => {
+            const errorMsg = validators[key]?.errorMsg;
+            if (key.startsWith('is') && errorMsg) {
+                message = errorMsg;
+            }
+        });
+        return message;
+    }
+    validateResolvedProperty({ property, value, name, fieldErrors, isBodyParam, parent, metadata, }) {
         switch (property.dataType) {
             case 'string':
                 return this.validateString(name, value, fieldErrors, property.validators, parent);
@@ -64,23 +99,41 @@ class ValidationService {
             case 'enum':
                 return this.validateEnum(name, value, fieldErrors, property.enums, parent);
             case 'array':
-                return this.validateArray(name, value, fieldErrors, isBodyParam, property.array, property.validators, parent);
+                return this.validateArray({
+                    name,
+                    value,
+                    fieldErrors,
+                    isBodyParam,
+                    schema: property.array,
+                    validators: property.validators,
+                    parent,
+                    metadata,
+                });
             case 'date':
                 return this.validateDate(name, value, fieldErrors, isBodyParam, property.validators, parent);
             case 'datetime':
                 return this.validateDateTime(name, value, fieldErrors, isBodyParam, property.validators, parent);
             case 'buffer':
-                return this.validateBuffer(name, value);
+                return this.validateBuffer(name, value, fieldErrors, parent);
             case 'union':
-                return this.validateUnion(name, value, fieldErrors, isBodyParam, property, parent);
+                return this.validateUnion(name, value, fieldErrors, isBodyParam, property, parent, metadata);
             case 'intersection':
-                return this.validateIntersection(name, value, fieldErrors, isBodyParam, property.subSchemas, parent);
+                return this.validateIntersection(name, value, fieldErrors, isBodyParam, property.subSchemas, parent, metadata);
             case 'undefined':
                 return this.validateUndefined(name, value, fieldErrors, parent);
             case 'any':
                 return value;
             case 'nestedObjectLiteral':
-                return this.validateNestedObjectLiteral(name, value, fieldErrors, isBodyParam, property.nestedProperties, property.additionalProperties, parent);
+                return this.validateNestedObjectLiteral({
+                    name,
+                    value,
+                    fieldErrors,
+                    isBodyParam,
+                    nestedProperties: property.nestedProperties,
+                    additionalProperties: property.additionalProperties,
+                    parent,
+                    metadata,
+                });
             default:
                 if (property.ref) {
                     // Detect circular references to prevent stack overflow
@@ -90,7 +143,7 @@ class ValidationService {
                     }
                     this.validationStack.add(refPath);
                     try {
-                        return this.validateModel({ name, value, modelDefinition: this.models[property.ref], fieldErrors, isBodyParam, parent });
+                        return this.validateModel({ name, value, modelDefinition: this.models[property.ref], fieldErrors, isBodyParam, parent, metadata });
                     }
                     finally {
                         this.validationStack.delete(refPath);
@@ -99,11 +152,73 @@ class ValidationService {
                 return value;
         }
     }
+    validateExternal(name, rawValue, fieldErrors, property, parent, metadata) {
+        const value = rawValue === undefined && property.default !== undefined ? property.default : rawValue;
+        const runtimeMetadata = this.getRuntimeExternalValidatorMetadata(metadata, property);
+        const fieldPath = parent + name;
+        if (!runtimeMetadata) {
+            fieldErrors[fieldPath] = {
+                message: `Missing runtime schema metadata for external validator '${property.externalValidator?.kind || 'unknown'}' on '${fieldPath || '(anonymous parameter)'}'. Ensure the controller module is imported so decorators run, and ensure custom templates pass controllerClass, methodName, and parameterIndex into validation.`,
+                value,
+            };
+            return undefined;
+        }
+        const declaredKind = property.externalValidator?.kind;
+        const runtimeKind = runtimeMetadata.kind;
+        if (declaredKind && declaredKind !== runtimeKind) {
+            fieldErrors[fieldPath] = {
+                message: `External validator kind mismatch for '${fieldPath}'. Route schema expects '${declaredKind}' but runtime metadata provided '${runtimeKind}'.`,
+                value,
+            };
+            return undefined;
+        }
+        const kindToUse = declaredKind || runtimeKind;
+        const result = (0, externalValidation_1.validateExternalSchema)(kindToUse, runtimeMetadata.schema, value, this.config.validation ?? {});
+        if (result.ok) {
+            return result.value;
+        }
+        this.projectExternalFailureToFieldErrors(result.failure, fieldErrors, name, parent, value);
+        return undefined;
+    }
+    getRuntimeExternalValidatorMetadata(metadata, property) {
+        if (!metadata?.controllerClass || metadata.parameterIndex === undefined || !metadata.methodName || !property.externalValidator) {
+            return undefined;
+        }
+        const controllerTarget = metadata.controllerClass;
+        const candidateTargets = controllerTarget.prototype ? [controllerTarget.prototype, controllerTarget] : [controllerTarget];
+        for (const target of candidateTargets) {
+            const runtimeMetadata = (0, validate_1.getParameterExternalValidatorMetadata)(target, metadata.methodName, metadata.parameterIndex);
+            if (runtimeMetadata) {
+                return runtimeMetadata;
+            }
+        }
+        return undefined;
+    }
+    projectExternalFailureToFieldErrors(failure, fieldErrors, name, parent, value) {
+        if (failure.issues.length === 0) {
+            fieldErrors[parent + name] = {
+                message: failure.summaryMessage,
+                value,
+            };
+            return;
+        }
+        for (const issue of failure.issues) {
+            const baseFieldPath = parent + name;
+            const fieldPath = issue.path ? this.buildIssueFieldPath(baseFieldPath, issue.path) : baseFieldPath;
+            if (!fieldErrors[fieldPath]) {
+                fieldErrors[fieldPath] = {
+                    message: issue.message || failure.summaryMessage,
+                    value,
+                };
+            }
+        }
+    }
     hasCorrectJsType(value, type, isBodyParam) {
         return !isBodyParam || this.config.bodyCoercion || typeof value === type;
     }
-    validateNestedObjectLiteral(name, value, fieldErrors, isBodyParam, nestedProperties, additionalProperties, parent) {
-        if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+    validateNestedObjectLiteral(...args) {
+        const { name, value, fieldErrors, isBodyParam, nestedProperties, additionalProperties, parent, metadata } = this.normalizeValidateNestedObjectLiteralArgs(args);
+        if (!this.isRecord(value)) {
             fieldErrors[parent + name] = {
                 message: `invalid object`,
                 value,
@@ -115,7 +230,7 @@ class ValidationService {
             throw new Error('internal tsoa error: ' +
                 'the metadata that was generated should have had nested property schemas since it’s for a nested object,' +
                 'however it did not. ' +
-                'Please file an issue with tsoa at https://github.com/lukeautry/tsoa/issues');
+                'Please file an issue with tsoa at https://github.com/tsoa-next/tsoa-next/issues');
         }
         const propHandling = this.config.noImplicitAdditionalProperties;
         if (propHandling !== 'ignore') {
@@ -134,17 +249,18 @@ class ValidationService {
                 }
             }
         }
+        const childPath = this.buildChildPath(parent, name);
         Object.keys(nestedProperties).forEach(key => {
-            const validatedProp = this.ValidateParam(nestedProperties[key], value[key], key, fieldErrors, isBodyParam, parent + name + '.');
+            const validatedProp = this.ValidateParam(nestedProperties[key], 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
             if (validatedProp !== undefined || (nestedProperties[key].dataType === 'undefined' && nestedProperties[key].required)) {
                 value[key] = validatedProp;
             }
         });
-        if (typeof additionalProperties === 'object' && typeof value === 'object') {
+        if (typeof additionalProperties === 'object') {
             const keys = Object.keys(value).filter(key => typeof nestedProperties[key] === 'undefined');
             keys.forEach(key => {
-                const validatedProp = this.ValidateParam(additionalProperties, value[key], key, fieldErrors, isBodyParam, parent + name + '.');
+                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
                 if (validatedProp !== undefined || (additionalProperties.dataType === 'undefined' && additionalProperties.required)) {
                     value[key] = validatedProp;
@@ -156,6 +272,14 @@ class ValidationService {
         }
         return value;
     }
+    normalizeValidateNestedObjectLiteralArgs(args) {
+        if (typeof args[0] === 'string') {
+            const tupleArgs = args;
+            const [name, value, fieldErrors, isBodyParam, nestedProperties, additionalProperties, parent = '', metadata] = tupleArgs;
+            return { name, value, fieldErrors, isBodyParam, nestedProperties, additionalProperties, parent, metadata };
+        }
+        return args[0];
+    }
     validateInt(name, value, fieldErrors, isBodyParam, validators, parent = '') {
         if (!this.hasCorrectJsType(value, 'number', isBodyParam) || !validator_1.default.isInt(String(value))) {
             let message = `invalid integer number`;
@@ -186,6 +310,15 @@ class ValidationService {
                 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] = {
@@ -195,6 +328,15 @@ class ValidationService {
                 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;
+            }
+        }
         return numberValue;
     }
     validateFloat(name, value, fieldErrors, isBodyParam, validators, parent = '') {
@@ -227,6 +369,15 @@ class ValidationService {
                 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] = {
@@ -236,6 +387,15 @@ class ValidationService {
                 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;
+            }
+        }
         return numberValue;
     }
     validateEnum(name, value, fieldErrors, members, parent = '') {
@@ -402,72 +562,101 @@ class ValidationService {
         };
         return;
     }
-    validateArray(name, value, fieldErrors, isBodyParam, schema, validators, parent = '') {
-        if ((isBodyParam && this.config.bodyCoercion === false && !Array.isArray(value)) || !schema || value === undefined) {
-            const message = validators && validators.isArray && validators.isArray.errorMsg ? validators.isArray.errorMsg : `invalid array`;
-            fieldErrors[parent + name] = {
+    validateArray(...args) {
+        const options = this.normalizeValidateArrayArgs(args);
+        const { name, value: resolvedValue, fieldErrors: resolvedFieldErrors, isBodyParam: resolvedIsBodyParam, schema: resolvedSchema, validators: resolvedValidators, parent: resolvedParent = '', metadata: resolvedMetadata, } = options;
+        if ((resolvedIsBodyParam && this.config.bodyCoercion === false && !Array.isArray(resolvedValue)) || !resolvedSchema || resolvedValue === undefined) {
+            const message = resolvedValidators?.isArray?.errorMsg || `invalid array`;
+            resolvedFieldErrors[resolvedParent + name] = {
                 message,
-                value,
+                value: resolvedValue,
             };
             return;
         }
         let arrayValue = [];
-        const previousErrors = Object.keys(fieldErrors).length;
-        if (Array.isArray(value)) {
-            arrayValue = value.map((elementValue, index) => {
-                return this.ValidateParam(schema, elementValue, `$${index}`, fieldErrors, isBodyParam, name + '.');
+        const previousErrors = Object.keys(resolvedFieldErrors).length;
+        const childParent = this.buildChildPath(resolvedParent, name);
+        if (Array.isArray(resolvedValue)) {
+            arrayValue = resolvedValue.map((elementValue, index) => {
+                const validatedElement = this.ValidateParam(resolvedSchema, elementValue, `$${index}`, resolvedFieldErrors, resolvedIsBodyParam, childParent, resolvedMetadata);
+                return validatedElement;
             });
         }
         else {
-            arrayValue = [this.ValidateParam(schema, value, '$0', fieldErrors, isBodyParam, name + '.')];
+            const validatedElement = this.ValidateParam(resolvedSchema, resolvedValue, '$0', resolvedFieldErrors, resolvedIsBodyParam, childParent, resolvedMetadata);
+            arrayValue = [validatedElement];
         }
-        if (Object.keys(fieldErrors).length > previousErrors) {
+        if (Object.keys(resolvedFieldErrors).length > previousErrors) {
+            return;
+        }
+        const validatorError = this.getArrayValidatorError(resolvedValidators, arrayValue, resolvedValue);
+        if (validatorError) {
+            resolvedFieldErrors[resolvedParent + name] = validatorError;
             return;
         }
+        return arrayValue;
+    }
+    normalizeValidateArrayArgs(args) {
+        if (typeof args[0] === 'string') {
+            const [name, value, fieldErrors, isBodyParam, schema, validators, parent = '', metadata] = args;
+            return { name, value, fieldErrors, isBodyParam, schema, validators, parent, metadata };
+        }
+        return args[0];
+    }
+    getArrayValidatorError(validators, arrayValue, originalValue) {
         if (!validators) {
-            return arrayValue;
+            return undefined;
         }
-        if (validators.minItems && validators.minItems.value) {
-            if (validators.minItems.value > arrayValue.length) {
-                fieldErrors[parent + name] = {
-                    message: validators.minItems.errorMsg || `minItems ${validators.minItems.value}`,
-                    value,
-                };
-                return;
-            }
+        if (validators.minItems?.value && validators.minItems.value > arrayValue.length) {
+            return {
+                message: validators.minItems.errorMsg || `minItems ${validators.minItems.value}`,
+                value: originalValue,
+            };
         }
-        if (validators.maxItems && validators.maxItems.value) {
-            if (validators.maxItems.value < arrayValue.length) {
-                fieldErrors[parent + name] = {
-                    message: validators.maxItems.errorMsg || `maxItems ${validators.maxItems.value}`,
-                    value,
-                };
-                return;
-            }
+        if (validators.maxItems?.value && validators.maxItems.value < arrayValue.length) {
+            return {
+                message: validators.maxItems.errorMsg || `maxItems ${validators.maxItems.value}`,
+                value: originalValue,
+            };
         }
-        if (validators.uniqueItems) {
-            const unique = arrayValue.some((elem, index, arr) => {
-                const indexOf = arr.indexOf(elem);
-                return indexOf > -1 && indexOf !== index;
-            });
-            if (unique) {
-                fieldErrors[parent + name] = {
-                    message: validators.uniqueItems.errorMsg || `required unique array`,
-                    value,
-                };
-                return;
-            }
+        if (validators.uniqueItems && this.hasDuplicateArrayItems(arrayValue)) {
+            return {
+                message: validators.uniqueItems.errorMsg || `required unique array`,
+                value: originalValue,
+            };
         }
-        return arrayValue;
+        return undefined;
     }
-    validateBuffer(_name, value) {
-        return Buffer.from(value);
+    hasDuplicateArrayItems(arrayValue) {
+        return arrayValue.some((elem, index, arr) => {
+            const indexOf = arr.indexOf(elem);
+            return indexOf > -1 && indexOf !== index;
+        });
+    }
+    buildIssueFieldPath(baseFieldPath, issuePath) {
+        return baseFieldPath ? `${baseFieldPath}.${issuePath}` : issuePath;
+    }
+    validateBuffer(name, value, fieldErrors, parent = '') {
+        if (Buffer.isBuffer(value)) {
+            return value;
+        }
+        if (typeof value === 'string') {
+            return Buffer.from(value);
+        }
+        if (value instanceof Uint8Array) {
+            return Buffer.from(value);
+        }
+        fieldErrors[parent + name] = {
+            message: 'invalid buffer value',
+            value,
+        };
+        return;
     }
-    validateUnion(name, value, fieldErrors, isBodyParam, property, parent = '') {
+    validateUnion(name, value, fieldErrors, isBodyParam, property, parent = '', metadata) {
         if (!property.subSchemas) {
             throw new Error('internal tsoa error: ' +
                 'the metadata that was generated should have had sub schemas since it’s for a union, however it did not. ' +
-                'Please file an issue with tsoa at https://github.com/lukeautry/tsoa/issues');
+                'Please file an issue with tsoa at https://github.com/tsoa-next/tsoa-next/issues');
         }
         const subFieldErrors = [];
         for (const subSchema of property.subSchemas) {
@@ -475,7 +664,7 @@ class ValidationService {
             // 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 cleanValue = this.ValidateParam({ ...subSchema, validators: { ...property.validators, ...subSchema.validators } }, validateableValue, name, subFieldError, isBodyParam, parent);
+            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) {
                 return cleanValue;
@@ -484,11 +673,11 @@ class ValidationService {
         this.addSummarizedError(fieldErrors, parent + name, 'Could not match the union against any of the items. Issues: ', subFieldErrors, value);
         return;
     }
-    validateIntersection(name, value, fieldErrors, isBodyParam, subSchemas, parent = '') {
+    validateIntersection(name, value, fieldErrors, isBodyParam, subSchemas, parent = '', metadata) {
         if (!subSchemas) {
             throw new Error('internal tsoa error: ' +
                 'the metadata that was generated should have had sub schemas since it’s for a intersection, however it did not. ' +
-                'Please file an issue with tsoa at https://github.com/lukeautry/tsoa/issues');
+                'Please file an issue with tsoa at https://github.com/tsoa-next/tsoa-next/issues');
         }
         const subFieldErrors = [];
         let cleanValues = {};
@@ -496,11 +685,13 @@ class ValidationService {
             const subFieldError = {};
             const cleanValue = this.createChildValidationService({
                 noImplicitAdditionalProperties: 'silently-remove-extras',
-            }).ValidateParam(subSchema, this.deepClone(value), name, subFieldError, isBodyParam, parent);
-            cleanValues = {
-                ...cleanValues,
-                ...cleanValue,
-            };
+            }).ValidateParam(subSchema, this.deepClone(value), name, subFieldError, isBodyParam, parent, metadata);
+            if (this.isRecord(cleanValue)) {
+                cleanValues = {
+                    ...cleanValues,
+                    ...cleanValue,
+                };
+            }
             subFieldErrors.push(subFieldError);
         });
         const filtered = subFieldErrors.filter(subFieldError => Object.keys(subFieldError).length !== 0);
@@ -519,12 +710,13 @@ class ValidationService {
                 modelDefinition: schema,
                 fieldErrors: requiredPropError,
                 isBodyParam,
+                metadata,
             });
             return requiredPropError;
         };
         const schemasWithRequiredProps = schemas.filter(schema => Object.keys(getRequiredPropError(schema)).length === 0);
         if (this.config.noImplicitAdditionalProperties === 'ignore') {
-            return { ...value, ...cleanValues };
+            return this.isRecord(value) ? { ...value, ...cleanValues } : cleanValues;
         }
         if (this.config.noImplicitAdditionalProperties === 'silently-remove-extras') {
             if (schemasWithRequiredProps.length > 0) {
@@ -538,7 +730,7 @@ class ValidationService {
                 return;
             }
         }
-        if (schemasWithRequiredProps.length > 0 && schemasWithRequiredProps.some(schema => this.getExcessPropertiesFor(schema, Object.keys(value)).length === 0)) {
+        if (this.isRecord(value) && schemasWithRequiredProps.length > 0 && schemasWithRequiredProps.some(schema => this.getExcessPropertiesFor(schema, Object.keys(value)).length === 0)) {
             return cleanValues;
         }
         else {
@@ -644,17 +836,18 @@ class ValidationService {
         }
     }
     validateModel(input) {
-        const { name, value, modelDefinition, fieldErrors, isBodyParam, parent = '' } = input;
+        const { name, value, modelDefinition, fieldErrors, isBodyParam, parent = '', metadata } = input;
         const previousErrors = Object.keys(fieldErrors).length;
         if (modelDefinition) {
             if (modelDefinition.dataType === 'refEnum') {
                 return this.validateEnum(name, value, fieldErrors, modelDefinition.enums, parent);
             }
             if (modelDefinition.dataType === 'refAlias') {
-                return this.ValidateParam(modelDefinition.type, value, name, fieldErrors, isBodyParam, parent);
+                return this.ValidateParam(modelDefinition.type, value, name, fieldErrors, isBodyParam, parent, metadata);
             }
             const fieldPath = parent + name;
-            if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+            const childPath = this.buildChildPath(parent, name);
+            if (!this.isRecord(value)) {
                 fieldErrors[fieldPath] = {
                     message: `invalid object`,
                     value,
@@ -665,7 +858,7 @@ class ValidationService {
             const keysOnPropertiesModelDefinition = new Set(Object.keys(properties));
             const allPropertiesOnData = new Set(Object.keys(value));
             Object.entries(properties).forEach(([key, property]) => {
-                const validatedParam = this.ValidateParam(property, value[key], key, fieldErrors, isBodyParam, fieldPath + '.');
+                const validatedParam = this.ValidateParam(property, 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
                 if (validatedParam !== undefined || (property.dataType === 'undefined' && property.required)) {
                     value[key] = validatedParam;
@@ -682,7 +875,7 @@ class ValidationService {
                 Object.keys(value).forEach((key) => {
                     if (isAnExcessProperty(key)) {
                         if (this.config.noImplicitAdditionalProperties === 'throw-on-extras') {
-                            fieldErrors[`${fieldPath}.${key}`] = {
+                            fieldErrors[`${childPath}${key}`] = {
                                 message: `"${key}" is an excess property and therefore is not allowed`,
                                 value: key,
                             };
@@ -702,13 +895,13 @@ class ValidationService {
             else {
                 Object.keys(value).forEach((key) => {
                     if (isAnExcessProperty(key)) {
-                        const validatedValue = this.ValidateParam(additionalProperties, value[key], key, fieldErrors, isBodyParam, fieldPath + '.');
+                        const validatedValue = 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
                         if (validatedValue !== undefined || (additionalProperties.dataType === 'undefined' && additionalProperties.required)) {
                             value[key] = validatedValue;
                         }
                         else {
-                            fieldErrors[`${fieldPath}.${key}`] = {
+                            fieldErrors[`${childPath}${key}`] = {
                                 message: `No matching model found in additionalProperties to validate ${key}`,
                                 value: key,
                             };
@@ -754,14 +947,13 @@ class ValidationService {
             return new Date(obj.getTime());
         }
         if (obj instanceof RegExp) {
-            return new RegExp(obj.source, obj.flags);
+            // Preserve the existing instance instead of reconstructing a pattern from untrusted data.
+            return obj;
         }
-        if (obj instanceof Array) {
-            const cloneArr = new Array(obj.length);
-            for (let i = 0; i < obj.length; i++) {
-                cloneArr[i] = this.deepClone(obj[i]);
-            }
-            return cloneArr;
+        if (Array.isArray(obj)) {
+            const arrayValues = obj;
+            const clonedArray = arrayValues.map(value => this.deepClone(value));
+            return clonedArray;
         }
         if (Buffer && obj instanceof Buffer) {
             return Buffer.from(obj);