@reldens/storage 0.54.0 → 0.56.0

package/lib/generators/models-generation.js

@@ -0,0 +1,173 @@
+/**
+ *
+ * Reldens - ModelsGeneration
+ *
+ */
+
+const { FileHandler } = require('@reldens/server-utils');
+const { Logger, sc } = require('@reldens/utils');
+const { TypeMapper } = require('../type-mapper');
+const { BaseGenerator } = require('./base-generator');
+
+class ModelsGeneration extends BaseGenerator
+{
+
+    constructor(props)
+    {
+        super();
+        this.modelsFolder = sc.get(props, 'modelsFolder', '');
+        this.templates = sc.get(props, 'templates', {});
+        this.generatedModels = {};
+    }
+
+    async generateModelFile(tableName, tableData, driverKey, entityInfo)
+    {
+        let modelTemplatePath = this.templates[driverKey];
+        if(!FileHandler.exists(modelTemplatePath)){
+            Logger.critical('Model template file "'+modelTemplatePath+'" not found for driver "'+driverKey+'".');
+            return false;
+        }
+        let modelTemplateContent = FileHandler.fetchFileContents(modelTemplatePath);
+        if(!modelTemplateContent){
+            Logger.critical('Failed to read model template file: '+modelTemplatePath);
+            return false;
+        }
+        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: 'prisma' === driverKey ? tableName.toLowerCase() : 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);
+        FileHandler.createFolder(driverFolder);
+        let filePath = FileHandler.joinPaths(driverFolder, fileName);
+        if(!FileHandler.writeFile(filePath, modelContent)){
+            Logger.critical('Failed to write model file: '+fileName);
+            return false;
+        }
+        Logger.info('Generated model file: '+fileName);
+        this.generatedModels[tableName] = {
+            modelClassName,
+            modelFileName: fileName,
+            driverKey
+        };
+        return true;
+    }
+
+    getEntityPropertiesDefinition(columns, driverKey)
+    {
+        if('mikro-orm' === driverKey){
+            let entityProps = [];
+            for(let columnName of Object.keys(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        ');
+        }
+        if('prisma' === driverKey){
+            let prismaProps = [];
+            for(let columnName of Object.keys(columns)){
+                let column = columns[columnName];
+                let prismaType = TypeMapper.mapDbTypeToPrismaType(column.type);
+                let isPrimary = 'PRI' === column.key;
+                let propDef = columnName+': {\n            type: \''+prismaType+'\'';
+                if(isPrimary){
+                    propDef += ',\n            id: true';
+                }
+                if(column.nullable){
+                    propDef += ',\n            optional: true';
+                }
+                propDef += '\n        }';
+                prismaProps.push(propDef);
+            }
+            return prismaProps.join(',\n        ');
+        }
+        return '';
+    }
+
+    generateRegisteredModelsFile(entitiesInfo, existingModels, driverKey, templatePath)
+    {
+        if(!FileHandler.exists(templatePath)){
+            Logger.critical('Registered models template file not found: '+templatePath);
+            return false;
+        }
+        let registeredTemplateContent = FileHandler.fetchFileContents(templatePath);
+        if(!registeredTemplateContent){
+            Logger.critical('Failed to read registered models template file: '+templatePath);
+            return false;
+        }
+        let allEntities = Object.assign({}, entitiesInfo);
+        let replacements = {
+            registeredModels: this.getRegisteredModels(allEntities, existingModels, driverKey),
+            registeredEntitiesObject: this.getRegisteredEntitiesObject(allEntities, existingModels, driverKey)
+        };
+        let registeredContent = this.applyReplacements(registeredTemplateContent, replacements);
+        let driverFolder = FileHandler.joinPaths(this.modelsFolder, driverKey);
+        let filePath = FileHandler.joinPaths(driverFolder, 'registered-models-'+driverKey+'.js');
+        if(!FileHandler.writeFile(filePath, registeredContent)){
+            Logger.critical('Failed to write registered models file: '+filePath);
+            return false;
+        }
+        Logger.info('Generated registered models file: '+filePath);
+        return true;
+    }
+
+    getRegisteredModels(allEntities, existingModels, driverKey)
+    {
+        let registeredModels = [];
+        for(let tableName of Object.keys(allEntities)){
+            let entity = allEntities[tableName];
+            if(entity.driverKey && driverKey !== entity.driverKey){
+                if(!existingModels[tableName] || !existingModels[tableName][driverKey]){
+                    continue;
+                }
+            }
+            let modelClassName = entity.modelClassName || sc.capitalizedCamelCase(tableName)+'Model';
+            let modelFileName = entity.modelFileName || sc.kebabCase(tableName)+'-model.js';
+            registeredModels.push(
+                'const { '+modelClassName+' } = require(\'./'+modelFileName.replace('.js', '')+'\');'
+            );
+        }
+        return registeredModels.join('\n');
+    }
+
+    getRegisteredEntitiesObject(allEntities, existingModels, driverKey)
+    {
+        let registeredEntitiesObject = [];
+        for(let tableName of Object.keys(allEntities)){
+            let entity = allEntities[tableName];
+            if(entity.driverKey && driverKey !== entity.driverKey){
+                if(!existingModels[tableName] || !existingModels[tableName][driverKey]){
+                    continue;
+                }
+            }
+            let modelClassName = entity.modelClassName || sc.capitalizedCamelCase(tableName)+'Model';
+            registeredEntitiesObject.push(sc.camelCase(tableName)+': '+modelClassName);
+        }
+        return registeredEntitiesObject.join(',\n    ');
+    }
+
+}
+
+module.exports.ModelsGeneration = ModelsGeneration;

package/lib/mysql-tables-provider.js

@@ -15,7 +15,7 @@ class MySQLTablesProvider
             '    TABLE_NAME, ' +
             '    COLUMN_NAME, ' +
             '    DATA_TYPE, ' +
-            '    CHARACTER_MAXIMUM_LENGTH, ' +
+            '    CAST(CHARACTER_MAXIMUM_LENGTH AS CHAR) as CHARACTER_MAXIMUM_LENGTH, ' +
             '    COLUMN_TYPE, ' +
             '    IS_NULLABLE, ' +
             '    COLUMN_KEY, ' +

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

@@ -8,7 +8,7 @@ const { BaseDataServer } = require('../base-data-server');
 const { PrismaDriver } = require('./prisma-driver');
 const { MySQLTablesProvider } = require('../mysql-tables-provider');
 const { PrismaClient } = require('@prisma/client');
-const { Logger } = require('@reldens/utils');
+const { Logger, sc } = require('@reldens/utils');
 
 class PrismaDataServer extends BaseDataServer
 {
@@ -16,7 +16,7 @@ class PrismaDataServer extends BaseDataServer
     constructor(props)
     {
         super(props);
-        this.prisma = false;
+        this.prisma = sc.get(props, 'prismaClient', false);
     }
 
     async connect()
@@ -25,10 +25,15 @@ class PrismaDataServer extends BaseDataServer
             return this.initialized;
         }
         try {
-            this.prisma = new PrismaClient({
-                log: this.debug ? ['query', 'info', 'warn', 'error'] : ['error']
-            });
+            if(!this.prisma){
+                this.prisma = new PrismaClient({
+                    datasources: {db: {url: this.connectString}},
+                    log: this.debug ? ['query', 'info', 'warn', 'error'] : ['error']
+                });
+            }
             await this.prisma.$connect();
+            let dbTest = await this.prisma.$queryRaw`SELECT DATABASE() as current_db`;
+            Logger.info('Connected to database: ' + dbTest[0].current_db);
             this.initialized = Date.now();
             return this.initialized;
         } catch(error) {
@@ -86,7 +91,9 @@ class PrismaDataServer extends BaseDataServer
                     continue;
                 }
                 try {
-                    results.push(await this.executeStatement(cleanStatement));
+                    let result = await this.executeStatement(cleanStatement);
+                    results.push(result);
+                    Logger.debug('Statement executed, result: ' + JSON.stringify(result));
                 } catch(stmtError) {
                     Logger.error('Statement "'+cleanStatement+'" execution failed: '+stmtError.message);
                     return false;
@@ -109,7 +116,11 @@ class PrismaDataServer extends BaseDataServer
         if(trimmedStatement.startsWith('SELECT')){
             return await this.prisma.$queryRawUnsafe(statement);
         }
+        if(trimmedStatement.startsWith('SHOW')){
+            return await this.prisma.$queryRawUnsafe(statement);
+        }
         let result = await this.prisma.$executeRawUnsafe(statement);
+        Logger.debug('Raw result from Prisma: ' + result);
         if(
             trimmedStatement.startsWith('CREATE')
             || trimmedStatement.startsWith('ALTER')

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@reldens/storage",
     "scope": "@reldens",
-    "version": "0.54.0",
+    "version": "0.56.0",
     "description": "Reldens - Storage",
     "author": "Damian A. Pastorini",
     "license": "MIT",