kybernus 2.0.10 → 2.1.0

package/templates/nestjs/hexagonal/src/adapters/outbound/persistence/prisma.service.ts.hbs

@@ -0,0 +1,13 @@
+import { Injectable, OnModuleInit, OnModuleDestroy } from '@nestjs/common';
+import { PrismaClient } from '@prisma/client';
+
+@Injectable()
+export class PrismaService extends PrismaClient implements OnModuleInit, OnModuleDestroy {
+  async onModuleInit() {
+    await this.$connect();
+  }
+
+  async onModuleDestroy() {
+    await this.$disconnect();
+  }
+}

package/templates/nestjs/hexagonal/src/adapters/outbound/persistence/prisma.user.adapter.ts.hbs

@@ -0,0 +1,32 @@
+import { Injectable } from '@nestjs/common';
+import { IUserRepositoryPort } from '../../../../core/ports/ports';
+import { User } from '../../../../core/domain/user.entity';
+import { PrismaService } from './prisma.service';
+
+@Injectable()
+export class PrismaUserAdapter implements IUserRepositoryPort {
+  constructor(private prisma: PrismaService) {}
+
+  async findByEmail(email: string): Promise<User | null> {
+    const user = await this.prisma.user.findUnique({ where: { email } });
+    if (!user) return null;
+    return new User(user.id, user.name, user.email, user.password);
+  }
+
+  async save(user: User): Promise<User> {
+    const savedUser = await this.prisma.user.upsert({
+      where: { email: user.email },
+      update: {
+        name: user.name,
+        password: user.password,
+      },
+      create: {
+        id: user.id,
+        name: user.name,
+        email: user.email,
+        password: user.password,
+      },
+    });
+    return new User(savedUser.id, savedUser.name, savedUser.email, savedUser.password);
+  }
+}

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

@@ -0,0 +1,17 @@
+import { Module } from '@nestjs/common';
+import { ConfigModule } from '@nestjs/config';
+import { AuthModule } from './auth.module';
+import { PrismaService } from './adapters/outbound/persistence/prisma.service';
+
+@Module({
+  imports: [
+    ConfigModule.forRoot({
+      isGlobal: true,
+    }),
+    AuthModule,
+  ],
+  controllers: [],
+  providers: [PrismaService],
+  exports: [PrismaService],
+})
+export class AppModule {}

package/templates/nestjs/hexagonal/src/auth.module.ts.hbs

@@ -1,19 +1,21 @@
 import { Module } from '@nestjs/common';
 import { AuthService } from './core/auth.service';
 import { HttpAdapter } from './adapters/inbound/http.adapter';
-import { PersistenceAdapter } from './adapters/outbound/persistence.adapter';
+import { PrismaUserAdapter } from './adapters/outbound/persistence/prisma.user.adapter';
+import { PrismaService } from './adapters/outbound/persistence/prisma.service';
 
 @Module({
-    providers: [
-        {
-            provide: 'IAuthPort',
-            useClass: AuthService,
-        },
-        {
-            provide: 'IUserRepositoryPort',
-            useClass: PersistenceAdapter,
-        },
-    ],
-    controllers: [HttpAdapter],
+  providers: [
+    PrismaService,
+    {
+      provide: 'IAuthPort',
+      useClass: AuthService,
+    },
+    {
+      provide: 'IUserRepositoryPort',
+      useClass: PrismaUserAdapter,
+    },
+  ],
+  controllers: [HttpAdapter],
 })
-export class AuthModule {}
+export class AuthModule {}

package/templates/nestjs/hexagonal/src/main.ts.hbs

@@ -0,0 +1,11 @@
+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.useGlobalPipes(new ValidationPipe({ whitelist: true, transform: true }));
+  app.enableCors();
+  await app.listen(process.env.PORT || 3000);
+}
+bootstrap();

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

@@ -1,34 +1,37 @@
 {
-"name": "{{kebabCase projectName}}",
-"version": "1.0.0",
-"private": true,
-"scripts": {
-"dev": "next dev",
-"build": "next build",
-"start": "next start",
-"lint": "next lint",
-"db:generate": "prisma generate",
-"db:push": "prisma db push",
-"db:studio": "prisma studio"
-},
-"dependencies": {
-"next": "^16.0.0",
-"react": "^19.0.0",
-"react-dom": "^19.0.0",
-"@prisma/client": "^5.9.0",
-"next-auth": "^4.24.5",
-"stripe": "^14.14.0"
-},
-"devDependencies": {
-"@types/node": "^20.11.0",
-"@types/react": "^19.0.0",
-"@types/react-dom": "^19.0.0",
-"autoprefixer": "^10.4.17",
-"eslint": "^9.0.0",
-"eslint-config-next": "^16.0.0",
-"postcss": "^8.4.33",
-"prisma": "^5.9.0",
-"tailwindcss": "^3.4.1",
-"typescript": "^5.3.3"
+  "name": "{{kebabCase projectName}}",
+  "version": "1.0.0",
+  "private": true,
+  "scripts": {
+    "dev": "next dev",
+    "build": "next build",
+    "start": "next start",
+    "lint": "next lint",
+    "db:generate": "prisma generate",
+    "db:push": "prisma db push",
+    "db:studio": "prisma studio"
+  },
+  "dependencies": {
+    "next": "^16.0.0",
+    "react": "^18.0.0",
+    "react-dom": "^18.0.0",
+    "@prisma/client": "^5.10.2",
+    "next-auth": "^4.24.6",
+    "stripe": "^14.14.0",
+    "zod": "^3.22.4",
+    "bcryptjs": "^2.4.3"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.19",
+    "@types/react": "^18.2.57",
+    "@types/react-dom": "^18.2.19",
+    "@types/bcryptjs": "^2.4.6",
+    "autoprefixer": "^10.4.17",
+    "eslint": "^8.56.0",
+    "eslint-config-next": "14.1.0",
+    "postcss": "^8.4.33",
+    "prisma": "^5.10.2",
+    "tailwindcss": "^3.4.1",
+    "typescript": "^5.3.3"
+  }
 }
-}

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

@@ -7,12 +7,15 @@ datasource db {
   url      = env("DATABASE_URL")
 }
 
-// Add your models here
-// Example:
-// model User {
-//   id        Int      @id @default(autoincrement())
-//   email     String   @unique
-//   name      String?
-//   createdAt DateTime @default(now())
-//   updatedAt DateTime @updatedAt
-// }
+model User {
+  id               String   @id @default(uuid())
+  email            String   @unique
+  name             String?
+  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")
+
+  @@map("users")
+}

package/templates/nextjs/mvc/src/lib/db.ts

@@ -0,0 +1,15 @@
+import { PrismaClient } from '@prisma/client';
+
+const prismaClientSingleton = () => {
+  return new PrismaClient();
+};
+
+type PrismaClientSingleton = ReturnType<typeof prismaClientSingleton>;
+
+const globalForPrisma = globalThis as unknown as {
+  prisma: PrismaClientSingleton | undefined;
+};
+
+export const db = globalForPrisma.prisma ?? prismaClientSingleton();
+
+if (process.env.NODE_ENV !== 'production') globalForPrisma.prisma = db;

package/templates/nodejs-express/clean/docker-compose.yml.hbs

@@ -1,18 +1,17 @@
 version: '3.8'
 
 services:
-  postgres:
+  db:
     image: postgres:15-alpine
-    container_name: {{kebabCase projectName}}-db
+    restart: always
     environment:
       POSTGRES_USER: postgres
-      POSTGRES_PASSWORD: postgres
-      POSTGRES_DB: {{snakeCase projectName}}
+      POSTGRES_PASSWORD: password
+      POSTGRES_DB: {{kebabCase projectName}}_db
     ports:
-      - "5432:5432"
+      - '5432:5432'
     volumes:
       - postgres_data:/var/lib/postgresql/data
-    restart: unless-stopped
 
 volumes:
   postgres_data:

package/templates/nodejs-express/clean/package.json.hbs

@@ -9,16 +9,18 @@
     "start": "node dist/index.js",
     "lint": "eslint src --ext .ts",
     "format": "prettier --write \"src/**/*.ts\"",
-    "test": "jest"
+    "test": "jest",
+    "migrate:dev": "prisma migrate dev",
+    "migrate:deploy": "prisma migrate deploy",
+    "generate": "prisma generate"
   },
   "keywords": [
     "express",
     "api",
     "typescript",
-    "mvc",
-    "saas",
-    "stripe",
-    "auth"
+    "clean-architecture",
+    "prisma",
+    "zod"
   ],
   "author": "",
   "license": "MIT",
@@ -30,7 +32,10 @@
     "morgan": "^1.10.0",
     "jsonwebtoken": "^9.0.2",
     "bcryptjs": "^2.4.3",
-    "stripe": "^14.14.0"
+    "stripe": "^14.14.0",
+    "zod": "^3.22.4",
+    "express-async-errors": "^3.1.1",
+    "@prisma/client": "^5.10.2"
   },
   "devDependencies": {
     "@types/express": "^4.17.21",
@@ -47,9 +52,10 @@
     "@typescript-eslint/parser": "^6.21.0",
     "prettier": "^3.2.5",
     "jest": "^29.7.0",
-    "@types/jest": "^29.5.12"
+    "@types/jest": "^29.5.12",
+    "prisma": "^5.10.2"
   },
   "engines": {
     "node": ">=18.0.0"
   }
-}
+}

package/templates/nodejs-express/clean/prisma/schema.prisma

@@ -0,0 +1,20 @@
+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")
+}

package/templates/nodejs-express/clean/src/config/index.ts

@@ -0,0 +1,27 @@
+import dotenv from 'dotenv';
+import { z } from 'zod';
+
+dotenv.config();
+
+const envSchema = z.object({
+  NODE_ENV: z.enum(['development', 'production', 'test']).default('development'),
+  PORT: z.string().default('3000'),
+  DATABASE_URL: z.string(),
+  JWT_SECRET: z.string().min(10),
+  STRIPE_SECRET_KEY: z.string().optional(),
+});
+
+const _env = envSchema.safeParse(process.env);
+
+if (!_env.success) {
+  console.error('❌ Invalid environment variables:', _env.error.format());
+  throw new Error('Invalid environment variables');
+}
+
+export const config = {
+  env: _env.data.NODE_ENV,
+  port: parseInt(_env.data.PORT, 10),
+  databaseUrl: _env.data.DATABASE_URL,
+  jwtSecret: _env.data.JWT_SECRET,
+  stripeSecretKey: _env.data.STRIPE_SECRET_KEY,
+};

package/templates/nodejs-express/clean/src/index.ts.hbs

@@ -1,40 +1,36 @@
+import 'express-async-errors';
 import express from 'express';
 import cors from 'cors';
 import helmet from 'helmet';
 import morgan from 'morgan';
-import dotenv from 'dotenv';
-
-import authRoutes from './infrastructure/http/controllers/AuthController';
-
-dotenv.config();
+import { config } from './config';
+import { PrismaUserRepository } from './infrastructure/database/PrismaUserRepository';
+import { AuthController } from './infrastructure/http/controllers/AuthController';
+import { errorHandler } from './infrastructure/http/middlewares/errorHandler';
 
 const app = express();
 
-// Security
-app.use(helmet());
+// Middlewares
+app.use(express.json());
 app.use(cors());
+app.use(helmet());
 app.use(morgan('dev'));
 
-// Body parsing
-app.use(express.json());
-app.use(express.urlencoded({ extended: true }));
-
-// Health check
-app.get('/health', (_, res) => res.json({ status: 'ok' }));
+// Dependency Injection
+const userRepository = new PrismaUserRepository();
+const authController = new AuthController(userRepository);
 
 // Routes
-app.use('/api/auth', authRoutes);
+app.post('/api/auth/register', authController.register);
+app.post('/api/auth/login', authController.login);
 
-// Error handling
-app.use((err: any, req: express.Request, res: express.Response, next: express.NextFunction) => {
-    console.error(err.stack);
-    res.status(500).json({ error: 'Internal server error' });
+app.get('/health', (req, res) => {
+  res.json({ status: 'ok', architecture: 'clean' });
 });
 
-const PORT = process.env.PORT || 3000;
+// Error Handler
+app.use(errorHandler);
 
-app.listen(PORT, () => {
-    console.log(`🚀 {{pascalCase projectName}} running on port ${PORT}`);
-    console.log(`📐 Architecture: Clean Architecture`);
-    console.log(`🔗 Health check: http://localhost:${PORT}/health`);
-});
+app.listen(config.port, () => {
+  console.log(`🚀 Server running on port ${config.port}`);
+});

package/templates/nodejs-express/clean/src/infrastructure/database/PrismaUserRepository.ts.hbs

@@ -0,0 +1,61 @@
+import { IUserRepository } from '../../domain/repositories/IUserRepository';
+import { User } from '../../domain/entities/User';
+import { prisma } from './prisma';
+
+export class PrismaUserRepository implements IUserRepository {
+  async findById(id: string): Promise<User | null> {
+    const user = await prisma.user.findUnique({ where: { id } });
+    if (!user) return null;
+    return User.restore({
+      id: user.id,
+      email: user.email,
+      name: user.name,
+      password: user.password,
+      stripeCustomerId: user.stripeCustomerId,
+    });
+  }
+
+  async findByEmail(email: string): Promise<User | null> {
+    const user = await prisma.user.findUnique({ where: { email } });
+    if (!user) return null;
+    return User.restore({
+      id: user.id,
+      email: user.email,
+      name: user.name,
+      password: user.password,
+      stripeCustomerId: user.stripeCustomerId,
+    });
+  }
+
+  async save(user: User): Promise<User> {
+    const data = {
+      id: user.id,
+      email: user.email,
+      name: user.name,
+      password: user.password,
+      stripeCustomerId: user.stripeCustomerId,
+    };
+
+    const savedUser = await prisma.user.upsert({
+      where: { id: user.id || '' },
+      update: { ...data },
+      create: { ...data },
+    });
+
+    return User.restore({
+      id: savedUser.id,
+      email: savedUser.email,
+      name: savedUser.name,
+      password: savedUser.password,
+      stripeCustomerId: savedUser.stripeCustomerId,
+    });
+  }
+
+  async update(user: User): Promise<User> {
+     return this.save(user);
+  }
+
+  async delete(id: string): Promise<void> {
+    await prisma.user.delete({ where: { id } });
+  }
+}

package/templates/nodejs-express/clean/src/infrastructure/database/prisma.ts.hbs

@@ -0,0 +1,5 @@
+import { PrismaClient } from '@prisma/client';
+
+export const prisma = new PrismaClient({
+  log: process.env.NODE_ENV === 'development' ? ['query', 'error', 'warn'] : ['error'],
+});

package/templates/nodejs-express/clean/src/infrastructure/http/controllers/AuthController.ts.hbs

@@ -1,45 +1,29 @@
-import { Router, Request, Response } from 'express';
-import { AuthService } from '../../../application/services/AuthService';
-import { InMemoryUserRepository } from '../../database/InMemoryUserRepository';
-import { bcryptPasswordHasher } from '../../providers/PasswordHasher';
-import { jwtTokenGenerator } from '../../providers/TokenGenerator';
-import { authMiddleware, AuthRequest } from '../middlewares/AuthMiddleware';
+import { Request, Response } from 'express';
+import { RegisterUserUseCase } from '../../../domain/usecases/RegisterUserUseCase';
+import { LoginUserUseCase } from '../../../domain/usecases/LoginUserUseCase';
+import { z } from 'zod';
 
-const router = Router();
-
-// Dependency Injection
-const userRepository = new InMemoryUserRepository();
-const authService = new AuthService(userRepository, bcryptPasswordHasher, jwtTokenGenerator);
-
-/**
-* @route POST /api/auth/register
-*/
-router.post('/register', async (req: Request, res: Response) => {
-    try {
-        const result = await authService.register(req.body);
-        res.status(201).json(result);
-    } catch (error: any) {
-        res.status(400).json({ error: error.message });
-    }
+const registerSchema = z.object({
+  email: z.string().email(),
+  name: z.string().min(2),
+  password: z.string().min(6),
 });
 
-/**
-* @route POST /api/auth/login
-*/
-router.post('/login', async (req: Request, res: Response) => {
-    try {
-        const result = await authService.login(req.body);
-        res.json(result);
-    } catch (error: any) {
-        res.status(401).json({ error: error.message });
-    }
-});
+export class AuthController {
+  constructor(
+    private registerUseCase: RegisterUserUseCase,
+    private loginUseCase: LoginUserUseCase
+  ) {}
 
-/**
-* @route GET /api/auth/me
-*/
-router.get('/me', authMiddleware, (req: AuthRequest, res: Response) => {
-    res.json({ user: req.user });
-});
+  register = async (req: Request, res: Response) => {
+    const { email, name, password } = registerSchema.parse(req.body);
+    const result = await this.registerUseCase.execute({ email, name, password });
+    res.status(201).json(result);
+  };
 
-export default router;
+  login = async (req: Request, res: Response) => {
+    const { email, password } = req.body;
+    const result = await this.loginUseCase.execute({ email, password });
+    res.json(result);
+  };
+}

package/templates/nodejs-express/clean/src/infrastructure/http/middlewares/errorHandler.ts

@@ -0,0 +1,24 @@
+import { Request, Response, NextFunction } from 'express';
+import { ZodError } from 'zod';
+
+export function errorHandler(
+  err: Error,
+  req: Request,
+  res: Response,
+  next: NextFunction
+) {
+  console.error(err);
+
+  if (err instanceof ZodError) {
+    return res.status(400).json({
+      error: 'Validation Error',
+      details: err.format(),
+    });
+  }
+
+  if (err.message === 'User already exists' || err.message === 'Invalid credentials') {
+    return res.status(400).json({ error: err.message });
+  }
+
+  res.status(500).json({ error: 'Internal Server Error' });
+}

package/templates/nodejs-express/clean/tsconfig.json.hbs

@@ -1,27 +1,18 @@
 {
   "compilerOptions": {
-    "target": "ES2022",
+    "target": "es2020",
     "module": "commonjs",
-    "lib": [
-      "ES2022"
-    ],
+    "lib": ["es2020"],
     "outDir": "./dist",
     "rootDir": "./src",
     "strict": true,
     "esModuleInterop": true,
     "skipLibCheck": true,
     "forceConsistentCasingInFileNames": true,
-    "resolveJsonModule": true,
-    "moduleResolution": "node",
-    "types": [
-      "node"
-    ]
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true,
+    "resolveJsonModule": true
   },
-  "include": [
-    "src/**/*"
-  ],
-  "exclude": [
-    "node_modules",
-    "dist"
-  ]
-}
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "**/*.spec.ts", "**/*.test.ts"]
+}

package/templates/nodejs-express/hexagonal/docker-compose.yml.hbs

@@ -1,18 +1,17 @@
 version: '3.8'
 
 services:
-  postgres:
+  db:
     image: postgres:15-alpine
-    container_name: {{kebabCase projectName}}-db
+    restart: always
     environment:
       POSTGRES_USER: postgres
-      POSTGRES_PASSWORD: postgres
-      POSTGRES_DB: {{snakeCase projectName}}
+      POSTGRES_PASSWORD: password
+      POSTGRES_DB: {{kebabCase projectName}}_db
     ports:
-      - "5432:5432"
+      - '5432:5432'
     volumes:
       - postgres_data:/var/lib/postgresql/data
-    restart: unless-stopped
 
 volumes:
   postgres_data: