kybernus 2.1.1 → 2.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kybernus",
-  "version": "2.1.1",
+  "version": "2.2.0",
   "type": "module",
   "description": "The Ultimate Scaffolding CLI for Modern Developers",
   "main": "dist/index.js",
@@ -76,4 +76,4 @@
   "overrides": {
     "rimraf": "^6.1.2"
   }
-}
+}

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

@@ -2,68 +2,64 @@ package {{packageName}}.controller;
 
 import {{packageName}}.dto.AuthRequest;
 import {{packageName}}.dto.AuthResponse;
-import {{packageName}}.security.JwtTokenProvider;
+import {{packageName}}.model.User;
+import {{packageName}}.service.AuthService;
 import org.springframework.http.ResponseEntity;
-import org.springframework.security.crypto.password.PasswordEncoder;
+import org.springframework.http.HttpStatus;
 import org.springframework.web.bind.annotation.*;
+import org.springframework.security.core.context.SecurityContextHolder;
+import org.springframework.security.core.Authentication;
 
-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;
+    private final AuthService authService;
 
-    // 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;
+    public AuthController(AuthService authService) {
+        this.authService = authService;
     }
 
     @PostMapping("/register")
-    public ResponseEntity
-    <?> register(@RequestBody AuthRequest request) {
-        if (users.containsKey(request.email())) {
-            return ResponseEntity.badRequest().body(Map.of("error", "User already exists"));
+    public ResponseEntity<?> register(@RequestBody AuthRequest request) {
+        try {
+            AuthResponse response = authService.register(request);
+            return ResponseEntity.ok(response);
+        } catch (IllegalArgumentException e) {
+            return ResponseEntity.badRequest().body(Map.of("error", e.getMessage()));
         }
-
-        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"));
+        try {
+            AuthResponse response = authService.login(request);
+            return ResponseEntity.ok(response);
+        } catch (IllegalArgumentException e) {
+            return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body(Map.of("error", e.getMessage()));
         }
-
-        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"));
+    public ResponseEntity<?> me() {
+        Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
+        if (authentication == null || !authentication.isAuthenticated()) {
+            return ResponseEntity.status(HttpStatus.UNAUTHORIZED).build();
+        }
+        
+        try {
+            String userId = (String) authentication.getPrincipal(); // Assuming custom jwt filter sets principal to id
+            User user = authService.getMe(userId);
+            return ResponseEntity.ok(Map.of(
+                "id", user.getId(),
+                "email", user.getEmail(),
+                "name", user.getName()
+            ));
+        } catch (Exception e) {
+            // Keep original behavior if principal isn't id 
+            return ResponseEntity.ok(Map.of("message", "Authenticated"));
+        }
     }
-}
+}

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

@@ -0,0 +1,42 @@
+package {{packageName}}.controller;
+
+import {{packageName}}.model.Item;
+import {{packageName}}.repository.ItemRepository;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+
+@RestController
+@RequestMapping("/api/items")
+public class ItemController {
+
+    private final ItemRepository itemRepository;
+
+    public ItemController(ItemRepository itemRepository) {
+        this.itemRepository = itemRepository;
+    }
+
+    @GetMapping
+    public List<Item> getAllItems() {
+        return itemRepository.findAll();
+    }
+
+    @PostMapping
+    public Item createItem(@RequestBody Item item) {
+        return itemRepository.save(item);
+    }
+
+    @GetMapping("/{id}")
+    public ResponseEntity<Item> getItem(@PathVariable String id) {
+        return itemRepository.findById(id)
+                .map(ResponseEntity::ok)
+                .orElse(ResponseEntity.notFound().build());
+    }
+
+    @DeleteMapping("/{id}")
+    public ResponseEntity<Void> deleteItem(@PathVariable String id) {
+        itemRepository.deleteById(id);
+        return ResponseEntity.ok().build();
+    }
+}

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

@@ -1,49 +1,92 @@
 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 com.stripe.exception.StripeException;
+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.web.bind.annotation.*;
 
 import java.util.Map;
+import java.util.Optional;
 
 @RestController
 @RequestMapping("/api/payments")
 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) {
+    public PaymentsController(StripeService stripeService, UserRepository userRepository) {
         this.stripeService = stripeService;
+        this.userRepository = userRepository;
     }
 
     @PostMapping("/checkout")
-    public ResponseEntity
-    <?> createCheckout(@RequestBody Map<String, String> request) {
+    public ResponseEntity<?> createCheckout(@RequestBody Map<String, String> request) {
         try {
-            var session = stripeService.createCheckoutSession(request.get("customerId"));
+            String customerId = request.get("customerId"); // Optional
+            com.stripe.model.checkout.Session session = stripeService.createCheckoutSession(customerId);
             return ResponseEntity.ok(Map.of("url", session.getUrl()));
-        } catch (StripeException e) {
-            return ResponseEntity.status(500).body(Map.of("error", e.getMessage()));
+        } catch (Exception e) {
+            logger.error("Error creating checkout session", e);
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
+                    .body(Map.of("error", e.getMessage()));
         }
     }
 
-    @PostMapping("/portal")
-    public ResponseEntity<?> createPortal(@RequestBody Map<String, String> request) {
+    @PostMapping("/webhook")
+    public ResponseEntity<String> handleWebhook(
+            @RequestBody String payload,
+            @RequestHeader("Stripe-Signature") String sigHeader) {
+
+        Event event;
+
         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()));
+            event = Webhook.constructEvent(payload, sigHeader, webhookSecret);
+        } catch (SignatureVerificationException e) {
+            logger.warn("Invalid signature", e);
+            return ResponseEntity.status(HttpStatus.BAD_REQUEST).body("Invalid signature");
+        } catch (Exception e) {
+            logger.error("Error parsing webhook", e);
+             return ResponseEntity.status(HttpStatus.BAD_REQUEST).body("Error parsing webhook");
         }
-    }
 
-    @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));
+        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");
     }
-}
+}

package/templates/java-spring/mvc/src/main/java/{{packagePath}}/model/Item.java.hbs

@@ -0,0 +1,38 @@
+package {{packageName}}.model;
+
+import jakarta.persistence.*;
+import lombok.*;
+import org.springframework.data.annotation.CreatedDate;
+import org.springframework.data.annotation.LastModifiedDate;
+import org.springframework.data.jpa.domain.support.AuditingEntityListener;
+
+import java.time.LocalDateTime;
+
+@Entity
+@Table(name = "items")
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+@Builder
+@EntityListeners(AuditingEntityListener.class)
+public class Item {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.UUID)
+    private String id;
+
+    @Column(nullable = false)
+    private String name;
+
+    private String description;
+
+    private Double price;
+
+    @CreatedDate
+    @Column(name = "created_at", nullable = false, updatable = false)
+    private LocalDateTime createdAt;
+
+    @LastModifiedDate
+    @Column(name = "updated_at", nullable = false)
+    private LocalDateTime updatedAt;
+}

package/templates/java-spring/mvc/src/main/java/{{packagePath}}/model/User.java.hbs

@@ -0,0 +1,41 @@
+package {{packageName}}.model;
+
+import jakarta.persistence.*;
+import lombok.*;
+import org.springframework.data.annotation.CreatedDate;
+import org.springframework.data.annotation.LastModifiedDate;
+import org.springframework.data.jpa.domain.support.AuditingEntityListener;
+
+import java.time.LocalDateTime;
+
+@Entity
+@Table(name = "users")
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+@Builder
+@EntityListeners(AuditingEntityListener.class)
+public class User {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.UUID)
+    private String id;
+
+    @Column(unique = true, nullable = false)
+    private String email;
+
+    private String name;
+
+    private String password;
+
+    @Column(name = "stripe_customer_id")
+    private String stripeCustomerId;
+
+    @CreatedDate
+    @Column(name = "created_at", nullable = false, updatable = false)
+    private LocalDateTime createdAt;
+
+    @LastModifiedDate
+    @Column(name = "updated_at", nullable = false)
+    private LocalDateTime updatedAt;
+}

package/templates/java-spring/mvc/src/main/java/{{packagePath}}/repository/ItemRepository.java.hbs

@@ -0,0 +1,9 @@
+package {{packageName}}.repository;
+
+import {{packageName}}.model.Item;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+@Repository
+public interface ItemRepository extends JpaRepository<Item, String> {
+}

package/templates/java-spring/mvc/src/main/java/{{packagePath}}/repository/UserRepository.java.hbs

@@ -0,0 +1,13 @@
+package {{packageName}}.repository;
+
+import {{packageName}}.model.User;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+import java.util.Optional;
+
+@Repository
+public interface UserRepository extends JpaRepository<User, String> {
+    Optional<User> findByEmail(String email);
+    Optional<User> findByStripeCustomerId(String stripeCustomerId);
+}

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

@@ -0,0 +1,62 @@
+package {{packageName}}.service;
+
+import {{packageName}}.dto.AuthRequest;
+import {{packageName}}.dto.AuthResponse;
+import {{packageName}}.model.User;
+import {{packageName}}.repository.UserRepository;
+import {{packageName}}.security.JwtTokenProvider;
+import org.springframework.security.crypto.password.PasswordEncoder;
+import org.springframework.stereotype.Service;
+
+import java.util.Optional;
+
+@Service
+public class AuthService {
+
+    private final UserRepository userRepository;
+    private final PasswordEncoder passwordEncoder;
+    private final JwtTokenProvider tokenProvider;
+
+    public AuthService(UserRepository userRepository, PasswordEncoder passwordEncoder, JwtTokenProvider tokenProvider) {
+        this.userRepository = userRepository;
+        this.passwordEncoder = passwordEncoder;
+        this.tokenProvider = tokenProvider;
+    }
+
+    public AuthResponse register(AuthRequest request) {
+        if (userRepository.findByEmail(request.email()).isPresent()) {
+            throw new IllegalArgumentException("User already exists");
+        }
+
+        String hashedPassword = passwordEncoder.encode(request.password());
+
+        User user = User.builder()
+                .email(request.email())
+                .password(hashedPassword)
+                .build();
+
+        user = userRepository.save(user);
+
+        String token = tokenProvider.generateToken(user.getId(), user.getEmail());
+
+        return new AuthResponse(token, user.getId(), user.getEmail());
+    }
+
+    public AuthResponse login(AuthRequest request) {
+        Optional<User> userOptional = userRepository.findByEmail(request.email());
+
+        if (userOptional.isEmpty() || !passwordEncoder.matches(request.password(), userOptional.get().getPassword())) {
+            throw new IllegalArgumentException("Invalid credentials");
+        }
+
+        User user = userOptional.get();
+        String token = tokenProvider.generateToken(user.getId(), user.getEmail());
+
+        return new AuthResponse(token, user.getId(), user.getEmail());
+    }
+
+    public User getMe(String userId) {
+        return userRepository.findById(userId)
+            .orElseThrow(() -> new IllegalArgumentException("User not found"));
+    }
+}

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

@@ -29,18 +29,18 @@ public class StripeService {
 
     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()
-        );
+                .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);
+             paramsBuilder.setCustomer(customerId);
         }
 
         return Session.create(paramsBuilder.build());
@@ -48,20 +48,20 @@ public class StripeService {
 
     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();
+                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();
+                .setEmail(email)
+                .setName(name)
+                .build();
 
         return Customer.create(params);
     }
-}
+}

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

@@ -2,8 +2,10 @@ package {{packageName}};
 
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.data.jpa.repository.config.EnableJpaAuditing;
 
 @SpringBootApplication
+@EnableJpaAuditing
 public class {{projectNamePascalCase}}Application {
 
     public static void main(String[] args) {

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

@@ -7,7 +7,9 @@
     "build": "nest build",
     "start": "node dist/main.js",
     "lint": "eslint \"{src,test}/**/*.ts\"",
-    "test": "jest"
+    "test": "jest",
+    "db:generate": "prisma generate",
+    "db:push": "prisma db push"
   },
   "dependencies": {
     "@nestjs/common": "^10.3.0",
@@ -16,6 +18,7 @@
     "@nestjs/jwt": "^10.2.0",
     "@nestjs/passport": "^10.0.3",
     "@nestjs/platform-express": "^10.3.0",
+    "@prisma/client": "^5.10.2",
     "bcryptjs": "^2.4.3",
     "class-transformer": "^0.5.1",
     "class-validator": "^0.14.1",
@@ -32,6 +35,7 @@
     "@types/node": "^20.11.0",
     "@types/passport-jwt": "^4.0.0",
     "@types/uuid": "^9.0.7",
+    "prisma": "^5.10.2",
     "typescript": "^5.3.3"
   }
-}
+}

package/templates/nestjs/mvc/prisma/schema.prisma.hbs

@@ -0,0 +1,31 @@
+generator client {
+  provider = "prisma-client-js"
+}
+
+datasource db {
+  provider = "postgresql"
+  url      = env("DATABASE_URL")
+}
+
+model User {
+  id               String   @id @default(uuid())
+  email            String   @unique
+  name             String?
+  password         String
+  stripeCustomerId String?  @map("stripe_customer_id")
+  createdAt        DateTime @default(now()) @map("created_at")
+  updatedAt        DateTime @updatedAt @map("updated_at")
+
+  @@map("users")
+}
+
+model Item {
+  id          String   @id @default(uuid())
+  name        String
+  description String?
+  price       Float?
+  createdAt   DateTime @default(now()) @map("created_at")
+  updatedAt   DateTime @updatedAt @map("updated_at")
+
+  @@map("items")
+}

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

@@ -4,14 +4,16 @@ import { ItemsModule } from './modules/items.module';
 import { AuthModule } from './auth/auth.module';
 import { PaymentsModule } from './payments/payments.module';
 import { HealthController } from './controllers/health.controller';
+import { PrismaModule } from './prisma/prisma.module';
 
 @Module({
     imports: [
         ConfigModule.forRoot({ isGlobal: true }),
+        PrismaModule,
         AuthModule,
         PaymentsModule,
         ItemsModule,
     ],
     controllers: [HealthController],
 })
-export class AppModule {}
+export class AppModule {}