@reldens/storage 0.53.0 → 0.55.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/prisma/prisma-schema-generator.js

@@ -4,7 +4,7 @@
  *
  */
 
-const { execSync, spawn } = require('child_process');
+const { execSync } = require('child_process');
 const { FileHandler } = require('@reldens/server-utils');
 const { Logger, sc } = require('@reldens/utils');
 
@@ -21,7 +21,7 @@ class PrismaSchemaGenerator
         this.maxWaitTime = sc.get(props, 'maxWaitTime', 30000);
         this.prismaSchemaPath = sc.get(props, 'prismaSchemaPath', FileHandler.joinPaths(process.cwd(), 'prisma'));
         this.schemaFilePath = FileHandler.joinPaths(this.prismaSchemaPath, 'schema.prisma');
-        this.clientOutputPath = sc.get(props, 'clientOutputPath', './prisma/client');
+        this.clientOutputPath = sc.get(props, 'clientOutputPath', '');
         this.generateBinaryTargets = sc.get(props, 'generateBinaryTargets', ['native']);
     }
 
@@ -30,62 +30,41 @@ class PrismaSchemaGenerator
         FileHandler.createFolder(this.prismaSchemaPath);
         this.generateSchemaFile();
         Logger.info('Running prisma introspect "npx prisma db pull"...');
-        execSync('npx prisma db pull', { stdio: 'inherit' });
+        try {
+            execSync('npx prisma db pull', { stdio: 'inherit' });
+        } catch(error) {
+            Logger.critical('Failed to pull database schema: ' + error.message);
+            return false;
+        }
         let generateCommand = 'npx prisma generate';
         if(this.dataProxy){
             generateCommand += ' --data-proxy';
         }
         Logger.info('Running prisma generate "'+generateCommand+'"...');
-        await this.executeWithFallback(generateCommand);
-        await this.waitForSchemaGeneration();
-        return true;
-    }
-
-    async executeWithFallback(command)
-    {
         try {
-            execSync(command, { stdio: 'inherit' });
+            execSync(generateCommand, { stdio: 'inherit' });
         } catch(error) {
-            if(this.isWindowsPermissionError(error)){
-                Logger.warning('Windows permission error detected, retrying with detached process...');
-                await this.executeDetached(command);
-                return;
+            let errorString = error.toString();
+            if(errorString.includes('EPERM') && errorString.includes('query_engine-windows.dll.node')){
+                Logger.warning('Windows permission error detected with query engine file.');
+                Logger.warning('This is a known Prisma issue on Windows.');
+                Logger.warning('Please manually run: ' + generateCommand);
+                Logger.warning('You may need to close any processes using the Prisma client first.');
+                return false;
             }
-            Logger.critical('Command failed: ' + error.message);
+            Logger.critical('Generate command failed: ' + error.message);
             return false;
         }
-    }
-
-    isWindowsPermissionError(error)
-    {
-        return error.message
-            && error.message.includes('EPERM')
-            && error.message.includes('rename')
-            && error.message.includes('query_engine-windows.dll.node');
-    }
-
-    executeDetached(command)
-    {
-        return new Promise((resolve, reject) => {
-            let child = spawn(command, [], {
-                stdio: 'inherit',
-                shell: true,
-                detached: true
-            });
-            child.on('close', (code) => {
-                if(0 === code){
-                    resolve();
-                    return;
-                }
-                reject(new Error('Command failed with exit code ' + code));
-            });
-            child.on('error', reject);
-        });
+        await this.waitForSchemaGeneration();
+        return true;
     }
 
     async waitForSchemaGeneration()
     {
-        let generatedClientPath = FileHandler.joinPaths(this.prismaSchemaPath, this.clientOutputPath);
+        let clientPath = this.clientOutputPath || 'node_modules/.prisma/client';
+        let generatedClientPath = clientPath.startsWith('node_modules') 
+            ? FileHandler.joinPaths(process.cwd(), clientPath)
+            : FileHandler.joinPaths(this.prismaSchemaPath, clientPath);
         let clientIndexPath = FileHandler.joinPaths(generatedClientPath, 'index.js');
         let startTime = Date.now();
         return new Promise((resolve) => {
@@ -160,7 +139,10 @@ class PrismaSchemaGenerator
     {
         let generatorContent = 'generator client {\n';
         generatorContent += '  provider = "prisma-client-js"\n';
-        generatorContent += '  output   = "' + this.clientOutputPath + '"\n';
+        if(this.clientOutputPath){
+            let normalizedPath = this.clientOutputPath.replace(/\\/g, '/');
+            generatorContent += '  output   = "' + normalizedPath + '"\n';
+        }
         if(0 < this.generateBinaryTargets.length){
             generatorContent += '  binaryTargets = [' +
                 this.generateBinaryTargets.map(target => '"' + target + '"').join(', ')

package/package.json

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