@objectql/cli 1.6.0 → 1.7.0

package/src/commands/migrate.ts

@@ -0,0 +1,314 @@
+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();
+}

package/src/commands/new.ts

@@ -0,0 +1,268 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import chalk from 'chalk';
+import * as yaml from 'js-yaml';
+
+interface NewOptions {
+    type: string;
+    name: string;
+    dir?: string;
+}
+
+const METADATA_TYPES = [
+    'object',
+    'view',
+    'form',
+    'page',
+    'action',
+    'hook',
+    'permission',
+    'validation',
+    'workflow',
+    'report',
+    'menu',
+    'data'
+];
+
+const TEMPLATES: Record<string, any> = {
+    object: {
+        label: '{{label}}',
+        fields: {
+            name: {
+                type: 'text',
+                label: 'Name',
+                required: true
+            }
+        }
+    },
+    view: {
+        label: '{{label}} View',
+        object: '{{objectName}}',
+        columns: [
+            { field: 'name', label: 'Name' }
+        ]
+    },
+    form: {
+        label: '{{label}} Form',
+        object: '{{objectName}}',
+        layout: {
+            sections: [
+                {
+                    label: 'Basic Information',
+                    fields: ['name']
+                }
+            ]
+        }
+    },
+    page: {
+        label: '{{label}} Page',
+        type: 'standard',
+        components: [
+            {
+                type: 'title',
+                text: '{{label}}'
+            }
+        ]
+    },
+    action: {
+        label: '{{label}} Action',
+        object: '{{objectName}}',
+        type: 'record',
+        handler: 'action_{{name}}'
+    },
+    permission: {
+        label: '{{label}} Permissions',
+        object: '{{objectName}}',
+        profiles: {
+            admin: {
+                allow_read: true,
+                allow_create: true,
+                allow_edit: true,
+                allow_delete: true
+            },
+            user: {
+                allow_read: true,
+                allow_create: false,
+                allow_edit: false,
+                allow_delete: false
+            }
+        }
+    },
+    validation: {
+        label: '{{label}} Validation',
+        object: '{{objectName}}',
+        rules: [
+            {
+                name: 'required_name',
+                type: 'field',
+                field: 'name',
+                rule: 'required',
+                message: 'Name is required'
+            }
+        ]
+    },
+    workflow: {
+        label: '{{label}} Workflow',
+        object: '{{objectName}}',
+        trigger: 'on_create',
+        actions: [
+            {
+                type: 'field_update',
+                field: 'status',
+                value: 'draft'
+            }
+        ]
+    },
+    report: {
+        label: '{{label}} Report',
+        type: 'tabular',
+        object: '{{objectName}}',
+        columns: [
+            { field: 'name', label: 'Name' }
+        ]
+    },
+    menu: {
+        label: '{{label}} Menu',
+        items: [
+            {
+                label: 'Home',
+                page: 'home',
+                icon: 'home'
+            }
+        ]
+    },
+    data: {
+        label: '{{label}} Data',
+        object: '{{objectName}}',
+        records: []
+    }
+};
+
+export async function newMetadata(options: NewOptions) {
+    const { type, name, dir = '.' } = options;
+
+    // Validate type
+    if (!METADATA_TYPES.includes(type)) {
+        console.error(chalk.red(`❌ Unknown metadata type: ${type}`));
+        console.log(chalk.gray(`Available types: ${METADATA_TYPES.join(', ')}`));
+        process.exit(1);
+    }
+
+    // Validate name
+    if (!name || !/^[a-z][a-z0-9_]*$/.test(name)) {
+        console.error(chalk.red('❌ Invalid name. Must be lowercase with underscores (e.g., my_object)'));
+        process.exit(1);
+    }
+
+    const targetDir = path.resolve(process.cwd(), dir);
+    
+    // Create directory if it doesn't exist
+    if (!fs.existsSync(targetDir)) {
+        fs.mkdirSync(targetDir, { recursive: true });
+    }
+
+    const filename = `${name}.${type}.yml`;
+    const filePath = path.join(targetDir, filename);
+
+    // Check if file already exists
+    if (fs.existsSync(filePath)) {
+        console.error(chalk.red(`❌ File already exists: ${filePath}`));
+        process.exit(1);
+    }
+
+    // Get template and replace placeholders
+    let template = TEMPLATES[type];
+    const label = nameToLabel(name);
+    const objectName = type === 'object' ? name : extractObjectName(name);
+
+    template = JSON.parse(
+        JSON.stringify(template)
+            .replace(/\{\{label\}\}/g, label)
+            .replace(/\{\{name\}\}/g, name)
+            .replace(/\{\{objectName\}\}/g, objectName)
+    );
+
+    // Write YAML file
+    const yamlContent = yaml.dump(template, {
+        indent: 2,
+        lineWidth: 120,
+        noRefs: true
+    });
+
+    fs.writeFileSync(filePath, yamlContent, 'utf-8');
+
+    console.log(chalk.green(`✅ Created ${filename}`));
+    console.log(chalk.gray(`   Path: ${filePath}`));
+
+    // If it's an action or hook, also create the TypeScript implementation file
+    if (type === 'action' || type === 'hook') {
+        await createTsImplementation(type, name, targetDir);
+    }
+}
+
+async function createTsImplementation(type: 'action' | 'hook', name: string, dir: string) {
+    const filename = `${name}.${type}.ts`;
+    const filePath = path.join(dir, filename);
+
+    if (fs.existsSync(filePath)) {
+        console.log(chalk.yellow(`⚠ TypeScript file already exists: ${filename}`));
+        return;
+    }
+
+    let template = '';
+
+    if (type === 'action') {
+        template = `import { ActionContext } from '@objectql/types';
+
+export async function action_${name}(context: ActionContext) {
+    const { record, user } = context;
+    
+    // TODO: Implement action logic
+    console.log('Action ${name} triggered for record:', record._id);
+    
+    return {
+        success: true,
+        message: 'Action completed successfully'
+    };
+}
+`;
+    } else if (type === 'hook') {
+        template = `import { HookContext } from '@objectql/types';
+
+export async function beforeInsert(context: HookContext) {
+    const { doc } = context;
+    
+    // TODO: Implement before insert logic
+    console.log('Before insert hook for ${name}');
+    
+    // Modify doc as needed
+    return doc;
+}
+
+export async function afterInsert(context: HookContext) {
+    const { doc } = context;
+    
+    // TODO: Implement after insert logic
+    console.log('After insert hook for ${name}');
+}
+`;
+    }
+
+    fs.writeFileSync(filePath, template, 'utf-8');
+    console.log(chalk.green(`✅ Created ${filename}`));
+    console.log(chalk.gray(`   Path: ${filePath}`));
+}
+
+function nameToLabel(name: string): string {
+    return name
+        .split('_')
+        .map(word => word.charAt(0).toUpperCase() + word.slice(1))
+        .join(' ');
+}
+
+function extractObjectName(name: string): string {
+    // Try to extract object name from name like "project_status" -> "project"
+    // This is a heuristic and might not always be correct
+    const parts = name.split('_');
+    return parts[0];
+}

package/src/commands/studio.ts

@@ -42,7 +42,7 @@ function openBrowser(url: string) {
 }
 
 export async function startStudio(options: { port: number; dir: string, open?: boolean }) {
-    const port = options.port || 3000;
+    const startPort = options.port || 5555;
     const rootDir = path.resolve(process.cwd(), options.dir || '.');
     
     console.log(chalk.blue('Starting ObjectQL Studio...'));
@@ -78,6 +78,49 @@ export async function startStudio(options: { port: number; dir: string, open?: b
          process.exit(1);
     }
 
+    // Initialize App if it's a configuration object
+    if (typeof (app as any).init !== 'function') {
+        const config = app as any;
+        console.log(chalk.gray('Configuration object detected. Initializing ObjectQL instance...'));
+        
+        const datasources: any = {};
+        
+        if (config.datasource && config.datasource.default) {
+            const dbConfig = config.datasource.default;
+            if (dbConfig.type === 'sqlite') {
+                try {
+                    const { KnexDriver } = require('@objectql/driver-sql');
+                    datasources.default = new KnexDriver({
+                        client: 'sqlite3',
+                        connection: {
+                            filename: dbConfig.filename ? path.resolve(rootDir, dbConfig.filename) : ':memory:'
+                        },
+                        useNullAsDefault: true
+                    });
+                } catch (e) {
+                    console.warn(chalk.yellow('Failed to load @objectql/driver-sql. Ensure it is installed.'));
+                }
+            }
+        }
+
+        // Fallback to memory if no datasource
+        if (!datasources.default) {
+            console.warn(chalk.yellow('No valid datasource found. Using in-memory SQLite.'));
+            const { KnexDriver } = require('@objectql/driver-sql');
+            datasources.default = new KnexDriver({
+                client: 'sqlite3',
+                connection: { filename: ':memory:' },
+                useNullAsDefault: true
+            });
+        }
+
+        app = new ObjectQL({ datasources });
+        
+        // Load Schema
+        const loader = new ObjectLoader(app.metadata);
+        loader.load(rootDir);
+    }
+
     // 2. Load Schema & Init
     try {
         await app.init();
@@ -254,13 +297,35 @@ export async function startStudio(options: { port: number; dir: string, open?: b
         res.end('Not Found');
     });
 
-    server.listen(port, () => {
-        const url = `http://localhost:${port}/studio`;
-        console.log(chalk.green(`\n🚀 Studio running at: ${chalk.bold(url)}`));
-        console.log(chalk.gray(`   API endpoint: http://localhost:${port}/api`));
-        
-        if (options.open) {
-            openBrowser(url);
-        }
-    });
+    const tryListen = (port: number) => {
+        server.removeAllListeners('error');
+        server.removeAllListeners('listening'); // Prevent stacking callbacks
+
+        server.on('error', (e: any) => {
+            if (e.code === 'EADDRINUSE') {
+                if (port - startPort < 10) {
+                    console.log(chalk.yellow(`Port ${port} is in use, trying ${port + 1}...`));
+                    server.close();
+                    tryListen(port + 1);
+                } else {
+                    console.error(chalk.red(`❌ Unable to find a free port.`));
+                    process.exit(1);
+                }
+            } else {
+                console.error(chalk.red('❌ Server error:'), e);
+            }
+        });
+
+        server.listen(port, () => {
+            const url = `http://localhost:${port}/studio`;
+            console.log(chalk.green(`\n🚀 Studio running at: ${chalk.bold(url)}`));
+            console.log(chalk.gray(`   API endpoint: http://localhost:${port}/api`));
+            
+            if (options.open) {
+                openBrowser(url);
+            }
+        });
+    };
+
+    tryListen(startPort);
 }