kybernus 2.1.0 → 2.2.0

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 {}

package/templates/nestjs/mvc/src/auth/auth.service.ts.hbs

@@ -1,43 +1,46 @@
-import { Injectable } from '@nestjs/common';
+import { Injectable, UnauthorizedException, BadRequestException } from '@nestjs/common';
 import { JwtService } from '@nestjs/jwt';
 import * as bcrypt from 'bcryptjs';
-
-interface User {
-    id: string;
-    email: string;
-    name: string;
-    password: string;
-}
+import { PrismaService } from '../prisma/prisma.service';
 
 @Injectable()
 export class AuthService {
-    private users: Map<string, User> = new Map();
-
-    constructor(private jwtService: JwtService) {}
+    constructor(
+        private jwtService: JwtService,
+        private prisma: PrismaService,
+    ) {}
 
     async register(email: string, name: string, password: string) {
-        if (this.users.has(email)) {
-            throw new Error('User already exists');
+        const existingUser = await this.prisma.user.findUnique({
+            where: { email },
+        });
+
+        if (existingUser) {
+            throw new BadRequestException('User already exists');
         }
 
         const hashedPassword = await bcrypt.hash(password, 10);
-        const user: User = {
-            id: Date.now().toString(),
-            email,
-            name,
-            password: hashedPassword,
-        };
-
-        this.users.set(email, user);
+        
+        const user = await this.prisma.user.create({
+            data: {
+                email,
+                name,
+                password: hashedPassword,
+            },
+        });
+
         const token = this.jwtService.sign({ sub: user.id, email: user.email });
 
         return { token, user: { id: user.id, email: user.email, name: user.name } };
     }
 
     async login(email: string, password: string) {
-        const user = this.users.get(email);
-        if (!user || !(await bcrypt.compare(password, user.password))) {
-            throw new Error('Invalid credentials');
+        const user = await this.prisma.user.findUnique({
+            where: { email },
+        });
+
+        if (users || !(await bcrypt.compare(password, user.password))) {
+            throw new UnauthorizedException('Invalid credentials');
         }
 
         const token = this.jwtService.sign({ sub: user.id, email: user.email });
@@ -45,11 +48,11 @@ export class AuthService {
     }
 
     async validateUser(userId: string) {
-        for (const user of this.users.values()) {
-            if (user.id === userId) {
-                return { id: user.id, email: user.email, name: user.name };
-            }
-        }
-        return null;
+        const user = await this.prisma.user.findUnique({
+            where: { id: userId },
+            select: { id: true, email: true, name: true }
+        });
+        
+        return user;
     }
-}
+}

package/templates/nestjs/mvc/src/payments/payments.service.ts.hbs

@@ -1,12 +1,16 @@
 import { Injectable } from '@nestjs/common';
 import { ConfigService } from '@nestjs/config';
 import Stripe from 'stripe';
+import { PrismaService } from '../prisma/prisma.service';
 
 @Injectable()
 export class PaymentsService {
     private stripe: Stripe;
 
-    constructor(private configService: ConfigService) {
+    constructor(
+        private configService: ConfigService,
+        private prisma: PrismaService,
+    ) {
         this.stripe = new Stripe(configService.get('STRIPE_SECRET_KEY', ''), {
             apiVersion: '2024-12-18.acacia',
         });
@@ -31,13 +35,29 @@ export class PaymentsService {
 
         switch (event.type) {
             case 'checkout.session.completed':
-            console.log('Checkout completed:', event.data.object);
-            break;
+                {
+                    const session = event.data.object as Stripe.Checkout.Session;
+                    console.log('Checkout completed:', session.id);
+                    // Match the session back to the user via client_reference_id or customer email
+                    // await this.prisma.user.update({...});
+                }
+                break;
             case 'customer.subscription.updated':
-            console.log('Subscription updated:', event.data.object);
-            break;
+                {
+                    const subscription = event.data.object as Stripe.Subscription;
+                    console.log('Subscription updated:', subscription.id);
+                    // Update user's subscription status in DB
+                }
+                break;
+            case 'customer.subscription.deleted':
+                {
+                    const subscription = event.data.object as Stripe.Subscription;
+                    console.log('Subscription deleted:', subscription.id);
+                    // Cancel user's subscription in DB
+                }
+                break;
         }
 
         return { received: true };
     }
-}
+}

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

@@ -0,0 +1,9 @@
+import { Global, Module } from '@nestjs/common';
+import { PrismaService } from './prisma.service';
+
+@Global()
+@Module({
+  providers: [PrismaService],
+  exports: [PrismaService],
+})
+export class PrismaModule {}

package/templates/nestjs/mvc/src/prisma/prisma.service.ts.hbs

@@ -0,0 +1,15 @@
+import { Injectable, OnModuleInit, INestApplication } from '@nestjs/common';
+import { PrismaClient } from '@prisma/client';
+
+@Injectable()
+export class PrismaService extends PrismaClient implements OnModuleInit {
+  async onModuleInit() {
+    await this.$connect();
+  }
+
+  async enableShutdownHooks(app: INestApplication) {
+    this.$on('beforeExit', async () => {
+      await app.close();
+    });
+  }
+}

package/templates/nestjs/mvc/src/services/items.service.ts.hbs

@@ -1,32 +1,45 @@
-import { Injectable } from '@nestjs/common';
+import { Injectable, NotFoundException } from '@nestjs/common';
+import { PrismaService } from '../prisma/prisma.service';
 import { CreateItemDto } from '../models/create-item.dto';
-import { Item } from '../models/item.model';
-import { v4 as uuidv4 } from 'uuid';
 
 @Injectable()
 export class ItemsService {
-    private items: Map<string, Item> = new Map();
+    constructor(private prisma: PrismaService) {}
 
-    findAll(): Item[] {
-        return Array.from(this.items.values());
+    async findAll() {
+        return this.prisma.item.findMany();
     }
 
-    findOne(id: string): Item | undefined {
-        return this.items.get(id);
+    async findOne(id: string) {
+        const item = await this.prisma.item.findUnique({
+            where: { id },
+        });
+        
+        if (!item) {
+            throw new NotFoundException('Item not found');
+        }
+        
+        return item;
     }
 
-    create(dto: CreateItemDto): Item {
-        const item: Item = {
-            id: uuidv4(),
-            name: dto.name,
-            description: dto.description,
-            createdAt: new Date(),
-        };
-        this.items.set(item.id, item);
-        return item;
+    async create(createItemDto: CreateItemDto) {
+        return this.prisma.item.create({
+            data: {
+                name: createItemDto.name,
+                description: createItemDto.description,
+                price: createItemDto.price,
+            },
+        });
     }
 
-    remove(id: string): boolean {
-        return this.items.delete(id);
+    async remove(id: string) {
+        try {
+            await this.prisma.item.delete({
+                where: { id },
+            });
+            return true;
+        } catch (error) {
+            return false;
+        }
     }
-}
+}

package/templates/nextjs/mvc/package.json.hbs

@@ -16,6 +16,7 @@
     "react": "^18.0.0",
     "react-dom": "^18.0.0",
     "@prisma/client": "^5.10.2",
+    "@auth/prisma-adapter": "^1.5.0",
     "next-auth": "^4.24.6",
     "stripe": "^14.14.0",
     "zod": "^3.22.4",

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

@@ -8,14 +8,68 @@ datasource db {
 }
 
 model User {
-  id               String   @id @default(uuid())
-  email            String   @unique
+  id               String    @id @default(uuid())
+  email            String    @unique
   name             String?
-  password         String?  // Optional for OAuth, required for credentials
-  stripeCustomerId String?  @map("stripe_customer_id")
+  password         String?   // Optional for OAuth, required for credentials
+  stripeCustomerId String?   @map("stripe_customer_id")
   image            String?
-  createdAt        DateTime @default(now()) @map("created_at")
-  updatedAt        DateTime @updatedAt @map("updated_at")
+  emailVerified    DateTime? @map("email_verified")
+  createdAt        DateTime  @default(now()) @map("created_at")
+  updatedAt        DateTime  @updatedAt @map("updated_at")
+
+  accounts         Account[]
+  sessions         Session[]
 
   @@map("users")
 }
+
+model Account {
+  id                String  @id @default(uuid())
+  userId            String  @map("user_id")
+  type              String
+  provider          String
+  providerAccountId String  @map("provider_account_id")
+  refresh_token     String? @db.Text
+  access_token      String? @db.Text
+  expires_at        Int?
+  token_type        String?
+  scope             String?
+  id_token          String? @db.Text
+  session_state     String?
+
+  user User @relation(fields: [userId], references: [id], onDelete: Cascade)
+
+  @@unique([provider, providerAccountId])
+  @@map("accounts")
+}
+
+model Session {
+  id           String   @id @default(uuid())
+  sessionToken String   @unique @map("session_token")
+  userId       String   @map("user_id")
+  expires      DateTime
+  user         User     @relation(fields: [userId], references: [id], onDelete: Cascade)
+
+  @@map("sessions")
+}
+
+model VerificationToken {
+  identifier String
+  token      String   @unique
+  expires    DateTime
+
+  @@unique([identifier, token])
+  @@map("verification_tokens")
+}
+
+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")
+}