@e22m4u/js-repository 0.1.5 → 0.1.7

package/src/adapter/decorator/default-values-decorator.spec.js

@@ -17,6 +17,7 @@ S.defineModel({
 });
 
 const INPUT_DATA = {};
+const INPUT_DATA_WITH_DEFAULTS = {prop: 'value'};
 
 class TestAdapter extends Adapter {
   // eslint-disable-next-line no-unused-vars
@@ -65,139 +66,114 @@ describe('DefaultValuesDecorator', function () {
   });
 
   it('overrides the "create" method method and sets default values to input data', async function () {
-    sandbox.on(U, 'setDefaultValuesToEmptyProperties');
-    const retval = await A.create('model', INPUT_DATA);
-    expect(retval).to.be.eql({prop: 'value'});
-    expect(U.setDefaultValuesToEmptyProperties).to.be.called.once;
-    expect(U.setDefaultValuesToEmptyProperties).to.be.called.with.exactly(
-      'model',
-      INPUT_DATA,
+    sandbox.on(
+      U,
+      'setDefaultValuesToEmptyProperties',
+      (modelName, modelData, onlyProvidedProperties = false) => {
+        expect(modelName).to.be.eq('model');
+        expect(modelData).to.be.eql(INPUT_DATA);
+        expect(onlyProvidedProperties).to.be.false;
+        return INPUT_DATA_WITH_DEFAULTS;
+      },
     );
+    const res = await A.create('model', INPUT_DATA);
+    expect(res).to.be.eql(INPUT_DATA_WITH_DEFAULTS);
+    expect(U.setDefaultValuesToEmptyProperties).to.be.called.once;
   });
 
   it('overrides the "replaceById" method and sets default values to input data', async function () {
-    sandbox.on(U, 'setDefaultValuesToEmptyProperties');
-    const retval = await A.replaceById('model', 1, INPUT_DATA);
-    expect(retval).to.be.eql({prop: 'value'});
-    expect(U.setDefaultValuesToEmptyProperties).to.be.called.once;
-    expect(U.setDefaultValuesToEmptyProperties).to.be.called.with.exactly(
-      'model',
-      INPUT_DATA,
+    sandbox.on(
+      U,
+      'setDefaultValuesToEmptyProperties',
+      (modelName, modelData, onlyProvidedProperties = false) => {
+        expect(modelName).to.be.eq('model');
+        expect(modelData).to.be.eql(INPUT_DATA);
+        expect(onlyProvidedProperties).to.be.false;
+        return INPUT_DATA_WITH_DEFAULTS;
+      },
     );
+    const res = await A.replaceById('model', 1, INPUT_DATA);
+    expect(res).to.be.eql(INPUT_DATA_WITH_DEFAULTS);
+    expect(U.setDefaultValuesToEmptyProperties).to.be.called.once;
   });
 
   it('overrides the "replaceOrCreate" method and sets default values to input data', async function () {
-    sandbox.on(U, 'setDefaultValuesToEmptyProperties');
-    const retval = await A.replaceOrCreate('model', INPUT_DATA);
-    expect(retval).to.be.eql({prop: 'value'});
-    expect(U.setDefaultValuesToEmptyProperties).to.be.called.once;
-    expect(U.setDefaultValuesToEmptyProperties).to.be.called.with.exactly(
-      'model',
-      INPUT_DATA,
+    sandbox.on(
+      U,
+      'setDefaultValuesToEmptyProperties',
+      (modelName, modelData, onlyProvidedProperties = false) => {
+        expect(modelName).to.be.eq('model');
+        expect(modelData).to.be.eql(INPUT_DATA);
+        expect(onlyProvidedProperties).to.be.false;
+        return INPUT_DATA_WITH_DEFAULTS;
+      },
     );
+    const res = await A.replaceOrCreate('model', INPUT_DATA);
+    expect(res).to.be.eql(INPUT_DATA_WITH_DEFAULTS);
+    expect(U.setDefaultValuesToEmptyProperties).to.be.called.once;
   });
 
-  describe('overrides the "patch" method and sets default values to input data', function () {
-    it('does not set default values to not existing properties of input data', async function () {
-      sandbox.on(U, 'setDefaultValuesToEmptyProperties');
-      const data = {};
-      const retval = await A.patch('model', data);
-      expect(retval).to.be.eql({});
-      expect(U.setDefaultValuesToEmptyProperties).to.be.called.once;
-      expect(U.setDefaultValuesToEmptyProperties).to.be.called.with.exactly(
-        'model',
-        data,
-        true,
-      );
-    });
-
-    it('does set default values to input properties of null', async function () {
-      sandbox.on(U, 'setDefaultValuesToEmptyProperties');
-      const data = {prop: null};
-      const retval = await A.patch('model', data);
-      expect(retval).to.be.eql({prop: 'value'});
-      expect(U.setDefaultValuesToEmptyProperties).to.be.called.once;
-      expect(U.setDefaultValuesToEmptyProperties).to.be.called.with.exactly(
-        'model',
-        data,
-        true,
-      );
-    });
-
-    it('does set default values to input properties of undefined', async function () {
-      sandbox.on(U, 'setDefaultValuesToEmptyProperties');
-      const data = {prop: undefined};
-      const retval = await A.patch('model', data);
-      expect(retval).to.be.eql({prop: 'value'});
-      expect(U.setDefaultValuesToEmptyProperties).to.be.called.once;
-      expect(U.setDefaultValuesToEmptyProperties).to.be.called.with.exactly(
-        'model',
-        data,
-        true,
-      );
-    });
+  it('overrides the "patch" method and sets default values to input data', async function () {
+    sandbox.on(
+      U,
+      'setDefaultValuesToEmptyProperties',
+      (modelName, modelData, onlyProvidedProperties = false) => {
+        expect(modelName).to.be.eq('model');
+        expect(modelData).to.be.eql(INPUT_DATA);
+        expect(onlyProvidedProperties).to.be.true;
+        return INPUT_DATA_WITH_DEFAULTS;
+      },
+    );
+    const res = await A.patch('model', INPUT_DATA);
+    expect(res).to.be.eql(INPUT_DATA_WITH_DEFAULTS);
+    expect(U.setDefaultValuesToEmptyProperties).to.be.called.once;
   });
 
-  describe('overrides the "patchById" method and sets default values to input data', function () {
-    it('does not set default values to not existing properties of input data', async function () {
-      sandbox.on(U, 'setDefaultValuesToEmptyProperties');
-      const data = {};
-      const retval = await A.patchById('model', 1, data);
-      expect(retval).to.be.eql({});
-      expect(U.setDefaultValuesToEmptyProperties).to.be.called.once;
-      expect(U.setDefaultValuesToEmptyProperties).to.be.called.with.exactly(
-        'model',
-        data,
-        true,
-      );
-    });
-
-    it('does set default values to input properties of null', async function () {
-      sandbox.on(U, 'setDefaultValuesToEmptyProperties');
-      const data = {prop: null};
-      const retval = await A.patchById('model', 2, data);
-      expect(retval).to.be.eql({prop: 'value'});
-      expect(U.setDefaultValuesToEmptyProperties).to.be.called.once;
-      expect(U.setDefaultValuesToEmptyProperties).to.be.called.with.exactly(
-        'model',
-        data,
-        true,
-      );
-    });
-
-    it('does set default values to input properties of undefined', async function () {
-      sandbox.on(U, 'setDefaultValuesToEmptyProperties');
-      const data = {prop: undefined};
-      const retval = await A.patchById('model', 3, data);
-      expect(retval).to.be.eql({prop: 'value'});
-      expect(U.setDefaultValuesToEmptyProperties).to.be.called.once;
-      expect(U.setDefaultValuesToEmptyProperties).to.be.called.with.exactly(
-        'model',
-        data,
-        true,
-      );
-    });
+  it('overrides the "patchById" method and sets default values to input data', async function () {
+    sandbox.on(
+      U,
+      'setDefaultValuesToEmptyProperties',
+      (modelName, modelData, onlyProvidedProperties = false) => {
+        expect(modelName).to.be.eq('model');
+        expect(modelData).to.be.eql(INPUT_DATA);
+        expect(onlyProvidedProperties).to.be.true;
+        return INPUT_DATA_WITH_DEFAULTS;
+      },
+    );
+    const res = await A.patchById('model', 1, INPUT_DATA);
+    expect(res).to.be.eql(INPUT_DATA_WITH_DEFAULTS);
+    expect(U.setDefaultValuesToEmptyProperties).to.be.called.once;
   });
 
   it('overrides the "find" method and sets default values to output data', async function () {
-    sandbox.on(U, 'setDefaultValuesToEmptyProperties');
-    const retval = await A.find('model');
-    expect(retval).to.be.eql([{prop: 'value'}]);
-    expect(U.setDefaultValuesToEmptyProperties).to.be.called.once;
-    expect(U.setDefaultValuesToEmptyProperties).to.be.called.with.exactly(
-      'model',
-      INPUT_DATA,
+    sandbox.on(
+      U,
+      'setDefaultValuesToEmptyProperties',
+      (modelName, modelData, onlyProvidedProperties = false) => {
+        expect(modelName).to.be.eq('model');
+        expect(modelData).to.be.eql(INPUT_DATA);
+        expect(onlyProvidedProperties).to.be.false;
+        return INPUT_DATA_WITH_DEFAULTS;
+      },
     );
+    const res = await A.find('model');
+    expect(res).to.be.eql([INPUT_DATA_WITH_DEFAULTS]);
+    expect(U.setDefaultValuesToEmptyProperties).to.be.called.once;
   });
 
   it('overrides the "findById" method and sets default values to output data', async function () {
-    sandbox.on(U, 'setDefaultValuesToEmptyProperties');
-    const retval = await A.findById('model', 1);
-    expect(retval).to.be.eql({prop: 'value'});
-    expect(U.setDefaultValuesToEmptyProperties).to.be.called.once;
-    expect(U.setDefaultValuesToEmptyProperties).to.be.called.with.exactly(
-      'model',
-      INPUT_DATA,
+    sandbox.on(
+      U,
+      'setDefaultValuesToEmptyProperties',
+      (modelName, modelData, onlyProvidedProperties = false) => {
+        expect(modelName).to.be.eq('model');
+        expect(modelData).to.be.eql(INPUT_DATA);
+        expect(onlyProvidedProperties).to.be.false;
+        return INPUT_DATA_WITH_DEFAULTS;
+      },
     );
+    const res = await A.findById('model', 1);
+    expect(res).to.be.eql(INPUT_DATA_WITH_DEFAULTS);
+    expect(U.setDefaultValuesToEmptyProperties).to.be.called.once;
   });
 });

package/src/adapter/decorator/index.d.ts

@@ -3,3 +3,4 @@ export * from './default-values-decorator.js';
 export * from './data-sanitizing-decorator.js';
 export * from './data-validation-decorator.js';
 export * from './fields-filtering-decorator.js';
+export * from './data-transformation-decorator.js';

package/src/adapter/decorator/index.js

@@ -3,3 +3,4 @@ export * from './default-values-decorator.js';
 export * from './data-sanitizing-decorator.js';
 export * from './data-validation-decorator.js';
 export * from './fields-filtering-decorator.js';
+export * from './data-transformation-decorator.js';

package/src/definition/model/index.d.ts

@@ -3,5 +3,6 @@ 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-data-transformer.js';
 export * from './model-definition-utils.js';
 export * from './model-definition-validator.js';

package/src/definition/model/index.js

@@ -3,5 +3,6 @@ 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-data-transformer.js';
 export * from './model-definition-utils.js';
 export * from './model-definition-validator.js';

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

@@ -0,0 +1,15 @@
+import {ModelData} from '../../types.js';
+import {Service} from '@e22m4u/js-service';
+
+/**
+ * Model data transformer.
+ */
+export declare class ModelDataTransformer extends Service {
+  /**
+   * Transform.
+   *
+   * @param modelName
+   * @param modelData
+   */
+  transform(modelName: string, modelData: ModelData): ModelData;
+}

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,
+      );
+    }
+  }
+}