kybernus 1.0.0

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

@@ -0,0 +1,44 @@
+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

@@ -0,0 +1,30 @@
+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

@@ -0,0 +1,69 @@
+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

@@ -0,0 +1,30 @@
+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

@@ -0,0 +1,49 @@
+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

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

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

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

package/templates/java-spring/pro/mvc/src/main/java/{{packagePath}}/security/JwtAuthenticationFilter.java.hbs

@@ -0,0 +1,56 @@
+package {{packageName}}.security;
+
+import jakarta.servlet.FilterChain;
+import jakarta.servlet.ServletException;
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletResponse;
+import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
+import org.springframework.security.core.context.SecurityContextHolder;
+import org.springframework.security.web.authentication.WebAuthenticationDetailsSource;
+import org.springframework.stereotype.Component;
+import org.springframework.util.StringUtils;
+import org.springframework.web.filter.OncePerRequestFilter;
+
+import java.io.IOException;
+import java.util.Collections;
+
+@Component
+public class JwtAuthenticationFilter extends OncePerRequestFilter {
+
+    private final JwtTokenProvider tokenProvider;
+
+    public JwtAuthenticationFilter(JwtTokenProvider tokenProvider) {
+        this.tokenProvider = tokenProvider;
+    }
+
+    @Override
+    protected void doFilterInternal(HttpServletRequest request,
+    HttpServletResponse response,
+    FilterChain filterChain) throws ServletException, IOException {
+        try {
+            String jwt = getJwtFromRequest(request);
+
+            if (StringUtils.hasText(jwt) && tokenProvider.validateToken(jwt)) {
+                String userId = tokenProvider.getUserIdFromToken(jwt);
+
+                UsernamePasswordAuthenticationToken authentication =
+                new UsernamePasswordAuthenticationToken(userId, null, Collections.emptyList());
+                authentication.setDetails(new WebAuthenticationDetailsSource().buildDetails(request));
+
+                SecurityContextHolder.getContext().setAuthentication(authentication);
+            }
+        } catch (Exception ex) {
+            logger.error("Could not set user authentication in security context", ex);
+        }
+
+        filterChain.doFilter(request, response);
+    }
+
+    private String getJwtFromRequest(HttpServletRequest request) {
+        String bearerToken = request.getHeader("Authorization");
+        if (StringUtils.hasText(bearerToken) && bearerToken.startsWith("Bearer ")) {
+            return bearerToken.substring(7);
+        }
+        return null;
+    }
+}

package/templates/java-spring/pro/mvc/src/main/java/{{packagePath}}/security/JwtTokenProvider.java.hbs

@@ -0,0 +1,59 @@
+package {{packageName}}.security;
+
+import io.jsonwebtoken.*;
+import io.jsonwebtoken.security.Keys;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Component;
+
+import javax.crypto.SecretKey;
+import java.nio.charset.StandardCharsets;
+import java.util.Date;
+
+@Component
+public class JwtTokenProvider {
+
+    @Value("${jwt.secret:your-super-secret-jwt-key-change-in-production}")
+    private String jwtSecret;
+
+    @Value("${jwt.expiration:604800000}")
+    private long jwtExpiration; // 7 days in milliseconds
+
+    private SecretKey getSigningKey() {
+        return Keys.hmacShaKeyFor(jwtSecret.getBytes(StandardCharsets.UTF_8));
+    }
+
+    public String generateToken(String userId, String email) {
+        Date now = new Date();
+        Date expiryDate = new Date(now.getTime() + jwtExpiration);
+
+        return Jwts.builder()
+        .subject(userId)
+        .claim("email", email)
+        .issuedAt(now)
+        .expiration(expiryDate)
+        .signWith(getSigningKey())
+        .compact();
+    }
+
+    public String getUserIdFromToken(String token) {
+        Claims claims = Jwts.parser()
+        .verifyWith(getSigningKey())
+        .build()
+        .parseSignedClaims(token)
+        .getPayload();
+
+        return claims.getSubject();
+    }
+
+    public boolean validateToken(String token) {
+        try {
+            Jwts.parser()
+            .verifyWith(getSigningKey())
+            .build()
+            .parseSignedClaims(token);
+            return true;
+        } catch (JwtException | IllegalArgumentException e) {
+            return false;
+        }
+    }
+}

package/templates/java-spring/pro/mvc/src/main/java/{{packagePath}}/service/StripeService.java.hbs

@@ -0,0 +1,67 @@
+package {{packageName}}.service;
+
+import com.stripe.Stripe;
+import com.stripe.exception.StripeException;
+import com.stripe.model.Customer;
+import com.stripe.model.checkout.Session;
+import com.stripe.param.CustomerCreateParams;
+import com.stripe.param.checkout.SessionCreateParams;
+import jakarta.annotation.PostConstruct;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Service;
+
+@Service
+public class StripeService {
+
+    @Value("${stripe.secret-key}")
+    private String stripeSecretKey;
+
+    @Value("${stripe.price-id}")
+    private String priceId;
+
+    @Value("${frontend.url}")
+    private String frontendUrl;
+
+    @PostConstruct
+    public void init() {
+        Stripe.apiKey = stripeSecretKey;
+    }
+
+    public Session createCheckoutSession(String customerId) throws StripeException {
+        SessionCreateParams.Builder paramsBuilder = SessionCreateParams.builder()
+        .setMode(SessionCreateParams.Mode.SUBSCRIPTION)
+        .setSuccessUrl(frontendUrl + "/success?session_id={CHECKOUT_SESSION_ID}")
+        .setCancelUrl(frontendUrl + "/cancel")
+        .addLineItem(
+            SessionCreateParams.LineItem.builder()
+            .setPrice(priceId)
+            .setQuantity(1L)
+            .build()
+        );
+
+        if (customerId != null && !customerId.isEmpty()) {
+            paramsBuilder.setCustomer(customerId);
+        }
+
+        return Session.create(paramsBuilder.build());
+    }
+
+    public com.stripe.model.billingportal.Session createPortalSession(String customerId) throws StripeException {
+        com.stripe.param.billingportal.SessionCreateParams params =
+        com.stripe.param.billingportal.SessionCreateParams.builder()
+        .setCustomer(customerId)
+        .setReturnUrl(frontendUrl + "/dashboard")
+        .build();
+
+        return com.stripe.model.billingportal.Session.create(params);
+    }
+
+    public Customer createCustomer(String email, String name) throws StripeException {
+        CustomerCreateParams params = CustomerCreateParams.builder()
+        .setEmail(email)
+        .setName(name)
+        .build();
+
+        return Customer.create(params);
+    }
+}

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

@@ -0,0 +1,13 @@
+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);
+    }
+
+}

package/templates/java-spring/pro/mvc/src/main/resources/application.yml.hbs

@@ -0,0 +1,32 @@
+spring:
+  application:
+    name: {{projectNameKebabCase}}
+  
+    datasource:
+      url: jdbc:postgresql://localhost:5432/{{projectNameSnakeCase}}
+      username: postgres
+      password: postgres
+      driver-class-name: org.postgresql.Driver
+  
+      jpa:
+        hibernate:
+          ddl-auto: update
+          show-sql: true
+          properties:
+            hibernate:
+              format_sql: true
+              dialect: org.hibernate.dialect.PostgreSQLDialect
+
+  # H2 Console (for development)
+              h2:
+                console:
+                  enabled: true
+                  path: /h2-console
+
+                  server:
+                    port: 8080
+
+                    logging:
+                      level:
+                        root: INFO
+                        {{packageName}}: DEBUG

package/templates/java-spring/pro/mvc/src/test/java/{{packagePath}}/{{projectNamePascalCase}}ApplicationTests.java.hbs

@@ -0,0 +1,13 @@
+package {{packageName}};
+
+import org.junit.jupiter.api.Test;
+import org.springframework.boot.test.context.SpringBootTest;
+
+@SpringBootTest
+class {{projectNamePascalCase}}ApplicationTests {
+
+    @Test
+    void contextLoads() {
+    }
+
+}

package/templates/java-spring/pro/mvc/src/test/resources/application.yml.hbs

@@ -0,0 +1,10 @@
+spring:
+  datasource:
+    url: jdbc:h2:mem:testdb;DB_CLOSE_DELAY=-1
+    driver-class-name: org.h2.Driver
+    username: sa
+    password: password
+    jpa:
+      database-platform: org.hibernate.dialect.H2Dialect
+      hibernate:
+        ddl-auto: create-drop

package/templates/java-spring/pro/mvc/template.json

@@ -0,0 +1,14 @@
+{
+  "name": "Java Spring Boot MVC",
+  "tier": "free",
+  "stack": "java-spring",
+  "version": "1.0.0",
+  "description": "Spring Boot 4 REST API with Java 21 and MVC architecture",
+  "targetVersions": {
+    "java": "21",
+    "springBoot": "^4.0.0",
+    "maven": "^3.9.0"
+  },
+  "requiredConfig": ["projectName", "packageName"],
+  "optionalConfig": ["useAI", "buildTool"]
+}

package/templates/nestjs/free/mvc/README.md.hbs

@@ -0,0 +1,28 @@
+# {{projectName}}
+
+> Generated by [Kybernus CLI](https://kybernus.dev) 🚀 (Free)
+
+## Stack
+
+- **Framework**: NestJS
+- **Language**: TypeScript
+- **Validation**: class-validator
+
+## Quick Start
+
+```bash
+npm install
+npm run dev
+```
+
+## API Endpoints
+
+- `GET /api/health` - Health check
+- `GET /api/items` - List items
+- `POST /api/items` - Create item
+- `GET /api/items/:id` - Get item
+- `DELETE /api/items/:id` - Delete item
+
+---
+
+Made with ❤️ using [Kybernus](https://kybernus.dev)

package/templates/nestjs/free/mvc/package.json.hbs

@@ -0,0 +1,29 @@
+{
+"name": "{{kebabCase projectName}}",
+"version": "1.0.0",
+"description": "Generated by Kybernus CLI",
+"scripts": {
+"dev": "nest start --watch",
+"build": "nest build",
+"start": "node dist/main.js",
+"lint": "eslint \"{src,test}/**/*.ts\"",
+"test": "jest"
+},
+"dependencies": {
+"@nestjs/common": "^10.3.0",
+"@nestjs/core": "^10.3.0",
+"@nestjs/config": "^3.1.1",
+"@nestjs/platform-express": "^10.3.0",
+"class-transformer": "^0.5.1",
+"class-validator": "^0.14.1",
+"reflect-metadata": "^0.2.1",
+"rxjs": "^7.8.1",
+"uuid": "^9.0.1"
+},
+"devDependencies": {
+"@nestjs/cli": "^10.3.0",
+"@types/node": "^20.11.0",
+"@types/uuid": "^9.0.7",
+"typescript": "^5.3.3"
+}
+}

package/templates/nestjs/free/mvc/src/app.module.ts.hbs

@@ -0,0 +1,13 @@
+import { Module } from '@nestjs/common';
+import { ConfigModule } from '@nestjs/config';
+import { ItemsModule } from './modules/items.module';
+import { HealthController } from './controllers/health.controller';
+
+@Module({
+imports: [
+ConfigModule.forRoot({ isGlobal: true }),
+ItemsModule,
+],
+controllers: [HealthController],
+})
+export class AppModule {}

package/templates/nestjs/free/mvc/src/controllers/health.controller.ts.hbs

@@ -0,0 +1,9 @@
+import { Controller, Get } from '@nestjs/common';
+
+@Controller()
+export class HealthController {
+@Get('health')
+health() {
+return { status: 'ok' };
+}
+}

package/templates/nestjs/free/mvc/src/controllers/items.controller.ts.hbs

@@ -0,0 +1,32 @@
+import { Controller, Get, Post, Delete, Param, Body, NotFoundException } from '@nestjs/common';
+import { ItemsService } from '../services/items.service';
+import { CreateItemDto } from '../models/create-item.dto';
+
+@Controller('items')
+export class ItemsController {
+constructor(private readonly itemsService: ItemsService) {}
+
+@Get()
+findAll() {
+return this.itemsService.findAll();
+}
+
+@Get(':id')
+findOne(@Param('id') id: string) {
+const item = this.itemsService.findOne(id);
+if (!item) throw new NotFoundException('Item not found');
+return item;
+}
+
+@Post()
+create(@Body() createItemDto: CreateItemDto) {
+return this.itemsService.create(createItemDto);
+}
+
+@Delete(':id')
+remove(@Param('id') id: string) {
+const deleted = this.itemsService.remove(id);
+if (!deleted) throw new NotFoundException('Item not found');
+return { message: 'Item deleted' };
+}
+}

package/templates/nestjs/free/mvc/src/main.ts.hbs

@@ -0,0 +1,17 @@
+import { NestFactory } from '@nestjs/core';
+import { AppModule } from './app.module';
+import { ValidationPipe } from '@nestjs/common';
+
+async function bootstrap() {
+const app = await NestFactory.create(AppModule);
+
+app.enableCors();
+app.setGlobalPrefix('api');
+app.useGlobalPipes(new ValidationPipe({ whitelist: true }));
+
+const port = process.env.PORT || 3000;
+await app.listen(port);
+
+console.log(`🚀 {{pascalCase projectName}} running on port ${port}`);
+}
+bootstrap();

package/templates/nestjs/free/mvc/src/models/create-item.dto.ts.hbs

@@ -0,0 +1,10 @@
+import { IsString, IsOptional } from 'class-validator';
+
+export class CreateItemDto {
+@IsString()
+name: string;
+
+@IsString()
+@IsOptional()
+description?: string;
+}

package/templates/nestjs/free/mvc/src/models/item.model.ts.hbs

@@ -0,0 +1,6 @@
+export interface Item {
+id: string;
+name: string;
+description?: string;
+createdAt: Date;
+}