kybernus 3.0.1 → 3.2.0

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

@@ -2,25 +2,48 @@ 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.domain.usecases.login_user import LoginUserUseCase
 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 Factory
+
+class RegisterRequest(BaseModel):
+    email: EmailStr
+    name: str
+    password: str
+
+class LoginRequest(BaseModel):
+    email: EmailStr
+    password: str
+
+class UserResponse(BaseModel):
+    id: str
+    email: str
+    name: str
+
+class AuthResponse(BaseModel):
+    user: UserResponse
+    token: str
+
+
+# Dependency Injection Factories
 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
-    name: str
-    password: str
+def get_login_usecase(db: AsyncSession = Depends(get_db)) -> LoginUserUseCase:
+    repo = PostgresUserRepository(db)
+    hasher = BcryptHasher()
+    token_gen = JwtTokenGenerator()
+    return LoginUserUseCase(repo, hasher, token_gen)
 
-@router.post("/register")
+
+@router.post("/register", response_model=AuthResponse)
 async def register(
     req: RegisterRequest,
     usecase: RegisterUserUseCase = Depends(get_register_usecase)
@@ -30,3 +53,14 @@ async def register(
         return result
     except ValueError as e:
         raise HTTPException(status_code=400, detail=str(e))
+
+@router.post("/login", response_model=AuthResponse)
+async def login(
+    req: LoginRequest,
+    usecase: LoginUserUseCase = Depends(get_login_usecase)
+):
+    try:
+        result = await usecase.execute(req.email, req.password)
+        return result
+    except ValueError as e:
+        raise HTTPException(status_code=401, detail=str(e))

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

@@ -1,16 +1,17 @@
 from fastapi import APIRouter, HTTPException, Header, Request, Depends
 from pydantic import BaseModel
+from sqlalchemy.ext.asyncio import AsyncSession
 from app.application.services.payment_service import PaymentService
-from app.infrastructure.database.session import AsyncSessionLocal
-from app.infrastructure.database.user_repository import SQLAlchemyUserRepository
+from app.infrastructure.database.session import get_db
+from app.infrastructure.database.postgres_repository import PostgresUserRepository
 from app.infrastructure.stripe_provider import StripeProvider
 from app.infrastructure.security.jwt import get_current_user_id
 
 router = APIRouter()
 
 
-def get_payment_service() -> PaymentService:
-    repo = SQLAlchemyUserRepository(AsyncSessionLocal())
+def get_payment_service(db: AsyncSession = Depends(get_db)) -> PaymentService:
+    repo = PostgresUserRepository(db)
     provider = StripeProvider()
     return PaymentService(user_repository=repo, stripe_provider=provider)
 

package/templates/python-fastapi/clean/app/infrastructure/security/jwt.py.hbs

@@ -0,0 +1,23 @@
+from fastapi import HTTPException, Security
+from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
+from jose import jwt, JWTError
+import os
+
+security = HTTPBearer()
+
+SECRET_KEY = os.getenv("JWT_SECRET", "secret")
+ALGORITHM = "HS256"
+
+
+def get_current_user_id(
+    credentials: HTTPAuthorizationCredentials = Security(security),
+) -> str:
+    try:
+        token = credentials.credentials
+        payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
+        user_id: str = payload.get("sub")
+        if user_id is None:
+            raise HTTPException(status_code=401, detail="Invalid authentication credentials")
+        return user_id
+    except JWTError:
+        raise HTTPException(status_code=401, detail="Invalid authentication credentials")

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

@@ -1,3 +1,6 @@
+from dotenv import load_dotenv
+load_dotenv()
+
 from contextlib import asynccontextmanager
 from fastapi import FastAPI
 from app.infrastructure.http import auth_controller, payment_controller

package/templates/python-fastapi/clean/docker-compose.yml.hbs

@@ -1,16 +1,4 @@
-version: '3.8'
-
 services:
-  app:
-    build: .
-    container_name: {{kebabCase projectName}}-app
-    ports:
-      - "8000:8000"
-    environment:
-      - DATABASE_URL=postgresql://postgres:postgres@db:5432/{{snakeCase projectName}}
-    depends_on:
-      - db
-
   db:
     image: postgres:15-alpine
     container_name: {{kebabCase projectName}}-db
@@ -23,6 +11,11 @@ services:
     volumes:
       - postgres_data:/var/lib/postgresql/data
     restart: unless-stopped
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U postgres"]
+      interval: 10s
+      timeout: 5s
+      retries: 5
 
 volumes:
   postgres_data:

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

@@ -1,10 +1,13 @@
 fastapi>=0.109.0
 uvicorn[standard]>=0.27.0
 pydantic>=2.5.0
+pydantic[email]>=2.5.0
 pydantic-settings>=2.1.0
 python-dotenv>=1.0.0
 python-jose[cryptography]>=3.3.0
 passlib[bcrypt]>=1.7.4
+bcrypt>=3.0.0,<4.0.0
+greenlet>=3.0.0
 stripe>=8.0.0
 sqlalchemy>=2.0.0
 alembic>=1.13.0

package/templates/python-fastapi/hexagonal/.gitignore.hbs

@@ -0,0 +1,76 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+*.pyo
+
+# Distribution / packaging
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# Virtual environments
+.venv/
+venv/
+env/
+ENV/
+env.bak/
+venv.bak/
+.python-version
+
+# Environment variables
+.env
+.env.local
+.env.*.local
+!.env.example
+
+# Pytest
+.pytest_cache/
+pytest-cache/
+.cache/
+
+# Coverage
+htmlcov/
+.tox/
+.coverage
+.coverage.*
+coverage.xml
+*.cover
+*.py,cover
+
+# MyPy / Pyright
+.mypy_cache/
+.dmypy.json
+dmypy.json
+.pyright/
+pyrightconfig.json
+
+# Alembic — keep migrations, ignore autogenerated caches
+# alembic/versions/ is intentionally tracked
+
+# Jupyter
+.ipynb_checkpoints
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Editor
+.vscode/
+.idea/
+*.swp
+*.swo

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

@@ -5,7 +5,7 @@ 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.adapters.outbound.postgres_user_repository import PostgresUserRepository
 from app.core.service import AuthService
 from app.infrastructure.security.adapters import BcryptHasher, JwtTokenGenerator
 
@@ -16,6 +16,10 @@ class RegisterRequest(BaseModel):
     name: str
     password: str
 
+class LoginRequest(BaseModel):
+    email: EmailStr
+    password: str
+
 # Dependency Injection Factory
 def get_auth_service(db: AsyncSession = Depends(get_db)) -> IAuthPort:
     repo = PostgresUserRepository(db)
@@ -36,7 +40,7 @@ async def register(
 
 @router.post("/login")
 async def login(
-    req: RegisterRequest,
+    req: LoginRequest,
     service: IAuthPort = Depends(get_auth_service)
 ):
     try:
@@ -44,10 +48,3 @@ async def login(
         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):
-    # 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/inbound/payment_http_adapter.py.hbs

@@ -1,16 +1,17 @@
 from fastapi import APIRouter, HTTPException, Header, Request, Depends
 from pydantic import BaseModel
+from sqlalchemy.ext.asyncio import AsyncSession
 from app.core.payment_service import PaymentService
 from app.adapters.outbound.stripe_adapter import StripeAdapter
-from app.infrastructure.database.session import AsyncSessionLocal
+from app.infrastructure.database.session import get_db
 from app.infrastructure.database.user_repository import SQLAlchemyUserRepository
 from app.infrastructure.security.jwt import get_current_user_id
 
 router = APIRouter()
 
 
-def get_payment_service() -> PaymentService:
-    repo = SQLAlchemyUserRepository(AsyncSessionLocal())
+def get_payment_service(db: AsyncSession = Depends(get_db)) -> PaymentService:
+    repo = SQLAlchemyUserRepository(db)
     adapter = StripeAdapter()
     return PaymentService(user_repository=repo, stripe_adapter=adapter)
 

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

@@ -1,19 +1,24 @@
 import stripe
 import os
 
-stripe.api_key = os.getenv("STRIPE_SECRET_KEY")
 stripe.api_version = "2026-02-25.clover"
 
 
 class StripeAdapter:
     """Outbound adapter: wraps the Stripe SDK for use by the core domain."""
 
+    def __init__(self):
+        stripe.api_key = os.getenv("STRIPE_SECRET_KEY")
+
     def create_customer(self, email: str, name: str | None = None, user_id: str | None = None):
-        return stripe.Customer.create(
-            email=email,
-            name=name,
-            metadata={"userId": user_id} if user_id else {},
-        )
+        try:
+            return stripe.Customer.create(
+                email=email,
+                name=name,
+                metadata={"userId": user_id} if user_id else {},
+            )
+        except stripe.StripeError as e:
+            raise ValueError(f"Stripe error creating customer: {e.user_message or str(e)}")
 
     def create_checkout_session(
         self,
@@ -23,21 +28,27 @@ class StripeAdapter:
         success_url: str,
         cancel_url: str,
     ):
-        return stripe.checkout.Session.create(
-            mode="subscription",
-            payment_method_types=["card"],
-            line_items=[{"price": price_id, "quantity": 1}],
-            customer=customer_id,
-            success_url=success_url,
-            cancel_url=cancel_url,
-            client_reference_id=str(user_id),
-        )
+        try:
+            return stripe.checkout.Session.create(
+                mode="subscription",
+                payment_method_types=["card"],
+                line_items=[{"price": price_id, "quantity": 1}],
+                customer=customer_id,
+                success_url=success_url,
+                cancel_url=cancel_url,
+                client_reference_id=str(user_id),
+            )
+        except stripe.StripeError as e:
+            raise ValueError(f"Stripe error creating checkout session: {e.user_message or str(e)}")
 
     def create_portal_session(self, customer_id: str, return_url: str):
-        return stripe.billing_portal.Session.create(
-            customer=customer_id,
-            return_url=return_url,
-        )
+        try:
+            return stripe.billing_portal.Session.create(
+                customer=customer_id,
+                return_url=return_url,
+            )
+        except stripe.StripeError as e:
+            raise ValueError(f"Stripe error creating portal session: {e.user_message or str(e)}")
 
     def construct_event(self, payload: bytes, sig_header: str):
         webhook_secret = os.getenv("STRIPE_WEBHOOK_SECRET", "")

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

@@ -1,19 +1,29 @@
+from dotenv import load_dotenv
+load_dotenv()
+
 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"
-    
+    DATABASE_URL: str = "postgresql+asyncpg://postgres:postgres@localhost:5432/{{projectName}}"
+
     # 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)
+    # Stripe
+    STRIPE_SECRET_KEY: str = "sk_test_placeholder"
+    STRIPE_WEBHOOK_SECRET: str = "whsec_placeholder"
+
+    # Frontend
+    FRONTEND_URL: str = "http://localhost:3000"
+
+    model_config = SettingsConfigDict(env_file=".env", case_sensitive=True, extra="ignore")
 
 @lru_cache
 def get_settings():

package/templates/python-fastapi/hexagonal/app/core/domain/user.py.hbs

@@ -1,4 +1,5 @@
 from dataclasses import dataclass
+from datetime import datetime
 from typing import Optional
 
 @dataclass(frozen=True)
@@ -9,7 +10,8 @@ class User:
     password: str
     id: Optional[str] = None
     stripe_customer_id: Optional[str] = None
-    
+    created_at: Optional[datetime] = None
+
     def __post_init__(self):
         if "@" not in self.email:
             raise ValueError("Invalid email")

package/templates/python-fastapi/hexagonal/app/core/payment_service.py.hbs

@@ -1,4 +1,5 @@
 import os
+import dataclasses
 from app.core.ports.user_repository import UserRepository
 from app.adapters.outbound.stripe_adapter import StripeAdapter
 
@@ -18,22 +19,28 @@ class PaymentService:
         customer_id = user.stripe_customer_id
 
         if not customer_id:
-            customer = self.stripe_adapter.create_customer(
-                email=user.email,
-                name=getattr(user, "name", None),
-                user_id=str(user.id),
-            )
+            try:
+                customer = self.stripe_adapter.create_customer(
+                    email=user.email,
+                    name=getattr(user, "name", None),
+                    user_id=str(user.id),
+                )
+            except ValueError as e:
+                raise ValueError(f"Failed to create Stripe customer: {e}")
             customer_id = customer.id
-            user.stripe_customer_id = customer_id
+            user = dataclasses.replace(user, stripe_customer_id=customer_id)
             await self.user_repository.save(user)
 
-        session = self.stripe_adapter.create_checkout_session(
-            customer_id=customer_id,
-            price_id=price_id,
-            user_id=str(user_id),
-            success_url=f"{os.getenv('FRONTEND_URL')}/success?session_id={{CHECKOUT_SESSION_ID}}",
-            cancel_url=f"{os.getenv('FRONTEND_URL')}/cancel",
-        )
+        try:
+            session = self.stripe_adapter.create_checkout_session(
+                customer_id=customer_id,
+                price_id=price_id,
+                user_id=str(user_id),
+                success_url=f"{os.getenv('FRONTEND_URL')}/success?session_id={'{CHECKOUT_SESSION_ID}'}",
+                cancel_url=f"{os.getenv('FRONTEND_URL')}/cancel",
+            )
+        except ValueError as e:
+            raise ValueError(f"Failed to create checkout session: {e}")
         return session.url
 
     async def create_portal_session(self, user_id: str) -> str:
@@ -41,10 +48,13 @@ class PaymentService:
         if not user or not user.stripe_customer_id:
             raise ValueError("No Stripe customer found for this user")
 
-        session = self.stripe_adapter.create_portal_session(
-            customer_id=user.stripe_customer_id,
-            return_url=f"{os.getenv('FRONTEND_URL')}/dashboard",
-        )
+        try:
+            session = self.stripe_adapter.create_portal_session(
+                customer_id=user.stripe_customer_id,
+                return_url=f"{os.getenv('FRONTEND_URL')}/dashboard",
+            )
+        except ValueError as e:
+            raise ValueError(f"Failed to create portal session: {e}")
         return session.url
 
     async def handle_webhook(self, payload: bytes, sig_header: str) -> dict:
@@ -62,7 +72,7 @@ class PaymentService:
             if user_id and customer_id:
                 user = await self.user_repository.find_by_id(user_id)
                 if user:
-                    user.stripe_customer_id = customer_id
+                    user = dataclasses.replace(user, stripe_customer_id=customer_id)
                     await self.user_repository.save(user)
             print(f"Checkout completed for user: {user_id}")
 

package/templates/python-fastapi/hexagonal/app/core/ports/__init__.py.hbs

@@ -0,0 +1,3 @@
+from app.core.ports.ports import IAuthPort, IUserRepositoryPort
+
+__all__ = ["IAuthPort", "IUserRepositoryPort"]

package/templates/python-fastapi/hexagonal/app/core/ports/user_repository.py.hbs

@@ -0,0 +1,15 @@
+from abc import ABC, abstractmethod
+from typing import Optional
+from app.core.domain.user import User
+
+
+class UserRepository(ABC):
+    """Repository port for payment-related user lookups."""
+
+    @abstractmethod
+    async def find_by_id(self, user_id: str) -> Optional[User]:
+        pass
+
+    @abstractmethod
+    async def save(self, user: User) -> User:
+        pass

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

@@ -18,3 +18,10 @@ AsyncSessionLocal = async_sessionmaker(
 
 class Base(DeclarativeBase):
     pass
+
+async def get_db():
+    async with AsyncSessionLocal() as session:
+        try:
+            yield session
+        finally:
+            await session.close()

package/templates/python-fastapi/hexagonal/app/infrastructure/database/user_repository.py.hbs

@@ -0,0 +1,53 @@
+from typing import Optional
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy import select
+from app.core.ports.user_repository import UserRepository
+from app.core.domain.user import User
+from app.infrastructure.database.models import UserModel
+
+
+class SQLAlchemyUserRepository(UserRepository):
+    """Async SQLAlchemy implementation of UserRepository (payment context)."""
+
+    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 save(self, user: User) -> User:
+        result = await self.session.execute(
+            select(UserModel).where(UserModel.id == user.id)
+        )
+        model = result.scalars().first()
+
+        if model:
+            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/infrastructure/security/adapters.py.hbs

@@ -0,0 +1,23 @@
+from passlib.context import CryptContext
+from jose import jwt
+from datetime import datetime, timedelta
+import os
+
+SECRET_KEY = os.getenv("JWT_SECRET", "secret")
+ALGORITHM = "HS256"
+
+class BcryptHasher:
+    def __init__(self):
+        self.pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
+
+    def hash(self, password: str) -> str:
+        return self.pwd_context.hash(password)
+
+    def verify(self, password: str, hashed: str) -> bool:
+        return self.pwd_context.verify(password, hashed)
+
+class JwtTokenGenerator:
+    def generate(self, user_id: str, email: str) -> str:
+        expire = datetime.utcnow() + timedelta(days=7)
+        to_encode = {"exp": expire, "sub": user_id, "email": email}
+        return jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)

package/templates/python-fastapi/hexagonal/app/infrastructure/security/jwt.py.hbs

@@ -0,0 +1,23 @@
+from fastapi import HTTPException, Security
+from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
+from jose import jwt, JWTError
+import os
+
+security = HTTPBearer()
+
+SECRET_KEY = os.getenv("JWT_SECRET", "secret")
+ALGORITHM = "HS256"
+
+
+def get_current_user_id(
+    credentials: HTTPAuthorizationCredentials = Security(security),
+) -> str:
+    try:
+        token = credentials.credentials
+        payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
+        user_id: str = payload.get("sub")
+        if user_id is None:
+            raise HTTPException(status_code=401, detail="Invalid authentication credentials")
+        return user_id
+    except JWTError:
+        raise HTTPException(status_code=401, detail="Invalid authentication credentials")

package/templates/python-fastapi/hexagonal/docker-compose.yml.hbs

@@ -1,16 +1,4 @@
-version: '3.8'
-
 services:
-  app:
-    build: .
-    container_name: {{kebabCase projectName}}-app
-    ports:
-      - "8000:8000"
-    environment:
-      - DATABASE_URL=postgresql://postgres:postgres@db:5432/{{snakeCase projectName}}
-    depends_on:
-      - db
-
   db:
     image: postgres:15-alpine
     container_name: {{kebabCase projectName}}-db
@@ -23,6 +11,11 @@ services:
     volumes:
       - postgres_data:/var/lib/postgresql/data
     restart: unless-stopped
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U postgres"]
+      interval: 10s
+      timeout: 5s
+      retries: 5
 
 volumes:
   postgres_data: