@e22m4u/js-repository 0.1.26 → 0.2.2

package/dist/cjs/index.cjs

@@ -2348,8 +2348,19 @@ var init_model_definition_utils = __esm({
         propNames.forEach((propName) => {
           if (!(propName in convertedData)) return;
           const colName = this.getColumnNameByPropertyName(modelName, propName);
-          if (propName === colName) return;
-          const propValue = convertedData[propName];
+          let propValue = convertedData[propName];
+          const propDef = propDefs[propName];
+          if (propValue !== null && typeof propValue === "object" && !Array.isArray(propValue) && propDef !== null && typeof propDef === "object" && propDef.type === DataType.OBJECT && propDef.model) {
+            propValue = this.convertPropertyNamesToColumnNames(
+              propDef.model,
+              propValue
+            );
+          }
+          if (Array.isArray(propValue) && propDef !== null && typeof propDef === "object" && propDef.type === DataType.ARRAY && propDef.itemModel) {
+            propValue = propValue.map((el) => {
+              return el !== null && typeof el === "object" && !Array.isArray(el) ? this.convertPropertyNamesToColumnNames(propDef.itemModel, el) : el;
+            });
+          }
           delete convertedData[propName];
           convertedData[colName] = propValue;
         });
@@ -2368,8 +2379,20 @@ var init_model_definition_utils = __esm({
         const convertedData = cloneDeep(tableData);
         propNames.forEach((propName) => {
           const colName = this.getColumnNameByPropertyName(modelName, propName);
-          if (!(colName in convertedData) || colName === propName) return;
-          const colValue = convertedData[colName];
+          if (!(colName in convertedData)) return;
+          let colValue = convertedData[colName];
+          const propDef = propDefs[propName];
+          if (colValue !== null && typeof colValue === "object" && !Array.isArray(colValue) && propDef !== null && typeof propDef === "object" && propDef.type === DataType.OBJECT && propDef.model) {
+            colValue = this.convertColumnNamesToPropertyNames(
+              propDef.model,
+              colValue
+            );
+          }
+          if (Array.isArray(colValue) && propDef !== null && typeof propDef === "object" && propDef.type === DataType.ARRAY && propDef.itemModel) {
+            colValue = colValue.map((el) => {
+              return el !== null && typeof el === "object" && !Array.isArray(el) ? this.convertColumnNamesToPropertyNames(propDef.itemModel, el) : el;
+            });
+          }
           delete convertedData[colName];
           convertedData[propName] = colValue;
         });
@@ -2838,6 +2861,14 @@ var init_properties_definition_validator = __esm({
             propDef.itemType
           );
         }
+        if (propDef.itemModel && typeof propDef.itemModel !== "string") {
+          throw new InvalidArgumentError(
+            'The provided option "itemModel" of the property %v in the model %v should be a String, but %v given.',
+            propName,
+            modelName,
+            propDef.itemModel
+          );
+        }
         if (propDef.model && typeof propDef.model !== "string")
           throw new InvalidArgumentError(
             'The provided option "model" of the property %v in the model %v should be a String, but %v given.',
@@ -2893,28 +2924,41 @@ var init_properties_definition_validator = __esm({
           );
         if (propDef.itemType && propDef.type !== DataType.ARRAY)
           throw new InvalidArgumentError(
-            'The property %v of the model %v has the non-array type, so it should not have the option "itemType" to be provided.',
+            'The property %v of the model %v has a non-array type, so it should not have the option "itemType" to be provided.',
             propName,
             modelName,
             propDef.type
           );
-        if (propDef.model && propDef.type !== DataType.OBJECT && propDef.itemType !== DataType.OBJECT) {
-          if (propDef.type !== DataType.ARRAY) {
+        if (propDef.itemModel && propDef.type !== DataType.ARRAY)
+          throw new InvalidArgumentError(
+            'The option "itemModel" is not supported for %s property type, so the property %v of the model %v should not have the option "itemModel" to be provided.',
+            capitalize(propDef.type),
+            propName,
+            modelName
+          );
+        if (propDef.itemModel && propDef.itemType !== DataType.OBJECT) {
+          if (propDef.itemType) {
             throw new InvalidArgumentError(
-              'The option "model" is not supported for %s property type, so the property %v of the model %v should not have the option "model" to be provided.',
-              capitalize(propDef.type),
+              'The provided option "itemModel" requires the option "itemType" to be explicitly set to Object, but the property %v of the model %v has specified item type as %s.',
               propName,
-              modelName
+              modelName,
+              capitalize(propDef.itemType)
             );
           } else {
             throw new InvalidArgumentError(
-              'The option "model" is not supported for Array property type of %s, so the property %v of the model %v should not have the option "model" to be provided.',
-              capitalize(propDef.itemType),
+              'The provided option "itemModel" requires the option "itemType" to be explicitly set to Object, but the property %v of the model %v does not have specified item type.',
               propName,
               modelName
             );
           }
         }
+        if (propDef.model && propDef.type !== DataType.OBJECT)
+          throw new InvalidArgumentError(
+            'The option "model" is not supported for %s property type, so the property %v of the model %v should not have the option "model" to be provided.',
+            capitalize(propDef.type),
+            propName,
+            modelName
+          );
         if (propDef.validate != null) {
           const propertyValidatorRegistry = this.getService(
             PropertyValidatorRegistry
@@ -3186,11 +3230,15 @@ var init_model_data_validator = __esm({
             );
             break;
           // OBJECT
-          case DataType.OBJECT:
+          case DataType.OBJECT: {
             if (!isPureObject(propValue)) throw createError("an Object");
-            if (typeof propDef === "object" && propDef.model)
-              this.validate(propDef.model, propValue);
+            if (typeof propDef === "object") {
+              const modelOptionField = isArrayValue ? "itemModel" : "model";
+              const modelOptionValue = propDef[modelOptionField];
+              if (modelOptionValue) this.validate(modelOptionValue, propValue);
+            }
             break;
+          }
         }
       }
       /**
@@ -5321,7 +5369,7 @@ var init_decorator = __esm({
 });
 
 // src/adapter/adapter.js
-var import_js_service32, _Adapter, Adapter;
+var import_js_service32, ADAPTER_CLASS_NAME, _Adapter, Adapter;
 var init_adapter = __esm({
   "src/adapter/adapter.js"() {
     "use strict";
@@ -5334,6 +5382,7 @@ var init_adapter = __esm({
     init_decorator();
     init_decorator();
     init_decorator();
+    ADAPTER_CLASS_NAME = "Adapter";
     _Adapter = class _Adapter extends import_js_service32.Service {
       /**
        * Settings.
@@ -5526,7 +5575,7 @@ var init_adapter = __esm({
      *
      * @type {string}
      */
-    __publicField(_Adapter, "kind", "Adapter");
+    __publicField(_Adapter, "kinds", [...import_js_service32.Service.kinds, ADAPTER_CLASS_NAME]);
     Adapter = _Adapter;
   }
 });
@@ -5928,7 +5977,7 @@ function findAdapterCtorInModule(module2) {
   let adapterCtor;
   if (!module2 || typeof module2 !== "object" || Array.isArray(module2)) return;
   for (const ctor of Object.values(module2)) {
-    if (typeof ctor === "function" && ctor.kind === Adapter.kind) {
+    if (typeof ctor === "function" && Array.isArray(ctor.kinds) && Adapter.kinds.includes(ADAPTER_CLASS_NAME)) {
       adapterCtor = ctor;
       break;
     }
@@ -5941,6 +5990,7 @@ var init_adapter_loader = __esm({
     "use strict";
     init_adapter();
     import_js_service33 = require("@e22m4u/js-service");
+    init_adapter();
     init_errors();
     init_();
     _AdapterLoader = class _AdapterLoader extends import_js_service33.Service {
@@ -6303,6 +6353,7 @@ var init_repository2 = __esm({
 // src/index.js
 var src_exports = {};
 __export(src_exports, {
+  ADAPTER_CLASS_NAME: () => ADAPTER_CLASS_NAME,
   Adapter: () => Adapter,
   AdapterLoader: () => AdapterLoader,
   AdapterRegistry: () => AdapterRegistry,
@@ -6407,6 +6458,7 @@ init_definition();
 init_repository2();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  ADAPTER_CLASS_NAME,
   Adapter,
   AdapterLoader,
   AdapterRegistry,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@e22m4u/js-repository",
-  "version": "0.1.26",
+  "version": "0.2.2",
   "description": "Модуль для работы с базами данных для Node.js",
   "type": "module",
   "types": "./src/index.d.ts",
@@ -40,32 +40,32 @@
   "homepage": "https://github.com/e22m4u/js-repository",
   "peerDependencies": {
     "@e22m4u/js-format": "0.1.x",
-    "@e22m4u/js-service": "0.1.x"
+    "@e22m4u/js-service": "0.2.x"
   },
   "devDependencies": {
-    "@commitlint/cli": "~19.5.0",
-    "@commitlint/config-conventional": "~19.5.0",
+    "@commitlint/cli": "~19.6.0",
+    "@commitlint/config-conventional": "~19.6.0",
     "@types/chai": "~5.0.1",
     "@types/chai-as-promised": "~8.0.1",
     "@types/chai-spies": "~1.0.6",
-    "@types/mocha": "~10.0.9",
+    "@types/mocha": "~10.0.10",
     "c8": "~10.1.2",
     "chai": "~5.1.2",
-    "chai-as-promised": "~8.0.0",
+    "chai-as-promised": "~8.0.1",
     "chai-spies": "~1.1.0",
     "chai-subset": "~1.6.0",
     "esbuild": "~0.24.0",
-    "eslint": "~9.14.0",
+    "eslint": "~9.15.0",
     "eslint-config-prettier": "~9.1.0",
     "eslint-plugin-chai-expect": "~3.1.0",
-    "eslint-plugin-jsdoc": "~50.4.3",
+    "eslint-plugin-jsdoc": "~50.5.0",
     "eslint-plugin-mocha": "~10.5.0",
-    "husky": "~9.1.6",
+    "husky": "~9.1.7",
     "mocha": "~10.8.2",
     "prettier": "~3.3.3",
-    "rimraf": "^6.0.1",
+    "rimraf": "~6.0.1",
     "tsx": "~4.19.2",
     "typescript": "~5.6.3",
-    "typescript-eslint": "~8.13.0"
+    "typescript-eslint": "~8.15.0"
   }
 }

package/src/adapter/adapter-loader.js

@@ -1,5 +1,6 @@
 import {Adapter} from './adapter.js';
 import {Service} from '@e22m4u/js-service';
+import {ADAPTER_CLASS_NAME} from './adapter.js';
 import {InvalidArgumentError} from '../errors/index.js';
 
 /**
@@ -54,7 +55,11 @@ function findAdapterCtorInModule(module) {
   let adapterCtor;
   if (!module || typeof module !== 'object' || Array.isArray(module)) return;
   for (const ctor of Object.values(module)) {
-    if (typeof ctor === 'function' && ctor.kind === Adapter.kind) {
+    if (
+      typeof ctor === 'function' &&
+      Array.isArray(ctor.kinds) &&
+      Adapter.kinds.includes(ADAPTER_CLASS_NAME)
+    ) {
       adapterCtor = ctor;
       break;
     }

package/src/adapter/adapter.js

@@ -10,6 +10,13 @@ import {FieldsFilteringDecorator} from './decorator/index.js';
 import {DataTransformationDecorator} from './decorator/index.js';
 import {PropertyUniquenessDecorator} from './decorator/index.js';
 
+/**
+ * Adapter class name.
+ *
+ * @type {string}
+ */
+export const ADAPTER_CLASS_NAME = 'Adapter';
+
 /**
  * Adapter.
  */
@@ -19,7 +26,7 @@ export class Adapter extends Service {
    *
    * @type {string}
    */
-  static kind = 'Adapter';
+  static kinds = [...Service.kinds, ADAPTER_CLASS_NAME];
 
   /**
    * Settings.

package/src/adapter/adapter.spec.js

@@ -3,6 +3,7 @@ import {chai} from '../chai.js';
 import {Schema} from '../schema.js';
 import {Adapter} from './adapter.js';
 import {Service} from '@e22m4u/js-service';
+import {ADAPTER_CLASS_NAME} from './adapter.js';
 import {ServiceContainer} from '@e22m4u/js-service';
 import {InclusionDecorator} from './decorator/index.js';
 import {DefaultValuesDecorator} from './decorator/index.js';
@@ -15,12 +16,11 @@ import {PropertyUniquenessDecorator} from './decorator/index.js';
 const sandbox = chai.spy.sandbox();
 
 describe('Adapter', function () {
-  it('exposes static property "kind"', function () {
-    expect(Adapter.kind).to.be.eq(Adapter.name);
-    const MyAdapter1 = class extends Adapter {};
-    expect(MyAdapter1.kind).to.be.eq(Adapter.name);
-    class MyAdapter2 extends Adapter {}
-    expect(MyAdapter2.kind).to.be.eq(Adapter.name);
+  it('exposes static property "kinds"', function () {
+    const kinds = [...Service.kinds, ADAPTER_CLASS_NAME];
+    expect(Adapter.kinds).to.be.eql(kinds);
+    const MyAdapter = class extends Adapter {};
+    expect(MyAdapter.kinds).to.be.eql(kinds);
   });
 
   describe('constructor', function () {

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

@@ -157,11 +157,15 @@ export class ModelDataValidator extends Service {
         );
         break;
       // OBJECT
-      case DataType.OBJECT:
+      case DataType.OBJECT: {
         if (!isPureObject(propValue)) throw createError('an Object');
-        if (typeof propDef === 'object' && propDef.model)
-          this.validate(propDef.model, propValue);
+        if (typeof propDef === 'object') {
+          const modelOptionField = isArrayValue ? 'itemModel' : 'model';
+          const modelOptionValue = propDef[modelOptionField];
+          if (modelOptionValue) this.validate(modelOptionValue, propValue);
+        }
         break;
+      }
     }
   }
 

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

@@ -1651,7 +1651,22 @@ describe('ModelDataValidator', function () {
             );
           });
 
-          describe('the "model" option', function () {
+          describe('the "itemModel" option', function () {
+            it('does not throw an error if the option "itemModel" is not specified in case of Object item type', function () {
+              const S = new Schema();
+              S.defineModel({
+                name: 'model',
+                properties: {
+                  foo: {
+                    type: DataType.ARRAY,
+                    itemType: DataType.OBJECT,
+                  },
+                },
+              });
+              const value = {foo: [{a: 1}, {b: 2}]};
+              S.getService(ModelDataValidator).validate('model', value);
+            });
+
             it('throws an error when the given object element has an invalid model', function () {
               const S = new Schema();
               S.defineModel({
@@ -1667,7 +1682,7 @@ describe('ModelDataValidator', function () {
                   bar: {
                     type: DataType.ARRAY,
                     itemType: DataType.OBJECT,
-                    model: 'modelA',
+                    itemModel: 'modelA',
                   },
                 },
               });
@@ -1696,7 +1711,7 @@ describe('ModelDataValidator', function () {
                   bar: {
                     type: DataType.ARRAY,
                     itemType: DataType.OBJECT,
-                    model: 'modelA',
+                    itemModel: 'modelA',
                   },
                 },
               });

package/src/definition/model/model-definition-utils.js

@@ -179,8 +179,43 @@ export class ModelDefinitionUtils extends Service {
     propNames.forEach(propName => {
       if (!(propName in convertedData)) return;
       const colName = this.getColumnNameByPropertyName(modelName, propName);
-      if (propName === colName) return;
-      const propValue = convertedData[propName];
+      let propValue = convertedData[propName];
+      // если значением является объект, то проверяем
+      // тип свойства и наличие модели для замены
+      // полей данного объекта
+      const propDef = propDefs[propName];
+      if (
+        propValue !== null &&
+        typeof propValue === 'object' &&
+        !Array.isArray(propValue) &&
+        propDef !== null &&
+        typeof propDef === 'object' &&
+        propDef.type === DataType.OBJECT &&
+        propDef.model
+      ) {
+        propValue = this.convertPropertyNamesToColumnNames(
+          propDef.model,
+          propValue,
+        );
+      }
+      // если значением является массив, то проверяем
+      // тип свойства и наличие модели элементов массива
+      // для замены полей каждого объекта
+      if (
+        Array.isArray(propValue) &&
+        propDef !== null &&
+        typeof propDef === 'object' &&
+        propDef.type === DataType.ARRAY &&
+        propDef.itemModel
+      ) {
+        propValue = propValue.map(el => {
+          // если элементом массива является объект,
+          // то конвертируем поля согласно модели
+          return el !== null && typeof el === 'object' && !Array.isArray(el)
+            ? this.convertPropertyNamesToColumnNames(propDef.itemModel, el)
+            : el;
+        });
+      }
       delete convertedData[propName];
       convertedData[colName] = propValue;
     });
@@ -201,8 +236,44 @@ export class ModelDefinitionUtils extends Service {
     const convertedData = cloneDeep(tableData);
     propNames.forEach(propName => {
       const colName = this.getColumnNameByPropertyName(modelName, propName);
-      if (!(colName in convertedData) || colName === propName) return;
-      const colValue = convertedData[colName];
+      if (!(colName in convertedData)) return;
+      let colValue = convertedData[colName];
+      // если значением является объект, то проверяем
+      // тип свойства и наличие модели для замены
+      // полей данного объекта
+      const propDef = propDefs[propName];
+      if (
+        colValue !== null &&
+        typeof colValue === 'object' &&
+        !Array.isArray(colValue) &&
+        propDef !== null &&
+        typeof propDef === 'object' &&
+        propDef.type === DataType.OBJECT &&
+        propDef.model
+      ) {
+        colValue = this.convertColumnNamesToPropertyNames(
+          propDef.model,
+          colValue,
+        );
+      }
+      // если значением является массив, то проверяем
+      // тип свойства и наличие модели элементов массива
+      // для замены полей каждого объекта
+      if (
+        Array.isArray(colValue) &&
+        propDef !== null &&
+        typeof propDef === 'object' &&
+        propDef.type === DataType.ARRAY &&
+        propDef.itemModel
+      ) {
+        colValue = colValue.map(el => {
+          // если элементом массива является объект,
+          // то конвертируем поля согласно модели
+          return el !== null && typeof el === 'object' && !Array.isArray(el)
+            ? this.convertColumnNamesToPropertyNames(propDef.itemModel, el)
+            : el;
+        });
+      }
       delete convertedData[colName];
       convertedData[propName] = colValue;
     });

package/src/definition/model/model-definition-utils.spec.js

@@ -690,6 +690,191 @@ describe('ModelDefinitionUtils', function () {
         .convertPropertyNamesToColumnNames('modelB', {foo: 'string'});
       expect(result).to.be.eql({fooColumn: 'string'});
     });
+
+    describe('embedded object with model', function () {
+      it('does nothing if no property definitions', function () {
+        const schema = new Schema();
+        schema.defineModel({
+          name: 'modelA',
+          properties: {
+            embedded: {
+              type: DataType.OBJECT,
+              model: 'modelB',
+            },
+          },
+        });
+        schema.defineModel({
+          name: 'modelB',
+        });
+        const result = schema
+          .getService(ModelDefinitionUtils)
+          .convertPropertyNamesToColumnNames('modelA', {
+            embedded: {foo: 'string'},
+          });
+        expect(result).to.be.eql({embedded: {foo: 'string'}});
+      });
+
+      it('does nothing if no column name specified', function () {
+        const schema = new Schema();
+        schema.defineModel({
+          name: 'modelA',
+          properties: {
+            embedded: {
+              type: DataType.OBJECT,
+              model: 'modelB',
+            },
+          },
+        });
+        schema.defineModel({
+          name: 'modelB',
+          properties: {
+            foo: DataType.STRING,
+            bar: DataType.NUMBER,
+          },
+        });
+        const result = schema
+          .getService(ModelDefinitionUtils)
+          .convertPropertyNamesToColumnNames('modelA', {
+            embedded: {foo: 'string', bar: 10},
+          });
+        expect(result).to.be.eql({embedded: {foo: 'string', bar: 10}});
+      });
+
+      it('replaces property names by column names', function () {
+        const schema = new Schema();
+        schema.defineModel({
+          name: 'modelA',
+          properties: {
+            embedded: {
+              type: DataType.OBJECT,
+              model: 'modelB',
+            },
+          },
+        });
+        schema.defineModel({
+          name: 'modelB',
+          properties: {
+            foo: {
+              type: DataType.STRING,
+              columnName: 'fooColumn',
+            },
+            bar: {
+              type: DataType.NUMBER,
+              columnName: 'barColumn',
+            },
+          },
+        });
+        const result = schema
+          .getService(ModelDefinitionUtils)
+          .convertPropertyNamesToColumnNames('modelA', {
+            embedded: {foo: 'string', bar: 10},
+          });
+        expect(result).to.be.eql({
+          embedded: {fooColumn: 'string', barColumn: 10},
+        });
+      });
+    });
+
+    describe('embedded array with items model', function () {
+      it('does nothing if no property definitions', function () {
+        const schema = new Schema();
+        schema.defineModel({
+          name: 'modelA',
+          properties: {
+            embedded: {
+              type: DataType.ARRAY,
+              itemType: DataType.OBJECT,
+              itemModel: 'modelB',
+            },
+          },
+        });
+        schema.defineModel({
+          name: 'modelB',
+        });
+        const result = schema
+          .getService(ModelDefinitionUtils)
+          .convertPropertyNamesToColumnNames('modelA', {
+            embedded: [{foo: 'val'}, {bar: 10}],
+          });
+        expect(result).to.be.eql({embedded: [{foo: 'val'}, {bar: 10}]});
+      });
+
+      it('does nothing if no column name specified', function () {
+        const schema = new Schema();
+        schema.defineModel({
+          name: 'modelA',
+          properties: {
+            embedded: {
+              type: DataType.ARRAY,
+              itemType: DataType.OBJECT,
+              itemModel: 'modelB',
+            },
+          },
+        });
+        schema.defineModel({
+          name: 'modelB',
+          properties: {
+            foo: DataType.STRING,
+            bar: DataType.NUMBER,
+          },
+        });
+        const result = schema
+          .getService(ModelDefinitionUtils)
+          .convertPropertyNamesToColumnNames('modelA', {
+            embedded: [
+              {foo: 'val1', bar: 10},
+              {foo: 'val2', bar: 20},
+            ],
+          });
+        expect(result).to.be.eql({
+          embedded: [
+            {foo: 'val1', bar: 10},
+            {foo: 'val2', bar: 20},
+          ],
+        });
+      });
+
+      it('replaces property names by column names', function () {
+        const schema = new Schema();
+        schema.defineModel({
+          name: 'modelA',
+          properties: {
+            embedded: {
+              type: DataType.ARRAY,
+              itemType: DataType.OBJECT,
+              itemModel: 'modelB',
+            },
+          },
+        });
+        schema.defineModel({
+          name: 'modelB',
+          properties: {
+            foo: {
+              type: DataType.STRING,
+              columnName: 'fooColumn',
+            },
+            bar: {
+              type: DataType.NUMBER,
+              columnName: 'barColumn',
+            },
+          },
+        });
+        const result = schema
+          .getService(ModelDefinitionUtils)
+          .convertPropertyNamesToColumnNames('modelA', {
+            embedded: [
+              {foo: 'val1', bar: 10},
+              {foo: 'val2', bar: 20},
+            ],
+          });
+        expect(result).to.be.eql({
+          embedded: [
+            {fooColumn: 'val1', barColumn: 10},
+            {fooColumn: 'val2', barColumn: 20},
+          ],
+        });
+      });
+    });
   });
 
   describe('convertColumnNamesToPropertyNames', function () {
@@ -764,6 +949,189 @@ describe('ModelDefinitionUtils', function () {
         .convertColumnNamesToPropertyNames('modelA', {fooColumn: 'string'});
       expect(result).to.be.eql({foo: 'string'});
     });
+
+    describe('embedded object with model', function () {
+      it('does nothing if no property definitions', function () {
+        const schema = new Schema();
+        schema.defineModel({
+          name: 'modelA',
+          properties: {
+            embedded: {
+              type: DataType.OBJECT,
+              model: 'modelB',
+            },
+          },
+        });
+        schema.defineModel({
+          name: 'modelB',
+        });
+        const result = schema
+          .getService(ModelDefinitionUtils)
+          .convertColumnNamesToPropertyNames('modelA', {
+            embedded: {foo: 'string'},
+          });
+        expect(result).to.be.eql({embedded: {foo: 'string'}});
+      });
+
+      it('does nothing if no column name specified', function () {
+        const schema = new Schema();
+        schema.defineModel({
+          name: 'modelA',
+          properties: {
+            embedded: {
+              type: DataType.OBJECT,
+              model: 'modelB',
+            },
+          },
+        });
+        schema.defineModel({
+          name: 'modelB',
+          properties: {
+            foo: DataType.STRING,
+            bar: DataType.NUMBER,
+          },
+        });
+        const result = schema
+          .getService(ModelDefinitionUtils)
+          .convertColumnNamesToPropertyNames('modelA', {
+            embedded: {foo: 'string', bar: 10},
+          });
+        expect(result).to.be.eql({embedded: {foo: 'string', bar: 10}});
+      });
+
+      it('replaces property names by column names', function () {
+        const schema = new Schema();
+        schema.defineModel({
+          name: 'modelA',
+          properties: {
+            embedded: {
+              type: DataType.OBJECT,
+              model: 'modelB',
+            },
+          },
+        });
+        schema.defineModel({
+          name: 'modelB',
+          properties: {
+            foo: {
+              type: DataType.STRING,
+              columnName: 'fooColumn',
+            },
+            bar: {
+              type: DataType.NUMBER,
+              columnName: 'barColumn',
+            },
+          },
+        });
+        const result = schema
+          .getService(ModelDefinitionUtils)
+          .convertColumnNamesToPropertyNames('modelA', {
+            embedded: {fooColumn: 'string', barColumn: 10},
+          });
+        expect(result).to.be.eql({embedded: {foo: 'string', bar: 10}});
+      });
+    });
+
+    describe('embedded array with items model', function () {
+      it('does nothing if no property definitions', function () {
+        const schema = new Schema();
+        schema.defineModel({
+          name: 'modelA',
+          properties: {
+            embedded: {
+              type: DataType.ARRAY,
+              itemType: DataType.OBJECT,
+              itemModel: 'modelB',
+            },
+          },
+        });
+        schema.defineModel({
+          name: 'modelB',
+        });
+        const result = schema
+          .getService(ModelDefinitionUtils)
+          .convertColumnNamesToPropertyNames('modelA', {
+            embedded: [{foo: 'val'}, {bar: 10}],
+          });
+        expect(result).to.be.eql({embedded: [{foo: 'val'}, {bar: 10}]});
+      });
+
+      it('does nothing if no column name specified', function () {
+        const schema = new Schema();
+        schema.defineModel({
+          name: 'modelA',
+          properties: {
+            embedded: {
+              type: DataType.ARRAY,
+              itemType: DataType.OBJECT,
+              itemModel: 'modelB',
+            },
+          },
+        });
+        schema.defineModel({
+          name: 'modelB',
+          properties: {
+            foo: DataType.STRING,
+            bar: DataType.NUMBER,
+          },
+        });
+        const result = schema
+          .getService(ModelDefinitionUtils)
+          .convertColumnNamesToPropertyNames('modelA', {
+            embedded: [
+              {foo: 'val1', bar: 10},
+              {foo: 'val2', bar: 20},
+            ],
+          });
+        expect(result).to.be.eql({
+          embedded: [
+            {foo: 'val1', bar: 10},
+            {foo: 'val2', bar: 20},
+          ],
+        });
+      });
+
+      it('replaces property names by column names', function () {
+        const schema = new Schema();
+        schema.defineModel({
+          name: 'modelA',
+          properties: {
+            embedded: {
+              type: DataType.ARRAY,
+              itemType: DataType.OBJECT,
+              itemModel: 'modelB',
+            },
+          },
+        });
+        schema.defineModel({
+          name: 'modelB',
+          properties: {
+            foo: {
+              type: DataType.STRING,
+              columnName: 'fooColumn',
+            },
+            bar: {
+              type: DataType.NUMBER,
+              columnName: 'barColumn',
+            },
+          },
+        });
+        const result = schema
+          .getService(ModelDefinitionUtils)
+          .convertColumnNamesToPropertyNames('modelA', {
+            embedded: [
+              {fooColumn: 'val1', barColumn: 10},
+              {fooColumn: 'val2', barColumn: 20},
+            ],
+          });
+        expect(result).to.be.eql({
+          embedded: [
+            {foo: 'val1', bar: 10},
+            {foo: 'val2', bar: 20},
+          ],
+        });
+      });
+    });
   });
 
   describe('getDataTypeByPropertyName', function () {

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

@@ -112,6 +112,15 @@ export class PropertiesDefinitionValidator extends Service {
         propDef.itemType,
       );
     }
+    if (propDef.itemModel && typeof propDef.itemModel !== 'string') {
+      throw new InvalidArgumentError(
+        'The provided option "itemModel" of the property %v in the model %v ' +
+          'should be a String, but %v given.',
+        propName,
+        modelName,
+        propDef.itemModel,
+      );
+    }
     if (propDef.model && typeof propDef.model !== 'string')
       throw new InvalidArgumentError(
         'The provided option "model" of the property %v in the model %v ' +
@@ -175,37 +184,50 @@ export class PropertiesDefinitionValidator extends Service {
       );
     if (propDef.itemType && propDef.type !== Type.ARRAY)
       throw new InvalidArgumentError(
-        'The property %v of the model %v has the non-array type, ' +
+        'The property %v of the model %v has a non-array type, ' +
           'so it should not have the option "itemType" to be provided.',
         propName,
         modelName,
         propDef.type,
       );
-    if (
-      propDef.model &&
-      propDef.type !== Type.OBJECT &&
-      propDef.itemType !== Type.OBJECT
-    ) {
-      if (propDef.type !== Type.ARRAY) {
+    if (propDef.itemModel && propDef.type !== Type.ARRAY)
+      throw new InvalidArgumentError(
+        'The option "itemModel" is not supported for %s property type, ' +
+          'so the property %v of the model %v should not have ' +
+          'the option "itemModel" to be provided.',
+        capitalize(propDef.type),
+        propName,
+        modelName,
+      );
+    if (propDef.itemModel && propDef.itemType !== Type.OBJECT) {
+      if (propDef.itemType) {
         throw new InvalidArgumentError(
-          'The option "model" is not supported for %s property type, ' +
-            'so the property %v of the model %v should not have ' +
-            'the option "model" to be provided.',
-          capitalize(propDef.type),
+          'The provided option "itemModel" requires the option "itemType" ' +
+            'to be explicitly set to Object, but the property %v of ' +
+            'the model %v has specified item type as %s.',
           propName,
           modelName,
+          capitalize(propDef.itemType),
         );
       } else {
         throw new InvalidArgumentError(
-          'The option "model" is not supported for Array property type of %s, ' +
-            'so the property %v of the model %v should not have ' +
-            'the option "model" to be provided.',
-          capitalize(propDef.itemType),
+          'The provided option "itemModel" requires the option "itemType" ' +
+            'to be explicitly set to Object, but the property %v of ' +
+            'the model %v does not have specified item type.',
           propName,
           modelName,
         );
       }
     }
+    if (propDef.model && propDef.type !== Type.OBJECT)
+      throw new InvalidArgumentError(
+        'The option "model" is not supported for %s property type, ' +
+          'so the property %v of the model %v should not have ' +
+          'the option "model" to be provided.',
+        capitalize(propDef.type),
+        propName,
+        modelName,
+      );
     if (propDef.validate != null) {
       const propertyValidatorRegistry = this.getService(
         PropertyValidatorRegistry,

package/src/definition/model/properties/properties-definition-validator.spec.js

@@ -133,7 +133,7 @@ describe('PropertiesDefinitionValidator', function () {
       validate(DataType.STRING)();
     });
 
-    it('expects provided the option "itemType" to be a DataType', function () {
+    it('expects the provided option "itemType" to be a DataType', function () {
       const validate = v => {
         const foo = {type: DataType.ARRAY, itemType: v};
         return () => S.validate('model', {foo});
@@ -153,7 +153,29 @@ describe('PropertiesDefinitionValidator', function () {
       validate(DataType.STRING)();
     });
 
-    it('expects provided the option "model" to be a string', function () {
+    it('expects the provided option "itemModel" to be a string', function () {
+      const validate = v => {
+        const foo = {
+          type: DataType.ARRAY,
+          itemType: DataType.OBJECT,
+          itemModel: v,
+        };
+        return () => S.validate('model', {foo});
+      };
+      const error = v =>
+        format(
+          'The provided option "itemModel" of the property "foo" ' +
+            'in the model "model" should be a String, but %s given.',
+          v,
+        );
+      expect(validate(10)).to.throw(error('10'));
+      expect(validate(true)).to.throw(error('true'));
+      expect(validate([])).to.throw(error('Array'));
+      expect(validate({})).to.throw(error('Object'));
+      validate('model')();
+    });
+
+    it('expects the provided option "model" to be a string', function () {
       const validate = v => {
         const foo = {
           type: DataType.OBJECT,
@@ -174,7 +196,7 @@ describe('PropertiesDefinitionValidator', function () {
       validate('model')();
     });
 
-    it('expects provided the option "primaryKey" to be a boolean', function () {
+    it('expects the provided option "primaryKey" to be a boolean', function () {
       const validate = v => {
         const foo = {
           type: DataType.STRING,
@@ -195,7 +217,7 @@ describe('PropertiesDefinitionValidator', function () {
       validate(false)();
     });
 
-    it('expects provided the option "columnName" to be a string', function () {
+    it('expects the provided option "columnName" to be a string', function () {
       const validate = v => {
         const foo = {
           type: DataType.STRING,
@@ -216,7 +238,7 @@ describe('PropertiesDefinitionValidator', function () {
       validate('columnName')();
     });
 
-    it('expects provided the option "columnType" to be a string', function () {
+    it('expects the provided option "columnType" to be a string', function () {
       const validate = v => {
         const foo = {
           type: DataType.STRING,
@@ -237,7 +259,7 @@ describe('PropertiesDefinitionValidator', function () {
       validate('columnType')();
     });
 
-    it('expects provided the option "required" to be a boolean', function () {
+    it('expects the provided option "required" to be a boolean', function () {
       const validate = v => {
         const foo = {
           type: DataType.STRING,
@@ -332,7 +354,7 @@ describe('PropertiesDefinitionValidator', function () {
         S.validate('model', {foo});
       };
       const error =
-        'The property "foo" of the model "model" has the non-array type, ' +
+        'The property "foo" of the model "model" has a non-array type, ' +
         'so it should not have the option "itemType" to be provided.';
       expect(validate(DataType.ANY)).to.throw(error);
       expect(validate(DataType.STRING)).to.throw(error);
@@ -364,27 +386,34 @@ describe('PropertiesDefinitionValidator', function () {
       validate(DataType.OBJECT)();
     });
 
-    it('the option "model" requires the "object" item type', function () {
+    it('the option "itemModel" requires the "object" item type', function () {
       const validate = v => () => {
         const foo = {
           type: DataType.ARRAY,
           itemType: v,
-          model: 'model',
+          itemModel: 'model',
         };
         S.validate('model', {foo});
       };
-      const error = v =>
+      const errorForNonEmpty = v =>
         format(
-          'The option "model" is not supported for Array property type of %s, ' +
-            'so the property "foo" of the model "model" should not have ' +
-            'the option "model" to be provided.',
+          'The provided option "itemModel" requires the option "itemType" ' +
+            'to be explicitly set to Object, but the property "foo" of ' +
+            'the model "model" has specified item type as %s.',
           v,
         );
-      expect(validate(DataType.ANY)).to.throw(error('Any'));
-      expect(validate(DataType.STRING)).to.throw(error('String'));
-      expect(validate(DataType.NUMBER)).to.throw(error('Number'));
-      expect(validate(DataType.BOOLEAN)).to.throw(error('Boolean'));
-      expect(validate(DataType.ARRAY)).to.throw(error('Array'));
+      const errorForEmpty = format(
+        'The provided option "itemModel" requires the option "itemType" ' +
+          'to be explicitly set to Object, but the property "foo" of ' +
+          'the model "model" does not have specified item type.',
+      );
+      expect(validate(DataType.ANY)).to.throw(errorForNonEmpty('Any'));
+      expect(validate(DataType.STRING)).to.throw(errorForNonEmpty('String'));
+      expect(validate(DataType.NUMBER)).to.throw(errorForNonEmpty('Number'));
+      expect(validate(DataType.BOOLEAN)).to.throw(errorForNonEmpty('Boolean'));
+      expect(validate(DataType.ARRAY)).to.throw(errorForNonEmpty('Array'));
+      expect(validate(undefined)).to.throw(errorForEmpty);
+      expect(validate(null)).to.throw(errorForEmpty);
       validate(DataType.OBJECT)();
     });
 
@@ -491,7 +520,7 @@ describe('PropertiesDefinitionValidator', function () {
       validate({myTransformer: true})();
     });
 
-    it('expects provided the option "unique" to be a Boolean or the PropertyUniqueness', function () {
+    it('expects the provided option "unique" to be a Boolean or the PropertyUniqueness', function () {
       const validate = v => {
         const foo = {
           type: DataType.STRING,

package/src/definition/model/properties/property-definition.d.ts

@@ -9,6 +9,7 @@ import {PropertyTransformOptions} from './property-transformer/index.js';
 export declare type FullPropertyDefinition = {
   type: DataType;
   itemType?: DataType;
+  itemModel?: string;
   model?: string;
   primaryKey?: boolean;
   columnName?: string;