kybernus 2.0.10 → 2.1.1

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:

package/templates/nodejs-express/hexagonal/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"
+    "hexagonal-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/hexagonal/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/hexagonal/src/adapters/inbound/http/AuthController.ts.hbs

@@ -1,48 +1,33 @@
-import { Router, Request, Response } from 'express';
-import { IAuthPort } from '../../../core/ports/inbound/IAuthPort';
+import { Request, Response, NextFunction } from 'express';
+import { IAuthService } from '../../../core/ports/inbound/IAuthService';
+import { z } from 'zod';
 
-/**
-* HTTP Auth Controller - Inbound Adapter
-* Adapts HTTP requests to the application port
-*/
-export function createAuthController(authService: IAuthPort): Router {
-    const router = Router();
+const registerSchema = z.object({
+  email: z.string().email(),
+  name: z.string().min(2),
+  password: z.string().min(6),
+});
 
-    router.post('/register', async (req: Request, res: Response) => {
-        try {
-            const { email, name, password } = req.body;
-            const result = await authService.register(email, name, password);
-            res.status(201).json({
-                token: result.token,
-                user: { id: result.user.id, email: result.user.email, name: result.user.name },
-            });
-        } catch (error: any) {
-            res.status(400).json({ error: error.message });
-        }
-    });
+export class AuthController {
+  constructor(private authService: IAuthService) {}
 
-    router.post('/login', async (req: Request, res: Response) => {
-        try {
-            const { email, password } = req.body;
-            const result = await authService.login(email, password);
-            res.json({
-                token: result.token,
-                user: { id: result.user.id, email: result.user.email, name: result.user.name },
-            });
-        } catch (error: any) {
-            res.status(401).json({ error: error.message });
-        }
-    });
+  register = async (req: Request, res: Response, next: NextFunction) => {
+    try {
+      const { email, name, password } = registerSchema.parse(req.body);
+      const result = await this.authService.register(email, name, password);
+      res.status(201).json(result);
+    } catch (error) {
+      next(error);
+    }
+  };
 
-    router.get('/me', async (req: Request, res: Response) => {
-        const token = req.headers.authorization?.split(' ')[1];
-        if (!token) return res.status(401).json({ error: 'No token' });
-
-        const user = await authService.validateToken(token);
-        if (!user) return res.status(401).json({ error: 'Invalid token' });
-
-        res.json({ user: { id: user.id, email: user.email, name: user.name } });
-    });
-
-    return router;
-}
+  login = async (req: Request, res: Response, next: NextFunction) => {
+    try {
+      const { email, password } = req.body;
+      const result = await this.authService.login(email, password);
+      res.json(result);
+    } catch (error) {
+      next(error);
+    }
+  };
+}

package/templates/nodejs-express/hexagonal/src/adapters/inbound/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/hexagonal/src/adapters/outbound/persistence/PrismaUserAdapter.ts.hbs

@@ -0,0 +1,61 @@
+import { User } from '../../../core/domain/entities/User';
+import { IUserRepositoryPort } from '../../../core/ports/outbound/IUserRepositoryPort';
+import { prisma } from './prisma';
+
+export class PrismaUserAdapter implements IUserRepositoryPort {
+  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/hexagonal/src/adapters/outbound/persistence/prisma.ts

@@ -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/hexagonal/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,
+};