kybernus 2.0.10 → 2.1.0

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

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

@@ -1,41 +1,38 @@
+import 'express-async-errors';
 import express from 'express';
 import cors from 'cors';
 import helmet from 'helmet';
 import morgan from 'morgan';
-import dotenv from 'dotenv';
-
-// Core
-import { AuthService } from './core/AuthService';
-
-// Adapters
-import { InMemoryUserAdapter } from './adapters/outbound/persistence/InMemoryUserAdapter';
-import { bcryptAdapter, jwtAdapter } from './adapters/outbound/SecurityAdapters';
-import { createAuthController } from './adapters/inbound/http/AuthController';
-
-dotenv.config();
+import { config } from './config';
+import { PrismaUserAdapter } from './adapters/outbound/persistence/PrismaUserAdapter';
+import { AuthService } from './core/services/AuthService';
+import { AuthController } from './adapters/inbound/http/AuthController';
+import { errorHandler } from './adapters/inbound/http/middlewares/errorHandler';
 
 const app = express();
 
-// Middleware
-app.use(helmet());
+// Middlewares
+app.use(express.json());
 app.use(cors());
+app.use(helmet());
 app.use(morgan('dev'));
-app.use(express.json());
 
-// Dependency Injection - Wire up the hexagon
-const userRepository = new InMemoryUserAdapter();
-const authService = new AuthService(userRepository, bcryptAdapter, jwtAdapter);
+// Dependency Injection
+const userRepository = new PrismaUserAdapter();
+const authService = new AuthService(userRepository);
+const authController = new AuthController(authService);
 
-// Mount adapters
-app.use('/api/auth', createAuthController(authService));
+// Routes
+app.post('/api/auth/register', (req, res, next) => authController.register(req, res, next));
+app.post('/api/auth/login', (req, res, next) => authController.login(req, res, next));
 
-// Health check
-app.get('/health', (_, res) => res.json({ status: 'ok' }));
+app.get('/health', (req, res) => {
+  res.json({ status: 'ok', architecture: 'hexagonal' });
+});
 
-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: Hexagonal (Ports & Adapters)`);
-    console.log(`🔗 Health check: http://localhost:${PORT}/health`);
-});
+app.listen(config.port, () => {
+  console.log(`🚀 Server running on port ${config.port}`);
+});

package/templates/nodejs-express/hexagonal/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/python-fastapi/clean/app/application/services/user_service.py.hbs

@@ -0,0 +1,20 @@
+from typing import Optional
+from app.domain.entities.user import User
+from app.domain.repositories.user_repository import IUserRepository
+from app.domain.usecases.register_user import RegisterUserUseCase, IPasswordHasher, ITokenGenerator
+
+# In Clean Architecture, Services usually orchestrate Use Cases or coordinate cross-domain logic.
+# For simple CRUD, Use Cases might be sufficient, but here is a Service example.
+
+class UserService:
+    def __init__(self, repository: IUserRepository):
+        self.repository = repository
+
+    async def get_user(self, user_id: str) -> Optional[User]:
+        return await self.repository.find_by_id(user_id)
+
+    async def get_user_by_email(self, email: str) -> Optional[User]:
+        return await self.repository.find_by_email(email)
+
+# Note: Registration logic is handled by RegisterUserUseCase, aligning with Clean Architecture 
+# where specific complex actions are Use Cases.

package/templates/python-fastapi/clean/app/config.py.hbs

@@ -0,0 +1,24 @@
+from pydantic_settings import BaseSettings, SettingsConfigDict
+from functools import lru_cache
+
+class Settings(BaseSettings):
+    PROJECT_NAME: str = "{{projectName}}"
+    API_V1_STR: str = "/api/v1"
+    
+    # Database
+    # Use asyncpg for async SQLAlchemy
+    DATABASE_URL: str = "postgresql+asyncpg://postgres:postgres@localhost:5432/{{projectName}}_db"
+    
+    # Security
+    SECRET_KEY: str = "change_this_to_a_secure_random_key"
+    ALGORITHM: str = "HS256"
+    ACCESS_TOKEN_EXPIRE_MINUTES: int = 30
+    
+    # Stripe
+    STRIPE_API_KEY: str | None = None
+
+    model_config = SettingsConfigDict(env_file=".env", case_sensitive=True)
+
+@lru_cache
+def get_settings():
+    return Settings()

package/templates/python-fastapi/clean/app/infrastructure/database/models.py.hbs

@@ -0,0 +1,24 @@
+from sqlalchemy import Column, String, DateTime, Boolean
+from sqlalchemy.sql import func
+from app.infrastructure.database.session import Base
+import uuid
+
+class UserModel(Base):
+    __tablename__ = "users"
+
+    id = Column(String, primary_key=True, index=True, default=lambda: str(uuid.uuid4()))
+    email = Column(String, unique=True, index=True, nullable=False)
+    name = Column(String, nullable=False)
+    password = Column(String, nullable=False)
+    stripe_customer_id = Column(String, nullable=True)
+    created_at = Column(DateTime(timezone=True), server_default=func.now())
+    is_active = Column(Boolean, default=True)
+
+    def to_dict(self):
+        return {
+            "id": self.id,
+            "email": self.email,
+            "name": self.name,
+            "stripe_customer_id": self.stripe_customer_id,
+            "created_at": self.created_at
+        }

package/templates/python-fastapi/clean/app/infrastructure/database/postgres_repository.py.hbs

@@ -0,0 +1,62 @@
+from typing import Optional
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy import select, delete
+from app.domain.repositories.user_repository import IUserRepository
+from app.domain.entities.user import User
+from app.infrastructure.database.models import UserModel
+
+class PostgresUserRepository(IUserRepository):
+    def __init__(self, session: AsyncSession):
+        self.session = session
+
+    def _to_entity(self, model: UserModel) -> User:
+        return User(
+            id=model.id,
+            email=model.email,
+            name=model.name,
+            password=model.password,
+            stripe_customer_id=model.stripe_customer_id,
+            created_at=model.created_at
+        )
+
+    async def find_by_id(self, user_id: str) -> Optional[User]:
+        result = await self.session.execute(select(UserModel).where(UserModel.id == user_id))
+        model = result.scalars().first()
+        return self._to_entity(model) if model else None
+
+    async def find_by_email(self, email: str) -> Optional[User]:
+        result = await self.session.execute(select(UserModel).where(UserModel.email == email))
+        model = result.scalars().first()
+        return self._to_entity(model) if model else None
+
+    async def save(self, user: User) -> User:
+        # Check if exists to decide update vs insert (simplistic approach)
+        # In a real app, optimize this or use merge
+        existing = await self.find_by_id(user.id)
+        
+        if existing:
+            stmt = select(UserModel).where(UserModel.id == user.id)
+            result = await self.session.execute(stmt)
+            model = result.scalars().first()
+            model.email = user.email
+            model.name = user.name
+            model.password = user.password
+            model.stripe_customer_id = user.stripe_customer_id
+        else:
+            model = UserModel(
+                id=user.id,
+                email=user.email,
+                name=user.name,
+                password=user.password,
+                stripe_customer_id=user.stripe_customer_id,
+                created_at=user.created_at
+            )
+            self.session.add(model)
+        
+        await self.session.commit()
+        await self.session.refresh(model)
+        return self._to_entity(model)
+
+    async def delete(self, user_id: str) -> None:
+        await self.session.execute(delete(UserModel).where(UserModel.id == user_id))
+        await self.session.commit()

package/templates/python-fastapi/clean/app/infrastructure/database/session.py.hbs

@@ -0,0 +1,27 @@
+from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession, async_sessionmaker
+from sqlalchemy.orm import DeclarativeBase
+from app.config import get_settings
+
+settings = get_settings()
+
+engine = create_async_engine(
+    settings.DATABASE_URL,
+    echo=True, # Set to False in production
+)
+
+AsyncSessionLocal = async_sessionmaker(
+    bind=engine,
+    class_=AsyncSession,
+    expire_on_commit=False,
+    autoflush=False,
+)
+
+class Base(DeclarativeBase):
+    pass
+
+async def get_db():
+    async with AsyncSessionLocal() as session:
+        try:
+            yield session
+        finally:
+            await session.close()

package/templates/python-fastapi/clean/app/infrastructure/http/auth_controller.py.hbs

@@ -1,16 +1,19 @@
 from fastapi import APIRouter, HTTPException, Depends
 from pydantic import BaseModel, EmailStr
+from sqlalchemy.ext.asyncio import AsyncSession
 from app.domain.usecases.register_user import RegisterUserUseCase
-from app.infrastructure.database.in_memory_repository import InMemoryUserRepository
+from app.infrastructure.database.postgres_repository import PostgresUserRepository
 from app.infrastructure.security.adapters import BcryptHasher, JwtTokenGenerator
+from app.infrastructure.database.session import get_db
 
 router = APIRouter()
 
-# Dependency Injection
-repo = InMemoryUserRepository()
-hasher = BcryptHasher()
-token_gen = JwtTokenGenerator()
-register_usecase = RegisterUserUseCase(repo, hasher, token_gen)
+# Dependency Injection Factory
+def get_register_usecase(db: AsyncSession = Depends(get_db)) -> RegisterUserUseCase:
+    repo = PostgresUserRepository(db)
+    hasher = BcryptHasher()
+    token_gen = JwtTokenGenerator()
+    return RegisterUserUseCase(repo, hasher, token_gen)
 
 class RegisterRequest(BaseModel):
     email: EmailStr
@@ -18,9 +21,12 @@ class RegisterRequest(BaseModel):
     password: str
 
 @router.post("/register")
-async def register(req: RegisterRequest):
+async def register(
+    req: RegisterRequest,
+    usecase: RegisterUserUseCase = Depends(get_register_usecase)
+):
     try:
-        result = await register_usecase.execute(req.email, req.name, req.password)
+        result = await usecase.execute(req.email, req.name, req.password)
         return result
     except ValueError as e:
         raise HTTPException(status_code=400, detail=str(e))

package/templates/python-fastapi/clean/app/main.py.hbs

@@ -1,10 +1,32 @@
+from contextlib import asynccontextmanager
 from fastapi import FastAPI
 from app.infrastructure.http import auth_controller
+from app.config import get_settings
+from app.infrastructure.database.session import engine, Base
 
-app = FastAPI(title="{{projectName}} - Clean Architecture")
+settings = get_settings()
 
-app.include_router(auth_controller.router, prefix="/api/auth", tags=["Auth"])
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    # Create tables on startup (for development)
+    # In production, use Alembic migrations
+    async with engine.begin() as conn:
+        await conn.run_sync(Base.metadata.create_all)
+    yield
+    # Cleanup
+    await engine.dispose()
+
+app = FastAPI(
+    title="{{projectName}} - Clean Architecture",
+    lifespan=lifespan
+)
+
+app.include_router(auth_controller.router, prefix=settings.API_V1_STR + "/auth", tags=["Auth"])
 
 @app.get("/health")
 def health():
-    return {"status": "ok", "architecture": "clean"}
+    return {
+        "status": "ok", 
+        "architecture": "clean",
+        "project": settings.PROJECT_NAME
+    }

package/templates/python-fastapi/clean/requirements.txt.hbs

@@ -1,12 +1,14 @@
 fastapi>=0.109.0
 uvicorn[standard]>=0.27.0
 pydantic>=2.5.0
+pydantic-settings>=2.1.0
 python-dotenv>=1.0.0
 python-jose[cryptography]>=3.3.0
 passlib[bcrypt]>=1.7.4
 stripe>=8.0.0
 sqlalchemy>=2.0.0
 alembic>=1.13.0
+asyncpg>=0.29.0
 psycopg2-binary>=2.9.9
 pytest>=8.0.0
-httpx>=0.26.0
+httpx>=0.26.0