@e22m4u/js-repository 0.1.6 → 0.1.7

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

@@ -0,0 +1,96 @@
+import {Service} from '@e22m4u/js-service';
+import {cloneDeep} from '../../utils/index.js';
+import {isPureObject} from '../../utils/index.js';
+import {InvalidArgumentError} from '../../errors/index.js';
+import {ModelDefinitionUtils} from './model-definition-utils.js';
+import {PropertyTransformerRegistry} from './properties/index.js';
+
+/**
+ * Model data transformer.
+ */
+export class ModelDataTransformer extends Service {
+  /**
+   * Transform.
+   *
+   * @param {string} modelName
+   * @param {object} modelData
+   * @param {boolean} isPartial
+   * @returns {object}
+   */
+  transform(modelName, modelData, isPartial = false) {
+    if (!isPureObject(modelData))
+      throw new InvalidArgumentError(
+        'The data of the model %v should be an Object, but %v given.',
+        modelName,
+        modelData,
+      );
+    const propDefs =
+      this.getService(
+        ModelDefinitionUtils,
+      ).getPropertiesDefinitionInBaseModelHierarchy(modelName);
+    const transformedData = cloneDeep(modelData);
+    const propNames = Object.keys(isPartial ? modelData : propDefs);
+    propNames.forEach(propName => {
+      const propDef = propDefs[propName];
+      if (!propDef) return;
+      const oldValue = modelData[propName];
+      const newValue = this._transformPropertyValue(
+        modelName,
+        propName,
+        propDef,
+        oldValue,
+      );
+      if (oldValue !== newValue) {
+        transformedData[propName] = newValue;
+      }
+    });
+    return transformedData;
+  }
+
+  /**
+   * Transform property value.
+   *
+   * @param {string} modelName
+   * @param {string} propName
+   * @param {string|object} propDef
+   * @param {*} propValue
+   * @returns {*}
+   */
+  _transformPropertyValue(modelName, propName, propDef, propValue) {
+    if (typeof propDef === 'string' || propDef.transform == null)
+      return propValue;
+    const transformDef = propDef.transform;
+    const transformerRegistry = this.getService(PropertyTransformerRegistry);
+    const transformFn = (
+      value,
+      transformerName,
+      transformerOptions = undefined,
+    ) => {
+      const transformer = transformerRegistry.getTransformer(transformerName);
+      const context = {transformerName, modelName, propName};
+      return transformer(value, transformerOptions, context);
+    };
+    if (transformDef && typeof transformDef === 'string') {
+      return transformFn(propValue, transformDef);
+    } else if (Array.isArray(transformDef)) {
+      return transformDef.reduce(
+        (value, transformerName) => transformFn(value, transformerName),
+        propValue,
+      );
+    } else if (transformDef !== null && typeof transformDef === 'object') {
+      return Object.keys(transformDef).reduce((value, transformerName) => {
+        const transformerOptions = transformDef[transformerName];
+        return transformFn(value, transformerName, transformerOptions);
+      }, propValue);
+    } else {
+      throw new InvalidArgumentError(
+        'The provided option "transform" 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,
+        transformDef,
+      );
+    }
+  }
+}

package/src/definition/model/model-data-transformer.spec.js

@@ -0,0 +1,534 @@
+import {expect} from 'chai';
+import {Schema} from '../../schema.js';
+import {format} from '@e22m4u/js-format';
+import {DataType} from './properties/index.js';
+import {DefinitionRegistry} from '../definition-registry.js';
+import {ModelDataTransformer} from './model-data-transformer.js';
+import {PropertyTransformerRegistry} from './properties/index.js';
+
+describe('ModelDataTransformer', function () {
+  describe('transform', function () {
+    it('throws an error if the given model name is not defined', function () {
+      const schema = new Schema();
+      const T = schema.getService(ModelDataTransformer);
+      const throwable = () => T.transform('model', {});
+      expect(throwable).to.throw('The model "model" is not defined.');
+    });
+
+    it('throws an error if the given model data is not a pure object', function () {
+      const schema = new Schema();
+      const T = schema.getService(ModelDataTransformer);
+      const throwable = v => () => T.transform('model', v);
+      const error = v =>
+        format(
+          'The data of the model "model" should be an Object, but %s given.',
+          v,
+        );
+      expect(throwable('str')).to.throw(error('"str"'));
+      expect(throwable('')).to.throw(error('""'));
+      expect(throwable(10)).to.throw(error('10'));
+      expect(throwable(0)).to.throw(error('0'));
+      expect(throwable(true)).to.throw(error('true'));
+      expect(throwable(false)).to.throw(error('false'));
+      expect(throwable(undefined)).to.throw(error('undefined'));
+      expect(throwable(null)).to.throw(error('null'));
+      expect(throwable([])).to.throw(error('Array'));
+      expect(throwable(new Date())).to.throw(error('Date'));
+    });
+
+    it('does nothing with the given model if no transformers are set', function () {
+      const schema = new Schema();
+      schema.defineModel({
+        name: 'model',
+        properties: {
+          foo: DataType.STRING,
+          bar: {
+            type: DataType.STRING,
+            default: 'test',
+          },
+        },
+      });
+      const T = schema.getService(ModelDataTransformer);
+      const modelData = {baz: 'qux'};
+      const res = T.transform('model', modelData);
+      expect(res).to.be.eql(modelData);
+    });
+
+    describe('the option "transform" with a string value', function () {
+      it('transforms the property value by its transformer', function () {
+        const schema = new Schema();
+        const myTransformer = value => String(value);
+        schema
+          .getService(PropertyTransformerRegistry)
+          .addTransformer('myTransformer', myTransformer);
+        schema.defineModel({
+          name: 'model',
+          properties: {
+            foo: {
+              type: DataType.ANY,
+              transform: 'myTransformer',
+            },
+          },
+        });
+        const T = schema.getService(ModelDataTransformer);
+        const res = T.transform('model', {foo: 10});
+        expect(res).to.be.eql({foo: '10'});
+      });
+
+      it('passes specific arguments to the transformer function', function () {
+        const schema = new Schema();
+        const myTransformer = (value, options, context) => {
+          expect(value).to.be.eq('input');
+          expect(options).to.be.undefined;
+          expect(context).to.be.eql({
+            transformerName: 'myTransformer',
+            modelName: 'model',
+            propName: 'foo',
+          });
+          return 'transformed';
+        };
+        schema
+          .getService(PropertyTransformerRegistry)
+          .addTransformer('myTransformer', myTransformer);
+        schema.defineModel({
+          name: 'model',
+          properties: {
+            foo: {
+              type: DataType.ANY,
+              transform: 'myTransformer',
+            },
+          },
+        });
+        const T = schema.getService(ModelDataTransformer);
+        const res = T.transform('model', {foo: 'input'});
+        expect(res).to.be.eql({foo: 'transformed'});
+      });
+
+      it('transforms a property value even it is not provided', function () {
+        const schema = new Schema();
+        const myTransformer = () => 'transformed';
+        schema
+          .getService(PropertyTransformerRegistry)
+          .addTransformer('myTransformer', myTransformer);
+        schema.defineModel({
+          name: 'model',
+          properties: {
+            foo: {
+              type: DataType.STRING,
+              transform: 'myTransformer',
+            },
+          },
+        });
+        const T = schema.getService(ModelDataTransformer);
+        const res = T.transform('model', {});
+        expect(res).to.be.eql({foo: 'transformed'});
+      });
+
+      it('transforms undefined and null values', function () {
+        const schema = new Schema();
+        const myTransformer = () => 'transformed';
+        schema
+          .getService(PropertyTransformerRegistry)
+          .addTransformer('myTransformer', myTransformer);
+        schema.defineModel({
+          name: 'model',
+          properties: {
+            foo: {
+              type: DataType.STRING,
+              transform: 'myTransformer',
+            },
+          },
+        });
+        const T = schema.getService(ModelDataTransformer);
+        const res1 = T.transform('model', {foo: undefined});
+        const res2 = T.transform('model', {foo: null});
+        expect(res1).to.be.eql({foo: 'transformed'});
+        expect(res2).to.be.eql({foo: 'transformed'});
+      });
+
+      it('the parameter "isPartial" prevents to transform values of not provided properties', function () {
+        const schema = new Schema();
+        const myTransformer = () => 'transformed';
+        schema
+          .getService(PropertyTransformerRegistry)
+          .addTransformer('myTransformer', myTransformer);
+        schema.defineModel({
+          name: 'model',
+          properties: {
+            foo: {
+              type: DataType.STRING,
+              transform: 'myTransformer',
+            },
+          },
+        });
+        const T = schema.getService(ModelDataTransformer);
+        const res1 = T.transform('model', {});
+        const res2 = T.transform('model', {}, true);
+        expect(res1).to.be.eql({foo: 'transformed'});
+        expect(res2).to.be.eql({});
+      });
+    });
+
+    describe('the option "transform" with an array value', function () {
+      it('transforms given properties by their transformers', function () {
+        const schema = new Schema();
+        const myTransformer = value => String(value);
+        schema
+          .getService(PropertyTransformerRegistry)
+          .addTransformer('myTransformer', myTransformer);
+        schema.defineModel({
+          name: 'model',
+          properties: {
+            foo: {
+              type: DataType.ANY,
+              transform: ['myTransformer'],
+            },
+            bar: {
+              type: DataType.ANY,
+              transform: ['myTransformer'],
+            },
+            baz: {
+              type: DataType.ANY,
+              transform: ['myTransformer'],
+            },
+          },
+        });
+        const T = schema.getService(ModelDataTransformer);
+        const res = T.transform('model', {foo: 1, bar: 2, baz: 3});
+        expect(res).to.be.eql({foo: '1', bar: '2', baz: '3'});
+      });
+
+      it('transforms the property value by its transformers in specified order', function () {
+        const schema = new Schema();
+        const order = [];
+        const myTransformer1 = value => {
+          order.push('myTransformer1');
+          return value + '1';
+        };
+        const myTransformer2 = value => {
+          order.push('myTransformer2');
+          return value + '2';
+        };
+        schema
+          .getService(PropertyTransformerRegistry)
+          .addTransformer('myTransformer1', myTransformer1)
+          .addTransformer('myTransformer2', myTransformer2);
+        schema.defineModel({
+          name: 'model',
+          properties: {
+            foo: {
+              type: DataType.ANY,
+              transform: ['myTransformer1', 'myTransformer2'],
+            },
+          },
+        });
+        const T = schema.getService(ModelDataTransformer);
+        const res = T.transform('model', {foo: 'value'});
+        expect(res).to.be.eql({foo: 'value12'});
+        expect(order).to.be.eql(['myTransformer1', 'myTransformer2']);
+      });
+
+      it('passes specific arguments to the transformer function', function () {
+        const schema = new Schema();
+        const myTransformer = (value, options, context) => {
+          expect(value).to.be.eq('input');
+          expect(options).to.be.undefined;
+          expect(context).to.be.eql({
+            transformerName: 'myTransformer',
+            modelName: 'model',
+            propName: 'foo',
+          });
+          return 'transformed';
+        };
+        schema
+          .getService(PropertyTransformerRegistry)
+          .addTransformer('myTransformer', myTransformer);
+        schema.defineModel({
+          name: 'model',
+          properties: {
+            foo: {
+              type: DataType.ANY,
+              transform: ['myTransformer'],
+            },
+          },
+        });
+        const T = schema.getService(ModelDataTransformer);
+        const res = T.transform('model', {foo: 'input'});
+        expect(res).to.be.eql({foo: 'transformed'});
+      });
+
+      it('transforms a property value even it is not provided', function () {
+        const schema = new Schema();
+        const myTransformer = () => 'transformed';
+        schema
+          .getService(PropertyTransformerRegistry)
+          .addTransformer('myTransformer', myTransformer);
+        schema.defineModel({
+          name: 'model',
+          properties: {
+            foo: {
+              type: DataType.STRING,
+              transform: ['myTransformer'],
+            },
+          },
+        });
+        const T = schema.getService(ModelDataTransformer);
+        const res = T.transform('model', {});
+        expect(res).to.be.eql({foo: 'transformed'});
+      });
+
+      it('transforms undefined and null values', function () {
+        const schema = new Schema();
+        const myTransformer = () => 'transformed';
+        schema
+          .getService(PropertyTransformerRegistry)
+          .addTransformer('myTransformer', myTransformer);
+        schema.defineModel({
+          name: 'model',
+          properties: {
+            foo: {
+              type: DataType.STRING,
+              transform: ['myTransformer'],
+            },
+          },
+        });
+        const T = schema.getService(ModelDataTransformer);
+        const res1 = T.transform('model', {foo: undefined});
+        const res2 = T.transform('model', {foo: null});
+        expect(res1).to.be.eql({foo: 'transformed'});
+        expect(res2).to.be.eql({foo: 'transformed'});
+      });
+
+      it('the parameter "isPartial" prevents to transform values of not provided properties', function () {
+        const schema = new Schema();
+        const myTransformer = () => 'transformed';
+        schema
+          .getService(PropertyTransformerRegistry)
+          .addTransformer('myTransformer', myTransformer);
+        schema.defineModel({
+          name: 'model',
+          properties: {
+            foo: {
+              type: DataType.STRING,
+              transform: ['myTransformer'],
+            },
+          },
+        });
+        const T = schema.getService(ModelDataTransformer);
+        const res1 = T.transform('model', {});
+        const res2 = T.transform('model', {}, true);
+        expect(res1).to.be.eql({foo: 'transformed'});
+        expect(res2).to.be.eql({});
+      });
+    });
+
+    describe('the option "transform" with an object value', function () {
+      it('transforms given properties by their transformers', function () {
+        const schema = new Schema();
+        const myTransformer = value => String(value);
+        schema
+          .getService(PropertyTransformerRegistry)
+          .addTransformer('myTransformer', myTransformer);
+        schema.defineModel({
+          name: 'model',
+          properties: {
+            foo: {
+              type: DataType.ANY,
+              transform: {myTransformer: true},
+            },
+            bar: {
+              type: DataType.ANY,
+              transform: {myTransformer: true},
+            },
+            baz: {
+              type: DataType.ANY,
+              transform: {myTransformer: true},
+            },
+          },
+        });
+        const T = schema.getService(ModelDataTransformer);
+        const res = T.transform('model', {foo: 1, bar: 2, baz: 3});
+        expect(res).to.be.eql({foo: '1', bar: '2', baz: '3'});
+      });
+
+      it('transforms the property value by its transformers in specified order', function () {
+        const schema = new Schema();
+        const order = [];
+        const myTransformer1 = value => {
+          order.push('myTransformer1');
+          return value + '1';
+        };
+        const myTransformer2 = value => {
+          order.push('myTransformer2');
+          return value + '2';
+        };
+        schema
+          .getService(PropertyTransformerRegistry)
+          .addTransformer('myTransformer1', myTransformer1)
+          .addTransformer('myTransformer2', myTransformer2);
+        schema.defineModel({
+          name: 'model',
+          properties: {
+            foo: {
+              type: DataType.ANY,
+              transform: {
+                myTransformer1: true,
+                myTransformer2: true,
+              },
+            },
+          },
+        });
+        const T = schema.getService(ModelDataTransformer);
+        const res = T.transform('model', {foo: 'value'});
+        expect(res).to.be.eql({foo: 'value12'});
+        expect(order).to.be.eql(['myTransformer1', 'myTransformer2']);
+      });
+
+      it('passes specific arguments to the transformer function', function () {
+        const schema = new Schema();
+        const myTransformer = (value, options, context) => {
+          expect(value).to.be.eq('input');
+          expect(options).to.be.eql({
+            option1: 'value1',
+            option2: 'value2',
+          });
+          expect(context).to.be.eql({
+            transformerName: 'myTransformer',
+            modelName: 'model',
+            propName: 'foo',
+          });
+          return 'transformed';
+        };
+        schema
+          .getService(PropertyTransformerRegistry)
+          .addTransformer('myTransformer', myTransformer);
+        schema.defineModel({
+          name: 'model',
+          properties: {
+            foo: {
+              type: DataType.ANY,
+              transform: {
+                myTransformer: {
+                  option1: 'value1',
+                  option2: 'value2',
+                },
+              },
+            },
+          },
+        });
+        const T = schema.getService(ModelDataTransformer);
+        const res = T.transform('model', {foo: 'input'});
+        expect(res).to.be.eql({foo: 'transformed'});
+      });
+
+      it('transforms a property value even it is not provided', function () {
+        const schema = new Schema();
+        const myTransformer = () => 'transformed';
+        schema
+          .getService(PropertyTransformerRegistry)
+          .addTransformer('myTransformer', myTransformer);
+        schema.defineModel({
+          name: 'model',
+          properties: {
+            foo: {
+              type: DataType.STRING,
+              transform: {
+                myTransformer: true,
+              },
+            },
+          },
+        });
+        const T = schema.getService(ModelDataTransformer);
+        const res = T.transform('model', {});
+        expect(res).to.be.eql({foo: 'transformed'});
+      });
+
+      it('transforms undefined and null values', function () {
+        const schema = new Schema();
+        const myTransformer = () => 'transformed';
+        schema
+          .getService(PropertyTransformerRegistry)
+          .addTransformer('myTransformer', myTransformer);
+        schema.defineModel({
+          name: 'model',
+          properties: {
+            foo: {
+              type: DataType.STRING,
+              transform: {
+                myTransformer: true,
+              },
+            },
+          },
+        });
+        const T = schema.getService(ModelDataTransformer);
+        const res1 = T.transform('model', {foo: undefined});
+        const res2 = T.transform('model', {foo: null});
+        expect(res1).to.be.eql({foo: 'transformed'});
+        expect(res2).to.be.eql({foo: 'transformed'});
+      });
+
+      it('the parameter "isPartial" prevents to transform values of not provided properties', function () {
+        const schema = new Schema();
+        const myTransformer = () => 'transformed';
+        schema
+          .getService(PropertyTransformerRegistry)
+          .addTransformer('myTransformer', myTransformer);
+        schema.defineModel({
+          name: 'model',
+          properties: {
+            foo: {
+              type: DataType.STRING,
+              transform: {
+                myTransformer: true,
+              },
+            },
+          },
+        });
+        const T = schema.getService(ModelDataTransformer);
+        const res1 = T.transform('model', {});
+        const res2 = T.transform('model', {}, true);
+        expect(res1).to.be.eql({foo: 'transformed'});
+        expect(res2).to.be.eql({});
+      });
+    });
+
+    it('the option "transform" requires a non-empty String, an Array or an Object', function () {
+      const schema = new Schema();
+      schema
+        .getService(PropertyTransformerRegistry)
+        .addTransformer('myTransformer', () => 'transformed');
+      schema.defineModel({
+        name: 'model',
+        properties: {
+          foo: {
+            type: DataType.STRING,
+            transform: undefined,
+          },
+        },
+      });
+      const T = schema.getService(ModelDataTransformer);
+      const throwable = v => () => {
+        const models = schema.getService(DefinitionRegistry)['_models'];
+        models.model.properties.foo.transform = v;
+        T.transform('model', {});
+      };
+      const error = v =>
+        format(
+          'The provided option "transform" of the property "foo" in the model "model" ' +
+            'should be a non-empty String, an Array of String or an Object, ' +
+            'but %s given.',
+          v,
+        );
+      expect(throwable('')).to.throw(error('""'));
+      expect(throwable(10)).to.throw(error('10'));
+      expect(throwable(0)).to.throw(error('0'));
+      expect(throwable(true)).to.throw(error('true'));
+      expect(throwable(false)).to.throw(error('false'));
+      throwable('myTransformer')();
+      throwable(['myTransformer'])();
+      throwable([])();
+      throwable({myTransformer: true})();
+      throwable({})();
+    });
+  });
+});

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

@@ -52,6 +52,13 @@ export class ModelDataValidator extends Service {
    * @returns {undefined}
    */
   _validatePropertyValue(modelName, propName, propDef, propValue) {
+    // property validators
+    this._validateValueByPropertyValidators(
+      modelName,
+      propName,
+      propDef,
+      propValue,
+    );
     // undefined and null
     if (propValue == null) {
       const isRequired =
@@ -64,15 +71,8 @@ export class ModelDataValidator extends Service {
         propValue,
       );
     }
-    // Property type.
+    // property type
     this._validateValueByPropertyType(modelName, propName, propDef, propValue);
-    // Property validators.
-    this._validateValueByPropertyValidators(
-      modelName,
-      propName,
-      propDef,
-      propValue,
-    );
   }
 
   /**
@@ -164,9 +164,7 @@ export class ModelDataValidator extends Service {
   _validateValueByPropertyValidators(modelName, propName, propDef, propValue) {
     if (typeof propDef === 'string' || propDef.validate == null) return;
     const validateDef = propDef.validate;
-    const propertyValidatorRegistry = this.getService(
-      PropertyValidatorRegistry,
-    );
+    const validatorRegistry = this.getService(PropertyValidatorRegistry);
     const createError = validatorName =>
       new InvalidArgumentError(
         'The property %v of the model %v has an invalid value %v ' +
@@ -177,7 +175,7 @@ export class ModelDataValidator extends Service {
         validatorName,
       );
     const validateBy = (validatorName, validatorOptions = undefined) => {
-      const validator = propertyValidatorRegistry.getValidator(validatorName);
+      const validator = validatorRegistry.getValidator(validatorName);
       const context = {validatorName, modelName, propName};
       const valid = validator(propValue, validatorOptions, context);
       if (valid instanceof Promise) {