@objectql/cli 1.6.0 → 1.7.0

package/src/commands/i18n.ts

@@ -0,0 +1,303 @@
+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;
+}

package/src/commands/init.ts

@@ -0,0 +1,191 @@
+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;
+    }
+}