@objectql/cli 1.8.3 → 1.8.4

package/src/commands/start.ts

@@ -0,0 +1,100 @@
+import { ObjectQL } from '@objectql/core';
+import { SqlDriver } from '@objectql/driver-sql';
+import { ObjectLoader } from '@objectql/platform-node';
+import { createNodeHandler } from '@objectql/server';
+import { createServer } from 'http';
+import * as path from 'path';
+import * as fs from 'fs';
+import chalk from 'chalk';
+
+interface StartOptions {
+    port: number;
+    dir: string;
+    config?: string;
+}
+
+// Flexible config type that handles both ObjectQLConfig and custom config formats
+interface LoadedConfig {
+    datasources?: Record<string, any>;
+    datasource?: Record<string, any>;
+    [key: string]: any;
+}
+
+/**
+ * Start production server
+ * Loads configuration from objectql.config.ts/js if available
+ */
+export async function start(options: StartOptions) {
+    console.log(chalk.blue('Starting ObjectQL Production Server...'));
+    
+    const rootDir = path.resolve(process.cwd(), options.dir);
+    console.log(chalk.gray(`Loading schema from: ${rootDir}`));
+
+    // Try to load configuration
+    let config: LoadedConfig | null = null;
+    const configPath = options.config || path.join(process.cwd(), 'objectql.config.ts');
+    
+    if (fs.existsSync(configPath)) {
+        try {
+            console.log(chalk.gray(`Loading config from: ${configPath}`));
+            // Use require for .js files or ts-node for .ts files
+            if (configPath.endsWith('.ts')) {
+                require('ts-node/register');
+            }
+            const loadedModule = require(configPath);
+            // Handle both default export and direct export
+            config = loadedModule.default || loadedModule;
+        } catch (e: any) {
+            console.warn(chalk.yellow(`⚠️  Failed to load config: ${e.message}`));
+        }
+    }
+
+    // Initialize datasource from config or use default SQLite
+    // Note: Config files may use 'datasource' (singular) while ObjectQLConfig uses 'datasources' (plural)
+    const datasourceConfig = config?.datasources?.default || config?.datasource?.default || {
+        client: 'sqlite3',
+        connection: {
+            filename: process.env.DATABASE_FILE || './objectql.db'
+        },
+        useNullAsDefault: true
+    };
+
+    const driver = new SqlDriver(datasourceConfig);
+    const app = new ObjectQL({
+        datasources: { default: driver }
+    });
+
+    // Load Schema
+    try {
+        const loader = new ObjectLoader(app.metadata);
+        loader.load(rootDir);
+        await app.init();
+        console.log(chalk.green('✅ Schema loaded successfully.'));
+    } catch (e: any) {
+        console.error(chalk.red('❌ Failed to load schema:'), e.message);
+        process.exit(1);
+    }
+
+    // Create Handler
+    const handler = createNodeHandler(app);
+
+    // Start Server
+    const server = createServer(async (req, res) => {
+        await handler(req, res);
+    });
+    
+    server.listen(options.port, () => {
+        console.log(chalk.green(`\n✅ Server started in production mode`));
+        console.log(chalk.green(`🚀 API endpoint: http://localhost:${options.port}`));
+        console.log(chalk.blue(`📖 OpenAPI Spec: http://localhost:${options.port}/openapi.json`));
+        
+        // Handle graceful shutdown
+        process.on('SIGTERM', () => {
+            console.log(chalk.yellow('\n⚠️  SIGTERM received, shutting down gracefully...'));
+            server.close(() => {
+                console.log(chalk.green('✅ Server closed'));
+                process.exit(0);
+            });
+        });
+    });
+}

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,7 +2,12 @@ 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';
@@ -181,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')