@e22m4u/js-repository 0.8.8 → 0.8.9

package/dist/cjs/index.cjs

@@ -419,24 +419,6 @@ var init_exclude_object_keys = __esm({
   }
 });
 
-// src/utils/model-name-to-model-key.js
-function modelNameToModelKey(modelName) {
-  if (!modelName || typeof modelName !== "string" || /\s/.test(modelName)) {
-    throw new InvalidArgumentError(
-      "Model name must be a non-empty String without spaces, but %v was given.",
-      modelName
-    );
-  }
-  return modelName.toLowerCase().replace(/[-_]/g, "");
-}
-var init_model_name_to_model_key = __esm({
-  "src/utils/model-name-to-model-key.js"() {
-    "use strict";
-    init_errors();
-    __name(modelNameToModelKey, "modelNameToModelKey");
-  }
-});
-
 // src/utils/index.js
 var init_utils = __esm({
   "src/utils/index.js"() {
@@ -452,7 +434,6 @@ var init_utils = __esm({
     init_get_value_by_path();
     init_select_object_keys();
     init_exclude_object_keys();
-    init_model_name_to_model_key();
   }
 });
 
@@ -1833,17 +1814,65 @@ var init_property_uniqueness = __esm({
   }
 });
 
+// src/definition/datasource/datasource-definition-validator.js
+var import_js_service6, DatasourceDefinitionValidator;
+var init_datasource_definition_validator = __esm({
+  "src/definition/datasource/datasource-definition-validator.js"() {
+    "use strict";
+    import_js_service6 = require("@e22m4u/js-service");
+    init_errors();
+    DatasourceDefinitionValidator = class extends import_js_service6.Service {
+      static {
+        __name(this, "DatasourceDefinitionValidator");
+      }
+      /**
+       * Validate.
+       *
+       * @param {object} datasourceDef
+       */
+      validate(datasourceDef) {
+        if (!datasourceDef || typeof datasourceDef !== "object") {
+          throw new InvalidArgumentError(
+            "Datasource definition must be an Object, but %v was given.",
+            datasourceDef
+          );
+        }
+        if (!datasourceDef.name || typeof datasourceDef.name !== "string") {
+          throw new InvalidArgumentError(
+            'Datasource definition requires the option "name" as a non-empty String, but %v was given.',
+            datasourceDef.name
+          );
+        }
+        if (!datasourceDef.adapter || typeof datasourceDef.adapter !== "string") {
+          throw new InvalidArgumentError(
+            'Datasource %v requires the option "adapter" as a non-empty String, but %v was given.',
+            datasourceDef.name,
+            datasourceDef.adapter
+          );
+        }
+      }
+    };
+  }
+});
+
+// src/definition/datasource/index.js
+var init_datasource = __esm({
+  "src/definition/datasource/index.js"() {
+    "use strict";
+    init_datasource_definition_validator();
+  }
+});
+
 // src/definition/definition-registry.js
-var import_js_service6, DefinitionRegistry;
+var import_js_service7, DefinitionRegistry;
 var init_definition_registry = __esm({
   "src/definition/definition-registry.js"() {
     "use strict";
-    import_js_service6 = require("@e22m4u/js-service");
-    init_utils();
+    import_js_service7 = require("@e22m4u/js-service");
     init_errors();
     init_model();
-    init_definition();
-    DefinitionRegistry = class extends import_js_service6.Service {
+    init_datasource();
+    DefinitionRegistry = class extends import_js_service7.Service {
       static {
         __name(this, "DefinitionRegistry");
       }
@@ -1894,6 +1923,14 @@ var init_definition_registry = __esm({
         }
         return datasourceDef;
       }
+      /**
+       * Get datasource names.
+       *
+       * @returns {string[]}
+       */
+      getDatasourceNames() {
+        return Object.keys(this._datasources);
+      }
       /**
        * Add model.
        *
@@ -1901,14 +1938,11 @@ var init_definition_registry = __esm({
        */
       addModel(modelDef) {
         this.getService(ModelDefinitionValidator).validate(modelDef);
-        const modelKey = modelNameToModelKey(modelDef.name);
-        if (modelKey in this._models) {
-          throw new InvalidArgumentError(
-            "Model %v is already defined.",
-            modelDef.name
-          );
+        const name = modelDef.name;
+        if (name in this._models) {
+          throw new InvalidArgumentError("Model %v is already defined.", name);
         }
-        this._models[modelKey] = modelDef;
+        this._models[name] = modelDef;
       }
       /**
        * Has model.
@@ -1917,8 +1951,7 @@ var init_definition_registry = __esm({
        * @returns {boolean}
        */
       hasModel(name) {
-        const modelKey = modelNameToModelKey(name);
-        return Boolean(this._models[modelKey]);
+        return Boolean(this._models[name]);
       }
       /**
        * Get model.
@@ -1927,29 +1960,36 @@ var init_definition_registry = __esm({
        * @returns {object}
        */
       getModel(name) {
-        const modelKey = modelNameToModelKey(name);
-        const modelDef = this._models[modelKey];
+        const modelDef = this._models[name];
         if (!modelDef) {
           throw new InvalidArgumentError("Model %v is not defined.", name);
         }
         return modelDef;
       }
+      /**
+       * Get model names.
+       *
+       * @returns {string[]}
+       */
+      getModelNames() {
+        return Object.keys(this._models);
+      }
     };
   }
 });
 
 // src/definition/model/model-definition-utils.js
-var import_js_service7, DEFAULT_PRIMARY_KEY_PROPERTY_NAME, ModelDefinitionUtils;
+var import_js_service8, DEFAULT_PRIMARY_KEY_PROPERTY_NAME, ModelDefinitionUtils;
 var init_model_definition_utils = __esm({
   "src/definition/model/model-definition-utils.js"() {
     "use strict";
-    import_js_service7 = require("@e22m4u/js-service");
+    import_js_service8 = require("@e22m4u/js-service");
     init_properties();
     init_errors();
     init_definition_registry();
     init_utils();
     DEFAULT_PRIMARY_KEY_PROPERTY_NAME = "id";
-    ModelDefinitionUtils = class extends import_js_service7.Service {
+    ModelDefinitionUtils = class extends import_js_service8.Service {
       static {
         __name(this, "ModelDefinitionUtils");
       }
@@ -2383,15 +2423,15 @@ var init_model_definition_utils = __esm({
 });
 
 // src/definition/model/properties/required-property-validator.js
-var import_js_service8, RequiredPropertyValidator;
+var import_js_service9, RequiredPropertyValidator;
 var init_required_property_validator = __esm({
   "src/definition/model/properties/required-property-validator.js"() {
     "use strict";
     init_data_type();
-    import_js_service8 = require("@e22m4u/js-service");
+    import_js_service9 = require("@e22m4u/js-service");
     init_errors();
     init_model_definition_utils();
-    RequiredPropertyValidator = class extends import_js_service8.Service {
+    RequiredPropertyValidator = class extends import_js_service9.Service {
       static {
         __name(this, "RequiredPropertyValidator");
       }
@@ -2456,16 +2496,16 @@ var init_required_property_validator = __esm({
 });
 
 // src/definition/model/properties/property-uniqueness-validator.js
-var import_js_service9, PropertyUniquenessValidator;
+var import_js_service10, PropertyUniquenessValidator;
 var init_property_uniqueness_validator = __esm({
   "src/definition/model/properties/property-uniqueness-validator.js"() {
     "use strict";
-    import_js_service9 = require("@e22m4u/js-service");
+    import_js_service10 = require("@e22m4u/js-service");
     init_utils();
     init_property_uniqueness();
     init_errors();
     init_model_definition_utils();
-    PropertyUniquenessValidator = class extends import_js_service9.Service {
+    PropertyUniquenessValidator = class extends import_js_service10.Service {
       static {
         __name(this, "PropertyUniquenessValidator");
       }
@@ -2588,14 +2628,14 @@ var init_property_uniqueness_validator = __esm({
 });
 
 // src/definition/model/properties/primary-keys-definition-validator.js
-var import_js_service10, PrimaryKeysDefinitionValidator;
+var import_js_service11, PrimaryKeysDefinitionValidator;
 var init_primary_keys_definition_validator = __esm({
   "src/definition/model/properties/primary-keys-definition-validator.js"() {
     "use strict";
-    import_js_service10 = require("@e22m4u/js-service");
+    import_js_service11 = require("@e22m4u/js-service");
     init_errors();
     init_model_definition_utils();
-    PrimaryKeysDefinitionValidator = class extends import_js_service10.Service {
+    PrimaryKeysDefinitionValidator = class extends import_js_service11.Service {
       static {
         __name(this, "PrimaryKeysDefinitionValidator");
       }
@@ -2643,17 +2683,17 @@ var init_primary_keys_definition_validator = __esm({
 });
 
 // src/definition/model/properties/properties-definition-validator.js
-var import_js_service11, PropertiesDefinitionValidator;
+var import_js_service12, PropertiesDefinitionValidator;
 var init_properties_definition_validator = __esm({
   "src/definition/model/properties/properties-definition-validator.js"() {
     "use strict";
-    import_js_service11 = require("@e22m4u/js-service");
+    import_js_service12 = require("@e22m4u/js-service");
     init_data_type();
     init_utils();
     init_property_uniqueness();
     init_errors();
     init_primary_keys_definition_validator();
-    PropertiesDefinitionValidator = class extends import_js_service11.Service {
+    PropertiesDefinitionValidator = class extends import_js_service12.Service {
       static {
         __name(this, "PropertiesDefinitionValidator");
       }
@@ -2908,14 +2948,14 @@ var init_model_definition = __esm({
 });
 
 // src/definition/model/model-data-sanitizer.js
-var import_js_service12, ModelDataSanitizer;
+var import_js_service13, ModelDataSanitizer;
 var init_model_data_sanitizer = __esm({
   "src/definition/model/model-data-sanitizer.js"() {
     "use strict";
-    import_js_service12 = require("@e22m4u/js-service");
+    import_js_service13 = require("@e22m4u/js-service");
     init_errors();
     init_model_definition_utils();
-    ModelDataSanitizer = class extends import_js_service12.Service {
+    ModelDataSanitizer = class extends import_js_service13.Service {
       static {
         __name(this, "ModelDataSanitizer");
       }
@@ -2948,15 +2988,15 @@ var init_model_data_sanitizer = __esm({
 });
 
 // src/definition/model/model-definition-validator.js
-var import_js_service13, ModelDefinitionValidator;
+var import_js_service14, ModelDefinitionValidator;
 var init_model_definition_validator = __esm({
   "src/definition/model/model-definition-validator.js"() {
     "use strict";
-    import_js_service13 = require("@e22m4u/js-service");
+    import_js_service14 = require("@e22m4u/js-service");
     init_errors();
     init_relations();
     init_properties();
-    ModelDefinitionValidator = class extends import_js_service13.Service {
+    ModelDefinitionValidator = class extends import_js_service14.Service {
       static {
         __name(this, "ModelDefinitionValidator");
       }
@@ -3043,55 +3083,6 @@ var init_model = __esm({
   }
 });
 
-// src/definition/datasource/datasource-definition-validator.js
-var import_js_service14, DatasourceDefinitionValidator;
-var init_datasource_definition_validator = __esm({
-  "src/definition/datasource/datasource-definition-validator.js"() {
-    "use strict";
-    import_js_service14 = require("@e22m4u/js-service");
-    init_errors();
-    DatasourceDefinitionValidator = class extends import_js_service14.Service {
-      static {
-        __name(this, "DatasourceDefinitionValidator");
-      }
-      /**
-       * Validate.
-       *
-       * @param {object} datasourceDef
-       */
-      validate(datasourceDef) {
-        if (!datasourceDef || typeof datasourceDef !== "object") {
-          throw new InvalidArgumentError(
-            "Datasource definition must be an Object, but %v was given.",
-            datasourceDef
-          );
-        }
-        if (!datasourceDef.name || typeof datasourceDef.name !== "string") {
-          throw new InvalidArgumentError(
-            'Datasource definition requires the option "name" as a non-empty String, but %v was given.',
-            datasourceDef.name
-          );
-        }
-        if (!datasourceDef.adapter || typeof datasourceDef.adapter !== "string") {
-          throw new InvalidArgumentError(
-            'Datasource %v requires the option "adapter" as a non-empty String, but %v was given.',
-            datasourceDef.name,
-            datasourceDef.adapter
-          );
-        }
-      }
-    };
-  }
-});
-
-// src/definition/datasource/index.js
-var init_datasource = __esm({
-  "src/definition/datasource/index.js"() {
-    "use strict";
-    init_datasource_definition_validator();
-  }
-});
-
 // src/definition/index.js
 var init_definition = __esm({
   "src/definition/index.js"() {
@@ -4664,7 +4655,6 @@ var init_repository_registry = __esm({
     "use strict";
     import_js_service26 = require("@e22m4u/js-service");
     init_repository();
-    init_utils();
     init_errors();
     RepositoryRegistry = class extends import_js_service26.Service {
       static {
@@ -4704,13 +4694,12 @@ var init_repository_registry = __esm({
        * @returns {Repository}
        */
       getRepository(modelName) {
-        const modelKey = modelNameToModelKey(modelName);
-        let repository = this._repositories[modelKey];
+        let repository = this._repositories[modelName];
         if (repository) {
           return repository;
         }
         repository = new this._repositoryCtor(this.container, modelName);
-        this._repositories[modelKey] = repository;
+        this._repositories[modelName] = repository;
         return repository;
       }
     };
@@ -6073,7 +6062,6 @@ __export(index_exports, {
   isPlainObject: () => isPlainObject,
   isPromise: () => isPromise,
   likeToRegexp: () => likeToRegexp,
-  modelNameToModelKey: () => modelNameToModelKey,
   selectObjectKeys: () => selectObjectKeys,
   singularize: () => singularize,
   stringToRegexp: () => stringToRegexp
@@ -6171,7 +6159,6 @@ init_repository2();
   isPlainObject,
   isPromise,
   likeToRegexp,
-  modelNameToModelKey,
   selectObjectKeys,
   singularize,
   stringToRegexp

package/package.json

@@ -1,16 +1,16 @@
 {
   "name": "@e22m4u/js-repository",
-  "version": "0.8.8",
+  "version": "0.8.9",
   "description": "Реализация репозитория для работы с базами данных",
   "author": "Mikhail Evstropov <e22m4u@yandex.ru>",
   "license": "MIT",
   "keywords": [
-    "Repository",
     "ORM",
     "ODM",
-    "Database",
-    "Datasource",
-    "Relations"
+    "database",
+    "datasource",
+    "repository",
+    "relations"
   ],
   "homepage": "https://gitverse.ru/e22m4u/js-repository",
   "repository": {

package/src/definition/definition-registry.d.ts

@@ -27,6 +27,11 @@ export declare class DefinitionRegistry extends Service {
    */
   getDatasource(name: string): DatasourceDefinition;
 
+  /**
+   * Get datasource names.
+   */
+  getDatasourceNames(): string[];
+
   /**
    * Add model.
    *
@@ -47,4 +52,9 @@ export declare class DefinitionRegistry extends Service {
    * @param name
    */
   getModel(name: string): ModelDefinition;
+
+  /**
+   * Get model names.
+   */
+  getModelNames(): string[];
 }

package/src/definition/definition-registry.js

@@ -1,8 +1,7 @@
 import {Service} from '@e22m4u/js-service';
-import {modelNameToModelKey} from '../utils/index.js';
 import {InvalidArgumentError} from '../errors/index.js';
 import {ModelDefinitionValidator} from './model/index.js';
-import {DatasourceDefinitionValidator} from '../definition/index.js';
+import {DatasourceDefinitionValidator} from './datasource/index.js';
 
 /**
  * Definition registry.
@@ -60,6 +59,15 @@ export class DefinitionRegistry extends Service {
     return datasourceDef;
   }
 
+  /**
+   * Get datasource names.
+   *
+   * @returns {string[]}
+   */
+  getDatasourceNames() {
+    return Object.keys(this._datasources);
+  }
+
   /**
    * Add model.
    *
@@ -67,14 +75,11 @@ export class DefinitionRegistry extends Service {
    */
   addModel(modelDef) {
     this.getService(ModelDefinitionValidator).validate(modelDef);
-    const modelKey = modelNameToModelKey(modelDef.name);
-    if (modelKey in this._models) {
-      throw new InvalidArgumentError(
-        'Model %v is already defined.',
-        modelDef.name,
-      );
+    const name = modelDef.name;
+    if (name in this._models) {
+      throw new InvalidArgumentError('Model %v is already defined.', name);
     }
-    this._models[modelKey] = modelDef;
+    this._models[name] = modelDef;
   }
 
   /**
@@ -84,8 +89,7 @@ export class DefinitionRegistry extends Service {
    * @returns {boolean}
    */
   hasModel(name) {
-    const modelKey = modelNameToModelKey(name);
-    return Boolean(this._models[modelKey]);
+    return Boolean(this._models[name]);
   }
 
   /**
@@ -95,11 +99,19 @@ export class DefinitionRegistry extends Service {
    * @returns {object}
    */
   getModel(name) {
-    const modelKey = modelNameToModelKey(name);
-    const modelDef = this._models[modelKey];
+    const modelDef = this._models[name];
     if (!modelDef) {
       throw new InvalidArgumentError('Model %v is not defined.', name);
     }
     return modelDef;
   }
+
+  /**
+   * Get model names.
+   *
+   * @returns {string[]}
+   */
+  getModelNames() {
+    return Object.keys(this._models);
+  }
 }

package/src/definition/definition-registry.spec.js

@@ -1,42 +1,33 @@
 import {expect} from 'chai';
-import {createSandbox} from '@e22m4u/js-spy';
+import {createSpy} from '@e22m4u/js-spy';
 import {ModelDefinitionValidator} from './model/index.js';
 import {DefinitionRegistry} from './definition-registry.js';
 import {DatasourceDefinitionValidator} from '../definition/index.js';
 
-const sandbox = createSandbox();
-
 describe('DefinitionRegistry', function () {
-  let S;
-
-  beforeEach(function () {
-    S = new DefinitionRegistry();
-  });
-
-  afterEach(function () {
-    sandbox.restore();
-  });
-
   describe('addDatasource', function () {
-    it('adds the given datasource to the registry', function () {
+    it('should add the given datasource to the registry', function () {
       const datasource = {name: 'datasource', adapter: 'adapter'};
+      const S = new DefinitionRegistry();
       S.addDatasource(datasource);
       const result = S.getDatasource('datasource');
       expect(result).to.be.eql(datasource);
     });
 
-    it('uses DatasourceDefinitionValidator to validate a given datasource', function () {
+    it('should use DatasourceDefinitionValidator to validate the given datasource', function () {
+      const S = new DefinitionRegistry();
       const V = S.getService(DatasourceDefinitionValidator);
-      sandbox.on(V, 'validate');
+      createSpy(V, 'validate');
       const datasource = {name: 'datasource', adapter: 'adapter'};
       S.addDatasource(datasource);
       expect(V.validate).to.have.been.called.once;
       expect(V.validate).to.have.been.called.with(datasource);
     });
 
-    it('throws an error if a given datasource is already defined', function () {
+    it('should throw an error when the given datasource is already defined', function () {
       const datasource1 = {name: 'datasource', adapter: 'adapter'};
       const datasource2 = {name: 'datasource', adapter: 'adapter'};
+      const S = new DefinitionRegistry();
       S.addDatasource(datasource1);
       const throwable = () => S.addDatasource(datasource2);
       expect(throwable).to.throw('Datasource "datasource" is already defined.');
@@ -44,8 +35,9 @@ describe('DefinitionRegistry', function () {
   });
 
   describe('hasDatasource', function () {
-    it('should check the datasource registration by its name', function () {
+    it('should return true when the datasource name is registered', function () {
       const datasource = {name: 'datasource', adapter: 'adapter'};
+      const S = new DefinitionRegistry();
       expect(S.hasDatasource(datasource.name)).to.be.false;
       S.addDatasource(datasource);
       expect(S.hasDatasource(datasource.name)).to.be.true;
@@ -53,39 +45,62 @@ describe('DefinitionRegistry', function () {
   });
 
   describe('getDatasource', function () {
-    it('returns the datasource by its name', function () {
+    it('should return the registered datasource for its name', function () {
       const datasource = {name: 'datasource', adapter: 'adapter'};
+      const S = new DefinitionRegistry();
       S.addDatasource(datasource);
       const result = S.getDatasource('datasource');
       expect(result).to.be.eql(datasource);
     });
 
-    it('throws an error if ths datasource is not defined', function () {
+    it('should throw an error when the datasource name is not registered', function () {
+      const S = new DefinitionRegistry();
       const throwable = () => S.getDatasource('undefined');
       expect(throwable).to.throw('Datasource "undefined" is not defined.');
     });
   });
 
+  describe('getDatasourceNames', function () {
+    it('should return an array of datasource names in the definition order', function () {
+      const datasource1 = {name: 'datasource1', adapter: 'adapter'};
+      const datasource2 = {name: 'datasource2', adapter: 'adapter'};
+      const datasource3 = {name: 'datasource3', adapter: 'adapter'};
+      const S = new DefinitionRegistry();
+      expect(S.getDatasourceNames()).to.be.eql([]);
+      S.addDatasource(datasource1);
+      S.addDatasource(datasource2);
+      S.addDatasource(datasource3);
+      expect(S.getDatasourceNames()).to.be.eql([
+        datasource1.name,
+        datasource2.name,
+        datasource3.name,
+      ]);
+    });
+  });
+
   describe('addModel', function () {
-    it('adds the given model to the registry', function () {
+    it('should add the given model to the registry', function () {
       const model = {name: 'model'};
+      const S = new DefinitionRegistry();
       S.addModel(model);
       const result = S.getModel('model');
       expect(result).to.be.eql(model);
     });
 
-    it('uses ModelDefinitionValidator to validate a given model', function () {
+    it('should use ModelDefinitionValidator to validate the given model', function () {
+      const S = new DefinitionRegistry();
       const V = S.getService(ModelDefinitionValidator);
-      sandbox.on(V, 'validate');
+      createSpy(V, 'validate');
       const model = {name: 'model'};
       S.addModel(model);
       expect(V.validate).to.have.been.called.once;
       expect(V.validate).to.have.been.called.with(model);
     });
 
-    it('throws an error if a given model is already defined', function () {
+    it('should throw an error when the model name is already registered', function () {
       const model1 = {name: 'TestModel'};
       const model2 = {name: 'TestModel'};
+      const S = new DefinitionRegistry();
       S.addModel(model1);
       const throwable = () => S.addModel(model2);
       expect(throwable).to.throw('Model "TestModel" is already defined.');
@@ -93,112 +108,46 @@ describe('DefinitionRegistry', function () {
   });
 
   describe('hasModel', function () {
-    it('should check the model registration by its name', function () {
+    it('should return true when the model name is registered', function () {
       const model = {name: 'model'};
+      const S = new DefinitionRegistry();
       expect(S.hasModel(model.name)).to.be.false;
       S.addModel(model);
       expect(S.hasModel(model.name)).to.be.true;
     });
-
-    it('should ignore naming convention of the model name', function () {
-      const model = {name: 'UserProfileDetails'};
-      const modelNames = [
-        'userProfileDetails',
-        'UserProfileDetails',
-        'user-profile-details',
-        'user_profile_details',
-        'USER-PROFILE-DETAILS',
-        'USER_PROFILE_DETAILS',
-        'USERPROFILEDETAILS',
-        'userprofiledetails',
-      ];
-      modelNames.forEach(v => expect(S.hasModel(v)).to.be.false);
-      S.addModel(model);
-      modelNames.forEach(v => expect(S.hasModel(v)).to.be.true);
-    });
-
-    it('should respect numbers in the model name', function () {
-      const model1 = {name: 'UserProfileDetails1'};
-      const modelNames1 = [
-        'userProfileDetails1',
-        'UserProfileDetails1',
-        'user-profile-details-1',
-        'user_profile_details_1',
-        'USER-PROFILE-DETAILS-1',
-        'USER_PROFILE_DETAILS_1',
-        'USERPROFILEDETAILS1',
-        'userprofiledetails1',
-      ];
-      const modelNames2 = [
-        'userProfileDetails2',
-        'UserProfileDetails2',
-        'user-profile-details-2',
-        'user_profile_details_2',
-        'USER-PROFILE-DETAILS-2',
-        'USER_PROFILE_DETAILS_2',
-        'USERPROFILEDETAILS2',
-        'userprofiledetails2',
-      ];
-      S.addModel(model1);
-      modelNames1.forEach(v => expect(S.hasModel(v)).to.be.true);
-      modelNames2.forEach(v => expect(S.hasModel(v)).to.be.false);
-    });
   });
 
   describe('getModel', function () {
-    it('returns the model by its name', function () {
+    it('should return the model definition for the model name', function () {
       const model = {name: 'model'};
+      const S = new DefinitionRegistry();
       S.addModel(model);
       const result = S.getModel('model');
       expect(result).to.be.eql(model);
     });
 
-    it('throws an error if the model is not defined', function () {
+    it('should throw an error when the model name is not registered', function () {
+      const S = new DefinitionRegistry();
       const throwable = () => S.getModel('undefined');
       expect(throwable).to.throw('Model "undefined" is not defined.');
     });
+  });
 
-    it('should ignore naming convention of the model name', function () {
-      const model = {name: 'userProfileDetails'};
-      const modelNames = [
-        'userProfileDetails',
-        'UserProfileDetails',
-        'user-profile-details',
-        'user_profile_details',
-        'USER-PROFILE-DETAILS',
-        'USER_PROFILE_DETAILS',
-        'USERPROFILEDETAILS',
-        'userprofiledetails',
-      ];
-      S.addModel(model);
-      modelNames.forEach(v => expect(S.getModel(v)).to.be.eq(model));
-    });
-
-    it('should respect numbers in the model name', function () {
-      const model1 = {name: 'userProfileDetails1'};
-      const modelNames1 = [
-        'userProfileDetails1',
-        'UserProfileDetails1',
-        'user-profile-details-1',
-        'user_profile_details_1',
-        'USER-PROFILE-DETAILS-1',
-        'USER_PROFILE_DETAILS_1',
-        'USERPROFILEDETAILS1',
-        'userprofiledetails1',
-      ];
-      const modelNames2 = [
-        'userProfileDetails2',
-        'UserProfileDetails2',
-        'user-profile-details-2',
-        'user_profile_details_2',
-        'USER-PROFILE-DETAILS-2',
-        'USER_PROFILE_DETAILS_2',
-        'USERPROFILEDETAILS2',
-        'userprofiledetails2',
-      ];
+  describe('getModelNames', function () {
+    it('should return an array of model names in the definition order', function () {
+      const model1 = {name: 'model1'};
+      const model2 = {name: 'model2'};
+      const model3 = {name: 'model3'};
+      const S = new DefinitionRegistry();
+      expect(S.getModelNames()).to.be.eql([]);
       S.addModel(model1);
-      modelNames1.forEach(v => expect(S.getModel(v)).to.be.eq(model1));
-      modelNames2.forEach(v => expect(() => S.getModel(v)).to.throw(Error));
+      S.addModel(model2);
+      S.addModel(model3);
+      expect(S.getModelNames()).to.be.eql([
+        model1.name,
+        model2.name,
+        model3.name,
+      ]);
     });
   });
 });

package/src/repository/repository-registry.js

@@ -1,6 +1,5 @@
 import {Service} from '@e22m4u/js-service';
 import {Repository} from './repository.js';
-import {modelNameToModelKey} from '../utils/index.js';
 import {InvalidArgumentError} from '../errors/index.js';
 
 /**
@@ -49,13 +48,12 @@ export class RepositoryRegistry extends Service {
    * @returns {Repository}
    */
   getRepository(modelName) {
-    const modelKey = modelNameToModelKey(modelName);
-    let repository = this._repositories[modelKey];
+    let repository = this._repositories[modelName];
     if (repository) {
       return repository;
     }
     repository = new this._repositoryCtor(this.container, modelName);
-    this._repositories[modelKey] = repository;
+    this._repositories[modelName] = repository;
     return repository;
   }
 }

package/src/repository/repository-registry.spec.js

@@ -35,25 +35,6 @@ describe('RepositoryRegistry', function () {
       expect(repA2).to.be.not.eq(repB2);
     });
 
-    it('should ignore naming convention of the model name', function () {
-      const dbs = new DatabaseSchema();
-      const modelName = 'userProfileDetails';
-      dbs.defineDatasource({name: 'datasource', adapter: 'memory'});
-      dbs.defineModel({name: modelName, datasource: 'datasource'});
-      const reg = dbs.getService(RepositoryRegistry);
-      const rep = reg.getRepository(modelName);
-      const modelNames = [
-        'UserProfileDetails',
-        'user-profile-details',
-        'user_profile_details',
-        'USER-PROFILE-DETAILS',
-        'USER_PROFILE_DETAILS',
-        'USERPROFILEDETAILS',
-        'userprofiledetails',
-      ];
-      modelNames.forEach(v => expect(reg.getRepository(v)).to.be.eq(rep));
-    });
-
     it('should respect numbers in the model name', function () {
       const dbs = new DatabaseSchema();
       dbs.defineDatasource({name: 'datasource', adapter: 'memory'});

package/src/utils/index.d.ts

@@ -9,4 +9,3 @@ export * from './string-to-regexp.js';
 export * from './get-value-by-path.js';
 export * from './select-object-keys.js';
 export * from './exclude-object-keys.js';
-export * from './model-name-to-model-key.js';

package/src/utils/index.js

@@ -9,4 +9,3 @@ export * from './string-to-regexp.js';
 export * from './get-value-by-path.js';
 export * from './select-object-keys.js';
 export * from './exclude-object-keys.js';
-export * from './model-name-to-model-key.js';

package/src/utils/model-name-to-model-key.d.ts

@@ -1,6 +0,0 @@
-/**
- * Model name to model key.
- * 
- * @param modelName
- */
-export function modelNameToModelKey(modelName: string): string;

package/src/utils/model-name-to-model-key.js

@@ -1,18 +0,0 @@
-import {InvalidArgumentError} from '../errors/index.js';
-
-/**
- * Model name to model key.
- *
- * @param {string} modelName
- * @returns {string}
- */
-export function modelNameToModelKey(modelName) {
-  if (!modelName || typeof modelName !== 'string' || /\s/.test(modelName)) {
-    throw new InvalidArgumentError(
-      'Model name must be a non-empty String ' +
-        'without spaces, but %v was given.',
-      modelName,
-    );
-  }
-  return modelName.toLowerCase().replace(/[-_]/g, '');
-}

package/src/utils/model-name-to-model-key.spec.js

@@ -1,94 +0,0 @@
-import {expect} from 'chai';
-import {modelNameToModelKey} from './model-name-to-model-key.js';
-
-describe('modelNameToModelKey', function () {
-  it('should return a simple lowercase string as is', function () {
-    expect(modelNameToModelKey('user')).to.be.eq('user');
-  });
-
-  it('should convert to lowercase and remove hyphens and underscores', function () {
-    const modelNames = [
-      'userProfileDetails',
-      'UserProfileDetails',
-      'user-profile-details',
-      'user_profile_details',
-      'User-Profile-Details',
-      'User_Profile_Details',
-      'USER-PROFILE-DETAILS',
-      'USER_PROFILE_DETAILS',
-      'USERPROFILEDETAILS',
-      'userprofiledetails',
-    ];
-    modelNames.forEach(v =>
-      expect(modelNameToModelKey(v)).to.be.eq('userprofiledetails'),
-    );
-  });
-
-  it('should handle a mixed string with uppercase, hyphens and underscores', function () {
-    const modelName = 'User_Profile-Details';
-    const expected = 'userprofiledetails';
-    expect(modelNameToModelKey(modelName)).to.be.eq(expected);
-  });
-
-  it('should not remove numbers from the string', function () {
-    const modelName = 'Type1-Model_2';
-    const expected = 'type1model2';
-    expect(modelNameToModelKey(modelName)).to.be.eq(expected);
-  });
-
-  it('should throw an error for an empty string', function () {
-    const throwable = () => modelNameToModelKey('');
-    expect(throwable).to.throw(
-      'Model name must be a non-empty String ' +
-        'without spaces, but "" was given.',
-    );
-  });
-
-  it('should throw an error for a string with spaces', function () {
-    const throwable = () => modelNameToModelKey('user profile');
-    expect(throwable).to.throw(
-      'Model name must be a non-empty String ' +
-        'without spaces, but "user profile" was given.',
-    );
-  });
-
-  it('should throw an error for null', function () {
-    const throwable = () => modelNameToModelKey(null);
-    expect(throwable).to.throw(
-      'Model name must be a non-empty String ' +
-        'without spaces, but null was given.',
-    );
-  });
-
-  it('should throw an error for undefined', function () {
-    const throwable = () => modelNameToModelKey(undefined);
-    expect(throwable).to.throw(
-      'Model name must be a non-empty String ' +
-        'without spaces, but undefined was given.',
-    );
-  });
-
-  it('should throw an error for a number', function () {
-    const throwable = () => modelNameToModelKey(123);
-    expect(throwable).to.throw(
-      'Model name must be a non-empty String ' +
-        'without spaces, but 123 was given.',
-    );
-  });
-
-  it('should throw an error for an object', function () {
-    const throwable = () => modelNameToModelKey({name: 'test'});
-    expect(throwable).to.throw(
-      'Model name must be a non-empty String ' +
-        'without spaces, but Object was given.',
-    );
-  });
-
-  it('should throw an error for an array', function () {
-    const throwable = () => modelNameToModelKey(['test']);
-    expect(throwable).to.throw(
-      'Model name must be a non-empty String ' +
-        'without spaces, but Array was given.',
-    );
-  });
-});