@e22m4u/js-repository 0.2.1 → 0.2.3

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;
         });
@@ -2555,6 +2578,34 @@ var init_model_definition_utils = __esm({
         const relNames = Object.keys(relDefs);
         return excludeObjectKeys(modelData, relNames);
       }
+      /**
+       * Get model name of property value if defined.
+       *
+       * @param {string} modelName
+       * @param {string} propertyName
+       * @returns {undefined|string}
+       */
+      getModelNameOfPropertyValueIfDefined(modelName, propertyName) {
+        if (!modelName || typeof modelName !== "string")
+          throw new InvalidArgumentError(
+            'Parameter "modelName" of ModelDefinitionUtils.getModelNameOfPropertyValueIfDefined requires a non-empty String, but %v given.',
+            modelName
+          );
+        if (!propertyName || typeof propertyName !== "string")
+          throw new InvalidArgumentError(
+            'Parameter "propertyName" of ModelDefinitionUtils.getModelNameOfPropertyValueIfDefined requires a non-empty String, but %v given.',
+            propertyName
+          );
+        const propDefs = this.getPropertiesDefinitionInBaseModelHierarchy(modelName);
+        const propDef = propDefs[propertyName];
+        if (!propDef) return void 0;
+        if (propDef && typeof propDef === "object") {
+          if (propDef.type === DataType.OBJECT) return propDef.model || void 0;
+          if (propDef.type === DataType.ARRAY)
+            return propDef.itemModel || void 0;
+        }
+        return void 0;
+      }
     };
     __name(_ModelDefinitionUtils, "ModelDefinitionUtils");
     ModelDefinitionUtils = _ModelDefinitionUtils;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@e22m4u/js-repository",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "description": "Модуль для работы с базами данных для Node.js",
   "type": "module",
   "types": "./src/index.d.ts",
@@ -51,21 +51,21 @@
     "@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.15.0",
     "eslint-config-prettier": "~9.1.0",
     "eslint-plugin-chai-expect": "~3.1.0",
-    "eslint-plugin-jsdoc": "~50.5.0",
+    "eslint-plugin-jsdoc": "~50.6.0",
     "eslint-plugin-mocha": "~10.5.0",
     "husky": "~9.1.7",
     "mocha": "~10.8.2",
-    "prettier": "~3.3.3",
+    "prettier": "~3.4.1",
     "rimraf": "~6.0.1",
     "tsx": "~4.19.2",
     "typescript": "~5.6.3",
-    "typescript-eslint": "~8.15.0"
+    "typescript-eslint": "~8.16.0"
   }
 }

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;
     });
@@ -404,4 +475,51 @@ export class ModelDefinitionUtils extends Service {
     const relNames = Object.keys(relDefs);
     return excludeObjectKeys(modelData, relNames);
   }
+
+  /**
+   * Get model name of property value if defined.
+   *
+   * @param {string} modelName
+   * @param {string} propertyName
+   * @returns {undefined|string}
+   */
+  getModelNameOfPropertyValueIfDefined(modelName, propertyName) {
+    if (!modelName || typeof modelName !== 'string')
+      throw new InvalidArgumentError(
+        'Parameter "modelName" of ' +
+          'ModelDefinitionUtils.getModelNameOfPropertyValueIfDefined ' +
+          'requires a non-empty String, but %v given.',
+        modelName,
+      );
+    if (!propertyName || typeof propertyName !== 'string')
+      throw new InvalidArgumentError(
+        'Parameter "propertyName" of ' +
+          'ModelDefinitionUtils.getModelNameOfPropertyValueIfDefined ' +
+          'requires a non-empty String, but %v given.',
+        propertyName,
+      );
+    // если определение свойства не найдено,
+    // то возвращаем undefined
+    const propDefs =
+      this.getPropertiesDefinitionInBaseModelHierarchy(modelName);
+    const propDef = propDefs[propertyName];
+    if (!propDef) return undefined;
+    // если определение свойства является
+    // объектом, то проверяем тип и возвращаем
+    // название модели
+    if (propDef && typeof propDef === 'object') {
+      // если тип свойства является объектом,
+      // то возвращаем значение опции "model",
+      // или undefined
+      if (propDef.type === DataType.OBJECT) return propDef.model || undefined;
+      // если тип свойства является массивом,
+      // то возвращаем значение опции "itemModel",
+      // или undefined
+      if (propDef.type === DataType.ARRAY)
+        return propDef.itemModel || undefined;
+    }
+    // если определение свойства не является
+    // объектом, то возвращаем undefined
+    return undefined;
+  }
 }

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 () {
@@ -1553,4 +1921,236 @@ describe('ModelDefinitionUtils', function () {
       throwable({foo: 'bar'})();
     });
   });
+
+  describe('getModelNameOfPropertyValueIfDefined', function () {
+    it('returns undefined if a given property does not exist in the model', function () {
+      const schema = new Schema();
+      schema.defineModel({name: 'model'});
+      const S = schema.getService(ModelDefinitionUtils);
+      const res = S.getModelNameOfPropertyValueIfDefined('model', 'foo');
+      expect(res).to.be.undefined;
+    });
+
+    describe('short property definition', function () {
+      it('requires parameter "modelName" to be a non-empty String', function () {
+        const schema = new Schema();
+        schema.defineModel({
+          name: 'model',
+          properties: {
+            foo: DataType.OBJECT,
+          },
+        });
+        const S = schema.getService(ModelDefinitionUtils);
+        const throwable = v => () =>
+          S.getModelNameOfPropertyValueIfDefined(v, 'foo');
+        const error = v =>
+          format(
+            'Parameter "modelName" of ' +
+              'ModelDefinitionUtils.getModelNameOfPropertyValueIfDefined ' +
+              'requires a non-empty String, but %s given.',
+            v,
+          );
+        expect(throwable('')).to.throw(error('""'));
+        expect(throwable(10)).to.throw(error('10'));
+        expect(throwable(true)).to.throw(error('true'));
+        expect(throwable(false)).to.throw(error('false'));
+        expect(throwable([])).to.throw(error('Array'));
+        expect(throwable({})).to.throw(error('Object'));
+        expect(throwable(undefined)).to.throw(error('undefined'));
+        expect(throwable(null)).to.throw(error('null'));
+        throwable('model')();
+      });
+
+      it('requires parameter "propertyName" to be a non-empty String', function () {
+        const schema = new Schema();
+        schema.defineModel({
+          name: 'model',
+          properties: {
+            foo: DataType.OBJECT,
+          },
+        });
+        const S = schema.getService(ModelDefinitionUtils);
+        const throwable = v => () =>
+          S.getModelNameOfPropertyValueIfDefined('model', v);
+        const error = v =>
+          format(
+            'Parameter "propertyName" of ' +
+              'ModelDefinitionUtils.getModelNameOfPropertyValueIfDefined ' +
+              'requires a non-empty String, but %s given.',
+            v,
+          );
+        expect(throwable('')).to.throw(error('""'));
+        expect(throwable(10)).to.throw(error('10'));
+        expect(throwable(true)).to.throw(error('true'));
+        expect(throwable(false)).to.throw(error('false'));
+        expect(throwable([])).to.throw(error('Array'));
+        expect(throwable({})).to.throw(error('Object'));
+        expect(throwable(undefined)).to.throw(error('undefined'));
+        expect(throwable(null)).to.throw(error('null'));
+        throwable('foo')();
+      });
+
+      it('returns undefined if the property definition is DataType', function () {
+        const fn = v => {
+          const schema = new Schema();
+          schema.defineModel({
+            name: 'model',
+            properties: {
+              foo: v,
+            },
+          });
+          const S = schema.getService(ModelDefinitionUtils);
+          return S.getModelNameOfPropertyValueIfDefined('model', 'foo');
+        };
+        expect(fn(DataType.ANY)).to.be.undefined;
+        expect(fn(DataType.STRING)).to.be.undefined;
+        expect(fn(DataType.NUMBER)).to.be.undefined;
+        expect(fn(DataType.BOOLEAN)).to.be.undefined;
+        expect(fn(DataType.ARRAY)).to.be.undefined;
+        expect(fn(DataType.OBJECT)).to.be.undefined;
+      });
+    });
+
+    describe('full property definition', function () {
+      it('requires parameter "modelName" to be a non-empty String', function () {
+        const schema = new Schema();
+        schema.defineModel({
+          name: 'model',
+          properties: {
+            foo: {
+              type: DataType.OBJECT,
+            },
+          },
+        });
+        const S = schema.getService(ModelDefinitionUtils);
+        const throwable = v => () =>
+          S.getModelNameOfPropertyValueIfDefined(v, 'foo');
+        const error = v =>
+          format(
+            'Parameter "modelName" of ' +
+              'ModelDefinitionUtils.getModelNameOfPropertyValueIfDefined ' +
+              'requires a non-empty String, but %s given.',
+            v,
+          );
+        expect(throwable('')).to.throw(error('""'));
+        expect(throwable(10)).to.throw(error('10'));
+        expect(throwable(true)).to.throw(error('true'));
+        expect(throwable(false)).to.throw(error('false'));
+        expect(throwable([])).to.throw(error('Array'));
+        expect(throwable({})).to.throw(error('Object'));
+        expect(throwable(undefined)).to.throw(error('undefined'));
+        expect(throwable(null)).to.throw(error('null'));
+        throwable('model')();
+      });
+
+      it('requires parameter "propertyName" to be a non-empty String', function () {
+        const schema = new Schema();
+        schema.defineModel({
+          name: 'model',
+          properties: {
+            foo: {
+              type: DataType.OBJECT,
+            },
+          },
+        });
+        const S = schema.getService(ModelDefinitionUtils);
+        const throwable = v => () =>
+          S.getModelNameOfPropertyValueIfDefined('model', v);
+        const error = v =>
+          format(
+            'Parameter "propertyName" of ' +
+              'ModelDefinitionUtils.getModelNameOfPropertyValueIfDefined ' +
+              'requires a non-empty String, but %s given.',
+            v,
+          );
+        expect(throwable('')).to.throw(error('""'));
+        expect(throwable(10)).to.throw(error('10'));
+        expect(throwable(true)).to.throw(error('true'));
+        expect(throwable(false)).to.throw(error('false'));
+        expect(throwable([])).to.throw(error('Array'));
+        expect(throwable({})).to.throw(error('Object'));
+        expect(throwable(undefined)).to.throw(error('undefined'));
+        expect(throwable(null)).to.throw(error('null'));
+        throwable('foo')();
+      });
+
+      it('return undefined if no model name specified', function () {
+        const fn = v => {
+          const schema = new Schema();
+          schema.defineModel({
+            name: 'model',
+            properties: {
+              foo: {
+                type: v,
+              },
+            },
+          });
+          const S = schema.getService(ModelDefinitionUtils);
+          return S.getModelNameOfPropertyValueIfDefined('model', 'foo');
+        };
+        expect(fn(DataType.ANY)).to.be.undefined;
+        expect(fn(DataType.STRING)).to.be.undefined;
+        expect(fn(DataType.NUMBER)).to.be.undefined;
+        expect(fn(DataType.BOOLEAN)).to.be.undefined;
+        expect(fn(DataType.ARRAY)).to.be.undefined;
+        expect(fn(DataType.OBJECT)).to.be.undefined;
+      });
+
+      it('return undefined if no model name specified in case of Array property', function () {
+        const fn = v => {
+          const schema = new Schema();
+          schema.defineModel({
+            name: 'model',
+            properties: {
+              foo: {
+                type: DataType.ARRAY,
+                itemType: v,
+              },
+            },
+          });
+          const S = schema.getService(ModelDefinitionUtils);
+          return S.getModelNameOfPropertyValueIfDefined('model', 'foo');
+        };
+        expect(fn(DataType.ANY)).to.be.undefined;
+        expect(fn(DataType.STRING)).to.be.undefined;
+        expect(fn(DataType.NUMBER)).to.be.undefined;
+        expect(fn(DataType.BOOLEAN)).to.be.undefined;
+        expect(fn(DataType.ARRAY)).to.be.undefined;
+        expect(fn(DataType.OBJECT)).to.be.undefined;
+      });
+
+      it('returns a model name from the option "model" in case of Object property', function () {
+        const schema = new Schema();
+        schema.defineModel({
+          name: 'model',
+          properties: {
+            foo: {
+              type: DataType.OBJECT,
+              model: 'myModel',
+            },
+          },
+        });
+        const S = schema.getService(ModelDefinitionUtils);
+        const res = S.getModelNameOfPropertyValueIfDefined('model', 'foo');
+        expect(res).to.be.eq('myModel');
+      });
+
+      it('returns a model name from the option "itemModel" in case of Array property', function () {
+        const schema = new Schema();
+        schema.defineModel({
+          name: 'model',
+          properties: {
+            foo: {
+              type: DataType.ARRAY,
+              itemType: DataType.OBJECT,
+              itemModel: 'myModel',
+            },
+          },
+        });
+        const S = schema.getService(ModelDefinitionUtils);
+        const res = S.getModelNameOfPropertyValueIfDefined('model', 'foo');
+        expect(res).to.be.eq('myModel');
+      });
+    });
+  });
 });