kybernus 1.0.0

package/templates/java-spring/pro/clean/src/main/java/{{packagePath}}/domain/usecase/RegisterUserUseCase.java.hbs

@@ -0,0 +1,46 @@
+package {{packageName}}.domain.usecase;
+
+import {{packageName}}.domain.entity.User;
+import {{packageName}}.domain.repository.UserRepository;
+
+/**
+* Register User Use Case - Domain Layer
+*/
+public class RegisterUserUseCase {
+    private final UserRepository userRepository;
+    private final PasswordEncoder passwordEncoder;
+    private final TokenGenerator tokenGenerator;
+
+    public RegisterUserUseCase(UserRepository userRepository, PasswordEncoder passwordEncoder, TokenGenerator
+    tokenGenerator) {
+        this.userRepository = userRepository;
+        this.passwordEncoder = passwordEncoder;
+        this.tokenGenerator = tokenGenerator;
+    }
+
+    public record Input(String email, String name, String password) {}
+    public record Output(User user, String token) {}
+
+    public Output execute(Input input) {
+        userRepository.findByEmail(input.email()).ifPresent(u -> {
+            throw new IllegalStateException("User already exists");
+        });
+
+        String hashedPassword = passwordEncoder.encode(input.password());
+        User user = User.create(input.email(), input.name(), hashedPassword);
+        User savedUser = userRepository.save(user);
+        String token = tokenGenerator.generate(savedUser.getId(), savedUser.getEmail());
+
+        return new Output(savedUser, token);
+    }
+
+    // Port interfaces
+    public interface PasswordEncoder {
+        String encode(String rawPassword);
+        boolean matches(String rawPassword, String encodedPassword);
+    }
+
+    public interface TokenGenerator {
+        String generate(String userId, String email);
+    }
+}

package/templates/java-spring/pro/clean/src/main/java/{{packagePath}}/infrastructure/persistence/InMemoryUserRepository.java.hbs

@@ -0,0 +1,41 @@
+package {{packageName}}.infrastructure.persistence;
+
+import {{packageName}}.domain.entity.User;
+import {{packageName}}.domain.repository.UserRepository;
+import org.springframework.stereotype.Repository;
+
+import java.util.Map;
+import java.util.Optional;
+import java.util.concurrent.ConcurrentHashMap;
+
+/**
+* In-Memory User Repository - Infrastructure Layer
+* Replace with JPA implementation for production
+*/
+@Repository
+public class InMemoryUserRepository implements UserRepository {
+    private final Map<String, User> users = new ConcurrentHashMap<>();
+
+    @Override
+    public Optional<User> findById(String id) {
+        return Optional.ofNullable(users.get(id));
+    }
+
+    @Override
+    public Optional<User> findByEmail(String email) {
+        return users.values().stream()
+        .filter(user -> user.getEmail().equals(email))
+        .findFirst();
+    }
+
+    @Override
+    public User save(User user) {
+        users.put(user.getId(), user);
+        return user;
+    }
+
+    @Override
+    public void delete(String id) {
+        users.remove(id);
+    }
+}

package/templates/java-spring/pro/clean/src/main/java/{{packagePath}}/infrastructure/security/SecurityAdapters.java.hbs

@@ -0,0 +1,53 @@
+package {{packageName}}.infrastructure.security;
+
+import {{packageName}}.domain.usecase.RegisterUserUseCase;
+import io.jsonwebtoken.Jwts;
+import io.jsonwebtoken.security.Keys;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
+import org.springframework.stereotype.Component;
+
+import javax.crypto.SecretKey;
+import java.nio.charset.StandardCharsets;
+import java.util.Date;
+
+/**
+* Security Adapters - Infrastructure Layer
+* Implements domain port interfaces
+*/
+@Component
+public class SecurityAdapters implements RegisterUserUseCase.PasswordEncoder, RegisterUserUseCase.TokenGenerator {
+
+    private final BCryptPasswordEncoder encoder = new BCryptPasswordEncoder();
+
+    @Value("${jwt.secret:your-super-secret-jwt-key-change-in-production}")
+    private String jwtSecret;
+
+    @Value("${jwt.expiration:604800000}")
+    private long jwtExpiration;
+
+    private SecretKey getSigningKey() {
+        return Keys.hmacShaKeyFor(jwtSecret.getBytes(StandardCharsets.UTF_8));
+    }
+
+    @Override
+    public String encode(String rawPassword) {
+        return encoder.encode(rawPassword);
+    }
+
+    @Override
+    public boolean matches(String rawPassword, String encodedPassword) {
+        return encoder.matches(rawPassword, encodedPassword);
+    }
+
+    @Override
+    public String generate(String userId, String email) {
+        return Jwts.builder()
+        .subject(userId)
+        .claim("email", email)
+        .issuedAt(new Date())
+        .expiration(new Date(System.currentTimeMillis() + jwtExpiration))
+        .signWith(getSigningKey())
+        .compact();
+    }
+}

package/templates/java-spring/pro/clean/src/main/java/{{packagePath}}/infrastructure/web/controller/AuthController.java.hbs

@@ -0,0 +1,41 @@
+package {{packageName}}.infrastructure.web.controller;
+
+import {{packageName}}.application.service.AuthService;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.Map;
+
+@RestController
+@RequestMapping("/api/auth")
+public class AuthController {
+
+    private final AuthService authService;
+
+    public AuthController(AuthService authService) {
+        this.authService = authService;
+    }
+
+    public record AuthRequest(String email, String name, String password) {}
+
+    @PostMapping("/register")
+    public ResponseEntity
+    <?> register(@RequestBody AuthRequest request) {
+        try {
+            var result = authService.register(request.email(), request.name(), request.password());
+            return ResponseEntity.ok(result);
+        } catch (Exception e) {
+            return ResponseEntity.badRequest().body(Map.of("error", e.getMessage()));
+        }
+    }
+
+    @PostMapping("/login")
+    public ResponseEntity<?> login(@RequestBody AuthRequest request) {
+        try {
+            var result = authService.login(request.email(), request.password());
+            return ResponseEntity.ok(result);
+        } catch (Exception e) {
+            return ResponseEntity.status(401).body(Map.of("error", e.getMessage()));
+        }
+    }
+}

package/templates/java-spring/pro/clean/src/main/java/{{packagePath}}/{{projectNamePascalCase}}Application.java.hbs

@@ -0,0 +1,14 @@
+package {{packageName}};
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+
+@SpringBootApplication
+public class {{projectNamePascalCase}}Application {
+
+    public static void main(String[] args) {
+        SpringApplication.run({{projectNamePascalCase}}Application.class, args);
+        System.out.println("🚀 {{projectNamePascalCase}} running!");
+        System.out.println("📐 Architecture: Clean Architecture");
+    }
+}

package/templates/java-spring/pro/hexagonal/.github/workflows/ci-cd.yml.hbs

@@ -0,0 +1,88 @@
+name: CI/CD Pipeline
+
+on:
+  push:
+    branches: [main, develop]
+    pull_request:
+      branches: [main]
+
+      env:
+        NODE_VERSION: '20'
+        AWS_REGION: 'us-east-1'
+
+        jobs:
+          test:
+            runs-on: ubuntu-latest
+
+            steps:
+              - uses: actions/checkout@v4
+
+              - name: Setup Node.js
+              uses: actions/setup-node@v4
+              with:
+                node-version: $\{{ env.NODE_VERSION }}
+                cache: 'npm'
+
+                - name: Install dependencies
+                run: npm ci
+
+                - name: Run linter
+                run: npm run lint --if-present
+
+                - name: Run tests
+                run: npm test --if-present
+
+                - name: Build
+                run: npm run build
+
+                build-and-push:
+                  needs: test
+                  runs-on: ubuntu-latest
+                  if: github.ref == 'refs/heads/main'
+
+                  steps:
+                    - uses: actions/checkout@v4
+
+                    - name: Configure AWS credentials
+                    uses: aws-actions/configure-aws-credentials@v4
+                    with:
+                      aws-access-key-id: $\{{ secrets.AWS_ACCESS_KEY_ID }}
+                      aws-secret-access-key: $\{{ secrets.AWS_SECRET_ACCESS_KEY }}
+                      aws-region: $\{{ env.AWS_REGION }}
+
+                      - name: Login to Amazon ECR
+                      id: login-ecr
+                      uses: aws-actions/amazon-ecr-login@v2
+
+                      - name: Build, tag, and push image to Amazon ECR
+                      env:
+                        ECR_REGISTRY: $\{{ steps.login-ecr.outputs.registry }}
+                        ECR_REPOSITORY: {{projectNameKebabCase}}
+                        IMAGE_TAG: $\{{ github.sha }}
+                        run: |
+                        docker build -t $ECR_REGISTRY/$ECR_REPOSITORY:$IMAGE_TAG .
+                        docker build -t $ECR_REGISTRY/$ECR_REPOSITORY:latest .
+                        docker push $ECR_REGISTRY/$ECR_REPOSITORY:$IMAGE_TAG
+                        docker push $ECR_REGISTRY/$ECR_REPOSITORY:latest
+
+                        deploy:
+                          needs: build-and-push
+                          runs-on: ubuntu-latest
+                          if: github.ref == 'refs/heads/main'
+
+                          steps:
+                            - uses: actions/checkout@v4
+
+                            - name: Configure AWS credentials
+                            uses: aws-actions/configure-aws-credentials@v4
+                            with:
+                              aws-access-key-id: $\{{ secrets.AWS_ACCESS_KEY_ID }}
+                              aws-secret-access-key: $\{{ secrets.AWS_SECRET_ACCESS_KEY }}
+                              aws-region: $\{{ env.AWS_REGION }}
+
+                              - name: Deploy to ECS
+                              run: |
+                              aws ecs update-service \
+                              --cluster {{projectNameKebabCase}}-prod \
+                              --service {{projectNameKebabCase}}-api \
+                              --force-new-deployment

package/templates/java-spring/pro/hexagonal/Dockerfile.hbs

@@ -0,0 +1,45 @@
+# Production Dockerfile for {{projectName}}
+
+# Build stage
+FROM node:20-alpine AS builder
+
+WORKDIR /app
+
+# Copy package files
+COPY package*.json ./
+
+# Install dependencies
+RUN npm ci --only=production
+
+# Copy source code
+COPY . .
+
+# Build TypeScript
+RUN npm run build
+
+# Production stage
+FROM node:20-alpine AS production
+
+WORKDIR /app
+
+# Create non-root user
+RUN addgroup -g 1001 -S nodejs && \
+    adduser -S nodejs -u 1001
+
+# Copy built application
+COPY --from=builder --chown=nodejs:nodejs /app/dist ./dist
+COPY --from=builder --chown=nodejs:nodejs /app/node_modules ./node_modules
+COPY --from=builder --chown=nodejs:nodejs /app/package.json ./
+
+# Switch to non-root user
+USER nodejs
+
+# Expose port
+EXPOSE 3000
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
+  CMD wget --no-verbose --tries=1 --spider http://localhost:3000/health || exit 1
+
+# Start application
+CMD ["node", "dist/index.js"]

package/templates/java-spring/pro/hexagonal/README.md.hbs

@@ -0,0 +1,38 @@
+# {{projectName}}
+
+> Generated by [Kybernus CLI](https://kybernus.dev) 🚀 (Pro - Hexagonal Architecture)
+
+## Architecture
+
+This project follows **Hexagonal Architecture** (Ports & Adapters):
+
+```
+src/main/java/{{packagePath}}/
+├── domain/ # The Hexagon Core
+│ ├── entity/ # Business entities
+│ ├── repository/ # Outbound port (repository interface)
+│ └── usecase/ # Inbound ports (use case interfaces + impl)
+├── application/ # Application services
+│ └── service/ # Use case orchestration
+└── infrastructure/ # Adapters (outside the hexagon)
+├── persistence/ # Outbound adapter (database)
+├── security/ # Outbound adapter (security)
+└── web/ # Inbound adapter (HTTP)
+```
+
+## Key Concepts
+
+- **Inbound Ports**: What the application CAN DO (use cases)
+- **Outbound Ports**: What the application NEEDS (repositories, external services)
+- **Inbound Adapters**: Controllers, CLI, etc.
+- **Outbound Adapters**: Database, messaging, external APIs
+
+## Quick Start
+
+```bash
+./mvnw spring-boot:run
+```
+
+---
+
+Made with ❤️ using [Kybernus Pro](https://kybernus.dev/pro)

package/templates/java-spring/pro/hexagonal/docker-compose.yml.hbs

@@ -0,0 +1,18 @@
+version: '3.8'
+
+services:
+  postgres:
+    image: postgres:15-alpine
+    container_name: {{projectNameKebabCase}}-db
+    environment:
+      POSTGRES_USER: postgres
+      POSTGRES_PASSWORD: postgres
+      POSTGRES_DB: {{projectNameSnakeCase}}
+      ports:
+        - "5432:5432"
+        volumes:
+          - postgres_data:/var/lib/postgresql/data
+          restart: unless-stopped
+
+          volumes:
+            postgres_data:

package/templates/java-spring/pro/hexagonal/infra/main.tf.hbs

@@ -0,0 +1,83 @@
+# Terraform Infrastructure for {{projectName}}
+
+terraform {
+  required_version = ">= 1.0.0"
+
+  required_providers {
+    aws = {
+      source = "hashicorp/aws"
+      version = "~> 5.0"
+    }
+  }
+
+# Uncomment for remote state (recommended for production)
+# backend "s3" {
+# bucket = "your-terraform-state-bucket"
+# key = "{{projectNameKebabCase}}/terraform.tfstate"
+# region = "us-east-1"
+# encrypt = true
+# dynamodb_table = "terraform-locks"
+# }
+}
+
+provider "aws" {
+  region = var.aws_region
+}
+
+# Variables
+variable "aws_region" {
+  description = "AWS region"
+  type = string
+  default = "us-east-1"
+}
+
+variable "environment" {
+  description = "Environment name (dev, staging, prod)"
+  type = string
+  default = "dev"
+}
+
+variable "app_name" {
+  description = "Application name"
+  type = string
+  default = "{{projectNameKebabCase}}"
+}
+
+# VPC
+module "vpc" {
+  source = "./modules/vpc"
+
+  app_name = var.app_name
+  environment = var.environment
+}
+
+# ECS Cluster
+module "ecs" {
+  source = "./modules/ecs"
+
+  app_name = var.app_name
+  environment = var.environment
+  vpc_id = module.vpc.vpc_id
+  subnet_ids = module.vpc.private_subnet_ids
+}
+
+# RDS PostgreSQL
+module "rds" {
+  source = "./modules/rds"
+
+  app_name = var.app_name
+  environment = var.environment
+  vpc_id = module.vpc.vpc_id
+  subnet_ids = module.vpc.private_subnet_ids
+  security_group_id = module.vpc.db_security_group_id
+}
+
+# Outputs
+output "ecs_cluster_name" {
+  value = module.ecs.cluster_name
+}
+
+output "rds_endpoint" {
+  value = module.rds.endpoint
+  sensitive = true
+}

package/templates/java-spring/pro/hexagonal/infra/modules/ecs/main.tf.hbs

@@ -0,0 +1,54 @@
+# ECS Module
+
+variable "app_name" {
+  type = string
+}
+
+variable "environment" {
+  type = string
+}
+
+variable "vpc_id" {
+  type = string
+}
+
+variable "subnet_ids" {
+  type = list(string)
+}
+
+# ECS Cluster
+resource "aws_ecs_cluster" "main" {
+  name = "${var.app_name}-${var.environment}"
+
+  setting {
+    name = "containerInsights"
+    value = "enabled"
+  }
+
+  tags = {
+    Name = "${var.app_name}-${var.environment}"
+    Environment = var.environment
+  }
+}
+
+# ECS Capacity Provider
+resource "aws_ecs_cluster_capacity_providers" "main" {
+  cluster_name = aws_ecs_cluster.main.name
+
+  capacity_providers = ["FARGATE", "FARGATE_SPOT"]
+
+  default_capacity_provider_strategy {
+    base = 1
+    weight = 100
+    capacity_provider = "FARGATE"
+  }
+}
+
+# Outputs
+output "cluster_name" {
+  value = aws_ecs_cluster.main.name
+}
+
+output "cluster_arn" {
+  value = aws_ecs_cluster.main.arn
+}

package/templates/java-spring/pro/hexagonal/infra/modules/rds/main.tf.hbs

@@ -0,0 +1,88 @@
+# RDS Module
+
+variable "app_name" {
+  type = string
+}
+
+variable "environment" {
+  type = string
+}
+
+variable "vpc_id" {
+  type = string
+}
+
+variable "subnet_ids" {
+  type = list(string)
+}
+
+variable "security_group_id" {
+  type = string
+}
+
+# DB Subnet Group
+resource "aws_db_subnet_group" "main" {
+  name = "${var.app_name}-${var.environment}"
+  subnet_ids = var.subnet_ids
+
+  tags = {
+    Name = "${var.app_name}-${var.environment}"
+    Environment = var.environment
+  }
+}
+
+# RDS PostgreSQL Instance
+resource "aws_db_instance" "main" {
+  identifier = "${var.app_name}-${var.environment}"
+
+  engine = "postgres"
+  engine_version = "16"
+  instance_class = "db.t3.micro"
+
+  allocated_storage = 20
+  max_allocated_storage = 100
+  storage_type = "gp3"
+  storage_encrypted = true
+
+  db_name = replace(var.app_name, "-", "_")
+  username = "postgres"
+  password = random_password.db_password.result
+
+  db_subnet_group_name = aws_db_subnet_group.main.name
+  vpc_security_group_ids = [var.security_group_id]
+
+  backup_retention_period = 7
+  skip_final_snapshot = var.environment != "prod"
+
+  tags = {
+    Name = "${var.app_name}-${var.environment}"
+    Environment = var.environment
+  }
+}
+
+# Random password for DB
+resource "random_password" "db_password" {
+  length = 32
+  special = false
+}
+
+# Store password in SSM
+resource "aws_ssm_parameter" "db_password" {
+  name = "/${var.app_name}/${var.environment}/db-password"
+  description = "Database password for ${var.app_name}"
+  type = "SecureString"
+  value = random_password.db_password.result
+
+  tags = {
+    Environment = var.environment
+  }
+}
+
+# Outputs
+output "endpoint" {
+  value = aws_db_instance.main.endpoint
+}
+
+output "db_name" {
+  value = aws_db_instance.main.db_name
+}