@e22m4u/js-repository 0.8.8 → 0.8.10

package/README.md

@@ -3,18 +3,21 @@
 ![npm version](https://badge.fury.io/js/@e22m4u%2Fjs-repository.svg)
 ![license](https://img.shields.io/badge/license-mit-blue.svg)
 
-Реализация паттерна «Репозиторий» для работы с базами данных.
+ORM/ODM библиотека для Node.js, реализующая слой управления данными на основе
+паттерна «Репозиторий». Унифицирует интерфейс различных баз данных, фильтрацию
+и работу со связанными документами независимо от источника.
 
 ## Содержание
 
 - [Установка](#установка)
 - [Импорт](#импорт)
 - [Описание](#описание)
-- [Пример](#пример)
+  - [Терминология](#терминология)
+- [Базовый пример](#пример)
 - [Схема баз данных](#схема-баз-данных)
 - [Источник данных](#источник-данных)
 - [Модель](#модель)
-- [Свойства](#свойства)
+  - [Свойства](#свойства)
 - [Репозиторий](#репозиторий)
   - [create](#repositorycreate)
   - [replaceById](#repositoryreplacebyid)
@@ -50,10 +53,15 @@ npm install @e22m4u/js-repository
 
 Опционально устанавливается нужный адаптер.
 
-| адаптер   | описание                                        | установка                                                                  |
-|-----------|-------------------------------------------------|----------------------------------------------------------------------------|
-| `memory`  | Виртуальная база в памяти процесса              | *встроенный*                                                               |
-| `mongodb` | MongoDB - документо-ориентированная база данных | [npm](https://www.npmjs.com/package/@e22m4u/js-repository-mongodb-adapter) |
+| адаптер   | описание                                          |                                                                                    |
+|-----------|---------------------------------------------------|------------------------------------------------------------------------------------|
+| `memory`  | Виртуальная база данных в памяти процесса Node.js | *встроенный*                                                                       |
+| `mongodb` | MongoDB - документо-ориентированная база данных   | [*установка*](https://www.npmjs.com/package/@e22m4u/js-repository-mongodb-adapter) |
+
+**Утилиты**
+
+- [@e22m4u/js-repository-json-schema](https://www.npmjs.com/package/@e22m4u/js-repository-json-schema)  
+  *Генератор JSON Schema для моделей репозитория*
 
 ## Импорт
 
@@ -122,11 +130,49 @@ flowchart TD
   G-->K
 ```
 
+### Терминология
+
+Описание ключевых понятий.
+
+- **Схема баз данных** (*DatabaseSchema*) - хранит определения источников
+данных и моделей. Связывает модели с источниками данных и предоставляет
+доступ к экземплярам репозитория.
+
+- **Источник данных** (*Datasource*) - именованная конфигурация подключения
+к базе данных. Содержит название используемого адаптера и параметры соединения.
+
+- **Адаптер** (*Adapter*) - низкоуровневая реализация для взаимодействия с
+конкретной СУБД. Обеспечивает совместимость хранилища с унифицированным
+интерфейсом репозитория.
+
+- **Коллекция** (*Collection*) - физическая область хранения записей или
+документов в базе данных, ассоциированная с конкретной моделью. В контексте
+реляционных баз данных является эквивалентом таблицы.
+
+- **Модель** (*Model*) - структурное описание коллекции базы данных. Содержит
+определения свойств документа и отношений с другими моделями.
+
+- **Свойство** (*Property*) - описание отдельного поля модели. Определяет тип
+данных, значение по умолчанию, обязательность наличия и правила проверки
+на уникальность.
+
+- **Связь** (*Relation*) - абстракция отношений между моделями. Поддерживает
+классические отношения и полиморфный режим динамического определения
+целевой модели через поле дискриминатора.
+
+- **Дискриминатор** (*Discriminator*) - свойство документа в рамках полиморфной
+связи. Хранит строковое название целевой модели, что позволяет динамически
+определять связанную коллекцию при выполнении запросов.
+
+- **Репозиторий** (*Repository*) - абстрактный фасад для работы с данными
+конкретной модели. Изолирует логику приложения от деталей реализации
+базы данных. Выполняет операции записи, поиска, обновления и удаления.
+
 ## Пример
 
-Пример демонстрирует создание экземпляра схемы, объявление источника данных
-и модели `country`. После чего, с помощью репозитория данной модели, в коллекцию
-добавляется новый документ (страна), который выводится в консоль.
+Пример демонстрирует создание экземпляра `DatabaseSchema`, объявление источника
+данных `myDb` и модели `country`. Далее в коллекцию добавляется новый документ,
+содержимого которого выводится в консоль.
 
 ```
    Страна (country)
@@ -351,8 +397,8 @@ dbs.defineDatasource({
 - `base: string` название наследуемой модели;
 - `tableName: string` название коллекции в базе;
 - `datasource: string` выбранный источник данных;
-- `properties: object` определения свойств (см. [Свойства](#Свойства));
-- `relations: object` определения связей (см. [Связи](#Связи));
+- `properties: object` определения свойств (см. [Свойства](#свойства));
+- `relations: object` определения связей (см. [Связи](#связи));
 
 **Примеры**
 
@@ -368,13 +414,32 @@ dbs.defineModel({
 });
 ```
 
-## Свойства
+### Свойства
 
 Параметр `properties` находится в определении модели и принимает объект, ключи
 которого являются свойствами этой модели, а значением тип свойства или объект
-с дополнительными параметрами.
+с дополнительными параметрами. Параметры свойства используется репозиторием
+для проверки документов перед сохранением.
 
-**Тип данных**
+```js
+dbs.defineModel({
+  name: 'user',
+  properties: {
+    // краткая форма (только тип)
+    name: DataType.STRING,
+    // расширенное определение (см. далее)
+    email: {
+      type: DataType.STRING,
+      unique: PropertyUniqueness.SPARSE,
+      default: '',
+    },
+  },
+});
+```
+
+*i. В контексте реляционных баз данных свойства отражают колонки таблицы.*
+
+**Типы данных**
 
 - `DataType.ANY` разрешено любое значение;
 - `DataType.STRING` только значение типа `string`;
@@ -383,7 +448,12 @@ dbs.defineModel({
 - `DataType.ARRAY` только значение типа `array`;
 - `DataType.OBJECT` только значение типа `object`;
 
-**Параметры**
+**Параметры свойства**
+
+Объект с параметрами (расширенное определение) позволяет задавать значения
+по умолчанию, правила проверки на уникальность и обязательность наличия данных.
+Для массивов и вложенных объектов предусмотрено указание типа элемента
+и название модели.
 
 - `type: string` тип допустимого значения (обязательно);
 - `itemType?: string` тип элемента массива (для `type: 'array'`);

package/dist/cjs/index.cjs

@@ -9,8 +9,13 @@ var __glob = (map) => (path) => {
   if (fn) return fn();
   throw new Error("Module not found in bundle: " + path);
 };
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
 };
 var __export = (target, all) => {
   for (var name in all)
@@ -419,24 +424,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 +439,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 +1819,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 +1928,14 @@ var init_definition_registry = __esm({
         }
         return datasourceDef;
       }
+      /**
+       * Get datasource names.
+       *
+       * @returns {string[]}
+       */
+      getDatasourceNames() {
+        return Object.keys(this._datasources);
+      }
       /**
        * Add model.
        *
@@ -1901,14 +1943,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 +1956,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 +1965,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 +2428,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 +2501,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 +2633,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 +2688,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 +2953,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 +2993,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 +3088,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 +4660,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 +4699,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 +6067,6 @@ __export(index_exports, {
   isPlainObject: () => isPlainObject,
   isPromise: () => isPromise,
   likeToRegexp: () => likeToRegexp,
-  modelNameToModelKey: () => modelNameToModelKey,
   selectObjectKeys: () => selectObjectKeys,
   singularize: () => singularize,
   stringToRegexp: () => stringToRegexp
@@ -6171,7 +6164,6 @@ init_repository2();
   isPlainObject,
   isPromise,
   likeToRegexp,
-  modelNameToModelKey,
   selectObjectKeys,
   singularize,
   stringToRegexp

package/eslint.config.js

@@ -2,7 +2,6 @@ import globals from 'globals';
 import eslintJs from '@eslint/js';
 import eslintJsdocPlugin from 'eslint-plugin-jsdoc';
 import eslintMochaPlugin from 'eslint-plugin-mocha';
-import eslintImportPlugin from 'eslint-plugin-import';
 import eslintPrettierConfig from 'eslint-config-prettier';
 import eslintChaiExpectPlugin from 'eslint-plugin-chai-expect';
 
@@ -18,19 +17,16 @@ export default [{
   plugins: {
     'jsdoc': eslintJsdocPlugin,
     'mocha': eslintMochaPlugin,
-    'import': eslintImportPlugin,
     'chai-expect': eslintChaiExpectPlugin,
   },
   rules: {
     ...eslintJs.configs.recommended.rules,
     ...eslintPrettierConfig.rules,
-    ...eslintImportPlugin.flatConfigs.recommended.rules,
     ...eslintMochaPlugin.configs.recommended.rules,
     ...eslintChaiExpectPlugin.configs['recommended-flat'].rules,
     ...eslintJsdocPlugin.configs['flat/recommended-error'].rules,
     'curly': 'error',
     'no-duplicate-imports': 'error',
-    'import/export': 0,
     'jsdoc/reject-any-type': 0,
     'jsdoc/reject-function-type': 0,
     'jsdoc/require-param-description': 0,

package/package.json

@@ -1,21 +1,22 @@
 {
   "name": "@e22m4u/js-repository",
-  "version": "0.8.8",
-  "description": "Реализация репозитория для работы с базами данных",
+  "version": "0.8.10",
+  "description": "ORM/ODM библиотека для работы с базами данных",
   "author": "Mikhail Evstropov <e22m4u@yandex.ru>",
   "license": "MIT",
   "keywords": [
-    "Repository",
-    "ORM",
-    "ODM",
-    "Database",
-    "Datasource",
-    "Relations"
+    "js-repository",
+    "orm",
+    "odm",
+    "database",
+    "datasource",
+    "repository",
+    "relations"
   ],
-  "homepage": "https://gitverse.ru/e22m4u/js-repository",
+  "homepage": "https://github.com/e22m4u/js-repository",
   "repository": {
     "type": "git",
-    "url": "git+https://gitverse.ru/e22m4u/js-repository.git"
+    "url": "git+https://github.com/e22m4u/js-repository.git"
   },
   "type": "module",
   "types": "./src/index.d.ts",
@@ -43,27 +44,26 @@
     "@e22m4u/js-service": "~0.6.2"
   },
   "devDependencies": {
-    "@commitlint/cli": "~20.5.0",
-    "@commitlint/config-conventional": "~20.5.0",
+    "@commitlint/cli": "~21.2.1",
+    "@commitlint/config-conventional": "~21.2.0",
     "@e22m4u/js-spy": "~0.3.6",
-    "@eslint/js": "~9.39.2",
+    "@eslint/js": "~10.0.1",
     "@types/chai": "~5.2.3",
     "@types/chai-as-promised": "~8.0.2",
     "@types/mocha": "~10.0.10",
-    "c8": "~11.0.0",
+    "c8": "~12.0.0",
     "chai": "~6.2.2",
     "chai-as-promised": "~8.0.2",
-    "esbuild": "~0.27.4",
-    "eslint": "~9.39.2",
+    "esbuild": "~0.28.1",
+    "eslint": "~10.7.0",
     "eslint-config-prettier": "~10.1.8",
-    "eslint-plugin-chai-expect": "~4.0.0",
-    "eslint-plugin-import": "~2.32.0",
-    "eslint-plugin-jsdoc": "~62.8.0",
-    "eslint-plugin-mocha": "~11.2.0",
+    "eslint-plugin-chai-expect": "~4.1.0",
+    "eslint-plugin-jsdoc": "~63.2.0",
+    "eslint-plugin-mocha": "~11.3.0",
     "husky": "~9.1.7",
-    "mocha": "~11.7.5",
-    "prettier": "~3.8.1",
+    "mocha": "~11.7.6",
+    "prettier": "~3.9.6",
     "rimraf": "~6.1.3",
-    "typescript": "~5.9.3"
+    "typescript": "~7.0.2"
   }
 }

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.',
-    );
-  });
-});