@objectql/cli 1.8.4 → 1.9.0

package/src/commands/init.ts

@@ -1,191 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import { exec } from 'child_process';
-import { promisify } from 'util';
-import chalk from 'chalk';
-
-const execAsync = promisify(exec);
-
-interface InitOptions {
-    template?: string;
-    name?: string;
-    dir?: string;
-    skipInstall?: boolean;
-    skipGit?: boolean;
-}
-
-const TEMPLATES = {
-    basic: '@objectql/starter-basic',
-    'express-api': '@objectql/starter-express-api',
-    enterprise: '@objectql/starter-enterprise'
-};
-
-export async function initProject(options: InitOptions) {
-    const projectName = options.name || 'my-objectql-project';
-    const targetDir = options.dir || path.join(process.cwd(), projectName);
-    const template = (options.template || 'basic') as keyof typeof TEMPLATES;
-
-    if (!TEMPLATES[template]) {
-        console.error(chalk.red(`❌ Unknown template: ${template}`));
-        console.log(chalk.gray(`Available templates: ${Object.keys(TEMPLATES).join(', ')}`));
-        process.exit(1);
-    }
-
-    console.log(chalk.blue(`\n🚀 Initializing ObjectQL project: ${chalk.bold(projectName)}`));
-    console.log(chalk.gray(`Template: ${template}`));
-    console.log(chalk.gray(`Directory: ${targetDir}\n`));
-
-    // Check if directory exists
-    if (fs.existsSync(targetDir)) {
-        console.error(chalk.red(`❌ Directory already exists: ${targetDir}`));
-        process.exit(1);
-    }
-
-    // Create project directory
-    fs.mkdirSync(targetDir, { recursive: true });
-
-    try {
-        // Copy template files from starters
-        const templatePath = path.join(__dirname, '../../../../starters', template);
-        
-        // Check if we're in the monorepo (for development)
-        if (fs.existsSync(templatePath)) {
-            console.log(chalk.gray('Copying template files...'));
-            await copyDirectory(templatePath, targetDir, ['node_modules', 'dist', '.git']);
-        } else {
-            // Try to use the published package
-            console.log(chalk.gray(`Installing template from npm: ${TEMPLATES[template]}...`));
-            await execAsync(`npm create ${TEMPLATES[template]} ${targetDir}`, { 
-                cwd: process.cwd() 
-            });
-        }
-
-        // Update package.json with project name
-        const pkgPath = path.join(targetDir, 'package.json');
-        if (fs.existsSync(pkgPath)) {
-            const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
-            pkg.name = projectName;
-            pkg.version = '0.1.0';
-            // Convert workspace dependencies to actual versions for standalone project
-            if (pkg.dependencies) {
-                for (const dep of Object.keys(pkg.dependencies)) {
-                    if (pkg.dependencies[dep] === 'workspace:*') {
-                        pkg.dependencies[dep] = '^1.0.0'; // Use latest published version
-                    }
-                }
-            }
-            if (pkg.devDependencies) {
-                for (const dep of Object.keys(pkg.devDependencies)) {
-                    if (pkg.devDependencies[dep] === 'workspace:*') {
-                        pkg.devDependencies[dep] = '^1.0.0';
-                    }
-                }
-            }
-            fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2));
-        }
-
-        // Initialize git repository
-        if (!options.skipGit) {
-            try {
-                console.log(chalk.gray('\nInitializing git repository...'));
-                await execAsync('git init', { cwd: targetDir });
-                
-                // Create .gitignore if it doesn't exist
-                const gitignorePath = path.join(targetDir, '.gitignore');
-                if (!fs.existsSync(gitignorePath)) {
-                    const gitignore = `node_modules/
-dist/
-*.log
-.DS_Store
-*.sqlite3
-.env
-.env.local
-`;
-                    fs.writeFileSync(gitignorePath, gitignore);
-                }
-                
-                console.log(chalk.green('✓ Git repository initialized'));
-            } catch (err) {
-                console.log(chalk.yellow('⚠ Git initialization skipped (git not available)'));
-            }
-        }
-
-        // Install dependencies
-        if (!options.skipInstall) {
-            console.log(chalk.gray('\nInstalling dependencies...'));
-            console.log(chalk.gray('This might take a few minutes...\n'));
-            
-            try {
-                // Try pnpm first, fall back to npm
-                const hasNpm = await checkCommand('pnpm');
-                const packageManager = hasNpm ? 'pnpm' : 'npm';
-                
-                await execAsync(`${packageManager} install`, { 
-                    cwd: targetDir,
-                    // Show output in real-time would be better, but this is simpler
-                });
-                console.log(chalk.green(`✓ Dependencies installed with ${packageManager}`));
-            } catch (err: any) {
-                console.log(chalk.yellow(`⚠ Failed to install dependencies: ${err.message}`));
-                console.log(chalk.gray(`You can install them manually by running:`));
-                console.log(chalk.gray(`  cd ${projectName} && npm install`));
-            }
-        }
-
-        // Success message
-        console.log(chalk.green('\n✅ Project created successfully!\n'));
-        console.log(chalk.bold('Next steps:'));
-        console.log(chalk.gray(`  cd ${projectName}`));
-        
-        if (options.skipInstall) {
-            console.log(chalk.gray('  pnpm install  # or npm install'));
-        }
-        
-        console.log(chalk.gray('  pnpm run build'));
-        console.log(chalk.gray('  pnpm run repl\n'));
-        
-        console.log(chalk.blue('📚 Documentation: https://github.com/objectql/objectql'));
-
-    } catch (error: any) {
-        console.error(chalk.red(`\n❌ Failed to create project: ${error.message}`));
-        // Clean up
-        if (fs.existsSync(targetDir)) {
-            fs.rmSync(targetDir, { recursive: true, force: true });
-        }
-        process.exit(1);
-    }
-}
-
-async function copyDirectory(src: string, dest: string, ignore: string[] = []) {
-    // Create destination directory
-    if (!fs.existsSync(dest)) {
-        fs.mkdirSync(dest, { recursive: true });
-    }
-
-    const entries = fs.readdirSync(src, { withFileTypes: true });
-
-    for (const entry of entries) {
-        const srcPath = path.join(src, entry.name);
-        const destPath = path.join(dest, entry.name);
-
-        // Skip ignored directories
-        if (ignore.includes(entry.name)) {
-            continue;
-        }
-
-        if (entry.isDirectory()) {
-            await copyDirectory(srcPath, destPath, ignore);
-        } else {
-            fs.copyFileSync(srcPath, destPath);
-        }
-    }
-}
-
-async function checkCommand(cmd: string): Promise<boolean> {
-    try {
-        await execAsync(`${cmd} --version`);
-        return true;
-    } catch {
-        return false;
-    }
-}

package/src/commands/lint.ts

@@ -1,98 +0,0 @@
-import { ObjectQL } from '@objectql/core';
-import { ObjectLoader } from '@objectql/platform-node';
-import { ObjectConfig, FieldConfig } from '@objectql/types';
-import * as path from 'path';
-import chalk from 'chalk';
-
-// Naming convention regex
-const VALID_NAME_REGEX = /^[a-z][a-z0-9_]*$/;
-
-interface LintOptions {
-    dir?: string;
-    fix?: boolean;
-}
-
-/**
- * Lint command - validates metadata files for correctness and best practices
- */
-export async function lint(options: LintOptions) {
-    console.log(chalk.blue('🔍 Linting ObjectQL metadata files...\n'));
-    
-    const rootDir = path.resolve(process.cwd(), options.dir || '.');
-    let hasErrors = false;
-    let hasWarnings = false;
-    
-    try {
-        const app = new ObjectQL({ datasources: {} });
-        const loader = new ObjectLoader(app.metadata);
-        
-        console.log(chalk.cyan('Loading metadata files...'));
-        loader.load(rootDir);
-        
-        const objects = app.metadata.list('object');
-        
-        console.log(chalk.green(`✅ Found ${objects.length} object(s)\n`));
-        
-        // Validate each object
-        for (const obj of objects) {
-            const objectConfig = obj as ObjectConfig;
-            const name = objectConfig.name;
-            console.log(chalk.cyan(`Checking object: ${name}`));
-            
-            // Check naming convention (lowercase with underscores)
-            if (!VALID_NAME_REGEX.test(name)) {
-                console.log(chalk.red(`  ❌ Invalid name format: "${name}" should be lowercase with underscores`));
-                hasErrors = true;
-            }
-            
-            // Check if label exists
-            if (!objectConfig.label) {
-                console.log(chalk.yellow(`  ⚠️  Missing label for object "${name}"`));
-                hasWarnings = true;
-            }
-            
-            // Check fields
-            const fieldCount = Object.keys(objectConfig.fields || {}).length;
-            if (fieldCount === 0) {
-                console.log(chalk.yellow(`  ⚠️  Object "${name}" has no fields defined`));
-                hasWarnings = true;
-            } else {
-                console.log(chalk.gray(`  ℹ️  ${fieldCount} field(s) defined`));
-            }
-            
-            // Validate field names
-            for (const [fieldName, field] of Object.entries(objectConfig.fields || {})) {
-                if (!VALID_NAME_REGEX.test(fieldName)) {
-                    console.log(chalk.red(`  ❌ Invalid field name: "${fieldName}" should be lowercase with underscores`));
-                    hasErrors = true;
-                }
-                
-                const fieldConfig = field as FieldConfig;
-                // Check for required label on fields
-                if (!fieldConfig.label) {
-                    console.log(chalk.yellow(`  ⚠️  Field "${fieldName}" missing label`));
-                    hasWarnings = true;
-                }
-            }
-            
-            console.log('');
-        }
-        
-        // Summary
-        if (hasErrors) {
-            console.log(chalk.red.bold('❌ Linting failed with errors\n'));
-            process.exit(1);
-        } else if (hasWarnings) {
-            console.log(chalk.yellow.bold('⚠️  Linting completed with warnings\n'));
-        } else {
-            console.log(chalk.green.bold('✅ Linting passed - no issues found!\n'));
-        }
-        
-    } catch (e: any) {
-        console.error(chalk.red('❌ Linting failed:'), e.message);
-        if (e.stack) {
-            console.error(chalk.gray(e.stack));
-        }
-        process.exit(1);
-    }
-}

package/src/commands/migrate.ts

@@ -1,314 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import chalk from 'chalk';
-
-interface MigrateOptions {
-    config?: string;
-    dir?: string;
-}
-
-interface MigrateCreateOptions {
-    name: string;
-    dir?: string;
-}
-
-interface MigrateStatusOptions {
-    config?: string;
-    dir?: string;
-}
-
-const MIGRATION_TEMPLATE = `import { ObjectQL } from '@objectql/core';
-
-/**
- * Migration: {{name}}
- * Created: {{timestamp}}
- */
-export async function up(app: ObjectQL) {
-    // TODO: Implement migration logic
-    console.log('Running migration: {{name}}');
-    
-    // Example: Add a new field to an object
-    // const tasks = app.getObject('tasks');
-    // await tasks.updateSchema({
-    //     fields: {
-    //         new_field: { type: 'text', label: 'New Field' }
-    //     }
-    // });
-}
-
-export async function down(app: ObjectQL) {
-    // TODO: Implement rollback logic
-    console.log('Rolling back migration: {{name}}');
-    
-    // Example: Remove the field
-    // const tasks = app.getObject('tasks');
-    // await tasks.updateSchema({
-    //     fields: {
-    //         new_field: undefined
-    //     }
-    // });
-}
-`;
-
-/**
- * Run pending migrations
- */
-export async function migrate(options: MigrateOptions) {
-    const migrationsDir = path.resolve(process.cwd(), options.dir || './migrations');
-    
-    console.log(chalk.blue('🔄 Running migrations...'));
-    console.log(chalk.gray(`Migrations directory: ${migrationsDir}\n`));
-
-    if (!fs.existsSync(migrationsDir)) {
-        console.log(chalk.yellow('⚠ No migrations directory found'));
-        console.log(chalk.gray('Create one with: objectql migrate:create --name init'));
-        return;
-    }
-
-    try {
-        // Load ObjectQL instance from config
-        const app = await loadObjectQLInstance(options.config);
-
-        // Get list of migration files
-        const files = fs.readdirSync(migrationsDir)
-            .filter(f => f.endsWith('.ts') || f.endsWith('.js'))
-            .sort();
-
-        if (files.length === 0) {
-            console.log(chalk.yellow('⚠ No migration files found'));
-            return;
-        }
-
-        // Get already run migrations
-        const migrations = app.getObject('_migrations');
-        let runMigrations: string[] = [];
-        
-        try {
-            const result = await migrations.find({
-                fields: ['name'],
-                sort: [['created_at', 'asc']]
-            });
-            runMigrations = result.records.map((r: any) => r.name);
-        } catch (err) {
-            // Migrations table doesn't exist yet, create it
-            console.log(chalk.gray('Creating migrations tracking table...'));
-            await createMigrationsTable(app);
-        }
-
-        // Run pending migrations
-        let ranCount = 0;
-        for (const file of files) {
-            const migrationName = file.replace(/\.(ts|js)$/, '');
-            
-            if (runMigrations.includes(migrationName)) {
-                console.log(chalk.gray(`⊘ ${migrationName} (already run)`));
-                continue;
-            }
-
-            console.log(chalk.blue(`▶ ${migrationName}`));
-
-            const migrationPath = path.join(migrationsDir, file);
-            const migration = require(migrationPath);
-
-            if (!migration.up) {
-                console.log(chalk.red(`  ✗ No 'up' function found`));
-                continue;
-            }
-
-            try {
-                await migration.up(app);
-                
-                // Record migration
-                await migrations.insert({
-                    name: migrationName,
-                    run_at: new Date()
-                });
-
-                console.log(chalk.green(`  ✓ Complete`));
-                ranCount++;
-            } catch (error: any) {
-                console.log(chalk.red(`  ✗ Failed: ${error.message}`));
-                throw error;
-            }
-        }
-
-        console.log(chalk.green(`\n✅ Ran ${ranCount} migration(s)`));
-
-    } catch (error: any) {
-        console.error(chalk.red(`❌ Migration failed: ${error.message}`));
-        process.exit(1);
-    }
-}
-
-/**
- * Create a new migration file with boilerplate code
- */
-export async function migrateCreate(options: MigrateCreateOptions) {
-    const { name } = options;
-    const migrationsDir = path.resolve(process.cwd(), options.dir || './migrations');
-
-    // Validate name
-    if (!name || !/^[a-z][a-z0-9_]*$/.test(name)) {
-        console.error(chalk.red('❌ Invalid migration name. Use lowercase with underscores (e.g., add_status_field)'));
-        process.exit(1);
-    }
-
-    // Create migrations directory if it doesn't exist
-    if (!fs.existsSync(migrationsDir)) {
-        fs.mkdirSync(migrationsDir, { recursive: true });
-        console.log(chalk.gray(`Created directory: ${migrationsDir}`));
-    }
-
-    // Generate filename with timestamp
-    const timestamp = new Date().toISOString().replace(/[:\-T.]/g, '').slice(0, 14);
-    const filename = `${timestamp}_${name}.ts`;
-    const filePath = path.join(migrationsDir, filename);
-
-    // Create migration file from template
-    const content = MIGRATION_TEMPLATE
-        .replace(/\{\{name\}\}/g, name)
-        .replace(/\{\{timestamp\}\}/g, new Date().toISOString());
-
-    fs.writeFileSync(filePath, content, 'utf-8');
-
-    console.log(chalk.green(`✅ Created migration: ${filename}`));
-    console.log(chalk.gray(`Path: ${filePath}`));
-    console.log(chalk.gray(`\nNext steps:`));
-    console.log(chalk.gray(`  1. Edit the migration file to add your changes`));
-    console.log(chalk.gray(`  2. Run: objectql migrate`));
-}
-
-/**
- * Show migration status - displays pending and completed migrations
- * @param options - Configuration options including config path and migrations directory
- */
-export async function migrateStatus(options: MigrateStatusOptions) {
-    const migrationsDir = path.resolve(process.cwd(), options.dir || './migrations');
-
-    console.log(chalk.blue('📊 Migration Status\n'));
-
-    if (!fs.existsSync(migrationsDir)) {
-        console.log(chalk.yellow('⚠ No migrations directory found'));
-        return;
-    }
-
-    try {
-        // Load ObjectQL instance
-        const app = await loadObjectQLInstance(options.config);
-
-        // Get list of migration files
-        const files = fs.readdirSync(migrationsDir)
-            .filter(f => f.endsWith('.ts') || f.endsWith('.js'))
-            .sort();
-
-        if (files.length === 0) {
-            console.log(chalk.gray('No migration files found'));
-            return;
-        }
-
-        // Get run migrations
-        const migrations = app.getObject('_migrations');
-        let runMigrations: string[] = [];
-        
-        try {
-            const result = await migrations.find({
-                fields: ['name', 'run_at'],
-                sort: [['run_at', 'asc']]
-            });
-            runMigrations = result.records.map((r: any) => r.name);
-        } catch (err) {
-            // Migrations table doesn't exist
-            runMigrations = [];
-        }
-
-        // Display status
-        let pendingCount = 0;
-        for (const file of files) {
-            const migrationName = file.replace(/\.(ts|js)$/, '');
-            const isRun = runMigrations.includes(migrationName);
-
-            if (isRun) {
-                console.log(chalk.green(`✓ ${migrationName}`));
-            } else {
-                console.log(chalk.yellow(`○ ${migrationName} (pending)`));
-                pendingCount++;
-            }
-        }
-
-        console.log(chalk.blue(`\n📊 Summary:`));
-        console.log(chalk.gray(`Total migrations: ${files.length}`));
-        console.log(chalk.gray(`Run: ${files.length - pendingCount}`));
-        console.log(chalk.gray(`Pending: ${pendingCount}`));
-
-    } catch (error: any) {
-        console.error(chalk.red(`❌ Failed to get status: ${error.message}`));
-        process.exit(1);
-    }
-}
-
-async function loadObjectQLInstance(configPath?: string): Promise<any> {
-    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 = file;
-                break;
-            }
-        }
-    }
-
-    if (!configFile) {
-        throw new Error('No configuration file found (objectql.config.ts/js)');
-    }
-
-    // Register ts-node for TypeScript support
-    try {
-        require('ts-node').register({
-            transpileOnly: true,
-            compilerOptions: {
-                module: 'commonjs'
-            }
-        });
-    } catch (err) {
-        // ts-node not available, try to load JS directly
-    }
-
-    const configModule = require(path.join(cwd, configFile));
-    const app = configModule.default || configModule.app || configModule.objectql || configModule.db;
-
-    if (!app) {
-        throw new Error('Config file must export an ObjectQL instance');
-    }
-
-    await app.init();
-    return app;
-}
-
-async function createMigrationsTable(app: any) {
-    // Create a system object to track migrations
-    app.metadata.register('object', {
-        name: '_migrations',
-        label: 'Migrations',
-        system: true,
-        fields: {
-            name: {
-                type: 'text',
-                label: 'Migration Name',
-                required: true,
-                unique: true
-            },
-            run_at: {
-                type: 'datetime',
-                label: 'Run At',
-                required: true
-            }
-        }
-    });
-
-    // Sync to database
-    await app.getObject('_migrations').sync();
-}