eva4j 1.0.0

package/src/commands/add-kafka-client.js

@@ -0,0 +1,193 @@
+const ora = require('ora');
+const chalk = require('chalk');
+const path = require('path');
+const fs = require('fs-extra');
+const ConfigManager = require('../utils/config-manager');
+const { isEva4jProject } = require('../utils/validator');
+const { toPackagePath } = require('../utils/naming');
+const { renderAndWrite } = require('../utils/template-engine');
+
+async function addKafkaClientCommand() {
+  const projectDir = process.cwd();
+  
+  // Validate we're in an eva4j project
+  if (!(await isEva4jProject(projectDir))) {
+    console.error(chalk.red('❌ Not in an eva4j project directory'));
+    console.error(chalk.gray('Run this command inside a project created with eva4j'));
+    process.exit(1);
+  }
+
+  // Check if kafka is already installed
+  const configManager = new ConfigManager(projectDir);
+  if (await configManager.featureExists('kafka')) {
+    console.error(chalk.red('❌ Kafka client is already installed in this project'));
+    console.log(chalk.gray('\nKafka dependencies and configuration already exist.'));
+    process.exit(1);
+  }
+
+  // Load project configuration
+  const projectConfig = await configManager.loadProjectConfig();
+  if (!projectConfig) {
+    console.error(chalk.red('❌ Could not load project configuration'));
+    console.error(chalk.gray('Make sure .eva4j.json exists in the project root'));
+    process.exit(1);
+  }
+
+  const { packageName, projectName, groupId } = projectConfig;
+  const packagePath = toPackagePath(packageName);
+
+  // Check if shared module exists
+  const sharedPath = path.join(projectDir, 'src', 'main', 'java', packagePath, 'shared');
+  if (!(await fs.pathExists(sharedPath))) {
+    console.error(chalk.red('❌ Shared module not found'));
+    console.error(chalk.gray('Create at least one module first using: eva4j add module <name>'));
+    process.exit(1);
+  }
+
+  const spinner = ora('Adding Kafka client support...').start();
+
+  try {
+    const context = {
+      packageName,
+      packagePath,
+      projectName,
+      groupId
+    };
+
+    // 1. Add dependencies to build.gradle
+    spinner.text = 'Adding Kafka dependencies to build.gradle...';
+    await addKafkaDependencies(projectDir);
+
+    // 2. Generate kafka.yml files for all environments
+    spinner.text = 'Generating Kafka configuration files...';
+    await generateKafkaConfigFiles(projectDir, context);
+
+    // 3. Add kafka.yml imports to application-*.yml files
+    spinner.text = 'Updating application configuration files...';
+    await addKafkaImports(projectDir);
+
+    // 4. Generate KafkaConfig.java
+    spinner.text = 'Generating KafkaConfig class...';
+    await generateKafkaConfigClass(projectDir, context);
+
+    // 5. Save feature to configuration
+    await configManager.addFeature('kafka');
+
+    spinner.succeed(chalk.green('Kafka client support added successfully! ✨'));
+
+    console.log(chalk.blue('\n📦 Added components:'));
+    console.log(chalk.gray('  ├── build.gradle (Kafka dependencies)'));
+    console.log(chalk.gray('  ├── src/main/resources/parameters/'));
+    console.log(chalk.gray('  │   ├── local/kafka.yml'));
+    console.log(chalk.gray('  │   ├── develop/kafka.yml'));
+    console.log(chalk.gray('  │   ├── test/kafka.yml'));
+    console.log(chalk.gray('  │   └── production/kafka.yml'));
+    console.log(chalk.gray('  └── shared/configurations/kafkaConfig/KafkaConfig.java'));
+    
+    console.log(chalk.blue('\n✅ Kafka client configured successfully!'));
+    console.log(chalk.white('\n   Bootstrap Servers: localhost:9092'));
+    console.log(chalk.white(`   Consumer Group: ${projectName}-api-group`));
+    console.log(chalk.gray('\n   Update kafka.yml files to customize broker URLs per environment'));
+    console.log();
+
+  } catch (error) {
+    spinner.fail(chalk.red('Failed to add Kafka client support'));
+    console.error(chalk.red('\n❌ Error:'), error.message);
+    if (error.stack) {
+      console.error(chalk.gray(error.stack));
+    }
+    process.exit(1);
+  }
+}
+
+/**
+ * Add Kafka dependencies to build.gradle
+ */
+async function addKafkaDependencies(projectDir) {
+  const buildGradlePath = path.join(projectDir, 'build.gradle');
+  let buildGradleContent = await fs.readFile(buildGradlePath, 'utf-8');
+
+  // Check if dependencies already exist
+  if (buildGradleContent.includes('spring-kafka')) {
+    return; // Already added
+  }
+
+  // Find the dependencies block and add Kafka dependencies
+  const dependenciesMatch = buildGradleContent.match(/(dependencies\s*\{[^}]*)(implementation 'org\.springframework\.modulith:spring-modulith-starter-core'[^\n]*\n)/s);
+  
+  if (!dependenciesMatch) {
+    throw new Error('Could not find dependencies block in build.gradle');
+  }
+
+  const kafkaDependencies = `\n\t// Kafka\n\timplementation 'org.springframework.kafka:spring-kafka'\n\ttestImplementation 'org.springframework.kafka:spring-kafka-test'\n\n\t`;
+
+  buildGradleContent = buildGradleContent.replace(
+    dependenciesMatch[0],
+    dependenciesMatch[1] + dependenciesMatch[2] + kafkaDependencies
+  );
+
+  await fs.writeFile(buildGradlePath, buildGradleContent, 'utf-8');
+}
+
+/**
+ * Generate kafka.yml configuration files for all environments
+ */
+async function generateKafkaConfigFiles(projectDir, context) {
+  const templatePath = path.join(__dirname, '..', '..', 'templates', 'base', 'resources', 'parameters');
+  const environments = ['local', 'develop', 'test', 'production'];
+
+  for (const env of environments) {
+    const outputPath = path.join(projectDir, 'src', 'main', 'resources', 'parameters', env, 'kafka.yml');
+    const templateFile = path.join(templatePath, env, 'kafka.yml.ejs');
+    
+    await renderAndWrite(templateFile, outputPath, context);
+  }
+}
+
+/**
+ * Add kafka.yml imports to application-*.yml files
+ */
+async function addKafkaImports(projectDir) {
+  const resourcesDir = path.join(projectDir, 'src', 'main', 'resources');
+  const environments = ['local', 'develop', 'test', 'production'];
+
+  for (const env of environments) {
+    const appYmlPath = path.join(resourcesDir, `application-${env}.yml`);
+    
+    if (await fs.pathExists(appYmlPath)) {
+      let content = await fs.readFile(appYmlPath, 'utf-8');
+      
+      // Check if kafka.yml import already exists
+      if (content.includes('kafka.yml')) {
+        continue;
+      }
+
+      // Add kafka.yml import after existing imports
+      const importPattern = /(spring:\s*\n\s*config:\s*\n\s*import:\s*\n(?:\s*-\s*"[^"]+"\s*\n)*)/;
+      
+      if (importPattern.test(content)) {
+        content = content.replace(
+          importPattern,
+          `$1      - "classpath:parameters/${env}/kafka.yml"\n`
+        );
+      } else {
+        // If no imports section exists, add it
+        content = `spring:\n  config:\n    import:\n      - "classpath:parameters/${env}/kafka.yml"\n\n` + content;
+      }
+
+      await fs.writeFile(appYmlPath, content, 'utf-8');
+    }
+  }
+}
+
+/**
+ * Generate KafkaConfig.java class
+ */
+async function generateKafkaConfigClass(projectDir, context) {
+  const templatePath = path.join(__dirname, '..', '..', 'templates', 'shared', 'configurations', 'kafkaConfig', 'KafkaConfig.java.ejs');
+  const outputPath = path.join(projectDir, 'src', 'main', 'java', context.packagePath, 'shared', 'infrastructure', 'configurations', 'kafkaConfig', 'KafkaConfig.java');
+  
+  await renderAndWrite(templatePath, outputPath, context);
+}
+
+module.exports = addKafkaClientCommand;

package/src/commands/add-module.js

@@ -0,0 +1,221 @@
+const inquirer = require('inquirer');
+const ora = require('ora');
+const chalk = require('chalk');
+const path = require('path');
+const fs = require('fs-extra');
+const SharedGenerator = require('../generators/shared-generator');
+const ModuleGenerator = require('../generators/module-generator');
+const { buildModuleContext } = require('../utils/context-builder');
+const { validateModuleName, isEva4jProject, moduleExists } = require('../utils/validator');
+const { toPackagePath } = require('../utils/naming');
+const ConfigManager = require('../utils/config-manager');
+
+async function addModuleCommand(moduleName, options) {
+  const projectDir = process.cwd();
+  
+  // Validate we're in a Spring Boot project
+  if (!(await isEva4jProject(projectDir))) {
+    console.error(chalk.red('❌ Not in a Spring Boot project directory'));
+    console.error(chalk.gray('Run this command inside a project created with eva4j'));
+    process.exit(1);
+  }
+  
+  // Prompt for module name if not provided
+  if (!moduleName) {
+    const nameAnswer = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'moduleName',
+        message: 'Enter module name (camelCase):',
+        validate: (input) => {
+          const validation = validateModuleName(input);
+          if (validation !== true) {
+            return `${validation}. Examples: user, product, orderItem`;
+          }
+          return true;
+        }
+      }
+    ]);
+    moduleName = nameAnswer.moduleName;
+  }
+  
+  // Read build.gradle to get project info
+  const buildGradle = await fs.readFile(path.join(projectDir, 'build.gradle'), 'utf-8');
+  const groupMatch = buildGradle.match(/group\s*=\s*['"](.+)['"]/);
+  const packageMatch = buildGradle.match(/package\s+([a-z.]+)/);
+  
+  if (!groupMatch) {
+    console.error(chalk.red('❌ Could not determine project package'));
+    process.exit(1);
+  }
+  
+  // Extract package info from Application.java
+  const srcJavaDir = path.join(projectDir, 'src', 'main', 'java');
+  const javaFiles = await findJavaFiles(srcJavaDir);
+  let packageName = '';
+  
+  for (const file of javaFiles) {
+    if (file.includes('Application.java')) {
+      const content = await fs.readFile(file, 'utf-8');
+      const pkgMatch = content.match(/package\s+([a-zA-Z0-9_.]+);/);
+      if (pkgMatch) {
+        packageName = pkgMatch[1];
+        break;
+      }
+    }
+  }
+  
+  if (!packageName) {
+    console.error(chalk.red('❌ Could not determine project package'));
+    process.exit(1);
+  }
+  
+  const packagePath = toPackagePath(packageName);
+  
+  // Validate module name
+  const validation = validateModuleName(moduleName);
+  if (validation !== true) {
+    console.error(chalk.red(`❌ ${validation}`));
+    process.exit(1);
+  }
+  
+  // Check if module already exists (filesystem check)
+  if (await moduleExists(projectDir, packagePath, moduleName)) {
+    console.error(chalk.red(`❌ Module '${moduleName}' already exists`));
+    process.exit(1);
+  }
+  
+  // Check ConfigManager for module tracking
+  const configManager = new ConfigManager(projectDir);
+  let projectName = 'Project';
+  
+  if (await configManager.exists()) {
+    if (await configManager.moduleExists(moduleName)) {
+      console.error(chalk.red(`❌ Module '${moduleName}' is already registered`));
+      process.exit(1);
+    }
+    // Load project config to get projectName
+    const projectConfig = await configManager.loadProjectConfig();
+    if (projectConfig && projectConfig.projectName) {
+      projectName = projectConfig.projectName;
+    }
+  }
+  
+  // Prompt for module options
+  const answers = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'hasSoftDelete',
+      message: 'Enable soft delete?',
+      default: true
+    },
+    {
+      type: 'confirm',
+      name: 'hasAudit',
+      message: 'Enable audit fields (createdAt, updatedAt)?',
+      default: true
+    }
+  ]);
+  
+  const baseContext = {
+    packageName,
+    packagePath,
+    projectName,
+    groupId: groupMatch[1]
+  };
+  
+  const moduleContext = buildModuleContext(baseContext, moduleName, answers);
+  
+  try {
+    // Check if shared module needs to be generated
+    const needsShared = await SharedGenerator.needsSharedModule(projectDir, packagePath);
+    
+    if (needsShared) {
+      console.log(chalk.blue('\n📦 First module! Creating shared module...\n'));
+      const sharedSpinner = ora('Generating shared module...').start();
+      
+      const sharedGenerator = new SharedGenerator(moduleContext);
+      await sharedGenerator.generate();
+      
+      sharedSpinner.succeed(chalk.green('Shared module created ✨'));
+      
+      console.log(chalk.gray('  └── shared/'));
+      console.log(chalk.gray('      ├── domain/ (BaseEntity, AuditableEntity, SoftDeletableEntity)'));
+      console.log(chalk.gray('      ├── dto/ (ApiResponse, PageResponse, ErrorDetail)'));
+      console.log(chalk.gray('      ├── enums/ (Status, Currency, ErrorCode)'));
+      console.log(chalk.gray('      └── constants/'));
+      console.log();
+    }
+    
+    // Generate module
+    const moduleSpinner = ora(`Generating ${moduleName} module...`).start();
+    
+    const moduleGenerator = new ModuleGenerator(moduleContext);
+    await moduleGenerator.generate();
+    
+    moduleSpinner.succeed(chalk.green(`Module '${moduleName}' created successfully! ✨`));
+    
+    console.log(chalk.blue(`\n📦 Module structure:`));
+    console.log(chalk.gray(`  └── ${moduleName}/`));
+    console.log(chalk.gray(`      ├── package-info.java (@ApplicationModule)`));
+    console.log(chalk.gray(`      ├── application/`));
+    console.log(chalk.gray(`      │   ├── commands/ (write operations)`));
+    console.log(chalk.gray(`      │   ├── dtos/ (data transfer objects)`));
+    console.log(chalk.gray(`      │   ├── mappers/ (entity-dto conversions)`));
+    console.log(chalk.gray(`      │   ├── events/ (domain events)`));
+    console.log(chalk.gray(`      │   ├── ports/ (interfaces)`));
+    console.log(chalk.gray(`      │   ├── queries/ (read operations)`));
+    console.log(chalk.gray(`      │   └── usecases/ (application logic)`));
+    console.log(chalk.gray(`      ├── domain/`));
+    console.log(chalk.gray(`      │   ├── models/`));
+    console.log(chalk.gray(`      │   │   ├── entities/`));
+    console.log(chalk.gray(`      │   │   └── valueObjects/`));
+    console.log(chalk.gray(`      │   ├── repositories/ (domain interfaces)`));
+    console.log(chalk.gray(`      │   └── services/ (domain services)`));
+    console.log(chalk.gray(`      └── infrastructure/`));
+    console.log(chalk.gray(`          ├── adapters/ (external adapters)`));
+    console.log(chalk.gray(`          ├── database/ (repository implementations)`));
+    console.log(chalk.gray(`          └── rest/`));
+    console.log(chalk.gray(`              ├── controllers/ (REST controllers)`));
+    console.log(chalk.gray(`              └── validators/ (request validators)`));
+    
+    console.log(chalk.blue('\n✅ Module created successfully!'));
+    console.log(chalk.white(`\n   Module: ${moduleName}`));
+    console.log(chalk.gray(`   Package: ${moduleContext.packageName}.${moduleName}`));
+    
+    // Save module to configuration
+    if (await configManager.exists()) {
+      await configManager.addModule(moduleName, {
+        hasSoftDelete: answers.hasSoftDelete,
+        hasAudit: answers.hasAudit
+      });
+      console.log(chalk.gray('   Configuration saved to .eva4j.json'));
+    }
+    console.log();
+    
+  } catch (error) {
+    console.error(chalk.red('\n❌ Failed to create module'));
+    console.error(chalk.red(error.message));
+    if (error.stack) {
+      console.error(chalk.gray(error.stack));
+    }
+    process.exit(1);
+  }
+}
+
+async function findJavaFiles(dir, files = []) {
+  const entries = await fs.readdir(dir, { withFileTypes: true });
+  
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      await findJavaFiles(fullPath, files);
+    } else if (entry.name.endsWith('.java')) {
+      files.push(fullPath);
+    }
+  }
+  
+  return files;
+}
+
+module.exports = addModuleCommand;

package/src/commands/create.js

@@ -0,0 +1,92 @@
+const inquirer = require('inquirer');
+const ora = require('ora');
+const chalk = require('chalk');
+const BaseGenerator = require('../generators/base-generator');
+const { buildBaseContext } = require('../utils/context-builder');
+const { validateProjectName, validateGroupId } = require('../utils/validator');
+const defaults = require('../../config/defaults.json');
+
+async function createCommand(projectName, options) {
+  console.log(chalk.blue.bold('\n🚀 Creating new Spring Boot project with eva4j\n'));
+  
+  // Gather project information
+  const answers = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'artifactId',
+      message: 'Project artifact ID:',
+      default: projectName,
+      validate: validateProjectName
+    },
+    {
+      type: 'input',
+      name: 'groupId',
+      message: 'Group ID:',
+      default: 'com.example',
+      validate: validateGroupId
+    },
+    {
+      type: 'list',
+      name: 'javaVersion',
+      message: 'Java version:',
+      choices: [21, 22, 23],
+      default: 21
+    },
+    {
+      type: 'input',
+      name: 'springBootVersion',
+      message: 'Spring Boot version:',
+      default: defaults.springBootVersion
+    },
+    {
+      type: 'list',
+      name: 'databaseType',
+      message: 'Database type:',
+      choices: ['postgresql', 'mysql', 'h2'],
+      default: 'postgresql'
+    },
+    {
+      type: 'input',
+      name: 'author',
+      message: 'Author name:',
+      default: 'Developer'
+    }
+  ]);
+  
+  // Set all required dependencies
+  answers.dependencies = ['web', 'data-jpa', 'security', 'validation', 'actuator'];
+  
+  // Build context
+  const context = buildBaseContext(answers);
+  
+  // Generate project
+  const spinner = ora('Generating project structure...').start();
+  
+  try {
+    const generator = new BaseGenerator(context);
+    await generator.generate();
+    
+    spinner.succeed(chalk.green('Project created successfully! ✨'));
+    
+    console.log(chalk.blue('\n📦 Project structure:'));
+    console.log(chalk.gray(`  ${context.artifactId}/`));
+    console.log(chalk.gray(`    ├── src/main/java/${context.packagePath.replace(/\//g, '.')}`));
+    console.log(chalk.gray(`    │   ├── ${context.applicationClassName}.java`));
+    console.log(chalk.gray(`    │   └── common/`));
+    console.log(chalk.gray(`    ├── build.gradle`));
+    console.log(chalk.gray(`    └── README.md`));
+    
+    console.log(chalk.blue('\n🚀 Next steps:'));
+    console.log(chalk.white(`  cd ${context.artifactId}`));
+    console.log(chalk.white(`  eva4j add module user    # Add your first module`));
+    console.log(chalk.white(`  ./gradlew bootRun        # Run the application`));
+    console.log();
+    
+  } catch (error) {
+    spinner.fail(chalk.red('Failed to create project'));
+    console.error(chalk.red(error.message));
+    process.exit(1);
+  }
+}
+
+module.exports = createCommand;