@reldens/cms 0.28.0 → 0.30.0

package/lib/installer.js

@@ -4,9 +4,11 @@
  *
  */
 
+const { fork, execSync } = require('child_process');
+const { EntitiesLoader } = require('./entities-loader');
+const { MySQLInstaller } = require('./mysql-installer');
 const { FileHandler, Encryptor } = require('@reldens/server-utils');
 const { DriversMap, DriversClassMap, EntitiesGenerator, PrismaSchemaGenerator } = require('@reldens/storage');
-const { EntitiesLoader } = require('./entities-loader');
 const { Logger, sc } = require('@reldens/utils');
 
 class Installer
@@ -32,11 +34,12 @@ class Installer
         this.defaultTemplatesPath = FileHandler.joinPaths(this.modulePath, 'templates');
         this.moduleAdminPath = FileHandler.joinPaths(this.modulePath, 'admin');
         this.moduleAdminAssetsPath = FileHandler.joinPaths(this.moduleAdminPath, 'assets');
-        this.moduleAdminTemplatesPath = FileHandler.joinPaths(this.moduleAdminPath, 'templates')
+        this.moduleAdminTemplatesPath = FileHandler.joinPaths(this.moduleAdminPath, 'templates');
         this.indexTemplatePath = FileHandler.joinPaths(this.defaultTemplatesPath, 'index.js.dist');
         this.postInstallCallback = sc.get(props, 'postInstallCallback', false);
         this.prismaClient = sc.get(props, 'prismaClient', false);
         this.entitiesLoader = new EntitiesLoader({projectRoot: this.projectRoot});
+        this.subprocessMaxAttempts = sc.get(props, 'subprocessMaxAttempts', 1800);
     }
 
     isInstalled()
@@ -44,22 +47,22 @@ class Installer
         return FileHandler.exists(this.installLockPath);
     }
 
-    async prepareSetup(app, appServer, appServerFactory, renderEngine)
+    async configureAppServerRoutes(app, appServer, appServerFactory, renderEngine)
     {
         if(!app){
-            Logger.error('Missing app on prepareSetup for Installer.');
+            Logger.error('Missing app on configureAppServerRoutes for Installer.');
             return false;
         }
         if(!appServer){
-            Logger.error('Missing appServer on prepareSetup for Installer.');
+            Logger.error('Missing appServer on configureAppServerRoutes for Installer.');
             return false;
         }
         if(!appServerFactory){
-            Logger.error('Missing appServerFactory on prepareSetup for Installer.');
+            Logger.error('Missing appServerFactory on configureAppServerRoutes for Installer.');
             return false;
         }
         if(!renderEngine){
-            Logger.error('Missing renderEngine on prepareSetup for Installer.');
+            Logger.error('Missing renderEngine on configureAppServerRoutes for Installer.');
             return false;
         }
         this.app = app;
@@ -110,6 +113,7 @@ class Installer
     {
         let errorMessages = {
             'invalid-driver': 'Invalid storage driver selected.',
+            'installation-dependencies-failed': 'Required dependencies failed to install.',
             'connection-failed': 'Database connection failed. Please check your credentials.',
             'raw-query-not-found': 'Query method not found in driver.',
             'sql-file-not-found': 'SQL installation file not found.',
@@ -120,6 +124,8 @@ class Installer
             'installation-entities-generation-failed': 'Failed to generate entities.',
             'installation-entities-callback-failed': 'Failed to process entities for callback.',
             'configuration-error': 'Configuration error while completing installation.',
+            'prisma-generation-subprocess-failed': 'Prisma generation subprocess failed.',
+            'temporal-mysql-only-supported': 'Only MySQL is supported at installation time.',
             'already-installed': 'The application is already installed.'
         };
         return sc.get(errorMessages, errorCode, 'An unknown error occurred during installation.');
@@ -130,6 +136,7 @@ class Installer
         if(this.isInstalled()){
             return res.redirect('/?redirect=already-installed');
         }
+        // map database configuration variables:
         let templateVariables = req.body;
         req.session.templateVariables = templateVariables;
         let selectedDriver = templateVariables['db-storage-driver'];
@@ -139,7 +146,7 @@ class Installer
             return res.redirect('/?error=invalid-driver');
         }
         let dbConfig = {
-            client: templateVariables['db-client'],
+            client: sc.get(templateVariables, 'db-client', 'mysql'),
             config: {
                 host: templateVariables['db-host'],
                 port: Number(templateVariables['db-port']),
@@ -150,41 +157,42 @@ class Installer
             },
             debug: false
         };
-        if('prisma' === selectedDriver && this.prismaClient){
-            dbConfig.prismaClient = this.prismaClient;
+        if(!await this.checkAndInstallPackages(['@reldens/cms'])){
+            Logger.error('Required @reldens/cms dependency installation failed.');
+            return res.redirect('/?error=installation-dependencies-failed');
+        }
+        if('prisma' === selectedDriver){
+            if(!await this.checkAndInstallPackages(['@prisma/client'])){
+                Logger.error('Required @prisma/client dependency installation failed.');
+                return res.redirect('/?error=installation-dependencies-failed');
+            }
         }
         let dbDriver = new driverClass(dbConfig);
-        if(!await dbDriver.connect()){
-            Logger.error('Connection failed');
-            return res.redirect('/?error=connection-failed');
-        }
         if(!sc.isObjectFunction(dbDriver, 'rawQuery')){
-            Logger.error('Method "rawQuery" not found.');
+            Logger.error('Method "rawQuery" not found in driver.', driverClass);
             return res.redirect('/?error=raw-query-not-found');
         }
-        let executeFiles = {
-            'install-cms-tables': 'install.sql',
-            'install-user-auth': 'users-authentication.sql',
-            'install-default-user': 'default-user.sql',
-            'install-default-homepage': 'default-homepage.sql',
-            'install-default-blocks': 'default-blocks.sql',
-            'install-entity-access': 'default-entity-access.sql',
-            'install-dynamic-forms': 'default-forms.sql'
-        };
-        for(let checkboxName of Object.keys(executeFiles)){
-            let fileName = executeFiles[checkboxName];
-            let redirectError = await this.executeQueryFile(
-                sc.get(templateVariables, checkboxName, 'off'),
-                fileName,
-                dbDriver
-            );
-            if('' !== redirectError){
-                return res.redirect(redirectError);
+        let queryFilesResult = await this.executeQueryFiles(selectedDriver, dbDriver, dbConfig, templateVariables);
+        if('' !== queryFilesResult){
+            Logger.critical('Invalid query result: ' + queryFilesResult);
+            if('prisma' === selectedDriver){
+                res.redirect('/?'+queryFilesResult);
+                res.on('finish', () => { process.exit(); });
+                return;
             }
+            return res.redirect('/?'+queryFilesResult);
         }
-        let entitiesGenerationResult = await this.generateEntities(dbDriver, false, true);
+        // @IMPORTANT: if the selectedDriver is 'prisma', then at this point the executeQueryFiles already created the
+        // client through the sub-process worker.
+        // Search: FileHandler.joinPaths(this.projectRoot, 'prisma', 'client')
+        let entitiesGenerationResult = await this.generateEntities(dbDriver, false, true, false, dbConfig);
         if(!entitiesGenerationResult){
             Logger.error('Entities generation error.');
+            if('prisma' === selectedDriver){
+                res.redirect('/?error=installation-entities-generation-failed');
+                res.on('finish', () => { process.exit(); });
+                return;
+            }
             return res.redirect('/?error=installation-entities-generation-failed');
         }
         Logger.info('Generated entities.');
@@ -196,15 +204,22 @@ class Installer
             await this.createIndexJsFile(templateVariables);
             if(sc.isFunction(this.postInstallCallback)){
                 if(this.appServer && sc.isFunction(this.appServer.close)){
+                    // @TODO - CHECK IF THIS SHOULD BE REMOVED.
                     await this.appServer.close();
                 }
                 Logger.debug('Running postInstallCallback.');
                 let callbackResult = await this.postInstallCallback({
                     loadedEntities: this.entitiesLoader.loadEntities(selectedDriver),
-                    mappedVariablesForConfig
+                    mappedVariablesForConfig,
+                    dataServer: dbDriver
                 });
                 if(false === callbackResult){
                     Logger.error('Post-install callback failed.');
+                    if('prisma' === selectedDriver){
+                        res.redirect('/?error=installation-entities-callback-failed');
+                        res.on('finish', () => { process.exit(); });
+                        return;
+                    }
                     return res.redirect('/?error=installation-entities-callback-failed');
                 }
             }
@@ -215,43 +230,69 @@ class Installer
             if(successFileContent){
                 successContent = this.renderEngine.render(
                     successFileContent,
-                    {adminPath: templateVariables['app-admin-path']},
+                    {adminPath: templateVariables['app-admin-path']}
                 );
             }
             return res.send(successContent);
         } catch (error) {
             Logger.critical('Configuration error: '+error.message);
-            return res.redirect('/?error=installation-error');
+            if('prisma' === selectedDriver){
+                res.redirect('/?error=configuration-error');
+                res.on('finish', () => { process.exit(); });
+                return;
+            }
+            return res.redirect('/?error=configuration-error');
         }
     }
 
-    async executeQueryFile(isMarked, fileName, dbDriver)
+    async executeQueryFiles(selectedDriver, dbDriver, dbConfig, templateVariables)
     {
-        if('on' !== isMarked){
+        if('prisma' === selectedDriver){
+            let subProcessResult = await this.runSubprocessInstallation(dbConfig, templateVariables);
+            if(!subProcessResult){
+                return 'error=prisma-generation-subprocess-failed';
+            }
             return '';
         }
-        let sqlFileContent = FileHandler.readFile(FileHandler.joinPaths(this.migrationsPath, fileName));
-        if(!sqlFileContent){
-            Logger.error('SQL file "'+fileName+'" not found.');
-            return '/?error=sql-file-not-found&file-name='+fileName;
+        if(!await dbDriver.connect()){
+            Logger.error('Connection failed');
+            return 'error=connection-failed';
         }
-        let queryExecutionResult = await dbDriver.rawQuery(sqlFileContent);
-        if(!queryExecutionResult){
-            Logger.error('SQL file "'+fileName+'" raw execution failed.');
-            return '/?error=sql-file-execution-error&file-name='+fileName;
+        if(-1 === dbConfig.client.indexOf('mysql')){
+            return 'error=temporal-mysql-only-supported';
+        }
+        let migrationFiles = MySQLInstaller.migrationFiles();
+        for(let checkboxName of Object.keys(migrationFiles)){
+            let fileName = migrationFiles[checkboxName];
+            let redirectError = await MySQLInstaller.executeQueryFile(
+                sc.get(templateVariables, checkboxName, 'off'),
+                fileName,
+                dbDriver,
+                this.migrationsPath
+            );
+            if('' !== redirectError){
+                return redirectError;
+            }
         }
-        Logger.info('SQL file "'+fileName+'" raw execution successfully.');
         return '';
     }
 
-    async generateEntities(server, isOverride = false, isInstallationMode = false, isDryPrisma = false)
-    {
+    async generateEntities(
+        server,
+        isOverride = false,
+        isInstallationMode = false,
+        isDryPrisma = false,
+        dbConfig = null
+    ){
         let driverType = sc.get(DriversClassMap, server.constructor.name, '');
         Logger.debug('Driver type detected: '+driverType+', Server constructor: '+server.constructor.name);
-        if('prisma' === driverType && !isInstallationMode && !isDryPrisma){
+        if('prisma' === driverType && !isDryPrisma){
             Logger.info('Running prisma introspect "npx prisma db pull"...');
-            let dbConfig = this.extractDbConfigFromServer(server);
-            Logger.debug('Extracted DB config:', dbConfig);
+            if(!dbConfig){
+                dbConfig = this.extractDbConfigFromServer(server);
+                Logger.debug('Extracted DB config.');
+            }
+            Logger.debug('DB config:', dbConfig);
             if(dbConfig){
                 let generatedPrismaSchema = await this.generatePrismaSchema(dbConfig);
                 if(!generatedPrismaSchema){
@@ -259,16 +300,20 @@ class Installer
                     return false;
                 }
                 Logger.info('Generated Prisma schema for entities generation.');
+                if(isInstallationMode){
+                    Logger.info('Creating local Prisma client for entities generation...');
+                    let localPrismaClient = await MySQLInstaller.createPrismaClient(this.projectRoot);
+                    if(localPrismaClient){
+                        this.prismaClient = localPrismaClient;
+                        server.prisma = localPrismaClient;
+                    }
+                }
             }
         }
         if('prisma' === driverType && isDryPrisma){
             Logger.info('Skipping Prisma schema generation due to --dry-prisma flag.');
         }
-        let generatorConfig = {
-            server,
-            projectPath: this.projectRoot,
-            isOverride
-        };
+        let generatorConfig = {server, projectPath: this.projectRoot, isOverride};
         if('prisma' === driverType && this.prismaClient){
             generatorConfig.prismaClient = this.prismaClient;
         }
@@ -387,8 +432,7 @@ class Installer
         let driverKey = templateVariables['db-storage-driver'];
         let templateParams = {driverKey};
         if('prisma' === driverKey){
-            let prismaClientPath = FileHandler.joinPaths(this.projectRoot, 'prisma', 'client');
-            templateParams.prismaClientImports = 'const { PrismaClient } = require(\'' + prismaClientPath + '\');';
+            templateParams.prismaClientImports = 'const { PrismaClient } = require(\'./prisma/client\');';
             templateParams.prismaClientParam = ',\n    prismaClient: new PrismaClient()';
         }
         if('prisma' !== driverKey){
@@ -425,11 +469,11 @@ class Installer
         FileHandler.copyFolderSync(this.moduleAdminAssetsPath, this.projectPublicAssetsPath);
         FileHandler.copyFile(
             FileHandler.joinPaths(this.moduleAdminPath, 'reldens-admin-client.css'),
-            FileHandler.joinPaths(this.projectCssPath, 'reldens-admin-client.css'),
+            FileHandler.joinPaths(this.projectCssPath, 'reldens-admin-client.css')
         );
         FileHandler.copyFile(
             FileHandler.joinPaths(this.moduleAdminPath, 'reldens-admin-client.js'),
-            FileHandler.joinPaths(this.projectJsPath, 'reldens-admin-client.js'),
+            FileHandler.joinPaths(this.projectJsPath, 'reldens-admin-client.js')
         );
         Logger.info('Admin folder copied to project root.');
         return true;
@@ -460,14 +504,8 @@ class Installer
             FileHandler.joinPaths(this.defaultTemplatesPath, 'layouts', 'default.html'),
             FileHandler.joinPaths(this.projectTemplatesPath, 'layouts', 'default.html')
         );
-        FileHandler.copyFile(
-            FileHandler.joinPaths(this.defaultTemplatesPath, 'css', 'styles.css'),
-            FileHandler.joinPaths(this.projectCssPath, 'styles.css')
-        );
-        FileHandler.copyFile(
-            FileHandler.joinPaths(this.defaultTemplatesPath, 'js', 'scripts.js'),
-            FileHandler.joinPaths(this.projectJsPath, 'scripts.js')
-        );
+        FileHandler.copyFolderSync(FileHandler.joinPaths(this.defaultTemplatesPath, 'css'), this.projectCssPath);
+        FileHandler.copyFolderSync(FileHandler.joinPaths(this.defaultTemplatesPath, 'js'), this.projectJsPath);
         FileHandler.copyFolderSync(
             FileHandler.joinPaths(this.defaultTemplatesPath, 'partials'),
             FileHandler.joinPaths(this.projectTemplatesPath, 'partials')
@@ -476,6 +514,10 @@ class Installer
             FileHandler.joinPaths(this.defaultTemplatesPath, 'domains'),
             FileHandler.joinPaths(this.projectTemplatesPath, 'domains')
         );
+        FileHandler.copyFolderSync(
+            FileHandler.joinPaths(this.defaultTemplatesPath, 'assets'),
+            this.projectPublicAssetsPath
+        );
         return true;
     }
 
@@ -495,6 +537,100 @@ class Installer
             'db-password': process.env.RELDENS_DB_PASSWORD || ''
         };
     }
+
+    async checkAndInstallPackages(requiredPackages)
+    {
+        let missingPackages = [];
+        for(let packageName of requiredPackages){
+            let packagePath = FileHandler.joinPaths(this.projectRoot, 'node_modules', packageName);
+            if(!FileHandler.exists(packagePath)){
+                missingPackages.push(packageName);
+            }
+        }
+        if(0 === missingPackages.length){
+            return true;
+        }
+        Logger.info('Missing required packages: ' + missingPackages.join(', '));
+        Logger.info('These packages are required for the CMS to function properly.');
+        Logger.info('Would you like to install them automatically? (This may take a few minutes)');
+        Logger.info('Installing packages: npm install ' + missingPackages.join(' '));
+        try {
+            let installCommand = 'npm install ' + missingPackages.join(' ');
+            execSync(installCommand, {stdio: 'inherit', cwd: this.projectRoot});
+            Logger.info('Dependencies installed successfully.');
+            return true;
+        } catch (error) {
+            Logger.error('Failed to install dependencies: ' + error.message);
+            Logger.error('Please run manually: npm install ' + missingPackages.join(' '));
+            return false;
+        }
+    }
+
+    async runSubprocessInstallation(dbConfig, templateVariables)
+    {
+        Logger.info('Subprocess Prisma installation - Starting...');
+        let workerPath = FileHandler.joinPaths(__dirname, 'prisma-subprocess-worker.js');
+        let worker = fork(workerPath, [], {
+            cwd: this.projectRoot,
+            stdio: ['pipe', 'pipe', 'pipe', 'ipc'],
+            env: {...process.env}
+        });
+        let message = {
+            dbConfig: dbConfig,
+            templateVariables: templateVariables,
+            migrationsPath: this.migrationsPath,
+            projectRoot: this.projectRoot
+        };
+        worker.stdout.on('data', (data) => {
+            Logger.info('Subprocess: '+data.toString().trim());
+        });
+        worker.stderr.on('data', (data) => {
+            Logger.error('Subprocess error: '+data.toString().trim());
+        });
+        worker.send(message);
+        let subprocessCompleted = false;
+        let subprocessSuccess = false;
+        let workerExited = false;
+        worker.on('message', (message) => {
+            subprocessCompleted = true;
+            subprocessSuccess = sc.get(message, 'success', false);
+            if(!subprocessSuccess){
+                Logger.error('Subprocess failed: '+sc.get(message, 'error', 'Unknown'));
+            }
+        });
+        worker.on('error', (error) => {
+            subprocessCompleted = true;
+            subprocessSuccess = false;
+            Logger.error('Subprocess error: '+error.message);
+        });
+        worker.on('exit', (code, signal) => {
+            workerExited = true;
+            if(!subprocessCompleted){
+                subprocessCompleted = true;
+                subprocessSuccess = false;
+            }
+        });
+        let attempts = 0;
+        while(!subprocessCompleted && attempts < this.subprocessMaxAttempts){
+            attempts++;
+            await this.waitMilliseconds(100);
+        }
+        if(!workerExited){
+            worker.kill('SIGTERM');
+            await this.waitMilliseconds(1000);
+            if(!workerExited){
+                worker.kill('SIGKILL');
+            }
+        }
+        Logger.info('Subprocess Prisma installation - Ended.');
+        return subprocessSuccess;
+    }
+
+    async waitMilliseconds(ms)
+    {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+
 }
 
 module.exports.Installer = Installer;

package/lib/manager.js

@@ -75,10 +75,9 @@ class Manager
         this.frontend = sc.get(props, 'frontend', false);
         this.renderEngine = sc.get(props, 'renderEngine', mustache);
         this.prismaClient = sc.get(props, 'prismaClient', false);
-        this.defaultDevelopmentPatterns = ['localhost', '127.0.0.1', '.local', '.test', '.dev'];
-        this.developmentPatterns = sc.get(props, 'developmentPatterns', this.defaultDevelopmentPatterns);
-        this.developmentEnvironments = sc.get(props, 'developmentEnvironments', ['development', 'dev', 'test']);
-        this.developmentPorts = sc.get(props, 'developmentPorts', [3000, 8080, 8081]);
+        this.developmentPatterns = sc.get(props, 'developmentPatterns', []);
+        this.developmentEnvironments = sc.get(props, 'developmentEnvironments', []);
+        this.developmentPorts = sc.get(props, 'developmentPorts', []);
         this.developmentMultiplier = sc.get(props, 'developmentMultiplier', 10);
         this.appServerConfig = sc.get(props, 'appServerConfig', {});
         this.developmentExternalDomains = sc.get(props, 'developmentExternalDomains', {});
@@ -207,7 +206,12 @@ class Manager
         }
         if(!this.isInstalled()){
             Logger.info('CMS not installed, preparing setup');
-            await this.installer.prepareSetup(this.app, this.appServer, this.appServerFactory, this.renderEngine);
+            await this.installer.configureAppServerRoutes(
+                this.app,
+                this.appServer,
+                this.appServerFactory,
+                this.renderEngine
+            );
             if(!this.useProvidedServer){
                 await this.appServer.listen(this.config.port);
             }
@@ -226,9 +230,14 @@ class Manager
 
     buildAppServerConfiguration()
     {
+        let useHelmet = true;
+        if(!this.isInstalled()){
+            useHelmet = false;
+        }
         let baseConfig = {
             port: this.config.port,
-            useHttps: this.config.host.startsWith('https://'),
+            useHttps: this.determineHttpsUsage(),
+            useHelmet,
             domainMapping: this.domainMapping || {},
             defaultDomain: this.defaultDomain,
             developmentPatterns: this.developmentPatterns,
@@ -248,14 +257,37 @@ class Manager
         return appServerConfig;
     }
 
+    determineHttpsUsage()
+    {
+        if(this.config.publicUrl && this.config.publicUrl.startsWith('https://')){
+            return true;
+        }
+        return this.config.host.startsWith('https://');
+    }
+
     async initializeCmsAfterInstall(props)
     {
         try {
+            this.config = props.mappedVariablesForConfig;
+            let appServerConfig = this.buildAppServerConfiguration();
+            Object.assign(this.appServerFactory, appServerConfig);
+            this.appServerFactory.addHttpDomainsAsDevelopment();
+            this.appServerFactory.detectDevelopmentMode();
+            this.appServerFactory.setupSecurity();
+            //Logger.debug('Development mode installation: '+this.appServerFactory.isDevelopmentMode);
             this.rawRegisteredEntities = props.loadedEntities.rawRegisteredEntities;
             this.entitiesTranslations = props.loadedEntities.entitiesTranslations;
             this.entitiesConfig = props.loadedEntities.entitiesConfig;
             this.config = props.mappedVariablesForConfig;
-            await this.initializeServices();
+            if(props.dataServer){
+                this.dataServer = props.dataServer;
+                this.useProvidedDataServer = true;
+            }
+            let servicesResult = await this.initializeServices();
+            if(!servicesResult){
+                Logger.critical('Failed to initialize services after installation.');
+                return false;
+            }
             Logger.info('CMS initialized after installation on '+this.config.host+':'+this.config.port);
             return true;
         } catch (error) {
@@ -357,7 +389,8 @@ class Manager
             this.dataServer.entityManager.entities
         );
         if(0 === Object.keys(this.adminEntities).length){
-            Logger.warning('Admin entities not found.');
+            Logger.critical('Admin entities generation failed - no entities available.');
+            Logger.critical('CMS cannot start without admin entities.');
             return false;
         }
         return true;

package/lib/mysql-installer.js

@@ -0,0 +1,92 @@
+/**
+ *
+ * Reldens - CMS - MySQLInstaller
+ *
+ */
+
+const { execSync } = require('child_process');
+const { FileHandler } = require('@reldens/server-utils');
+const { Logger } = require('@reldens/utils');
+
+class MySQLInstaller
+{
+
+    static migrationFiles()
+    {
+        return {
+            'install-cms-tables': 'install.sql',
+            'install-user-auth': 'users-authentication.sql',
+            'install-default-user': 'default-user.sql',
+            'install-default-homepage': 'default-homepage.sql',
+            'install-default-blocks': 'default-blocks.sql',
+            'install-entity-access': 'default-entity-access.sql',
+            'install-dynamic-forms': 'default-forms.sql'
+        };
+    }
+
+    static async executeQueryFile(isMarked, fileName, dbDriver, migrationsPath)
+    {
+        if('on' !== isMarked){
+            return '';
+        }
+        let sqlFileContent = FileHandler.readFile(FileHandler.joinPaths(migrationsPath, fileName));
+        if(!sqlFileContent){
+            Logger.error('SQL file "'+fileName+'" not found.');
+            return '/?error=sql-file-not-found&file-name='+fileName;
+        }
+        let queryExecutionResult = await dbDriver.rawQuery(sqlFileContent);
+        if(!queryExecutionResult){
+            Logger.error('SQL file "'+fileName+'" raw execution failed.');
+            return '/?error=sql-file-execution-error&file-name='+fileName;
+        }
+        Logger.info('SQL file "'+fileName+'" raw execution successfully.');
+        return '';
+    }
+
+    static async generateMinimalPrismaClient(dbConfig, projectRoot)
+    {
+        let prismaPath = FileHandler.joinPaths(projectRoot, 'prisma');
+        let schemaPath = FileHandler.joinPaths(prismaPath, 'schema.prisma');
+        FileHandler.createFolder(prismaPath);
+        let schemaContent = 'generator client {\n'
+            + '  provider = "prisma-client-js"\n'
+            + '  output = "./client"\n'
+            + '}\n'
+            + '\n'
+            + 'datasource db {\n'
+            + '  provider = "' + dbConfig.client + '"\n'
+            + '  url = env("RELDENS_DB_URL")\n'
+            + '}';
+        FileHandler.writeFile(schemaPath, schemaContent);
+        Logger.info('Running prisma generate...');
+        try {
+            execSync('npx prisma generate', { stdio: 'inherit', cwd: projectRoot });
+            let clientPath = FileHandler.joinPaths(projectRoot, 'prisma', 'client');
+            let { PrismaClient } = require(clientPath);
+            return new PrismaClient();
+        } catch(error) {
+            Logger.error('Prisma generate failed: '+error.message);
+            return false;
+        }
+    }
+
+    static async createPrismaClient(projectRoot)
+    {
+        try {
+            let clientPath = FileHandler.joinPaths(projectRoot, 'prisma', 'client');
+            if(!FileHandler.exists(clientPath)){
+                return false;
+            }
+            const { PrismaClient } = require(clientPath);
+            let client = new PrismaClient();
+            await client.$connect();
+            return client;
+        } catch(error){
+            Logger.error('Prisma client creation failed: '+error.message);
+            return false;
+        }
+    }
+
+}
+
+module.exports.MySQLInstaller = MySQLInstaller;