spring-feature-cli 0.2.1

package/README.md

@@ -0,0 +1,68 @@
+# spring-feature-cli
+
+`spring-feature-cli` is a personal project to learn how to build command-line tools with Node.js. It is designed to generate basic Spring Boot artifacts using a feature-based structure and clean architecture principles.
+
+## Purpose
+
+- Learn Node.js and the CLI ecosystem
+- Practice using `commander`, `inquirer`, and `handlebars`
+- Automate repetitive code generation for Spring Boot projects
+- Generate entities, services, repositories, and controllers with a simple workflow
+
+## Features
+
+- Executable CLI via the `spfc` command
+- Template generation using `handlebars`
+- Input validation and project detection
+- Supports generating:
+  - `Entity`
+  - `Repository`
+  - `Service`
+  - `Controller`
+
+## Installation
+
+```bash
+npm install
+```
+
+To install globally (optional):
+
+```bash
+npm install -g .
+```
+
+## Usage
+
+Run the tool from the project directory:
+
+```bash
+spfc generate
+```
+
+Or in development mode:
+
+```bash
+npm run dev
+```
+
+## Project Structure
+
+- `bin/index.js`: executable CLI entry point
+- `src/index.js`: main CLI logic
+- `src/commands/generate.js`: generate command
+- `src/actions/generateActions.js`: file creation actions
+- `src/validations/generateValidations.js`: input validations
+- `src/utils/`: utilities for Java package resolution, project scanning, and template compilation
+- `src/templates/`: Handlebars templates for generated artifacts
+
+## Key Dependencies
+
+- `commander` for defining CLI commands
+- `inquirer` for interactive prompts
+- `handlebars` for template generation
+- `chalk` for console styling
+
+## License
+
+This project is licensed under `MIT`.

package/bin/index.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+import "../src/index.js";

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "spring-feature-cli",
+  "version": "0.2.1",
+  "description": "CLI para generar features de Spring Boot",
+  "type": "module",
+  "bin": {
+    "spfc": "bin/index.js"
+  },
+  "files": [
+    "src",
+    "bin"
+  ],
+  "scripts": {
+    "dev": "node src/index.js"
+  },
+  "keywords": [
+    "spring",
+    "spring-boot",
+    "cli",
+    "generator"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "chalk": "^5.4.1",
+    "commander": "^13.1.0",
+    "handlebars": "^4.7.9",
+    "inquirer": "^12.1.0"
+  }
+}

package/src/actions/generateActions.js

@@ -0,0 +1,61 @@
+import { runValidations } from '../utils/runValidations.js';
+import { getMainClassDirectory, getRootPackage } from '../utils/javaPackageResolver.js'
+import { logger } from '../utils/logger.js';
+import { renderTemplate } from '../utils/templateCompiler.js'
+import fs from 'fs';
+import path from 'path';
+import validations from '../validations/generateValidations.js';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+export function generateFeature(featureName) {
+    const javaPath = getMainClassDirectory();
+    const packageName = getRootPackage();
+
+    const input_context = { featureName, javaPath, packageName };
+
+    runValidations(validations, featureName);
+
+    generateFeatureStructure(input_context)
+    logger.success(`\n` + 'Feature created successfully');
+}
+
+function generateFeatureStructure({ featureName, javaPath, packageName }) {
+    const templatesBasePath = path.join(__dirname, '..', 'templates');
+    const template_context = { featureName, packageName };
+    const structure = {
+        domain: {
+            featureName: `${featureName}.java`,
+            templatePath: path.join(templatesBasePath, 'domain', 'Entity.hbs')
+        },
+        service: {
+            featureName: `${featureName}Service.java`,
+            templatePath: path.join(templatesBasePath, 'service', 'Service.hbs')
+
+
+        },
+        controller: {
+            featureName: `${featureName}Controller.java`,
+            templatePath: path.join(templatesBasePath, 'controller', 'Controller.hbs')
+
+
+        },
+        repository: {
+            featureName: `${featureName}Repository.java`,
+            templatePath: path.join(templatesBasePath, 'repository', 'Repository.hbs')
+
+        }
+    };
+
+    for (const [folder, file] of Object.entries(structure)) {
+        const folderPath = path.join(javaPath, featureName, folder);
+
+        logger.info(`Creating ${folder}...`);
+        fs.mkdirSync(folderPath, { recursive: true });
+
+        const content = renderTemplate(file.templatePath, template_context);
+        fs.writeFileSync(path.join(folderPath, file.featureName), content);
+    }
+}

package/src/commands/generate.js

@@ -0,0 +1,21 @@
+import { Command } from 'commander';
+import { generateFeature } from '../actions/generateActions.js';
+import { logger } from '../utils/logger.js';
+
+const generate = new Command('generate');
+
+generate
+    .description('Create a new feature (entity, service, controller)')
+    .alias('g')
+    .argument('<featureName>')
+    .action((featureName) => {
+        try {
+            const name = featureName?.trim();
+            generateFeature(name);
+        } catch (error) {
+            logger.error(error.message);
+            process.exit(1);
+        }
+    });
+
+export default generate;

package/src/index.js

@@ -0,0 +1,14 @@
+
+import { Command } from 'commander';
+import generateCommand from './commands/generate.js';
+
+const program = new Command();
+
+program
+    .name('spring-feature-cli')
+    .description('CLI tool to generate feature-based structure for Spring Boot applications, including entities, services and controllers, following clean architecture principles.')
+    .version('0.2.0');
+
+program.addCommand(generateCommand);
+
+program.parse();

package/src/templates/controller/Controller.hbs

@@ -0,0 +1,10 @@
+package {{packageName}}.{{featureName}}.controller;
+
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.bind.annotation.RequestMapping;
+
+@RestController
+@RequestMapping("/api/{{featureName}}")
+public class {{featureName}}Controller{
+
+}

package/src/templates/domain/Entity.hbs

@@ -0,0 +1,26 @@
+package {{packageName}}.{{featureName}}.domain;
+
+import jakarta.persistence.Entity;
+import jakarta.persistence.Id;
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.GenerationType;
+
+
+@Entity
+public class {{featureName}} {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+    
+    public {{featureName}}() {
+    }
+
+     public Long getId() {
+        return id;
+    }
+
+    public void setId(Long id) {
+        this.id = id;
+    }
+}

package/src/templates/repository/Repository.hbs

@@ -0,0 +1,8 @@
+package {{packageName}}.{{featureName}}.repository;
+
+import org.springframework.data.jpa.repository.JpaRepository;
+import {{packageName}}.{{featureName}}.domain.{{featureName}};
+
+public interface {{featureName}}Repository extends JpaRepository<{{featureName}}, Long> {
+
+}

package/src/templates/service/Service.hbs

@@ -0,0 +1,8 @@
+package {{packageName}}.{{featureName}}.service;
+
+import org.springframework.stereotype.Service;
+
+@Service
+public class {{featureName}}Service {
+    
+}

package/src/utils/javaPackageResolver.js

@@ -0,0 +1,18 @@
+import { getMainClassFile } from '../utils/projectScanner.js';
+import fs from 'fs';
+import path from 'path';
+
+export function getMainClassDirectory() {
+    return path.dirname(getMainClassFile());
+}
+
+export function getRootPackage() {
+    const file = getMainClassFile();
+    const content = fs.readFileSync(file, 'utf-8');
+
+    const packageLine = content.split('\n').find(line => line.trim().startsWith('package'));
+
+    if (!packageLine) throw new Error("Root Package not found");
+
+    return packageLine.replace('package', '').replace(';', '').trim();
+}

package/src/utils/logger.js

@@ -0,0 +1,8 @@
+import chalk from 'chalk';
+
+export const logger = {
+    success: (msg) => console.log(`\n` + chalk.green(`${msg}`)),
+    error: (msg) => console.error(`\n` + chalk.red(`${msg}`)),
+    info: (msg) => console.log(chalk.cyan(`${msg}`)),
+    warn: (msg) => console.log(chalk.yellow(`${msg}`)),
+};

package/src/utils/projectScanner.js

@@ -0,0 +1,55 @@
+import fs from 'fs';
+import path from 'path';
+
+export function getMainClassFile() {
+    const rootPath = findProjectRoot();
+    let current = path.join(rootPath, 'src', 'main', 'java');
+
+    const FilePath = searchInDirectory(current);
+    if(!FilePath) throw new Error('@SpringBootApplication not found');
+    return FilePath;
+
+}
+
+function searchInDirectory(DirectoryPath) {
+    const files = fs.readdirSync(DirectoryPath);
+
+    for (const file of files) {
+        const filePath = path.join(DirectoryPath, file)
+        const stats = fs.statSync(filePath);
+
+        if (stats.isFile() && file.endsWith(".java")) {
+            const content = fs.readFileSync(filePath, 'utf-8');
+
+            if (content.includes('@SpringBootApplication')) {
+                return filePath;
+            }
+        } else if (stats.isDirectory()) {
+            const result = searchInDirectory(filePath);
+            if (result) return result;
+
+        }
+    }
+    return null;
+}
+
+function findProjectRoot(start = process.cwd()) {
+    let current = start;
+
+    while (current !== path.dirname(current)) {
+        if (isSpringProject(current)) return current;
+        current = path.dirname(current);
+    }
+    throw new Error('Project Home not found');
+}
+
+
+function isSpringProject(projectPath) {
+    const pomPath = path.join(projectPath, 'pom.xml');
+
+    if (!fs.existsSync(pomPath)) return false;
+
+    const pomContent = fs.readFileSync(pomPath, 'utf-8');
+    return pomContent.includes('spring-boot-starter');
+
+}

package/src/utils/runValidations.js

@@ -0,0 +1,5 @@
+export const runValidations = (validations, value) => {
+    for (const validation of validations) {
+        validation(value);
+    }
+};

package/src/utils/templateCompiler.js

@@ -0,0 +1,9 @@
+import fs from 'fs';
+import Handlebars from 'handlebars';
+
+export function renderTemplate(templatePath,context){
+const templateSource = fs.readFileSync(templatePath, 'utf-8');
+const template = Handlebars.compile(templateSource);
+
+return template(context);
+}

package/src/validations/generateValidations.js

@@ -0,0 +1,30 @@
+import fs from 'fs';
+import path from 'path';
+import { getMainClassDirectory } from '../utils/javaPackageResolver.js'
+
+const NotNullName = (name) => {
+    if (!name) throw new Error('Feature name is required');
+};
+
+const minLengthName = (name) => {
+    if (name.length < 3) throw new Error('Feature name must be at least 3 characters');
+};
+
+const alphabeticalName = (name) => {
+    if (!name.match(/^[a-zA-Z]+$/)) throw new Error('Feature name must be alphabetical');
+};
+
+const featureExists = (name) => {
+    const featurePath = path.join(getMainClassDirectory(), name);
+
+    if (fs.existsSync(featurePath)) throw new Error('Feature already exists');
+};
+
+const validations = [
+    NotNullName,
+    minLengthName,
+    alphabeticalName,
+    featureExists
+];
+
+export default validations;