kybernus 2.0.10 → 2.1.1

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

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/node_modules/minipass/LICENSE

@@ -1,15 +0,0 @@
-The ISC License
-
-Copyright (c) 2017-2023 npm, Inc., Isaac Z. Schlueter, and Contributors
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted, provided that the above
-copyright notice and this permission notice appear in all copies.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
-IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.