@objectstack/cli 3.0.5 → 3.0.7

package/dist/commands/generate.js

@@ -0,0 +1,833 @@
+// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
+import { Args, Command, Flags } from '@oclif/core';
+import chalk from 'chalk';
+import fs from 'fs';
+import path from 'path';
+import { printHeader, printSuccess, printError, printInfo, printStep, createTimer } from '../utils/format.js';
+// ─── Metadata Type Templates ────────────────────────────────────────
+const GENERATORS = {
+    object: {
+        description: 'Business data object',
+        defaultDir: 'src/objects',
+        generate: (name) => `import { Data } from '@objectstack/spec';
+
+/**
+ * ${toTitleCase(name)} Object
+ */
+const ${toCamelCase(name)}: Data.Object = {
+  name: '${toSnakeCase(name)}',
+  label: '${toTitleCase(name)}',
+  pluralLabel: '${toTitleCase(name)}s',
+  ownership: 'own',
+  fields: {
+    name: {
+      type: 'text',
+      label: 'Name',
+      required: true,
+      maxLength: 255,
+    },
+    description: {
+      type: 'textarea',
+      label: 'Description',
+    },
+  },
+};
+
+export default ${toCamelCase(name)};
+`,
+    },
+    view: {
+        description: 'List or form view',
+        defaultDir: 'src/views',
+        generate: (name) => `import { UI } from '@objectstack/spec';
+
+/**
+ * ${toTitleCase(name)} List View
+ */
+const ${toCamelCase(name)}ListView: UI.View = {
+  name: '${toSnakeCase(name)}_list',
+  label: '${toTitleCase(name)} List',
+  type: 'list',
+  objectName: '${toSnakeCase(name)}',
+  list: {
+    type: 'grid',
+    columns: [
+      { field: 'name', width: 200 },
+    ],
+    defaultSort: { field: 'name', direction: 'asc' },
+    pageSize: 25,
+  },
+};
+
+export default ${toCamelCase(name)}ListView;
+`,
+    },
+    action: {
+        description: 'Button or batch action',
+        defaultDir: 'src/actions',
+        generate: (name) => `import { UI } from '@objectstack/spec';
+
+/**
+ * ${toTitleCase(name)} Action
+ */
+const ${toCamelCase(name)}Action: UI.Action = {
+  name: '${toSnakeCase(name)}',
+  label: '${toTitleCase(name)}',
+  type: 'custom',
+  objectName: '${toSnakeCase(name)}',
+  handler: {
+    type: 'flow',
+    target: '${toSnakeCase(name)}_flow',
+  },
+};
+
+export default ${toCamelCase(name)}Action;
+`,
+    },
+    flow: {
+        description: 'Automation flow',
+        defaultDir: 'src/flows',
+        generate: (name) => `import { Automation } from '@objectstack/spec';
+
+/**
+ * ${toTitleCase(name)} Flow
+ */
+const ${toCamelCase(name)}Flow: Automation.Flow = {
+  name: '${toSnakeCase(name)}_flow',
+  label: '${toTitleCase(name)} Flow',
+  type: 'autolaunched',
+  status: 'draft',
+  trigger: {
+    type: 'record_change',
+    object: '${toSnakeCase(name)}',
+    events: ['after_insert', 'after_update'],
+  },
+  nodes: [
+    {
+      id: 'start',
+      type: 'start',
+      name: 'Start',
+      next: 'end',
+    },
+  ],
+};
+
+export default ${toCamelCase(name)}Flow;
+`,
+    },
+    agent: {
+        description: 'AI agent',
+        defaultDir: 'src/agents',
+        generate: (name) => `import { AI } from '@objectstack/spec';
+
+/**
+ * ${toTitleCase(name)} Agent
+ */
+const ${toCamelCase(name)}Agent: AI.Agent = {
+  name: '${toSnakeCase(name)}_agent',
+  label: '${toTitleCase(name)} Agent',
+  role: '${toTitleCase(name)} assistant',
+  instructions: 'You are a helpful ${toTitleCase(name).toLowerCase()} assistant.',
+  model: {
+    provider: 'openai',
+    model: 'gpt-4o',
+  },
+  tools: [],
+};
+
+export default ${toCamelCase(name)}Agent;
+`,
+    },
+    dashboard: {
+        description: 'Analytics dashboard',
+        defaultDir: 'src/dashboards',
+        generate: (name) => `import { UI } from '@objectstack/spec';
+
+/**
+ * ${toTitleCase(name)} Dashboard
+ */
+const ${toCamelCase(name)}Dashboard: UI.Dashboard = {
+  name: '${toSnakeCase(name)}_dashboard',
+  label: '${toTitleCase(name)} Dashboard',
+  widgets: [],
+};
+
+export default ${toCamelCase(name)}Dashboard;
+`,
+    },
+    app: {
+        description: 'Application navigation',
+        defaultDir: 'src/apps',
+        generate: (name) => `import { UI } from '@objectstack/spec';
+
+/**
+ * ${toTitleCase(name)} App
+ */
+const ${toCamelCase(name)}App: UI.App = {
+  name: '${toSnakeCase(name)}_app',
+  label: '${toTitleCase(name)}',
+  navigation: {
+    type: 'sidebar',
+    items: [],
+  },
+};
+
+export default ${toCamelCase(name)}App;
+`,
+    },
+};
+// ─── Helpers ────────────────────────────────────────────────────────
+function toCamelCase(str) {
+    return str.replace(/[-_]([a-z])/g, (_, c) => c.toUpperCase());
+}
+function toTitleCase(str) {
+    return str.replace(/[-_]/g, ' ').replace(/\b\w/g, c => c.toUpperCase());
+}
+function toSnakeCase(str) {
+    return str.replace(/[-]/g, '_').replace(/[A-Z]/g, c => `_${c.toLowerCase()}`).replace(/^_/, '');
+}
+// ─── Field Type Mapping ─────────────────────────────────────────────
+const FIELD_TYPE_MAP = {
+    text: 'string',
+    textarea: 'string',
+    richtext: 'string',
+    html: 'string',
+    markdown: 'string',
+    number: 'number',
+    integer: 'number',
+    currency: 'number',
+    percent: 'number',
+    boolean: 'boolean',
+    date: 'string',
+    datetime: 'string',
+    time: 'string',
+    email: 'string',
+    phone: 'string',
+    url: 'string',
+    select: 'string',
+    multiselect: 'string[]',
+    lookup: 'string',
+    master_detail: 'string',
+    formula: 'unknown',
+    autonumber: 'string',
+    json: 'Record<string, unknown>',
+    file: 'string',
+    image: 'string',
+    password: 'string',
+    slug: 'string',
+    uuid: 'string',
+    ip_address: 'string',
+    color: 'string',
+    rating: 'number',
+    geo_point: '{ lat: number; lng: number }',
+    vector: 'number[]',
+    encrypted: 'string',
+};
+function fieldTypeToTs(fieldType, multiple) {
+    const base = FIELD_TYPE_MAP[fieldType] || 'unknown';
+    return multiple ? `${base}[]` : base;
+}
+function generateTypesFromConfig(config) {
+    const lines = [
+        '// Auto-generated by ObjectStack CLI — do not edit manually',
+        `// Generated at ${new Date().toISOString()}`,
+        '',
+        "import type { Data } from '@objectstack/spec';",
+        '',
+    ];
+    // Extract objects from config (supports both top-level and nested)
+    const objects = [];
+    const rawObjects = config.objects ?? config.data?.objects ?? {};
+    if (Array.isArray(rawObjects)) {
+        objects.push(...rawObjects);
+    }
+    else if (typeof rawObjects === 'object') {
+        for (const val of Object.values(rawObjects)) {
+            if (val && typeof val === 'object')
+                objects.push(val);
+        }
+    }
+    if (objects.length === 0) {
+        lines.push('// No objects found in configuration');
+        return lines.join('\n') + '\n';
+    }
+    for (const obj of objects) {
+        const name = String(obj.name || 'unknown');
+        const typeName = name
+            .split('_')
+            .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
+            .join('');
+        const fields = (obj.fields ?? {});
+        lines.push(`/** ${String(obj.label || typeName)} record type */`);
+        lines.push(`export interface ${typeName}Record {`);
+        lines.push('  id: string;');
+        for (const [fieldName, fieldDef] of Object.entries(fields)) {
+            const fType = String(fieldDef.type || 'text');
+            const tsType = fieldTypeToTs(fType, !!fieldDef.multiple);
+            const required = fieldDef.required ? '' : '?';
+            if (fieldDef.label) {
+                lines.push(`  /** ${fieldDef.label} */`);
+            }
+            lines.push(`  ${fieldName}${required}: ${tsType};`);
+        }
+        lines.push('}');
+        lines.push('');
+    }
+    return lines.join('\n') + '\n';
+}
+// ─── Command ────────────────────────────────────────────────────────
+async function runMetadataGeneration(type, name, flags) {
+    printHeader('Generate');
+    const generator = GENERATORS[type];
+    if (!generator) {
+        printError(`Unknown type: ${type}`);
+        console.log('');
+        console.log(chalk.bold('  Available types:'));
+        for (const [key, gen] of Object.entries(GENERATORS)) {
+            console.log(`    ${chalk.cyan(key.padEnd(12))} ${chalk.dim(gen.description)}`);
+        }
+        console.log('');
+        console.log(chalk.dim('  Usage: objectstack generate <type> <name>'));
+        console.log(chalk.dim('  Example: objectstack generate object project'));
+        console.log(chalk.dim('  Alias: os g object project'));
+        process.exit(1);
+    }
+    const dir = flags.dir || generator.defaultDir;
+    const fileName = `${toSnakeCase(name)}.ts`;
+    const filePath = path.join(process.cwd(), dir, fileName);
+    console.log(`  ${chalk.dim('Type:')}  ${chalk.cyan(type)} — ${generator.description}`);
+    console.log(`  ${chalk.dim('Name:')}  ${chalk.white(name)}`);
+    console.log(`  ${chalk.dim('File:')}  ${chalk.white(path.join(dir, fileName))}`);
+    console.log('');
+    if (flags.dryRun) {
+        printInfo('Dry run — no files written');
+        console.log('');
+        console.log(chalk.dim('  Content:'));
+        console.log(chalk.dim('  ' + '-'.repeat(38)));
+        const content = generator.generate(name);
+        for (const line of content.split('\n')) {
+            console.log(chalk.dim(`  ${line}`));
+        }
+        console.log('');
+        return;
+    }
+    // Check if file exists
+    if (fs.existsSync(filePath)) {
+        printError(`File already exists: ${filePath}`);
+        process.exit(1);
+    }
+    try {
+        // Create directory
+        const fullDir = path.dirname(filePath);
+        if (!fs.existsSync(fullDir)) {
+            fs.mkdirSync(fullDir, { recursive: true });
+        }
+        // Write file
+        const content = generator.generate(name);
+        fs.writeFileSync(filePath, content);
+        printSuccess(`Created ${path.join(dir, fileName)}`);
+        // Check for barrel index
+        const indexPath = path.join(process.cwd(), dir, 'index.ts');
+        if (fs.existsSync(indexPath)) {
+            const indexContent = fs.readFileSync(indexPath, 'utf-8');
+            const exportLine = `export { default as ${toCamelCase(name)} } from './${toSnakeCase(name)}';`;
+            if (!indexContent.includes(toCamelCase(name))) {
+                fs.appendFileSync(indexPath, exportLine + '\n');
+                printSuccess(`Updated ${dir}/index.ts with export`);
+            }
+        }
+        else {
+            // Create barrel index
+            const exportLine = `export { default as ${toCamelCase(name)} } from './${toSnakeCase(name)}';\n`;
+            fs.writeFileSync(indexPath, exportLine);
+            printSuccess(`Created ${dir}/index.ts`);
+        }
+        console.log('');
+        console.log(chalk.dim(`  Tip: Run \`objectstack validate\` to check your config`));
+        console.log('');
+    }
+    catch (error) {
+        printError(error.message || String(error));
+        process.exit(1);
+    }
+}
+async function runTypesGeneration(configPath, flags) {
+    printHeader('Generate Types');
+    try {
+        const { loadConfig } = await import('../utils/config.js');
+        printInfo('Loading configuration...');
+        const { config, absolutePath } = await loadConfig(configPath);
+        console.log(`  ${chalk.dim('Config:')} ${chalk.white(absolutePath)}`);
+        console.log(`  ${chalk.dim('Output:')} ${chalk.white(flags.output)}`);
+        console.log('');
+        const content = generateTypesFromConfig(config);
+        if (flags.dryRun) {
+            printInfo('Dry run — no files written');
+            console.log('');
+            for (const line of content.split('\n')) {
+                console.log(chalk.dim(`  ${line}`));
+            }
+            console.log('');
+            return;
+        }
+        const outPath = path.resolve(process.cwd(), flags.output);
+        const outDir = path.dirname(outPath);
+        if (!fs.existsSync(outDir)) {
+            fs.mkdirSync(outDir, { recursive: true });
+        }
+        fs.writeFileSync(outPath, content);
+        printSuccess(`Generated types at ${flags.output}`);
+        console.log('');
+    }
+    catch (error) {
+        printError(error.message || String(error));
+        process.exit(1);
+    }
+}
+// ─── Client SDK Generator ───────────────────────────────────────────
+function generateClientFromConfig(config) {
+    const lines = [
+        '// Auto-generated by ObjectStack CLI — do not edit manually',
+        `// Generated at ${new Date().toISOString()}`,
+        '',
+        "import type { Data } from '@objectstack/spec';",
+        '',
+    ];
+    const objects = [];
+    const rawObjects = config.objects ?? config.data?.objects ?? {};
+    if (Array.isArray(rawObjects)) {
+        objects.push(...rawObjects);
+    }
+    else if (typeof rawObjects === 'object') {
+        for (const val of Object.values(rawObjects)) {
+            if (val && typeof val === 'object')
+                objects.push(val);
+        }
+    }
+    if (objects.length === 0) {
+        lines.push('// No objects found in configuration');
+        return lines.join('\n') + '\n';
+    }
+    // Generate type interfaces
+    for (const obj of objects) {
+        const name = String(obj.name || 'unknown');
+        const typeName = name
+            .split('_')
+            .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
+            .join('');
+        const fields = (obj.fields ?? {});
+        lines.push(`export interface ${typeName}Record {`);
+        lines.push('  id: string;');
+        for (const [fieldName, fieldDef] of Object.entries(fields)) {
+            const fType = String(fieldDef.type || 'text');
+            const tsType = fieldTypeToTs(fType, !!fieldDef.multiple);
+            const required = fieldDef.required ? '' : '?';
+            lines.push(`  ${fieldName}${required}: ${tsType};`);
+        }
+        lines.push('}');
+        lines.push('');
+    }
+    // Generate client class
+    lines.push('export class ObjectStackClient {');
+    lines.push('  constructor(private baseUrl: string, private headers: Record<string, string> = {}) {}');
+    lines.push('');
+    lines.push('  private async request<T>(method: string, path: string, body?: unknown): Promise<T> {');
+    lines.push('    const res = await fetch(`${this.baseUrl}${path}`, {');
+    lines.push('      method,');
+    lines.push("      headers: { 'Content-Type': 'application/json', ...this.headers },");
+    lines.push('      body: body ? JSON.stringify(body) : undefined,');
+    lines.push('    });');
+    lines.push('    if (!res.ok) throw new Error(`HTTP ${res.status}: ${res.statusText}`);');
+    lines.push('    return res.json() as Promise<T>;');
+    lines.push('  }');
+    for (const obj of objects) {
+        const name = String(obj.name || 'unknown');
+        const typeName = name
+            .split('_')
+            .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
+            .join('');
+        const endpoint = `/api/${name}`;
+        lines.push('');
+        lines.push(`  async list${typeName}(): Promise<${typeName}Record[]> {`);
+        lines.push(`    return this.request<${typeName}Record[]>('GET', '${endpoint}');`);
+        lines.push('  }');
+        lines.push('');
+        lines.push(`  async get${typeName}(id: string): Promise<${typeName}Record> {`);
+        lines.push(`    return this.request<${typeName}Record>('GET', '${endpoint}/\${id}');`);
+        lines.push('  }');
+        lines.push('');
+        lines.push(`  async create${typeName}(data: Omit<${typeName}Record, 'id'>): Promise<${typeName}Record> {`);
+        lines.push(`    return this.request<${typeName}Record>('POST', '${endpoint}', data);`);
+        lines.push('  }');
+        lines.push('');
+        lines.push(`  async update${typeName}(id: string, data: Partial<${typeName}Record>): Promise<${typeName}Record> {`);
+        lines.push(`    return this.request<${typeName}Record>('PATCH', '${endpoint}/\${id}', data);`);
+        lines.push('  }');
+        lines.push('');
+        lines.push(`  async delete${typeName}(id: string): Promise<void> {`);
+        lines.push(`    return this.request<void>('DELETE', '${endpoint}/\${id}');`);
+        lines.push('  }');
+    }
+    lines.push('}');
+    lines.push('');
+    return lines.join('\n') + '\n';
+}
+async function runClientGeneration(configPath, flags) {
+    printHeader('Generate Client SDK');
+    try {
+        const { loadConfig } = await import('../utils/config.js');
+        const timer = createTimer();
+        printInfo('Loading configuration...');
+        const { config, absolutePath } = await loadConfig(configPath);
+        console.log(`  ${chalk.dim('Config:')} ${chalk.white(absolutePath)}`);
+        console.log(`  ${chalk.dim('Output:')} ${chalk.white(flags.output)}`);
+        console.log('');
+        printStep('Generating client SDK...');
+        const content = generateClientFromConfig(config);
+        if (flags.dryRun) {
+            printInfo('Dry run — no files written');
+            console.log('');
+            for (const line of content.split('\n')) {
+                console.log(chalk.dim(`  ${line}`));
+            }
+            console.log('');
+            return;
+        }
+        const outPath = path.resolve(process.cwd(), flags.output);
+        const outDir = path.dirname(outPath);
+        if (!fs.existsSync(outDir)) {
+            fs.mkdirSync(outDir, { recursive: true });
+        }
+        fs.writeFileSync(outPath, content);
+        printSuccess(`Generated client SDK at ${flags.output} (${timer.display()})`);
+        console.log('');
+    }
+    catch (error) {
+        printError(error.message || String(error));
+        process.exit(1);
+    }
+}
+// ─── Migration Generator ────────────────────────────────────────────
+const FIELD_TYPE_SQL_MAP = {
+    text: 'VARCHAR(255)',
+    textarea: 'TEXT',
+    richtext: 'TEXT',
+    html: 'TEXT',
+    markdown: 'TEXT',
+    number: 'DECIMAL(18,2)',
+    integer: 'INTEGER',
+    currency: 'DECIMAL(18,2)',
+    percent: 'DECIMAL(5,2)',
+    boolean: 'BOOLEAN',
+    date: 'DATE',
+    datetime: 'TIMESTAMP',
+    time: 'TIME',
+    email: 'VARCHAR(255)',
+    phone: 'VARCHAR(50)',
+    url: 'VARCHAR(2048)',
+    select: 'VARCHAR(255)',
+    multiselect: 'TEXT',
+    lookup: 'VARCHAR(36)',
+    master_detail: 'VARCHAR(36)',
+    formula: 'TEXT',
+    autonumber: 'SERIAL',
+    json: 'JSONB',
+    file: 'VARCHAR(2048)',
+    image: 'VARCHAR(2048)',
+    password: 'VARCHAR(255)',
+    slug: 'VARCHAR(255)',
+    uuid: 'UUID',
+    ip_address: 'VARCHAR(45)',
+    color: 'VARCHAR(7)',
+    rating: 'INTEGER',
+    geo_point: 'POINT',
+    vector: 'VECTOR',
+    encrypted: 'TEXT',
+};
+function fieldTypeToSql(fieldType) {
+    return FIELD_TYPE_SQL_MAP[fieldType] || 'TEXT';
+}
+function generateMigrationSql(config) {
+    const lines = [
+        '-- Auto-generated by ObjectStack CLI — do not edit manually',
+        `-- Generated at ${new Date().toISOString()}`,
+        '',
+    ];
+    const objects = [];
+    const rawObjects = config.objects ?? config.data?.objects ?? {};
+    if (Array.isArray(rawObjects)) {
+        objects.push(...rawObjects);
+    }
+    else if (typeof rawObjects === 'object') {
+        for (const val of Object.values(rawObjects)) {
+            if (val && typeof val === 'object')
+                objects.push(val);
+        }
+    }
+    if (objects.length === 0) {
+        lines.push('-- No objects found in configuration');
+        return lines.join('\n') + '\n';
+    }
+    for (const obj of objects) {
+        const tableName = String(obj.name || 'unknown');
+        const fields = (obj.fields ?? {});
+        lines.push(`CREATE TABLE IF NOT EXISTS "${tableName}" (`);
+        lines.push('  "id" UUID PRIMARY KEY DEFAULT gen_random_uuid(),');
+        const fieldLines = [];
+        for (const [fieldName, fieldDef] of Object.entries(fields)) {
+            const sqlType = fieldTypeToSql(String(fieldDef.type || 'text'));
+            const notNull = fieldDef.required ? ' NOT NULL' : '';
+            fieldLines.push(`  "${fieldName}" ${sqlType}${notNull}`);
+        }
+        fieldLines.push('  "created_at" TIMESTAMP NOT NULL DEFAULT now()');
+        fieldLines.push('  "updated_at" TIMESTAMP NOT NULL DEFAULT now()');
+        lines.push(fieldLines.join(',\n'));
+        lines.push(');');
+        lines.push('');
+    }
+    return lines.join('\n') + '\n';
+}
+function generateMigrationTs(config) {
+    const lines = [
+        '// Auto-generated by ObjectStack CLI — do not edit manually',
+        `// Generated at ${new Date().toISOString()}`,
+        '',
+        'export async function up(db: any): Promise<void> {',
+    ];
+    const objects = [];
+    const rawObjects = config.objects ?? config.data?.objects ?? {};
+    if (Array.isArray(rawObjects)) {
+        objects.push(...rawObjects);
+    }
+    else if (typeof rawObjects === 'object') {
+        for (const val of Object.values(rawObjects)) {
+            if (val && typeof val === 'object')
+                objects.push(val);
+        }
+    }
+    if (objects.length === 0) {
+        lines.push('  // No objects found in configuration');
+        lines.push('}');
+        lines.push('');
+        lines.push('export async function down(db: any): Promise<void> {');
+        lines.push('  // No objects found in configuration');
+        lines.push('}');
+        return lines.join('\n') + '\n';
+    }
+    for (const obj of objects) {
+        const tableName = String(obj.name || 'unknown');
+        const fields = (obj.fields ?? {});
+        lines.push(`  await db.schema.createTable('${tableName}', (table: any) => {`);
+        lines.push("    table.uuid('id').primary().defaultTo(db.fn.uuid());");
+        for (const [fieldName, fieldDef] of Object.entries(fields)) {
+            const fType = String(fieldDef.type || 'text');
+            const required = fieldDef.required ? '.notNullable()' : '.nullable()';
+            let colMethod;
+            switch (fType) {
+                case 'text':
+                case 'email':
+                case 'phone':
+                case 'url':
+                case 'select':
+                case 'slug':
+                case 'password':
+                case 'color':
+                case 'ip_address':
+                    colMethod = `table.string('${fieldName}')`;
+                    break;
+                case 'textarea':
+                case 'richtext':
+                case 'html':
+                case 'markdown':
+                case 'formula':
+                case 'encrypted':
+                    colMethod = `table.text('${fieldName}')`;
+                    break;
+                case 'number':
+                case 'currency':
+                case 'percent':
+                    colMethod = `table.decimal('${fieldName}')`;
+                    break;
+                case 'integer':
+                case 'rating':
+                    colMethod = `table.integer('${fieldName}')`;
+                    break;
+                case 'boolean':
+                    colMethod = `table.boolean('${fieldName}')`;
+                    break;
+                case 'date':
+                    colMethod = `table.date('${fieldName}')`;
+                    break;
+                case 'datetime':
+                    colMethod = `table.timestamp('${fieldName}')`;
+                    break;
+                case 'time':
+                    colMethod = `table.time('${fieldName}')`;
+                    break;
+                case 'json':
+                case 'multiselect':
+                    colMethod = `table.jsonb('${fieldName}')`;
+                    break;
+                case 'uuid':
+                case 'lookup':
+                case 'master_detail':
+                    colMethod = `table.uuid('${fieldName}')`;
+                    break;
+                default:
+                    colMethod = `table.text('${fieldName}')`;
+            }
+            lines.push(`    ${colMethod}${required};`);
+        }
+        lines.push("    table.timestamps(true, true);");
+        lines.push('  });');
+    }
+    lines.push('}');
+    lines.push('');
+    lines.push('export async function down(db: any): Promise<void> {');
+    // Drop tables in reverse order
+    const tableNames = objects.map(o => String(o.name || 'unknown')).reverse();
+    for (const tableName of tableNames) {
+        lines.push(`  await db.schema.dropTableIfExists('${tableName}');`);
+    }
+    lines.push('}');
+    return lines.join('\n') + '\n';
+}
+async function runMigrationGeneration(configPath, flags) {
+    printHeader('Generate Migration');
+    try {
+        const { loadConfig } = await import('../utils/config.js');
+        const timer = createTimer();
+        printInfo('Loading configuration...');
+        const { config, absolutePath } = await loadConfig(configPath);
+        const ext = flags.format === 'sql' ? 'sql' : 'ts';
+        // Format: YYYYMMDDHHmmss (e.g. 20250101120000)
+        const timestamp = new Date().toISOString().replace(/[-:T]/g, '').slice(0, 14);
+        const defaultOutput = `migrations/${timestamp}_migration.${ext}`;
+        const output = flags.output || defaultOutput;
+        console.log(`  ${chalk.dim('Config:')} ${chalk.white(absolutePath)}`);
+        console.log(`  ${chalk.dim('Format:')} ${chalk.white(flags.format)}`);
+        console.log(`  ${chalk.dim('Output:')} ${chalk.white(output)}`);
+        console.log('');
+        printStep('Generating migration...');
+        const content = flags.format === 'sql'
+            ? generateMigrationSql(config)
+            : generateMigrationTs(config);
+        if (flags.dryRun) {
+            printInfo('Dry run — no files written');
+            console.log('');
+            for (const line of content.split('\n')) {
+                console.log(chalk.dim(`  ${line}`));
+            }
+            console.log('');
+            return;
+        }
+        const outPath = path.resolve(process.cwd(), output);
+        const outDir = path.dirname(outPath);
+        if (!fs.existsSync(outDir)) {
+            fs.mkdirSync(outDir, { recursive: true });
+        }
+        fs.writeFileSync(outPath, content);
+        printSuccess(`Generated migration at ${output} (${timer.display()})`);
+        console.log('');
+    }
+    catch (error) {
+        printError(error.message || String(error));
+        process.exit(1);
+    }
+}
+// ─── JSON Schema Generator ──────────────────────────────────────────
+async function runSchemaGeneration(flags) {
+    printHeader('Generate Schema');
+    try {
+        const timer = createTimer();
+        printStep('Loading ObjectStackDefinitionSchema...');
+        const { z } = await import('zod');
+        const { ObjectStackDefinitionSchema } = await import('@objectstack/spec');
+        printStep('Converting to JSON Schema...');
+        const jsonSchema = z.toJSONSchema(ObjectStackDefinitionSchema, {
+            target: 'draft-2020-12',
+        });
+        // Add metadata
+        const schema = {
+            ...jsonSchema,
+            $id: 'https://schema.objectstack.io/objectstack.config.json',
+            title: 'ObjectStack Configuration',
+            description: 'JSON Schema for objectstack.config.ts — generated from ObjectStackDefinitionSchema',
+        };
+        const content = JSON.stringify(schema, null, 2) + '\n';
+        if (flags.dryRun) {
+            printInfo('Dry run — no files written');
+            console.log('');
+            console.log(content);
+            return;
+        }
+        const outPath = path.resolve(process.cwd(), flags.output);
+        const outDir = path.dirname(outPath);
+        if (!fs.existsSync(outDir)) {
+            fs.mkdirSync(outDir, { recursive: true });
+        }
+        fs.writeFileSync(outPath, content);
+        printSuccess(`Generated JSON Schema at ${flags.output} (${timer.display()})`);
+        console.log('');
+        console.log(chalk.dim('  Usage: Reference in your IDE or editor for autocomplete'));
+        console.log(chalk.dim(`  Path:  ${outPath}`));
+        console.log('');
+    }
+    catch (error) {
+        printError(error.message || String(error));
+        process.exit(1);
+    }
+}
+// ─── Main Generate Command ──────────────────────────────────────────
+export default class Generate extends Command {
+    static description = 'Generate metadata files or TypeScript types';
+    static aliases = ['g'];
+    static args = {
+        type: Args.string({ description: 'Metadata type to generate (object, view, action, flow, agent, dashboard, app)', required: true }),
+        name: Args.string({ description: 'Name for the metadata (use kebab-case)', required: false }),
+    };
+    static flags = {
+        dir: Flags.string({ char: 'd', description: 'Target directory (overrides default)' }),
+        'dry-run': Flags.boolean({ description: 'Show what would be created without writing files' }),
+        output: Flags.string({ char: 'o', description: 'Output file path' }),
+        format: Flags.string({ description: 'Output format: sql or typescript', default: 'typescript' }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(Generate);
+        // Route to sub-commands by type name
+        switch (args.type) {
+            case 'types':
+                return runTypesGeneration(args.name, {
+                    output: flags.output ?? 'src/types/objectstack.d.ts',
+                    dryRun: flags['dry-run'],
+                });
+            case 'client':
+                return runClientGeneration(args.name, {
+                    output: flags.output ?? 'src/client/objectstack-client.ts',
+                    dryRun: flags['dry-run'],
+                });
+            case 'migration':
+                return runMigrationGeneration(args.name, {
+                    output: flags.output,
+                    format: flags.format ?? 'typescript',
+                    dryRun: flags['dry-run'],
+                });
+            case 'schema':
+                return runSchemaGeneration({
+                    output: flags.output ?? 'objectstack.schema.json',
+                    dryRun: flags['dry-run'],
+                });
+        }
+        // Metadata generation
+        if (!args.name) {
+            printError('Missing required argument: <name>');
+            console.log(chalk.dim('  Usage: objectstack generate <type> <name>'));
+            process.exit(1);
+        }
+        await runMetadataGeneration(args.type, args.name, {
+            dir: flags.dir,
+            dryRun: flags['dry-run'],
+        });
+    }
+}
+//# sourceMappingURL=generate.js.map