@objectql/cli 1.8.4 → 1.9.1

package/src/commands/format.ts

@@ -1,110 +0,0 @@
-import * as path from 'path';
-import * as fs from 'fs';
-import chalk from 'chalk';
-import * as yaml from 'js-yaml';
-import glob from 'fast-glob';
-
-// Naming convention regex
-const VALID_NAME_REGEX = /^[a-z][a-z0-9_]*$/;
-
-interface FormatOptions {
-    dir?: string;
-    check?: boolean;
-}
-
-/**
- * Format command - formats metadata files using Prettier
- */
-export async function format(options: FormatOptions) {
-    console.log(chalk.blue('🎨 Formatting ObjectQL metadata files...\n'));
-    
-    const rootDir = path.resolve(process.cwd(), options.dir || '.');
-    let formattedCount = 0;
-    let unchangedCount = 0;
-    let errorCount = 0;
-    
-    // Load Prettier once at the start
-    let prettier: any;
-    try {
-        prettier = await import('prettier');
-    } catch (e) {
-        console.error(chalk.red('❌ Prettier is not installed. Install it with: npm install --save-dev prettier'));
-        process.exit(1);
-    }
-    
-    try {
-        const files = await glob(['**/*.yml', '**/*.yaml'], { 
-            cwd: rootDir,
-            ignore: ['node_modules/**', 'dist/**', 'build/**']
-        });
-        
-        console.log(chalk.cyan(`Found ${files.length} YAML file(s)\n`));
-        
-        for (const file of files) {
-            const filePath = path.join(rootDir, file);
-            
-            try {
-                const content = fs.readFileSync(filePath, 'utf-8');
-                
-                // Parse to validate YAML
-                yaml.load(content);
-                
-                // Format with Prettier
-                const formatted = await prettier.format(content, {
-                    parser: 'yaml',
-                    printWidth: 80,
-                    tabWidth: 2,
-                    singleQuote: true
-                });
-                    
-                    if (content !== formatted) {
-                        if (options.check) {
-                            console.log(chalk.yellow(`  ⚠️  ${file} needs formatting`));
-                            formattedCount++;
-                        } else {
-                            fs.writeFileSync(filePath, formatted, 'utf-8');
-                            console.log(chalk.green(`  ✅ ${file}`));
-                            formattedCount++;
-                        }
-                    } else {
-                        unchangedCount++;
-                        if (!options.check) {
-                            console.log(chalk.gray(`  ✓  ${file}`));
-                        }
-                    }
-            } catch (e: any) {
-                console.error(chalk.red(`  ❌ ${file}: ${e.message}`));
-                errorCount++;
-            }
-        }
-        
-        console.log('');
-        
-        // Summary
-        if (options.check) {
-            if (formattedCount > 0) {
-                console.log(chalk.yellow.bold(`⚠️  ${formattedCount} file(s) need formatting`));
-                console.log(chalk.gray('Run without --check to format files\n'));
-                process.exit(1);
-            } else {
-                console.log(chalk.green.bold('✅ All files are properly formatted!\n'));
-            }
-        } else {
-            console.log(chalk.cyan('Summary:'));
-            console.log(chalk.green(`  ✅ Formatted: ${formattedCount}`));
-            console.log(chalk.gray(`  ✓  Unchanged: ${unchangedCount}`));
-            if (errorCount > 0) {
-                console.log(chalk.red(`  ❌ Errors: ${errorCount}`));
-            }
-            console.log('');
-            
-            if (errorCount > 0) {
-                process.exit(1);
-            }
-        }
-        
-    } catch (e: any) {
-        console.error(chalk.red('❌ Format failed:'), e.message);
-        process.exit(1);
-    }
-}

package/src/commands/generate.ts

@@ -1,135 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import { loadObjectConfigs } from '@objectql/platform-node';
-import { ObjectConfig, FieldConfig } from '@objectql/types';
-
-export async function generateTypes(sourceDir: string, outputDir: string) {
-    console.log(`Searching for objects in ${sourceDir}...`);
-    
-    // Use Loader to get Merged Objects (Flat list)
-    let schemas: Record<string, ObjectConfig>;
-    try {
-        schemas = loadObjectConfigs(sourceDir);
-    } catch (e) {
-        console.error('Failed to load object configs:', e);
-        return;
-    }
-
-    if (Object.keys(schemas).length === 0) {
-        console.log('No object files found.');
-        return;
-    }
-
-    // Ensure output dir exists
-    if (!fs.existsSync(outputDir)) {
-        fs.mkdirSync(outputDir, { recursive: true });
-    }
-
-    const indexContent: string[] = [];
-
-    for (const [name, schema] of Object.entries(schemas)) {
-        try {
-            const typeName = toPascalCase(name);
-            const typeDefinition = generateInterface(typeName, schema);
-            
-            // Generate flat files based on Object Name
-            // e.g. User.ts, CrmContact.ts
-            // We lose original directory structure but gain correct merged types.
-            // This is arguably better for "Generated Types" which are usually a flat library.
-            
-            const fileName = `${name}.ts`;
-            const outPath = path.join(outputDir, fileName);
-            fs.writeFileSync(outPath, typeDefinition);
-            console.log(`Generated ${fileName}`);
-
-            indexContent.push(`export * from './${name}';`);
-        } catch (e) {
-            console.error(`Failed to generate type for ${name}:`, e);
-        }
-    }
-
-    // Generate index.ts
-    fs.writeFileSync(path.join(outputDir, 'index.ts'), indexContent.join('\n'));
-    console.log(`Generated types in ${outputDir}`);
-}
-
-function generateInterface(typeName: string, schema: ObjectConfig): string {
-    const fields = schema.fields || {};
-    const lines = [
-        `// Auto-generated by ObjectQL. DO NOT EDIT.`,
-        `import { ObjectDoc } from '@objectql/types';`, // Assuming a base type exists or we define it
-        ``,
-        `export interface ${typeName} extends ObjectDoc {`
-    ];
-
-    for (const [key, field] of Object.entries(fields)) {
-        const fieldName = field.name || key;
-        const isOptional = !field.required;
-        const tsType = mapFieldTypeToTs(field);
-        
-        // Add JSDoc
-        if (field.label || field.description) {
-            lines.push(`    /**`);
-            if (field.label) lines.push(`     * ${field.label}`);
-            if (field.description) lines.push(`     * ${field.description}`);
-            lines.push(`     */`);
-        }
-        
-        lines.push(`    ${fieldName}${isOptional ? '?' : ''}: ${tsType};`);
-    }
-
-    lines.push(`}`);
-    lines.push(``);
-    return lines.join('\n');
-}
-
-function mapFieldTypeToTs(field: FieldConfig): string {
-    switch (field.type) {
-        case 'text':
-        case 'textarea':
-        case 'markdown':
-        case 'html':
-        case 'email':
-        case 'phone':
-        case 'url':
-        case 'password':
-        case 'select': // Could be stricter if options are strings
-            return 'string';
-        
-        case 'number':
-        case 'currency':
-        case 'percent':
-        case 'auto_number':
-            return 'number';
-        
-        case 'boolean':
-            return 'boolean';
-            
-        case 'date':
-        case 'datetime':
-        case 'time':
-            return 'Date | string';
-            
-        case 'vector':
-            return 'number[]';
-            
-        case 'file':
-        case 'image':
-            return field.multiple ? 'any[]' : 'any'; // Simplified for now
-            
-        case 'object':
-        case 'location':
-            return 'any';
-
-        case 'lookup':
-        case 'master_detail':
-            return 'string | number'; // The ID
-
-        default:
-            return 'any';
-    }
-}
-
-function toPascalCase(str: string): string {
-    return str.replace(/(^\w|_\w)/g, m => m.replace('_', '').toUpperCase());
-}

package/src/commands/i18n.ts

@@ -1,303 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import chalk from 'chalk';
-import * as yaml from 'js-yaml';
-import glob from 'fast-glob';
-
-interface I18nExtractOptions {
-    source?: string;
-    output?: string;
-    lang?: string;
-}
-
-interface I18nInitOptions {
-    lang: string;
-    baseDir?: string;
-}
-
-interface I18nValidateOptions {
-    lang: string;
-    baseDir?: string;
-    baseLang?: string;
-}
-
-/**
- * Extract translatable strings from metadata files and create i18n files
- */
-export async function i18nExtract(options: I18nExtractOptions) {
-    const sourceDir = path.resolve(process.cwd(), options.source || '.');
-    const outputDir = path.resolve(process.cwd(), options.output || './src/i18n');
-    const lang = options.lang || 'en';
-
-    console.log(chalk.blue('🌐 Extracting translatable strings...'));
-    console.log(chalk.gray(`Source: ${sourceDir}`));
-    console.log(chalk.gray(`Output: ${outputDir}/${lang}\n`));
-
-    try {
-        // Find all metadata files
-        const files = await glob('**/*.{object,view,form,page,action,permission,validation,workflow,report,menu}.yml', {
-            cwd: sourceDir,
-            ignore: ['node_modules/**', 'dist/**', 'i18n/**']
-        });
-
-        console.log(chalk.gray(`Found ${files.length} metadata files`));
-
-        const translations: Record<string, any> = {};
-
-        for (const file of files) {
-            const filePath = path.join(sourceDir, file);
-            const content = fs.readFileSync(filePath, 'utf-8');
-            const data = yaml.load(content) as any;
-
-            if (!data) continue;
-
-            // Extract object name from filename
-            const objectName = path.basename(file).split('.')[0];
-
-            // Extract translatable fields
-            const objectTranslations: any = {};
-
-            if (data.label) {
-                objectTranslations.label = data.label;
-            }
-
-            if (data.description) {
-                objectTranslations.description = data.description;
-            }
-
-            // Extract field labels
-            if (data.fields) {
-                objectTranslations.fields = {};
-                for (const [fieldName, fieldConfig] of Object.entries(data.fields) as any) {
-                    const fieldTrans: any = {};
-                    
-                    if (fieldConfig.label) {
-                        fieldTrans.label = fieldConfig.label;
-                    }
-                    
-                    if (fieldConfig.description) {
-                        fieldTrans.description = fieldConfig.description;
-                    }
-                    
-                    if (fieldConfig.help_text) {
-                        fieldTrans.help_text = fieldConfig.help_text;
-                    }
-
-                    // Extract select options
-                    if (fieldConfig.options && Array.isArray(fieldConfig.options)) {
-                        fieldTrans.options = {};
-                        for (const option of fieldConfig.options) {
-                            if (option.value && option.label) {
-                                fieldTrans.options[option.value] = option.label;
-                            }
-                        }
-                    }
-
-                    if (Object.keys(fieldTrans).length > 0) {
-                        objectTranslations.fields[fieldName] = fieldTrans;
-                    }
-                }
-            }
-
-            // Extract action labels
-            if (data.actions) {
-                objectTranslations.actions = {};
-                for (const [actionName, actionConfig] of Object.entries(data.actions) as any) {
-                    const actionTrans: any = {};
-                    if (actionConfig.label) {
-                        actionTrans.label = actionConfig.label;
-                    }
-                    if (actionConfig.confirm_text) {
-                        actionTrans.confirm_text = actionConfig.confirm_text;
-                    }
-                    if (Object.keys(actionTrans).length > 0) {
-                        objectTranslations.actions[actionName] = actionTrans;
-                    }
-                }
-            }
-
-            // Extract validation messages
-            if (data.validation?.rules) {
-                objectTranslations.validation = {};
-                for (const rule of data.validation.rules) {
-                    if (rule.name && rule.message) {
-                        objectTranslations.validation[rule.name] = rule.message;
-                    }
-                }
-            }
-
-            if (Object.keys(objectTranslations).length > 0) {
-                translations[objectName] = objectTranslations;
-            }
-        }
-
-        // Write translation files
-        const langDir = path.join(outputDir, lang);
-        if (!fs.existsSync(langDir)) {
-            fs.mkdirSync(langDir, { recursive: true });
-        }
-
-        // Write one file per object
-        for (const [objectName, objectTranslations] of Object.entries(translations)) {
-            const outputFile = path.join(langDir, `${objectName}.json`);
-            fs.writeFileSync(outputFile, JSON.stringify(objectTranslations, null, 4), 'utf-8');
-            console.log(chalk.green(`✓ ${objectName}.json`));
-        }
-
-        console.log(chalk.green(`\n✅ Extracted translations to ${langDir}`));
-        console.log(chalk.gray(`Total: ${Object.keys(translations).length} files`));
-
-    } catch (error: any) {
-        console.error(chalk.red(`❌ Failed to extract translations: ${error.message}`));
-        process.exit(1);
-    }
-}
-
-/**
- * Initialize i18n structure for a new language
- */
-export async function i18nInit(options: I18nInitOptions) {
-    const baseDir = path.resolve(process.cwd(), options.baseDir || './src/i18n');
-    const { lang } = options;
-
-    console.log(chalk.blue(`🌐 Initializing i18n for language: ${lang}`));
-
-    // Validate language code
-    if (!/^[a-z]{2}(-[A-Z]{2})?$/.test(lang)) {
-        console.error(chalk.red('❌ Invalid language code. Use format: en, zh-CN, etc.'));
-        process.exit(1);
-    }
-
-    const langDir = path.join(baseDir, lang);
-
-    if (fs.existsSync(langDir)) {
-        console.error(chalk.red(`❌ Language directory already exists: ${langDir}`));
-        process.exit(1);
-    }
-
-    try {
-        fs.mkdirSync(langDir, { recursive: true });
-
-        // Create a sample translation file
-        const sampleTranslation = {
-            _meta: {
-                language: lang,
-                created: new Date().toISOString()
-            }
-        };
-
-        const sampleFile = path.join(langDir, 'common.json');
-        fs.writeFileSync(sampleFile, JSON.stringify(sampleTranslation, null, 4), 'utf-8');
-
-        console.log(chalk.green(`✅ Initialized i18n for ${lang}`));
-        console.log(chalk.gray(`Directory: ${langDir}`));
-        console.log(chalk.gray(`\nNext steps:`));
-        console.log(chalk.gray(`  1. Run: objectql i18n extract --lang ${lang}`));
-        console.log(chalk.gray(`  2. Translate the JSON files in ${langDir}`));
-
-    } catch (error: any) {
-        console.error(chalk.red(`❌ Failed to initialize i18n: ${error.message}`));
-        process.exit(1);
-    }
-}
-
-/**
- * Validate translation completeness
- */
-export async function i18nValidate(options: I18nValidateOptions) {
-    const baseDir = path.resolve(process.cwd(), options.baseDir || './src/i18n');
-    const { lang, baseLang = 'en' } = options;
-
-    console.log(chalk.blue(`🌐 Validating translations for ${lang} against ${baseLang}...\n`));
-
-    const baseLangDir = path.join(baseDir, baseLang);
-    const targetLangDir = path.join(baseDir, lang);
-
-    if (!fs.existsSync(baseLangDir)) {
-        console.error(chalk.red(`❌ Base language directory not found: ${baseLangDir}`));
-        process.exit(1);
-    }
-
-    if (!fs.existsSync(targetLangDir)) {
-        console.error(chalk.red(`❌ Target language directory not found: ${targetLangDir}`));
-        process.exit(1);
-    }
-
-    try {
-        const baseFiles = fs.readdirSync(baseLangDir).filter(f => f.endsWith('.json'));
-        const targetFiles = fs.readdirSync(targetLangDir).filter(f => f.endsWith('.json'));
-
-        let totalMissing = 0;
-        let totalFiles = 0;
-
-        for (const file of baseFiles) {
-            totalFiles++;
-            const basePath = path.join(baseLangDir, file);
-            const targetPath = path.join(targetLangDir, file);
-
-            if (!fs.existsSync(targetPath)) {
-                console.log(chalk.red(`✗ ${file} - Missing file`));
-                totalMissing++;
-                continue;
-            }
-
-            const baseData = JSON.parse(fs.readFileSync(basePath, 'utf-8'));
-            const targetData = JSON.parse(fs.readFileSync(targetPath, 'utf-8'));
-
-            const missing = findMissingKeys(baseData, targetData);
-
-            if (missing.length > 0) {
-                console.log(chalk.yellow(`⚠ ${file} - ${missing.length} missing keys:`));
-                for (const key of missing) {
-                    console.log(chalk.gray(`    - ${key}`));
-                }
-                totalMissing += missing.length;
-            } else {
-                console.log(chalk.green(`✓ ${file} - Complete`));
-            }
-        }
-
-        // Check for extra files in target
-        const extraFiles = targetFiles.filter(f => !baseFiles.includes(f));
-        if (extraFiles.length > 0) {
-            console.log(chalk.yellow(`\n⚠ Extra files in ${lang}:`));
-            for (const file of extraFiles) {
-                console.log(chalk.gray(`  - ${file}`));
-            }
-        }
-
-        console.log(chalk.blue(`\n📊 Summary:`));
-        console.log(chalk.gray(`Total files: ${totalFiles}`));
-        console.log(totalMissing > 0 
-            ? chalk.yellow(`Missing translations: ${totalMissing}`) 
-            : chalk.green('All translations complete ✓')
-        );
-
-    } catch (error: any) {
-        console.error(chalk.red(`❌ Failed to validate translations: ${error.message}`));
-        process.exit(1);
-    }
-}
-
-function findMissingKeys(base: any, target: any, prefix = ''): string[] {
-    const missing: string[] = [];
-
-    for (const key in base) {
-        const fullKey = prefix ? `${prefix}.${key}` : key;
-
-        if (!(key in target)) {
-            missing.push(fullKey);
-            continue;
-        }
-
-        if (typeof base[key] === 'object' && base[key] !== null && !Array.isArray(base[key])) {
-            if (typeof target[key] === 'object' && target[key] !== null) {
-                missing.push(...findMissingKeys(base[key], target[key], fullKey));
-            } else {
-                missing.push(fullKey);
-            }
-        }
-    }
-
-    return missing;
-}