@e22m4u/js-repository 0.1.5 → 0.1.6

package/src/definition/model/model-data-validator.js

@@ -16,9 +16,9 @@ export class ModelDataValidator extends Service {
    * @param {string} modelName
    * @param {object} modelData
    * @param {boolean} isPartial
-   * @returns {Promise<void>}
+   * @returns {undefined}
    */
-  async validate(modelName, modelData, isPartial = false) {
+  validate(modelName, modelData, isPartial = false) {
     if (!isPureObject(modelData))
       throw new InvalidArgumentError(
         'The data of the model %v should be an Object, but %v given.',
@@ -30,16 +30,16 @@ export class ModelDataValidator extends Service {
         ModelDefinitionUtils,
       ).getPropertiesDefinitionInBaseModelHierarchy(modelName);
     const propNames = Object.keys(isPartial ? modelData : propDefs);
-    for (const propName of propNames) {
+    propNames.forEach(propName => {
       const propDef = propDefs[propName];
-      if (!propDef) continue;
-      await this._validatePropertyValue(
+      if (!propDef) return;
+      this._validatePropertyValue(
         modelName,
         propName,
         propDef,
         modelData[propName],
       );
-    }
+    });
   }
 
   /**
@@ -49,9 +49,9 @@ export class ModelDataValidator extends Service {
    * @param {string} propName
    * @param {string|object} propDef
    * @param {*} propValue
-   * @returns {Promise<void>}
+   * @returns {undefined}
    */
-  async _validatePropertyValue(modelName, propName, propDef, propValue) {
+  _validatePropertyValue(modelName, propName, propDef, propValue) {
     // undefined and null
     if (propValue == null) {
       const isRequired =
@@ -65,9 +65,9 @@ export class ModelDataValidator extends Service {
       );
     }
     // Property type.
-    await this._validateByPropertyType(modelName, propName, propDef, propValue);
+    this._validateValueByPropertyType(modelName, propName, propDef, propValue);
     // Property validators.
-    await this._validateByPropertyValidators(
+    this._validateValueByPropertyValidators(
       modelName,
       propName,
       propDef,
@@ -76,16 +76,16 @@ export class ModelDataValidator extends Service {
   }
 
   /**
-   * Validate by property type.
+   * Validate value by property type.
    *
    * @param {string} modelName
    * @param {string} propName
    * @param {string|object} propDef
    * @param {*} propValue
    * @param {boolean} isArrayValue
-   * @returns {Promise<void>}
+   * @returns {undefined}
    */
-  async _validateByPropertyType(
+  _validateValueByPropertyType(
     modelName,
     propName,
     propDef,
@@ -133,8 +133,8 @@ export class ModelDataValidator extends Service {
       // ARRAY
       case DataType.ARRAY:
         if (!Array.isArray(propValue)) throw createError('an Array');
-        const arrayItemsValidationPromises = propValue.map(async value =>
-          this._validateByPropertyType(
+        propValue.forEach(value =>
+          this._validateValueByPropertyType(
             modelName,
             propName,
             propDef,
@@ -142,29 +142,28 @@ export class ModelDataValidator extends Service {
             true,
           ),
         );
-        await Promise.all(arrayItemsValidationPromises);
         break;
       // OBJECT
       case DataType.OBJECT:
         if (!isPureObject(propValue)) throw createError('an Object');
         if (typeof propDef === 'object' && propDef.model)
-          await this.validate(propDef.model, propValue);
+          this.validate(propDef.model, propValue);
         break;
     }
   }
 
   /**
-   * Validate by property validators.
+   * Validate value by property validators.
    *
    * @param {string} modelName
    * @param {string} propName
    * @param {string|object} propDef
    * @param {*} propValue
-   * @returns {Promise<void>}
+   * @returns {undefined}
    */
-  async _validateByPropertyValidators(modelName, propName, propDef, propValue) {
+  _validateValueByPropertyValidators(modelName, propName, propDef, propValue) {
     if (typeof propDef === 'string' || propDef.validate == null) return;
-    const options = propDef.validate;
+    const validateDef = propDef.validate;
     const propertyValidatorRegistry = this.getService(
       PropertyValidatorRegistry,
     );
@@ -177,30 +176,31 @@ export class ModelDataValidator extends Service {
         propValue,
         validatorName,
       );
-    const container = this.container;
-    const validateBy = async (validatorName, validatorOptions = undefined) => {
+    const validateBy = (validatorName, validatorOptions = undefined) => {
       const validator = propertyValidatorRegistry.getValidator(validatorName);
-      const context = {validatorName, modelName, propName, propDef, container};
-      const valid = await validator(propValue, validatorOptions, context);
-      if (valid !== true) throw createError(validatorName);
+      const context = {validatorName, modelName, propName};
+      const valid = validator(propValue, validatorOptions, context);
+      if (valid instanceof Promise) {
+        throw new InvalidArgumentError(
+          'Asynchronous property validators are not supported, ' +
+            'but the property validator %v returns a Promise.',
+          validatorName,
+        );
+      } else if (valid !== true) {
+        throw createError(validatorName);
+      }
     };
-    if (options && typeof options === 'string') {
-      await validateBy(options);
-    } else if (Array.isArray(options)) {
-      const validationPromises = options.map(validatorName =>
-        validateBy(validatorName),
-      );
-      await Promise.all(validationPromises);
-    } else if (options !== null && typeof options === 'object') {
-      const validationPromises = [];
-      Object.keys(options).forEach(validatorName => {
-        if (Object.prototype.hasOwnProperty.call(options, validatorName)) {
-          const validatorOptions = options[validatorName];
-          const validationPromise = validateBy(validatorName, validatorOptions);
-          validationPromises.push(validationPromise);
+    if (validateDef && typeof validateDef === 'string') {
+      validateBy(validateDef);
+    } else if (Array.isArray(validateDef)) {
+      validateDef.forEach(validatorName => validateBy(validatorName));
+    } else if (validateDef !== null && typeof validateDef === 'object') {
+      Object.keys(validateDef).forEach(validatorName => {
+        if (Object.prototype.hasOwnProperty.call(validateDef, validatorName)) {
+          const validatorOptions = validateDef[validatorName];
+          validateBy(validatorName, validatorOptions);
         }
       });
-      await Promise.all(validationPromises);
     } else {
       throw new InvalidArgumentError(
         'The provided option "validate" of the property %v in the model %v ' +
@@ -208,7 +208,7 @@ export class ModelDataValidator extends Service {
           'but %v given.',
         propName,
         modelName,
-        options,
+        validateDef,
       );
     }
   }