kybernus 1.0.1 → 1.1.0

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

@@ -1,54 +0,0 @@
-# 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/mvc/infra/modules/rds/main.tf.hbs

@@ -1,88 +0,0 @@
-# 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
-}

package/templates/java-spring/pro/mvc/infra/modules/vpc/main.tf.hbs

@@ -1,107 +0,0 @@
-# VPC Module
-
-variable "app_name" {
-  type = string
-}
-
-variable "environment" {
-  type = string
-}
-
-# VPC
-resource "aws_vpc" "main" {
-  cidr_block = "10.0.0.0/16"
-  enable_dns_hostnames = true
-  enable_dns_support = true
-
-  tags = {
-    Name = "${var.app_name}-${var.environment}-vpc"
-    Environment = var.environment
-  }
-}
-
-# Public Subnets
-resource "aws_subnet" "public" {
-  count = 2
-  vpc_id = aws_vpc.main.id
-  cidr_block = "10.0.${count.index + 1}.0/24"
-  availability_zone = data.aws_availability_zones.available.names[count.index]
-
-  map_public_ip_on_launch = true
-
-  tags = {
-    Name = "${var.app_name}-${var.environment}-public-${count.index + 1}"
-    Environment = var.environment
-  }
-}
-
-# Private Subnets
-resource "aws_subnet" "private" {
-  count = 2
-  vpc_id = aws_vpc.main.id
-  cidr_block = "10.0.${count.index + 10}.0/24"
-  availability_zone = data.aws_availability_zones.available.names[count.index]
-
-  tags = {
-    Name = "${var.app_name}-${var.environment}-private-${count.index + 1}"
-    Environment = var.environment
-  }
-}
-
-# Internet Gateway
-resource "aws_internet_gateway" "main" {
-  vpc_id = aws_vpc.main.id
-
-  tags = {
-    Name = "${var.app_name}-${var.environment}-igw"
-    Environment = var.environment
-  }
-}
-
-# Data source for AZs
-data "aws_availability_zones" "available" {
-  state = "available"
-}
-
-# Security Group for DB
-resource "aws_security_group" "db" {
-  name = "${var.app_name}-${var.environment}-db-sg"
-  description = "Security group for database"
-  vpc_id = aws_vpc.main.id
-
-  ingress {
-    from_port = 5432
-    to_port = 5432
-    protocol = "tcp"
-    cidr_blocks = ["10.0.0.0/16"]
-  }
-
-  egress {
-    from_port = 0
-    to_port = 0
-    protocol = "-1"
-    cidr_blocks = ["0.0.0.0/0"]
-  }
-
-  tags = {
-    Name = "${var.app_name}-${var.environment}-db-sg"
-    Environment = var.environment
-  }
-}
-
-# Outputs
-output "vpc_id" {
-  value = aws_vpc.main.id
-}
-
-output "public_subnet_ids" {
-  value = aws_subnet.public[*].id
-}
-
-output "private_subnet_ids" {
-  value = aws_subnet.private[*].id
-}
-
-output "db_security_group_id" {
-  value = aws_security_group.db.id
-}

package/templates/java-spring/pro/mvc/pom.xml.hbs

@@ -1,130 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
-         https://maven.apache.org/xsd/maven-4.0.0.xsd">
-    <modelVersion>4.0.0</modelVersion>
-
-    <parent>
-        <groupId>org.springframework.boot</groupId>
-        <artifactId>spring-boot-starter-parent</artifactId>
-        <version>3.4.1</version>
-        <relativePath />
-    </parent>
-
-    <groupId>{{packageName}}</groupId>
-    <artifactId>{{projectNameKebabCase}}</artifactId>
-    <version>0.0.1-SNAPSHOT</version>
-    <name>{{projectNamePascalCase}}</name>
-    <description>Generated by Kibernus CLI</description>
-
-    <properties>
-        <java.version>21</java.version>
-    </properties>
-
-    <dependencies>
-        <!-- Spring Boot Starters -->
-        <dependency>
-            <groupId>org.springframework.boot</groupId>
-            <artifactId>spring-boot-starter-web</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>org.springframework.boot</groupId>
-            <artifactId>spring-boot-starter-validation</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>org.springframework.boot</groupId>
-            <artifactId>spring-boot-starter-data-jpa</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>org.springframework.boot</groupId>
-            <artifactId>spring-boot-starter-security</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>org.springframework.boot</groupId>
-            <artifactId>spring-boot-starter-actuator</artifactId>
-        </dependency>
-
-        <!-- JWT -->
-        <dependency>
-            <groupId>io.jsonwebtoken</groupId>
-            <artifactId>jjwt-api</artifactId>
-            <version>0.12.5</version>
-        </dependency>
-        <dependency>
-            <groupId>io.jsonwebtoken</groupId>
-            <artifactId>jjwt-impl</artifactId>
-            <version>0.12.5</version>
-            <scope>runtime</scope>
-        </dependency>
-        <dependency>
-            <groupId>io.jsonwebtoken</groupId>
-            <artifactId>jjwt-jackson</artifactId>
-            <version>0.12.5</version>
-            <scope>runtime</scope>
-        </dependency>
-
-        <!-- Stripe -->
-        <dependency>
-            <groupId>com.stripe</groupId>
-            <artifactId>stripe-java</artifactId>
-            <version>24.19.0</version>
-        </dependency>
-
-        <!-- Database -->
-        <dependency>
-            <groupId>org.postgresql</groupId>
-            <artifactId>postgresql</artifactId>
-            <scope>runtime</scope>
-        </dependency>
-        <dependency>
-            <groupId>com.h2database</groupId>
-            <artifactId>h2</artifactId>
-            <scope>runtime</scope>
-        </dependency>
-
-        <!-- Lombok -->
-        <dependency>
-            <groupId>org.projectlombok</groupId>
-            <artifactId>lombok</artifactId>
-            <optional>true</optional>
-        </dependency>
-
-        <!-- DevTools -->
-        <dependency>
-            <groupId>org.springframework.boot</groupId>
-            <artifactId>spring-boot-devtools</artifactId>
-            <scope>runtime</scope>
-            <optional>true</optional>
-        </dependency>
-
-        <!-- Testing -->
-        <dependency>
-            <groupId>org.springframework.boot</groupId>
-            <artifactId>spring-boot-starter-test</artifactId>
-            <scope>test</scope>
-        </dependency>
-        <dependency>
-            <groupId>org.springframework.security</groupId>
-            <artifactId>spring-security-test</artifactId>
-            <scope>test</scope>
-        </dependency>
-    </dependencies>
-
-    <build>
-        <plugins>
-            <plugin>
-                <groupId>org.springframework.boot</groupId>
-                <artifactId>spring-boot-maven-plugin</artifactId>
-                <configuration>
-                    <excludes>
-                        <exclude>
-                            <groupId>org.projectlombok</groupId>
-                            <artifactId>lombok</artifactId>
-                        </exclude>
-                    </excludes>
-                </configuration>
-            </plugin>
-        </plugins>
-    </build>
-
-</project>

package/templates/java-spring/pro/mvc/src/main/java/{{packagePath}}/config/GlobalExceptionHandler.java.hbs

@@ -1,39 +0,0 @@
-package {{packageName}}.config;
-
-import org.springframework.http.HttpStatus;
-import org.springframework.http.ResponseEntity;
-import org.springframework.web.bind.annotation.ExceptionHandler;
-import org.springframework.web.bind.annotation.RestControllerAdvice;
-
-import java.time.Instant;
-import java.util.HashMap;
-import java.util.Map;
-
-/**
-* Global exception handler for REST API
-*/
-@RestControllerAdvice
-public class GlobalExceptionHandler {
-
-    @ExceptionHandler(Exception.class)
-    public ResponseEntity<Map<String, Object>> handleException(Exception ex) {
-        Map<String, Object> error = new HashMap<>();
-        error.put("timestamp", Instant.now().toString());
-        error.put("status", HttpStatus.INTERNAL_SERVER_ERROR.value());
-        error.put("error", "Internal Server Error");
-        error.put("message", ex.getMessage());
-
-        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(error);
-    }
-
-    @ExceptionHandler(IllegalArgumentException.class)
-    public ResponseEntity<Map<String, Object>> handleBadRequest(IllegalArgumentException ex) {
-        Map<String, Object> error = new HashMap<>();
-        error.put("timestamp", Instant.now().toString());
-        error.put("status", HttpStatus.BAD_REQUEST.value());
-        error.put("error", "Bad Request");
-        error.put("message", ex.getMessage());
-
-        return ResponseEntity.status(HttpStatus.BAD_REQUEST).body(error);
-    }
-}

package/templates/java-spring/pro/mvc/src/main/java/{{packagePath}}/config/SecurityConfig.java.hbs

@@ -1,44 +0,0 @@
-package {{packageName}}.config;
-
-import {{packageName}}.security.JwtAuthenticationFilter;
-import org.springframework.context.annotation.Bean;
-import org.springframework.context.annotation.Configuration;
-import org.springframework.security.config.annotation.web.builders.HttpSecurity;
-import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
-import org.springframework.security.config.http.SessionCreationPolicy;
-import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
-import org.springframework.security.crypto.password.PasswordEncoder;
-import org.springframework.security.web.SecurityFilterChain;
-import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
-
-@Configuration
-@EnableWebSecurity
-public class SecurityConfig {
-
-    private final JwtAuthenticationFilter jwtAuthenticationFilter;
-
-    public SecurityConfig(JwtAuthenticationFilter jwtAuthenticationFilter) {
-        this.jwtAuthenticationFilter = jwtAuthenticationFilter;
-    }
-
-    @Bean
-    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
-        http
-        .csrf(csrf -> csrf.disable())
-        .sessionManagement(session -> session.sessionCreationPolicy(SessionCreationPolicy.STATELESS))
-        .authorizeHttpRequests(auth -> auth
-        .requestMatchers("/api/auth/**").permitAll()
-        .requestMatchers("/api/payments/webhook").permitAll()
-        .requestMatchers("/actuator/health").permitAll()
-        .anyRequest().authenticated()
-    )
-    .addFilterBefore(jwtAuthenticationFilter, UsernamePasswordAuthenticationFilter.class);
-
-    return http.build();
-}
-
-@Bean
-public PasswordEncoder passwordEncoder() {
-    return new BCryptPasswordEncoder();
-}
-}

package/templates/java-spring/pro/mvc/src/main/java/{{packagePath}}/config/WebConfig.java.hbs

@@ -1,30 +0,0 @@
-package {{packageName}}.config;
-
-import org.springframework.context.annotation.Bean;
-import org.springframework.context.annotation.Configuration;
-import org.springframework.web.cors.CorsConfiguration;
-import org.springframework.web.cors.UrlBasedCorsConfigurationSource;
-import org.springframework.web.filter.CorsFilter;
-
-import java.util.Arrays;
-
-/**
-* Web configuration for CORS and other settings
-*/
-@Configuration
-public class WebConfig {
-
-    @Bean
-    public CorsFilter corsFilter() {
-        CorsConfiguration config = new CorsConfiguration();
-        config.setAllowCredentials(true);
-        config.setAllowedOriginPatterns(Arrays.asList("*"));
-        config.setAllowedHeaders(Arrays.asList("*"));
-        config.setAllowedMethods(Arrays.asList("GET", "POST", "PUT", "DELETE", "OPTIONS"));
-
-        UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
-        source.registerCorsConfiguration("/**", config);
-
-        return new CorsFilter(source);
-    }
-}

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

@@ -1,69 +0,0 @@
-package {{packageName}}.controller;
-
-import {{packageName}}.dto.AuthRequest;
-import {{packageName}}.dto.AuthResponse;
-import {{packageName}}.security.JwtTokenProvider;
-import org.springframework.http.ResponseEntity;
-import org.springframework.security.crypto.password.PasswordEncoder;
-import org.springframework.web.bind.annotation.*;
-
-import java.util.HashMap;
-import java.util.Map;
-import java.util.UUID;
-
-@RestController
-@RequestMapping("/api/auth")
-public class AuthController {
-
-    private final JwtTokenProvider tokenProvider;
-    private final PasswordEncoder passwordEncoder;
-
-    // In-memory user store (replace with repository in production)
-    private final Map<String, Map<String, String>> users = new HashMap<>();
-
-    public AuthController(JwtTokenProvider tokenProvider, PasswordEncoder passwordEncoder) {
-        this.tokenProvider = tokenProvider;
-        this.passwordEncoder = passwordEncoder;
-    }
-
-    @PostMapping("/register")
-    public ResponseEntity
-    <?> register(@RequestBody AuthRequest request) {
-        if (users.containsKey(request.email())) {
-            return ResponseEntity.badRequest().body(Map.of("error", "User already exists"));
-        }
-
-        String userId = UUID.randomUUID().toString();
-        String hashedPassword = passwordEncoder.encode(request.password());
-
-        users.put(request.email(), Map.of(
-            "id", userId,
-            "email", request.email(),
-            "password", hashedPassword
-        ));
-
-        String token = tokenProvider.generateToken(userId, request.email());
-
-        return ResponseEntity.ok(new AuthResponse(token, userId, request.email()));
-    }
-
-    @PostMapping("/login")
-    public ResponseEntity<?> login(@RequestBody AuthRequest request) {
-        Map<String, String> user = users.get(request.email());
-
-        if (user == null || !passwordEncoder.matches(request.password(), user.get("password"))) {
-            return ResponseEntity.status(401).body(Map.of("error", "Invalid credentials"));
-        }
-
-        String token = tokenProvider.generateToken(user.get("id"), user.get("email"));
-
-        return ResponseEntity.ok(new AuthResponse(token, user.get("id"), user.get("email")));
-    }
-
-    @GetMapping("/me")
-    public ResponseEntity
-    <?> me(@RequestHeader("Authorization") String authHeader) {
-        // User is already authenticated by JWT filter
-        return ResponseEntity.ok(Map.of("message", "Authenticated"));
-    }
-}

package/templates/java-spring/pro/mvc/src/main/java/{{packagePath}}/controller/HealthController.java.hbs

@@ -1,30 +0,0 @@
-package {{packageName}}.controller;
-
-import org.springframework.http.ResponseEntity;
-import org.springframework.web.bind.annotation.GetMapping;
-import org.springframework.web.bind.annotation.RequestMapping;
-import org.springframework.web.bind.annotation.RestController;
-
-import java.time.Instant;
-import java.util.HashMap;
-import java.util.Map;
-
-/**
-* Health check controller
-*/
-@RestController
-@RequestMapping("/api")
-public class HealthController {
-
-    private final Instant startTime = Instant.now();
-
-    @GetMapping("/health")
-    public ResponseEntity<Map<String, Object>> health() {
-        Map<String, Object> response = new HashMap<>();
-        response.put("status", "ok");
-        response.put("message", "{{projectNamePascalCase}} API is running");
-        response.put("timestamp", Instant.now().toString());
-        response.put("uptime", java.time.Duration.between(startTime, Instant.now()).getSeconds());
-        return ResponseEntity.ok(response);
-    }
-}

package/templates/java-spring/pro/mvc/src/main/java/{{packagePath}}/controller/PaymentsController.java.hbs

@@ -1,49 +0,0 @@
-package {{packageName}}.controller;
-
-import {{packageName}}.service.StripeService;
-import com.stripe.exception.StripeException;
-import org.springframework.http.ResponseEntity;
-import org.springframework.web.bind.annotation.*;
-
-import java.util.Map;
-
-@RestController
-@RequestMapping("/api/payments")
-public class PaymentsController {
-
-    private final StripeService stripeService;
-
-    public PaymentsController(StripeService stripeService) {
-        this.stripeService = stripeService;
-    }
-
-    @PostMapping("/checkout")
-    public ResponseEntity
-    <?> createCheckout(@RequestBody Map<String, String> request) {
-        try {
-            var session = stripeService.createCheckoutSession(request.get("customerId"));
-            return ResponseEntity.ok(Map.of("url", session.getUrl()));
-        } catch (StripeException e) {
-            return ResponseEntity.status(500).body(Map.of("error", e.getMessage()));
-        }
-    }
-
-    @PostMapping("/portal")
-    public ResponseEntity<?> createPortal(@RequestBody Map<String, String> request) {
-        try {
-            var session = stripeService.createPortalSession(request.get("customerId"));
-            return ResponseEntity.ok(Map.of("url", session.getUrl()));
-        } catch (StripeException e) {
-            return ResponseEntity.status(500).body(Map.of("error", e.getMessage()));
-        }
-    }
-
-    @PostMapping("/webhook")
-    public ResponseEntity
-    <?> handleWebhook(@RequestBody String payload,
-    @RequestHeader("Stripe-Signature") String sigHeader) {
-        // TODO: Implement webhook verification and handling
-        // Use Stripe.webhooks.constructEvent to verify signature
-        return ResponseEntity.ok(Map.of("received", true));
-    }
-}

package/templates/java-spring/pro/mvc/src/main/java/{{packagePath}}/dto/AuthRequest.java.hbs

@@ -1,3 +0,0 @@
-package {{packageName}}.dto;
-
-public record AuthRequest(String email, String password) {}

package/templates/java-spring/pro/mvc/src/main/java/{{packagePath}}/dto/AuthResponse.java.hbs

@@ -1,3 +0,0 @@
-package {{packageName}}.dto;
-
-public record AuthResponse(String token, String userId, String email) {}