@reldens/storage 0.87.0 → 0.89.0

package/tests/unit/test-type-mapper.js

@@ -0,0 +1,232 @@
+/**
+ *
+ * Reldens - TypeMapper Test
+ *
+ */
+
+const { TestRunner, assert } = require('../utils/test-runner');
+const { TypeMapper } = require('../../lib/type-mapper');
+
+class TypeMapperTest
+{
+
+    constructor()
+    {
+        this.runner = new TestRunner();
+    }
+
+    async run()
+    {
+        this.runner.suite('TypeMapper');
+        await this.testMapDbTypeToJsTypeNumeric();
+        await this.testMapDbTypeToJsTypeString();
+        await this.testMapDbTypeToJsTypeDate();
+        await this.testMapDbTypeToJsTypeBoolean();
+        await this.testMapDbTypeToJsTypeJson();
+        await this.testMapDbTypeToJsTypeBinary();
+        await this.testMapDbTypeToJsTypeCaseInsensitive();
+        await this.testMapDbTypeToPrismaTypeNumeric();
+        await this.testMapDbTypeToPrismaTypeString();
+        await this.testMapDbTypeToPrismaTypeDate();
+        await this.testMapDbTypeToPrismaTypeBoolean();
+        await this.testMapDbTypeToPrismaTypeJson();
+        await this.testMapDbTypeToPrismaTypeBinary();
+        await this.testMapDbTypeToPrismaTypeUnknown();
+        await this.testMapDbTypeToPrismaTypeCaseInsensitive();
+        return this.runner.getResults();
+    }
+
+    async testMapDbTypeToJsTypeNumeric()
+    {
+        this.runner.group('mapDbTypeToJsType - numeric types');
+        await this.runner.test('should map int types to number', async () => {
+            assert.strictEqual(TypeMapper.mapDbTypeToJsType('int'), 'number');
+            assert.strictEqual(TypeMapper.mapDbTypeToJsType('integer'), 'number');
+            assert.strictEqual(TypeMapper.mapDbTypeToJsType('tinyint'), 'number');
+            assert.strictEqual(TypeMapper.mapDbTypeToJsType('smallint'), 'number');
+            assert.strictEqual(TypeMapper.mapDbTypeToJsType('mediumint'), 'number');
+            assert.strictEqual(TypeMapper.mapDbTypeToJsType('bigint'), 'number');
+        });
+        await this.runner.test('should map decimal types to number', async () => {
+            assert.strictEqual(TypeMapper.mapDbTypeToJsType('decimal'), 'number');
+            assert.strictEqual(TypeMapper.mapDbTypeToJsType('float'), 'number');
+            assert.strictEqual(TypeMapper.mapDbTypeToJsType('double'), 'number');
+        });
+        await this.runner.test('should map year to number', async () => {
+            assert.strictEqual(TypeMapper.mapDbTypeToJsType('year'), 'number');
+        });
+    }
+
+    async testMapDbTypeToJsTypeString()
+    {
+        this.runner.group('mapDbTypeToJsType - string types');
+        await this.runner.test('should map varchar and char to string', async () => {
+            assert.strictEqual(TypeMapper.mapDbTypeToJsType('varchar'), 'string');
+            assert.strictEqual(TypeMapper.mapDbTypeToJsType('char'), 'string');
+        });
+        await this.runner.test('should map text types to string', async () => {
+            assert.strictEqual(TypeMapper.mapDbTypeToJsType('text'), 'string');
+            assert.strictEqual(TypeMapper.mapDbTypeToJsType('tinytext'), 'string');
+            assert.strictEqual(TypeMapper.mapDbTypeToJsType('mediumtext'), 'string');
+            assert.strictEqual(TypeMapper.mapDbTypeToJsType('longtext'), 'string');
+        });
+        await this.runner.test('should map time to string', async () => {
+            assert.strictEqual(TypeMapper.mapDbTypeToJsType('time'), 'string');
+        });
+    }
+
+    async testMapDbTypeToJsTypeDate()
+    {
+        this.runner.group('mapDbTypeToJsType - date types');
+        await this.runner.test('should map date types to Date', async () => {
+            assert.strictEqual(TypeMapper.mapDbTypeToJsType('date'), 'Date');
+            assert.strictEqual(TypeMapper.mapDbTypeToJsType('datetime'), 'Date');
+            assert.strictEqual(TypeMapper.mapDbTypeToJsType('timestamp'), 'Date');
+        });
+    }
+
+    async testMapDbTypeToJsTypeBoolean()
+    {
+        this.runner.group('mapDbTypeToJsType - boolean types');
+        await this.runner.test('should map boolean types to boolean', async () => {
+            assert.strictEqual(TypeMapper.mapDbTypeToJsType('boolean'), 'boolean');
+            assert.strictEqual(TypeMapper.mapDbTypeToJsType('bool'), 'boolean');
+            assert.strictEqual(TypeMapper.mapDbTypeToJsType('bit'), 'boolean');
+        });
+    }
+
+    async testMapDbTypeToJsTypeJson()
+    {
+        this.runner.group('mapDbTypeToJsType - json type');
+        await this.runner.test('should map json to object', async () => {
+            assert.strictEqual(TypeMapper.mapDbTypeToJsType('json'), 'object');
+        });
+    }
+
+    async testMapDbTypeToJsTypeBinary()
+    {
+        this.runner.group('mapDbTypeToJsType - binary types');
+        await this.runner.test('should map binary types to Buffer', async () => {
+            assert.strictEqual(TypeMapper.mapDbTypeToJsType('binary'), 'Buffer');
+            assert.strictEqual(TypeMapper.mapDbTypeToJsType('varbinary'), 'Buffer');
+            assert.strictEqual(TypeMapper.mapDbTypeToJsType('blob'), 'Buffer');
+            assert.strictEqual(TypeMapper.mapDbTypeToJsType('tinyblob'), 'Buffer');
+            assert.strictEqual(TypeMapper.mapDbTypeToJsType('mediumblob'), 'Buffer');
+            assert.strictEqual(TypeMapper.mapDbTypeToJsType('longblob'), 'Buffer');
+        });
+    }
+
+    async testMapDbTypeToJsTypeCaseInsensitive()
+    {
+        this.runner.group('mapDbTypeToJsType - case insensitive');
+        await this.runner.test('should handle uppercase type names', async () => {
+            assert.strictEqual(TypeMapper.mapDbTypeToJsType('INT'), 'number');
+            assert.strictEqual(TypeMapper.mapDbTypeToJsType('VARCHAR'), 'string');
+            assert.strictEqual(TypeMapper.mapDbTypeToJsType('DATETIME'), 'Date');
+        });
+    }
+
+    async testMapDbTypeToPrismaTypeNumeric()
+    {
+        this.runner.group('mapDbTypeToPrismaType - numeric types');
+        await this.runner.test('should map int types to Int', async () => {
+            assert.strictEqual(TypeMapper.mapDbTypeToPrismaType('int'), 'Int');
+            assert.strictEqual(TypeMapper.mapDbTypeToPrismaType('integer'), 'Int');
+            assert.strictEqual(TypeMapper.mapDbTypeToPrismaType('tinyint'), 'Int');
+            assert.strictEqual(TypeMapper.mapDbTypeToPrismaType('smallint'), 'Int');
+            assert.strictEqual(TypeMapper.mapDbTypeToPrismaType('mediumint'), 'Int');
+            assert.strictEqual(TypeMapper.mapDbTypeToPrismaType('year'), 'Int');
+        });
+        await this.runner.test('should map bigint to BigInt', async () => {
+            assert.strictEqual(TypeMapper.mapDbTypeToPrismaType('bigint'), 'BigInt');
+        });
+        await this.runner.test('should map decimal to Decimal', async () => {
+            assert.strictEqual(TypeMapper.mapDbTypeToPrismaType('decimal'), 'Decimal');
+        });
+        await this.runner.test('should map float types to Float', async () => {
+            assert.strictEqual(TypeMapper.mapDbTypeToPrismaType('float'), 'Float');
+            assert.strictEqual(TypeMapper.mapDbTypeToPrismaType('double'), 'Float');
+        });
+    }
+
+    async testMapDbTypeToPrismaTypeString()
+    {
+        this.runner.group('mapDbTypeToPrismaType - string types');
+        await this.runner.test('should map varchar and char to String', async () => {
+            assert.strictEqual(TypeMapper.mapDbTypeToPrismaType('varchar'), 'String');
+            assert.strictEqual(TypeMapper.mapDbTypeToPrismaType('char'), 'String');
+        });
+        await this.runner.test('should map text types to String', async () => {
+            assert.strictEqual(TypeMapper.mapDbTypeToPrismaType('text'), 'String');
+            assert.strictEqual(TypeMapper.mapDbTypeToPrismaType('tinytext'), 'String');
+            assert.strictEqual(TypeMapper.mapDbTypeToPrismaType('mediumtext'), 'String');
+            assert.strictEqual(TypeMapper.mapDbTypeToPrismaType('longtext'), 'String');
+        });
+        await this.runner.test('should map time to String', async () => {
+            assert.strictEqual(TypeMapper.mapDbTypeToPrismaType('time'), 'String');
+        });
+    }
+
+    async testMapDbTypeToPrismaTypeDate()
+    {
+        this.runner.group('mapDbTypeToPrismaType - date types');
+        await this.runner.test('should map date types to DateTime', async () => {
+            assert.strictEqual(TypeMapper.mapDbTypeToPrismaType('date'), 'DateTime');
+            assert.strictEqual(TypeMapper.mapDbTypeToPrismaType('datetime'), 'DateTime');
+            assert.strictEqual(TypeMapper.mapDbTypeToPrismaType('timestamp'), 'DateTime');
+        });
+    }
+
+    async testMapDbTypeToPrismaTypeBoolean()
+    {
+        this.runner.group('mapDbTypeToPrismaType - boolean types');
+        await this.runner.test('should map boolean types to Boolean', async () => {
+            assert.strictEqual(TypeMapper.mapDbTypeToPrismaType('boolean'), 'Boolean');
+            assert.strictEqual(TypeMapper.mapDbTypeToPrismaType('bool'), 'Boolean');
+            assert.strictEqual(TypeMapper.mapDbTypeToPrismaType('bit'), 'Boolean');
+        });
+    }
+
+    async testMapDbTypeToPrismaTypeJson()
+    {
+        this.runner.group('mapDbTypeToPrismaType - json type');
+        await this.runner.test('should map json to Json', async () => {
+            assert.strictEqual(TypeMapper.mapDbTypeToPrismaType('json'), 'Json');
+        });
+    }
+
+    async testMapDbTypeToPrismaTypeBinary()
+    {
+        this.runner.group('mapDbTypeToPrismaType - binary types');
+        await this.runner.test('should map binary types to Bytes', async () => {
+            assert.strictEqual(TypeMapper.mapDbTypeToPrismaType('binary'), 'Bytes');
+            assert.strictEqual(TypeMapper.mapDbTypeToPrismaType('varbinary'), 'Bytes');
+            assert.strictEqual(TypeMapper.mapDbTypeToPrismaType('blob'), 'Bytes');
+            assert.strictEqual(TypeMapper.mapDbTypeToPrismaType('tinyblob'), 'Bytes');
+            assert.strictEqual(TypeMapper.mapDbTypeToPrismaType('mediumblob'), 'Bytes');
+            assert.strictEqual(TypeMapper.mapDbTypeToPrismaType('longblob'), 'Bytes');
+        });
+    }
+
+    async testMapDbTypeToPrismaTypeUnknown()
+    {
+        this.runner.group('mapDbTypeToPrismaType - unknown types');
+        await this.runner.test('should default to String for unknown types', async () => {
+            assert.strictEqual(TypeMapper.mapDbTypeToPrismaType('unknowntype'), 'String');
+            assert.strictEqual(TypeMapper.mapDbTypeToPrismaType('customtype'), 'String');
+        });
+    }
+
+    async testMapDbTypeToPrismaTypeCaseInsensitive()
+    {
+        this.runner.group('mapDbTypeToPrismaType - case insensitive');
+        await this.runner.test('should handle uppercase type names', async () => {
+            assert.strictEqual(TypeMapper.mapDbTypeToPrismaType('INT'), 'Int');
+            assert.strictEqual(TypeMapper.mapDbTypeToPrismaType('VARCHAR'), 'String');
+            assert.strictEqual(TypeMapper.mapDbTypeToPrismaType('DATETIME'), 'DateTime');
+        });
+    }
+
+}
+
+module.exports = TypeMapperTest;

package/tests/utils/custom-reporter.js

@@ -0,0 +1,73 @@
+/**
+ *
+ * Reldens - Custom Test Reporter
+ * Filters test output to remove suites, cancelled (treats as fail), skipped, todo
+ *
+ */
+
+const { Transform } = require('node:stream');
+
+class OutputFilter extends Transform
+{
+    constructor()
+    {
+        super();
+        this.buffer = '';
+        this.stats = {
+            tests: 0,
+            pass: 0,
+            fail: 0,
+            cancelled: 0
+        };
+    }
+
+    _transform(chunk, encoding, callback)
+    {
+        this.buffer += chunk.toString();
+        let lines = this.buffer.split('\n');
+        this.buffer = lines.pop();
+        for(let line of lines){
+            // Extract stats before filtering
+            if(line.includes('ℹ tests ')){
+                this.stats.tests = parseInt(line.match(/\d+/)[0]);
+            }
+            if(line.includes('ℹ pass ')){
+                this.stats.pass = parseInt(line.match(/\d+/)[0]);
+            }
+            if(line.includes('ℹ fail ')){
+                this.stats.fail = parseInt(line.match(/\d+/)[0]);
+            }
+            if(line.includes('ℹ cancelled ')){
+                this.stats.cancelled = parseInt(line.match(/\d+/)[0]);
+                continue; // Skip this line
+            }
+            if(line.includes('ℹ skipped ')){
+                continue; // Skip this line
+            }
+            if(line.includes('ℹ todo ')){
+                continue; // Skip this line
+            }
+            if(line.includes('ℹ suites ')){
+                continue; // Skip this line
+            }
+            this.push(line + '\n');
+        }
+        callback();
+    }
+
+    _flush(callback)
+    {
+        if(this.buffer){
+            this.push(this.buffer);
+        }
+        if(0 < this.stats.tests){
+            this.push('\n');
+            this.push('ℹ tests ' + this.stats.tests + '\n');
+            this.push('ℹ pass ' + this.stats.pass + '\n');
+            this.push('ℹ fail ' + (this.stats.fail + this.stats.cancelled) + '\n');
+        }
+        callback();
+    }
+}
+
+module.exports = { OutputFilter };

package/tests/utils/driver-registry.js

@@ -0,0 +1,144 @@
+/**
+ *
+ * Reldens - Driver Registry
+ * Singleton registry for shared driver instances across integration tests
+ * Reduces test setup/teardown from 9x to 3x (70% performance improvement)
+ *
+ */
+
+const { Logger } = require('@reldens/utils');
+const { FileHandler } = require('@reldens/server-utils');
+const { TestHelpers } = require('./test-helpers');
+
+class DriverRegistry
+{
+
+    constructor()
+    {
+        this.sharedState = {
+            drivers: {},
+            repos: {},
+            initialized: false,
+            instanceId: Math.random()
+        };
+        this.schemaPath = FileHandler.joinPaths(__dirname, '..', 'fixtures', 'sql', 'test-schema.sql');
+        this.repoNames = ['testCategories', 'testProducts', 'testReviews'];
+        this.driverNames = ['objection-js', 'mikro-orm', 'prisma'];
+        this.skipGeneration = false;
+    }
+
+    async initialize()
+    {
+        if(this.sharedState.initialized){
+            return;
+        }
+        Logger.info('='.repeat(60));
+        Logger.info('INITIALIZING SHARED DRIVER REGISTRY');
+        Logger.info('='.repeat(60));
+        for(let driverName of this.driverNames){
+            let dataServer = null;
+            try {
+                Logger.info('REGISTRY: Setting up driver: '+driverName);
+                let rawEntities = {};
+                dataServer = await TestHelpers.setupDriver(driverName, rawEntities);
+                let schemaSql = FileHandler.readFile(this.schemaPath);
+                await TestHelpers.executeRawSQL(dataServer, schemaSql);
+                await this.generateOrLoadEntities(dataServer, driverName);
+                let repos = {};
+                for(let entityName of this.repoNames){
+                    let repo = dataServer.getEntity(entityName);
+                    Logger.info('REGISTRY: Got entity '+entityName+' for '+driverName+': '+(repo ? 'EXISTS' : 'NULL'));
+                    repos[entityName] = repo;
+                }
+                Logger.info('REGISTRY: About to assign driver '+driverName+' to registry');
+                this.sharedState.drivers[driverName] = dataServer;
+                this.sharedState.repos[driverName] = repos;
+                Logger.info(
+                    'REGISTRY: Assigned! drivers['+driverName+'] = '
+                    +(this.sharedState.drivers[driverName] ? 'EXISTS' : 'NULL')
+                );
+                Logger.info(
+                    'REGISTRY: Assigned! repos['+driverName+'] = '
+                    +(this.sharedState.repos[driverName] ? 'EXISTS' : 'NULL')
+                );
+                Logger.info('REGISTRY: Driver '+driverName+' initialized successfully');
+            } catch(error) {
+                Logger.critical('REGISTRY: Failed to initialize driver '+driverName);
+                Logger.critical('ERROR: '+error.message);
+                Logger.critical('STACK: '+error.stack);
+                if(dataServer){
+                    try {
+                        await TestHelpers.teardownDriver(dataServer);
+                    } catch(cleanupError) {
+                        Logger.warning('Failed to disconnect '+driverName+' after init error: '+cleanupError.message);
+                    }
+                }
+                this.sharedState.drivers[driverName] = null;
+                this.sharedState.repos[driverName] = {};
+            }
+        }
+        this.sharedState.initialized = true;
+        Logger.info('='.repeat(60));
+        Logger.info('DRIVER REGISTRY INITIALIZED - instanceId = '+this.sharedState.instanceId);
+        Logger.info('REGISTRY DEBUG: drivers keys = '+Object.keys(this.sharedState.drivers).join(', '));
+        Logger.info('REGISTRY DEBUG: repos keys = '+Object.keys(this.sharedState.repos).join(', '));
+        Logger.info('='.repeat(60));
+    }
+
+    async generateOrLoadEntities(dataServer, driverName)
+    {
+        if(this.skipGeneration){
+            Logger.info('REGISTRY: Skipping entity generation for '+driverName+' (using existing files)');
+            return await TestHelpers.loadGeneratedEntities(dataServer, driverName);
+        }
+        return await TestHelpers.generateTestEntities(dataServer, driverName);
+    }
+
+    getDriver(driverName)
+    {
+        Logger.info('REGISTRY: getDriver called - instanceId = '+this.sharedState.instanceId);
+        let driverInstance = this.sharedState.drivers[driverName];
+        Logger.info(
+            'REGISTRY: getDriver('+driverName+') typeof = '
+            +(typeof driverInstance)+', null? '+(driverInstance === null)+', undefined? '+(driverInstance === undefined)
+        );
+        return driverInstance;
+    }
+
+    getRepos(driverName)
+    {
+        Logger.info('REGISTRY: getRepos called - instanceId = '+this.sharedState.instanceId);
+        let reposObject = this.sharedState.repos[driverName];
+        Logger.info(
+            'REGISTRY: getRepos('+driverName+') typeof = '
+            +(typeof reposObject)+', keys = '+(reposObject ? JSON.stringify(Object.keys(reposObject)) : 'NO VALUE')
+        );
+        return reposObject;
+    }
+
+    async cleanup()
+    {
+        Logger.info('='.repeat(60));
+        Logger.info('CLEANING UP DRIVER REGISTRY');
+        Logger.info('='.repeat(60));
+        for(let driverName of this.driverNames){
+            let dataServer = this.sharedState.drivers[driverName];
+            if(dataServer){
+                try {
+                    await TestHelpers.dropTestTables(dataServer);
+                    await TestHelpers.teardownDriver(dataServer);
+                } catch(error) {
+                    Logger.warning('Failed to cleanup driver '+driverName+': '+error.message);
+                }
+            }
+        }
+        TestHelpers.cleanupGeneratedFiles();
+        this.sharedState.drivers = {};
+        this.sharedState.repos = {};
+        this.sharedState.initialized = false;
+        Logger.info('Driver registry cleanup complete');
+    }
+
+}
+
+module.exports.DriverRegistry = DriverRegistry;

package/tests/utils/prisma-subprocess-worker.js

@@ -0,0 +1,150 @@
+/**
+ *
+ * Reldens - Storage - Prisma Test Subprocess Worker
+ *
+ */
+
+const { FileHandler } = require('@reldens/server-utils');
+const { Logger, sc } = require('@reldens/utils');
+const { exec } = require('child_process');
+const { promisify } = require('util');
+const execAsync = promisify(exec);
+
+class PrismaTestSubprocessWorker
+{
+
+    constructor()
+    {
+        this.setupProcessHandlers();
+    }
+
+    setupProcessHandlers()
+    {
+        process.on('message', async (message) => {
+            try {
+                await this.processIncomingMessage(message);
+            } catch(error) {
+                Logger.error('PrismaTestSubprocessWorker error: '+error.message);
+                this.sendErrorResponse(error.message);
+                setTimeout(() => process.exit(1), 100);
+            }
+        });
+        process.on('uncaughtException', (error) => {
+            Logger.error('PrismaTestSubprocessWorker uncaught exception: '+error.message);
+            this.sendErrorResponse(error.message);
+            setTimeout(() => process.exit(1), 100);
+        });
+        process.on('unhandledRejection', (error) => {
+            Logger.error('PrismaTestSubprocessWorker unhandled rejection: '+error.message);
+            this.sendErrorResponse(error.message);
+            setTimeout(() => process.exit(1), 100);
+        });
+    }
+
+    async ensureStubFiles(projectRoot)
+    {
+        let stubPath = FileHandler.joinPaths(projectRoot, 'node_modules', '.prisma', 'client', 'default.js');
+        if(FileHandler.exists(stubPath)){
+            Logger.info('Subprocess: Prisma stub files already exist');
+            return true;
+        }
+        Logger.info('Subprocess: Creating Prisma stub files...');
+        try {
+            let postinstallPath = FileHandler.joinPaths(
+                projectRoot,
+                'node_modules',
+                '@prisma',
+                'client',
+                'scripts',
+                'postinstall.js'
+            );
+            if(!FileHandler.exists(postinstallPath)){
+                Logger.warning('Subprocess: Prisma postinstall script not found at: '+postinstallPath);
+                return false;
+            }
+            let { execSync } = require('child_process');
+            execSync('node "' + postinstallPath + '"', {
+                cwd: projectRoot,
+                stdio: 'inherit'
+            });
+            Logger.info('Subprocess: Prisma stub files created successfully');
+            return true;
+        } catch(error) {
+            Logger.error('Subprocess: Failed to create stub files: '+error.message);
+            return false;
+        }
+    }
+
+    async processIncomingMessage(message)
+    {
+        let projectRoot = sc.get(message, 'projectRoot', './');
+        let config = sc.get(message, 'config', {});
+        let stubsCreated = await this.ensureStubFiles(projectRoot);
+        if(!stubsCreated){
+            Logger.warning('Subprocess: Stub files could not be created, proceeding anyway');
+        }
+        let generatedClient = await this.generateMinimalPrismaClient(projectRoot, config);
+        if(!generatedClient){
+            this.sendErrorResponse('Failed to generate Prisma client.');
+            return;
+        }
+        await generatedClient.$disconnect();
+        this.sendSuccessResponse('Subprocess Prisma client generation completed.');
+    }
+
+    async generateMinimalPrismaClient(projectRoot, config)
+    {
+        let prismaPath = FileHandler.joinPaths(projectRoot, 'prisma');
+        let schemaPath = FileHandler.joinPaths(prismaPath, 'schema.prisma');
+        FileHandler.createFolder(prismaPath);
+        let dbUrl = 'mysql://'+config.user+':'+config.password+'@'+config.host+':'+config.port+'/'+config.database;
+        let schemaContent = 'generator client {\n'
+            + '  provider = "prisma-client-js"\n'
+            + '  output = "./client"\n'
+            + '}\n'
+            + '\n'
+            + 'datasource db {\n'
+            + '  provider = "mysql"\n'
+            + '  url = "'+dbUrl+'"\n'
+            + '}';
+        FileHandler.writeFile(schemaPath, schemaContent);
+        Logger.info('Subprocess: Running prisma db pull to introspect database...');
+        try {
+            let { stdout: pullStdout, stderr: pullStderr } = await execAsync('npx prisma db pull', {cwd: projectRoot});
+            if(pullStderr && !pullStderr.includes('Introspected')){
+                Logger.warning('Subprocess: Prisma db pull stderr: '+pullStderr);
+            }
+            Logger.info('Subprocess: Database introspection completed');
+        } catch(error) {
+            Logger.critical('Subprocess: Prisma db pull failed: '+error.message);
+            return false;
+        }
+        Logger.info('Subprocess: Running prisma generate...');
+        try {
+            let { stdout, stderr } = await execAsync('npx prisma generate', {cwd: projectRoot});
+            if(stderr && !stderr.includes('Generated Prisma Client')){
+                Logger.warning('Subprocess: Prisma generate stderr: '+stderr);
+            }
+            Logger.info('Subprocess: Prisma client generated successfully');
+            let clientPath = FileHandler.joinPaths(projectRoot, 'prisma', 'client');
+            let { PrismaClient } = require(clientPath);
+            return new PrismaClient();
+        } catch(error) {
+            Logger.critical('Subprocess: Prisma generate failed: '+error.message);
+            return false;
+        }
+    }
+
+    sendSuccessResponse(message)
+    {
+        process.send({success: true, message: message});
+    }
+
+    sendErrorResponse(errorMessage)
+    {
+        process.send({success: false, error: errorMessage});
+    }
+
+}
+
+new PrismaTestSubprocessWorker();