@e22m4u/js-repository 0.4.0 → 0.5.1

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

@@ -2,6 +2,7 @@ import {expect} from 'chai';
 import {format} from '@e22m4u/js-format';
 import {DataType} from './properties/index.js';
 import {DatabaseSchema} from '../../database-schema.js';
+import {EmptyValuesService} from '@e22m4u/js-empty-values';
 import {DefinitionRegistry} from '../definition-registry.js';
 import {ModelDataTransformer} from './model-data-transformer.js';
 import {PropertyTransformerRegistry} from './properties/index.js';
@@ -21,7 +22,7 @@ describe('ModelDataTransformer', function () {
       const throwable = v => () => T.transform('model', v);
       const error = v =>
         format(
-          'The data of the model "model" should be an Object, but %s given.',
+          'The data of the model "model" should be an Object, but %s was given.',
           v,
         );
       expect(throwable('str')).to.throw(error('"str"'));
@@ -54,42 +55,58 @@ describe('ModelDataTransformer', function () {
       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 dbs = new DatabaseSchema();
-        const myTransformer = value => String(value);
-        dbs
-          .getService(PropertyTransformerRegistry)
-          .addTransformer('myTransformer', myTransformer);
-        dbs.defineModel({
-          name: 'model',
-          properties: {
-            foo: {
-              type: DataType.ANY,
-              transform: 'myTransformer',
-            },
+    it('the option "transform" requires a non-empty String, a Function, an Array or an Object', function () {
+      const dbs = new DatabaseSchema();
+      dbs
+        .getService(PropertyTransformerRegistry)
+        .addTransformer('myTransformer', () => 'transformed');
+      dbs.defineModel({
+        name: 'model',
+        properties: {
+          foo: {
+            type: DataType.ANY,
+            transform: undefined,
           },
-        });
-        const T = dbs.getService(ModelDataTransformer);
-        const res = T.transform('model', {foo: 10});
-        expect(res).to.be.eql({foo: '10'});
+        },
       });
+      const T = dbs.getService(ModelDataTransformer);
+      const throwable = v => () => {
+        const models = dbs.getService(DefinitionRegistry)['_models'];
+        models.model.properties.foo.transform = v;
+        T.transform('model', {foo: 'bar'});
+      };
+      const error = v =>
+        format(
+          'The provided option "transform" for the property "foo" in the model "model" ' +
+            'should be either a transformer name, a transformer function, an array ' +
+            'of transformer names or functions, or an object mapping transformer ' +
+            'names to their arguments, but %s was 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(() => 10)();
+      throwable(() => Promise.resolve('bar'))();
+      throwable(['myTransformer'])();
+      throwable([() => Promise.resolve('bar')])();
+      throwable([])();
+      throwable({myTransformer: true})();
+      throwable({})();
+    });
 
-      it('passes specific arguments to the transformer function', function () {
+    describe('when the option "transform" is a String', function () {
+      it('should not transform the non-provided property', function () {
+        let calls = 0;
         const dbs = new DatabaseSchema();
-        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';
-        };
-        dbs
-          .getService(PropertyTransformerRegistry)
-          .addTransformer('myTransformer', myTransformer);
+        const reg = dbs.getService(PropertyTransformerRegistry);
+        reg.addTransformer('myTransformer', () => {
+          calls++;
+          throw new Error('Should not to be called.');
+        });
         dbs.defineModel({
           name: 'model',
           properties: {
@@ -100,41 +117,51 @@ describe('ModelDataTransformer', function () {
           },
         });
         const T = dbs.getService(ModelDataTransformer);
-        const res = T.transform('model', {foo: 'input'});
-        expect(res).to.be.eql({foo: 'transformed'});
+        const res = T.transform('model', {});
+        expect(res).to.be.eql({});
+        expect(calls).to.be.eq(0);
       });
 
-      it('does not transform a property value if it is not provided', function () {
+      it('should not transform non-provided properties when the option "isPartial" is true', function () {
+        let calls = 0;
         const dbs = new DatabaseSchema();
-        const myTransformer = () => 'transformed';
-        dbs
-          .getService(PropertyTransformerRegistry)
-          .addTransformer('myTransformer', myTransformer);
+        const reg = dbs.getService(PropertyTransformerRegistry);
+        reg.addTransformer('myTransformer', value => {
+          calls++;
+          return String(value);
+        });
         dbs.defineModel({
           name: 'model',
           properties: {
             foo: {
-              type: DataType.STRING,
+              type: DataType.ANY,
+              transform: 'myTransformer',
+            },
+            bar: {
+              type: DataType.ANY,
               transform: 'myTransformer',
             },
           },
         });
         const T = dbs.getService(ModelDataTransformer);
-        const res = T.transform('model', {});
+        const res = T.transform('model', {}, true);
         expect(res).to.be.eql({});
+        expect(calls).to.be.eq(0);
       });
 
-      it('does not transform undefined and null values', function () {
+      it('should not transform undefined and null values', function () {
+        let calls = 0;
         const dbs = new DatabaseSchema();
-        const myTransformer = () => 'transformed';
-        dbs
-          .getService(PropertyTransformerRegistry)
-          .addTransformer('myTransformer', myTransformer);
+        const reg = dbs.getService(PropertyTransformerRegistry);
+        reg.addTransformer('myTransformer', () => {
+          calls++;
+          throw new Error('Should not to be called.');
+        });
         dbs.defineModel({
           name: 'model',
           properties: {
             foo: {
-              type: DataType.STRING,
+              type: DataType.ANY,
               transform: 'myTransformer',
             },
           },
@@ -144,70 +171,64 @@ describe('ModelDataTransformer', function () {
         const res2 = T.transform('model', {foo: null});
         expect(res1).to.be.eql({foo: undefined});
         expect(res2).to.be.eql({foo: null});
+        expect(calls).to.be.eq(0);
       });
 
-      it('the parameter "isPartial" prevents to transform values of not provided properties', function () {
+      it('should not transform the empty value', function () {
+        let calls = 0;
         const dbs = new DatabaseSchema();
-        const myTransformer = () => 'transformed';
-        dbs
-          .getService(PropertyTransformerRegistry)
-          .addTransformer('myTransformer', myTransformer);
+        const reg = dbs.getService(PropertyTransformerRegistry);
+        reg.addTransformer('myTransformer', () => {
+          calls++;
+          throw new Error('Should not to be called.');
+        });
         dbs.defineModel({
           name: 'model',
           properties: {
             foo: {
-              type: DataType.STRING,
+              type: DataType.ANY,
               transform: 'myTransformer',
             },
           },
         });
+        dbs.getService(EmptyValuesService).setEmptyValuesOf(DataType.ANY, [10]);
         const T = dbs.getService(ModelDataTransformer);
-        const res = T.transform('model', {}, true);
-        expect(res).to.be.eql({});
+        const res = T.transform('model', {foo: 10});
+        expect(res).to.be.eql({foo: 10});
+        expect(calls).to.be.eq(0);
       });
 
-      it('transforms the property value by its asynchronous transformer', async function () {
+      it('should transform the property by the transformer', function () {
+        let calls = 0;
         const dbs = new DatabaseSchema();
-        const myTransformer1 = (value, options) => {
-          expect(options).to.be.undefined;
-          return Promise.resolve(`${value}2`);
-        };
-        const myTransformer2 = (value, options) => {
-          expect(options).to.be.undefined;
-          return Promise.resolve(`${value}3`);
-        };
-        dbs
-          .getService(PropertyTransformerRegistry)
-          .addTransformer('myTransformer1', myTransformer1)
-          .addTransformer('myTransformer2', myTransformer2);
+        const reg = dbs.getService(PropertyTransformerRegistry);
+        reg.addTransformer('myTransformer', value => {
+          calls++;
+          return String(value);
+        });
         dbs.defineModel({
           name: 'model',
           properties: {
             foo: {
-              type: DataType.STRING,
-              transform: 'myTransformer1',
-            },
-            bar: {
-              type: DataType.STRING,
-              transform: 'myTransformer2',
+              type: DataType.ANY,
+              transform: 'myTransformer',
             },
           },
         });
         const T = dbs.getService(ModelDataTransformer);
-        const promise = T.transform('model', {foo: '1', bar: '2'});
-        expect(promise).to.be.instanceof(Promise);
-        const res = await promise;
-        expect(res).to.be.eql({foo: '12', bar: '23'});
+        const res = T.transform('model', {foo: 10});
+        expect(res).to.be.eql({foo: '10'});
+        expect(calls).to.be.eq(1);
       });
-    });
 
-    describe('the option "transform" with an array value', function () {
-      it('transforms given properties by their transformers', function () {
+      it('should transform properties by transformers', function () {
+        let calls = 0;
         const dbs = new DatabaseSchema();
-        const myTransformer = value => String(value);
-        dbs
-          .getService(PropertyTransformerRegistry)
-          .addTransformer('myTransformer', myTransformer);
+        const reg = dbs.getService(PropertyTransformerRegistry);
+        reg.addTransformer('myTransformer', value => {
+          calls++;
+          return String(value);
+        });
         dbs.defineModel({
           name: 'model',
           properties: {
@@ -219,428 +240,2073 @@ describe('ModelDataTransformer', function () {
               type: DataType.ANY,
               transform: ['myTransformer'],
             },
-            baz: {
-              type: DataType.ANY,
-              transform: ['myTransformer'],
-            },
-          },
-        });
-        const T = dbs.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 dbs = new DatabaseSchema();
-        const order = [];
-        const myTransformer1 = value => {
-          order.push('myTransformer1');
-          return value + '1';
-        };
-        const myTransformer2 = value => {
-          order.push('myTransformer2');
-          return value + '2';
-        };
-        dbs
-          .getService(PropertyTransformerRegistry)
-          .addTransformer('myTransformer1', myTransformer1)
-          .addTransformer('myTransformer2', myTransformer2);
-        dbs.defineModel({
-          name: 'model',
-          properties: {
-            foo: {
-              type: DataType.ANY,
-              transform: ['myTransformer1', 'myTransformer2'],
-            },
           },
         });
         const T = dbs.getService(ModelDataTransformer);
-        const res = T.transform('model', {foo: 'value'});
-        expect(res).to.be.eql({foo: 'value12'});
-        expect(order).to.be.eql(['myTransformer1', 'myTransformer2']);
+        const res = T.transform('model', {foo: 1, bar: 2});
+        expect(res).to.be.eql({foo: '1', bar: '2'});
+        expect(calls).to.be.eq(2);
       });
 
-      it('passes specific arguments to the transformer function', function () {
+      it('should pass arguments to the transformer', function () {
+        let calls = 0;
         const dbs = new DatabaseSchema();
-        const myTransformer = (value, options, context) => {
-          expect(value).to.be.eq('input');
+        const reg = dbs.getService(PropertyTransformerRegistry);
+        reg.addTransformer('myTransformer', (value, options, context) => {
+          calls++;
+          expect(value).to.be.eq(10);
           expect(options).to.be.undefined;
           expect(context).to.be.eql({
             transformerName: 'myTransformer',
             modelName: 'model',
             propName: 'foo',
           });
-          return 'transformed';
-        };
-        dbs
-          .getService(PropertyTransformerRegistry)
-          .addTransformer('myTransformer', myTransformer);
+          return String(value);
+        });
         dbs.defineModel({
           name: 'model',
           properties: {
             foo: {
               type: DataType.ANY,
-              transform: ['myTransformer'],
+              transform: 'myTransformer',
             },
           },
         });
         const T = dbs.getService(ModelDataTransformer);
-        const res = T.transform('model', {foo: 'input'});
-        expect(res).to.be.eql({foo: 'transformed'});
+        const res = T.transform('model', {foo: 10});
+        expect(res).to.be.eql({foo: '10'});
+        expect(calls).to.be.eq(1);
       });
 
-      it('does not transform a property value if it is not provided', function () {
+      it('should transform the property by the asynchronous transformer', async function () {
+        let calls = 0;
         const dbs = new DatabaseSchema();
-        const myTransformer = () => 'transformed';
-        dbs
-          .getService(PropertyTransformerRegistry)
-          .addTransformer('myTransformer', myTransformer);
-        dbs.defineModel({
-          name: 'model',
-          properties: {
-            foo: {
-              type: DataType.STRING,
-              transform: ['myTransformer'],
-            },
-          },
+        const reg = dbs.getService(PropertyTransformerRegistry);
+        reg.addTransformer('myTransformer', value => {
+          calls++;
+          return Promise.resolve(String(value));
         });
-        const T = dbs.getService(ModelDataTransformer);
-        const res = T.transform('model', {});
-        expect(res).to.be.eql({});
-      });
-
-      it('transforms undefined and null values', function () {
-        const dbs = new DatabaseSchema();
-        const myTransformer = () => 'transformed';
-        dbs
-          .getService(PropertyTransformerRegistry)
-          .addTransformer('myTransformer', myTransformer);
         dbs.defineModel({
           name: 'model',
           properties: {
             foo: {
-              type: DataType.STRING,
-              transform: ['myTransformer'],
+              type: DataType.ANY,
+              transform: 'myTransformer',
             },
           },
         });
         const T = dbs.getService(ModelDataTransformer);
-        const res1 = T.transform('model', {foo: undefined});
-        const res2 = T.transform('model', {foo: null});
-        expect(res1).to.be.eql({foo: undefined});
-        expect(res2).to.be.eql({foo: null});
+        const promise = T.transform('model', {foo: 10});
+        expect(promise).to.be.instanceof(Promise);
+        const res = await promise;
+        expect(res).to.be.eql({foo: '10'});
+        expect(calls).to.be.eq(1);
       });
 
-      it('the parameter "isPartial" prevents to transform values of not provided properties', function () {
+      it('should transform properties by the asynchronous transformer', async function () {
+        let calls = 0;
         const dbs = new DatabaseSchema();
-        const myTransformer = () => 'transformed';
-        dbs
-          .getService(PropertyTransformerRegistry)
-          .addTransformer('myTransformer', myTransformer);
-        dbs.defineModel({
-          name: 'model',
-          properties: {
-            foo: {
-              type: DataType.STRING,
-              transform: ['myTransformer'],
-            },
-          },
+        const reg = dbs.getService(PropertyTransformerRegistry);
+        reg.addTransformer('myTransformer', value => {
+          calls++;
+          return Promise.resolve(String(value));
         });
-        const T = dbs.getService(ModelDataTransformer);
-        const res = T.transform('model', {}, true);
-        expect(res).to.be.eql({});
-      });
-
-      it('transforms the property value by its asynchronous transformers', async function () {
-        const dbs = new DatabaseSchema();
-        const myTransformer1 = (value, options) => {
-          expect(options).to.be.undefined;
-          return Promise.resolve(`${value}2`);
-        };
-        const myTransformer2 = (value, options) => {
-          expect(options).to.be.undefined;
-          return Promise.resolve(`${value}3`);
-        };
-        const myTransformer3 = (value, options) => {
-          expect(options).to.be.undefined;
-          return Promise.resolve(`${value}4`);
-        };
-        dbs
-          .getService(PropertyTransformerRegistry)
-          .addTransformer('myTransformer1', myTransformer1)
-          .addTransformer('myTransformer2', myTransformer2)
-          .addTransformer('myTransformer3', myTransformer3);
         dbs.defineModel({
           name: 'model',
           properties: {
             foo: {
-              type: DataType.STRING,
-              transform: ['myTransformer1', 'myTransformer2'],
+              type: DataType.ANY,
+              transform: 'myTransformer',
             },
             bar: {
-              type: DataType.STRING,
-              transform: ['myTransformer2', 'myTransformer3'],
+              type: DataType.ANY,
+              transform: 'myTransformer',
             },
           },
         });
         const T = dbs.getService(ModelDataTransformer);
-        const promise = T.transform('model', {foo: '1', bar: '2'});
+        const promise = T.transform('model', {foo: 10, bar: 20});
         expect(promise).to.be.instanceof(Promise);
         const res = await promise;
-        expect(res).to.be.eql({foo: '123', bar: '234'});
+        expect(res).to.be.eql({foo: '10', bar: '20'});
+        expect(calls).to.be.eq(2);
       });
-    });
 
-    describe('the option "transform" with an object value', function () {
-      it('transforms given properties by their transformers', function () {
+      it('should throw an error from the transformer', async function () {
+        let calls = 0;
         const dbs = new DatabaseSchema();
-        const myTransformer = value => String(value);
-        dbs
-          .getService(PropertyTransformerRegistry)
-          .addTransformer('myTransformer', myTransformer);
+        const reg = dbs.getService(PropertyTransformerRegistry);
+        reg.addTransformer('myTransformer', () => {
+          calls++;
+          throw new Error('My error');
+        });
         dbs.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},
+              transform: 'myTransformer',
             },
           },
         });
         const T = dbs.getService(ModelDataTransformer);
-        const res = T.transform('model', {foo: 1, bar: 2, baz: 3});
-        expect(res).to.be.eql({foo: '1', bar: '2', baz: '3'});
+        const throwable = () => T.transform('model', {foo: 10});
+        expect(throwable).to.throw('My error');
+        expect(calls).to.be.eq(1);
       });
 
-      it('transforms the property value by its transformers in specified order', function () {
+      it('should throw an error from the asynchronous transformer', async function () {
+        let calls = 0;
         const dbs = new DatabaseSchema();
-        const order = [];
-        const myTransformer1 = value => {
-          order.push('myTransformer1');
-          return value + '1';
-        };
-        const myTransformer2 = value => {
-          order.push('myTransformer2');
-          return value + '2';
-        };
-        dbs
-          .getService(PropertyTransformerRegistry)
-          .addTransformer('myTransformer1', myTransformer1)
-          .addTransformer('myTransformer2', myTransformer2);
+        const reg = dbs.getService(PropertyTransformerRegistry);
+        reg.addTransformer('myTransformer', async () => {
+          calls++;
+          throw new Error('My error');
+        });
         dbs.defineModel({
           name: 'model',
           properties: {
             foo: {
               type: DataType.ANY,
-              transform: {
-                myTransformer1: true,
-                myTransformer2: true,
-              },
+              transform: 'myTransformer',
             },
           },
         });
         const T = dbs.getService(ModelDataTransformer);
-        const res = T.transform('model', {foo: 'value'});
-        expect(res).to.be.eql({foo: 'value12'});
-        expect(order).to.be.eql(['myTransformer1', 'myTransformer2']);
+        const promise = T.transform('model', {foo: 10});
+        await expect(promise).to.rejectedWith('My error');
+        expect(calls).to.be.eq(1);
       });
+    });
 
-      it('passes specific arguments to the transformer function', function () {
-        const dbs = new DatabaseSchema();
-        const myTransformer = (value, options, context) => {
-          expect(value).to.be.eq('input');
-          expect(options).to.be.eql({
-            option1: 'value1',
-            option2: 'value2',
+    describe('when the option "transform" is a Function', function () {
+      describe('named transformers', function () {
+        it('should not transform the non-provided property', function () {
+          let calls = 0;
+          const dbs = new DatabaseSchema();
+          const myTransformer = function () {
+            calls++;
+            throw new Error('Should not to be called.');
+          };
+          dbs.defineModel({
+            name: 'model',
+            properties: {
+              foo: {
+                type: DataType.ANY,
+                transform: myTransformer,
+              },
+            },
           });
-          expect(context).to.be.eql({
-            transformerName: 'myTransformer',
-            modelName: 'model',
-            propName: 'foo',
+          const T = dbs.getService(ModelDataTransformer);
+          const res = T.transform('model', {});
+          expect(res).to.be.eql({});
+          expect(calls).to.be.eq(0);
+        });
+
+        it('should not transform non-provided properties when the option "isPartial" is true', function () {
+          let calls = 0;
+          const dbs = new DatabaseSchema();
+          const myTransformer = function () {
+            calls++;
+            throw new Error('Should not to be called.');
+          };
+          dbs.defineModel({
+            name: 'model',
+            properties: {
+              foo: {
+                type: DataType.ANY,
+                transform: myTransformer,
+              },
+              bar: {
+                type: DataType.ANY,
+                transform: myTransformer,
+              },
+            },
           });
-          return 'transformed';
-        };
-        dbs
-          .getService(PropertyTransformerRegistry)
-          .addTransformer('myTransformer', myTransformer);
-        dbs.defineModel({
-          name: 'model',
-          properties: {
-            foo: {
-              type: DataType.ANY,
-              transform: {
-                myTransformer: {
-                  option1: 'value1',
-                  option2: 'value2',
-                },
+          const T = dbs.getService(ModelDataTransformer);
+          const res = T.transform('model', {}, true);
+          expect(res).to.be.eql({});
+          expect(calls).to.be.eq(0);
+        });
+
+        it('should not transform undefined and null values', function () {
+          let calls = 0;
+          const dbs = new DatabaseSchema();
+          const myTransformer = function () {
+            calls++;
+            throw new Error('Should not to be called.');
+          };
+          dbs.defineModel({
+            name: 'model',
+            properties: {
+              foo: {
+                type: DataType.ANY,
+                transform: myTransformer,
               },
             },
-          },
+          });
+          const T = dbs.getService(ModelDataTransformer);
+          const res1 = T.transform('model', {foo: undefined});
+          const res2 = T.transform('model', {foo: null});
+          expect(res1).to.be.eql({foo: undefined});
+          expect(res2).to.be.eql({foo: null});
+          expect(calls).to.be.eq(0);
         });
-        const T = dbs.getService(ModelDataTransformer);
-        const res = T.transform('model', {foo: 'input'});
-        expect(res).to.be.eql({foo: 'transformed'});
-      });
 
-      it('does not transform a property value if it is not provided', function () {
-        const dbs = new DatabaseSchema();
-        const myTransformer = () => 'transformed';
-        dbs
-          .getService(PropertyTransformerRegistry)
-          .addTransformer('myTransformer', myTransformer);
-        dbs.defineModel({
-          name: 'model',
-          properties: {
-            foo: {
-              type: DataType.STRING,
-              transform: {
-                myTransformer: true,
+        it('should not transform the empty value', function () {
+          let calls = 0;
+          const dbs = new DatabaseSchema();
+          const myTransformer = function () {
+            calls++;
+            throw new Error('Should not to be called.');
+          };
+          dbs.defineModel({
+            name: 'model',
+            properties: {
+              foo: {
+                type: DataType.ANY,
+                transform: myTransformer,
               },
             },
-          },
+          });
+          dbs
+            .getService(EmptyValuesService)
+            .setEmptyValuesOf(DataType.ANY, [10]);
+          const T = dbs.getService(ModelDataTransformer);
+          const res = T.transform('model', {foo: 10});
+          expect(res).to.be.eql({foo: 10});
+          expect(calls).to.be.eq(0);
         });
-        const T = dbs.getService(ModelDataTransformer);
-        const res = T.transform('model', {});
-        expect(res).to.be.eql({});
-      });
 
-      it('transforms undefined and null values', function () {
-        const dbs = new DatabaseSchema();
-        const myTransformer = () => 'transformed';
-        dbs
-          .getService(PropertyTransformerRegistry)
-          .addTransformer('myTransformer', myTransformer);
-        dbs.defineModel({
-          name: 'model',
-          properties: {
-            foo: {
-              type: DataType.STRING,
-              transform: {
-                myTransformer: true,
+        it('should transform the property by the transformer', function () {
+          let calls = 0;
+          const dbs = new DatabaseSchema();
+          const myTransformer = function (value) {
+            calls++;
+            return String(value);
+          };
+          dbs.defineModel({
+            name: 'model',
+            properties: {
+              foo: {
+                type: DataType.ANY,
+                transform: myTransformer,
               },
             },
-          },
+          });
+          const T = dbs.getService(ModelDataTransformer);
+          const res = T.transform('model', {foo: 10});
+          expect(res).to.be.eql({foo: '10'});
+          expect(calls).to.be.eq(1);
         });
-        const T = dbs.getService(ModelDataTransformer);
-        const res1 = T.transform('model', {foo: undefined});
-        const res2 = T.transform('model', {foo: null});
-        expect(res1).to.be.eql({foo: undefined});
-        expect(res2).to.be.eql({foo: null});
-      });
 
-      it('the parameter "isPartial" prevents to transform values of not provided properties', function () {
-        const dbs = new DatabaseSchema();
-        const myTransformer = () => 'transformed';
-        dbs
-          .getService(PropertyTransformerRegistry)
-          .addTransformer('myTransformer', myTransformer);
-        dbs.defineModel({
-          name: 'model',
-          properties: {
-            foo: {
-              type: DataType.STRING,
-              transform: {
-                myTransformer: true,
+        it('should transform properties by transformers', function () {
+          let calls = 0;
+          const dbs = new DatabaseSchema();
+          const myTransformer = function (value) {
+            calls++;
+            return String(value);
+          };
+          dbs.defineModel({
+            name: 'model',
+            properties: {
+              foo: {
+                type: DataType.ANY,
+                transform: myTransformer,
+              },
+              bar: {
+                type: DataType.ANY,
+                transform: myTransformer,
               },
             },
-          },
+          });
+          const T = dbs.getService(ModelDataTransformer);
+          const res = T.transform('model', {foo: 1, bar: 2});
+          expect(res).to.be.eql({foo: '1', bar: '2'});
+          expect(calls).to.be.eq(2);
         });
-        const T = dbs.getService(ModelDataTransformer);
-        const res = T.transform('model', {}, true);
-        expect(res).to.be.eql({});
-      });
 
-      it('transforms the property value by its asynchronous transformers', async function () {
-        const dbs = new DatabaseSchema();
-        const myTransformer1 = (value, options) => {
-          expect(options).to.be.eq('foo');
-          return Promise.resolve(`${value}2`);
-        };
-        const myTransformer2 = (value, options) => {
-          expect(options).to.be.eq('bar');
-          return Promise.resolve(`${value}3`);
-        };
-        const myTransformer3 = (value, options) => {
-          expect(options).to.be.eq('baz');
-          return Promise.resolve(`${value}4`);
-        };
-        dbs
-          .getService(PropertyTransformerRegistry)
-          .addTransformer('myTransformer1', myTransformer1)
-          .addTransformer('myTransformer2', myTransformer2)
-          .addTransformer('myTransformer3', myTransformer3);
-        dbs.defineModel({
-          name: 'model',
-          properties: {
-            foo: {
-              type: DataType.STRING,
-              transform: {
-                myTransformer1: 'foo',
-                myTransformer2: 'bar',
+        it('should pass arguments to the transformer', function () {
+          let calls = 0;
+          const dbs = new DatabaseSchema();
+          const myTransformer = function (value, options, context) {
+            calls++;
+            expect(value).to.be.eq(10);
+            expect(options).to.be.undefined;
+            expect(context).to.be.eql({
+              transformerName: 'myTransformer',
+              modelName: 'model',
+              propName: 'foo',
+            });
+            return String(value);
+          };
+          dbs.defineModel({
+            name: 'model',
+            properties: {
+              foo: {
+                type: DataType.ANY,
+                transform: myTransformer,
               },
             },
-            bar: {
-              type: DataType.STRING,
-              transform: {
-                myTransformer2: 'bar',
-                myTransformer3: 'baz',
+          });
+          const T = dbs.getService(ModelDataTransformer);
+          const res = T.transform('model', {foo: 10});
+          expect(res).to.be.eql({foo: '10'});
+          expect(calls).to.be.eq(1);
+        });
+
+        it('should transform the property by the asynchronous transformer', async function () {
+          let calls = 0;
+          const dbs = new DatabaseSchema();
+          const myTransformer = function (value) {
+            calls++;
+            return Promise.resolve(String(value));
+          };
+          dbs.defineModel({
+            name: 'model',
+            properties: {
+              foo: {
+                type: DataType.ANY,
+                transform: myTransformer,
               },
             },
-          },
+          });
+          const T = dbs.getService(ModelDataTransformer);
+          const promise = T.transform('model', {foo: 10});
+          expect(promise).to.be.instanceof(Promise);
+          const res = await promise;
+          expect(res).to.be.eql({foo: '10'});
+          expect(calls).to.be.eq(1);
         });
-        const T = dbs.getService(ModelDataTransformer);
-        const promise = T.transform('model', {foo: '1', bar: '2'});
-        expect(promise).to.be.instanceof(Promise);
-        const res = await promise;
-        expect(res).to.be.eql({foo: '123', bar: '234'});
-      });
-    });
 
-    it('the option "transform" requires a non-empty String, an Array or an Object', function () {
-      const dbs = new DatabaseSchema();
-      dbs
-        .getService(PropertyTransformerRegistry)
-        .addTransformer('myTransformer', () => 'transformed');
-      dbs.defineModel({
-        name: 'model',
-        properties: {
-          foo: {
-            type: DataType.ANY,
-            transform: undefined,
+        it('should transform properties by the asynchronous transformer', async function () {
+          let calls = 0;
+          const dbs = new DatabaseSchema();
+          const myTransformer = function (value) {
+            calls++;
+            return Promise.resolve(String(value));
+          };
+          dbs.defineModel({
+            name: 'model',
+            properties: {
+              foo: {
+                type: DataType.ANY,
+                transform: myTransformer,
+              },
+              bar: {
+                type: DataType.ANY,
+                transform: myTransformer,
+              },
+            },
+          });
+          const T = dbs.getService(ModelDataTransformer);
+          const promise = T.transform('model', {foo: 10, bar: 20});
+          expect(promise).to.be.instanceof(Promise);
+          const res = await promise;
+          expect(res).to.be.eql({foo: '10', bar: '20'});
+          expect(calls).to.be.eq(2);
+        });
+
+        it('should throw an error from the transformer', async function () {
+          let calls = 0;
+          const dbs = new DatabaseSchema();
+          const myTransformer = function () {
+            calls++;
+            throw new Error('My error');
+          };
+          dbs.defineModel({
+            name: 'model',
+            properties: {
+              foo: {
+                type: DataType.ANY,
+                transform: myTransformer,
+              },
+            },
+          });
+          const T = dbs.getService(ModelDataTransformer);
+          const throwable = () => T.transform('model', {foo: 10});
+          expect(throwable).to.throw('My error');
+          expect(calls).to.be.eq(1);
+        });
+
+        it('should throw an error from the asynchronous transformer', async function () {
+          let calls = 0;
+          const dbs = new DatabaseSchema();
+          const myTransformer = async function () {
+            calls++;
+            throw new Error('My error');
+          };
+          dbs.defineModel({
+            name: 'model',
+            properties: {
+              foo: {
+                type: DataType.ANY,
+                transform: myTransformer,
+              },
+            },
+          });
+          const T = dbs.getService(ModelDataTransformer);
+          const promise = T.transform('model', {foo: 10});
+          await expect(promise).to.rejectedWith('My error');
+          expect(calls).to.be.eq(1);
+        });
+      });
+
+      describe('anonymous transformers', function () {
+        it('should not transform the non-provided property', function () {
+          let calls = 0;
+          const dbs = new DatabaseSchema();
+          dbs.defineModel({
+            name: 'model',
+            properties: {
+              foo: {
+                type: DataType.ANY,
+                transform() {
+                  calls++;
+                  throw new Error('Should not to be called.');
+                },
+              },
+            },
+          });
+          const T = dbs.getService(ModelDataTransformer);
+          const res = T.transform('model', {});
+          expect(res).to.be.eql({});
+          expect(calls).to.be.eq(0);
+        });
+
+        it('should not transform non-provided properties when the option "isPartial" is true', function () {
+          let calls = 0;
+          const dbs = new DatabaseSchema();
+          dbs.defineModel({
+            name: 'model',
+            properties: {
+              foo: {
+                type: DataType.ANY,
+                transform() {
+                  calls++;
+                  throw new Error('Should not to be called.');
+                },
+              },
+              bar: {
+                type: DataType.ANY,
+                transform() {
+                  calls++;
+                  throw new Error('Should not to be called.');
+                },
+              },
+            },
+          });
+          const T = dbs.getService(ModelDataTransformer);
+          const res = T.transform('model', {}, true);
+          expect(res).to.be.eql({});
+          expect(calls).to.be.eq(0);
+        });
+
+        it('should not transform undefined and null values', function () {
+          let calls = 0;
+          const dbs = new DatabaseSchema();
+          dbs.defineModel({
+            name: 'model',
+            properties: {
+              foo: {
+                type: DataType.ANY,
+                transform() {
+                  calls++;
+                  throw new Error('Should not to be called.');
+                },
+              },
+            },
+          });
+          const T = dbs.getService(ModelDataTransformer);
+          const res1 = T.transform('model', {foo: undefined});
+          const res2 = T.transform('model', {foo: null});
+          expect(res1).to.be.eql({foo: undefined});
+          expect(res2).to.be.eql({foo: null});
+          expect(calls).to.be.eq(0);
+        });
+
+        it('should not transform the empty value', function () {
+          let calls = 0;
+          const dbs = new DatabaseSchema();
+          dbs.defineModel({
+            name: 'model',
+            properties: {
+              foo: {
+                type: DataType.ANY,
+                transform() {
+                  calls++;
+                  throw new Error('Should not to be called.');
+                },
+              },
+            },
+          });
+          dbs
+            .getService(EmptyValuesService)
+            .setEmptyValuesOf(DataType.ANY, [10]);
+          const T = dbs.getService(ModelDataTransformer);
+          const res = T.transform('model', {foo: 10});
+          expect(res).to.be.eql({foo: 10});
+          expect(calls).to.be.eq(0);
+        });
+
+        it('should transform the property by the transformer', function () {
+          let calls = 0;
+          const dbs = new DatabaseSchema();
+          dbs.defineModel({
+            name: 'model',
+            properties: {
+              foo: {
+                type: DataType.ANY,
+                transform(value) {
+                  calls++;
+                  return String(value);
+                },
+              },
+            },
+          });
+          const T = dbs.getService(ModelDataTransformer);
+          const res = T.transform('model', {foo: 10});
+          expect(res).to.be.eql({foo: '10'});
+          expect(calls).to.be.eq(1);
+        });
+
+        it('should transform properties by transformers', function () {
+          let calls = 0;
+          const dbs = new DatabaseSchema();
+          dbs.defineModel({
+            name: 'model',
+            properties: {
+              foo: {
+                type: DataType.ANY,
+                transform(value) {
+                  calls++;
+                  return String(value);
+                },
+              },
+              bar: {
+                type: DataType.ANY,
+                transform(value) {
+                  calls++;
+                  return String(value);
+                },
+              },
+            },
+          });
+          const T = dbs.getService(ModelDataTransformer);
+          const res = T.transform('model', {foo: 1, bar: 2});
+          expect(res).to.be.eql({foo: '1', bar: '2'});
+          expect(calls).to.be.eq(2);
+        });
+
+        it('should pass arguments to the transformer', function () {
+          let calls = 0;
+          const dbs = new DatabaseSchema();
+          dbs.defineModel({
+            name: 'model',
+            properties: {
+              foo: {
+                type: DataType.ANY,
+                transform(value, options, context) {
+                  calls++;
+                  expect(value).to.be.eq(10);
+                  expect(options).to.be.undefined;
+                  expect(context).to.be.eql({
+                    transformerName: undefined,
+                    modelName: 'model',
+                    propName: 'foo',
+                  });
+                  return String(value);
+                },
+              },
+            },
+          });
+          const T = dbs.getService(ModelDataTransformer);
+          const res = T.transform('model', {foo: 10});
+          expect(res).to.be.eql({foo: '10'});
+          expect(calls).to.be.eq(1);
+        });
+
+        it('should transform the property by the asynchronous transformer', async function () {
+          let calls = 0;
+          const dbs = new DatabaseSchema();
+          dbs.defineModel({
+            name: 'model',
+            properties: {
+              foo: {
+                type: DataType.ANY,
+                transform(value) {
+                  calls++;
+                  return Promise.resolve(String(value));
+                },
+              },
+            },
+          });
+          const T = dbs.getService(ModelDataTransformer);
+          const promise = T.transform('model', {foo: 10});
+          expect(promise).to.be.instanceof(Promise);
+          const res = await promise;
+          expect(res).to.be.eql({foo: '10'});
+          expect(calls).to.be.eq(1);
+        });
+
+        it('should transform properties by the asynchronous transformer', async function () {
+          let calls = 0;
+          const dbs = new DatabaseSchema();
+          dbs.defineModel({
+            name: 'model',
+            properties: {
+              foo: {
+                type: DataType.ANY,
+                transform(value) {
+                  calls++;
+                  return Promise.resolve(String(value));
+                },
+              },
+              bar: {
+                type: DataType.ANY,
+                transform(value) {
+                  calls++;
+                  return Promise.resolve(String(value));
+                },
+              },
+            },
+          });
+          const T = dbs.getService(ModelDataTransformer);
+          const promise = T.transform('model', {foo: 10, bar: 20});
+          expect(promise).to.be.instanceof(Promise);
+          const res = await promise;
+          expect(res).to.be.eql({foo: '10', bar: '20'});
+          expect(calls).to.be.eq(2);
+        });
+
+        it('should throw an error from the transformer', async function () {
+          let calls = 0;
+          const dbs = new DatabaseSchema();
+          dbs.defineModel({
+            name: 'model',
+            properties: {
+              foo: {
+                type: DataType.ANY,
+                transform() {
+                  calls++;
+                  throw new Error('My error');
+                },
+              },
+            },
+          });
+          const T = dbs.getService(ModelDataTransformer);
+          const throwable = () => T.transform('model', {foo: 10});
+          expect(throwable).to.throw('My error');
+          expect(calls).to.be.eq(1);
+        });
+
+        it('should throw an error from the asynchronous transformer', async function () {
+          let calls = 0;
+          const dbs = new DatabaseSchema();
+          dbs.defineModel({
+            name: 'model',
+            properties: {
+              foo: {
+                type: DataType.ANY,
+                async transform() {
+                  calls++;
+                  throw new Error('My error');
+                },
+              },
+            },
+          });
+          const T = dbs.getService(ModelDataTransformer);
+          const promise = T.transform('model', {foo: 10});
+          await expect(promise).to.rejectedWith('My error');
+          expect(calls).to.be.eq(1);
+        });
+      });
+    });
+
+    describe('when the option "transform" is an Array', function () {
+      describe('when an Array element is a String', function () {
+        it('should not transform the non-provided property', function () {
+          let calls = 0;
+          const dbs = new DatabaseSchema();
+          const reg = dbs.getService(PropertyTransformerRegistry);
+          reg.addTransformer('myTransformer', () => {
+            calls++;
+            throw new Error('Should not to be called.');
+          });
+          dbs.defineModel({
+            name: 'model',
+            properties: {
+              foo: {
+                type: DataType.ANY,
+                transform: ['myTransformer'],
+              },
+            },
+          });
+          const T = dbs.getService(ModelDataTransformer);
+          const res = T.transform('model', {});
+          expect(res).to.be.eql({});
+          expect(calls).to.be.eq(0);
+        });
+
+        it('should not transform non-provided properties when the option "isPartial" is true', function () {
+          let calls = 0;
+          const dbs = new DatabaseSchema();
+          const reg = dbs.getService(PropertyTransformerRegistry);
+          reg.addTransformer('myTransformer', () => {
+            calls++;
+            throw new Error('Should not to be called.');
+          });
+          dbs.defineModel({
+            name: 'model',
+            properties: {
+              foo: {
+                type: DataType.ANY,
+                transform: ['myTransformer'],
+              },
+              bar: {
+                type: DataType.ANY,
+                transform: ['myTransformer'],
+              },
+            },
+          });
+          const T = dbs.getService(ModelDataTransformer);
+          const res = T.transform('model', {}, true);
+          expect(res).to.be.eql({});
+          expect(calls).to.be.eq(0);
+        });
+
+        it('should not transform undefined and null values', function () {
+          let calls = 0;
+          const dbs = new DatabaseSchema();
+          const reg = dbs.getService(PropertyTransformerRegistry);
+          reg.addTransformer('myTransformer', () => {
+            calls++;
+            throw new Error('Should not to be called.');
+          });
+          dbs.defineModel({
+            name: 'model',
+            properties: {
+              foo: {
+                type: DataType.ANY,
+                transform: ['myTransformer'],
+              },
+            },
+          });
+          const T = dbs.getService(ModelDataTransformer);
+          const res1 = T.transform('model', {foo: undefined});
+          const res2 = T.transform('model', {foo: null});
+          expect(res1).to.be.eql({foo: undefined});
+          expect(res2).to.be.eql({foo: null});
+          expect(calls).to.be.eq(0);
+        });
+
+        it('should not transform the empty value', function () {
+          let calls = 0;
+          const dbs = new DatabaseSchema();
+          const reg = dbs.getService(PropertyTransformerRegistry);
+          reg.addTransformer('myTransformer', () => {
+            calls++;
+            throw new Error('Should not to be called.');
+          });
+          dbs.defineModel({
+            name: 'model',
+            properties: {
+              foo: {
+                type: DataType.ANY,
+                transform: ['myTransformer'],
+              },
+            },
+          });
+          dbs
+            .getService(EmptyValuesService)
+            .setEmptyValuesOf(DataType.ANY, [10]);
+          const T = dbs.getService(ModelDataTransformer);
+          const res = T.transform('model', {foo: 10});
+          expect(res).to.be.eql({foo: 10});
+          expect(calls).to.be.eq(0);
+        });
+
+        it('should transform the property by the transformer', function () {
+          let calls = 0;
+          const dbs = new DatabaseSchema();
+          const reg = dbs.getService(PropertyTransformerRegistry);
+          reg.addTransformer('myTransformer', value => {
+            calls++;
+            return String(value);
+          });
+          dbs.defineModel({
+            name: 'model',
+            properties: {
+              foo: {
+                type: DataType.ANY,
+                transform: ['myTransformer'],
+              },
+            },
+          });
+          const T = dbs.getService(ModelDataTransformer);
+          const res = T.transform('model', {foo: 10});
+          expect(res).to.be.eql({foo: '10'});
+          expect(calls).to.be.eq(1);
+        });
+
+        it('should transform properties by transformers', function () {
+          let calls = 0;
+          const dbs = new DatabaseSchema();
+          const reg = dbs.getService(PropertyTransformerRegistry);
+          reg.addTransformer('myTransformer', value => {
+            calls++;
+            return String(value);
+          });
+          dbs.defineModel({
+            name: 'model',
+            properties: {
+              foo: {
+                type: DataType.ANY,
+                transform: ['myTransformer'],
+              },
+              bar: {
+                type: DataType.ANY,
+                transform: ['myTransformer'],
+              },
+            },
+          });
+          const T = dbs.getService(ModelDataTransformer);
+          const res = T.transform('model', {foo: 1, bar: 2});
+          expect(res).to.be.eql({foo: '1', bar: '2'});
+          expect(calls).to.be.eq(2);
+        });
+
+        it('should pass arguments to the transformer', function () {
+          let calls = 0;
+          const dbs = new DatabaseSchema();
+          const reg = dbs.getService(PropertyTransformerRegistry);
+          reg.addTransformer('myTransformer', (value, options, context) => {
+            calls++;
+            expect(value).to.be.eq(10);
+            expect(options).to.be.undefined;
+            expect(context).to.be.eql({
+              transformerName: 'myTransformer',
+              modelName: 'model',
+              propName: 'foo',
+            });
+            return String(value);
+          });
+          dbs.defineModel({
+            name: 'model',
+            properties: {
+              foo: {
+                type: DataType.ANY,
+                transform: ['myTransformer'],
+              },
+            },
+          });
+          const T = dbs.getService(ModelDataTransformer);
+          const res = T.transform('model', {foo: 10});
+          expect(res).to.be.eql({foo: '10'});
+          expect(calls).to.be.eq(1);
+        });
+
+        it('should transform the property by the asynchronous transformer', async function () {
+          let calls = 0;
+          const dbs = new DatabaseSchema();
+          const reg = dbs.getService(PropertyTransformerRegistry);
+          reg.addTransformer('myTransformer', value => {
+            calls++;
+            return Promise.resolve(String(value));
+          });
+          dbs.defineModel({
+            name: 'model',
+            properties: {
+              foo: {
+                type: DataType.ANY,
+                transform: ['myTransformer'],
+              },
+            },
+          });
+          const T = dbs.getService(ModelDataTransformer);
+          const promise = T.transform('model', {foo: 10});
+          expect(promise).to.be.instanceof(Promise);
+          const res = await promise;
+          expect(res).to.be.eql({foo: '10'});
+          expect(calls).to.be.eq(1);
+        });
+
+        it('should transform properties by the asynchronous transformer', async function () {
+          let calls = 0;
+          const dbs = new DatabaseSchema();
+          const reg = dbs.getService(PropertyTransformerRegistry);
+          reg.addTransformer('myTransformer', value => {
+            calls++;
+            return Promise.resolve(String(value));
+          });
+          dbs.defineModel({
+            name: 'model',
+            properties: {
+              foo: {
+                type: DataType.ANY,
+                transform: ['myTransformer'],
+              },
+              bar: {
+                type: DataType.ANY,
+                transform: ['myTransformer'],
+              },
+            },
+          });
+          const T = dbs.getService(ModelDataTransformer);
+          const promise = T.transform('model', {foo: 10, bar: 20});
+          expect(promise).to.be.instanceof(Promise);
+          const res = await promise;
+          expect(res).to.be.eql({foo: '10', bar: '20'});
+          expect(calls).to.be.eq(2);
+        });
+
+        it('should throw an error from the transformer', async function () {
+          let calls = 0;
+          const dbs = new DatabaseSchema();
+          const reg = dbs.getService(PropertyTransformerRegistry);
+          reg.addTransformer('myTransformer', () => {
+            calls++;
+            throw new Error('My error');
+          });
+          dbs.defineModel({
+            name: 'model',
+            properties: {
+              foo: {
+                type: DataType.ANY,
+                transform: ['myTransformer'],
+              },
+            },
+          });
+          const T = dbs.getService(ModelDataTransformer);
+          const throwable = () => T.transform('model', {foo: 10});
+          expect(throwable).to.throw('My error');
+          expect(calls).to.be.eq(1);
+        });
+
+        it('should throw an error from the asynchronous transformer', async function () {
+          let calls = 0;
+          const dbs = new DatabaseSchema();
+          const reg = dbs.getService(PropertyTransformerRegistry);
+          reg.addTransformer('myTransformer', async () => {
+            calls++;
+            throw new Error('My error');
+          });
+          dbs.defineModel({
+            name: 'model',
+            properties: {
+              foo: {
+                type: DataType.ANY,
+                transform: ['myTransformer'],
+              },
+            },
+          });
+          const T = dbs.getService(ModelDataTransformer);
+          const promise = T.transform('model', {foo: 10});
+          await expect(promise).to.rejectedWith('My error');
+          expect(calls).to.be.eq(1);
+        });
+
+        it('should transform the property by transformers with the correct order', function () {
+          const order = [];
+          const dbs = new DatabaseSchema();
+          const reg = dbs.getService(PropertyTransformerRegistry);
+          reg.addTransformer('myTransformer1', value => {
+            order.push('myTransformer1');
+            return String(value);
+          });
+          reg.addTransformer('myTransformer2', value => {
+            order.push('myTransformer2');
+            return value.toUpperCase();
+          });
+          dbs.defineModel({
+            name: 'model',
+            properties: {
+              foo: {
+                type: DataType.ANY,
+                transform: ['myTransformer1', 'myTransformer2'],
+              },
+            },
+          });
+          const T = dbs.getService(ModelDataTransformer);
+          const res = T.transform('model', {foo: true});
+          expect(res).to.be.eql({foo: 'TRUE'});
+          expect(order).to.be.eql(['myTransformer1', 'myTransformer2']);
+        });
+
+        it('should transform the property by asynchronous transformers with the correct order', async function () {
+          const order = [];
+          const dbs = new DatabaseSchema();
+          const reg = dbs.getService(PropertyTransformerRegistry);
+          reg.addTransformer('myTransformer1', async value => {
+            order.push('myTransformer1');
+            return String(value);
+          });
+          reg.addTransformer('myTransformer2', async value => {
+            order.push('myTransformer2');
+            return value.toUpperCase();
+          });
+          dbs.defineModel({
+            name: 'model',
+            properties: {
+              foo: {
+                type: DataType.ANY,
+                transform: ['myTransformer1', 'myTransformer2'],
+              },
+            },
+          });
+          const T = dbs.getService(ModelDataTransformer);
+          const res = await T.transform('model', {foo: true});
+          expect(res).to.be.eql({foo: 'TRUE'});
+          expect(order).to.be.eql(['myTransformer1', 'myTransformer2']);
+        });
+      });
+
+      describe('when an Array element is a Function', function () {
+        describe('named transformers', function () {
+          it('should not transform the non-provided property', function () {
+            let calls = 0;
+            const dbs = new DatabaseSchema();
+            const myTransformer = function () {
+              calls++;
+              throw new Error('Should not to be called.');
+            };
+            dbs.defineModel({
+              name: 'model',
+              properties: {
+                foo: {
+                  type: DataType.ANY,
+                  transform: [myTransformer],
+                },
+              },
+            });
+            const T = dbs.getService(ModelDataTransformer);
+            const res = T.transform('model', {});
+            expect(res).to.be.eql({});
+            expect(calls).to.be.eq(0);
+          });
+
+          it('should not transform non-provided properties when the option "isPartial" is true', function () {
+            let calls = 0;
+            const dbs = new DatabaseSchema();
+            const myTransformer = function () {
+              calls++;
+              throw new Error('Should not to be called.');
+            };
+            dbs.defineModel({
+              name: 'model',
+              properties: {
+                foo: {
+                  type: DataType.ANY,
+                  transform: [myTransformer],
+                },
+                bar: {
+                  type: DataType.ANY,
+                  transform: [myTransformer],
+                },
+              },
+            });
+            const T = dbs.getService(ModelDataTransformer);
+            const res = T.transform('model', {}, true);
+            expect(res).to.be.eql({});
+            expect(calls).to.be.eq(0);
+          });
+
+          it('should not transform undefined and null values', function () {
+            let calls = 0;
+            const dbs = new DatabaseSchema();
+            const myTransformer = function () {
+              calls++;
+              throw new Error('Should not to be called.');
+            };
+            dbs.defineModel({
+              name: 'model',
+              properties: {
+                foo: {
+                  type: DataType.ANY,
+                  transform: [myTransformer],
+                },
+              },
+            });
+            const T = dbs.getService(ModelDataTransformer);
+            const res1 = T.transform('model', {foo: undefined});
+            const res2 = T.transform('model', {foo: null});
+            expect(res1).to.be.eql({foo: undefined});
+            expect(res2).to.be.eql({foo: null});
+            expect(calls).to.be.eq(0);
+          });
+
+          it('should not transform the empty value', function () {
+            let calls = 0;
+            const dbs = new DatabaseSchema();
+            const myTransformer = function () {
+              calls++;
+              throw new Error('Should not to be called.');
+            };
+            dbs.defineModel({
+              name: 'model',
+              properties: {
+                foo: {
+                  type: DataType.ANY,
+                  transform: [myTransformer],
+                },
+              },
+            });
+            dbs
+              .getService(EmptyValuesService)
+              .setEmptyValuesOf(DataType.ANY, [10]);
+            const T = dbs.getService(ModelDataTransformer);
+            const res = T.transform('model', {foo: 10});
+            expect(res).to.be.eql({foo: 10});
+            expect(calls).to.be.eq(0);
+          });
+
+          it('should transform the property by the transformer', function () {
+            let calls = 0;
+            const dbs = new DatabaseSchema();
+            const myTransformer = function (value) {
+              calls++;
+              return String(value);
+            };
+            dbs.defineModel({
+              name: 'model',
+              properties: {
+                foo: {
+                  type: DataType.ANY,
+                  transform: [myTransformer],
+                },
+              },
+            });
+            const T = dbs.getService(ModelDataTransformer);
+            const res = T.transform('model', {foo: 10});
+            expect(res).to.be.eql({foo: '10'});
+            expect(calls).to.be.eq(1);
+          });
+
+          it('should transform properties by transformers', function () {
+            let calls = 0;
+            const dbs = new DatabaseSchema();
+            const myTransformer = function (value) {
+              calls++;
+              return String(value);
+            };
+            dbs.defineModel({
+              name: 'model',
+              properties: {
+                foo: {
+                  type: DataType.ANY,
+                  transform: [myTransformer],
+                },
+                bar: {
+                  type: DataType.ANY,
+                  transform: [myTransformer],
+                },
+              },
+            });
+            const T = dbs.getService(ModelDataTransformer);
+            const res = T.transform('model', {foo: 1, bar: 2});
+            expect(res).to.be.eql({foo: '1', bar: '2'});
+            expect(calls).to.be.eq(2);
+          });
+
+          it('should pass arguments to the transformer', function () {
+            let calls = 0;
+            const dbs = new DatabaseSchema();
+            const myTransformer = function (value, options, context) {
+              calls++;
+              expect(value).to.be.eq(10);
+              expect(options).to.be.undefined;
+              expect(context).to.be.eql({
+                transformerName: 'myTransformer',
+                modelName: 'model',
+                propName: 'foo',
+              });
+              return String(value);
+            };
+            dbs.defineModel({
+              name: 'model',
+              properties: {
+                foo: {
+                  type: DataType.ANY,
+                  transform: [myTransformer],
+                },
+              },
+            });
+            const T = dbs.getService(ModelDataTransformer);
+            const res = T.transform('model', {foo: 10});
+            expect(res).to.be.eql({foo: '10'});
+            expect(calls).to.be.eq(1);
+          });
+
+          it('should transform the property by the asynchronous transformer', async function () {
+            let calls = 0;
+            const dbs = new DatabaseSchema();
+            const myTransformer = function (value) {
+              calls++;
+              return Promise.resolve(String(value));
+            };
+            dbs.defineModel({
+              name: 'model',
+              properties: {
+                foo: {
+                  type: DataType.ANY,
+                  transform: [myTransformer],
+                },
+              },
+            });
+            const T = dbs.getService(ModelDataTransformer);
+            const promise = T.transform('model', {foo: 10});
+            expect(promise).to.be.instanceof(Promise);
+            const res = await promise;
+            expect(res).to.be.eql({foo: '10'});
+            expect(calls).to.be.eq(1);
+          });
+
+          it('should transform properties by the asynchronous transformer', async function () {
+            let calls = 0;
+            const dbs = new DatabaseSchema();
+            const myTransformer = function (value) {
+              calls++;
+              return Promise.resolve(String(value));
+            };
+            dbs.defineModel({
+              name: 'model',
+              properties: {
+                foo: {
+                  type: DataType.ANY,
+                  transform: [myTransformer],
+                },
+                bar: {
+                  type: DataType.ANY,
+                  transform: [myTransformer],
+                },
+              },
+            });
+            const T = dbs.getService(ModelDataTransformer);
+            const promise = T.transform('model', {foo: 10, bar: 20});
+            expect(promise).to.be.instanceof(Promise);
+            const res = await promise;
+            expect(res).to.be.eql({foo: '10', bar: '20'});
+            expect(calls).to.be.eq(2);
+          });
+
+          it('should throw an error from the transformer', async function () {
+            let calls = 0;
+            const dbs = new DatabaseSchema();
+            const myTransformer = function () {
+              calls++;
+              throw new Error('My error');
+            };
+            dbs.defineModel({
+              name: 'model',
+              properties: {
+                foo: {
+                  type: DataType.ANY,
+                  transform: [myTransformer],
+                },
+              },
+            });
+            const T = dbs.getService(ModelDataTransformer);
+            const throwable = () => T.transform('model', {foo: 10});
+            expect(throwable).to.throw('My error');
+            expect(calls).to.be.eq(1);
+          });
+
+          it('should throw an error from the asynchronous transformer', async function () {
+            let calls = 0;
+            const dbs = new DatabaseSchema();
+            const myTransformer = async function () {
+              calls++;
+              throw new Error('My error');
+            };
+            dbs.defineModel({
+              name: 'model',
+              properties: {
+                foo: {
+                  type: DataType.ANY,
+                  transform: [myTransformer],
+                },
+              },
+            });
+            const T = dbs.getService(ModelDataTransformer);
+            const promise = T.transform('model', {foo: 10});
+            await expect(promise).to.rejectedWith('My error');
+            expect(calls).to.be.eq(1);
+          });
+
+          it('should transform the property by transformers with the correct order', function () {
+            const order = [];
+            const dbs = new DatabaseSchema();
+            const myTransformer1 = function (value) {
+              order.push('myTransformer1');
+              return String(value);
+            };
+            const myTransformer2 = function (value) {
+              order.push('myTransformer2');
+              return value.toUpperCase();
+            };
+            dbs.defineModel({
+              name: 'model',
+              properties: {
+                foo: {
+                  type: DataType.ANY,
+                  transform: [myTransformer1, myTransformer2],
+                },
+              },
+            });
+            const T = dbs.getService(ModelDataTransformer);
+            const res = T.transform('model', {foo: true});
+            expect(res).to.be.eql({foo: 'TRUE'});
+            expect(order).to.be.eql(['myTransformer1', 'myTransformer2']);
+          });
+
+          it('should transform the property by asynchronous transformers with the correct order', async function () {
+            const order = [];
+            const dbs = new DatabaseSchema();
+            const myTransformer1 = async function (value) {
+              order.push('myTransformer1');
+              return String(value);
+            };
+            const myTransformer2 = async function (value) {
+              order.push('myTransformer2');
+              return value.toUpperCase();
+            };
+            dbs.defineModel({
+              name: 'model',
+              properties: {
+                foo: {
+                  type: DataType.ANY,
+                  transform: [myTransformer1, myTransformer2],
+                },
+              },
+            });
+            const T = dbs.getService(ModelDataTransformer);
+            const res = await T.transform('model', {foo: true});
+            expect(res).to.be.eql({foo: 'TRUE'});
+            expect(order).to.be.eql(['myTransformer1', 'myTransformer2']);
+          });
+        });
+
+        describe('anonymous transformers', function () {
+          it('should not transform the non-provided property', function () {
+            let calls = 0;
+            const dbs = new DatabaseSchema();
+            dbs.defineModel({
+              name: 'model',
+              properties: {
+                foo: {
+                  type: DataType.ANY,
+                  transform: [
+                    () => {
+                      calls++;
+                      throw new Error('Should not to be called.');
+                    },
+                  ],
+                },
+              },
+            });
+            const T = dbs.getService(ModelDataTransformer);
+            const res = T.transform('model', {});
+            expect(res).to.be.eql({});
+            expect(calls).to.be.eq(0);
+          });
+
+          it('should not transform non-provided properties when the option "isPartial" is true', function () {
+            let calls = 0;
+            const dbs = new DatabaseSchema();
+            dbs.defineModel({
+              name: 'model',
+              properties: {
+                foo: {
+                  type: DataType.ANY,
+                  transform: [
+                    () => {
+                      calls++;
+                      throw new Error('Should not to be called.');
+                    },
+                  ],
+                },
+                bar: {
+                  type: DataType.ANY,
+                  transform: [
+                    () => {
+                      calls++;
+                      throw new Error('Should not to be called.');
+                    },
+                  ],
+                },
+              },
+            });
+            const T = dbs.getService(ModelDataTransformer);
+            const res = T.transform('model', {}, true);
+            expect(res).to.be.eql({});
+            expect(calls).to.be.eq(0);
+          });
+
+          it('should not transform undefined and null values', function () {
+            let calls = 0;
+            const dbs = new DatabaseSchema();
+            dbs.defineModel({
+              name: 'model',
+              properties: {
+                foo: {
+                  type: DataType.ANY,
+                  transform: [
+                    () => {
+                      calls++;
+                      throw new Error('Should not to be called.');
+                    },
+                  ],
+                },
+              },
+            });
+            const T = dbs.getService(ModelDataTransformer);
+            const res1 = T.transform('model', {foo: undefined});
+            const res2 = T.transform('model', {foo: null});
+            expect(res1).to.be.eql({foo: undefined});
+            expect(res2).to.be.eql({foo: null});
+            expect(calls).to.be.eq(0);
+          });
+
+          it('should not transform the empty value', function () {
+            let calls = 0;
+            const dbs = new DatabaseSchema();
+            dbs.defineModel({
+              name: 'model',
+              properties: {
+                foo: {
+                  type: DataType.ANY,
+                  transform: [
+                    () => {
+                      calls++;
+                      throw new Error('Should not to be called.');
+                    },
+                  ],
+                },
+              },
+            });
+            dbs
+              .getService(EmptyValuesService)
+              .setEmptyValuesOf(DataType.ANY, [10]);
+            const T = dbs.getService(ModelDataTransformer);
+            const res = T.transform('model', {foo: 10});
+            expect(res).to.be.eql({foo: 10});
+            expect(calls).to.be.eq(0);
+          });
+
+          it('should transform the property by the transformer', function () {
+            let calls = 0;
+            const dbs = new DatabaseSchema();
+            dbs.defineModel({
+              name: 'model',
+              properties: {
+                foo: {
+                  type: DataType.ANY,
+                  transform: [
+                    value => {
+                      calls++;
+                      return String(value);
+                    },
+                  ],
+                },
+              },
+            });
+            const T = dbs.getService(ModelDataTransformer);
+            const res = T.transform('model', {foo: 10});
+            expect(res).to.be.eql({foo: '10'});
+            expect(calls).to.be.eq(1);
+          });
+
+          it('should transform properties by transformers', function () {
+            let calls = 0;
+            const dbs = new DatabaseSchema();
+            dbs.defineModel({
+              name: 'model',
+              properties: {
+                foo: {
+                  type: DataType.ANY,
+                  transform: [
+                    value => {
+                      calls++;
+                      return String(value);
+                    },
+                  ],
+                },
+                bar: {
+                  type: DataType.ANY,
+                  transform: [
+                    value => {
+                      calls++;
+                      return String(value);
+                    },
+                  ],
+                },
+              },
+            });
+            const T = dbs.getService(ModelDataTransformer);
+            const res = T.transform('model', {foo: 1, bar: 2});
+            expect(res).to.be.eql({foo: '1', bar: '2'});
+            expect(calls).to.be.eq(2);
+          });
+
+          it('should pass arguments to the transformer', function () {
+            let calls = 0;
+            const dbs = new DatabaseSchema();
+            dbs.defineModel({
+              name: 'model',
+              properties: {
+                foo: {
+                  type: DataType.ANY,
+                  transform: [
+                    (value, options, context) => {
+                      calls++;
+                      expect(value).to.be.eq(10);
+                      expect(options).to.be.undefined;
+                      expect(context).to.be.eql({
+                        transformerName: undefined,
+                        modelName: 'model',
+                        propName: 'foo',
+                      });
+                      return String(value);
+                    },
+                  ],
+                },
+              },
+            });
+            const T = dbs.getService(ModelDataTransformer);
+            const res = T.transform('model', {foo: 10});
+            expect(res).to.be.eql({foo: '10'});
+            expect(calls).to.be.eq(1);
+          });
+
+          it('should transform the property by the asynchronous transformer', async function () {
+            let calls = 0;
+            const dbs = new DatabaseSchema();
+            dbs.defineModel({
+              name: 'model',
+              properties: {
+                foo: {
+                  type: DataType.ANY,
+                  transform: [
+                    value => {
+                      calls++;
+                      return Promise.resolve(String(value));
+                    },
+                  ],
+                },
+              },
+            });
+            const T = dbs.getService(ModelDataTransformer);
+            const promise = T.transform('model', {foo: 10});
+            expect(promise).to.be.instanceof(Promise);
+            const res = await promise;
+            expect(res).to.be.eql({foo: '10'});
+            expect(calls).to.be.eq(1);
+          });
+
+          it('should transform properties by the asynchronous transformer', async function () {
+            let calls = 0;
+            const dbs = new DatabaseSchema();
+            dbs.defineModel({
+              name: 'model',
+              properties: {
+                foo: {
+                  type: DataType.ANY,
+                  transform: [
+                    value => {
+                      calls++;
+                      return Promise.resolve(String(value));
+                    },
+                  ],
+                },
+                bar: {
+                  type: DataType.ANY,
+                  transform: [
+                    value => {
+                      calls++;
+                      return Promise.resolve(String(value));
+                    },
+                  ],
+                },
+              },
+            });
+            const T = dbs.getService(ModelDataTransformer);
+            const promise = T.transform('model', {foo: 10, bar: 20});
+            expect(promise).to.be.instanceof(Promise);
+            const res = await promise;
+            expect(res).to.be.eql({foo: '10', bar: '20'});
+            expect(calls).to.be.eq(2);
+          });
+
+          it('should throw an error from the transformer', async function () {
+            let calls = 0;
+            const dbs = new DatabaseSchema();
+            dbs.defineModel({
+              name: 'model',
+              properties: {
+                foo: {
+                  type: DataType.ANY,
+                  transform: [
+                    () => {
+                      calls++;
+                      throw new Error('My error');
+                    },
+                  ],
+                },
+              },
+            });
+            const T = dbs.getService(ModelDataTransformer);
+            const throwable = () => T.transform('model', {foo: 10});
+            expect(throwable).to.throw('My error');
+            expect(calls).to.be.eq(1);
+          });
+
+          it('should throw an error from the asynchronous transformer', async function () {
+            let calls = 0;
+            const dbs = new DatabaseSchema();
+            dbs.defineModel({
+              name: 'model',
+              properties: {
+                foo: {
+                  type: DataType.ANY,
+                  transform: [
+                    async () => {
+                      calls++;
+                      throw new Error('My error');
+                    },
+                  ],
+                },
+              },
+            });
+            const T = dbs.getService(ModelDataTransformer);
+            const promise = T.transform('model', {foo: 10});
+            await expect(promise).to.rejectedWith('My error');
+            expect(calls).to.be.eq(1);
+          });
+
+          it('should transform the property by transformers with the correct order', function () {
+            const order = [];
+            const dbs = new DatabaseSchema();
+            dbs.defineModel({
+              name: 'model',
+              properties: {
+                foo: {
+                  type: DataType.ANY,
+                  transform: [
+                    value => {
+                      order.push('myTransformer1');
+                      return String(value);
+                    },
+                    value => {
+                      order.push('myTransformer2');
+                      return value.toUpperCase();
+                    },
+                  ],
+                },
+              },
+            });
+            const T = dbs.getService(ModelDataTransformer);
+            const res = T.transform('model', {foo: true});
+            expect(res).to.be.eql({foo: 'TRUE'});
+            expect(order).to.be.eql(['myTransformer1', 'myTransformer2']);
+          });
+
+          it('should transform the property by asynchronous transformers with the correct order', async function () {
+            const order = [];
+            const dbs = new DatabaseSchema();
+            dbs.defineModel({
+              name: 'model',
+              properties: {
+                foo: {
+                  type: DataType.ANY,
+                  transform: [
+                    async value => {
+                      order.push('myTransformer1');
+                      return String(value);
+                    },
+                    async value => {
+                      order.push('myTransformer2');
+                      return value.toUpperCase();
+                    },
+                  ],
+                },
+              },
+            });
+            const T = dbs.getService(ModelDataTransformer);
+            const res = await T.transform('model', {foo: true});
+            expect(res).to.be.eql({foo: 'TRUE'});
+            expect(order).to.be.eql(['myTransformer1', 'myTransformer2']);
+          });
+        });
+      });
+    });
+
+    describe('when the option "transform" is an Object', function () {
+      it('should not transform the non-provided property', function () {
+        let calls = 0;
+        const dbs = new DatabaseSchema();
+        const reg = dbs.getService(PropertyTransformerRegistry);
+        reg.addTransformer('myTransformer', () => {
+          calls++;
+          throw new Error('Should not to be called.');
+        });
+        dbs.defineModel({
+          name: 'model',
+          properties: {
+            foo: {
+              type: DataType.ANY,
+              transform: {
+                myTransformer: true,
+              },
+            },
+          },
+        });
+        const T = dbs.getService(ModelDataTransformer);
+        const res = T.transform('model', {});
+        expect(res).to.be.eql({});
+        expect(calls).to.be.eq(0);
+      });
+
+      it('should not transform non-provided properties when the option "isPartial" is true', function () {
+        let calls = 0;
+        const dbs = new DatabaseSchema();
+        const reg = dbs.getService(PropertyTransformerRegistry);
+        reg.addTransformer('myTransformer', () => {
+          calls++;
+          throw new Error('Should not to be called.');
+        });
+        dbs.defineModel({
+          name: 'model',
+          properties: {
+            foo: {
+              type: DataType.ANY,
+              transform: {
+                myTransformer: true,
+              },
+            },
+            bar: {
+              type: DataType.ANY,
+              transform: {
+                myTransformer: true,
+              },
+            },
           },
-        },
+        });
+        const T = dbs.getService(ModelDataTransformer);
+        const res = T.transform('model', {}, true);
+        expect(res).to.be.eql({});
+        expect(calls).to.be.eq(0);
+      });
+
+      it('should not transform undefined and null values', function () {
+        let calls = 0;
+        const dbs = new DatabaseSchema();
+        const reg = dbs.getService(PropertyTransformerRegistry);
+        reg.addTransformer('myTransformer', () => {
+          calls++;
+          throw new Error('Should not to be called.');
+        });
+        dbs.defineModel({
+          name: 'model',
+          properties: {
+            foo: {
+              type: DataType.ANY,
+              transform: {
+                myTransformer: true,
+              },
+            },
+          },
+        });
+        const T = dbs.getService(ModelDataTransformer);
+        const res1 = T.transform('model', {foo: undefined});
+        const res2 = T.transform('model', {foo: null});
+        expect(res1).to.be.eql({foo: undefined});
+        expect(res2).to.be.eql({foo: null});
+        expect(calls).to.be.eq(0);
+      });
+
+      it('should not transform the empty value', function () {
+        let calls = 0;
+        const dbs = new DatabaseSchema();
+        const reg = dbs.getService(PropertyTransformerRegistry);
+        reg.addTransformer('myTransformer', () => {
+          calls++;
+          throw new Error('Should not to be called.');
+        });
+        dbs.defineModel({
+          name: 'model',
+          properties: {
+            foo: {
+              type: DataType.ANY,
+              transform: {
+                myTransformer: true,
+              },
+            },
+          },
+        });
+        dbs.getService(EmptyValuesService).setEmptyValuesOf(DataType.ANY, [10]);
+        const T = dbs.getService(ModelDataTransformer);
+        const res = T.transform('model', {foo: 10});
+        expect(res).to.be.eql({foo: 10});
+        expect(calls).to.be.eq(0);
+      });
+
+      it('should transform the property by the transformer', function () {
+        let calls = 0;
+        const dbs = new DatabaseSchema();
+        const reg = dbs.getService(PropertyTransformerRegistry);
+        reg.addTransformer('myTransformer', value => {
+          calls++;
+          return String(value);
+        });
+        dbs.defineModel({
+          name: 'model',
+          properties: {
+            foo: {
+              type: DataType.ANY,
+              transform: {
+                myTransformer: true,
+              },
+            },
+          },
+        });
+        const T = dbs.getService(ModelDataTransformer);
+        const res = T.transform('model', {foo: 10});
+        expect(res).to.be.eql({foo: '10'});
+        expect(calls).to.be.eq(1);
+      });
+
+      it('should transform properties by transformers', function () {
+        let calls = 0;
+        const dbs = new DatabaseSchema();
+        const reg = dbs.getService(PropertyTransformerRegistry);
+        reg.addTransformer('myTransformer', value => {
+          calls++;
+          return String(value);
+        });
+        dbs.defineModel({
+          name: 'model',
+          properties: {
+            foo: {
+              type: DataType.ANY,
+              transform: {
+                myTransformer: true,
+              },
+            },
+            bar: {
+              type: DataType.ANY,
+              transform: {
+                myTransformer: true,
+              },
+            },
+          },
+        });
+        const T = dbs.getService(ModelDataTransformer);
+        const res = T.transform('model', {foo: 1, bar: 2});
+        expect(res).to.be.eql({foo: '1', bar: '2'});
+        expect(calls).to.be.eq(2);
+      });
+
+      it('should pass arguments to the transformer', function () {
+        let calls = 0;
+        const dbs = new DatabaseSchema();
+        const reg = dbs.getService(PropertyTransformerRegistry);
+        reg.addTransformer('myTransformer', (value, options, context) => {
+          calls++;
+          expect(value).to.be.eq(10);
+          expect(options).to.be.eq('test');
+          expect(context).to.be.eql({
+            transformerName: 'myTransformer',
+            modelName: 'model',
+            propName: 'foo',
+          });
+          return String(value);
+        });
+        dbs.defineModel({
+          name: 'model',
+          properties: {
+            foo: {
+              type: DataType.ANY,
+              transform: {
+                myTransformer: 'test',
+              },
+            },
+          },
+        });
+        const T = dbs.getService(ModelDataTransformer);
+        const res = T.transform('model', {foo: 10});
+        expect(res).to.be.eql({foo: '10'});
+        expect(calls).to.be.eq(1);
+      });
+
+      it('should transform the property by the asynchronous transformer', async function () {
+        let calls = 0;
+        const dbs = new DatabaseSchema();
+        const reg = dbs.getService(PropertyTransformerRegistry);
+        reg.addTransformer('myTransformer', value => {
+          calls++;
+          return Promise.resolve(String(value));
+        });
+        dbs.defineModel({
+          name: 'model',
+          properties: {
+            foo: {
+              type: DataType.ANY,
+              transform: {
+                myTransformer: true,
+              },
+            },
+          },
+        });
+        const T = dbs.getService(ModelDataTransformer);
+        const promise = T.transform('model', {foo: 10});
+        expect(promise).to.be.instanceof(Promise);
+        const res = await promise;
+        expect(res).to.be.eql({foo: '10'});
+        expect(calls).to.be.eq(1);
+      });
+
+      it('should transform properties by the asynchronous transformer', async function () {
+        let calls = 0;
+        const dbs = new DatabaseSchema();
+        const reg = dbs.getService(PropertyTransformerRegistry);
+        reg.addTransformer('myTransformer', value => {
+          calls++;
+          return Promise.resolve(String(value));
+        });
+        dbs.defineModel({
+          name: 'model',
+          properties: {
+            foo: {
+              type: DataType.ANY,
+              transform: {
+                myTransformer: true,
+              },
+            },
+            bar: {
+              type: DataType.ANY,
+              transform: {
+                myTransformer: true,
+              },
+            },
+          },
+        });
+        const T = dbs.getService(ModelDataTransformer);
+        const promise = T.transform('model', {foo: 10, bar: 20});
+        expect(promise).to.be.instanceof(Promise);
+        const res = await promise;
+        expect(res).to.be.eql({foo: '10', bar: '20'});
+        expect(calls).to.be.eq(2);
+      });
+
+      it('should throw an error from the transformer', async function () {
+        let calls = 0;
+        const dbs = new DatabaseSchema();
+        const reg = dbs.getService(PropertyTransformerRegistry);
+        reg.addTransformer('myTransformer', () => {
+          calls++;
+          throw new Error('My error');
+        });
+        dbs.defineModel({
+          name: 'model',
+          properties: {
+            foo: {
+              type: DataType.ANY,
+              transform: {
+                myTransformer: true,
+              },
+            },
+          },
+        });
+        const T = dbs.getService(ModelDataTransformer);
+        const throwable = () => T.transform('model', {foo: 10});
+        expect(throwable).to.throw('My error');
+        expect(calls).to.be.eq(1);
+      });
+
+      it('should throw an error from the asynchronous transformer', async function () {
+        let calls = 0;
+        const dbs = new DatabaseSchema();
+        const reg = dbs.getService(PropertyTransformerRegistry);
+        reg.addTransformer('myTransformer', async () => {
+          calls++;
+          throw new Error('My error');
+        });
+        dbs.defineModel({
+          name: 'model',
+          properties: {
+            foo: {
+              type: DataType.ANY,
+              transform: {
+                myTransformer: true,
+              },
+            },
+          },
+        });
+        const T = dbs.getService(ModelDataTransformer);
+        const promise = T.transform('model', {foo: 10});
+        await expect(promise).to.rejectedWith('My error');
+        expect(calls).to.be.eq(1);
+      });
+
+      it('should transform the property by transformers with the correct order', function () {
+        const order = [];
+        const dbs = new DatabaseSchema();
+        const reg = dbs.getService(PropertyTransformerRegistry);
+        reg.addTransformer('myTransformer1', value => {
+          order.push('myTransformer1');
+          return String(value);
+        });
+        reg.addTransformer('myTransformer2', value => {
+          order.push('myTransformer2');
+          return value.toUpperCase();
+        });
+        dbs.defineModel({
+          name: 'model',
+          properties: {
+            foo: {
+              type: DataType.ANY,
+              transform: {
+                myTransformer1: true,
+                myTransformer2: true,
+              },
+            },
+          },
+        });
+        const T = dbs.getService(ModelDataTransformer);
+        const res = T.transform('model', {foo: true});
+        expect(res).to.be.eql({foo: 'TRUE'});
+        expect(order).to.be.eql(['myTransformer1', 'myTransformer2']);
+      });
+
+      it('should transform the property by asynchronous transformers with the correct order', async function () {
+        const order = [];
+        const dbs = new DatabaseSchema();
+        const reg = dbs.getService(PropertyTransformerRegistry);
+        reg.addTransformer('myTransformer1', async value => {
+          order.push('myTransformer1');
+          return String(value);
+        });
+        reg.addTransformer('myTransformer2', async value => {
+          order.push('myTransformer2');
+          return value.toUpperCase();
+        });
+        dbs.defineModel({
+          name: 'model',
+          properties: {
+            foo: {
+              type: DataType.ANY,
+              transform: {
+                myTransformer1: true,
+                myTransformer2: true,
+              },
+            },
+          },
+        });
+        const T = dbs.getService(ModelDataTransformer);
+        const res = await T.transform('model', {foo: true});
+        expect(res).to.be.eql({foo: 'TRUE'});
+        expect(order).to.be.eql(['myTransformer1', 'myTransformer2']);
       });
-      const T = dbs.getService(ModelDataTransformer);
-      const throwable = v => () => {
-        const models = dbs.getService(DefinitionRegistry)['_models'];
-        models.model.properties.foo.transform = v;
-        T.transform('model', {foo: 'bar'});
-      };
-      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({})();
     });
   });
 });