@reldens/storage 0.32.0 → 0.33.0

package/README.md

@@ -3,56 +3,103 @@
 # Reldens - Storage
 
 ## About this package
-This package is designed to provide a standard drivers support for managing Reldens project data.
+This package provides standardized database drivers for Reldens projects. 
+It ensures consistent data access methods across different database types and ORM implementations.
 
-This way in any Reldens project we can trust that any driver implementation will have the exact same methods available to fetch and manage the project entities.
+## Features
 
-Every time you need to load, create, update or delete data in Reldens, the drivers from this package will be used.
+### ORM Support
+- **Objection JS** (via Knex) - For SQL databases (recommended)
+- **Mikro-ORM** - For MongoDB/NoSQL support
 
-## Current features
-The package currently has drivers to support two ORMs:
-- Objection JS (with Knex), for everything that's SQL related (this is our base and recommended package).
+### Entity Management
+- Standardized CRUD operations
+- Automatic entity generation from database schemas
+- Type mapping between database and JavaScript
+- Foreign key relationship handling
+- ENUM field support with formatted values
+
+### CLI Tools
+Generate entity files directly from your database structure:
+```bash
+npx reldens-storage generateEntities --user=dbuser --pass=dbpass --database=dbname --driver=objection-js
+```
+
+Options:
+- `--user` - Database username
+- `--pass` - Database password
+- `--host` - Database host (default: localhost)
+- `--port` - Database port (default: 3306)
+- `--database` - Database name
+- `--driver` - ORM driver (objection-js|mikro-orm)
+- `--client` - Database client (mysql|mysql2|mongodb)
+- `--path` - Project path for output files
+
+## Usage Examples
+
+### SQL with Objection JS
 ```javascript
-let server = new ObjectionJsDataServer({
-    client: 'mysql',
+const { ObjectionJsDataServer } = require('@reldens/storage');
+
+const server = new ObjectionJsDataServer({
+    client: 'mysql2',
     config: {
         user: 'reldens',
         password: 'reldens',
         database: 'reldens',
-        port : 3306,
+        host: 'localhost',
+        port: 3306
     }
 });
+
+await server.connect();
+const entities = server.generateEntities();
 ```
-- Mikro-ORM, to offer support for nonSQL/MongoDB (this package is not finished, if you like to use it please contact us).
+
+### MongoDB with Mikro-ORM
 ```javascript
-let server = new MikroOrmDataServer({
+const { MikroOrmDataServer } = require('@reldens/storage');
+
+const server = new MikroOrmDataServer({
     client: 'mongodb',
     config: {
         user: 'reldens',
         password: 'reldens',
-        database: 'test',
-        port : 27017,
+        database: 'reldens',
+        host: 'localhost',
+        port: 27017
     },
-    connectStringOptions: 'authSource=reldens&readPreference=primary&appname=MongoDB%20Compass&ssl=false',
-    autoGenerateEntities: false,
-    rawEntities: Object.values(rawRegisteredEntities)
+    connectStringOptions: 'authSource=reldens&readPreference=primary&ssl=false',
+    rawEntities: yourEntities
 });
+
+await server.connect();
+const entities = server.generateEntities();
 ```
 
-## Custom drivers
-Through this package you can also create your own drivers (to support your own storage system) and later implement it on any Reldens project.
+## Custom Drivers
 
-In order to do this, just extend the BaseDataServer and BaseDriver classes and fill all the required methods.
+You can create custom storage drivers by extending the base classes:
 
-For last, on your Reldens implementation you just need to pass an instance of your data server to the server manager and you are done:
-```
-const appServer = new ServerManager(serverConfig, eventsManager, yourDriverInstance);
+1. Extend `BaseDataServer` and `BaseDriver`
+2. Implement all required methods
+3. Pass your custom server instance to Reldens ServerManager:
+
+```javascript
+const { ServerManager } = require('@reldens/server');
+const YourCustomDriver = require('./your-custom-driver');
+
+const customDriver = new YourCustomDriver(options);
+const appServer = new ServerManager(serverConfig, eventsManager, customDriver);
 ```
 
-You can also check the [skeleton implementation](https://github.com/damian-pastorini/reldens-skeleton/) to see how it works.
+## Links
+- [Reldens Website](https://www.reldens.com/)
+- [GitHub Repository](https://github.com/damian-pastorini/reldens/tree/master)
 
-For reference see Reldens GitHub: [https://github.com/damian-pastorini/reldens/tree/master](https://github.com/damian-pastorini/reldens/tree/master)
+---
 
 ### [Reldens](https://www.reldens.com/ "Reldens")
 
 ##### [By DwDeveloper](https://www.dwdeveloper.com/ "DwDeveloper")
+

package/bin/reldens-storage.js

@@ -0,0 +1,75 @@
+#!/usr/bin/env node
+
+/**
+ *
+ * Reldens - Storage CLI
+ *
+ */
+
+const { EntitiesGenerator } = require('../lib/entities-generator');
+const { Logger } = require('@reldens/utils');
+
+let args = process.argv.slice(2);
+let command = args[0];
+
+if('generateEntities' !== command){
+    Logger.error('Unknown command. Available command "generateEntities".');
+    process.exit();
+}
+
+let connectionData = {
+    driver: 'objection-js',
+    client: 'mysql2',
+    user: '',
+    password: '',
+    host: 'localhost',
+    database: '',
+    port: 3306
+};
+
+let projectPath = process.cwd();
+for(let i = 1; i < args.length; i++){
+    let arg = args[i];
+    if(!arg.startsWith('--')){
+        continue;
+    }
+    let [key, value] = arg.substring(2).split('=');
+    if(!key || !value){
+        continue;
+    }
+    if('pass' === key){
+        connectionData.password = value;
+        continue;
+    }
+    if('path' === key){
+        projectPath = value;
+        continue;
+    }
+    connectionData[key] = value;
+}
+
+if('mikro-orm' === connectionData.driver && !args.find(arg => arg.startsWith('--client='))){
+    connectionData.client = 'mysql';
+}
+
+if(!connectionData.user || !connectionData.database){
+    Logger.error('Required parameters missing.');
+    Logger.error(
+        'Usage:',
+        'npx reldens-storage generateEntities --user=[db-username] --pass=[db-password] --host=[db-host] --database=[db-name] --driver=[driver-map-key] --client=[db-client] --path=[project-path]'
+    );
+    process.exit();
+}
+
+let generator = new EntitiesGenerator({connectionData, projectPath});
+generator.generate().then((success) => {
+    if(!success){
+        Logger.error('Entity generation failed.');
+        return;
+    }
+    Logger.info('Entity generation completed successfully!');
+    process.exit();
+}).catch((error) => {
+    Logger.error('Error during entity generation: '+error.message);
+    process.exit();
+});

package/index.js

@@ -12,17 +12,30 @@ const { Model } = require('objection');
 const { MikroOrmDriver } = require('./lib/mikro-orm/mikro-orm-driver');
 const { MikroOrmDataServer } = require('./lib/mikro-orm/mikro-orm-data-server');
 const MikroOrmCore = require('@mikro-orm/core');
+const { EntitiesGenerator } = require('./lib/entities-generator');
+const { EntityProperties } = require('./lib/entity-properties');
+const { TypeMapper } = require('./lib/type-mapper');
+const { MySQLTablesProvider } = require('./lib/mysql-tables-provider');
 
 module.exports = {
     // base:
-    BaseDataServer: BaseDataServer,
-    BaseDriver: BaseDriver,
+    BaseDataServer,
+    BaseDriver,
+    DriversMap: {
+        'objection-js': ObjectionJsDataServer,
+        'mikro-orm': MikroOrmDataServer
+    },
     // objection-js:
-    ObjectionJsDataServer: ObjectionJsDataServer,
-    ObjectionJsDriver: ObjectionJsDriver,
+    ObjectionJsDataServer,
+    ObjectionJsDriver,
     ObjectionJsRawModel: Model,
     // mikro-orm:
     MikroOrmCore,
-    MikroOrmDataServer: MikroOrmDataServer,
-    MikroOrmDriver: MikroOrmDriver
+    MikroOrmDataServer,
+    MikroOrmDriver,
+    // entities:
+    EntitiesGenerator,
+    EntityProperties,
+    TypeMapper,
+    MySQLTablesProvider
 };

package/lib/base-data-server.js

@@ -56,6 +56,11 @@ class BaseDataServer
         ErrorManager.error('BaseDriver connect() not implemented.');
     }
 
+    async fetchEntitiesFromDatabase()
+    {
+        ErrorManager.error('BaseDriver fetchEntitiesFromDatabase() not implemented.');
+    }
+
 }
 
 module.exports.BaseDataServer = BaseDataServer;

package/lib/entities-generator.js

@@ -0,0 +1,584 @@
+/**
+ *
+ * Reldens - EntitiesGenerator
+ *
+ */
+
+const { FileHandler } = require('@reldens/server-utils');
+const { ErrorManager, Logger, sc } = require('@reldens/utils');
+const { ObjectionJsDataServer } = require('./objection-js/objection-js-data-server');
+const { MikroOrmDataServer } = require('./mikro-orm/mikro-orm-data-server');
+const { TypeMapper } = require('./type-mapper');
+
+class EntitiesGenerator
+{
+
+    constructor(props)
+    {
+        this.templatesFolderPath = FileHandler.joinPaths(__dirname, 'entity-templates');
+        this.templates = {
+            'objection-js': FileHandler.joinPaths(this.templatesFolderPath, 'objection-js-entity.template'),
+            'mikro-orm': FileHandler.joinPaths(this.templatesFolderPath, 'mikro-orm-entity.template'),
+            'entity': FileHandler.joinPaths(this.templatesFolderPath, 'entity.template'),
+            'entities-config': FileHandler.joinPaths(this.templatesFolderPath, 'entities-config.template'),
+            'entities-translations': FileHandler.joinPaths(this.templatesFolderPath, 'entities-translations.template'),
+            'registered-models': FileHandler.joinPaths(this.templatesFolderPath, 'registered-models.template')
+        };
+        this.projectPath = sc.get(props, 'projectPath', FileHandler.joinPaths(__dirname, '..'));
+        this.generationFolder = FileHandler.joinPaths(this.projectPath, 'generated-entities');
+        this.entitiesFolder = FileHandler.joinPaths(this.generationFolder, 'entities');
+        this.modelsFolder = FileHandler.joinPaths(this.generationFolder, 'models');
+        this.entitiesConfigPath = FileHandler.joinPaths(this.generationFolder, 'entities-config.js');
+        this.entitiesTranslationsPath = FileHandler.joinPaths(this.generationFolder, 'entities-translations.js');
+        this.driverMap = {
+            'objection-js': ObjectionJsDataServer,
+            'mikro-orm': MikroOrmDataServer
+        };
+        this.server = sc.get(props, 'server', false);
+        this.connectionData = sc.get(props, 'connectionData', false);
+        if(!this.server && !this.connectionData){
+            ErrorManager.error('Either server or connectionData must be provided to EntitiesGenerator.');
+        }
+        this.generatedEntities = {};
+    }
+
+    ensureFoldersExist()
+    {
+        if(!FileHandler.exists(this.generationFolder)){
+            try {
+                FileHandler.createFolder(this.generationFolder, { recursive: true });
+            } catch (error) {
+                ErrorManager.error('Failed to create generation folder: '+error.message);
+            }
+        }
+        if(!FileHandler.exists(this.entitiesFolder)){
+            try {
+                FileHandler.createFolder(this.entitiesFolder, { recursive: true });
+            } catch (error) {
+                ErrorManager.error('Failed to create entities folder: '+error.message);
+            }
+        }
+        if(!FileHandler.exists(this.modelsFolder)){
+            try {
+                FileHandler.createFolder(this.modelsFolder, { recursive: true });
+            } catch (error) {
+                ErrorManager.error('Failed to create models folder: '+error.message);
+            }
+        }
+        for(let driverKey of Object.keys(this.driverMap)){
+            let driverFolder = FileHandler.joinPaths(this.modelsFolder, driverKey);
+            if(!FileHandler.exists(driverFolder)){
+                try {
+                    FileHandler.createFolder(driverFolder, { recursive: true });
+                } catch (error) {
+                    ErrorManager.error('Failed to create driver folder: '+error.message);
+                }
+            }
+        }
+    }
+
+    async generateEntityFile(tableName, tableData)
+    {
+        let entityTemplatePath = this.templates['entity'];
+        if(!FileHandler.exists(entityTemplatePath)){
+            ErrorManager.error('Entity template file not found: '+entityTemplatePath);
+        }
+        let entityTemplateContent;
+        try {
+            entityTemplateContent = FileHandler.fetchFileContents(entityTemplatePath);
+        } catch (error) {
+            ErrorManager.error('Failed to read entity template file: '+error.message);
+        }
+        let entityClassName = sc.capitalizedCamelCase(tableName)+'Entity';
+        let titleProperty = this.determineTitleProperty(tableData.columns);
+        for(let columnName in tableData.columns){
+            tableData.columns[columnName].tableName = tableName;
+        }
+        let propertiesConfig = this.generatePropertiesConfig(tableData.columns, titleProperty);
+        let titlePropertyDeclaration = titleProperty ? '\n        let titleProperty = \''+titleProperty+'\';' : '';
+        let titlePropertyReturn = titleProperty ? '\n            titleProperty,' : '';
+        let fieldsToRemoveFromEdit = ['id'];
+        if(tableData.columns['created_at']){
+            fieldsToRemoveFromEdit.push('created_at');
+        }
+        if(tableData.columns['updated_at']){
+            fieldsToRemoveFromEdit.push('updated_at');
+        }
+        let editPropertiesRemoval = this.getEditPropertiesRemoval(fieldsToRemoveFromEdit);
+        let listPropertiesDeclaration = this.getListPropertiesDeclaration(tableData.columns);
+        let needsSc = listPropertiesDeclaration.includes('sc.removeFromArray') || editPropertiesRemoval.includes('sc.removeFromArray');
+        let scRequire = needsSc ? '\nconst { sc } = require(\'@reldens/utils\');' : '';
+        let replacements = {
+            entityClassName,
+            propertiesConfig,
+            titlePropertyDeclaration,
+            titlePropertyReturn,
+            listPropertiesDeclaration,
+            editPropertiesRemoval,
+            scRequire
+        };
+        let entityContent = this.applyReplacements(entityTemplateContent, replacements);
+        let fileName = sc.kebabCase(tableName)+'-entity.js';
+        let filePath = FileHandler.joinPaths(this.entitiesFolder, fileName);
+        try {
+            FileHandler.writeFile(filePath, entityContent);
+            Logger.info('Generated entity file: '+filePath);
+            this.generatedEntities[tableName] = {
+                entityClassName,
+                entityFileName: fileName,
+                tableName,
+                titleProperty
+            };
+            return true;
+        } catch (error) {
+            ErrorManager.error('Failed to write entity file: '+error.message);
+        }
+    }
+
+    getEditPropertiesRemoval(fieldsToRemove)
+    {
+        if(1 === fieldsToRemove.length){
+            return 'let editProperties = [...showProperties];\n        editProperties.splice(editProperties.indexOf(\''+fieldsToRemove[0]+'\'), 1);';
+        }
+        return 'let editProperties = sc.removeFromArray([...showProperties], [\''+fieldsToRemove.join('\', \'')+'\']);';
+    }
+
+    determineTitleProperty(columns)
+    {
+        if(columns['label']){
+            return 'label';
+        }
+        if(columns['title']){
+            return 'title';
+        }
+        if(columns['name']){
+            return 'name';
+        }
+        if(columns['key']){
+            return 'key';
+        }
+        return false;
+    }
+
+    generatePropertiesConfig(columns, titleProperty)
+    {
+        let propertiesConfig = [];
+        for(let columnName in columns){
+            let column = columns[columnName];
+            let propertyKey = titleProperty && columnName === titleProperty ? '[titleProperty]' : columnName;
+            if('id' === columnName){
+                propertiesConfig.push(columnName+': {}');
+                continue;
+            }
+            let props = this.getPropertyAttributes(column);
+            if(0 === props.length){
+                propertiesConfig.push(propertyKey+': {}');
+                continue;
+            }
+            propertiesConfig.push(propertyKey+': {\n                '+props.join(',\n                ')+'\n            }');
+        }
+        return propertiesConfig.join(',\n            ');
+    }
+
+    getPropertyAttributes(column)
+    {
+        let props = [];
+        let type = column.type.toLowerCase();
+        this.addTypeAttribute(props, column, type);
+        this.addRequiredAttribute(props, column);
+        return props;
+    }
+
+    addTypeAttribute(props, column, type)
+    {
+        if(this.isForeignKey(column)){
+            props.push('type: \'reference\'');
+            props.push('reference: \''+this.getReferenceTable(column)+'\'');
+            return;
+        }
+        if('date' === type || 'datetime' === type || 'timestamp' === type){
+            props.push('type: \'datetime\'');
+            return;
+        }
+        if('tinyint' === type){
+            props.push('type: \'boolean\'');
+            return;
+        }
+        if('enum' === type){
+            this.addEnumValues(props, column);
+            return;
+        }
+        if(type.includes('int')){
+            props.push('type: \'number\'');
+            return;
+        }
+        if('varchar' === type || 'char' === type){
+            return;
+        }
+        let jsType = TypeMapper.mapDbTypeToJsType(type);
+        if(jsType && 'string' !== jsType){
+            props.push('type: \''+jsType+'\'');
+        }
+    }
+
+    addEnumValues(props, column)
+    {
+        let enumValues = this.parseEnumValues(column.columnType);
+        if(0 === enumValues.length){
+            return;
+        }
+        let availableValues = [];
+        for(let i = 0; i < enumValues.length; i++){
+            availableValues.push('{value: '+(i+1)+', label: \''+enumValues[i]+'\'}');
+        }
+        props.push('availableValues: [\n                    '+availableValues.join(',\n                    ')+'\n                ]');
+    }
+
+    parseEnumValues(columnType)
+    {
+        if(!columnType){
+            return [];
+        }
+        let match = columnType.match(/^enum\('(.+)'\)$/i);
+        if(!match){
+            return [];
+        }
+        let valuesString = match[1];
+        let values = valuesString.split('\',\'');
+        return values;
+    }
+
+    addRequiredAttribute(props, column)
+    {
+        if(!column.nullable && !column.default){
+            props.push('isRequired: true');
+        }
+    }
+
+    isForeignKey(column)
+    {
+        if(column.referencedTable){
+            return true;
+        }
+        return false;
+    }
+
+    getReferenceTable(column)
+    {
+        if(column.referencedTable){
+            return column.referencedTable;
+        }
+        let refTableName = column.name.replace('_id', '');
+        if(refTableName.includes('_')){
+            let parts = refTableName.split('_');
+            if(column.tableName && column.tableName === parts[0]){
+                refTableName = parts.slice(1).join('_');
+            }
+        }
+        return refTableName;
+    }
+
+    getListPropertiesDeclaration(columns)
+    {
+        let fieldsToRemove = this.getTextAndJsonFields(columns);
+        if(0 === fieldsToRemove.length){
+            return 'let listProperties = showProperties;';
+        }
+        if(1 === fieldsToRemove.length){
+            return 'let listProperties = [...showProperties];\n        listProperties.splice(listProperties.indexOf(\''+fieldsToRemove[0]+'\'), 1);';
+        }
+        return 'let listProperties = sc.removeFromArray([...showProperties], [\''+fieldsToRemove.join('\', \'')+'\']);';
+    }
+
+    getTextAndJsonFields(columns)
+    {
+        let fieldsToRemove = [];
+        for(let columnName in columns){
+            let column = columns[columnName];
+            let type = column.type.toLowerCase();
+            if(['text', 'json', 'tinytext', 'mediumtext', 'longtext'].includes(type)){
+                fieldsToRemove.push(columnName);
+            }
+        }
+        return fieldsToRemove;
+    }
+
+    async generateModelFile(tableName, tableData, driverKey)
+    {
+        let modelTemplatePath = this.templates[driverKey];
+        if(!FileHandler.exists(modelTemplatePath)){
+            ErrorManager.error('Model template file not found: '+modelTemplatePath);
+        }
+        let modelTemplateContent;
+        try {
+            modelTemplateContent = FileHandler.fetchFileContents(modelTemplatePath);
+        } catch (error) {
+            ErrorManager.error('Failed to read model template file: '+error.message);
+        }
+        let modelClassName = sc.capitalizedCamelCase(tableName)+'Model';
+        let modelPropertiesList = Object.keys(tableData.columns).join(', ');
+        let modelPropertiesConstructor = Object.keys(tableData.columns)
+            .map(columnName => 'this.'+columnName+' = '+columnName+';')
+            .join('\n        ');
+        let modelRelations = '';
+        let entityPropertiesDefinition = this.getEntityPropertiesDefinition(tableData.columns, driverKey);
+        let replacements = {
+            modelClassName,
+            tableName,
+            modelPropertiesList,
+            modelPropertiesConstructor,
+            modelRelations,
+            entityPropertiesDefinition
+        };
+        let modelContent = this.applyReplacements(modelTemplateContent, replacements);
+        let fileName = sc.kebabCase(tableName)+'-model.js';
+        let driverFolder = FileHandler.joinPaths(this.modelsFolder, driverKey);
+        let filePath = FileHandler.joinPaths(driverFolder, fileName);
+        try {
+            FileHandler.writeFile(filePath, modelContent);
+            Logger.info('Generated model file: '+filePath);
+            this.generatedEntities[tableName].modelClassName = modelClassName;
+            this.generatedEntities[tableName].modelFileName = fileName;
+            this.generatedEntities[tableName].driverKey = driverKey;
+            return true;
+        } catch (error) {
+            ErrorManager.error('Failed to write model file: '+error.message);
+        }
+    }
+
+    getEntityPropertiesDefinition(columns, driverKey)
+    {
+        if('mikro-orm' !== driverKey){
+            return '';
+        }
+        let entityProps = [];
+        for(let columnName in columns){
+            let column = columns[columnName];
+            let isPrimary = 'PRI' === column.key;
+            let type = TypeMapper.mapDbTypeToJsType(column.type);
+            let propDef = columnName+': { type: \''+type+'\'';
+            if(isPrimary){
+                propDef += ', primary: true';
+            }
+            if(column.nullable){
+                propDef += ', nullable: true';
+            }
+            propDef += ' }';
+            entityProps.push(propDef);
+        }
+        return entityProps.join(',\n        ');
+    }
+
+    generateEntitiesConfigFile()
+    {
+        let configTemplatePath = this.templates['entities-config'];
+        if(!FileHandler.exists(configTemplatePath)){
+            ErrorManager.error('Entities config template file not found: '+configTemplatePath);
+        }
+        let configTemplateContent;
+        try {
+            configTemplateContent = FileHandler.fetchFileContents(configTemplatePath);
+        } catch (error) {
+            ErrorManager.error('Failed to read entities config template file: '+error.message);
+        }
+        if(!configTemplateContent || 'string' !== typeof configTemplateContent){
+            ErrorManager.error('Invalid entities config template content');
+        }
+        let requireStatements = this.getRequireStatements();
+        let entitiesConfigExport = this.getEntitiesConfigExport();
+        let replacements = {
+            requireStatements,
+            entitiesConfigExport
+        };
+        let configContent = this.applyReplacements(configTemplateContent, replacements);
+        try {
+            FileHandler.writeFile(this.entitiesConfigPath, configContent);
+            Logger.info('Generated entities config file: '+this.entitiesConfigPath);
+            return true;
+        } catch (error) {
+            ErrorManager.error('Failed to write entities config file: '+error.message);
+        }
+    }
+
+    getRequireStatements()
+    {
+        let requireStatements = [];
+        for(let tableName in this.generatedEntities){
+            let entity = this.generatedEntities[tableName];
+            requireStatements.push('const { '+entity.entityClassName+' } = require(\'./entities/'+entity.entityFileName.replace('.js', '')+'\');');
+        }
+        return requireStatements.join('\n');
+    }
+
+    getEntitiesConfigExport()
+    {
+        let entitiesConfigExport = [];
+        for(let tableName in this.generatedEntities){
+            let entity = this.generatedEntities[tableName];
+            let camelCaseKey = sc.camelCase(tableName);
+            entitiesConfigExport.push(camelCaseKey+': '+entity.entityClassName+'.propertiesConfig()');
+        }
+        return entitiesConfigExport.join(',\n    ');
+    }
+
+    generateEntitiesTranslationsFile()
+    {
+        let translationsTemplatePath = this.templates['entities-translations'];
+        if(!FileHandler.exists(translationsTemplatePath)){
+            ErrorManager.error('Entities translations template file not found: '+translationsTemplatePath);
+        }
+        let translationsTemplateContent;
+        try {
+            translationsTemplateContent = FileHandler.fetchFileContents(translationsTemplatePath);
+        } catch (error) {
+            ErrorManager.error('Failed to read entities translations template file: '+error.message);
+        }
+        if(!translationsTemplateContent || 'string' !== typeof translationsTemplateContent){
+            ErrorManager.error('Invalid entities translations template content');
+        }
+        let labels = this.getTranslationLabels();
+        let translationsContent = translationsTemplateContent.replace(
+            /{{labels}}/g,
+            labels
+        );
+        try {
+            FileHandler.writeFile(this.entitiesTranslationsPath, translationsContent);
+            Logger.info('Generated entities translations file: '+this.entitiesTranslationsPath);
+            return true;
+        } catch (error) {
+            ErrorManager.error('Failed to write entities translations file: '+error.message);
+        }
+    }
+
+    getTranslationLabels()
+    {
+        let labels = [];
+        for(let tableName in this.generatedEntities){
+            let humanReadable = tableName
+                .split('_')
+                .map(word => word.charAt(0).toUpperCase() + word.slice(1))
+                .join(' ');
+            labels.push('\''+tableName+'\': \''+humanReadable+'\'');
+        }
+        return labels.join(',\n        ');
+    }
+
+    generateRegisteredModelsFile(driverKey)
+    {
+        let registeredTemplatePath = this.templates['registered-models'];
+        if(!FileHandler.exists(registeredTemplatePath)){
+            ErrorManager.error('Registered models template file not found: '+registeredTemplatePath);
+        }
+        let registeredTemplateContent;
+        try {
+            registeredTemplateContent = FileHandler.fetchFileContents(registeredTemplatePath);
+        } catch (error) {
+            ErrorManager.error('Failed to read registered models template file: '+error.message);
+        }
+        if(!registeredTemplateContent || 'string' !== typeof registeredTemplateContent){
+            ErrorManager.error('Invalid registered models template content');
+        }
+        let registeredModels = this.getRegisteredModels(driverKey);
+        let registeredEntitiesObject = this.getRegisteredEntitiesObject(driverKey);
+        let replacements = {
+            registeredModels,
+            registeredEntitiesObject
+        };
+        let registeredContent = this.applyReplacements(registeredTemplateContent, replacements);
+        let driverFolder = FileHandler.joinPaths(this.modelsFolder, driverKey);
+        let filePath = FileHandler.joinPaths(driverFolder, 'registered-models-'+driverKey+'.js');
+        try {
+            FileHandler.writeFile(filePath, registeredContent);
+            Logger.info('Generated registered models file: '+filePath);
+            return true;
+        } catch (error) {
+            ErrorManager.error('Failed to write registered models file: '+error.message);
+        }
+    }
+
+    getRegisteredModels(driverKey)
+    {
+        let registeredModels = [];
+        for(let tableName in this.generatedEntities){
+            let entity = this.generatedEntities[tableName];
+            if(entity.driverKey === driverKey){
+                registeredModels.push('const { '+entity.modelClassName+' } = require(\'./'+entity.modelFileName.replace('.js', '')+'\');');
+            }
+        }
+        return registeredModels.join('\n');
+    }
+
+    getRegisteredEntitiesObject(driverKey)
+    {
+        let registeredEntitiesObject = [];
+        for(let tableName in this.generatedEntities){
+            let entity = this.generatedEntities[tableName];
+            if(entity.driverKey === driverKey){
+                let camelCaseKey = sc.camelCase(tableName);
+                registeredEntitiesObject.push(camelCaseKey+': '+entity.modelClassName);
+            }
+        }
+        return registeredEntitiesObject.join(',\n    ');
+    }
+
+    applyReplacements(content, replacements)
+    {
+        let result = content;
+        for(let placeholder in replacements){
+            result = result.replace(
+                new RegExp('{{'+placeholder+'}}', 'g'),
+                replacements[placeholder]
+            );
+        }
+        return result;
+    }
+
+    async generate()
+    {
+        if(!this.server){
+            this.createServer();
+        }
+        try {
+            await this.server.connect();
+        } catch (error) {
+            ErrorManager.error('Failed to connect to database: '+error.message);
+        }
+        let tables = await this.server.fetchEntitiesFromDatabase();
+        if(!tables){
+            ErrorManager.error('Failed to fetch tables from database.');
+        }
+        this.ensureFoldersExist();
+        let driverKey = sc.get(this.connectionData, 'driver', 'objection-js');
+        for(let tableName in tables){
+            let tableData = tables[tableName];
+            await this.generateEntityFile(tableName, tableData);
+            await this.generateModelFile(tableName, tableData, driverKey);
+        }
+        this.generateEntitiesConfigFile();
+        this.generateEntitiesTranslationsFile();
+        this.generateRegisteredModelsFile(driverKey);
+        return true;
+    }
+
+    createServer()
+    {
+        let driverKey = sc.get(this.connectionData, 'driver', 'objection-js');
+        let driverClassMapped = this.driverMap[driverKey];
+        if(!driverClassMapped){
+            ErrorManager.error('Unsupported driver: '+driverKey);
+        }
+        this.server = new driverClassMapped({
+            client: sc.get(this.connectionData, 'client', 'mysql2'),
+            config: {
+                user: sc.get(this.connectionData, 'user', ''),
+                password: sc.get(this.connectionData, 'password', ''),
+                database: sc.get(this.connectionData, 'database', ''),
+                host: sc.get(this.connectionData, 'host', 'localhost'),
+                port: sc.get(this.connectionData, 'port', 3306)
+            }
+        });
+    }
+
+}
+
+module.exports.EntitiesGenerator = EntitiesGenerator;

package/lib/entity-properties.js

@@ -0,0 +1,26 @@
+/**
+ *
+ * Reldens - EntityProperties
+ *
+ */
+
+const { Logger } = require('@reldens/utils');
+
+class EntityProperties
+{
+
+    static propertiesDefinition()
+    {
+        Logger.alert('Method not implemented propertiesDefinition().');
+        return {};
+    }
+
+    static propertiesConfig(extraProps)
+    {
+        Logger.alert('Method not implemented propertiesConfig().', extraProps);
+        return {};
+    }
+
+}
+
+module.exports.EntityProperties = EntityProperties;

package/lib/entity-templates/entities-config.template

@@ -0,0 +1,13 @@
+/**
+ *
+ * Reldens - Entities Config
+ *
+ */
+
+{{requireStatements}}
+
+let entitiesConfig = {
+    {{entitiesConfigExport}}
+};
+
+module.exports.entitiesConfig = entitiesConfig;

package/lib/entity-templates/entities-translations.template

@@ -0,0 +1,11 @@
+/**
+ *
+ * Reldens - Entities Translations
+ *
+ */
+
+module.exports.entitiesTranslations = {
+    labels: {
+        {{labels}}
+    }
+};

package/lib/entity-templates/entity.template

@@ -0,0 +1,32 @@
+/**
+ *
+ * Reldens - {{entityClassName}}
+ *
+ */
+
+const { EntityProperties } = require('@reldens/storage');{{scRequire}}
+
+class {{entityClassName}} extends EntityProperties
+{
+
+    static propertiesConfig(extraProps)
+    {{{titlePropertyDeclaration}}
+        let properties = {
+            {{propertiesConfig}}
+        };
+        let showProperties = Object.keys(properties);
+        {{editPropertiesRemoval}}
+        {{listPropertiesDeclaration}}
+        return {
+            showProperties,
+            editProperties,
+            listProperties,
+            filterProperties: listProperties,
+            properties,{{titlePropertyReturn}}
+            ...extraProps
+        };
+    }
+
+}
+
+module.exports.{{entityClassName}} = {{entityClassName}};

package/lib/entity-templates/mikro-orm-entity.template

@@ -0,0 +1,37 @@
+/**
+ *
+ * Reldens - {{modelClassName}}
+ *
+ */
+
+const { MikroOrmCore } = require('@reldens/storage');
+const { EntitySchema } = MikroOrmCore;
+
+class {{modelClassName}}
+{
+
+    constructor({{modelPropertiesList}})
+    {
+        {{modelPropertiesConstructor}}
+    }
+
+    static createByProps(props)
+    {
+        const {{{modelPropertiesList}}} = props;
+        return new this({{modelPropertiesList}});
+    }
+    {{modelRelations}}
+}
+
+const schema = new EntitySchema({
+    class: {{modelClassName}},
+    properties: {
+        {{entityPropertiesDefinition}}
+    },
+});
+
+module.exports = {
+    {{modelClassName}},
+    entity: {{modelClassName}},
+    schema: schema
+};

package/lib/entity-templates/objection-js-entity.template

@@ -0,0 +1,19 @@
+/**
+ *
+ * Reldens - {{modelClassName}}
+ *
+ */
+
+const { ObjectionJsRawModel } = require('@reldens/storage');
+
+class {{modelClassName}} extends ObjectionJsRawModel
+{
+
+    static get tableName()
+    {
+        return '{{tableName}}';
+    }
+    {{modelRelations}}
+}
+
+module.exports.{{modelClassName}} = {{modelClassName}};

package/lib/entity-templates/registered-models.template

@@ -0,0 +1,19 @@
+/**
+ *
+ * Reldens - Registered Models
+ *
+ */
+
+{{registeredModels}}
+const { entitiesConfig } = require('../../entities-config');
+const { entitiesTranslations } = require('../../entities-translations');
+
+let rawRegisteredEntities = {
+    {{registeredEntitiesObject}}
+};
+
+module.exports.rawRegisteredEntities = rawRegisteredEntities;
+
+module.exports.entitiesConfig = entitiesConfig;
+
+module.exports.entitiesTranslations = entitiesTranslations;

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

@@ -6,10 +6,11 @@
 
 const { MikroOrmDriver } = require('./mikro-orm-driver');
 const { BaseDataServer } = require('../base-data-server');
+const { MySQLTablesProvider } = require('../mysql-tables-provider');
 const { MikroORM } = require('@mikro-orm/core');
 const { MySqlDriver } = require('@mikro-orm/mysql');
 const { MongoDriver } = require('@mikro-orm/mongodb');
-const { Logger, ErrorManager } = require('@reldens/utils');
+const { ErrorManager, Logger, sc } = require('@reldens/utils');
 
 class MikroOrmDataServer extends BaseDataServer
 {
@@ -22,9 +23,9 @@ class MikroOrmDataServer extends BaseDataServer
 
     constructor(props)
     {
-        // @TODO - BETA - Finish implementation.
         super(props);
         this.entitiesPath = props.entitiesPath;
+        this.warnWhenNoEntities = Boolean(props.warnWhenNoEntities);
     }
 
     async connect()
@@ -36,7 +37,7 @@ class MikroOrmDataServer extends BaseDataServer
             driver: this.clientsMapped[(this.client || 'mongodb')],
             dbName: this.config.database,
             clientUrl: this.connectString,
-            allowGlobalContext: true
+            allowGlobalContext: true,
         };
         if(this.rawEntities){
             providedSetup.entities = Object.values(this.rawEntities);
@@ -47,6 +48,7 @@ class MikroOrmDataServer extends BaseDataServer
         if(this.entitiesPath){
             providedSetup.entities = this.entitiesPath;
         }
+        providedSetup.discovery = {warnWhenNoEntities: this.warnWhenNoEntities};
         this.orm = await MikroORM.init(providedSetup);
         this.initialized = Date.now();
         return this.initialized;
@@ -85,8 +87,43 @@ class MikroOrmDataServer extends BaseDataServer
 
     async rawQuery(content)
     {
-        // @TODO - BETA - Implement.
-        ErrorManager.error('MikroORM rawQuery() not implemented.');
+        try {
+            let queryResult = await this.orm.em.execute(content);
+            if(!sc.isArray(queryResult) || 0 === queryResult.length){
+                return false;
+            }
+            return queryResult;
+        } catch(error) {
+            Logger.error('Raw query failed: '+error.message);
+            return false;
+        }
+    }
+
+    async fetchEntitiesFromDatabase()
+    {
+        if(!this.initialized){
+            Logger.error('Connection was not initialized, please use the connect method first.');
+            return false;
+        }
+        try {
+            if('mysql' === this.client){
+                return await MySQLTablesProvider.fetchTables(this);
+            }
+            if('mongodb' === this.client){
+                let tables = {};
+                let collections = await this.orm.em.getDriver().getConnection().db().listCollections().toArray();
+                for(let collection of collections){
+                    tables[collection.name] = {
+                        name: collection.name,
+                        columns: {}
+                    };
+                }
+                return tables;
+            }
+            ErrorManager.error('Unsupported client type: '+this.client);
+        } catch(error) {
+            ErrorManager.error('Failed to fetch tables from database: ' + error.message);
+        }
     }
 
 }

package/lib/mysql-tables-provider.js

@@ -0,0 +1,87 @@
+/**
+ *
+ * Reldens - MySQLTablesProvider
+ *
+ */
+
+const { ErrorManager, sc } = require('@reldens/utils');
+
+class MySQLTablesProvider
+{
+
+    static async fetchTables(server)
+    {
+        let tablesQuery = 
+            'SELECT ' +
+            '    TABLE_NAME, ' +
+            '    COLUMN_NAME, ' +
+            '    DATA_TYPE, ' +
+            '    CHARACTER_MAXIMUM_LENGTH, ' +
+            '    COLUMN_TYPE, ' +
+            '    IS_NULLABLE, ' +
+            '    COLUMN_KEY, ' +
+            '    EXTRA, ' +
+            '    COLUMN_DEFAULT ' +
+            'FROM ' +
+            '    information_schema.COLUMNS ' +
+            'WHERE ' +
+            '    TABLE_SCHEMA = \'' + server.config.database + '\' ' +
+            'ORDER BY ' +
+            '    TABLE_NAME, ORDINAL_POSITION';
+        try {
+            let result = await server.rawQuery(tablesQuery);
+            if(!sc.isArray(result) || 0 === result.length){
+                ErrorManager.error('No tables found in the database.');
+            }
+            let tables = {};
+            for(let row of result){
+                if(!tables[row.TABLE_NAME]){
+                    tables[row.TABLE_NAME] = {
+                        name: row.TABLE_NAME,
+                        columns: {}
+                    };
+                }
+                tables[row.TABLE_NAME].columns[row.COLUMN_NAME] = {
+                    name: row.COLUMN_NAME,
+                    type: row.DATA_TYPE,
+                    columnType: row.COLUMN_TYPE,
+                    length: row.CHARACTER_MAXIMUM_LENGTH,
+                    nullable: 'YES' === row.IS_NULLABLE,
+                    key: row.COLUMN_KEY,
+                    extra: row.EXTRA,
+                    default: row.COLUMN_DEFAULT
+                };
+            }
+            let foreignKeysQuery = 
+                'SELECT ' +
+                '    TABLE_NAME, ' +
+                '    COLUMN_NAME, ' +
+                '    REFERENCED_TABLE_NAME, ' +
+                '    REFERENCED_COLUMN_NAME ' +
+                'FROM ' +
+                '    information_schema.KEY_COLUMN_USAGE ' +
+                'WHERE ' +
+                '    TABLE_SCHEMA = \'' + server.config.database + '\' ' +
+                '    AND REFERENCED_TABLE_NAME IS NOT NULL';
+            
+            let foreignKeysResult = await server.rawQuery(foreignKeysQuery);
+            if(sc.isArray(foreignKeysResult) && 0 < foreignKeysResult.length){
+                for(let row of foreignKeysResult){
+                    if(
+                        tables[row.TABLE_NAME] && 
+                        tables[row.TABLE_NAME].columns[row.COLUMN_NAME]
+                    ){
+                        tables[row.TABLE_NAME].columns[row.COLUMN_NAME].referencedTable = row.REFERENCED_TABLE_NAME;
+                        tables[row.TABLE_NAME].columns[row.COLUMN_NAME].referencedColumn = row.REFERENCED_COLUMN_NAME;
+                    }
+                }
+            }
+            return tables;
+        } catch(error) {
+            ErrorManager.error('Failed to fetch tables from database: '+error.message);
+        }
+    }
+
+}
+
+module.exports.MySQLTablesProvider = MySQLTablesProvider;

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

@@ -6,6 +6,7 @@
 
 const { BaseDataServer } = require('../base-data-server');
 const { ObjectionJsDriver } = require('./objection-js-driver');
+const { MySQLTablesProvider } = require('../mysql-tables-provider');
 const { Model } = require('objection');
 const Knex = require('knex');
 const { Logger } = require('@reldens/utils');
@@ -72,7 +73,17 @@ class ObjectionJsDataServer extends BaseDataServer
 
     async rawQuery(content)
     {
-        return await this.knex.raw(content);
+        let result = await this.knex.raw(content);
+        return result[0] || false;
+    }
+
+    async fetchEntitiesFromDatabase()
+    {
+        if(!this.initialized){
+            Logger.error('Connection was not initialized, please use the connect method first.');
+            return false;
+        }
+        return await MySQLTablesProvider.fetchTables(this);
     }
 
 }

package/lib/type-mapper.js

@@ -0,0 +1,49 @@
+/**
+ *
+ * Reldens - TypeMapper
+ *
+ */
+
+class TypeMapper
+{
+
+    mapDbTypeToJsType(dbType)
+    {
+        let typeMap = {
+            'int': 'number',
+            'integer': 'number',
+            'tinyint': 'number',
+            'smallint': 'number',
+            'mediumint': 'number',
+            'bigint': 'number',
+            'decimal': 'number',
+            'float': 'number',
+            'double': 'number',
+            'varchar': 'string',
+            'char': 'string',
+            'text': 'string',
+            'tinytext': 'string',
+            'mediumtext': 'string',
+            'longtext': 'string',
+            'date': 'Date',
+            'datetime': 'Date',
+            'timestamp': 'Date',
+            'time': 'string',
+            'year': 'number',
+            'boolean': 'boolean',
+            'bool': 'boolean',
+            'bit': 'boolean',
+            'json': 'object',
+            'binary': 'Buffer',
+            'varbinary': 'Buffer',
+            'blob': 'Buffer',
+            'tinyblob': 'Buffer',
+            'mediumblob': 'Buffer',
+            'longblob': 'Buffer'
+        };
+        return typeMap[dbType.toLowerCase()];
+    }
+
+}
+
+module.exports.TypeMapper = new TypeMapper();

package/package.json

@@ -1,13 +1,16 @@
 {
     "name": "@reldens/storage",
     "scope": "@reldens",
-    "version": "0.32.0",
+    "version": "0.33.0",
     "description": "Reldens - Storage",
     "author": "Damian A. Pastorini",
     "license": "MIT",
     "homepage": "https://github.com/damian-pastorini/reldens-storage",
     "source": true,
     "main": "index.js",
+    "bin": {
+        "reldens-storage": "./bin/reldens-storage.js"
+    },
     "repository": {
         "type": "git",
         "url": "https://github.com/damian-pastorini/reldens-storage.git"
@@ -44,13 +47,14 @@
         "url": "https://github.com/damian-pastorini/reldens-storage/issues"
     },
     "dependencies": {
-        "@mikro-orm/core": "^6.4.13",
-        "@mikro-orm/mongodb": "^6.4.13",
-        "@mikro-orm/mysql": "^6.4.13",
-        "@reldens/utils": "^0.40.0",
+        "@mikro-orm/core": "^6.4.15",
+        "@mikro-orm/mongodb": "^6.4.15",
+        "@mikro-orm/mysql": "^6.4.15",
+        "@reldens/utils": "^0.47.0",
+        "@reldens/server-utils": "^0.15.0",
         "knex": "^3.1.0",
         "mysql": "^2.18.1",
-        "mysql2": "^3.14.0",
+        "mysql2": "^3.14.1",
         "objection": "^3.1.5"
     }
 }