@diagramers/cli 1.0.23 → 1.0.24

package/src/services/project-extender.ts

@@ -1,330 +0,0 @@
-import * as fs from 'fs-extra';
-import * as path from 'path';
-import chalk from 'chalk';
-
-export interface Feature {
-  name: string;
-  description: string;
-  files: string[];
-  dependencies?: string[];
-}
-
-export class ProjectExtender {
-  private features: Feature[] = [
-    {
-      name: 'auth',
-      description: 'Authentication system with JWT',
-      files: ['src/features/auth/**/*'],
-      dependencies: ['jsonwebtoken', 'bcryptjs']
-    },
-    {
-      name: 'email',
-      description: 'Email notification system',
-      files: ['src/features/email/**/*'],
-      dependencies: ['nodemailer', 'handlebars']
-    },
-    {
-      name: 'socket',
-      description: 'Real-time WebSocket communication',
-      files: ['src/features/socket/**/*'],
-      dependencies: ['socket.io']
-    },
-    {
-      name: 'cron',
-      description: 'Scheduled task system',
-      files: ['src/features/cron/**/*'],
-      dependencies: ['node-cron']
-    },
-    {
-      name: 'audit',
-      description: 'Audit logging system',
-      files: ['src/features/audit/**/*']
-    }
-  ];
-
-  async listFeatures(): Promise<void> {
-    console.log(chalk.blue('📋 Available features:'));
-    console.log('');
-    
-    this.features.forEach(feature => {
-      console.log(chalk.green(`  ${feature.name}`));
-      console.log(chalk.gray(`    ${feature.description}`));
-      if (feature.dependencies && feature.dependencies.length > 0) {
-        console.log(chalk.yellow(`    Dependencies: ${feature.dependencies.join(', ')}`));
-      }
-      console.log('');
-    });
-  }
-
-  async addFeature(featureName: string): Promise<void> {
-    const feature = this.features.find(f => f.name === featureName);
-    
-    if (!feature) {
-      throw new Error(`Feature '${featureName}' not found. Use --list to see available features.`);
-    }
-
-    const projectPath = process.cwd();
-    
-    // Check if feature already exists
-    const featurePath = path.join(projectPath, 'src', 'features', featureName);
-    if (await fs.pathExists(featurePath)) {
-      throw new Error(`Feature '${featureName}' already exists in this project.`);
-    }
-
-    // Create feature directory structure
-    await this.createFeatureStructure(projectPath, feature);
-
-    // Add dependencies if any
-    if (feature.dependencies && feature.dependencies.length > 0) {
-      await this.addDependencies(feature.dependencies);
-    }
-
-    // Update main configuration to use the extended feature
-    await this.updateMainConfiguration(projectPath, feature);
-
-    console.log(chalk.green(`✅ Feature '${featureName}' added successfully!`));
-    console.log(chalk.blue(`📝 Main configuration updated to include ${featureName} feature`));
-  }
-
-  private async createFeatureStructure(projectPath: string, feature: Feature): Promise<void> {
-    const featurePath = path.join(projectPath, 'src', 'features', feature.name);
-    
-    // Create basic feature structure
-    const structure = {
-      'controllers': 'Feature controllers',
-      'services': 'Feature business logic',
-      'schemas': 'Feature validation schemas',
-      'routes': 'Feature API routes',
-      'types': 'Feature TypeScript types'
-    };
-
-    for (const [dir, description] of Object.entries(structure)) {
-      const dirPath = path.join(featurePath, dir);
-      await fs.ensureDir(dirPath);
-      
-      // Create index file
-      const indexContent = `// ${description} for ${feature.name} feature
-export * from './${feature.name}-${dir.slice(0, -1)}';
-`;
-      await fs.writeFile(path.join(dirPath, 'index.ts'), indexContent);
-    }
-
-    // Create main feature file
-    const mainFeatureContent = `import { Router } from 'express';
-import { ${feature.name}Controller } from './controllers';
-import { ${feature.name}Service } from './services';
-
-export class ${this.capitalizeFirst(feature.name)}Feature {
-  private router: Router;
-  private controller: ${feature.name}Controller;
-  private service: ${feature.name}Service;
-
-  constructor() {
-    this.router = Router();
-    this.service = new ${feature.name}Service();
-    this.controller = new ${feature.name}Controller(this.service);
-    this.setupRoutes();
-  }
-
-  private setupRoutes(): void {
-    // Define your routes here
-    // this.router.get('/', this.controller.index.bind(this.controller));
-  }
-
-  public getRouter(): Router {
-    return this.router;
-  }
-}
-`;
-    
-    await fs.writeFile(path.join(featurePath, `${feature.name}.ts`), mainFeatureContent);
-
-    // Create controller
-    const controllerContent = `import { Request, Response } from 'express';
-import { ${feature.name}Service } from '../services';
-
-export class ${feature.name}Controller {
-  constructor(private service: ${feature.name}Service) {}
-
-  // Add your controller methods here
-  // async index(req: Request, res: Response): Promise<void> {
-  //   try {
-  //     const result = await this.service.someMethod();
-  //     res.json(result);
-  //   } catch (error) {
-  //     res.status(500).json({ error: error.message });
-  //   }
-  // }
-}
-`;
-    
-    await fs.writeFile(path.join(featurePath, 'controllers', `${feature.name}-controller.ts`), controllerContent);
-
-    // Create service
-    const serviceContent = `export class ${feature.name}Service {
-  // Add your service methods here
-  // async someMethod(): Promise<any> {
-  //   // Implementation
-  // }
-}
-`;
-    
-    await fs.writeFile(path.join(featurePath, 'services', `${feature.name}-service.ts`), serviceContent);
-
-    // Create types
-    const typesContent = `// TypeScript types for ${feature.name} feature
-export interface ${this.capitalizeFirst(feature.name)}Config {
-  // Add configuration interface
-}
-
-export interface ${this.capitalizeFirst(feature.name)}Data {
-  // Add data interface
-}
-`;
-    
-    await fs.writeFile(path.join(featurePath, 'types', `${feature.name}-types.ts`), typesContent);
-  }
-
-  private async addDependencies(dependencies: string[]): Promise<void> {
-    console.log(chalk.blue('📦 Installing dependencies...'));
-    
-    // This would typically run npm install with the dependencies
-    // For now, we'll just log what would be installed
-    console.log(chalk.yellow(`Would install: ${dependencies.join(', ')}`));
-    console.log(chalk.gray('Run: npm install ' + dependencies.join(' ') + ' to install dependencies'));
-  }
-
-  private async updateMainConfiguration(projectPath: string, feature: Feature): Promise<void> {
-    console.log(chalk.blue(`📝 Updating main configuration for ${feature.name} feature...`));
-
-    // Update main server file to include the feature
-    await this.updateServerFile(projectPath, feature);
-
-    // Update routes index to include feature routes
-    await this.updateRoutesIndex(projectPath, feature);
-
-    // Update package.json scripts if needed
-    await this.updatePackageJson(projectPath, feature);
-
-    console.log(chalk.green(`✅ Main configuration updated for ${feature.name} feature`));
-  }
-
-  private async updateServerFile(projectPath: string, feature: Feature): Promise<void> {
-    const serverFiles = [
-      'src/server/index.ts',
-      'main.ts',
-      'src/index.ts',
-      'lib/main.js'
-    ];
-
-    for (const serverFile of serverFiles) {
-      const filePath = path.join(projectPath, serverFile);
-      if (await fs.pathExists(filePath)) {
-        let content = await fs.readFile(filePath, 'utf8');
-        
-        // Add import for the feature
-        const importStatement = `import { ${this.capitalizeFirst(feature.name)}Feature } from './features/${feature.name}/${feature.name}';`;
-        
-        if (!content.includes(importStatement)) {
-          // Find the last import statement and add after it
-          const importRegex = /import.*from.*['"];?\s*$/gm;
-          const matches = [...content.matchAll(importRegex)];
-          if (matches.length > 0) {
-            const lastImport = matches[matches.length - 1];
-            const insertIndex = lastImport.index! + lastImport[0].length;
-            content = content.slice(0, insertIndex) + '\n' + importStatement + content.slice(insertIndex);
-          }
-        }
-
-        // Add feature initialization
-        const featureInit = `// Initialize ${feature.name} feature
-const ${feature.name}Feature = new ${this.capitalizeFirst(feature.name)}Feature();
-app.use('/api/${feature.name}', ${feature.name}Feature.getRouter());`;
-
-        if (!content.includes(featureInit)) {
-          // Find where routes are registered and add after
-          const routeRegex = /app\.use\(.*\);?\s*$/gm;
-          const matches = [...content.matchAll(routeRegex)];
-          if (matches.length > 0) {
-            const lastRoute = matches[matches.length - 1];
-            const insertIndex = lastRoute.index! + lastRoute[0].length;
-            content = content.slice(0, insertIndex) + '\n' + featureInit + content.slice(insertIndex);
-          }
-        }
-
-        await fs.writeFile(filePath, content);
-        console.log(chalk.green(`   ✅ Updated ${serverFile}`));
-        break; // Only update the first found server file
-      }
-    }
-  }
-
-  private async updateRoutesIndex(projectPath: string, feature: Feature): Promise<void> {
-    const routesIndexPath = path.join(projectPath, 'src/routes/index.ts');
-    
-    if (await fs.pathExists(routesIndexPath)) {
-      let content = await fs.readFile(routesIndexPath, 'utf8');
-      
-      // Add import for feature routes
-      const importStatement = `import ${feature.name}Routes from '../features/${feature.name}/routes';`;
-      
-      if (!content.includes(importStatement)) {
-        const importRegex = /import.*from.*['"];?\s*$/gm;
-        const matches = [...content.matchAll(importRegex)];
-        if (matches.length > 0) {
-          const lastImport = matches[matches.length - 1];
-          const insertIndex = lastImport.index! + lastImport[0].length;
-          content = content.slice(0, insertIndex) + '\n' + importStatement + content.slice(insertIndex);
-        }
-      }
-
-      // Add route registration
-      const routeRegistration = `app.use('/api/${feature.name}', ${feature.name}Routes);`;
-      
-      if (!content.includes(routeRegistration)) {
-        const routeRegex = /app\.use\(.*\);?\s*$/gm;
-        const matches = [...content.matchAll(routeRegex)];
-        if (matches.length > 0) {
-          const lastRoute = matches[matches.length - 1];
-          const insertIndex = lastRoute.index! + lastRoute[0].length;
-          content = content.slice(0, insertIndex) + '\n' + routeRegistration + content.slice(insertIndex);
-        }
-      }
-
-      await fs.writeFile(routesIndexPath, content);
-      console.log(chalk.green(`   ✅ Updated routes/index.ts`));
-    }
-  }
-
-  private async updatePackageJson(projectPath: string, feature: Feature): Promise<void> {
-    const packageJsonPath = path.join(projectPath, 'package.json');
-    
-    if (await fs.pathExists(packageJsonPath)) {
-      const packageJson = JSON.parse(await fs.readFile(packageJsonPath, 'utf8'));
-      
-      // Add feature-specific scripts if needed
-      if (!packageJson.scripts) {
-        packageJson.scripts = {};
-      }
-
-      // Add feature-specific scripts
-      const featureScripts = {
-        [`test:${feature.name}`]: `npm test -- --grep "${feature.name}"`,
-        [`build:${feature.name}`]: `npm run build && echo "Built with ${feature.name} feature"`
-      };
-
-      for (const [scriptName, scriptCommand] of Object.entries(featureScripts)) {
-        if (!packageJson.scripts[scriptName]) {
-          packageJson.scripts[scriptName] = scriptCommand;
-        }
-      }
-
-      await fs.writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2));
-      console.log(chalk.green(`   ✅ Updated package.json with ${feature.name} scripts`));
-    }
-  }
-
-  private capitalizeFirst(str: string): string {
-    return str.charAt(0).toUpperCase() + str.slice(1);
-  }
-} 

package/src/services/project-initializer.ts

@@ -1,335 +0,0 @@
-import * as fs from 'fs-extra';
-import * as path from 'path';
-import * as glob from 'glob';
-import chalk from 'chalk';
-import { execSync } from 'child_process';
-
-export interface InitOptions {
-  template?: string;
-  yes?: boolean;
-}
-
-export class ProjectInitializer {
-  private templateFiles: string[] = [
-    'scripts',
-    'src/**/*',
-    'scripts/**/*',
-    'package.json',
-    'tsconfig.json',
-    'webpack.config.js',
-    'main.ts',
-    'certs/**/*'
-  ];
-
-  constructor() {
-    // No need for template path as we'll use npm package
-  }
-
-  async initialize(projectName: string, options: InitOptions): Promise<void> {
-    const projectPath = path.resolve(process.cwd(), projectName);
-    const templateType = options.template || 'api';
-
-    // Check if project directory already exists
-    if (await fs.pathExists(projectPath)) {
-      throw new Error(`Project directory ${projectName} already exists`);
-    }
-
-    // Create project directory
-    await fs.ensureDir(projectPath);
-
-    // Install the appropriate template package
-    await this.installTemplatePackage(projectPath, templateType);
-
-    // Copy template files from the installed package
-    await this.copyTemplateFiles(projectPath, templateType);
-
-    // Update package.json with project name
-    await this.updatePackageJson(projectPath, projectName, templateType);
-
-    // Create .gitignore
-    await this.createGitignore(projectPath);
-
-    // Create README
-    await this.createReadme(projectPath, projectName, templateType);
-
-    // Make scripts executable
-    await this.makeScriptsExecutable(projectPath);
-
-    // Process template for project name (update database names, etc.)
-    await this.processTemplate(projectPath, projectName);
-
-    // Clean up the temporary installation
-    await this.cleanup(projectPath);
-
-    console.log(chalk.green(`✅ Project structure created successfully`));
-  }
-
-  private async installTemplatePackage(projectPath: string, templateType: string): Promise<void> {
-    const packageName = `@diagramers/${templateType}`;
-    console.log(chalk.blue(`📦 Installing ${packageName} template...`));
-    
-    try {
-      // Install the template package temporarily
-      execSync(`npm install ${packageName} --no-save`, { 
-        cwd: projectPath, 
-        stdio: 'inherit' 
-      });
-    } catch (error: any) {
-      throw new Error(`Failed to install ${packageName} package: ${error.message}`);
-    }
-  }
-
-  private async copyTemplateFiles(projectPath: string, templateType: string): Promise<void> {
-    const nodeModulesPath = path.join(projectPath, 'node_modules', '@diagramers', templateType);
-    
-    if (!await fs.pathExists(nodeModulesPath)) {
-      throw new Error(`@diagramers/${templateType} package not found in node_modules`);
-    }
-
-    for (const pattern of this.templateFiles) {
-      try {
-        const files = glob.sync(pattern, { 
-          cwd: nodeModulesPath, 
-          ignore: ['node_modules/**', 'dist/**', '.git/**'],
-          nodir: false
-        });
-
-        for (const file of files) {
-          const sourcePath = path.join(nodeModulesPath, file);
-          const destPath = path.join(projectPath, file);
-
-          if (await fs.pathExists(sourcePath)) {
-            const stat = await fs.stat(sourcePath);
-            
-            if (stat.isDirectory()) {
-              // Copy directory
-              await fs.ensureDir(destPath);
-              await fs.copy(sourcePath, destPath);
-            } else {
-              // Copy file
-              await fs.ensureDir(path.dirname(destPath));
-              await fs.copy(sourcePath, destPath);
-            }
-          }
-        }
-      } catch (error: any) {
-        // Log warning but continue with other files
-        console.log(chalk.yellow(`⚠️  Warning: Could not copy pattern '${pattern}': ${error.message}`));
-      }
-    }
-  }
-
-  private async cleanup(projectPath: string): Promise<void> {
-    // Remove the temporary node_modules
-    const nodeModulesPath = path.join(projectPath, 'node_modules');
-    if (await fs.pathExists(nodeModulesPath)) {
-      await fs.remove(nodeModulesPath);
-    }
-    
-    // Remove package-lock.json if it exists
-    const packageLockPath = path.join(projectPath, 'package-lock.json');
-    if (await fs.pathExists(packageLockPath)) {
-      await fs.remove(packageLockPath);
-    }
-  }
-
-  private async updatePackageJson(projectPath: string, projectName: string, templateType: string): Promise<void> {
-    const packageJsonPath = path.join(projectPath, 'package.json');
-    
-    if (await fs.pathExists(packageJsonPath)) {
-      const packageJson = await fs.readJson(packageJsonPath);
-      packageJson.name = projectName;
-      packageJson.description = `${templateType.toUpperCase()} project: ${projectName}`;
-      
-      // Remove the bin field if it exists (this is for CLI packages)
-      if (packageJson.bin) {
-        delete packageJson.bin;
-      }
-
-      // Ensure CLI scripts are included
-      if (!packageJson.scripts) {
-        packageJson.scripts = {};
-      }
-      
-      // Add CLI scripts if they don't exist
-      if (!packageJson.scripts['generate:module']) {
-        packageJson.scripts['generate:module'] = './scripts/generate-module.sh';
-      }
-      if (!packageJson.scripts['cli']) {
-        packageJson.scripts['cli'] = './scripts/cli-commands.sh';
-      }
-      
-      await fs.writeJson(packageJsonPath, packageJson, { spaces: 2 });
-    }
-  }
-
-  private async createGitignore(projectPath: string): Promise<void> {
-    const gitignoreContent = `
-# Dependencies
-node_modules/
-npm-debug.log*
-yarn-debug.log*
-yarn-error.log*
-
-# Build outputs
-dist/
-build/
-*.tsbuildinfo
-
-# Environment variables
-.env
-.env.local
-.env.development.local
-.env.test.local
-.env.production.local
-
-# IDE
-.vscode/
-.idea/
-*.swp
-*.swo
-
-# OS
-.DS_Store
-Thumbs.db
-
-# Logs
-logs
-*.log
-
-# Runtime data
-pids
-*.pid
-*.seed
-*.pid.lock
-
-# Coverage directory used by tools like istanbul
-coverage/
-
-# Firebase
-.firebase/
-firebase-debug.log
-firestore-debug.log
-ui-debug.log
-
-# Temporary folders
-tmp/
-temp/
-`.trim();
-
-    await fs.writeFile(path.join(projectPath, '.gitignore'), gitignoreContent);
-  }
-
-  private async createReadme(projectPath: string, projectName: string, templateType: string): Promise<void> {
-    const templateTitle = templateType.toUpperCase();
-    const readmeContent = `# ${projectName}
-
-A Node.js ${templateType} project built with TypeScript and Firebase Functions.
-
-## Features
-
-- Express.js server with TypeScript
-- Firebase Functions integration
-- Socket.io for real-time communication
-- MongoDB with Mongoose
-- Authentication system
-- Email notifications
-- Cron jobs
-- Audit logging
-
-## Getting Started
-
-1. Install dependencies:
-   \`\`\`bash
-   npm install
-   \`\`\`
-
-2. Set up environment variables:
-   - Copy \`.env.example\` to \`.env\`
-   - Update the values according to your configuration
-
-3. Start development server:
-   \`\`\`bash
-   npm run serve
-   \`\`\`
-
-## Available Scripts
-
-- \`npm run serve\` - Start development server
-- \`npm run build:dev\` - Build for development
-- \`npm run build:prod\` - Build for production
-- \`npm run deploy\` - Deploy to Firebase
-
-## Project Structure
-
-\`\`\`
-src/
-├── config/          # Configuration files
-├── controllers/     # Route controllers
-├── entities/        # Database entities
-├── helpers/         # Utility functions
-├── routes/          # API routes
-├── schemas/         # Validation schemas
-├── server/          # Server setup
-└── services/        # Business logic
-\`\`\`
-
-## Contributing
-
-1. Fork the repository
-2. Create a feature branch
-3. Make your changes
-4. Test thoroughly
-5. Submit a pull request
-
-## License
-
-MIT
-`;
-
-    await fs.writeFile(path.join(projectPath, 'README.md'), readmeContent);
-  }
-
-  private async makeScriptsExecutable(projectPath: string): Promise<void> {
-    const scriptsDir = path.join(projectPath, 'scripts');
-    
-    if (await fs.pathExists(scriptsDir)) {
-      try {
-        const scripts = await fs.readdir(scriptsDir);
-        for (const script of scripts) {
-          if (script.endsWith('.sh')) {
-            const scriptPath = path.join(scriptsDir, script);
-            // Make script executable (chmod 755)
-            await fs.chmod(scriptPath, 0o755);
-            console.log(chalk.blue(`🔧 Made executable: ${script}`));
-          }
-        }
-      } catch (error: any) {
-        console.log(chalk.yellow(`⚠️  Warning: Could not make scripts executable: ${error.message}`));
-      }
-    }
-  }
-
-  private async processTemplate(projectPath: string, projectName: string): Promise<void> {
-    try {
-      console.log(chalk.blue(`🔧 Processing template for project: ${projectName}`));
-      
-      // Change to project directory
-      const originalCwd = process.cwd();
-      process.chdir(projectPath);
-      
-      // Run the template processor
-      execSync(`npm run cli process:template ${projectName}`, { 
-        stdio: 'inherit' 
-      });
-      
-      // Change back to original directory
-      process.chdir(originalCwd);
-      
-      console.log(chalk.green(`✅ Template processed successfully`));
-    } catch (error: any) {
-      console.log(chalk.yellow(`⚠️  Warning: Could not process template: ${error.message}`));
-      console.log(chalk.yellow(`   You can manually run: npm run cli process:template ${projectName}`));
-    }
-  }
-}