@reldens/storage 0.76.0 → 0.78.0

package/CLAUDE.md

@@ -0,0 +1,278 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Package Overview
+
+**@reldens/storage** is the database abstraction layer for Reldens. It provides:
+- Multi-ORM support (objection-js, mikro-orm, prisma)
+- Entity/model generation from database schemas
+- Unified API across different ORM drivers
+- Database connection management
+- Schema introspection and code generation
+- Type mapping between database and JavaScript types
+
+## Key Commands
+
+```bash
+# Generate entities from database
+npx reldens-storage generateEntities --user=<user> --pass=<pass> --host=<host> --database=<db> --driver=<driver> --client=<client>
+
+# Generate entities with override (overwrites existing entities)
+npx reldens-storage generateEntities --user=<user> --pass=<pass> --database=<db> --driver=<driver> --override
+
+# Generate Prisma schema
+npx reldens-storage-prisma --host=<host> --port=<port> --database=<db> --user=<user> --password=<pass>
+
+# Generate Prisma schema with database parameters
+npx reldens-storage-prisma --host=<host> --database=<db> --user=<user> --password=<pass> --dbParams="authPlugin=mysql_native_password"
+
+# Alternative: Use environment variable for database parameters
+export RELDENS_DB_PARAMS="authPlugin=mysql_native_password&sslmode=require"
+npx reldens-storage-prisma --host=<host> --database=<db> --user=<user> --password=<pass>
+```
+
+## Architecture
+
+### Core Classes
+
+**EntitiesGenerator** (`lib/entities-generator.js`):
+- Main orchestrator for entity generation
+- Coordinates all generation steps
+- Detects existing entities and models
+- Determines what needs to be generated or updated
+- Key methods:
+  - `generate()`: Main entry point for generation
+  - `detectExistingEntities()`: Scans for existing entity files
+  - `detectExistingModels()`: Scans for existing model files
+  - `filterTablesToGenerate()`: Determines what needs generation
+  - `entityNeedsUpdate()`: Checks if entity fields changed
+  - `extractPrismaRelationsMetadata()`: Extracts Prisma relation info
+
+**BaseDriver** (`lib/base-driver.js`):
+- Abstract base class for ORM drivers
+- Provides common interface for all database operations
+- Key methods (all must be implemented by drivers):
+  - CRUD: `create()`, `update()`, `delete()`, `upsert()`
+  - Read: `load()`, `loadById()`, `loadAll()`, `loadOne()`
+  - Relations: `loadWithRelations()`, `createWithRelations()`
+  - Count: `count()`, `countWithRelations()`
+  - Query: `rawQuery()`, `executeCustomQuery()`
+  - Helpers: `parseRelationsString()`, `isJsonField()`
+
+**BaseDataServer** (`lib/base-data-server.js`):
+- Abstract base class for data servers
+- Manages database connection and entity management
+- Uses EntityManager for entity registry
+- Key methods:
+  - `connect()`: Establishes database connection
+  - `generateEntities()`: Generates entities from raw models
+  - `fetchEntitiesFromDatabase()`: Introspects database schema
+  - `getEntity()`: Retrieves entity by name
+  - `createConnectionString()`: Builds connection string
+
+**EntityManager** (`lib/entity-manager.js`):
+- Registry for managing entities
+- Simple key-value store for entity instances
+- Methods: `get()`, `add()`, `remove()`, `clear()`, `setEntities()`
+
+**TypeMapper** (`lib/type-mapper.js`):
+- Maps database types to JavaScript and Prisma types
+- Handles MySQL types: int, varchar, text, json, datetime, enum, blob, etc.
+- Methods:
+  - `mapDbTypeToJsType()`: Returns JS type (number, string, Date, object, Buffer, boolean)
+  - `mapDbTypeToPrismaType()`: Returns Prisma type (Int, String, DateTime, Json, Bytes, Boolean)
+
+### Driver Implementations
+
+**ObjectionJS Driver** (`lib/objection-js/`):
+- `objection-js-driver.js`: Query builder using Objection.js API
+- `objection-js-data-server.js`: Data server using Knex for connection
+- Features:
+  - Complex relation support via `relationMappings`
+  - Uses `withGraphFetched()` for eager loading
+  - Supports relation modifiers (orderBy, limit)
+  - JSON field handling with `castText()` for LIKE queries
+  - Filter operators: OR, IN, NOT, LIKE
+  - Methods: `appendFilters()`, `appendRelationsToQuery()`
+
+**MikroORM Driver** (`lib/mikro-orm/`):
+- `mikro-orm-driver.js`: Driver implementation
+- `mikro-orm-data-server.js`: Data server for MongoDB/SQL
+- Features:
+  - MongoDB support
+  - Entity metadata decorators
+  - Automatic schema synchronization
+
+**Prisma Driver** (`lib/prisma/`):
+- `prisma-driver.js`: Driver implementation
+- `prisma-data-server.js`: Data server using Prisma Client
+- `prisma-schema-generator.js`: Schema generation and introspection
+- Features:
+  - Schema-first approach
+  - Type-safe queries
+  - Introspection via `prisma db pull`
+  - Binary targets configuration
+  - Data proxy support
+  - Windows permission error handling
+
+### Generators
+
+**EntitiesGeneration** (`lib/generators/entities-generation.js`):
+- Generates entity definition files
+- Determines title property (label, title, name, key)
+- Detects primary keys and auto-increment fields
+- Handles ENUM values with formatted labels
+- Generates property configurations with types
+- Creates list/show/edit property arrays
+- Methods:
+  - `generateEntityFile()`: Creates entity file
+  - `generatePropertiesConfig()`: Builds properties object
+  - `determineTitleProperty()`: Finds display field
+  - `getPropertyAttributes()`: Builds property metadata
+  - `parseEnumValues()`: Extracts ENUM options
+
+**ModelsGeneration** (`lib/generators/models-generation.js`):
+- Generates ORM-specific model files
+- Creates relation mappings for ObjectionJS
+- Generates relation types for Prisma
+- Handles forward and reverse relations
+- Creates registered models file
+- Relation key naming:
+  - Single reference: `related_[table]`
+  - Multiple references: `related_[table]_[column_suffix]`
+- Methods:
+  - `generateModelFile()`: Creates model file
+  - `generateObjectionJsRelations()`: Builds relationMappings
+  - `generatePrismaRelations()`: Builds relationTypes
+  - `detectObjectionJsRelations()`: Finds forward relations
+  - `detectReverseObjectionJsRelations()`: Finds reverse relations
+  - `generateRegisteredModelsFile()`: Creates model registry
+  - `countReferencesPerTable()`: Determines relation naming
+
+**EntitiesConfigGeneration** (`lib/generators/entities-config-generation.js`):
+- Generates `entities-config.js` file
+- Contains entity-to-entity relation mappings
+- Used by entity loader to resolve relations
+
+**EntitiesTranslationsGeneration** (`lib/generators/entities-translations-generation.js`):
+- Generates `entities-translations.js` file
+- Creates i18n translation keys for entities
+
+**BaseGenerator** (`lib/generators/base-generator.js`):
+- Base class for all generators
+- Provides `applyReplacements()` method for template processing
+
+### Database Introspection
+
+**MySQLTablesProvider** (`lib/mysql-tables-provider.js`):
+- Queries `information_schema` for table structure
+- Fetches columns with types, constraints, defaults
+- Retrieves foreign key relationships
+- Returns structured table data with:
+  - Table name
+  - Columns with type, length, nullable, key, extra, default
+  - Referenced tables and columns for foreign keys
+- Used by ObjectionJS and Prisma drivers
+
+### Entity Templates
+
+Located in `lib/entity-templates/`:
+- `entity.template`: Base entity class template
+- `objection-js-model.template`: ObjectionJS model template
+- `mikro-orm-model.template`: MikroORM model template
+- `prisma-model.template`: Prisma model template
+- `entities-config.template`: Entities configuration template
+- `entities-translations.template`: Translations template
+- `registered-models.template`: Model registry template
+
+Templates use placeholder replacement with `{{placeholderName}}` syntax.
+
+## Workflow
+
+1. **Database Connection**: Connect to database using appropriate driver
+2. **Schema Introspection**: Read database schema (tables, columns, foreign keys)
+3. **Entity Detection**: Scan for existing entities and models
+4. **Change Detection**: Compare database schema with existing entities
+5. **Entity Generation**:
+   - Generate entity files with property definitions
+   - Generate model files with ORM-specific code
+   - Generate relation mappings
+6. **Configuration**:
+   - Update `entities-config.js` with new/updated entities
+   - Update `entities-translations.js` with translation keys
+   - Generate `registered-models-[driver].js` with model imports
+7. **File Output**: Write all files to `generated-entities/` directory
+
+## Generated File Structure
+
+```
+generated-entities/
+├── entities/
+│   ├── [table-name]-entity.js      # Entity definitions
+│   └── ...
+├── models/
+│   ├── objection-js/
+│   │   ├── [table-name]-model.js
+│   │   └── registered-models-objection-js.js
+│   ├── mikro-orm/
+│   │   ├── [table-name]-model.js
+│   │   └── registered-models-mikro-orm.js
+│   └── prisma/
+│       ├── [table-name]-model.js
+│       └── registered-models-prisma.js
+├── entities-config.js               # Entity relation configuration
+└── entities-translations.js         # Translation keys
+```
+
+## Relation Keys Pattern
+
+All generated entity relations follow the `related_*` prefix pattern:
+
+- **Single reference**: `related_[table_name]`
+  - Example: `related_players`, `related_users`
+- **Multiple references to same table**: `related_[table_name]_[column_suffix]`
+  - Example: `related_skills_skill`, `related_skills_owner`
+  - The `_id` suffix is removed from column name when multiple references exist
+
+This pattern is consistent across all ORM drivers and is defined in `entities-config.js`.
+
+## Important Notes
+
+### Entity Management
+- **DO NOT modify** generated entities directly (files in `generated-entities/`)
+- Extend generated entities in custom model files if customization needed
+- Custom models should be placed in project-specific directories
+- Entity configuration (`entities-config.js`) defines relation keys used throughout codebase
+- Relation keys are critical - changing them affects all code referencing relations
+
+### Generation Behavior
+- Generation is smart: only creates/updates entities that changed
+- Detects new tables, field changes, missing configs, missing models
+- Use `--override` flag to force regeneration of all files
+- Override flag useful after major schema changes or driver switches
+- Each driver has its own model structure and relation syntax
+
+### Schema Changes
+- Always regenerate entities after database schema changes
+- Adding columns: entities auto-update with new fields
+- Removing columns: entities auto-update, remove fields
+- Changing relations: models regenerate with new relation mappings
+- ENUM changes: entity updates with new available values
+
+### Driver-Specific Notes
+- **ObjectionJS**: Recommended driver, mature and stable
+- **MikroORM**: Use for MongoDB or NoSQL requirements
+- **Prisma**: Requires schema generation first, then entity generation
+- Cannot mix drivers - regenerate all when switching drivers
+- Each driver has different relation syntax in generated models
+
+### Binary Executables
+- `bin/reldens-storage.js`: Main CLI for entity generation
+- `bin/generate-prisma-schema.js`: Prisma schema generator CLI
+- Both are available via npx after package installation
+
+### Environment Variables
+- `RELDENS_DB_PARAMS`: Database connection parameters (used by Prisma)
+- Format: `key1=value1&key2=value2`
+- Example: `authPlugin=mysql_native_password&sslmode=require`

package/README.md

@@ -10,54 +10,78 @@ It ensures consistent data access methods across different database types and OR
 
 ### ORM Support
 - **Objection JS** (via Knex) - For SQL databases (recommended)
+  - MySQL, MariaDB, PostgreSQL support
+  - Complex relation mappings
+  - Query builder with filtering and sorting
 - **Mikro-ORM** - For MongoDB/NoSQL support
+  - MongoDB native support
+  - Entity metadata decorators
+  - Automatic schema synchronization
 - **Prisma** - Modern database toolkit
+  - Type-safe queries
+  - Schema-first approach
+  - Introspection and migration tools
 
 ### Entity Management
-- Standardized CRUD operations
+- Standardized CRUD operations across all drivers
 - Automatic entity generation from database schemas
-- Type mapping between database and JavaScript
-- Foreign key relationship handling
+- Type mapping between database and JavaScript/Prisma types
+- Foreign key relationship handling with smart naming
 - ENUM field support with formatted values
+- JSON field support with type casting
+- Relation modifiers (orderBy, limit) for complex queries
 
 ### CLI Tools
-Generate entity files directly from your database structure:
+
+**Generate entity files directly from your database structure:**
 ```bash
 npx reldens-storage generateEntities --user=[dbuser] --pass=[dbpass] --database=[dbname] --driver=[objection-js]
 ```
 
-Options:
-- `--user=[username]` - Database username
-- `--pass=[password]` - Database password
+**Entity Generation Options:**
+- `--user=[username]` - Database username (required)
+- `--pass=[password]` - Database password (required)
+- `--database=[name]` - Database name (required)
+- `--driver=[driver]` - ORM driver: objection-js, mikro-orm, or prisma (default: objection-js)
+- `--client=[client]` - Database client: mysql, mysql2, or mongodb (default: mysql2)
 - `--host=[host]` - Database host (default: localhost)
 - `--port=[port]` - Database port (default: 3306)
-- `--database=[name]` - Database name
-- `--driver=[driver]` - ORM driver (objection-js|mikro-orm|prisma)
-- `--client=[client]` - Database client (mysql|mysql2|mongodb)
-- `--path=[path]` - Project path for output files
+- `--path=[path]` - Project path for output files (default: current directory)
 - `--override` - Regenerate all files even if they exist
 
-Generate Prisma schema:
+**Smart Generation:**
+- Only generates/updates entities that have changed
+- Detects new tables, field changes, missing configurations
+- Preserves custom code outside generated files
+- Use `--override` to force complete regeneration
+
+**Generate Prisma schema:**
 ```bash
-npx reldens-generate-prisma-schema --host=[host] --port=[port] --user=[dbuser] --password=[dbpass] --database=[dbname]
+npx reldens-storage-prisma --host=[host] --port=[port] --user=[dbuser] --password=[dbpass] --database=[dbname]
 ```
 
-Options:
+**Prisma Schema Generation Options:**
 - `--host=[host]` - Database host (required)
 - `--port=[port]` - Database port (required)
 - `--user=[username]` - Database username (required)
 - `--password=[password]` - Database password (required)
 - `--database=[name]` - Database name (required)
-- `--client=[client]` - Database client (default: mysql)
+- `--client=[client]` - Database client: mysql, postgresql (default: mysql)
 - `--debug` - Enable debug mode
-- `--dataProxy` - Enable data proxy
-- `--checkInterval=[ms]` - Check interval in milliseconds (default: 1000)
-- `--maxWaitTime=[ms]` - Max wait time in milliseconds (default: 30000)
-- `--prismaSchemaPath=[path]` - Path to Prisma schema directory
-- `--clientOutputPath=[path]` - Client output path (if not set, uses Prisma default)
+- `--dataProxy` - Enable Prisma data proxy
+- `--checkInterval=[ms]` - Schema generation check interval (default: 1000)
+- `--maxWaitTime=[ms]` - Maximum wait time for generation (default: 30000)
+- `--prismaSchemaPath=[path]` - Path to Prisma schema directory (default: ./prisma)
+- `--clientOutputPath=[path]` - Client output path (default: Prisma default)
 - `--generateBinaryTargets=[targets]` - Comma-separated binary targets (default: native,debian-openssl-1.1.x)
 - `--dbParams=[params]` - Database connection parameters (e.g., authPlugin=mysql_native_password)
 
+**Prisma Workflow:**
+1. Generate schema: `npx reldens-storage-prisma --host=... --database=...`
+2. Schema file created at: `prisma/schema.prisma`
+3. Prisma client generated automatically
+4. Generate entities: `npx reldens-storage generateEntities --driver=prisma ...`
+
 ### Environment Variables
 
 You can set database connection parameters using environment variables:
@@ -162,18 +186,130 @@ Note: The PrismaDataServer requires the Prisma schema to be generated first. Mak
 
 You can create custom storage drivers by extending the base classes:
 
-1. Extend `BaseDataServer` and `BaseDriver`
-2. Implement all required methods
-3. Pass your custom server instance to Reldens ServerManager:
+### Creating a Custom Driver
+
+1. **Extend `BaseDataServer`** for connection management:
+```javascript
+const { BaseDataServer } = require('@reldens/storage');
+
+class CustomDataServer extends BaseDataServer {
+    async connect() {
+        // Implement connection logic
+    }
+
+    async fetchEntitiesFromDatabase() {
+        // Implement schema introspection
+    }
+
+    generateEntities() {
+        // Generate entities from raw models
+    }
+}
+```
+
+2. **Extend `BaseDriver`** for query operations:
+```javascript
+const { BaseDriver } = require('@reldens/storage');
+
+class CustomDriver extends BaseDriver {
+    // Implement all required methods:
+    // create(), update(), delete(), load(), loadById(), etc.
+}
+```
 
+3. **Use your custom driver** in your application:
 ```javascript
 const { ServerManager } = require('@reldens/server');
-const YourCustomDriver = require('./your-custom-driver');
+const CustomDataServer = require('./custom-data-server');
 
-const customDriver = new YourCustomDriver(options);
+const customDriver = new CustomDataServer(options);
 const appServer = new ServerManager(serverConfig, eventsManager, customDriver);
 ```
 
+### Required Methods
+
+All drivers must implement the methods defined in `BaseDriver`:
+- **CRUD**: `create()`, `update()`, `delete()`, `upsert()`
+- **Read**: `load()`, `loadById()`, `loadAll()`, `loadOne()`
+- **Relations**: `loadWithRelations()`, `createWithRelations()`
+- **Count**: `count()`, `countWithRelations()`
+- **Helpers**: `tableName()`, `databaseName()`, `property()`
+
+## Generated File Structure
+
+When you run entity generation, files are created in the `generated-entities/` directory:
+
+```
+generated-entities/
+├── entities/
+│   ├── users-entity.js           # Entity definitions with properties
+│   ├── players-entity.js
+│   └── ...
+├── models/
+│   ├── objection-js/
+│   │   ├── users-model.js        # ObjectionJS models with relationMappings
+│   │   ├── players-model.js
+│   │   └── registered-models-objection-js.js
+│   ├── mikro-orm/
+│   │   ├── users-model.js        # MikroORM models
+│   │   └── registered-models-mikro-orm.js
+│   └── prisma/
+│       ├── users-model.js        # Prisma models with relationTypes
+│       └── registered-models-prisma.js
+├── entities-config.js            # Entity configuration and relations
+└── entities-translations.js      # i18n translation keys
+```
+
+### Entity Files
+- **Entity classes**: Define properties, types, validations
+- **Property metadata**: Type, required, reference, availableValues (for ENUMs)
+- **Display properties**: Separate arrays for list, show, edit views
+
+### Model Files
+- **Driver-specific**: Each driver has its own model syntax
+- **Relations**: Automatically generated based on foreign keys
+- **Registered models**: Central registry for all models
+
+### Relation Naming Pattern
+
+All relations use the `related_*` prefix:
+- **Single reference**: `related_users`, `related_players`
+- **Multiple references**: `related_skills_skill`, `related_skills_owner`
+
+Example usage:
+```javascript
+// Load user with related player
+const user = await dataServer.getEntity('users')
+    .loadByIdWithRelations(userId, ['related_player']);
+
+// Access nested relations
+const player = await dataServer.getEntity('players')
+    .loadByIdWithRelations(playerId, ['related_state', 'related_scenes']);
+```
+
+## Architecture Overview
+
+### Core Components
+
+- **EntitiesGenerator**: Orchestrates entity generation
+- **BaseDriver**: Abstract interface for database operations
+- **BaseDataServer**: Connection and entity management
+- **EntityManager**: Entity registry
+- **TypeMapper**: Database type to JavaScript/Prisma type conversion
+
+### Generators
+
+- **EntitiesGeneration**: Creates entity definition files
+- **ModelsGeneration**: Creates ORM-specific models
+- **EntitiesConfigGeneration**: Creates configuration file
+- **EntitiesTranslationsGeneration**: Creates translation keys
+
+### Database Support
+
+- **MySQL/MariaDB**: Via ObjectionJS or Prisma
+- **PostgreSQL**: Via Prisma
+- **MongoDB**: Via MikroORM
+
 ## Links
 - [Reldens Website](https://www.reldens.com/)
 - [GitHub Repository](https://github.com/damian-pastorini/reldens/tree/master)

package/lib/base-data-server.js

@@ -66,6 +66,11 @@ class BaseDataServer
         ErrorManager.error('BaseDriver connect() not implemented.');
     }
 
+    async disconnect()
+    {
+        ErrorManager.error('BaseDriver disconnect() not implemented.');
+    }
+
     async fetchEntitiesFromDatabase()
     {
         ErrorManager.error('BaseDriver fetchEntitiesFromDatabase() not implemented.');

package/lib/generators/entities-generation.js

@@ -36,10 +36,14 @@ class EntitiesGeneration extends BaseGenerator
         for(let columnName of Object.keys(tableData.columns)){
             tableData.columns[columnName].tableName = tableName;
         }
-        let propertiesConfig = this.generatePropertiesConfig(tableData.columns, titleProperty);
+        let primaryKeyColumn = this.detectPrimaryKeyColumn(tableData.columns);
+        let propertiesConfig = this.generatePropertiesConfig(tableData.columns, titleProperty, primaryKeyColumn);
         let titlePropertyDeclaration = titleProperty ? '\n        let titleProperty = \''+titleProperty+'\';' : '';
         let titlePropertyReturn = titleProperty ? '\n            titleProperty,' : '';
-        let fieldsToRemoveFromEdit = ['id'];
+        let fieldsToRemoveFromEdit = [];
+        if(primaryKeyColumn){
+            fieldsToRemoveFromEdit.push(primaryKeyColumn);
+        }
         if(tableData.columns['created_at']){
             fieldsToRemoveFromEdit.push('created_at');
         }
@@ -80,6 +84,17 @@ class EntitiesGeneration extends BaseGenerator
         return true;
     }
 
+    detectPrimaryKeyColumn(columns)
+    {
+        for(let columnName of Object.keys(columns)){
+            let column = columns[columnName];
+            if('PRI' === column.key){
+                return columnName;
+            }
+        }
+        return false;
+    }
+
     getFieldsToRemoveFromList(columns)
     {
         let fieldsToRemove = [];
@@ -98,6 +113,9 @@ class EntitiesGeneration extends BaseGenerator
 
     getEditPropertiesRemoval(fieldsToRemove)
     {
+        if(0 === fieldsToRemove.length){
+            return 'let editProperties = propertiesKeys;';
+        }
         if(1 === fieldsToRemove.length){
             return 'let editProperties = [...propertiesKeys];\n        editProperties.splice(editProperties.indexOf(\''+
                 fieldsToRemove[0]
@@ -123,15 +141,17 @@ class EntitiesGeneration extends BaseGenerator
         return false;
     }
 
-    generatePropertiesConfig(columns, titleProperty)
+    generatePropertiesConfig(columns, titleProperty, primaryKeyColumn)
     {
         let propertiesConfig = [];
         for(let columnName of Object.keys(columns)){
             let column = columns[columnName];
             let propertyKey = titleProperty && titleProperty === columnName ? '[titleProperty]' : columnName;
-            if('id' === columnName){
-                let idType = column.type.toLowerCase();
-                propertiesConfig.push(columnName+': {\n                dbType: \''+idType+'\'\n            }');
+            let isPrimaryKey = primaryKeyColumn && primaryKeyColumn === columnName;
+            if(isPrimaryKey){
+                let props = this.getPropertyAttributes(column);
+                props.unshift('isId: true');
+                propertiesConfig.push(propertyKey+': {\n                '+props.join(',\n                ')+ '\n            }');
                 continue;
             }
             let props = this.getPropertyAttributes(column);

package/lib/generators/models-generation.js

@@ -19,6 +19,7 @@ class ModelsGeneration extends BaseGenerator
         this.templates = sc.get(props, 'templates', {});
         this.generatedModels = {};
         this.allTablesData = {};
+        this.removeIdFromMultipleRelations = sc.get(props, 'removeIdFromMultipleRelations', true);
     }
 
     async generateModelFile(tableName, tableData, driverKey, entityInfo, relationMetadata = {})
@@ -135,7 +136,7 @@ class ModelsGeneration extends BaseGenerator
         for(let modelInfo of requiredModels){
             requireStatements.push('        const { '+modelInfo.modelClass+' } = require(\'./'+modelInfo.fileName+'\');');
         }
-        let relationMappingsMethod = '\n\n    static get relationMappings()\n    {\n';
+        let relationMappingsMethod = '\n    static get relationMappings()\n    {\n';
         relationMappingsMethod += requireStatements.join('\n')+'\n';
         relationMappingsMethod += '        return {\n';
         relationMappingsMethod += relationMappings.join(',\n');
@@ -147,13 +148,14 @@ class ModelsGeneration extends BaseGenerator
     detectObjectionJsRelations(tableName, tableData)
     {
         let relations = {};
+        let referenceCounts = this.countReferencesPerTable(tableData);
         for(let columnName of Object.keys(tableData.columns)){
             let column = tableData.columns[columnName];
             if(!sc.hasOwn(column, 'referencedTable')){
                 continue;
             }
-            let relationKey = 'related_'+column.referencedTable;
-            let relationType = this.determineRelationType(column, true);
+            let relationKey = this.generateForwardRelationKey(column.referencedTable, columnName, referenceCounts);
+            let relationType = this.determineForwardRelationType(tableName, columnName, column);
             relations[relationKey] = {
                 fromColumn: columnName,
                 toColumn: column.referencedColumn,
@@ -172,6 +174,7 @@ class ModelsGeneration extends BaseGenerator
                 continue;
             }
             let otherTableData = this.allTablesData[otherTableName];
+            let referenceCounts = this.countReferencesToTable(tableName, otherTableData);
             for(let columnName of Object.keys(otherTableData.columns)){
                 let column = otherTableData.columns[columnName];
                 if(!sc.hasOwn(column, 'referencedTable')){
@@ -180,8 +183,8 @@ class ModelsGeneration extends BaseGenerator
                 if(column.referencedTable !== tableName){
                     continue;
                 }
-                let relationKey = 'related_'+otherTableName;
-                let relationType = this.determineRelationType(column, false);
+                let relationKey = this.generateReverseRelationKey(otherTableName, columnName, referenceCounts);
+                let relationType = this.determineReverseRelationType(otherTableName, columnName, column);
                 reverseRelations[relationKey] = {
                     fromColumn: column.referencedColumn,
                     toColumn: columnName,
@@ -193,15 +196,88 @@ class ModelsGeneration extends BaseGenerator
         return reverseRelations;
     }
 
+    countReferencesPerTable(tableData)
+    {
+        let counts = {};
+        for(let columnName of Object.keys(tableData.columns)){
+            let column = tableData.columns[columnName];
+            if(!sc.hasOwn(column, 'referencedTable')){
+                continue;
+            }
+            if(!counts[column.referencedTable]){
+                counts[column.referencedTable] = 0;
+            }
+            counts[column.referencedTable]++;
+        }
+        return counts;
+    }
+
+    countReferencesToTable(targetTable, sourceTableData)
+    {
+        let count = 0;
+        for(let columnName of Object.keys(sourceTableData.columns)){
+            let column = sourceTableData.columns[columnName];
+            if(!sc.hasOwn(column, 'referencedTable')){
+                continue;
+            }
+            if(column.referencedTable === targetTable){
+                count++;
+            }
+        }
+        return count;
+    }
+
+    generateForwardRelationKey(referencedTable, columnName, referenceCounts)
+    {
+        if(1 === referenceCounts[referencedTable]){
+            return 'related_'+referencedTable;
+        }
+        let columnSuffix = columnName;
+        if(this.removeIdFromMultipleRelations){
+            columnSuffix = columnName.replace(/_id$/i, '');
+        }
+        return 'related_'+referencedTable+'_'+columnSuffix;
+    }
+
+    generateReverseRelationKey(referencingTable, columnName, referenceCount)
+    {
+        if(1 === referenceCount){
+            return 'related_'+referencingTable;
+        }
+        let columnSuffix = columnName;
+        if(this.removeIdFromMultipleRelations){
+            columnSuffix = columnName.replace(/_id$/i, '');
+        }
+        return 'related_'+referencingTable+'_'+columnSuffix;
+    }
+
+    determineForwardRelationType(tableName, columnName, column)
+    {
+        return 'BelongsToOneRelation';
+    }
+
+    determineReverseRelationType(referencingTableName, referencingColumnName, referencingColumn)
+    {
+        if(!this.allTablesData[referencingTableName]){
+            return 'HasManyRelation';
+        }
+        let referencingTableData = this.allTablesData[referencingTableName];
+        let referencingColumnData = referencingTableData.columns[referencingColumnName];
+        if(!referencingColumnData){
+            return 'HasManyRelation';
+        }
+        if('UNI' === referencingColumnData.key || 'PRI' === referencingColumnData.key){
+            return 'HasOneRelation';
+        }
+        return 'HasManyRelation';
+    }
+
     determineRelationType(column, isForwardRelation)
     {
         if(isForwardRelation){
-            if('PRI' === column.key){
-                return 'HasOneRelation';
-            }
             return 'BelongsToOneRelation';
         }
-        if('PRI' === column.key){
+        if('PRI' === column.key || 'UNI' === column.key){
             return 'HasOneRelation';
         }
         return 'HasManyRelation';

package/lib/mikro-orm/mikro-orm-data-server.js

@@ -54,6 +54,15 @@ class MikroOrmDataServer extends BaseDataServer
         return this.initialized;
     }
 
+    async disconnect()
+    {
+        if(!this.orm){
+            return false;
+        }
+        await this.orm.close();
+        return true;
+    }
+
     generateEntities()
     {
         if(!this.initialized){

package/lib/objection-js/objection-js-data-server.js

@@ -47,6 +47,15 @@ class ObjectionJsDataServer extends BaseDataServer
         return this.initialized;
     }
 
+    async disconnect()
+    {
+        if(!this.knex){
+            return false;
+        }
+        await this.knex.destroy();
+        return true;
+    }
+
     generateEntities()
     {
         if(!this.rawEntities){

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@reldens/storage",
     "scope": "@reldens",
-    "version": "0.76.0",
+    "version": "0.78.0",
     "description": "Reldens - Storage",
     "author": "Damian A. Pastorini",
     "license": "MIT",
@@ -42,16 +42,16 @@
         "url": "https://github.com/damian-pastorini/reldens-storage/issues"
     },
     "dependencies": {
-        "@mikro-orm/core": "6.5.8",
-        "@mikro-orm/mongodb": "6.5.8",
-        "@mikro-orm/mysql": "6.5.8",
-        "@prisma/client": "6.18.0",
-        "@reldens/server-utils": "^0.39.0",
-        "@reldens/utils": "^0.53.0",
+        "@mikro-orm/core": "6.6.0",
+        "@mikro-orm/mongodb": "6.6.0",
+        "@mikro-orm/mysql": "6.6.0",
+        "@prisma/client": "6.19.0",
+        "@reldens/server-utils": "^0.40.0",
+        "@reldens/utils": "^0.54.0",
         "knex": "3.1.0",
         "mysql": "2.18.1",
         "mysql2": "3.15.3",
         "objection": "3.1.5",
-        "prisma": "6.18.0"
+        "prisma": "6.19.0"
     }
 }