@reldens/storage 0.53.0 → 0.55.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,83 +7,152 @@
  */
 
 const { PrismaSchemaGenerator } = require('../lib/prisma/prisma-schema-generator');
-const { FileHandler } = require('@reldens/server-utils');
-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: FileHandler.joinPaths(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);
 });