innovationhub-cli 1.1.0 → 2.0.1

package/templates/python/app/common/schemas.py

@@ -0,0 +1,20 @@
+from enum import StrEnum
+
+from pydantic import BaseModel, Field
+
+
+class SortOrder(StrEnum):
+    ASC = "ASC"
+    DESC = "DESC"
+
+
+class BaseQueryParams(BaseModel):
+    """Parâmetros base de query com paginação e ordenação."""
+
+    page: int = Field(default=1, ge=1, description="Número da página que deseja buscar.")
+    limit: int = Field(
+        default=10, ge=1, le=100, description="Quantidade de itens por página."
+    )
+    search: str | None = Field(default=None, description="Termo de busca.")
+    sort_by: str = Field(default="created_at", description="Coluna de ordenação.")
+    sort_order: SortOrder = Field(default=SortOrder.DESC, description="Direção da ordenação.")

package/templates/python/app/common/utils.py

@@ -0,0 +1,15 @@
+import re
+import unicodedata
+
+
+def create_slug(title: str) -> str:
+    """Gera um slug URL-friendly a partir de um título."""
+    slug = unicodedata.normalize("NFD", title.lower())
+    slug = re.sub(r"[\u0300-\u036f]", "", slug)  # Remove acentos
+    slug = re.sub(r"[^a-z0-9]+", "-", slug)
+    slug = slug.strip("-")
+
+    if len(slug) > 50:
+        slug = slug[:50].rstrip("-")
+
+    return slug

package/templates/python/app/core/__init__.py

@@ -0,0 +1,4 @@
+from app.core.config import settings
+from app.core.database import get_db
+
+__all__ = ["settings", "get_db"]

package/templates/python/app/core/config.py

@@ -0,0 +1,55 @@
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+
+class Settings(BaseSettings):
+    model_config = SettingsConfigDict(env_file=".env", env_file_encoding="utf-8", extra="ignore")
+
+    # Database
+    DATABASE_HOST: str = "localhost"
+    DATABASE_PORT: int = 5432
+    DATABASE_USERNAME: str = "postgres"
+    DATABASE_PASSWORD: str = "docker"
+    DATABASE_NAME: str = "innovationhub"
+    DATABASE_SSL: bool = False
+
+    # JWT
+    JWT_SECRET: str = "change-me"
+    JWT_EXPIRATION_MINUTES: int = 15
+    JWT_REFRESH_SECRET: str = "change-me-refresh"
+    JWT_REFRESH_EXPIRATION_DAYS: int = 7
+
+    # Default password
+    DEFAULT_PASSWORD: str = "ih123"
+
+    # CORS
+    CORS_ORIGIN: str = "http://localhost:3001"
+
+    # Mail
+    MAIL_HOST: str = "smtp.gmail.com"
+    MAIL_PORT: int = 587
+    MAIL_USER: str = ""
+    MAIL_PASSWORD: str = ""
+    MAIL_FROM: str = ""
+
+    @property
+    def database_url(self) -> str:
+        scheme = "postgresql+asyncpg"
+        return (
+            f"{scheme}://{self.DATABASE_USERNAME}:{self.DATABASE_PASSWORD}"
+            f"@{self.DATABASE_HOST}:{self.DATABASE_PORT}/{self.DATABASE_NAME}"
+        )
+
+    @property
+    def database_url_sync(self) -> str:
+        """URL síncrona para uso com Alembic."""
+        return (
+            f"postgresql://{self.DATABASE_USERNAME}:{self.DATABASE_PASSWORD}"
+            f"@{self.DATABASE_HOST}:{self.DATABASE_PORT}/{self.DATABASE_NAME}"
+        )
+
+    @property
+    def cors_origins(self) -> list[str]:
+        return [origin.strip() for origin in self.CORS_ORIGIN.split(",") if origin.strip()]
+
+
+settings = Settings()

package/templates/python/app/core/database.py

@@ -0,0 +1,20 @@
+from collections.abc import AsyncGenerator
+
+from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker, create_async_engine
+
+from app.core.config import settings
+
+engine = create_async_engine(settings.database_url, echo=False, future=True)
+
+async_session_factory = async_sessionmaker(engine, class_=AsyncSession, expire_on_commit=False)
+
+
+async def get_db() -> AsyncGenerator[AsyncSession, None]:
+    """Dependency que fornece uma sessão async do banco de dados."""
+    async with async_session_factory() as session:
+        try:
+            yield session
+            await session.commit()
+        except Exception:
+            await session.rollback()
+            raise

package/templates/python/app/main.py

@@ -0,0 +1,33 @@
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+
+from app.auth.router import router as auth_router
+from app.core.config import settings
+from app.user.router import router as user_router
+
+app = FastAPI(
+    title="API da Landing Page/Blog",
+    description="Documentação da API do backend (FastAPI) para Autenticação e Blog.",
+    version="1.0.0",
+    docs_url="/api/docs",
+    redoc_url="/api/redoc",
+    openapi_url="/api/openapi.json",
+)
+
+# CORS
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=settings.cors_origins,
+    allow_credentials=True,
+    allow_methods=["GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS"],
+    allow_headers=["Content-Type", "Authorization"],
+)
+
+# Routers
+app.include_router(auth_router)
+app.include_router(user_router)
+
+
+@app.get("/", tags=["health"])
+async def health_check():
+    return {"status": "ok"}

package/templates/python/app/user/__init__.py

@@ -0,0 +1,4 @@
+from app.user.models import User
+from app.user.router import router
+
+__all__ = ["User", "router"]

package/templates/python/app/user/models.py

@@ -0,0 +1,26 @@
+from datetime import datetime
+
+from sqlalchemy import Boolean, Column, DateTime, Enum, String
+from sqlalchemy.orm import relationship
+
+from app.auth.enums import Role
+from app.common.base_model import BaseModel
+
+
+class User(BaseModel):
+
+    __tablename__ = "users"
+
+    email: str = Column(String, unique=True, nullable=False, index=True)
+    name: str = Column(String, nullable=False)
+    phone: str | None = Column(String, nullable=True)
+    password: str = Column(String, nullable=False)
+    is_active: bool = Column(Boolean, default=True, nullable=False)
+    role: str = Column(Enum(Role, name="role_enum"), default=Role.USER, nullable=False)
+    must_change_password: bool = Column(Boolean, default=False, nullable=False)
+    deleted_at: datetime | None = Column(DateTime(timezone=True), nullable=True)
+
+    # Relationships
+    refresh_tokens = relationship(
+        "RefreshToken", back_populates="user", cascade="all, delete-orphan"
+    )

package/templates/python/app/user/repository.py

@@ -0,0 +1,84 @@
+import uuid
+
+from sqlalchemy import desc, func, or_, select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.common.base_repository import BaseRepository
+from app.common.pagination import PaginatedResult, PaginationMeta
+from app.user.models import User
+from app.user.schemas import QueryUsersParams
+
+
+class UserRepository(BaseRepository[User]):
+    """Repositório de usuários."""
+
+    def __init__(self, session: AsyncSession):
+        super().__init__(User, session)
+
+    async def find_by_id(self, id: uuid.UUID) -> User | None:
+        """Busca usuário ativo (sem soft delete) pelo ID."""
+        stmt = select(User).where(User.id == id, User.deleted_at.is_(None))
+        result = await self.session.execute(stmt)
+        return result.scalar_one_or_none()
+
+    async def find_all(self) -> list[User]:
+        """Busca todos os usuários ativos."""
+        stmt = select(User).where(User.deleted_at.is_(None)).order_by(desc(User.created_at))
+        result = await self.session.execute(stmt)
+        return list(result.scalars().all())
+
+    async def find_by_email(self, email: str) -> User | None:
+        """Busca usuário pelo email."""
+        stmt = select(User).where(User.email == email)
+        result = await self.session.execute(stmt)
+        return result.scalar_one_or_none()
+
+    async def find_and_count_users(self, query: QueryUsersParams) -> PaginatedResult[User]:
+        """Busca paginada com filtro por nome/email."""
+        base_stmt = select(User).where(User.deleted_at.is_(None))
+        count_stmt = select(func.count()).select_from(User).where(User.deleted_at.is_(None))
+
+        if query.search:
+            search_filter = or_(
+                User.name.ilike(f"%{query.search}%"),
+                User.email.ilike(f"%{query.search}%"),
+            )
+            base_stmt = base_stmt.where(search_filter)
+            count_stmt = count_stmt.where(search_filter)
+
+        # Whitelist de colunas para ordenação
+        allowed_columns = {"id", "name", "email", "is_active", "role", "created_at"}
+        sort_col = query.sort_by if query.sort_by in allowed_columns else "created_at"
+        column = getattr(User, sort_col, User.created_at)
+        order = desc(column) if query.sort_order.value == "DESC" else column.asc()
+
+        base_stmt = base_stmt.order_by(order)
+        base_stmt = base_stmt.offset((query.page - 1) * query.limit).limit(query.limit)
+
+        total_result = await self.session.execute(count_stmt)
+        total_items = total_result.scalar() or 0
+
+        result = await self.session.execute(base_stmt)
+        users = list(result.scalars().all())
+
+        total_pages = (total_items + query.limit - 1) // query.limit if query.limit > 0 else 0
+
+        return PaginatedResult(
+            data=users,
+            meta=PaginationMeta(
+                total_items=total_items,
+                item_count=len(users),
+                items_per_page=query.limit,
+                total_pages=total_pages,
+                current_page=query.page,
+            ),
+        )
+
+    async def soft_delete(self, id: uuid.UUID) -> None:
+        """Soft delete (marca deleted_at)."""
+        from datetime import UTC, datetime
+
+        user = await self.find_by_id(id)
+        if user:
+            user.deleted_at = datetime.now(UTC)
+            await self.session.flush()

package/templates/python/app/user/router.py

@@ -0,0 +1,170 @@
+import uuid
+
+from fastapi import APIRouter, Depends, Query, status
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.auth.dependencies import get_current_user, require_role
+from app.auth.enums import Role
+from app.core.database import get_db
+from app.user import service as user_service
+from app.user.models import User
+from app.user.schemas import (
+    CreateUserRequest,
+    QueryUsersParams,
+    UpdateUserRequest,
+    UserResponse,
+)
+
+router = APIRouter(prefix="/users", tags=["users"])
+
+
+# --- Rotas do próprio usuário ---
+
+
+@router.get(
+    "/me",
+    response_model=UserResponse,
+    summary="Retorna o perfil do usuário logado",
+    responses={200: {"description": "Perfil do usuário."}},
+)
+async def get_me(
+    current_user: User = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db),
+):
+    return await user_service.get_user_by_id(db, current_user.id)
+
+
+@router.patch(
+    "/me",
+    response_model=UserResponse,
+    summary="Atualiza o perfil do usuário logado",
+    responses={200: {"description": "Perfil atualizado com sucesso."}},
+)
+async def update_me(
+    data: UpdateUserRequest,
+    current_user: User = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db),
+):
+    return await user_service.update_user_profile(db, current_user.id, data)
+
+
+# --- Rotas administrativas ---
+
+
+@router.post(
+    "/",
+    response_model=UserResponse,
+    status_code=status.HTTP_201_CREATED,
+    summary="Cria um novo usuário (admin)",
+    responses={201: {"description": "Usuário criado com sucesso."}},
+)
+async def create_user(
+    data: CreateUserRequest,
+    _admin: User = Depends(require_role(Role.ADMIN)),
+    db: AsyncSession = Depends(get_db),
+):
+    return await user_service.create_user(db, data)
+
+
+@router.get(
+    "/",
+    response_model=list[UserResponse],
+    summary="Busca todos os usuários",
+    responses={200: {"description": "Lista de usuários retornada com sucesso."}},
+)
+async def find_all(
+    _admin: User = Depends(require_role(Role.ADMIN)),
+    db: AsyncSession = Depends(get_db),
+):
+    return await user_service.get_all_users(db)
+
+
+@router.get(
+    "/paginated",
+    summary="Busca todos os usuários com paginação",
+    responses={200: {"description": "Lista de usuários retornada com sucesso."}},
+)
+async def find_paginated(
+    page: int = Query(1, ge=1),
+    limit: int = Query(10, ge=1, le=100),
+    search: str | None = Query(None),
+    sort_by: str = Query("id"),
+    sort_order: str = Query("ASC"),
+    _admin: User = Depends(require_role(Role.ADMIN)),
+    db: AsyncSession = Depends(get_db),
+):
+    from app.common.schemas import SortOrder as SortOrderEnum
+
+    query = QueryUsersParams(
+        page=page,
+        limit=limit,
+        search=search,
+        sort_by=sort_by,
+        sort_order=SortOrderEnum(sort_order.upper()),
+    )
+    return await user_service.get_users_paginated(db, query)
+
+
+@router.get(
+    "/{user_id}",
+    response_model=UserResponse,
+    summary="Busca usuário pelo Id",
+    responses={
+        200: {"description": "Usuário encontrado."},
+        404: {"description": "Usuário não encontrado."},
+    },
+)
+async def find_by_id(
+    user_id: uuid.UUID,
+    _admin: User = Depends(require_role(Role.ADMIN)),
+    db: AsyncSession = Depends(get_db),
+):
+    return await user_service.get_user_by_id(db, user_id)
+
+
+@router.patch(
+    "/{user_id}",
+    status_code=status.HTTP_204_NO_CONTENT,
+    summary="Atualiza um usuário pelo ID (admin)",
+    responses={204: {"description": "Usuário atualizado com sucesso."}},
+)
+async def update_user(
+    user_id: uuid.UUID,
+    data: UpdateUserRequest,
+    _admin: User = Depends(require_role(Role.ADMIN)),
+    db: AsyncSession = Depends(get_db),
+):
+    await user_service.update_user_profile(db, user_id, data)
+
+
+@router.patch(
+    "/{user_id}/reset-password",
+    summary="Reseta a senha de um usuário (admin)",
+    responses={
+        200: {"description": "Senha resetada com sucesso."},
+        404: {"description": "Usuário não encontrado."},
+    },
+)
+async def reset_password(
+    user_id: uuid.UUID,
+    _admin: User = Depends(require_role(Role.ADMIN)),
+    db: AsyncSession = Depends(get_db),
+):
+    return await user_service.reset_password_by_admin(db, user_id)
+
+
+@router.delete(
+    "/{user_id}",
+    status_code=status.HTTP_204_NO_CONTENT,
+    summary="Deleta um usuário (admin)",
+    responses={
+        204: {"description": "Usuário deletado com sucesso."},
+        404: {"description": "Usuário não encontrado."},
+    },
+)
+async def delete_user(
+    user_id: uuid.UUID,
+    _admin: User = Depends(require_role(Role.ADMIN)),
+    db: AsyncSession = Depends(get_db),
+):
+    await user_service.delete_user(db, user_id)

package/templates/python/app/user/schemas.py

@@ -0,0 +1,60 @@
+import uuid
+
+from pydantic import BaseModel, EmailStr, Field
+
+from app.auth.enums import Role
+from app.common.schemas import BaseQueryParams
+
+# --- Create ---
+
+
+class CreateUserRequest(BaseModel):
+    """Schema para criação de usuário."""
+
+    email: EmailStr
+    name: str
+    is_active: bool | None = True
+    role: Role | None = Role.USER
+
+
+# --- Update ---
+
+
+class UpdateUserRequest(BaseModel):
+    """Schema para atualização de usuário."""
+
+    email: EmailStr | None = None
+    name: str | None = None
+    phone: str | None = None
+    is_active: bool | None = None
+    role: Role | None = None
+
+
+# --- Response ---
+
+
+class UserResponse(BaseModel):
+    """Schema de resposta do usuário (sem password)."""
+
+    model_config = {"from_attributes": True}
+
+    id: uuid.UUID
+    email: str
+    name: str
+    phone: str | None = None
+    is_active: bool
+    role: Role
+    must_change_password: bool
+
+
+# --- Query ---
+
+
+class QueryUsersParams(BaseQueryParams):
+    """Query params para busca de usuários."""
+
+    sort_by: str = Field(
+        default="id",
+        description="Coluna de ordenação.",
+        json_schema_extra={"enum": ["id", "name", "email", "is_active", "role"]},
+    )

package/templates/python/app/user/service.py

@@ -0,0 +1,114 @@
+import uuid
+
+from fastapi import HTTPException, status
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.auth.service import hash_password
+from app.common.errors import ERRORS
+from app.common.pagination import PaginatedResult
+from app.core.config import settings
+from app.user.models import User
+from app.user.repository import UserRepository
+from app.user.schemas import CreateUserRequest, QueryUsersParams, UpdateUserRequest
+
+
+async def create_user(db: AsyncSession, data: CreateUserRequest) -> User:
+    """Cria um novo usuário com senha padrão."""
+    repo = UserRepository(db)
+
+    existing = await repo.find_by_email(data.email)
+    if existing:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail=f"{ERRORS['USER']['EMAIL_IN_USE']} (Email: {data.email})",
+        )
+
+    default_password = settings.DEFAULT_PASSWORD
+    if not default_password:
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=ERRORS["USER"]["DEFAULT_PASSWORD_NOT_SET"],
+        )
+
+    hashed = hash_password(default_password)
+
+    return await repo.create({
+        **data.model_dump(exclude_unset=True),
+        "password": hashed,
+        "must_change_password": True,
+    })
+
+
+async def get_user_by_id(db: AsyncSession, user_id: uuid.UUID) -> User:
+    """Busca um usuário pelo ID, levantando 404 se não encontrado."""
+    repo = UserRepository(db)
+    user = await repo.find_by_id(user_id)
+    if not user:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=ERRORS["USER"]["NOT_FOUND"],
+        )
+    return user
+
+
+async def get_all_users(db: AsyncSession) -> list[User]:
+    """Lista todos os usuários ativos."""
+    repo = UserRepository(db)
+    return await repo.find_all()
+
+
+async def get_users_paginated(db: AsyncSession, query: QueryUsersParams) -> PaginatedResult[User]:
+    """Lista usuários com paginação e busca."""
+    repo = UserRepository(db)
+    return await repo.find_and_count_users(query)
+
+
+async def update_user_profile(
+    db: AsyncSession, user_id: uuid.UUID, data: UpdateUserRequest
+) -> User:
+    """Atualiza o perfil de um usuário."""
+    repo = UserRepository(db)
+    user = await repo.find_by_id(user_id)
+    if not user:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=ERRORS["USER"]["NOT_FOUND"],
+        )
+
+    update_data = data.model_dump(exclude_unset=True)
+    for key, value in update_data.items():
+        setattr(user, key, value)
+
+    await db.flush()
+    await db.refresh(user)
+    return user
+
+
+async def reset_password_by_admin(db: AsyncSession, user_id: uuid.UUID) -> dict:
+    """Reseta a senha de um usuário para a senha padrão."""
+    user = await get_user_by_id(db, user_id)
+
+    default_password = settings.DEFAULT_PASSWORD
+    if not default_password:
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=ERRORS["USER"]["DEFAULT_PASSWORD_NOT_SET"],
+        )
+
+    user.password = hash_password(default_password)
+    user.must_change_password = True
+    await db.flush()
+
+    return {"message": f"A senha do usuário {user.name} foi resetada com sucesso"}
+
+
+async def delete_user(db: AsyncSession, user_id: uuid.UUID) -> None:
+    """Soft delete de um usuário."""
+    repo = UserRepository(db)
+    user = await repo.find_by_id(user_id)
+    if not user:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=ERRORS["USER"]["NOT_FOUND"],
+        )
+    await repo.soft_delete(user_id)

package/templates/python/docker-compose.yml

@@ -0,0 +1,55 @@
+version: "3.9"
+
+services:
+  api-prod:
+    container_name: api_prod
+    build:
+      context: .
+      dockerfile: Dockerfile
+      target: production
+    ports:
+      - "3000:3000"
+    env_file:
+      - .env
+    depends_on:
+      postgres:
+        condition: service_healthy
+    restart: unless-stopped
+    profiles: ["prod"]
+
+  api-dev:
+    container_name: api_dev
+    build:
+      context: .
+      dockerfile: Dockerfile
+      target: development
+    ports:
+      - "3000:3000"
+    env_file:
+      - .env
+    depends_on:
+      postgres:
+        condition: service_healthy
+    volumes:
+      - .:/app
+    restart: unless-stopped
+    profiles: ["dev"]
+
+  postgres:
+    image: postgres:15
+    container_name: postgres
+    restart: unless-stopped
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U $${POSTGRES_USER} -d $${POSTGRES_DB}"]
+      interval: 10s
+      timeout: 5s
+      retries: 5
+    env_file:
+      - .env
+    ports:
+      - "5432:5432"
+    volumes:
+      - db_data:/var/lib/postgresql/data
+
+volumes:
+  db_data: