@reldens/storage 0.52.0 → 0.54.0

package/README.md

@@ -23,32 +23,39 @@ It ensures consistent data access methods across different database types and OR
 ### CLI Tools
 Generate entity files directly from your database structure:
 ```bash
-npx reldens-storage generateEntities --user=dbuser --pass=dbpass --database=dbname --driver=objection-js
+npx reldens-storage generateEntities --user=[dbuser] --pass=[dbpass] --database=[dbname] --driver=[objection-js]
 ```
 
 Options:
-- `--user` - Database username
-- `--pass` - Database password
-- `--host` - Database host (default: localhost)
-- `--port` - Database port (default: 3306)
-- `--database` - Database name
-- `--driver` - ORM driver (objection-js|mikro-orm)
-- `--client` - Database client (mysql|mysql2|mongodb)
-- `--path` - Project path for output files
-
-Generate Prisma schema for Prisma database:
+- `--user=[username]` - Database username
+- `--pass=[password]` - Database password
+- `--host=[host]` - Database host (default: localhost)
+- `--port=[port]` - Database port (default: 3306)
+- `--database=[name]` - Database name
+- `--driver=[driver]` - ORM driver (objection-js|mikro-orm|prisma)
+- `--client=[client]` - Database client (mysql|mysql2|mongodb)
+- `--path=[path]` - Project path for output files
+- `--override` - Regenerate all files even if they exist
+
+Generate Prisma schema:
 ```bash
-npx reldens-storage-prisma --user=dbuser --pass=dbpass --database=dbname
+npx reldens-generate-prisma-schema --host=[host] --port=[port] --user=[dbuser] --password=[dbpass] --database=[dbname]
 ```
 
 Options:
-- `--user` - Database username
-- `--pass` - Database password
-- `--host` - Database host (default: localhost)
-- `--port` - Database port (default: 3306)
-- `--database` - Database name
-- `--client` - Database client (mysql|mysql2|postgresql|mongodb)
-- `--path` - Project path for output files
+- `--host=[host]` - Database host (required)
+- `--port=[port]` - Database port (required)
+- `--user=[username]` - Database username (required)
+- `--password=[password]` - Database password (required)
+- `--database=[name]` - Database name (required)
+- `--client=[client]` - Database client (default: mysql)
+- `--debug` - Enable debug mode
+- `--dataProxy` - Enable data proxy
+- `--checkInterval=[ms]` - Check interval in milliseconds (default: 1000)
+- `--maxWaitTime=[ms]` - Max wait time in milliseconds (default: 30000)
+- `--prismaSchemaPath=[path]` - Path to Prisma schema directory
+- `--clientOutputPath=[path]` - Client output path (if not set, uses Prisma default)
+- `--generateBinaryTargets=[targets]` - Comma-separated binary targets (default: native)
 
 ## Usage Examples
 
@@ -96,7 +103,7 @@ const entities = server.generateEntities();
 
 First, generate your Prisma schema:
 ```bash
-npx reldens-storage-prisma --user=dbuser --pass=dbpass --database=dbname
+npx reldens-generate-prisma-schema --host=localhost --port=3306 --user=dbuser --password=dbpass --database=dbname
 ```
 
 Then, use the PrismaDataServer in your code:
@@ -119,7 +126,7 @@ await server.connect();
 const entities = server.generateEntities();
 ```
 
-Note: The PrismaDataServer requires the Prisma schema to be generated first. Make sure to run the `reldens-storage-prisma` command before using PrismaDataServer.
+Note: The PrismaDataServer requires the Prisma schema to be generated first. Make sure to run the `reldens-generate-prisma-schema` command before using PrismaDataServer.
 
 ## Custom Drivers
 

package/bin/generate-prisma-schema.js

@@ -7,79 +7,152 @@
  */
 
 const { PrismaSchemaGenerator } = require('../lib/prisma/prisma-schema-generator');
-const { Logger } = require('@reldens/utils');
+const { Logger, sc } = require('@reldens/utils');
 
-let args = process.argv.slice(2);
+class PrismaSchemaGeneratorCLI
+{
 
-let connectionData = {
-    client: 'mysql',
-    config: {
-        user: '',
-        password: '',
-        host: 'localhost',
-        database: '',
-        port: 3306
+    constructor()
+    {
+        this.args = process.argv.slice(2);
+        this.config = {};
+        this.parseArguments();
     }
-};
 
-let projectPath = process.cwd();
-for(let i = 0; i < args.length; i++){
-    let arg = args[i];
-    if(!arg.startsWith('--')){
-        continue;
+    parseArguments()
+    {
+        for(let i = 0; i < this.args.length; i++){
+            let arg = this.args[i];
+            if(!arg.startsWith('--')){
+                continue;
+            }
+            let equalIndex = arg.indexOf('=');
+            if(-1 === equalIndex){
+                let flag = arg.substring(2);
+                if('debug' === flag || 'dataProxy' === flag || 'help' === flag || 'h' === flag){
+                    this.config[flag] = true;
+                }
+                continue;
+            }
+            let key = arg.substring(2, equalIndex);
+            let value = arg.substring(equalIndex + 1);
+            if('port' === key || 'checkInterval' === key || 'maxWaitTime' === key){
+                this.config[key] = parseInt(value);
+                continue;
+            }
+            if('generateBinaryTargets' === key){
+                this.config[key] = value.split(',').map(target => target.trim());
+                continue;
+            }
+            this.config[key] = value;
+        }
     }
-    let [key, value] = arg.substring(2).split('=');
-    if(!key || !value){
-        continue;
-    }
-    if('pass' === key){
-        connectionData.config.password = value;
-        continue;
-    }
-    if('path' === key){
-        projectPath = value;
-        continue;
-    }
-    if('user' === key){
-        connectionData.config.user = value;
-        continue;
+
+    shouldShowHelp()
+    {
+        return 0 === this.args.length || sc.get(this.config, 'help', false) || sc.get(this.config, 'h', false);
     }
-    if('database' === key){
-        connectionData.config.database = value;
-        continue;
+
+    showHelp()
+    {
+        Logger.info('');
+        Logger.info('Reldens Prisma Schema Generator');
+        Logger.info('================================');
+        Logger.info('');
+        Logger.info('Usage: npx reldens-generate-prisma-schema [options]');
+        Logger.info('');
+        Logger.info('Required Options:');
+        Logger.info('  --host=[host]                    Database host');
+        Logger.info('  --port=[port]                    Database port');
+        Logger.info('  --user=[user]                    Database user');
+        Logger.info('  --password=[password]            Database password');
+        Logger.info('  --database=[database]            Database name');
+        Logger.info('');
+        Logger.info('Optional Options:');
+        Logger.info('  --client=[client]                Database client (default: mysql)');
+        Logger.info('  --debug                          Enable debug mode (default: false)');
+        Logger.info('  --dataProxy                      Enable data proxy (default: false)');
+        Logger.info('  --checkInterval=[ms]             Check interval in milliseconds (default: 1000)');
+        Logger.info('  --maxWaitTime=[ms]               Max wait time in milliseconds (default: 30000)');
+        Logger.info('  --prismaSchemaPath=[path]        Path to Prisma schema directory');
+        Logger.info('  --clientOutputPath=[path]        Client output path (if not set, uses Prisma default)');
+        Logger.info('  --generateBinaryTargets=[targets] Comma-separated binary targets (default: native)');
+        Logger.info('');
+        Logger.info('Example:');
+        Logger.info('  npx reldens-generate-prisma-schema --host=localhost --port=3306 --user=root --password=secret --database=mydb');
+        Logger.info('');
+        Logger.info('Advanced Example:');
+        Logger.info('  npx reldens-generate-prisma-schema --host=localhost --port=3306 --user=root --password=secret --database=mydb --client=postgresql --debug --dataProxy --checkInterval=2000 --maxWaitTime=60000 --prismaSchemaPath=./custom/prisma --clientOutputPath=./custom/client --generateBinaryTargets=native,debian-openssl-1.1.x');
+        Logger.info('');
     }
-    if('host' === key){
-        connectionData.config.host = value;
-        continue;
+
+    validateRequiredArgs()
+    {
+        let requiredArgs = ['host', 'port', 'user', 'password', 'database'];
+        let missing = [];
+        for(let arg of requiredArgs){
+            if(!this.config[arg]){
+                missing.push(arg);
+            }
+        }
+        if(0 < missing.length){
+            Logger.error('Missing required arguments: ' + missing.join(', '));
+            this.showHelp();
+            return false;
+        }
+        return true;
     }
-    if('port' === key){
-        connectionData.config.port = value;
-        continue;
+
+    getSchemaConfig()
+    {
+        return {
+            config: {
+                host: this.config.host,
+                port: this.config.port,
+                user: this.config.user,
+                password: this.config.password,
+                database: this.config.database
+            },
+            client: sc.get(this.config, 'client', 'mysql'),
+            debug: sc.get(this.config, 'debug', false),
+            dataProxy: sc.get(this.config, 'dataProxy', false),
+            checkInterval: sc.get(this.config, 'checkInterval', 1000),
+            maxWaitTime: sc.get(this.config, 'maxWaitTime', 30000),
+            prismaSchemaPath: sc.get(this.config, 'prismaSchemaPath'),
+            clientOutputPath: sc.get(this.config, 'clientOutputPath'),
+            generateBinaryTargets: sc.get(this.config, 'generateBinaryTargets')
+        };
     }
-    if('client' === key){
-        connectionData.client = value;
+
+    async run()
+    {
+        if(this.shouldShowHelp()){
+            this.showHelp();
+            return true;
+        }
+        if(!this.validateRequiredArgs()){
+            return false;
+        }
+        let schemaConfig = this.getSchemaConfig();
+        let generator = new PrismaSchemaGenerator(schemaConfig);
+        let success = await generator.generate();
+        if(!success){
+            Logger.critical('Failed to generate Prisma schema');
+            return false;
+        }
+        Logger.info('Prisma schema generation completed successfully');
+        return true;
     }
-}
 
-if(!connectionData.config.user || !connectionData.config.database){
-    Logger.error('Required parameters missing.');
-    Logger.error(
-        'Usage:',
-        'npx reldens-storage generatePrismaSchema --user=[db-username] --pass=[db-password] --host=[db-host] --database=[db-name] --client=[db-client] --path=[project-path]'
-    );
-    process.exit();
 }
 
-let generator = new PrismaSchemaGenerator({...connectionData, prismaSchemaPath: projectPath+'/prisma'});
-
-generator.generate().then((success) => {
+let generator = new PrismaSchemaGeneratorCLI();
+generator.run().then((success) => {
     if(!success){
-        Logger.error('Prisma schema generation failed.');
-        process.exit();
+        process.exit(1);
     }
-    Logger.info('Prisma schema generation completed successfully!');
-    process.exit();
+    process.exit(0);
 }).catch((error) => {
-    Logger.error('Error during Prisma schema generation: '+error.message);
-    process.exit();
+    Logger.critical('Unexpected error: ' + error.message);
+    process.exit(1);
 });

package/bin/reldens-storage.js

@@ -7,69 +7,124 @@
  */
 
 const { EntitiesGenerator } = require('../lib/entities-generator');
-const { Logger } = require('@reldens/utils');
+const { Logger, sc } = require('@reldens/utils');
 
-let args = process.argv.slice(2);
-let command = args[0];
+class StorageEntitiesGenerator
+{
 
-if('generateEntities' !== command){
-    Logger.error('Unknown command. Available command "generateEntities".');
-    process.exit();
-}
-
-let connectionData = {
-    driver: 'objection-js',
-    client: 'mysql2',
-    user: '',
-    password: '',
-    host: 'localhost',
-    database: '',
-    port: 3306
-};
-
-let projectPath = process.cwd();
-for(let i = 1; i < args.length; i++){
-    let arg = args[i];
-    if(!arg.startsWith('--')){
-        continue;
+    constructor()
+    {
+        this.args = process.argv.slice(2);
+        this.command = this.args[0];
+        this.config = {};
+        this.projectPath = process.cwd();
+        this.isOverride = false;
+        this.parseArguments();
     }
-    let [key, value] = arg.substring(2).split('=');
-    if(!key || !value){
-        continue;
+
+    parseArguments()
+    {
+        for(let i = 1; i < this.args.length; i++){
+            let arg = this.args[i];
+            if(!arg.startsWith('--')){
+                continue;
+            }
+            let equalIndex = arg.indexOf('=');
+            if(-1 === equalIndex){
+                let flag = arg.substring(2);
+                if('override' === flag){
+                    this.isOverride = true;
+                }
+                continue;
+            }
+            let key = arg.substring(2, equalIndex);
+            let value = arg.substring(equalIndex + 1);
+            if('path' === key){
+                this.projectPath = value;
+                continue;
+            }
+            if('pass' === key){
+                this.config['password'] = value;
+                continue;
+            }
+            if('port' === key){
+                this.config[key] = parseInt(value);
+                continue;
+            }
+            this.config[key] = value;
+        }
     }
-    if('pass' === key){
-        connectionData.password = value;
-        continue;
+
+    getConnectionData()
+    {
+        let connectionData = {
+            driver: sc.get(this.config, 'driver', 'objection-js'),
+            client: sc.get(this.config, 'client', 'mysql2'),
+            user: sc.get(this.config, 'user', ''),
+            password: sc.get(this.config, 'password', ''),
+            host: sc.get(this.config, 'host', 'localhost'),
+            database: sc.get(this.config, 'database', ''),
+            port: sc.get(this.config, 'port', 3306)
+        };
+        if('mikro-orm' === connectionData.driver && !this.config.client){
+            connectionData.client = 'mysql';
+        }
+        return connectionData;
     }
-    if('path' === key){
-        projectPath = value;
-        continue;
+
+    validateCommand()
+    {
+        if('generateEntities' !== this.command){
+            Logger.error('Unknown command. Available command "generateEntities".');
+            return false;
+        }
+        return true;
     }
-    connectionData[key] = value;
-}
 
-if('mikro-orm' === connectionData.driver && !args.find(arg => arg.startsWith('--client='))){
-    connectionData.client = 'mysql';
-}
+    validateRequiredArgs(connectionData)
+    {
+        if(!connectionData.user || !connectionData.database){
+            Logger.error('Required parameters missing.');
+            Logger.error('Usage: npx reldens-storage generateEntities --user=[db-username] --pass=[db-password] --host=[db-host] --database=[db-name] --driver=[driver-map-key] --client=[db-client] --path=[project-path] --override');
+            Logger.error('');
+            Logger.error('Optional flags:');
+            Logger.error('  --override    Regenerate all files even if they exist');
+            return false;
+        }
+        return true;
+    }
 
-if(!connectionData.user || !connectionData.database){
-    Logger.error('Required parameters missing.');
-    Logger.error(
-        'Usage:',
-        'npx reldens-storage generateEntities --user=[db-username] --pass=[db-password] --host=[db-host] --database=[db-name] --driver=[driver-map-key] --client=[db-client] --path=[project-path]'
-    );
-    process.exit();
+    async run()
+    {
+        if(!this.validateCommand()){
+            return false;
+        }
+        let connectionData = this.getConnectionData();
+        if(!this.validateRequiredArgs(connectionData)){
+            return false;
+        }
+        let generator = new EntitiesGenerator({
+            connectionData,
+            projectPath: this.projectPath,
+            isOverride: this.isOverride
+        });
+        let success = await generator.generate();
+        if(!success){
+            Logger.error('Entity generation failed.');
+            return false;
+        }
+        Logger.info('Entity generation completed successfully!');
+        return true;
+    }
 }
 
-let generator = new EntitiesGenerator({connectionData, projectPath});
-generator.generate().then((success) => {
+let generator = new StorageEntitiesGenerator();
+generator.run().then((success) => {
     if(!success){
-        Logger.error('Entity generation failed.');
-        process.exit();
+        process.exit(1);
     }
-    Logger.info('Entity generation completed successfully!');
-    process.exit();
+    process.exit(0);
 }).catch((error) => {
     Logger.error('Error during entity generation: '+error.message);
-    process.exit();
+    process.exit(1);
 });

package/lib/entities-generator.js

@@ -47,6 +47,8 @@ class EntitiesGenerator
         this.isOverride = sc.get(props, 'isOverride', false);
         this.generatedEntities = {};
         this.existingEntities = {};
+        this.existingEntityFields = {};
+        this.existingModels = {};
     }
 
     async generateEntityFile(tableName, tableData)
@@ -57,7 +59,7 @@ class EntitiesGenerator
             return false;
         }
         let entityTemplateContent = FileHandler.fetchFileContents(entityTemplatePath);
-        if(!entityTemplateContent) {
+        if(!entityTemplateContent){
             Logger.critical('Failed to read entity template file: '+entityTemplatePath);
             return false;
         }
@@ -158,7 +160,7 @@ class EntitiesGenerator
         let propertiesConfig = [];
         for(let columnName of Object.keys(columns)){
             let column = columns[columnName];
-            let propertyKey = titleProperty && columnName === titleProperty ? '[titleProperty]' : columnName;
+            let propertyKey = titleProperty && titleProperty === columnName ? '[titleProperty]' : columnName;
             if('id' === columnName){
                 propertiesConfig.push(columnName+': {}');
                 continue;
@@ -195,7 +197,7 @@ class EntitiesGenerator
             props.push('type: \'datetime\'');
             return;
         }
-        if('text' === type || 'longtext' === type || 'mediumtext' === type || 'tinytext' === type){
+        if('text' === type || 'longtext' === type || 'mediumtext' === type || 'tinytext' === type || 'json' === type){
             props.push('type: \'textarea\'');
             return;
         }
@@ -332,7 +334,7 @@ class EntitiesGenerator
         let entityPropertiesDefinition = this.getEntityPropertiesDefinition(tableData.columns, driverKey);
         let replacements = {
             modelClassName,
-            tableName: driverKey === 'prisma' ? tableName.toLowerCase() : tableName,
+            tableName: 'prisma' === driverKey ? tableName.toLowerCase() : tableName,
             modelPropertiesList,
             modelPropertiesConstructor,
             modelRelations,
@@ -341,10 +343,7 @@ class EntitiesGenerator
         let modelContent = this.applyReplacements(modelTemplateContent, replacements);
         let fileName = sc.kebabCase(tableName)+'-model.js';
         let driverFolder = FileHandler.joinPaths(this.modelsFolder, driverKey);
-        if(!FileHandler.createFolder(driverFolder)){
-            Logger.critical('Failed to create driver folder.');
-            return false;
-        }
+        FileHandler.createFolder(driverFolder);
         let filePath = FileHandler.joinPaths(driverFolder, fileName);
         if(!FileHandler.writeFile(filePath, modelContent)){
             Logger.critical('Failed to write model file: '+fileName);
@@ -410,32 +409,166 @@ class EntitiesGenerator
             }
             let tableName = file.replace('-entity.js', '').replace(/-/g, '_');
             this.existingEntities[tableName] = {entityFileName: file, tableName};
+            this.detectExistingEntityFields(tableName, file);
         }
+        this.detectExistingModels();
         Logger.info('Detected '+Object.keys(this.existingEntities).length+' existing entities.');
     }
 
-    filterTablesToGenerate(tables)
+    detectExistingModels()
     {
-        if(this.isOverride){
-            return tables;
+        if(!FileHandler.exists(this.modelsFolder)){
+            return;
+        }
+        let driverFolders = FileHandler.fetchSubFoldersList(this.modelsFolder);
+        for(let driverKey of driverFolders){
+            let driverFolder = FileHandler.joinPaths(this.modelsFolder, driverKey);
+            let modelFiles = FileHandler.getFilesInFolder(driverFolder, ['.js']);
+            for(let file of modelFiles){
+                if(!file.endsWith('-model.js')){
+                    continue;
+                }
+                let tableName = file.replace('-model.js', '').replace(/-/g, '_');
+                if(!this.existingModels[tableName]){
+                    this.existingModels[tableName] = {};
+                }
+                this.existingModels[tableName][driverKey] = {
+                    modelFileName: file,
+                    driverKey: driverKey
+                };
+            }
+        }
+    }
+
+    detectExistingEntityFields(tableName, fileName)
+    {
+        let filePath = FileHandler.joinPaths(this.entitiesFolder, fileName);
+        let fileContent = FileHandler.readFile(filePath);
+        if(!fileContent){
+            return;
+        }
+        let fieldsMatch = fileContent.match(/properties\s*=\s*\{([^}]+)\}/s);
+        if(!fieldsMatch){
+            return;
+        }
+        let propertiesContent = fieldsMatch[1];
+        let fieldMatches = propertiesContent.match(/(\w+):\s*\{[^}]*\}/g);
+        if(!fieldMatches){
+            return;
+        }
+        this.existingEntityFields[tableName] = [];
+        for(let fieldMatch of fieldMatches){
+            let fieldName = fieldMatch.split(':')[0].trim();
+            this.existingEntityFields[tableName].push(fieldName);
+        }
+    }
+
+    entityNeedsUpdate(tableName, tableData)
+    {
+        if(!this.existingEntityFields[tableName]){
+            return true;
+        }
+        let existingFields = this.existingEntityFields[tableName];
+        let databaseFields = Object.keys(tableData.columns);
+        for(let dbField of databaseFields){
+            if(!existingFields.includes(dbField)){
+                return true;
+            }
         }
+        for(let existingField of existingFields){
+            if('id' === existingField){
+                continue;
+            }
+            if(!databaseFields.includes(existingField)){
+                return true;
+            }
+        }
+        return false;
+    }
+
+    filterTablesToGenerate(tables, driverKey)
+    {
         let filteredTables = {};
         let newTablesCount = 0;
+        let updateTablesCount = 0;
+        let missingConfigCount = 0;
+        let missingModelCount = 0;
         for(let tableName of Object.keys(tables)){
+            let needsGeneration = false;
+            let reasons = [];
             if(!this.existingEntities[tableName]){
-                filteredTables[tableName] = tables[tableName];
+                needsGeneration = true;
                 newTablesCount++;
+                reasons.push('new entity');
+            }
+            if(this.existingEntities[tableName]){
+                if(this.entityNeedsUpdate(tableName, tables[tableName])){
+                    needsGeneration = true;
+                    updateTablesCount++;
+                    reasons.push('fields mismatch');
+                }
+                if(!this.entityExistsInConfig(tableName)){
+                    needsGeneration = true;
+                    missingConfigCount++;
+                    reasons.push('missing from config');
+                }
+            }
+            if(!this.existingModels[tableName] || !this.existingModels[tableName][driverKey]){
+                needsGeneration = true;
+                missingModelCount++;
+                reasons.push('missing model');
+            }
+            if(this.existingModels[tableName] && this.existingModels[tableName][driverKey]){
+                if(!this.modelExistsInRegistered(tableName, driverKey)){
+                    needsGeneration = true;
+                    reasons.push('missing from registered models');
+                }
+            }
+            if(needsGeneration || this.isOverride){
+                filteredTables[tableName] = tables[tableName];
+                if(0 < reasons.length){
+                    Logger.info('Entity '+tableName+' needs generation: '+reasons.join(', '));
+                }
             }
         }
-        if(0 === newTablesCount){
-            Logger.info('No new tables found. All entities are up to date.');
+        if(0 === newTablesCount && 0 === updateTablesCount && 0 === missingConfigCount && 0 === missingModelCount){
+            Logger.info('No new tables found and all entities are properly configured.');
+            return filteredTables;
         }
         if(0 < newTablesCount){
             Logger.info('Found '+newTablesCount+' new tables to generate entities for.');
         }
+        if(0 < updateTablesCount){
+            Logger.info('Found '+updateTablesCount+' existing entities that need updates.');
+        }
+        if(0 < missingConfigCount){
+            Logger.info('Found '+missingConfigCount+' entities missing from config.');
+        }
+        if(0 < missingModelCount){
+            Logger.info('Found '+missingModelCount+' entities missing models.');
+        }
         return filteredTables;
     }
 
+    entityExistsInConfig(tableName)
+    {
+        if(!FileHandler.exists(this.entitiesConfigPath)){
+            return false;
+        }
+        let configContent = FileHandler.readFile(this.entitiesConfigPath);
+        return configContent && configContent.includes(sc.camelCase(tableName)+':');
+    }
+
+    modelExistsInRegistered(tableName, driverKey)
+    {
+        let registeredPath = FileHandler.joinPaths(this.modelsFolder, driverKey, 'registered-models-'+driverKey+'.js');
+        if(!FileHandler.exists(registeredPath)){
+            return false;
+        }
+        let registeredContent = FileHandler.readFile(registeredPath);
+        return registeredContent && registeredContent.includes(sc.camelCase(tableName)+':');
+    }
+
     generateEntitiesConfigFile()
     {
         if(this.isOverride){
@@ -447,7 +580,7 @@ class EntitiesGenerator
     regenerateEntitiesConfigFile()
     {
         let configTemplateContent = FileHandler.fetchFileContents(this.templates['entities-config']);
-        if(!configTemplateContent) {
+        if(!configTemplateContent){
             Logger.critical('Failed to read entities config template file: '+this.templates['entities-config']);
             return false;
         }
@@ -473,8 +606,8 @@ class EntitiesGenerator
             return true;
         }
         if(!FileHandler.exists(this.entitiesConfigPath)){
-            Logger.error('Entities config file does not exist, cannot append new entities.');
-            return false;
+            Logger.info('Entities config file does not exist, creating new file.');
+            return this.regenerateEntitiesConfigFile();
         }
         let existingContent = FileHandler.readFile(this.entitiesConfigPath);
         if(!existingContent){
@@ -492,37 +625,66 @@ class EntitiesGenerator
             if(!existingContent.includes(requireStatement)){
                 newRequires.push(requireStatement);
             }
-            if(!existingContent.includes(sc.camelCase(tableName)+':')){
+            if(!this.entityExistsInConfig(tableName)){
                 newConfigs.push(configEntry);
             }
         }
         if(0 === newRequires.length && 0 === newConfigs.length){
             return true;
         }
+        let normalizedContent = existingContent.replace(/\s+/g, ' ');
+        let entitiesConfigPattern = /let\s+entitiesConfig\s*=\s*\{/;
+        let entitiesConfigMatch = normalizedContent.match(entitiesConfigPattern);
+        if(!entitiesConfigMatch){
+            Logger.error('Could not find entitiesConfig variable in config file.');
+            return false;
+        }
+        let entitiesConfigStart = existingContent.indexOf(entitiesConfigMatch[0]);
+        let searchStart = entitiesConfigStart + entitiesConfigMatch[0].length;
+        let braceCount = 1;
+        let entitiesConfigEnd = -1;
+        for(let i = searchStart; i < existingContent.length; i++){
+            if('{' === existingContent[i]){
+                braceCount++;
+            }
+            if('}' === existingContent[i]){
+                braceCount--;
+                if(0 === braceCount){
+                    entitiesConfigEnd = i;
+                    break;
+                }
+            }
+        }
+        if(-1 === entitiesConfigEnd){
+            Logger.error('Could not find end of entitiesConfig object.');
+            return false;
+        }
         let firstRequirePosition = existingContent.indexOf('const {');
-        let entitiesConfigEnd = existingContent.indexOf('};\n\nmodule.exports');
-        if(-1 === firstRequirePosition || -1 === entitiesConfigEnd){
-            Logger.error('Could not find insertion points in config file.');
+        if(-1 === firstRequirePosition){
+            Logger.error('Could not find require statements in config file.');
             return false;
         }
         let beforeFirstRequire = existingContent.substring(0, firstRequirePosition);
         let afterFirstRequire = existingContent.substring(firstRequirePosition, entitiesConfigEnd);
+        let afterConfig = existingContent.substring(entitiesConfigEnd);
         let updatedContent = beforeFirstRequire;
         if(0 < newRequires.length){
             updatedContent += newRequires.join('\n') + '\n';
         }
         updatedContent += afterFirstRequire;
         if(0 < newConfigs.length){
-            if(!afterFirstRequire.trim().endsWith(',')){
+            let trimmedContent = afterFirstRequire.trimEnd();
+            if(!trimmedContent.endsWith(',')){
                 updatedContent = updatedContent.trimEnd() + ',';
             }
-            updatedContent += '\n    ' + newConfigs.join(',\n    ') + '\n';
+            updatedContent += '\n    ' + newConfigs.join(',\n    ');
         }
-        updatedContent += existingContent.substring(entitiesConfigEnd);
+        updatedContent += afterConfig;
         if(!FileHandler.writeFile(this.entitiesConfigPath, updatedContent)){
             Logger.error('Failed to append to entities config file: '+this.entitiesConfigPath);
             return false;
         }
+        Logger.info('Updated entities config file with '+newConfigs.length+' new entities.');
         return true;
     }
 
@@ -591,8 +753,8 @@ class EntitiesGenerator
             return true;
         }
         if(!FileHandler.exists(this.entitiesTranslationsPath)){
-            Logger.error('Entities translations file does not exist, cannot append new entities.');
-            return false;
+            Logger.info('Entities translations file does not exist, creating new file.');
+            return this.regenerateEntitiesTranslationsFile();
         }
         let existingContent = FileHandler.readFile(this.entitiesTranslationsPath);
         if(!existingContent){
@@ -611,22 +773,45 @@ class EntitiesGenerator
         if(0 === newTranslations.length){
             return true;
         }
-        let labelsEnd = existingContent.indexOf('\n    }\n');
-        if(-1 === existingContent.indexOf('labels: {') || -1 === labelsEnd){
-            Logger.error('Could not find labels object boundaries in existing translations file.');
+        let normalizedContent = existingContent.replace(/\s+/g, ' ');
+        let labelsPattern = /labels\s*:\s*\{/;
+        let labelsMatch = normalizedContent.match(labelsPattern);
+        if(!labelsMatch){
+            Logger.error('Could not find labels object in translations file.');
+            return false;
+        }
+        let labelsStart = existingContent.indexOf(labelsMatch[0]);
+        let searchStart = labelsStart + labelsMatch[0].length;
+        let braceCount = 1;
+        let labelsEnd = -1;
+        for(let i = searchStart; i < existingContent.length; i++){
+            if('{' === existingContent[i]){
+                braceCount++;
+            }
+            if('}' === existingContent[i]){
+                braceCount--;
+                if(0 === braceCount){
+                    labelsEnd = i;
+                    break;
+                }
+            }
+        }
+        if(-1 === labelsEnd){
+            Logger.error('Could not find end of labels object.');
             return false;
         }
         let beforeLabelsEnd = existingContent.substring(0, labelsEnd);
-        if(!beforeLabelsEnd.trim().endsWith(',')){
-            beforeLabelsEnd = beforeLabelsEnd.trimEnd() + ',';
+        let contentBeforeEnd = beforeLabelsEnd.trimEnd();
+        let lastChar = contentBeforeEnd[contentBeforeEnd.length - 1];
+        if('{' !== lastChar && ',' !== lastChar){
+            beforeLabelsEnd = contentBeforeEnd + ',';
         }
-        if(!FileHandler.writeFile(
-            this.entitiesTranslationsPath,
-            beforeLabelsEnd + '\n        ' + newTranslations.join(',\n        ') + existingContent.substring(labelsEnd)
-        )){
+        let updatedContent = beforeLabelsEnd + '\n        ' + newTranslations.join(',\n        ') + existingContent.substring(labelsEnd);
+        if(!FileHandler.writeFile(this.entitiesTranslationsPath, updatedContent)){
             Logger.error('Failed to append to entities translations file: '+this.entitiesTranslationsPath);
             return false;
         }
+        Logger.info('Updated translations file with '+newTranslations.length+' new labels.');
         return true;
     }
 
@@ -677,7 +862,9 @@ class EntitiesGenerator
         for(let tableName of Object.keys(allEntities)){
             let entity = allEntities[tableName];
             if(entity.driverKey && driverKey !== entity.driverKey){
-                continue;
+                if(!this.existingModels[tableName] || !this.existingModels[tableName][driverKey]){
+                    continue;
+                }
             }
             let modelClassName = entity.modelClassName || sc.capitalizedCamelCase(tableName)+'Model';
             let modelFileName = entity.modelFileName || sc.kebabCase(tableName)+'-model.js';
@@ -694,7 +881,9 @@ class EntitiesGenerator
         for(let tableName of Object.keys(allEntities)){
             let entity = allEntities[tableName];
             if(entity.driverKey && driverKey !== entity.driverKey){
-                continue;
+                if(!this.existingModels[tableName] || !this.existingModels[tableName][driverKey]){
+                    continue;
+                }
             }
             let modelClassName = entity.modelClassName || sc.capitalizedCamelCase(tableName)+'Model';
             registeredEntitiesObject.push(sc.camelCase(tableName)+': '+modelClassName);
@@ -731,10 +920,6 @@ class EntitiesGenerator
             return false;
         }
         this.detectExistingEntities();
-        let tablesToGenerate = this.filterTablesToGenerate(tables);
-        if(0 === Object.keys(tablesToGenerate).length && !this.isOverride){
-            return true;
-        }
         let driverKey = sc.get(
             this.connectionData,
             'driver',
@@ -744,6 +929,10 @@ class EntitiesGenerator
             Logger.critical('Failed to fetch driver key.');
             return false;
         }
+        let tablesToGenerate = this.filterTablesToGenerate(tables, driverKey);
+        if(0 === Object.keys(tablesToGenerate).length && !this.isOverride){
+            return true;
+        }
         for(let tableName of Object.keys(tablesToGenerate)){
             let tableData = tablesToGenerate[tableName];
             await this.generateEntityFile(tableName, tableData);

package/lib/prisma/prisma-driver.js

@@ -32,6 +32,7 @@ class PrismaDriver extends BaseDriver
         this.requiredFields = [];
         this.fieldTypes = {};
         this.idFieldType = 'String';
+        this.referenceFields = {};
         this.initFieldMetadata();
     }
 
@@ -55,6 +56,13 @@ class PrismaDriver extends BaseDriver
                 if(field.isId){
                     this.idFieldType = field.type;
                 }
+                if(field.kind === 'scalar' && field.isList === false){
+                    let isNumericType = ('Int' === field.type || 'BigInt' === field.type || 'Float' === field.type || 'Decimal' === field.type);
+                    let isReferenceField = field.relationFromFields && 0 < field.relationFromFields.length;
+                    if(isNumericType || isReferenceField){
+                        this.referenceFields[field.name] = field.type;
+                    }
+                }
             }
         } catch(error) {
             Logger.warning('Could not initialize field metadata: '+error.message);
@@ -75,6 +83,26 @@ class PrismaDriver extends BaseDriver
         return String(id);
     }
 
+    castNumericValue(value, fieldType)
+    {
+        if(null === value || undefined === value || '' === value){
+            return null;
+        }
+        if('Int' === fieldType || 'BigInt' === fieldType){
+            let numericValue = Number(value);
+            if(!isNaN(numericValue)){
+                return Math.floor(numericValue);
+            }
+        }
+        if('Float' === fieldType || 'Decimal' === fieldType){
+            let numericValue = Number(value);
+            if(!isNaN(numericValue)){
+                return numericValue;
+            }
+        }
+        return value;
+    }
+
     databaseName()
     {
         return this.config.database || '';
@@ -109,6 +137,10 @@ class PrismaDriver extends BaseDriver
             }
             if(this.isDateTimeField(key)){
                 data[key] = this.convertToDate(data[key], key);
+                continue;
+            }
+            if(sc.hasOwn(this.referenceFields, key)){
+                data[key] = this.castNumericValue(data[key], this.referenceFields[key]);
             }
         }
         return data;
@@ -173,6 +205,12 @@ class PrismaDriver extends BaseDriver
                 if('id' === key && !sc.isArray(operatorValue)){
                     operatorValue = this.castIdValue(operatorValue);
                 }
+                if(sc.hasOwn(this.referenceFields, key) && sc.isArray(operatorValue)){
+                    operatorValue = operatorValue.map(val => this.castNumericValue(val, this.referenceFields[key]));
+                }
+                if(sc.hasOwn(this.referenceFields, key) && !sc.isArray(operatorValue)){
+                    operatorValue = this.castNumericValue(operatorValue, this.referenceFields[key]);
+                }
                 processedFilters[key] = this.applyOperator(operatorValue, value.operator);
                 continue;
             }
@@ -188,6 +226,14 @@ class PrismaDriver extends BaseDriver
                 processedFilters[key] = this.castIdValue(value);
                 continue;
             }
+            if(sc.hasOwn(this.referenceFields, key) && sc.isArray(value)){
+                processedFilters[key] = value.map(val => this.castNumericValue(val, this.referenceFields[key]));
+                continue;
+            }
+            if(sc.hasOwn(this.referenceFields, key)){
+                processedFilters[key] = this.castNumericValue(value, this.referenceFields[key]);
+                continue;
+            }
             processedFilters[key] = value;
         }
         return processedFilters;
@@ -590,11 +636,18 @@ class PrismaDriver extends BaseDriver
     createSingleFilter(field, fieldValue, operator = null)
     {
         let filter = {};
+        let processedValue = fieldValue;
+        if(sc.hasOwn(this.referenceFields, field)){
+            processedValue = this.castNumericValue(fieldValue, this.referenceFields[field]);
+        }
+        if('id' === field){
+            processedValue = this.castIdValue(fieldValue);
+        }
         if(null === operator){
-            filter[field] = fieldValue;
+            filter[field] = processedValue;
             return filter;
         }
-        filter[field] = this.applyOperator(fieldValue, operator);
+        filter[field] = this.applyOperator(processedValue, operator);
         return filter;
     }
 

package/lib/prisma/prisma-schema-generator.js

@@ -21,34 +21,50 @@ 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']);
     }
 
     async generate()
     {
+        FileHandler.createFolder(this.prismaSchemaPath);
+        this.generateSchemaFile();
+        Logger.info('Running prisma introspect "npx prisma db pull"...');
         try {
-            FileHandler.createFolder(this.prismaSchemaPath);
-            this.generateSchemaFile();
-            Logger.info('Running prisma introspect "npx prisma db pull"...');
             execSync('npx prisma db pull', { stdio: 'inherit' });
-            let generateCommand = 'npx prisma generate';
-            if(this.dataProxy){
-                generateCommand += ' --data-proxy';
-            }
-            Logger.info('Running prisma generate "'+generateCommand+'"...');
+        } 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+'"...');
+        try {
             execSync(generateCommand, { stdio: 'inherit' });
-            await this.waitForSchemaGeneration();
-            return true;
         } catch(error) {
-            Logger.critical('Failed to generate Prisma schema. '+error.message);
+            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('Generate command failed: ' + error.message);
+            return false;
         }
-        return false;
+        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) => {
@@ -123,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.52.0",
+    "version": "0.54.0",
     "description": "Reldens - Storage",
     "author": "Damian A. Pastorini",
     "license": "MIT",