kybernus 2.2.1 → 2.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kybernus",
-  "version": "2.2.1",
+  "version": "2.3.0",
   "type": "module",
   "description": "The Ultimate Scaffolding CLI for Modern Developers",
   "main": "dist/index.js",

package/templates/java-spring/clean/src/main/java/{{packagePath}}/application/usecase/PaymentUseCase.java.hbs

@@ -0,0 +1,89 @@
+package {{packageName}}.application.usecase;
+
+import {{packageName}}.domain.entity.User;
+import {{packageName}}.domain.repository.UserRepository;
+import {{packageName}}.infrastructure.stripe.StripeGateway;
+import com.stripe.model.Event;
+import com.stripe.model.checkout.Session;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.stereotype.Service;
+
+@Service
+public class PaymentUseCase {
+
+    private static final Logger logger = LoggerFactory.getLogger(PaymentUseCase.class);
+
+    private final UserRepository userRepository;
+    private final StripeGateway stripeGateway;
+
+    public PaymentUseCase(UserRepository userRepository, StripeGateway stripeGateway) {
+        this.userRepository = userRepository;
+        this.stripeGateway = stripeGateway;
+    }
+
+    public String createCheckoutSession(String userId, String pricpackage {{packageName}}.application.usecase;
+
+import {{packageName}}.domain.l.UUID.fromString(userId))
+                .orElseThrow(() -> new RuntimeException("User not found"));
+
+        String customerId = user.getStripeCustomerId();
+
+        if (customerId == null || customerId.isEmpty()) {
+            cuimport com.stripeGateway.createCustomer(user.getEmail(), userId).getId();
+            user.setStripeCustomerId(customerId);
+            userRepository.save(user);
+        }
+
+        Session session = stripeGateway.createCheckoutSession(customerId, priceId, userId);
+        retu
+    private final UserRepository userRString createPortalSession(String userId) throws Exception {
+        User user = userRepository.findById(java.util.UUID.fromString(userId))
+                .orElseThrow(() -> new RuntimeException("User not found"));
+
+        if (user.getStripeCustomerId() == null) {
+            throw new RuntimeException("No Stripe customer found for this user");
+        }
+
+        return stripeGateway.createPortalSession(user.getStripeCustomerId()).getUrl();
+    }
+
+    public void handleWebhook(String payload, String sigHeader) throws Exception {
+        Event event = stripeGateway.constructWebhookEvent(payload, sigHeader);
+
+        switch (event.getType()) {
+            case "checkout.session.completed": {
+                Session session = (Session) event.getDataObjectDeserializer().getObject().orElse(null);
+                if (session != null && session.getClientReferenceId() != null) {
+                    String userId = session.getClientReferenceId();
+                    userRepository.findById(java.util.UUID.fromString(userId)).ifPresent(user -> {
+                        user.setStripeCustomerId(session.getCustomer());
+                        userRepository.save(user);
+                    });
+                    logger.info("Checkout completed for user: {}", userId);
+                }
+                break;
+            }
+            case "customer.subscription.updated": {
+                com.stripe.model.Subscription sub =
+                        (com.stripe.model.Subscription) event.getDataObjectDeserializer().getObject().orElse(null);
+                if (sub != null) logger.info("Subscription updated: {} | Status: {}", sub.getId(), sub.getStatus());
+                break;
+            }
+            case "customer.subscription.deleted": {
+                com.stripe.model.Subscription sub =
+                        (com.stripe.model.Subscription) event.getDataObjectDeserializer().getObject().orElse(null);
+                if (sub != null) logger.info("Subscription deleted: {}", sub.getId());
+                break;
+            }
+            case "invoice.payment_failed": {
+                com.stripe.model.Invoice invoice =
+                        (com.stripe.model.Invoice) event.getDataObjectDeserializer().getObject().orElse(null);
+                if (invoice != null) logger.info("Payment failed for invoice: {}", invoice.getId());
+                break;
+            }
+            default:
+                logger.info("Unhandled Stripe event: {}", event.getType());
+        }
+    }
+}

package/templates/java-spring/clean/src/main/java/{{packagePath}}/infrastructure/web/payment/PaymentController.java.hbs

@@ -0,0 +1,78 @@
+package {{packageName}}.infrastructure.web.payment;
+
+import {{packageName}}.application.usecase.PaymentUseCase;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.security.core.annotation.AuthenticationPrincipal;
+import org.springframework.security.core.userdetails.UserDetails;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.Map;
+
+@RestController
+@RequestMapping("/api/payments")
+public class PaymentController {
+
+    private static final Logger logger = LoggerFactory.getLogger(PaymentController.class);
+
+    private final PaymentUseCase paymentUseCase;
+
+    public PaymentController(PaymentUseCase paymentUseCase) {
+        this.paymentUseCase = paymentUseCase;
+    }
+
+    /**
+     * POST /api/payments/checkout
+     * Requires authentication.
+     */
+    @PostMapping("/checkout")
+    public ResponseEntity<?> createCheckout(
+            @AuthenticationPrincipal UserDetails userDetails,
+            @RequestBody Map<String, String> body) {
+        try {
+            String priceId = body.get("priceId");
+            if (priceId == null || priceId.isEmpty()) {
+                return ResponseEntity.badRequest().body(Map.of("error", "priceId is required"));
+            }
+            String url = paymentUseCase.createCheckoutSession(userDetails.getUsername(), priceId);
+            return ResponseEntity.ok(Map.of("url", url));
+        } catch (Exception e) {
+            logger.error("Checkout error", e);
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(Map.of("error", e.getMessage()));
+        }
+    }
+
+    /**
+     * POST /api/payments/portal
+     * Requires authentication.
+     */
+    @PostMapping("/portal")
+    public ResponseEntity<?> createPortal(@AuthenticationPrincipal UserDetails userDetails) {
+        try {
+            String url = paymentUseCase.createPortalSession(userDetails.getUsername());
+            return ResponseEntity.ok(Map.of("url", url));
+        } catch (Exception e) {
+            logger.error("Portal error", e);
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(Map.of("error", e.getMessage()));
+        }
+    }
+
+    /**
+     * POST /api/payments/webhook
+     * No authentication. Stripe sends raw body.
+     */
+    @PostMapping("/webhook")
+    public ResponseEntity<String> webhook(
+            @RequestBody String payload,
+            @RequestHeader("Stripe-Signature") String sigHeader) {
+        try {
+            paymentUseCase.handleWebhook(payload, sigHeader);
+            return ResponseEntity.ok("{\"received\": true}");
+        } catch (Exception e) {
+            logger.warn("Webhook error: {}", e.getMessage());
+            return ResponseEntity.status(HttpStatus.BAD_REQUEST).body(e.getMessage());
+        }
+    }
+}

package/templates/java-spring/clean/src/main/resources/application.properties.hbs

@@ -16,3 +16,10 @@ spring.jpa.properties.hibernate.format_sql=true
 application.security.jwt.secret-key={{jwtSecretKey}}
 application.security.jwt.expiration=86400000
 application.security.jwt.refresh-token.expiration=604800000
+
+# Stripe
+stripe.secret-key=${STRIPE_SECRET_KEY}
+stripe.webhook-secret=${STRIPE_WEBHOOK_SECRET}
+
+# Frontend URL (for Stripe redirect URLs)
+frontend.url=${FRONTEND_URL:http://localhost:3000}

package/templates/java-spring/hexagonal/src/main/java/{{packagePath}}/adapters/inbound/web/PaymentController.java.hbs

@@ -0,0 +1,78 @@
+package {{packageName}}.adapters.inbound.web;
+
+import {{packageName}}.core.service.PaymentService;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.security.core.annotation.AuthenticationPrincipal;
+import org.springframework.security.core.userdetails.UserDetails;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.Map;
+
+@RestController
+@RequestMapping("/api/payments")
+public class PaymentController {
+
+    private static final Logger logger = LoggerFactory.getLogger(PaymentController.class);
+
+    private final PaymentService paymentService;
+
+    public PaymentController(PaymentService paymentService) {
+        this.paymentService = paymentService;
+    }
+
+    /**
+     * POST /api/payments/checkout
+     * Requires authentication.
+     */
+    @PostMapping("/checkout")
+    public ResponseEntity<?> createCheckout(
+            @AuthenticationPrincipal UserDetails userDetails,
+            @RequestBody Map<String, String> body) {
+        try {
+            String priceId = body.get("priceId");
+            if (priceId == null || priceId.isEmpty()) {
+                return ResponseEntity.badRequest().body(Map.of("error", "priceId is required"));
+            }
+            String url = paymentService.createCheckoutSession(userDetails.getUsername(), priceId);
+            return ResponseEntity.ok(Map.of("url", url));
+        } catch (Exception e) {
+            logger.error("Checkout error", e);
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(Map.of("error", e.getMessage()));
+        }
+    }
+
+    /**
+     * POST /api/payments/portal
+     * Requires authentication.
+     */
+    @PostMapping("/portal")
+    public ResponseEntity<?> createPortal(@AuthenticationPrincipal UserDetails userDetails) {
+        try {
+            String url = paymentService.createPortalSession(userDetails.getUsername());
+            return ResponseEntity.ok(Map.of("url", url));
+        } catch (Exception e) {
+            logger.error("Portal error", e);
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(Map.of("error", e.getMessage()));
+        }
+    }
+
+    /**
+     * POST /api/payments/webhook
+     * No authentication. Stripe sends raw body.
+     */
+    @PostMapping("/webhook")
+    public ResponseEntity<String> webhook(
+            @RequestBody String payload,
+            @RequestHeader("Stripe-Signature") String sigHeader) {
+        try {
+            paymentService.handleWebhook(payload, sigHeader);
+            return ResponseEntity.ok("{\"received\": true}");
+        } catch (Exception e) {
+            logger.warn("Webhook error: {}", e.getMessage());
+            return ResponseEntity.status(HttpStatus.BAD_REQUEST).body(e.getMessage());
+        }
+    }
+}

package/templates/java-spring/hexagonal/src/main/java/{{packagePath}}/adapters/outbound/stripe/StripeAdapter.java.hbs

@@ -0,0 +1,76 @@
+package {{packageName}}.adapters.outbound.stripe;
+
+import com.stripe.Stripe;
+import com.stripe.exception.StripeException;
+import com.stripe.model.Customer;
+import com.stripe.model.Event;
+import com.stripe.model.checkout.Session;
+import com.stripe.net.Webhook;
+import com.stripe.param.CustomerCreateParams;
+import com.stripe.param.checkout.SessionCreateParams;
+import jakarta.annotation.PostConstruct;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Component;
+
+/**
+ * Outbound adapter: wraps the Stripe SDK for use by core services.
+ */
+@Component
+public class StripeAdapter {
+
+    private static final Logger logger = LoggerFactory.getLogger(StripeAdapter.class);
+
+    @Value("${stripe.secret-key}")
+    private String stripeSecretKey;
+
+    @Value("${stripe.webhook-secret}")
+    private String webhookSecret;
+
+    @Value("${frontend.url}")
+    private String frontendUrl;
+
+    @PostConstruct
+    public void init() {
+        Stripe.apiKey = stripeSecretKey;
+    }
+
+    public Customer createCustomer(String email, String userId) throws StripeException {
+        return Customer.create(CustomerCreateParams.builder()
+                .setEmail(email)
+                .putMetadata("userId", userId)
+                .build());
+    }
+
+    public Session createCheckoutSession(
+            String customerId, String priceId, String userId) throws StripeException {
+
+        return Session.create(SessionCreateParams.builder()
+                .setMode(SessionCreateParams.Mode.SUBSCRIPTION)
+                .addPaymentMethodType(SessionCreateParams.PaymentMethodType.CARD)
+                .addLineItem(SessionCreateParams.LineItem.builder()
+                        .setPrice(priceId)
+                        .setQuantity(1L)
+                        .build())
+                .setCustomer(customerId)
+                .setSuccessUrl(frontendUrl + "/success?session_id={CHECKOUT_SESSION_ID}")
+                .setCancelUrl(frontendUrl + "/cancel")
+                .setClientReferenceId(userId)
+                .build());
+    }
+
+    public com.stripe.model.billingportal.Session createPortalSession(
+            String customerId) throws StripeException {
+
+        return com.stripe.model.billingportal.Session.create(
+                com.stripe.param.billingportal.SessionCreateParams.builder()
+                        .setCustomer(customerId)
+                        .setReturnUrl(frontendUrl + "/dashboard")
+                        .build());
+    }
+
+    public Event constructWebhookEvent(String payload, String sigHeader) throws Exception {
+        return Webhook.constructEvent(payload, sigHeader, webhookSecret);
+    }
+}

package/templates/java-spring/hexagonal/src/main/java/{{packagePath}}/core/service/PaymentService.java.hbs

@@ -0,0 +1,90 @@
+package {{packageName}}.core.service;
+
+import {{packageName}}.adapters.outbound.stripe.StripeAdapter;
+import {{packageName}}.core.ports.outbound.UserRepository;
+import {{packageName}}.core.domain.User;
+import com.stripe.model.Event;
+import com.stripe.model.checkout.Session;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.stereotype.Service;
+
+@Service
+public class PaymentService {
+
+    private static final Logger logger = LoggerFactory.getLogger(PaymentService.class);
+
+    private final UserRepository userRepository;
+    private final StripeAdapter stripeAdapter;
+
+    public PaymentService(UserRepository userRepository, StripeAdapter stripeAdapter) {
+        this.userRepository = userRepository;
+        this.stripeAdapter = stripeAdapter;
+    }
+
+    public String createCheckoutSession(String userId, String priceId) throws Exception {
+        User user = userRepository.findById(java.util.UUID.fromString(userId))
+                .orElseThrow(() -> new RuntimeException("User not found"));
+
+        String customerId = user.getStripeCustomerId();
+
+        if (customerId == null || customerId.isEmpty()) {
+            customerId = stripeAdapter.createCustomer(user.getEmail(), userId).getId();
+            user.setStripeCustomerId(customerId);
+            userRepository.save(user);
+        }
+
+        Session session = stripeAdapter.createCheckoutSession(customerId, priceId, userId);
+        return session.getUrl();
+    }
+
+    public String createPortalSession(String userId) throws Exception {
+        User user = userRepository.findById(java.util.UUID.fromString(userId))
+                .orElseThrow(() -> new RuntimeException("User not found"));
+
+        if (user.getStripeCustomerId() == null) {
+            throw new RuntimeException("No Stripe customer found for this user");
+        }
+
+        return stripeAdapter.createPortalSession(user.getStripeCustomerId()).getUrl();
+    }
+
+    public void handleWebhook(String payload, String sigHeader) throws Exception {
+        Event event = stripeAdapter.constructWebhookEvent(payload, sigHeader);
+
+        switch (event.getType()) {
+            case "checkout.session.completed": {
+                Session session = (Session) event.getDataObjectDeserializer().getObject().orElse(null);
+                if (session != null && session.getClientReferenceId() != null) {
+                    String userId = session.getClientReferenceId();
+                    userRepository.findById(java.util.UUID.fromString(userId)).ifPresent(user -> {
+                        user.setStripeCustomerId(session.getCustomer());
+                        userRepository.save(user);
+                    });
+                    logger.info("Checkout completed for user: {}", userId);
+                }
+                break;
+            }
+            case "customer.subscription.updated": {
+                com.stripe.model.Subscription sub =
+                        (com.stripe.model.Subscription) event.getDataObjectDeserializer().getObject().orElse(null);
+                if (sub != null) logger.info("Subscription updated: {} | Status: {}", sub.getId(), sub.getStatus());
+                break;
+            }
+            case "customer.subscription.deleted": {
+                com.stripe.model.Subscription sub =
+                        (com.stripe.model.Subscription) event.getDataObjectDeserializer().getObject().orElse(null);
+                if (sub != null) logger.info("Subscription deleted: {}", sub.getId());
+                break;
+            }
+            case "invoice.payment_failed": {
+                com.stripe.model.Invoice invoice =
+                        (com.stripe.model.Invoice) event.getDataObjectDeserializer().getObject().orElse(null);
+                if (invoice != null) logger.info("Payment failed for invoice: {}", invoice.getId());
+                break;
+            }
+            default:
+                logger.info("Unhandled Stripe event: {}", event.getType());
+        }
+    }
+}

package/templates/java-spring/hexagonal/src/main/resources/application.properties.hbs

@@ -16,3 +16,10 @@ spring.jpa.properties.hibernate.format_sql=true
 application.security.jwt.secret-key={{jwtSecretKey}}
 application.security.jwt.expiration=86400000
 application.security.jwt.refresh-token.expiration=604800000
+
+# Stripe
+stripe.secret-key=${STRIPE_SECRET_KEY}
+stripe.webhook-secret=${STRIPE_WEBHOOK_SECRET}
+
+# Frontend URL (for Stripe redirect URLs)
+frontend.url=${FRONTEND_URL:http://localhost:3000}

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

@@ -1,20 +1,15 @@
 package {{packageName}}.controller;
 
-import com.stripe.exception.SignatureVerificationException;
-import com.stripe.model.Event;
-import com.stripe.net.Webhook;
-import {{packageName}}.model.User;
-import {{packageName}}.repository.UserRepository;
 import {{packageName}}.service.StripeService;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
-import org.springframework.beans.factory.annotation.Value;
 import org.springframework.http.HttpStatus;
 import org.springframework.http.ResponseEntity;
+import org.springframework.security.core.annotation.AuthenticationPrincipal;
+import org.springframework.security.core.userdetails.UserDetails;
 import org.springframework.web.bind.annotation.*;
 
 import java.util.Map;
-import java.util.Optional;
 
 @RestController
 @RequestMapping("/api/payments")
@@ -22,71 +17,65 @@ public class PaymentsController {
 
     private static final Logger logger = LoggerFactory.getLogger(PaymentsController.class);
 
-    @Value("${stripe.webhook-secret}")
-    private String webhookSecret;
-
     private final StripeService stripeService;
-    private final UserRepository userRepository;
 
-    public PaymentsController(StripeService stripeService, UserRepository userRepository) {
+    public PaymentsController(StripeService stripeService) {
         this.stripeService = stripeService;
-        this.userRepository = userRepository;
     }
 
+    /**
+     * POST /api/payments/checkout
+     * Requires authentication. Creates a Stripe Checkout session.
+     */
     @PostMapping("/checkout")
-    public ResponseEntity<?> createCheckout(@RequestBody Map<String, String> request) {
+    public ResponseEntity<?> createCheckout(
+            @AuthenticationPrincipal UserDetails userDetails,
+            @RequestBody Map<String, String> body) {
         try {
-            String customerId = request.get("customerId"); // Optional
-            com.stripe.model.checkout.Session session = stripeService.createCheckoutSession(customerId);
+            String priceId = body.get("priceId");
+            if (priceId == null || priceId.isEmpty()) {
+                return ResponseEntity.badRequest().body(Map.of("error", "priceId is required"));
+            }
+            // userDetails.getUsername() returns the user ID (set in JWT filter)
+            com.stripe.model.checkout.Session session =
+                    stripeService.createCheckoutSession(userDetails.getUsername(), priceId);
             return ResponseEntity.ok(Map.of("url", session.getUrl()));
         } catch (Exception e) {
             logger.error("Error creating checkout session", e);
-            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
-                    .body(Map.of("error", e.getMessage()));
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(Map.of("error", e.getMessage()));
+        }
+    }
+
+    /**
+     * POST /api/payments/portal
+     * Requires authentication. Opens Stripe Billing Portal.
+     */
+    @PostMapping("/portal")
+    public ResponseEntity<?> createPortal(@AuthenticationPrincipal UserDetails userDetails) {
+        try {
+            com.stripe.model.billingportal.Session session =
+                    stripeService.createPortalSession(userDetails.getUsername());
+            return ResponseEntity.ok(Map.of("url", session.getUrl()));
+        } catch (Exception e) {
+            logger.error("Error creating portal session", e);
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(Map.of("error", e.getMessage()));
         }
     }
 
+    /**
+     * POST /api/payments/webhook
+     * No authentication. Stripe sends raw body + signature header.
+     */
     @PostMapping("/webhook")
     public ResponseEntity<String> handleWebhook(
             @RequestBody String payload,
             @RequestHeader("Stripe-Signature") String sigHeader) {
-
-        Event event;
-
         try {
-            event = Webhook.constructEvent(payload, sigHeader, webhookSecret);
-        } catch (SignatureVerificationException e) {
-            logger.warn("Invalid signature", e);
-            return ResponseEntity.status(HttpStatus.BAD_REQUEST).body("Invalid signature");
+            stripeService.handleWebhook(payload, sigHeader);
+            return ResponseEntity.ok("{\"received\": true}");
         } catch (Exception e) {
-            logger.error("Error parsing webhook", e);
-             return ResponseEntity.status(HttpStatus.BAD_REQUEST).body("Error parsing webhook");
+            logger.warn("Webhook error: {}", e.getMessage());
+            return ResponseEntity.status(HttpStatus.BAD_REQUEST).body(e.getMessage());
         }
-
-        switch (event.getType()) {
-            case "checkout.session.completed":
-                com.stripe.model.checkout.Session session = (com.stripe.model.checkout.Session) event.getDataObjectDeserializer().getObject().orElse(null);
-                if (session != null) {
-                    logger.info("Checkout completed: {}", session.getId());
-                    // Match to database user here using session properties
-                }
-                break;
-            case "customer.subscription.updated":
-                 com.stripe.model.Subscription subscription = (com.stripe.model.Subscription) event.getDataObjectDeserializer().getObject().orElse(null);
-                 if (subscription != null) {
-                    logger.info("Subscription updated: {}", subscription.getId());
-                 }
-                 break;
-             case "customer.subscription.deleted":
-                  com.stripe.model.Subscription deletedSub = (com.stripe.model.Subscription) event.getDataObjectDeserializer().getObject().orElse(null);
-                  if (deletedSub != null) {
-                      logger.info("Subscription deleted: {}", deletedSub.getId());
-                  }
-                  break;
-            default:
-                logger.info("Unhandled event type: {}", event.getType());
-        }
-
-        return ResponseEntity.ok("Received");
     }
 }