@objectql/cli 1.8.2 → 1.8.4

package/src/commands/sync.ts

@@ -0,0 +1,328 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import chalk from 'chalk';
+import * as yaml from 'js-yaml';
+import { IntrospectedSchema, IntrospectedTable, IntrospectedColumn, ObjectConfig, IObjectQL, FieldConfig, FieldType } from '@objectql/types';
+
+interface SyncOptions {
+    config?: string;
+    output?: string;
+    tables?: string[];
+    force?: boolean;
+    app?: IObjectQL; // Allow passing app instance directly for testing
+}
+
+/**
+ * Sync database schema to ObjectQL .object.yml files
+ * Introspects existing SQL database and generates object definitions
+ */
+export async function syncDatabase(options: SyncOptions) {
+    const outputDir = path.resolve(process.cwd(), options.output || './src/objects');
+    
+    console.log(chalk.blue('🔄 Syncing database schema to ObjectQL...'));
+    console.log(chalk.gray(`Output directory: ${outputDir}\n`));
+    
+    let app: IObjectQL | undefined = options.app;
+    const shouldClose = !options.app; // Only close if we loaded it ourselves
+
+    try {
+        // Load ObjectQL instance from config if not provided
+        if (!app) {
+            app = await loadObjectQLInstance(options.config);
+        }
+        
+        // Check if driver supports introspection
+        const driver = app.datasource('default');
+        if (!driver || !driver.introspectSchema) {
+            const errorMsg = 'The configured driver does not support schema introspection. Only SQL drivers (PostgreSQL, MySQL, SQLite) support this feature.';
+            console.error(chalk.red(`❌ ${errorMsg}`));
+            throw new Error(errorMsg);
+        }
+
+        // Introspect database schema
+        console.log(chalk.blue('📊 Introspecting database schema...'));
+        const schema: IntrospectedSchema = await driver.introspectSchema();
+        
+        const tableNames = Object.keys(schema.tables);
+        if (tableNames.length === 0) {
+            console.log(chalk.yellow('⚠ No tables found in database'));
+            return;
+        }
+
+        console.log(chalk.green(`✓ Found ${tableNames.length} table(s)\n`));
+
+        // Filter tables if specified
+        let tablesToSync = tableNames;
+        if (options.tables && options.tables.length > 0) {
+            tablesToSync = tableNames.filter(t => options.tables!.includes(t));
+            if (tablesToSync.length === 0) {
+                console.log(chalk.yellow('⚠ No matching tables found'));
+                return;
+            }
+        }
+
+        // Create output directory if it doesn't exist
+        if (!fs.existsSync(outputDir)) {
+            fs.mkdirSync(outputDir, { recursive: true });
+            console.log(chalk.gray(`Created directory: ${outputDir}\n`));
+        }
+
+        // Generate .object.yml files
+        let createdCount = 0;
+        let skippedCount = 0;
+
+        for (const tableName of tablesToSync) {
+            const table = schema.tables[tableName];
+            const filename = `${tableName}.object.yml`;
+            const filePath = path.join(outputDir, filename);
+
+            // Check if file already exists
+            if (fs.existsSync(filePath) && !options.force) {
+                console.log(chalk.yellow(`⊘ ${tableName} (file exists, use --force to overwrite)`));
+                skippedCount++;
+                continue;
+            }
+
+            // Generate object definition
+            const objectDef = generateObjectDefinition(table, schema);
+            
+            // Write to file
+            const yamlContent = yaml.dump(objectDef, {
+                indent: 2,
+                lineWidth: -1,
+                noRefs: true,
+                sortKeys: false
+            });
+            
+            fs.writeFileSync(filePath, yamlContent, 'utf-8');
+            
+            console.log(chalk.green(`✓ ${tableName} → ${filename}`));
+            createdCount++;
+        }
+
+        console.log(chalk.blue('\n📊 Summary:'));
+        console.log(chalk.gray(`Total tables: ${tablesToSync.length}`));
+        console.log(chalk.gray(`Created: ${createdCount}`));
+        console.log(chalk.gray(`Skipped: ${skippedCount}`));
+        
+        if (createdCount > 0) {
+            console.log(chalk.green(`\n✅ Successfully synced ${createdCount} table(s) to ${outputDir}`));
+        }
+
+    } catch (error: any) {
+        console.error(chalk.red(`❌ Sync failed: ${error.message}`));
+        if (error.stack) {
+            console.error(chalk.gray(error.stack));
+        }
+        throw error;
+    } finally {
+        // Ensure connection is closed if we opened it
+        if (shouldClose && app) {
+            if (app.close) {
+                await app.close();
+            } else {
+                // Fallback for older versions if close isn't available
+                const driver = app.datasource('default');
+                if (driver && (driver as any).disconnect) {
+                    await (driver as any).disconnect();
+                }
+            }
+        }
+    }
+}
+
+/**
+ * Generate ObjectQL object definition from introspected table
+ */
+function generateObjectDefinition(table: IntrospectedTable, schema: IntrospectedSchema): ObjectConfig {
+    const obj: ObjectConfig = {
+        name: table.name,
+        label: formatLabel(table.name),
+        fields: {}
+    };
+
+    // Process each column
+    for (const column of table.columns) {
+        // Skip system fields (id, created_at, updated_at) - they're automatic
+        if (['id', 'created_at', 'updated_at'].includes(column.name)) {
+            continue;
+        }
+
+        const field: Partial<FieldConfig> = {};
+        
+        // Check if this is a foreign key
+        const fk = table.foreignKeys.find(fk => fk.columnName === column.name);
+        if (fk) {
+            // This is a lookup/relationship field
+            field.type = 'lookup';
+            field.reference_to = fk.referencedTable;
+            
+            // Add label
+            field.label = formatLabel(column.name);
+            
+            // Add required constraint
+            if (!column.nullable) {
+                field.required = true;
+            }
+        } else {
+            // Regular field - map SQL type to ObjectQL type
+            const fieldType = mapSqlTypeToObjectQL(column.type, column);
+            field.type = fieldType;
+            
+            // Add label
+            field.label = formatLabel(column.name);
+            
+            // Add constraints
+            if (!column.nullable) {
+                field.required = true;
+            }
+            
+            if (column.isUnique) {
+                field.unique = true;
+            }
+            
+            // Add max_length for text-based fields
+            if (column.maxLength && (fieldType === 'text' || fieldType === 'textarea')) {
+                field.max_length = column.maxLength;
+            }
+            
+            if (column.defaultValue !== undefined && column.defaultValue !== null) {
+                // Only include simple default values
+                if (typeof column.defaultValue === 'string' || 
+                    typeof column.defaultValue === 'number' || 
+                    typeof column.defaultValue === 'boolean') {
+                    field.defaultValue = column.defaultValue;
+                }
+            }
+        }
+
+        obj.fields[column.name] = field as FieldConfig;
+    }
+
+    return obj;
+}
+
+/**
+ * Map SQL native type to ObjectQL field type
+ */
+function mapSqlTypeToObjectQL(sqlType: string, column: IntrospectedColumn): FieldType {
+    const type = sqlType.toLowerCase();
+    
+    // Integer types - map to 'number'
+    if (type.includes('int') || type.includes('serial') || type.includes('bigserial')) {
+        return 'number';
+    }
+    
+    // Float/Decimal types
+    if (type.includes('float') || type.includes('double') || 
+        type.includes('decimal') || type.includes('numeric') || type.includes('real')) {
+        return 'number';
+    }
+    
+    // Boolean
+    if (type.includes('bool') || type === 'bit') {
+        return 'boolean';
+    }
+    
+    // Date/Time types
+    if (type.includes('timestamp') || type.includes('datetime')) {
+        return 'datetime';
+    }
+    if (type === 'date') {
+        return 'date';
+    }
+    if (type === 'time') {
+        return 'time';
+    }
+    
+    // Text types
+    if (type.includes('text') || type.includes('clob') || type.includes('long')) {
+        return 'textarea';
+    }
+    
+    // JSON types - map to 'object'
+    if (type.includes('json') || type.includes('jsonb')) {
+        return 'object';
+    }
+    
+    // Binary/Blob types
+    if (type.includes('blob') || type.includes('binary') || type.includes('bytea')) {
+        return 'file';
+    }
+    
+    // String types (varchar, char, etc.)
+    // Default to 'text' for general string fields
+    return 'text';
+}
+
+/**
+ * Format table/column name to human-readable label
+ * e.g., "user_profile" -> "User Profile"
+ */
+function formatLabel(name: string): string {
+    return name
+        .split('_')
+        .map(word => word.charAt(0).toUpperCase() + word.slice(1))
+        .join(' ');
+}
+
+/**
+ * Load ObjectQL instance from config file
+ */
+async function loadObjectQLInstance(configPath?: string): Promise<IObjectQL> {
+    const cwd = process.cwd();
+    
+    // Try to load from config file
+    let configFile = configPath;
+    if (!configFile) {
+        const potentialFiles = ['objectql.config.ts', 'objectql.config.js'];
+        for (const file of potentialFiles) {
+            if (fs.existsSync(path.join(cwd, file))) {
+                configFile = path.join(cwd, file);
+                break;
+            }
+        }
+    } else if (!path.isAbsolute(configFile)) {
+        // If configPath is provided but relative, make it absolute
+        configFile = path.join(cwd, configFile);
+    }
+
+    if (!configFile) {
+        throw new Error('No configuration file found (objectql.config.ts/js). Please create one with database connection.');
+    }
+
+    // Register ts-node for TypeScript support
+    if (configFile.endsWith('.ts')) {
+        try {
+            require('ts-node').register({
+                transpileOnly: true,
+                compilerOptions: {
+                    module: 'commonjs'
+                }
+            });
+        } catch (err) {
+            throw new Error('TypeScript config file detected but ts-node is not installed. Please run: npm install --save-dev ts-node');
+        }
+    }
+
+    const configModule = require(configFile);
+    
+    // Clear cache to support multiple runs in same process (e.g. tests)
+    try {
+        const resolvedPath = require.resolve(configFile);
+        delete require.cache[resolvedPath];
+    } catch (e) {
+        // Ignore resolution errors
+    }
+
+    // Support multiple export patterns: default, app, objectql, or db (in order of precedence)
+    const app = configModule.default || configModule.app || configModule.objectql || configModule.db;
+
+    if (!app) {
+        throw new Error('Config file must export an ObjectQL instance as default export or named export (app/objectql/db)');
+    }
+
+    // Initialize app (but don't sync schema - we're reading it)
+    await app.init();
+    return app;
+}

package/src/commands/test.ts

@@ -0,0 +1,98 @@
+import * as path from 'path';
+import * as fs from 'fs';
+import chalk from 'chalk';
+import { spawn } from 'child_process';
+
+interface TestOptions {
+    dir?: string;
+    watch?: boolean;
+    coverage?: boolean;
+}
+
+/**
+ * Test command - runs tests for the ObjectQL project
+ */
+export async function test(options: TestOptions) {
+    console.log(chalk.blue('🧪 Running tests...\n'));
+    
+    const rootDir = path.resolve(process.cwd(), options.dir || '.');
+    
+    // Look for package.json to determine test runner
+    const packageJsonPath = path.join(rootDir, 'package.json');
+    let testCommand = 'npm test';
+    
+    try {
+        if (fs.existsSync(packageJsonPath)) {
+            try {
+                const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+                
+                // Check if jest is configured
+                if (packageJson.devDependencies?.jest || packageJson.dependencies?.jest || packageJson.jest) {
+                const jestArgs = ['jest'];
+                
+                if (options.watch) {
+                    jestArgs.push('--watch');
+                }
+                
+                if (options.coverage) {
+                    jestArgs.push('--coverage');
+                }
+                
+                console.log(chalk.cyan(`Running: ${jestArgs.join(' ')}\n`));
+                
+                const jestProcess = spawn('npx', jestArgs, {
+                    cwd: rootDir,
+                    stdio: 'inherit',
+                    shell: true
+                });
+                
+                jestProcess.on('exit', (code) => {
+                    if (code !== 0) {
+                        console.error(chalk.red(`\n❌ Tests failed with exit code ${code}`));
+                        process.exit(code || 1);
+                    } else {
+                        console.log(chalk.green('\n✅ All tests passed!'));
+                    }
+                });
+                
+                return;
+            }
+            
+            // Fall back to package.json test script
+            if (packageJson.scripts?.test) {
+                console.log(chalk.cyan(`Running: npm test\n`));
+                
+                const npmProcess = spawn('npm', ['test'], {
+                    cwd: rootDir,
+                    stdio: 'inherit',
+                    shell: true
+                });
+                
+                npmProcess.on('exit', (code) => {
+                    if (code !== 0) {
+                        console.error(chalk.red(`\n❌ Tests failed with exit code ${code}`));
+                        process.exit(code || 1);
+                    } else {
+                        console.log(chalk.green('\n✅ All tests passed!'));
+                    }
+                });
+                
+                return;
+            }
+            } catch (parseError: any) {
+                console.error(chalk.yellow(`⚠️  Failed to parse package.json: ${parseError.message}`));
+            }
+        }
+        
+        // No test configuration found
+        console.log(chalk.yellow('⚠️  No test configuration found'));
+        console.log(chalk.gray('To add tests to your project:'));
+        console.log(chalk.gray('  1. Install jest: npm install --save-dev jest @types/jest ts-jest'));
+        console.log(chalk.gray('  2. Create a jest.config.js file'));
+        console.log(chalk.gray('  3. Add a test script to package.json'));
+        
+    } catch (e: any) {
+        console.error(chalk.red('❌ Test execution failed:'), e.message);
+        process.exit(1);
+    }
+}

package/src/index.ts

@@ -2,12 +2,18 @@ import { Command } from 'commander';
 import { generateTypes } from './commands/generate';
 import { startRepl } from './commands/repl';
 import { serve } from './commands/serve';
-import { startStudio } from './commands/studio';
+import { dev } from './commands/dev';
+import { start } from './commands/start';
+import { build } from './commands/build';
+import { test } from './commands/test';
+import { lint } from './commands/lint';
+import { format } from './commands/format';
 import { initProject } from './commands/init';
 import { newMetadata } from './commands/new';
 import { i18nExtract, i18nInit, i18nValidate } from './commands/i18n';
 import { migrate, migrateCreate, migrateStatus } from './commands/migrate';
 import { aiGenerate, aiValidate, aiChat, aiConversational } from './commands/ai';
+import { syncDatabase } from './commands/sync';
 
 const program = new Command();
 
@@ -153,6 +159,23 @@ migrateCmd
         }
     });
 
+// Sync command - Introspect database and generate .object.yml files
+program
+    .command('sync')
+    .description('Sync database schema to ObjectQL object definitions')
+    .option('-c, --config <path>', 'Path to objectql.config.ts/js')
+    .option('-o, --output <path>', 'Output directory for .object.yml files', './src/objects')
+    .option('-t, --tables <tables...>', 'Specific tables to sync (default: all)')
+    .option('-f, --force', 'Overwrite existing files')
+    .action(async (options) => {
+        try {
+            await syncDatabase(options);
+        } catch (error) {
+            console.error(error);
+            process.exit(1);
+        }
+    });
+
 // REPL command
 program
     .command('repl')
@@ -163,33 +186,110 @@ program
         await startRepl(options.config);
     });
 
-// Serve command
+// Dev command - Start development server
 program
-    .command('serve')
-    .alias('s')
-    .description('Start a development server')
+    .command('dev')
+    .alias('d')
+    .description('Start development server with hot reload')
     .option('-p, --port <number>', 'Port to listen on', '3000')
     .option('-d, --dir <path>', 'Directory containing schema', '.')
+    .option('--no-watch', 'Disable file watching')
     .action(async (options) => {
-        await serve({ port: parseInt(options.port), dir: options.dir });
+        await dev({ 
+            port: parseInt(options.port), 
+            dir: options.dir,
+            watch: options.watch
+        });
     });
 
-// Studio command
+// Start command - Production server
 program
-    .command('studio')
-    .alias('ui')
-    .description('Start the ObjectQL Studio')
-    .option('-p, --port <number>', 'Port to listen on', '5555')
+    .command('start')
+    .description('Start production server')
+    .option('-p, --port <number>', 'Port to listen on', '3000')
     .option('-d, --dir <path>', 'Directory containing schema', '.')
-    .option('--no-open', 'Do not open browser automatically')
+    .option('-c, --config <path>', 'Path to objectql.config.ts/js')
     .action(async (options) => {
-        await startStudio({ 
+        await start({ 
             port: parseInt(options.port), 
             dir: options.dir,
-            open: options.open
+            config: options.config
+        });
+    });
+
+// Build command - Build project for production
+program
+    .command('build')
+    .alias('b')
+    .description('Build project and generate types')
+    .option('-d, --dir <path>', 'Source directory', '.')
+    .option('-o, --output <path>', 'Output directory', './dist')
+    .option('--no-types', 'Skip TypeScript type generation')
+    .option('--no-validate', 'Skip metadata validation')
+    .action(async (options) => {
+        await build({
+            dir: options.dir,
+            output: options.output,
+            types: options.types,
+            validate: options.validate
+        });
+    });
+
+// Test command - Run tests
+program
+    .command('test')
+    .alias('t')
+    .description('Run tests')
+    .option('-d, --dir <path>', 'Project directory', '.')
+    .option('-w, --watch', 'Watch mode')
+    .option('--coverage', 'Generate coverage report')
+    .action(async (options) => {
+        await test({
+            dir: options.dir,
+            watch: options.watch,
+            coverage: options.coverage
+        });
+    });
+
+// Lint command - Validate metadata
+program
+    .command('lint')
+    .alias('l')
+    .description('Validate metadata files')
+    .option('-d, --dir <path>', 'Directory to lint', '.')
+    .option('--fix', 'Automatically fix issues')
+    .action(async (options) => {
+        await lint({
+            dir: options.dir,
+            fix: options.fix
+        });
+    });
+
+// Format command - Format metadata files
+program
+    .command('format')
+    .alias('fmt')
+    .description('Format metadata files with Prettier')
+    .option('-d, --dir <path>', 'Directory to format', '.')
+    .option('--check', 'Check if files are formatted without modifying')
+    .action(async (options) => {
+        await format({
+            dir: options.dir,
+            check: options.check
         });
     });
 
+// Serve command (kept for backwards compatibility)
+program
+    .command('serve')
+    .alias('s')
+    .description('Start a development server (alias for dev)')
+    .option('-p, --port <number>', 'Port to listen on', '3000')
+    .option('-d, --dir <path>', 'Directory containing schema', '.')
+    .action(async (options) => {
+        await serve({ port: parseInt(options.port), dir: options.dir });
+    });
+
 // AI command - Interactive by default, with specific subcommands for other modes
 const aiCmd = program
     .command('ai')