@e22m4u/js-repository 0.1.1 → 0.1.3

package/src/adapter/decorator/data-sanitizing-decorator.d.ts

@@ -1,3 +1,4 @@
+import {Adapter} from '../adapter.js';
 import {Service} from '@e22m4u/js-service';
 
 /**
@@ -9,5 +10,5 @@ export declare class DataSanitizingDecorator extends Service {
    *
    * @param adapter
    */
-  decorate(adapter): void;
+  decorate(adapter: Adapter): void;
 }

package/src/adapter/decorator/data-validation-decorator.d.ts

@@ -1,4 +1,5 @@
 import {Service} from '@e22m4u/js-service';
+import {Adapter} from '../adapter.js';
 
 /**
  * Data validation decorator.
@@ -9,5 +10,5 @@ export declare class DataValidationDecorator extends Service {
    *
    * @param adapter
    */
-  decorate(adapter): void;
+  decorate(adapter: Adapter): void;
 }

package/src/adapter/decorator/data-validation-decorator.js

@@ -21,32 +21,40 @@ export class DataValidationDecorator extends Service {
       );
 
     const create = adapter.create;
-    adapter.create = function (modelName, modelData, filter) {
-      this.getService(ModelDataValidator).validate(modelName, modelData);
+    adapter.create = async function (modelName, modelData, filter) {
+      await this.getService(ModelDataValidator).validate(modelName, modelData);
       return create.call(this, modelName, modelData, filter);
     };
 
     const replaceById = adapter.replaceById;
-    adapter.replaceById = function (modelName, id, modelData, filter) {
-      this.getService(ModelDataValidator).validate(modelName, modelData);
+    adapter.replaceById = async function (modelName, id, modelData, filter) {
+      await this.getService(ModelDataValidator).validate(modelName, modelData);
       return replaceById.call(this, modelName, id, modelData, filter);
     };
 
     const replaceOrCreate = adapter.replaceOrCreate;
-    adapter.replaceOrCreate = function (modelName, modelData, filter) {
-      this.getService(ModelDataValidator).validate(modelName, modelData);
+    adapter.replaceOrCreate = async function (modelName, modelData, filter) {
+      await this.getService(ModelDataValidator).validate(modelName, modelData);
       return replaceOrCreate.call(this, modelName, modelData, filter);
     };
 
     const patch = adapter.patch;
-    adapter.patch = function (modelName, modelData, where) {
-      this.getService(ModelDataValidator).validate(modelName, modelData, true);
+    adapter.patch = async function (modelName, modelData, where) {
+      await this.getService(ModelDataValidator).validate(
+        modelName,
+        modelData,
+        true,
+      );
       return patch.call(this, modelName, modelData, where);
     };
 
     const patchById = adapter.patchById;
-    adapter.patchById = function (modelName, id, modelData, filter) {
-      this.getService(ModelDataValidator).validate(modelName, modelData, true);
+    adapter.patchById = async function (modelName, id, modelData, filter) {
+      await this.getService(ModelDataValidator).validate(
+        modelName,
+        modelData,
+        true,
+      );
       return patchById.call(this, modelName, id, modelData, filter);
     };
   }

package/src/adapter/decorator/data-validation-decorator.spec.js

@@ -74,4 +74,44 @@ describe('DataValidationDecorator', function () {
     expect(V.validate).to.be.called.once;
     expect(V.validate).to.be.called.with.exactly('model', data, true);
   });
+
+  it('waits the validator execution in the "create" method', async function () {
+    const schema = new Schema();
+    schema.defineModel({name: 'model'});
+    const adapter = S.getService(TestAdapter);
+    const validator = S.getService(ModelDataValidator);
+    validator.validate = () => Promise.reject('rejected');
+    const promise = adapter.create('model', {});
+    await expect(promise).to.be.rejectedWith('rejected');
+  });
+
+  it('waits the validator execution in the "replaceById" method', async function () {
+    const schema = new Schema();
+    schema.defineModel({name: 'model'});
+    const adapter = S.getService(TestAdapter);
+    const validator = S.getService(ModelDataValidator);
+    validator.validate = () => Promise.reject('rejected');
+    const promise = adapter.replaceById('model', 1, {});
+    await expect(promise).to.be.rejectedWith('rejected');
+  });
+
+  it('waits the validator execution in the "replaceOrCreate" method', async function () {
+    const schema = new Schema();
+    schema.defineModel({name: 'model'});
+    const adapter = S.getService(TestAdapter);
+    const validator = S.getService(ModelDataValidator);
+    validator.validate = () => Promise.reject('rejected');
+    const promise = adapter.replaceOrCreate('model', {});
+    await expect(promise).to.be.rejectedWith('rejected');
+  });
+
+  it('waits the validator execution in the "patchById" method', async function () {
+    const schema = new Schema();
+    schema.defineModel({name: 'model'});
+    const adapter = S.getService(TestAdapter);
+    const validator = S.getService(ModelDataValidator);
+    validator.validate = () => Promise.reject('rejected');
+    const promise = adapter.patchById('model', 1, {});
+    await expect(promise).to.be.rejectedWith('rejected');
+  });
 });

package/src/adapter/decorator/default-values-decorator.d.ts

@@ -1,4 +1,5 @@
 import {Service} from '@e22m4u/js-service';
+import {Adapter} from '../adapter.js';
 
 /**
  * Default values decorator.
@@ -9,5 +10,5 @@ export declare class DefaultValuesDecorator extends Service {
    *
    * @param adapter
    */
-  decorate(adapter): void;
+  decorate(adapter: Adapter): void;
 }

package/src/adapter/decorator/fields-filtering-decorator.d.ts

@@ -1,4 +1,5 @@
 import {Service} from '@e22m4u/js-service';
+import {Adapter} from '../adapter.js';
 
 /**
  * Fields filtering decorator.
@@ -9,5 +10,5 @@ export declare class FieldsFilteringDecorator extends Service {
    *
    * @param adapter
    */
-  decorate(adapter): void;
+  decorate(adapter: Adapter): void;
 }

package/src/adapter/decorator/inclusion-decorator.d.ts

@@ -1,4 +1,5 @@
 import {Service} from '@e22m4u/js-service';
+import {Adapter} from '../adapter.js';
 
 /**
  * Inclusion decorator.
@@ -9,5 +10,5 @@ export declare class InclusionDecorator extends Service {
    *
    * @param adapter
    */
-  decorate(adapter): void;
+  decorate(adapter: Adapter): void;
 }

package/src/definition/model/index.js

@@ -1,5 +1,6 @@
 export * from './relations/index.js';
 export * from './properties/index.js';
+export * from './model-definition.js';
 export * from './model-data-validator.js';
 export * from './model-data-sanitizer.js';
 export * from './model-definition-utils.js';

package/src/definition/model/model-data-validator.d.ts

@@ -1,6 +1,5 @@
 import {ModelData} from '../../types.js';
 import {Service} from '@e22m4u/js-service';
-import {PropertyDefinition} from './properties/index.js';
 
 /**
  * Model data validator.
@@ -13,20 +12,9 @@ export declare class ModelDataValidator extends Service {
    * @param modelData
    * @param isPartial
    */
-  validate(modelName: string, modelData: ModelData, isPartial?: boolean): void;
-
-  /**
-   * Validate property value.
-   *
-   * @param modelName
-   * @param propName
-   * @param propDef
-   * @param propValue
-   */
-  validatePropertyValue(
+  validate(
     modelName: string,
-    propName: string,
-    propDef: PropertyDefinition,
-    propValue: unknown,
-  ): void;
+    modelData: ModelData,
+    isPartial?: boolean,
+  ): Promise<void>;
 }

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

@@ -3,6 +3,7 @@ import {DataType} from './properties/index.js';
 import {getCtorName} from '../../utils/index.js';
 import {isPureObject} from '../../utils/index.js';
 import {InvalidArgumentError} from '../../errors/index.js';
+import {PropertyValidatorRegistry} from './properties/index.js';
 import {ModelDefinitionUtils} from './model-definition-utils.js';
 
 /**
@@ -15,8 +16,9 @@ export class ModelDataValidator extends Service {
    * @param {string} modelName
    * @param {object} modelData
    * @param {boolean} isPartial
+   * @returns {Promise<void>}
    */
-  validate(modelName, modelData, isPartial = false) {
+  async validate(modelName, modelData, isPartial = false) {
     if (!isPureObject(modelData))
       throw new InvalidArgumentError(
         'The data of the model %v should be an Object, but %v given.',
@@ -28,16 +30,16 @@ export class ModelDataValidator extends Service {
         ModelDefinitionUtils,
       ).getPropertiesDefinitionInBaseModelHierarchy(modelName);
     const propNames = Object.keys(isPartial ? modelData : propDefs);
-    propNames.forEach(propName => {
+    for (const propName of propNames) {
       const propDef = propDefs[propName];
-      if (!propDef) return;
-      this._validatePropertyValue(
+      if (!propDef) continue;
+      await this._validatePropertyValue(
         modelName,
         propName,
         propDef,
         modelData[propName],
       );
-    });
+    }
   }
 
   /**
@@ -47,8 +49,9 @@ export class ModelDataValidator extends Service {
    * @param {string} propName
    * @param {string|object} propDef
    * @param {*} propValue
+   * @returns {Promise<void>}
    */
-  _validatePropertyValue(modelName, propName, propDef, propValue) {
+  async _validatePropertyValue(modelName, propName, propDef, propValue) {
     // undefined and null
     if (propValue == null) {
       const isRequired =
@@ -62,7 +65,19 @@ export class ModelDataValidator extends Service {
       );
     }
     // DataType
-    this._validatePropertyValueType(modelName, propName, propDef, propValue);
+    await this._validatePropertyValueType(
+      modelName,
+      propName,
+      propDef,
+      propValue,
+    );
+    // PropertyValidators
+    await this._validateByPropertyValidators(
+      modelName,
+      propName,
+      propDef,
+      propValue,
+    );
   }
 
   /**
@@ -73,9 +88,9 @@ export class ModelDataValidator extends Service {
    * @param {string|object} propDef
    * @param {*} propValue
    * @param {boolean} isArrayValue
-   * @returns {void}
+   * @returns {Promise<void>}
    */
-  _validatePropertyValueType(
+  async _validatePropertyValueType(
     modelName,
     propName,
     propDef,
@@ -123,7 +138,7 @@ export class ModelDataValidator extends Service {
       // ARRAY
       case DataType.ARRAY:
         if (!Array.isArray(propValue)) throw createError('an Array');
-        propValue.forEach(value =>
+        const arrayItemsValidationPromises = propValue.map(async value =>
           this._validatePropertyValueType(
             modelName,
             propName,
@@ -132,13 +147,79 @@ 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)
-          this.validate(propDef.model, propValue);
+          await this.validate(propDef.model, propValue);
         break;
     }
   }
+
+  /**
+   * Validate by property validators.
+   *
+   * @param {string} modelName
+   * @param {string} propName
+   * @param {string|object} propDef
+   * @param {*} propValue
+   * @returns {Promise<void>}
+   */
+  async _validateByPropertyValidators(
+    modelName,
+    propName,
+    propDef,
+    propValue,
+  ) {
+    if (typeof propDef === 'string' || propDef.validate == null) return;
+    const options = propDef.validate;
+    const propertyValidatorRegistry = this.getService(
+      PropertyValidatorRegistry,
+    );
+    const createError = validatorName =>
+      new InvalidArgumentError(
+        'The property %v of the model %v has an invalid value %v ' +
+          'that caught by the validator %v.',
+        propName,
+        modelName,
+        propValue,
+        validatorName,
+      );
+    const container = this.container;
+    const validateBy = async (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);
+    };
+    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);
+        }
+      });
+      await Promise.all(validationPromises);
+    } else {
+      throw new InvalidArgumentError(
+        'The provided option "validate" of the property %v in the model %v ' +
+          'should be a non-empty String, an Array of String or an Object, ' +
+          'but %v given.',
+        propName,
+        modelName,
+        options,
+      );
+    }
+  }
 }