@reldens/storage 0.117.0 → 0.119.0

package/tests/utils/reldens-schema-loader.js

@@ -0,0 +1,274 @@
+/**
+ *
+ * Reldens - ReldensSchemaLoader
+ *
+ */
+
+const { TestHelpers } = require('./test-helpers');
+const { Logger, sc } = require('@reldens/utils');
+const { FileHandler } = require('@reldens/server-utils');
+
+class ReldensSchemaLoader
+{
+
+    static migrationsPath()
+    {
+        return process.env.RELDENS_TEST_MIGRATIONS_PATH || '';
+    }
+
+    static sqlFileNames()
+    {
+        return ['reldens-install-v4.0.0.sql', 'reldens-basic-config-v4.0.0.sql', 'reldens-sample-data-v4.0.0.sql'];
+    }
+
+    static isAvailable()
+    {
+        let migrationsPath = this.migrationsPath();
+        if('' === migrationsPath){
+            return false;
+        }
+        for(let fileName of this.sqlFileNames()){
+            if(!FileHandler.exists(FileHandler.joinPaths(migrationsPath, fileName))){
+                Logger.warning('Reldens schema file not found: '+fileName);
+                return false;
+            }
+        }
+        return true;
+    }
+
+    static databaseName()
+    {
+        return process.env.RELDENS_TEST_RELDENS_DB_NAME || 'reldens_storage_test_full';
+    }
+
+    static generationPath()
+    {
+        return FileHandler.joinPaths(process.cwd(), 'tests', 'generated-reldens-schema');
+    }
+
+    static async ensureDatabase()
+    {
+        let BootstrapServerClass = TestHelpers.getDataServerClass('knex');
+        if(!BootstrapServerClass){
+            Logger.critical('Reldens schema bootstrap data server class not found.');
+            return false;
+        }
+        let bootstrapServer = new BootstrapServerClass({
+            client: TestHelpers.driverClient('knex'),
+            config: {...TestHelpers.getTestDbConfig(), multipleStatements: true},
+            rawEntities: {},
+            multipleStatements: true,
+            poolConfig: {min: 0, max: 2}
+        });
+        await bootstrapServer.connect();
+        if(!bootstrapServer.initialized){
+            Logger.critical('Reldens schema bootstrap connection failed.');
+            return false;
+        }
+        await TestHelpers.executeRawSQL(bootstrapServer, 'DROP DATABASE IF EXISTS '+this.databaseName()+';');
+        await TestHelpers.executeRawSQL(bootstrapServer, 'CREATE DATABASE '+this.databaseName()+';');
+        await bootstrapServer.disconnect();
+        Logger.info('Reldens schema database is ready: '+this.databaseName());
+        return true;
+    }
+
+    static async regeneratedPrismaModules(config)
+    {
+        let prismaConfig = Object.assign({}, config, {client: 'mysql'});
+        if(!await TestHelpers.generatePrismaSchema(prismaConfig)){
+            Logger.critical('Reldens schema Prisma schema generation failed.');
+            return false;
+        }
+        if(!await TestHelpers.generatePrismaClient()){
+            Logger.critical('Reldens schema Prisma client generation failed.');
+            return false;
+        }
+        delete require.cache[require.resolve(FileHandler.joinPaths(process.cwd(), 'prisma', 'client'))];
+        return await TestHelpers.loadPrismaModules(process.cwd(), config);
+    }
+
+    static async refreshPrismaClient(dataServer, driverName)
+    {
+        if('prisma' !== driverName){
+            return true;
+        }
+        let config = TestHelpers.getTestDbConfig();
+        config.database = this.databaseName();
+        let prismaModules = await this.regeneratedPrismaModules(config);
+        if(!prismaModules){
+            return false;
+        }
+        await dataServer.disconnect();
+        dataServer.prismaModules = prismaModules;
+        dataServer.prisma = prismaModules.client;
+        dataServer.initialized = Date.now();
+        return true;
+    }
+
+    static async setupDataServer(driverName)
+    {
+        let DataServerClass = TestHelpers.getDataServerClass(driverName);
+        if(!DataServerClass){
+            Logger.critical('Reldens schema data server class not found for '+driverName);
+            return false;
+        }
+        let config = TestHelpers.getTestDbConfig();
+        config.database = this.databaseName();
+        let serverConfig = {
+            client: TestHelpers.driverClient(driverName),
+            config: {...config, multipleStatements: true},
+            rawEntities: {},
+            multipleStatements: true,
+            poolConfig: {min: 0, max: 2}
+        };
+        TestHelpers.appendDriverModules(serverConfig, driverName);
+        if('prisma' === driverName){
+            serverConfig.prismaModules = await TestHelpers.loadPrismaModules(process.cwd(), config);
+            if(!serverConfig.prismaModules){
+                return false;
+            }
+        }
+        let dataServer = new DataServerClass(serverConfig);
+        await dataServer.connect();
+        if(!dataServer.initialized){
+            Logger.critical('Reldens schema data server failed to initialize for '+driverName);
+            return false;
+        }
+        return dataServer;
+    }
+
+    static async loadSchemaAndData(dataServer)
+    {
+        for(let fileName of this.sqlFileNames()){
+            let sql = FileHandler.readFile(FileHandler.joinPaths(this.migrationsPath(), fileName));
+            if(!sql){
+                Logger.critical('Could not read reldens schema file: '+fileName);
+                return false;
+            }
+            await TestHelpers.executeRawSQL(dataServer, sql);
+            Logger.info('Loaded reldens schema file: '+fileName);
+        }
+        return true;
+    }
+
+    static async generateEntities(dataServer, driverName)
+    {
+        let { EntitiesGenerator } = require('../../lib/entities-generator');
+        let config = TestHelpers.getTestDbConfig();
+        let generator = new EntitiesGenerator({
+            connectionData: {
+                driver: driverName,
+                client: TestHelpers.driverClient(driverName),
+                user: config.user,
+                password: config.password,
+                host: config.host,
+                database: this.databaseName(),
+                port: config.port
+            },
+            projectPath: this.generationPath(),
+            isOverride: true,
+            server: dataServer
+        });
+        if(!await generator.generate()){
+            Logger.critical('Reldens schema entities generation failed for '+driverName);
+            return false;
+        }
+        return this.fixGeneratedRequirePaths(driverName);
+    }
+
+    static modelsFolderDepth = 5;
+
+    static entitiesFolderDepth = 4;
+
+    static packageRequirePath(folderDepth)
+    {
+        return '..'+'/..'.repeat(folderDepth - 1)+'/index';
+    }
+
+    static fixGeneratedRequirePaths(driverName)
+    {
+        let modelsFolder = FileHandler.joinPaths(this.generationPath(), 'generated-entities', 'models', driverName);
+        if(!this.replacePackageRequire(modelsFolder, this.packageRequirePath(this.modelsFolderDepth))){
+            return false;
+        }
+        return this.replacePackageRequire(
+            FileHandler.joinPaths(this.generationPath(), 'generated-entities', 'entities'),
+            this.packageRequirePath(this.entitiesFolderDepth)
+        );
+    }
+
+    static replacePackageRequire(folderPath, packagePath)
+    {
+        let fileNames = FileHandler.getFilesInFolder(folderPath, ['.js']);
+        if(!sc.isArray(fileNames) || 0 === fileNames.length){
+            Logger.critical('No reldens schema files were generated at: '+folderPath);
+            return false;
+        }
+        for(let fileName of fileNames){
+            let filePath = FileHandler.joinPaths(folderPath, fileName);
+            let content = FileHandler.readFile(filePath);
+            FileHandler.writeFile(
+                filePath,
+                content.replace("require('@reldens/storage')", "require('"+packagePath+"')")
+            );
+        }
+        Logger.info('Fixed the require paths on '+fileNames.length+' reldens schema files at: '+folderPath);
+        return true;
+    }
+
+    static async loadEntities(dataServer, driverName)
+    {
+        let modelsFolder = FileHandler.joinPaths(this.generationPath(), 'generated-entities', 'models', driverName);
+        let modelsPath = FileHandler.joinPaths(modelsFolder, 'registered-models-'+driverName+'.js');
+        if(!FileHandler.exists(modelsPath)){
+            Logger.critical('Reldens schema registered models not found: '+modelsPath);
+            return false;
+        }
+        dataServer.rawEntities = require(modelsPath).rawRegisteredEntities;
+        if('mikro-orm' === driverName){
+            await dataServer.disconnect();
+            await dataServer.connect();
+        }
+        dataServer.generateEntities();
+        if(0 === Object.keys(dataServer.entities).length){
+            Logger.critical('No reldens schema entities generated for '+driverName);
+            return false;
+        }
+        Logger.info('Loaded '+Object.keys(dataServer.entities).length+' reldens schema entities for '+driverName);
+        return true;
+    }
+
+    static async setup(driverName)
+    {
+        if(!await this.ensureDatabase()){
+            return false;
+        }
+        let dataServer = await this.setupDataServer(driverName);
+        if(!dataServer){
+            return false;
+        }
+        if(!await this.loadSchemaAndData(dataServer)){
+            return false;
+        }
+        if(!await this.refreshPrismaClient(dataServer, driverName)){
+            return false;
+        }
+        if(!await this.generateEntities(dataServer, driverName)){
+            return false;
+        }
+        if(!await this.loadEntities(dataServer, driverName)){
+            return false;
+        }
+        return dataServer;
+    }
+
+    static async teardown(dataServer)
+    {
+        await TestHelpers.teardownDriver(dataServer);
+        FileHandler.remove(this.generationPath());
+        return true;
+    }
+
+}
+
+module.exports.ReldensSchemaLoader = ReldensSchemaLoader;

package/tests/utils/test-helpers.js

@@ -5,6 +5,11 @@
  */
 
 const { FileHandler } = require('@reldens/server-utils');
+const { KyselyModulesLoader } = require('../../lib/kysely/kysely-modules-loader');
+const { DrizzleModulesLoader } = require('../../lib/drizzle/drizzle-modules-loader');
+const { MikroOrmModulesLoader } = require('../../lib/mikro-orm/mikro-orm-modules-loader');
+const { ObjectionModulesLoader } = require('../../lib/objection-js/objection-modules-loader');
+const { KnexModulesLoader } = require('../../lib/knex/knex-modules-loader');
 const { Logger, sc } = require('@reldens/utils');
 const { exec, execSync } = require('child_process');
 const { promisify } = require('util');
@@ -22,7 +27,8 @@ class TestHelpers
             user: process.env.RELDENS_TEST_DB_USER || 'test_user',
             password: process.env.RELDENS_TEST_DB_PASSWORD || 'test_password',
             database: process.env.RELDENS_TEST_DB_NAME || 'reldens_storage_test',
-            client: process.env.RELDENS_TEST_DB_CLIENT || 'mysql'
+            client: process.env.RELDENS_TEST_DB_CLIENT || 'mysql',
+            connectionLimit: Number(process.env.RELDENS_TEST_DB_CONNECTION_LIMIT || 2)
         };
     }
 
@@ -41,10 +47,11 @@ class TestHelpers
                 }
             }
             let serverConfig = {
-                client: driverName === 'objection-js' ? 'mysql2' : 'mysql',
+                client: this.driverClient(driverName),
                 config: {...config, multipleStatements: true},
                 rawEntities: rawEntities,
-                multipleStatements: true
+                multipleStatements: true,
+                poolConfig: {min: 0, max: 2}
             };
             if('prisma' === driverName){
                 let prismaModules = await this.loadPrismaModules(process.cwd(), config);
@@ -53,6 +60,7 @@ class TestHelpers
                 }
                 serverConfig.prismaModules = prismaModules;
             }
+            this.appendDriverModules(serverConfig, driverName);
             let DataServerClass = this.getDataServerClass(driverName);
             let dataServer = new DataServerClass(serverConfig);
             let connected = await dataServer.connect();
@@ -81,16 +89,67 @@ class TestHelpers
             let { PrismaDataServer } = require('../../lib/prisma/prisma-data-server');
             return PrismaDataServer;
         }
+        if('knex' === driverName){
+            let { KnexDataServer } = require('../../lib/knex/knex-data-server');
+            return KnexDataServer;
+        }
+        if('kysely' === driverName){
+            let { KyselyDataServer } = require('../../lib/kysely/kysely-data-server');
+            return KyselyDataServer;
+        }
+        if('drizzle' === driverName){
+            let { DrizzleDataServer } = require('../../lib/drizzle/drizzle-data-server');
+            return DrizzleDataServer;
+        }
         Logger.critical('Unknown driver: '+driverName);
         return false;
     }
 
+    static driverClient(driverName)
+    {
+        if('objection-js' === driverName){
+            return 'mysql2';
+        }
+        if('knex' === driverName){
+            return 'mysql2';
+        }
+        return 'mysql';
+    }
+
+    static appendDriverModules(serverConfig, driverName)
+    {
+        this.registerNpmGlobalPaths();
+        if('kysely' === driverName){
+            serverConfig.kyselyModules = KyselyModulesLoader.load(false);
+            return serverConfig;
+        }
+        if('drizzle' === driverName){
+            serverConfig.drizzleModules = DrizzleModulesLoader.load(false);
+            return serverConfig;
+        }
+        if('mikro-orm' === driverName){
+            serverConfig.mikroOrmModules = MikroOrmModulesLoader.load(false, serverConfig.client);
+            return serverConfig;
+        }
+        if('objection-js' === driverName){
+            serverConfig.objectionModules = ObjectionModulesLoader.load(false);
+            return serverConfig;
+        }
+        if('knex' === driverName){
+            serverConfig.knexModules = KnexModulesLoader.load(false);
+        }
+        return serverConfig;
+    }
+
     static async teardownDriver(dataServer)
     {
         if(!dataServer){
             return;
         }
         try {
+            if(dataServer.db){
+                await dataServer.disconnect();
+            }
             if(dataServer.knex){
                 await dataServer.knex.destroy();
             }
@@ -294,14 +353,16 @@ class TestHelpers
     static verifyAllPackages()
     {
         let required = [
-            {name: '@mikro-orm/core', version: '7.2.0'},
-            {name: '@mikro-orm/mongodb', version: '7.2.0'},
-            {name: '@mikro-orm/mysql', version: '7.2.0'},
             {name: 'knex', version: '3.3.0'},
-            {name: 'mysql', version: '2.18.1'},
-            {name: 'mysql2', version: '3.24.3'},
-            {name: 'objection', version: '3.1.5'}
+            {name: 'mysql2', version: '3.24.4'}
         ];
+        if(this.isObjectionFlagEnabled()){
+            required.push({name: 'objection', version: '3.1.5', optional: true});
+        }
+        if(this.isMikroOrmFlagEnabled()){
+            required.push({name: '@mikro-orm/core', version: '7.2.0', optional: true});
+            required.push({name: '@mikro-orm/mysql', version: '7.2.0', optional: true});
+        }
         if(this.isPrismaFlagEnabled()){
             required.push({name: 'prisma', version: '7.9.1', optional: true});
             required.push({name: '@prisma/client', version: '7.9.1', optional: true});
@@ -361,7 +422,11 @@ class TestHelpers
             Logger.warning('Could not resolve the npm global root: '+error.message);
             return '';
         }
-        let extraPaths = [globalRoot, FileHandler.joinPaths(globalRoot, '@prisma', 'client', 'node_modules')];
+        let extraPaths = [
+            globalRoot,
+            FileHandler.joinPaths(globalRoot, '@prisma', 'client', 'node_modules'),
+            FileHandler.joinPaths(process.cwd(), 'node_modules')
+        ];
         let currentPaths = process.env.NODE_PATH ? process.env.NODE_PATH.split(delimiter) : [];
         process.env.NODE_PATH = [...currentPaths, ...extraPaths].join(delimiter);
         NodeModule._initPaths();
@@ -383,12 +448,66 @@ class TestHelpers
         return this.isPrismaAvailable();
     }
 
+    static isObjectionFlagEnabled()
+    {
+        return '1' === String(process.env.RELDENS_TEST_OBJECTION_ENABLED);
+    }
+
+    static isObjectionEnabled()
+    {
+        if(!this.isObjectionFlagEnabled()){
+            return false;
+        }
+        return this.canResolvePackage('objection');
+    }
+
+    static isMikroOrmFlagEnabled()
+    {
+        return '1' === String(process.env.RELDENS_TEST_MIKRO_ORM_ENABLED);
+    }
+
+    static isMikroOrmEnabled()
+    {
+        if(!this.isMikroOrmFlagEnabled()){
+            return false;
+        }
+        return this.canResolvePackage('@mikro-orm/core') && this.canResolvePackage('@mikro-orm/mysql');
+    }
+
+    static isKyselyEnabled()
+    {
+        if('1' !== String(process.env.RELDENS_TEST_KYSELY_ENABLED)){
+            return false;
+        }
+        return this.canResolvePackage('kysely');
+    }
+
+    static isDrizzleEnabled()
+    {
+        if('1' !== String(process.env.RELDENS_TEST_DRIZZLE_ENABLED)){
+            return false;
+        }
+        return this.canResolvePackage('drizzle-orm');
+    }
+
     static activeDriverNames()
     {
-        let driverNames = ['objection-js', 'mikro-orm'];
+        let driverNames = ['knex'];
+        if(this.isObjectionEnabled()){
+            driverNames.push('objection-js');
+        }
+        if(this.isMikroOrmEnabled()){
+            driverNames.push('mikro-orm');
+        }
         if(this.isPrismaEnabled()){
             driverNames.push('prisma');
         }
+        if(this.isKyselyEnabled()){
+            driverNames.push('kysely');
+        }
+        if(this.isDrizzleEnabled()){
+            driverNames.push('drizzle');
+        }
         return driverNames;
     }
 
@@ -481,7 +600,14 @@ class TestHelpers
             }
             let adapterModule = require('@prisma/adapter-mariadb');
             let adapterConfig = config
-                ? { host: config.host, port: config.port, user: config.user, password: config.password, database: config.database }
+                ? {
+                    host: config.host,
+                    port: config.port,
+                    user: config.user,
+                    password: config.password,
+                    database: config.database,
+                    connectionLimit: sc.get(config, 'connectionLimit', 2)
+                }
                 : process.env.RELDENS_DB_URL;
             let client = new prismaModule.PrismaClient({ adapter: new adapterModule.PrismaMariaDb(adapterConfig) });
             await client.$connect();
@@ -509,6 +635,10 @@ class TestHelpers
             Logger.info('Cleaning up Prisma config file: '+prismaConfigPath);
             FileHandler.remove(prismaConfigPath);
         }
+        if('1' === process.env.RELDENS_TEST_KEEP_GENERATED){
+            Logger.info('Keeping generated entities folder, RELDENS_TEST_KEEP_GENERATED is active.');
+            return;
+        }
         let entitiesPath = FileHandler.joinPaths(process.cwd(), 'generated-entities');
         if(FileHandler.exists(entitiesPath)){
             Logger.info('Cleaning up generated entities folder: '+entitiesPath);
@@ -798,7 +928,7 @@ class TestHelpers
         this.fixGeneratedRequirePaths();
         this.compareGeneratedWithExpected(driverName, 'entities');
         this.compareGeneratedWithExpected(driverName, 'models/'+driverName);
-        if('objection-js' === driverName){
+        if('knex' === driverName){
             this.compareGeneratedWithExpected(driverName, 'entities-config.js');
             this.compareGeneratedWithExpected(driverName, 'entities-translations.js');
         }

package/tests/utils/test-runner.js

@@ -17,6 +17,7 @@ class TestRunner
         this.failedCount = 0;
         this.currentSuite = '';
         this.currentGroup = '';
+        this.totalDuration = 0;
     }
 
     suite(name)
@@ -38,22 +39,42 @@ class TestRunner
         try {
             await testFn();
             this.passedCount++;
-            let duration = Date.now() - startTime;
-            Logger.info('    ✔ '+name+' ('+duration+'ms)');
+            this.logTestResult(name, startTime, false);
         } catch(error) {
             this.failedCount++;
-            let duration = Date.now() - startTime;
-            Logger.error('    ✖ '+name+' ('+duration+'ms)');
+            this.logTestResult(name, startTime, true);
             Logger.error('      Error: '+error.message);
         }
     }
 
+    fail(name, message)
+    {
+        this.testCount++;
+        this.failedCount++;
+        Logger.error('    ✖ '+name);
+        Logger.error('      Error: '+message);
+        return this.getResults();
+    }
+
+    logTestResult(name, startTime, hasFailed)
+    {
+        let duration = Date.now() - startTime;
+        this.totalDuration += duration;
+        if(hasFailed){
+            Logger.error('    ✖ '+name+' ('+duration+'ms)');
+            return duration;
+        }
+        Logger.info('    ✔ '+name+' ('+duration+'ms)');
+        return duration;
+    }
+
     getResults()
     {
         return {
             total: this.testCount,
             passed: this.passedCount,
-            failed: this.failedCount
+            failed: this.failedCount,
+            duration: this.totalDuration
         };
     }