kybernus 2.0.10 → 2.1.0

package/templates/python-fastapi/hexagonal/app/adapters/inbound/http_adapter.py.hbs

@@ -1,6 +1,13 @@
-from fastapi import APIRouter, HTTPException
+from fastapi import APIRouter, HTTPException, Depends
 from pydantic import BaseModel, EmailStr
+from sqlalchemy.ext.asyncio import AsyncSession
 from app.core.ports import IAuthPort
+from app.core.domain.user import User as DomainUser
+from app.infrastructure.database.session import get_db
+from app.infrastructure.database.models import UserModel
+from app.adapters.outbound.postgres_user_repository import PostgresUserRepository 
+from app.core.service import AuthService
+from app.infrastructure.security.adapters import BcryptHasher, JwtTokenGenerator
 
 router = APIRouter()
 
@@ -9,21 +16,38 @@ class RegisterRequest(BaseModel):
     name: str
     password: str
 
+# Dependency Injection Factory
+def get_auth_service(db: AsyncSession = Depends(get_db)) -> IAuthPort:
+    repo = PostgresUserRepository(db)
+    hasher = BcryptHasher()
+    token_gen = JwtTokenGenerator()
+    return AuthService(repo, hasher, token_gen)
+
+@router.post("/register")
+async def register(
+    req: RegisterRequest,
+    service: IAuthPort = Depends(get_auth_service)
+):
+    try:
+        result = await service.register(req.email, req.name, req.password)
+        return result
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+@router.post("/login")
+async def login(
+    req: RegisterRequest,
+    service: IAuthPort = Depends(get_auth_service)
+):
+    try:
+        result = await service.login(req.email, req.password)
+        return result
+    except ValueError as e:
+        raise HTTPException(status_code=401, detail=str(e))
+
+# Setup function for backward compatibility or direct usage 
+# though router is preferred
 def setup_auth_routes(auth_service: IAuthPort):
-    @router.post("/register")
-    async def register(req: RegisterRequest):
-        try:
-            result = await auth_service.register(req.email, req.name, req.password)
-            return result
-        except ValueError as e:
-            raise HTTPException(status_code=400, detail=str(e))
-    
-    @router.post("/login")
-    async def login(req: RegisterRequest):
-        try:
-            result = await auth_service.login(req.email, req.password)
-            return result
-        except ValueError as e:
-            raise HTTPException(status_code=401, detail=str(e))
-    
+    # This pattern is tricky with FastAPIs dependency injection system
+    # It's better to rely on Depends() as implemented above
     return router

package/templates/python-fastapi/hexagonal/app/adapters/outbound/postgres_user_repository.py.hbs

@@ -0,0 +1,50 @@
+from typing import Optional
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy import select
+from app.core.ports import IUserRepositoryPort
+from app.core.domain.user import User
+from app.infrastructure.database.models import UserModel
+
+class PostgresUserRepository(IUserRepositoryPort):
+    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_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:
+        # Simplistic save/update logic
+        result = await self.session.execute(select(UserModel).where(UserModel.id == user.id))
+        model = result.scalars().first()
+        
+        if model:
+            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)

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

@@ -0,0 +1,20 @@
+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
+    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
+
+    model_config = SettingsConfigDict(env_file=".env", case_sensitive=True)
+
+@lru_cache
+def get_settings():
+    return Settings()

package/templates/python-fastapi/hexagonal/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/hexagonal/app/infrastructure/database/session.py.hbs

@@ -0,0 +1,20 @@
+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,
+)
+
+AsyncSessionLocal = async_sessionmaker(
+    bind=engine,
+    class_=AsyncSession,
+    expire_on_commit=False,
+    autoflush=False,
+)
+
+class Base(DeclarativeBase):
+    pass

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

@@ -1,22 +1,30 @@
+from contextlib import asynccontextmanager
 from fastapi import FastAPI
-from app.core.service import AuthService
-from app.adapters.inbound.http_adapter import setup_auth_routes
+from app.adapters.inbound.http_adapter import router as auth_router
+from app.infrastructure.database.session import engine, Base
+from app.config import get_settings
 
-app = FastAPI(title="{{projectName}} - Hexagonal Architecture")
+settings = get_settings()
 
-# Setup dependencies (in production use DI container)
-from app.infrastructure.database import InMemoryUserRepository
-from app.infrastructure.security import BcryptHasher, JwtGenerator
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    # Create tables on startup (for development)
+    async with engine.begin() as conn:
+        await conn.run_sync(Base.metadata.create_all)
+    yield
+    await engine.dispose()
 
-repo = InMemoryUserRepository()
-hasher = BcryptHasher()
-token_gen = JwtGenerator()
-auth_service = AuthService(repo, hasher, token_gen)
+app = FastAPI(
+    title="{{projectName}} - Hexagonal Architecture",
+    lifespan=lifespan
+)
 
-# Setup routes
-auth_router = setup_auth_routes(auth_service)
-app.include_router(auth_router, prefix="/api/auth", tags=["Auth"])
+app.include_router(auth_router, prefix=settings.API_V1_STR + "/auth", tags=["Auth"])
 
 @app.get("/health")
 def health():
-    return {"status": "ok", "architecture": "hexagonal"}
+    return {
+        "status": "ok", 
+        "architecture": "hexagonal",
+        "project": settings.PROJECT_NAME
+    }

package/templates/python-fastapi/hexagonal/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

package/templates/java-spring/clean/src/main/java/{{packagePath}}/infrastructure/persistence/InMemoryUserRepository.java.hbs

@@ -1,41 +0,0 @@
-package {{packageName}}.infrastructure.persistence;
-
-import {{packageName}}.domain.entity.User;
-import {{packageName}}.domain.repository.UserRepository;
-import org.springframework.stereotype.Repository;
-
-import java.util.Map;
-import java.util.Optional;
-import java.util.concurrent.ConcurrentHashMap;
-
-/**
-* In-Memory User Repository - Infrastructure Layer
-* Replace with JPA implementation for production
-*/
-@Repository
-public class InMemoryUserRepository implements UserRepository {
-    private final Map<String, User> users = new ConcurrentHashMap<>();
-
-    @Override
-    public Optional<User> findById(String id) {
-        return Optional.ofNullable(users.get(id));
-    }
-
-    @Override
-    public Optional<User> findByEmail(String email) {
-        return users.values().stream()
-        .filter(user -> user.getEmail().equals(email))
-        .findFirst();
-    }
-
-    @Override
-    public User save(User user) {
-        users.put(user.getId(), user);
-        return user;
-    }
-
-    @Override
-    public void delete(String id) {
-        users.remove(id);
-    }
-}

package/templates/java-spring/hexagonal/src/main/java/{{packagePath}}/infrastructure/persistence/InMemoryUserRepository.java.hbs

@@ -1,41 +0,0 @@
-package {{packageName}}.infrastructure.persistence;
-
-import {{packageName}}.domain.entity.User;
-import {{packageName}}.domain.repository.UserRepository;
-import org.springframework.stereotype.Repository;
-
-import java.util.Map;
-import java.util.Optional;
-import java.util.concurrent.ConcurrentHashMap;
-
-/**
-* In-Memory User Repository - Infrastructure Layer
-* Replace with JPA implementation for production
-*/
-@Repository
-public class InMemoryUserRepository implements UserRepository {
-    private final Map<String, User> users = new ConcurrentHashMap<>();
-
-    @Override
-    public Optional<User> findById(String id) {
-        return Optional.ofNullable(users.get(id));
-    }
-
-    @Override
-    public Optional<User> findByEmail(String email) {
-        return users.values().stream()
-        .filter(user -> user.getEmail().equals(email))
-        .findFirst();
-    }
-
-    @Override
-    public User save(User user) {
-        users.put(user.getId(), user);
-        return user;
-    }
-
-    @Override
-    public void delete(String id) {
-        users.remove(id);
-    }
-}

package/templates/nestjs/clean/src/infrastructure/database/in-memory.repository.ts.hbs

@@ -1,17 +0,0 @@
-import { Injectable } from '@nestjs/common';
-import { IUserRepository } from '../../domain/repositories/user.repository';
-import { User } from '../../domain/entities/user.entity';
-
-@Injectable()
-export class InMemoryUserRepository extends IUserRepository {
-private users: User[] = [];
-
-async findByEmail(email: string): Promise<User | null> {
-    return this.users.find((u) => u.email === email) || null;
-    }
-
-    async save(user: User): Promise<User> {
-        this.users.push(user);
-        return user;
-        }
-        }

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

@@ -1,46 +0,0 @@
-import { User } from '../../domain/entities/User';
-import { IUserRepository } from '../../domain/repositories/IUserRepository';
-
-/**
-* In-Memory User Repository - Infrastructure Layer
-* Replace with actual database implementation (Prisma, TypeORM, etc.)
-*/
-export class InMemoryUserRepository implements IUserRepository {
-    private users: Map<string, User> = new Map();
-
-    async findById(id: string): Promise<User | null> {
-        return this.users.get(id) || null;
-    }
-
-    async findByEmail(email: string): Promise<User | null> {
-        for (const user of this.users.values()) {
-            if (user.email === email) {
-                return user;
-            }
-        }
-        return null;
-    }
-
-    async save(user: User): Promise<User> {
-        const id = Date.now().toString();
-        const savedUser = User.restore({
-            id,
-            email: user.email,
-            name: user.name,
-            password: user.password,
-            stripeCustomerId: user.stripeCustomerId,
-        });
-        this.users.set(id, savedUser);
-        return savedUser;
-    }
-
-    async update(user: User): Promise<User> {
-        if (!user.id) throw new Error('User must have an ID to update');
-        this.users.set(user.id, user);
-        return user;
-    }
-
-    async delete(id: string): Promise<void> {
-        this.users.delete(id);
-    }
-}

package/templates/nodejs-express/hexagonal/src/adapters/outbound/persistence/InMemoryUserAdapter.ts.hbs

@@ -1,38 +0,0 @@
-import { User } from '../../core/domain/entities/User';
-import { IUserRepositoryPort } from '../../core/ports/outbound/IUserRepositoryPort';
-
-/**
-* In-Memory User Repository Adapter
-* Implements the outbound port
-*/
-export class InMemoryUserAdapter implements IUserRepositoryPort {
-    private users: Map<string, User> = new Map();
-
-    async findById(id: string): Promise<User | null> {
-        return this.users.get(id) || null;
-    }
-
-    async findByEmail(email: string): Promise<User | null> {
-        for (const user of this.users.values()) {
-            if (user.email === email) return user;
-        }
-        return null;
-    }
-
-    async save(user: User): Promise<User> {
-        const id = Date.now().toString();
-        const savedUser = user.withId(id);
-        this.users.set(id, savedUser);
-        return savedUser;
-    }
-
-    async update(user: User): Promise<User> {
-        if (!user.id) throw new Error('User must have an ID');
-        this.users.set(user.id, user);
-        return user;
-    }
-
-    async delete(id: string): Promise<void> {
-        this.users.delete(id);
-    }
-}