eva4j 1.0.0

package/src/utils/config-manager.js

@@ -0,0 +1,156 @@
+const fs = require('fs-extra');
+const path = require('path');
+
+class ConfigManager {
+  constructor(projectPath = process.cwd()) {
+    this.projectPath = projectPath;
+    this.configFile = path.join(projectPath, '.eva4j.json');
+  }
+
+  /**
+   * Save project configuration to .eva4j.json
+   * @param {Object} config - Project configuration
+   * @param {string} config.projectName - Name of the project
+   * @param {string} config.groupId - Maven group ID
+   * @param {string} config.artifactId - Maven artifact ID
+   * @param {string} config.packageName - Base package name
+   * @param {string} config.javaVersion - Java version
+   * @param {string} config.springBootVersion - Spring Boot version
+   * @param {string} config.springModulithVersion - Spring Modulith version
+   * @param {Array<string>} config.dependencies - Selected dependencies
+   * @param {string} config.createdAt - ISO timestamp of creation
+   */
+  async saveProjectConfig(config) {
+    const projectConfig = {
+      projectName: config.projectName,
+      groupId: config.groupId,
+      artifactId: config.artifactId,
+      packageName: config.packageName,
+      javaVersion: config.javaVersion,
+      springBootVersion: config.springBootVersion,
+      springModulithVersion: config.springModulithVersion,
+      dependencies: config.dependencies || [],
+      databaseType: config.databaseType,
+      modules: [],
+      createdAt: config.createdAt || new Date().toISOString(),
+      updatedAt: new Date().toISOString()
+    };
+
+    await fs.writeJson(this.configFile, projectConfig, { spaces: 2 });
+    return projectConfig;
+  }
+
+  /**
+   * Load project configuration from .eva4j.json
+   * @returns {Object|null} Project configuration or null if not found
+   */
+  async loadProjectConfig() {
+    try {
+      if (await fs.pathExists(this.configFile)) {
+        return await fs.readJson(this.configFile);
+      }
+      return null;
+    } catch (error) {
+      console.error('Error loading project configuration:', error.message);
+      return null;
+    }
+  }
+
+  /**
+   * Add a module to the project configuration
+   * @param {string} moduleName - Name of the module
+   * @param {Object} options - Module options
+   */
+  async addModule(moduleName, options = {}) {
+    const config = await this.loadProjectConfig();
+    if (!config) {
+      throw new Error('Project configuration not found. Are you in an eva4j project?');
+    }
+
+    const module = {
+      name: moduleName,
+      createdAt: new Date().toISOString(),
+      ...options
+    };
+
+    config.modules.push(module);
+    config.updatedAt = new Date().toISOString();
+
+    await fs.writeJson(this.configFile, config, { spaces: 2 });
+    return config;
+  }
+
+  /**
+   * Check if a module exists in the project
+   * @param {string} moduleName - Name of the module to check
+   * @returns {boolean} True if module exists
+   */
+  async moduleExists(moduleName) {
+    const config = await this.loadProjectConfig();
+    if (!config) return false;
+    
+    return config.modules.some(module => module.name === moduleName);
+  }
+
+  /**
+   * Get all modules from the project configuration
+   * @returns {Array} List of modules
+   */
+  async getModules() {
+    const config = await this.loadProjectConfig();
+    return config ? config.modules : [];
+  }
+
+  /**
+   * Check if .eva4j.json exists in the project
+   * @returns {boolean} True if config file exists
+   */
+  async exists() {
+    return await fs.pathExists(this.configFile);
+  }
+
+  /**
+   * Get the full project configuration path
+   * @returns {string} Path to .eva4j.json
+   */
+  getConfigPath() {
+    return this.configFile;
+  }
+
+  /**
+   * Check if a feature exists in the project
+   * @param {string} featureName - Name of the feature to check
+   * @returns {boolean} True if feature exists
+   */
+  async featureExists(featureName) {
+    const config = await this.loadProjectConfig();
+    if (!config || !config.features) return false;
+    
+    return config.features.includes(featureName);
+  }
+
+  /**
+   * Add a feature to the project configuration
+   * @param {string} featureName - Name of the feature to add
+   */
+  async addFeature(featureName) {
+    const config = await this.loadProjectConfig();
+    if (!config) {
+      throw new Error('Project configuration not found. Are you in an eva4j project?');
+    }
+
+    if (!config.features) {
+      config.features = [];
+    }
+
+    if (!config.features.includes(featureName)) {
+      config.features.push(featureName);
+      config.updatedAt = new Date().toISOString();
+      await fs.writeJson(this.configFile, config, { spaces: 2 });
+    }
+
+    return config;
+  }
+}
+
+module.exports = ConfigManager;

package/src/utils/context-builder.js

@@ -0,0 +1,149 @@
+const defaults = require('../../config/defaults.json');
+const {
+  toPackagePath,
+  getApplicationClassName,
+  getFullPackageName,
+  toPascalCase,
+  toSnakeCase,
+  pluralizeWord,
+  getBaseEntity
+} = require('./naming');
+
+/**
+ * Build context for base project generation
+ */
+function buildBaseContext(answers) {
+  const packageName = getFullPackageName(answers.groupId, answers.artifactId);
+  const packagePath = toPackagePath(packageName);
+  const applicationClassName = getApplicationClassName(answers.artifactId);
+  
+  const context = {
+    projectName: answers.projectName || answers.artifactId,
+    artifactId: answers.artifactId,
+    groupId: answers.groupId,
+    version: defaults.version,
+    packageName,
+    packagePath,
+    applicationClassName,
+    javaVersion: answers.javaVersion || defaults.javaVersion,
+    springBootVersion: answers.springBootVersion || defaults.springBootVersion,
+    dependencyManagementVersion: defaults.dependencyManagementVersion,
+    springModulithVersion: defaults.springModulithVersion,
+    springCloudVersion: defaults.springCloudVersion,
+    gradleVersion: defaults.gradleVersion,
+    dependencies: answers.dependencies || [],
+    author: answers.author || 'Generated by eva4j',
+    createdDate: new Date().toISOString().split('T')[0],
+    license: 'MIT',
+    description: answers.description || `Spring Boot application: ${answers.artifactId}`,
+    ...buildDatabaseContext(answers),
+    ...buildServerContext(answers),
+    features: {
+      ...defaults.features,
+      includeAudit: answers.dependencies?.includes('data-jpa'),
+      ...answers.features
+    },
+    testing: defaults.testing,
+    loggingLevel: defaults.logging.level
+  };
+  
+  return context;
+}
+
+/**
+ * Build database configuration context
+ */
+function buildDatabaseContext(answers) {
+  if (!answers.dependencies?.includes('data-jpa')) {
+    return {};
+  }
+  
+  const databaseType = answers.databaseType || 'h2';
+  const databaseName = answers.artifactId.replace(/-/g, '_');
+  
+  const dbConfig = {
+    h2: {
+      driver: 'com.h2.database:h2',
+      driverClass: 'org.h2.Driver',
+      url: `jdbc:h2:mem:${databaseName}`,
+      username: 'sa',
+      password: '',
+      hibernateDialect: 'org.hibernate.dialect.H2Dialect',
+      testcontainer: 'h2'
+    },
+    postgresql: {
+      driver: 'org.postgresql:postgresql',
+      driverClass: 'org.postgresql.Driver',
+      url: `jdbc:postgresql://localhost:5432/${databaseName}`,
+      username: answers.databaseUsername || 'postgres',
+      password: answers.databasePassword || 'postgres',
+      hibernateDialect: 'org.hibernate.dialect.PostgreSQLDialect',
+      testcontainer: 'postgresql'
+    },
+    mysql: {
+      driver: 'com.mysql:mysql-connector-j',
+      driverClass: 'com.mysql.cj.jdbc.Driver',
+      url: `jdbc:mysql://localhost:3306/${databaseName}`,
+      username: answers.databaseUsername || 'root',
+      password: answers.databasePassword || 'root',
+      hibernateDialect: 'org.hibernate.dialect.MySQLDialect',
+      testcontainer: 'mysql'
+    }
+  };
+  
+  const config = dbConfig[databaseType];
+  
+  return {
+    databaseType,
+    databaseName,
+    databaseDriver: config.driver,
+    databaseDriverClass: config.driverClass,
+    databaseUrl: config.url,
+    databaseUsername: config.username,
+    databasePassword: config.password,
+    hibernateDialect: config.hibernateDialect,
+    databaseTestcontainer: config.testcontainer,
+    ddlAuto: defaults.database.ddlAuto,
+    showSql: defaults.database.showSql
+  };
+}
+
+/**
+ * Build server configuration context
+ */
+function buildServerContext(answers) {
+  return {
+    serverPort: answers.serverPort || defaults.server.port,
+    contextPath: answers.contextPath || defaults.server.contextPath
+  };
+}
+
+/**
+ * Build context for module generation
+ */
+function buildModuleContext(baseContext, moduleName, moduleOptions = {}) {
+  const className = toPascalCase(moduleName);
+  const tableName = toSnakeCase(pluralizeWord(moduleName));
+  const moduleNamePlural = pluralizeWord(moduleName);
+  
+  const hasSoftDelete = moduleOptions.hasSoftDelete ?? defaults.module.hasSoftDelete;
+  const hasAudit = moduleOptions.hasAudit ?? defaults.module.hasAudit;
+  const baseEntityClass = getBaseEntity(hasSoftDelete, hasAudit);
+  
+  return {
+    ...baseContext,
+    moduleName,
+    moduleNamePlural,
+    className,
+    tableName,
+    hasSoftDelete,
+    hasAudit,
+    baseEntityClass,
+    generateTests: moduleOptions.generateTests ?? defaults.module.generateTests
+  };
+}
+
+module.exports = {
+  buildBaseContext,
+  buildModuleContext
+};

package/src/utils/naming.js

@@ -0,0 +1,137 @@
+const pluralize = require('pluralize');
+
+/**
+ * Convert string to PascalCase
+ * @param {string} str - Input string
+ * @returns {string} PascalCase string
+ */
+function toPascalCase(str) {
+  return str
+    .replace(/[-_\s]+(.)?/g, (_, char) => (char ? char.toUpperCase() : ''))
+    .replace(/^(.)/, (char) => char.toUpperCase());
+}
+
+/**
+ * Convert string to camelCase
+ * @param {string} str - Input string
+ * @returns {string} camelCase string
+ */
+function toCamelCase(str) {
+  const pascal = toPascalCase(str);
+  return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+}
+
+/**
+ * Convert string to snake_case
+ * @param {string} str - Input string
+ * @returns {string} snake_case string
+ */
+function toSnakeCase(str) {
+  return str
+    .replace(/([A-Z])/g, '_$1')
+    .replace(/[-\s]+/g, '_')
+    .replace(/^_/, '')
+    .toLowerCase();
+}
+
+/**
+ * Convert string to kebab-case
+ * @param {string} str - Input string
+ * @returns {string} kebab-case string
+ */
+function toKebabCase(str) {
+  return str
+    .replace(/([A-Z])/g, '-$1')
+    .replace(/[\s_]+/g, '-')
+    .replace(/^-/, '')
+    .toLowerCase();
+}
+
+/**
+ * Pluralize a word
+ * @param {string} word - Word to pluralize
+ * @returns {string} Pluralized word
+ */
+function pluralizeWord(word) {
+  return pluralize(word);
+}
+
+/**
+ * Convert package name to path
+ * @param {string} packageName - Package name (e.g., com.company.project)
+ * @returns {string} Package path (e.g., com/company/project)
+ */
+function toPackagePath(packageName) {
+  return packageName.replace(/\./g, '/');
+}
+
+/**
+ * Get base entity class based on flags
+ * @param {boolean} hasSoftDelete - Whether to use soft delete
+ * @param {boolean} hasAudit - Whether to use audit fields
+ * @returns {string} Base entity class name
+ */
+function getBaseEntity(hasSoftDelete, hasAudit) {
+  if (hasSoftDelete) {
+    return 'SoftDeletableEntity';
+  }
+  if (hasAudit) {
+    return 'AuditableEntity';
+  }
+  return 'BaseEntity';
+}
+
+/**
+ * Convert artifact ID to valid Java package name
+ * @param {string} artifactId - Artifact ID (e.g., my-project)
+ * @returns {string} Valid package name (e.g., myproject)
+ */
+function artifactIdToPackageName(artifactId) {
+  return artifactId
+    .toLowerCase()
+    .replace(/[^a-z0-9]/g, '');
+}
+
+/**
+ * Generate application class name from artifact ID
+ * @param {string} artifactId - Artifact ID (e.g., my-project)
+ * @returns {string} Application class name (e.g., MyProjectApplication)
+ */
+function getApplicationClassName(artifactId) {
+  return toPascalCase(artifactId) + 'Application';
+}
+
+/**
+ * Get full package name
+ * @param {string} groupId - Group ID (e.g., com.company)
+ * @param {string} artifactId - Artifact ID (e.g., my-project)
+ * @returns {string} Full package name (e.g., com.company.myproject)
+ */
+function getFullPackageName(groupId, artifactId) {
+  const packagePart = artifactIdToPackageName(artifactId);
+  return `${groupId}.${packagePart}`;
+}
+
+/**
+ * Check if a use case name represents an "all" type query that returns a list
+ * @param {string} usecaseName - Use case name (e.g., FindAllUsers, GetAllProducts)
+ * @returns {boolean} True if the use case returns a list
+ */
+function isAllTypeQuery(usecaseName) {
+  const allPatterns = ['FindAll', 'GetAll', 'ListAll', 'SearchAll', 'RetrieveAll'];
+  return allPatterns.some(pattern => usecaseName.startsWith(pattern));
+}
+
+module.exports = {
+  toPascalCase,
+  toCamelCase,
+  toSnakeCase,
+  toKebabCase,
+  pluralizeWord,
+  toPackagePath,
+  getBaseEntity,
+  artifactIdToPackageName,
+  getApplicationClassName,
+  getFullPackageName,
+  isAllTypeQuery
+};

package/src/utils/template-engine.js

@@ -0,0 +1,55 @@
+const ejs = require('ejs');
+const fs = require('fs-extra');
+const path = require('path');
+
+/**
+ * Render a template file with given context
+ * @param {string} templatePath - Path to template file
+ * @param {object} context - Template variables
+ * @returns {Promise<string>} Rendered template
+ */
+async function renderTemplate(templatePath, context) {
+  const templateContent = await fs.readFile(templatePath, 'utf-8');
+  return ejs.render(templateContent, context);
+}
+
+/**
+ * Render and write template to destination
+ * @param {string} templatePath - Path to template file
+ * @param {string} destPath - Destination file path
+ * @param {object} context - Template variables
+ */
+async function renderAndWrite(templatePath, destPath, context) {
+  const content = await renderTemplate(templatePath, context);
+  await fs.ensureDir(path.dirname(destPath));
+  await fs.writeFile(destPath, content, 'utf-8');
+}
+
+/**
+ * Get template file paths recursively
+ * @param {string} dir - Directory to scan
+ * @param {Array<string>} fileList - Accumulated file list
+ * @returns {Promise<Array<string>>} List of template file paths
+ */
+async function getTemplateFiles(dir, fileList = []) {
+  const files = await fs.readdir(dir);
+  
+  for (const file of files) {
+    const filePath = path.join(dir, file);
+    const stat = await fs.stat(filePath);
+    
+    if (stat.isDirectory()) {
+      await getTemplateFiles(filePath, fileList);
+    } else if (file.endsWith('.ejs')) {
+      fileList.push(filePath);
+    }
+  }
+  
+  return fileList;
+}
+
+module.exports = {
+  renderTemplate,
+  renderAndWrite,
+  getTemplateFiles
+};

package/src/utils/validator.js

@@ -0,0 +1,159 @@
+const fs = require('fs-extra');
+const path = require('path');
+
+/**
+ * Validate project name
+ * @param {string} name - Project name
+ * @returns {boolean|string} True if valid, error message otherwise
+ */
+function validateProjectName(name) {
+  if (!name || name.trim() === '') {
+    return 'Project name cannot be empty';
+  }
+  
+  if (!/^[a-z0-9-]+$/.test(name)) {
+    return 'Project name must contain only lowercase letters, numbers, and hyphens';
+  }
+  
+  if (name.startsWith('-') || name.endsWith('-')) {
+    return 'Project name cannot start or end with a hyphen';
+  }
+  
+  if (name.length < 2) {
+    return 'Project name must be at least 2 characters long';
+  }
+  
+  return true;
+}
+
+/**
+ * Validate group ID (Java package naming convention)
+ * @param {string} groupId - Group ID
+ * @returns {boolean|string} True if valid, error message otherwise
+ */
+function validateGroupId(groupId) {
+  if (!groupId || groupId.trim() === '') {
+    return 'Group ID cannot be empty';
+  }
+  
+  const parts = groupId.split('.');
+  
+  if (parts.length < 2) {
+    return 'Group ID must have at least 2 parts (e.g., com.company)';
+  }
+  
+  for (const part of parts) {
+    if (!/^[a-z][a-z0-9]*$/.test(part)) {
+      return 'Each part of Group ID must start with a lowercase letter and contain only lowercase letters and numbers';
+    }
+  }
+  
+  return true;
+}
+
+/**
+ * Validate module name
+ * @param {string} name - Module name
+ * @returns {boolean|string} True if valid, error message otherwise
+ */
+function validateModuleName(name) {
+  if (!name || name.trim() === '') {
+    return 'Module name cannot be empty';
+  }
+  
+  if (!/^[a-z][a-z0-9]*$/.test(name)) {
+    return 'Module name must start with a lowercase letter and contain only lowercase letters and numbers';
+  }
+  
+  if (name.length < 2) {
+    return 'Module name must be at least 2 characters long';
+  }
+  
+  // Reserved names
+  const reserved = ['common', 'shared', 'config', 'util', 'test'];
+  if (reserved.includes(name)) {
+    return `Module name '${name}' is reserved and cannot be used`;
+  }
+  
+  return true;
+}
+
+/**
+ * Check if current directory is a valid eva4j project
+ * @param {string} dir - Directory path
+ * @returns {boolean} True if valid project
+ */
+async function isEva4jProject(dir) {
+  const buildGradlePath = path.join(dir, 'build.gradle');
+  
+  if (!await fs.pathExists(buildGradlePath)) {
+    return false;
+  }
+  
+  // Check if build.gradle contains Spring Boot plugin
+  const content = await fs.readFile(buildGradlePath, 'utf-8');
+  return content.includes('org.springframework.boot');
+}
+
+/**
+ * Check if module already exists
+ * @param {string} projectDir - Project directory
+ * @param {string} packagePath - Package path
+ * @param {string} moduleName - Module name
+ * @returns {boolean} True if module exists
+ */
+async function moduleExists(projectDir, packagePath, moduleName) {
+  const modulePath = path.join(projectDir, 'src', 'main', 'java', packagePath, moduleName);
+  return await fs.pathExists(modulePath);
+}
+
+/**
+ * Check if shared module exists
+ * @param {string} projectDir - Project directory
+ * @param {string} packagePath - Package path
+ * @returns {boolean} True if shared module exists
+ */
+async function sharedModuleExists(projectDir, packagePath) {
+  const sharedPath = path.join(projectDir, 'src', 'main', 'java', packagePath, 'shared');
+  return await fs.pathExists(sharedPath);
+}
+
+/**
+ * Validate Java version
+ * @param {number} version - Java version
+ * @returns {boolean} True if valid
+ */
+function validateJavaVersion(version) {
+  const validVersions = [21, 22, 23];
+  return validVersions.includes(version);
+}
+
+/**
+ * Validate port number
+ * @param {number} port - Port number
+ * @returns {boolean|string} True if valid, error message otherwise
+ */
+function validatePort(port) {
+  const portNum = parseInt(port, 10);
+  
+  if (isNaN(portNum)) {
+    return 'Port must be a number';
+  }
+  
+  if (portNum < 1024 || portNum > 65535) {
+    return 'Port must be between 1024 and 65535';
+  }
+  
+  return true;
+}
+
+module.exports = {
+  validateProjectName,
+  validateGroupId,
+  validateModuleName,
+  isEva4jProject,
+  moduleExists,
+  sharedModuleExists,
+  validateJavaVersion,
+  validatePort
+};

package/templates/base/application/Application.java.ejs

@@ -0,0 +1,27 @@
+package <%= packageName %>;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.cloud.openfeign.EnableFeignClients;
+import org.springframework.data.jpa.repository.config.EnableJpaAuditing;
+<% if (features.enableScheduling) { %>import org.springframework.scheduling.annotation.EnableScheduling;
+<% } %><% if (features.enableAsync) { %>import org.springframework.scheduling.annotation.EnableAsync;
+<% } %>
+/**
+ * Main application class for <%= projectName %>
+ * 
+ * @author <%= author %>
+ * @version <%= version %>
+ * @since <%= createdDate %>
+ */
+@SpringBootApplication
+@EnableFeignClients
+@EnableJpaAuditing
+<% if (features.enableScheduling) { %>@EnableScheduling
+<% } %><% if (features.enableAsync) { %>@EnableAsync
+<% } %>public class <%= applicationClassName %> {
+
+    public static void main(String[] args) {
+        SpringApplication.run(<%= applicationClassName %>.class, args);
+    }
+}