@e22m4u/js-repository 0.1.6 → 0.1.7

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

@@ -0,0 +1,54 @@
+import {Adapter} from '../adapter.js';
+import {Service} from '@e22m4u/js-service';
+import {InvalidArgumentError} from '../../errors/index.js';
+import {ModelDataTransformer} from '../../definition/index.js';
+
+/**
+ * Data transformation decorator.
+ */
+export class DataTransformationDecorator extends Service {
+  /**
+   * Decorate.
+   *
+   * @param {Adapter} adapter
+   */
+  decorate(adapter) {
+    if (!adapter || !(adapter instanceof Adapter))
+      throw new InvalidArgumentError(
+        'The first argument of DataTransformerDecorator.decorate should be ' +
+          'an Adapter instance, but %v given.',
+        adapter,
+      );
+    const transformer = this.getService(ModelDataTransformer);
+
+    const create = adapter.create;
+    adapter.create = function (modelName, modelData, filter) {
+      modelData = transformer.transform(modelName, modelData);
+      return create.call(this, modelName, modelData, filter);
+    };
+
+    const replaceById = adapter.replaceById;
+    adapter.replaceById = function (modelName, id, modelData, filter) {
+      modelData = transformer.transform(modelName, modelData);
+      return replaceById.call(this, modelName, id, modelData, filter);
+    };
+
+    const replaceOrCreate = adapter.replaceOrCreate;
+    adapter.replaceOrCreate = function (modelName, modelData, filter) {
+      modelData = transformer.transform(modelName, modelData);
+      return replaceOrCreate.call(this, modelName, modelData, filter);
+    };
+
+    const patch = adapter.patch;
+    adapter.patch = function (modelName, modelData, where) {
+      modelData = transformer.transform(modelName, modelData, true);
+      return patch.call(this, modelName, modelData, where);
+    };
+
+    const patchById = adapter.patchById;
+    adapter.patchById = function (modelName, id, modelData, filter) {
+      modelData = transformer.transform(modelName, modelData, true);
+      return patchById.call(this, modelName, id, modelData, filter);
+    };
+  }
+}

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

@@ -0,0 +1,95 @@
+import chai from 'chai';
+import {expect} from 'chai';
+import {Adapter} from '../adapter.js';
+import {Schema} from '../../schema.js';
+import {ModelDataTransformer} from '../../definition/index.js';
+
+const S = new Schema();
+S.defineModel({name: 'model'});
+
+class TestAdapter extends Adapter {
+  // eslint-disable-next-line no-unused-vars
+  create(modelName, modelData, filter = undefined) {
+    return Promise.resolve(modelData);
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  replaceById(modelName, id, modelData, filter = undefined) {
+    return Promise.resolve(modelData);
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  replaceOrCreate(modelName, modelData, filter = undefined) {
+    return Promise.resolve(modelData);
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  patch(modelName, modelData, where = undefined) {
+    return Promise.resolve(modelData);
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  patchById(modelName, id, modelData, filter = undefined) {
+    return Promise.resolve(modelData);
+  }
+}
+
+const A = S.getService(TestAdapter);
+const V = S.getService(ModelDataTransformer);
+const sandbox = chai.spy.sandbox();
+
+describe('DataTransformationDecorator', function () {
+  afterEach(function () {
+    sandbox.restore();
+  });
+
+  it('overrides the "create" method and transforms a given data', async function () {
+    const modelData = {kind: 'modelData'};
+    const transformedData = {kind: 'transformedData'};
+    sandbox.on(V, 'transform', () => transformedData);
+    const res = await A.create('model', modelData);
+    expect(res).to.be.eql(transformedData);
+    expect(V.transform).to.be.called.once;
+    expect(V.transform).to.be.called.with.exactly('model', modelData);
+  });
+
+  it('overrides the "replaceById" method and transforms a given data', async function () {
+    const modelData = {kind: 'modelData'};
+    const transformedData = {kind: 'transformedData'};
+    sandbox.on(V, 'transform', () => transformedData);
+    const res = await A.replaceById('model', 1, modelData);
+    expect(res).to.be.eql(transformedData);
+    expect(V.transform).to.be.called.once;
+    expect(V.transform).to.be.called.with.exactly('model', modelData);
+  });
+
+  it('overrides the "replaceOrCreate" method and transforms a given data', async function () {
+    const modelData = {kind: 'modelData'};
+    const transformedData = {kind: 'transformedData'};
+    sandbox.on(V, 'transform', () => transformedData);
+    const res = await A.replaceOrCreate('model', modelData);
+    expect(res).to.be.eql(transformedData);
+    expect(V.transform).to.be.called.once;
+    expect(V.transform).to.be.called.with.exactly('model', modelData);
+  });
+
+  it('overrides the "patch" method and transforms a given data', async function () {
+    const modelData = {kind: 'modelData'};
+    const transformedData = {kind: 'transformedData'};
+    sandbox.on(V, 'transform', () => transformedData);
+    const res = await A.patch('model', modelData);
+    expect(res).to.be.eql(transformedData);
+    expect(V.transform).to.be.called.once;
+    expect(V.transform).to.be.called.with.exactly('model', modelData, true);
+  });
+
+  it('overrides the "patchById" method and transforms a given data', async function () {
+    const modelData = {kind: 'modelData'};
+    const transformedData = {kind: 'transformedData'};
+    sandbox.on(V, 'transform', () => transformedData);
+    const res = await A.patchById('model', 1, modelData);
+    expect(res).to.be.eql(transformedData);
+    expect(V.transform).to.be.called.once;
+    expect(V.transform).to.be.called.with.exactly('model', modelData, true);
+  });
+});

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

@@ -19,34 +19,35 @@ export class DataValidationDecorator extends Service {
           'an Adapter instance, but %v given.',
         adapter,
       );
+    const validator = this.getService(ModelDataValidator);
 
     const create = adapter.create;
     adapter.create = function (modelName, modelData, filter) {
-      this.getService(ModelDataValidator).validate(modelName, modelData);
+      validator.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);
+      validator.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);
+      validator.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);
+      validator.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);
+      validator.validate(modelName, modelData, true);
       return patchById.call(this, modelName, id, modelData, filter);
     };
   }

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

@@ -10,27 +10,27 @@ S.defineModel({name: 'model'});
 class TestAdapter extends Adapter {
   // eslint-disable-next-line no-unused-vars
   create(modelName, modelData, filter = undefined) {
-    return Promise.resolve({});
+    return Promise.resolve(modelData);
   }
 
   // eslint-disable-next-line no-unused-vars
   replaceById(modelName, id, modelData, filter = undefined) {
-    return Promise.resolve({});
+    return Promise.resolve(modelData);
   }
 
   // eslint-disable-next-line no-unused-vars
   replaceOrCreate(modelName, modelData, filter = undefined) {
-    return Promise.resolve({});
+    return Promise.resolve(modelData);
   }
 
   // eslint-disable-next-line no-unused-vars
   patch(modelName, modelData, where = undefined) {
-    return Promise.resolve(1);
+    return Promise.resolve(modelData);
   }
 
   // eslint-disable-next-line no-unused-vars
   patchById(modelName, id, modelData, filter = undefined) {
-    return Promise.resolve({});
+    return Promise.resolve(modelData);
   }
 }
 
@@ -44,34 +44,62 @@ describe('DataValidationDecorator', function () {
   });
 
   it('overrides the "create" method and validates a given data', async function () {
-    sandbox.on(V, 'validate');
-    const data = {};
-    await A.create('model', data);
+    const data = {kind: 'data'};
+    sandbox.on(V, 'validate', (modelName, modelData, isPartial = false) => {
+      expect(modelName).to.be.eq('model');
+      expect(modelData).to.be.eql(data);
+      expect(isPartial).to.be.false;
+    });
+    const res = await A.create('model', data);
+    expect(res).to.be.eql(data);
     expect(V.validate).to.be.called.once;
-    expect(V.validate).to.be.called.with.exactly('model', data);
   });
 
   it('overrides the "replaceById" method and validates a given data', async function () {
-    sandbox.on(V, 'validate');
-    const data = {};
-    await A.replaceById('model', 1, data);
+    const data = {kind: 'data'};
+    sandbox.on(V, 'validate', (modelName, modelData, isPartial = false) => {
+      expect(modelName).to.be.eq('model');
+      expect(modelData).to.be.eql(data);
+      expect(isPartial).to.be.false;
+    });
+    const res = await A.replaceById('model', 1, data);
+    expect(res).to.be.eql(data);
     expect(V.validate).to.be.called.once;
-    expect(V.validate).to.be.called.with.exactly('model', data);
   });
 
   it('overrides the "replaceOrCreate" method and validates a given data', async function () {
-    sandbox.on(V, 'validate');
-    const data = {};
-    await A.replaceOrCreate('model', data);
+    const data = {kind: 'data'};
+    sandbox.on(V, 'validate', (modelName, modelData, isPartial = false) => {
+      expect(modelName).to.be.eq('model');
+      expect(modelData).to.be.eql(data);
+      expect(isPartial).to.be.false;
+    });
+    const res = await A.replaceOrCreate('model', data);
+    expect(res).to.be.eql(data);
+    expect(V.validate).to.be.called.once;
+  });
+
+  it('overrides the "patch" method and validates a given data', async function () {
+    const data = {kind: 'data'};
+    sandbox.on(V, 'validate', (modelName, modelData, isPartial = false) => {
+      expect(modelName).to.be.eq('model');
+      expect(modelData).to.be.eql(data);
+      expect(isPartial).to.be.true;
+    });
+    const res = await A.patch('model', data);
+    expect(res).to.be.eql(data);
     expect(V.validate).to.be.called.once;
-    expect(V.validate).to.be.called.with.exactly('model', data);
   });
 
   it('overrides the "patchById" method and validates a given data', async function () {
-    sandbox.on(V, 'validate');
-    const data = {};
-    await A.patchById('model', 1, data);
+    const data = {kind: 'data'};
+    sandbox.on(V, 'validate', (modelName, modelData, isPartial = false) => {
+      expect(modelName).to.be.eq('model');
+      expect(modelData).to.be.eql(data);
+      expect(isPartial).to.be.true;
+    });
+    const res = await A.patchById('model', 1, data);
+    expect(res).to.be.eql(data);
     expect(V.validate).to.be.called.once;
-    expect(V.validate).to.be.called.with.exactly('model', data, true);
   });
 });

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