fastapi-auth-starter 0.1.3__py3-none-any.whl

fastapi_auth_starter-0.1.3.data/data/app/api/v1/routes/task.py

@@ -0,0 +1,182 @@
+"""
+Task API routes
+CRUD endpoints for task management
+Reference: https://fastapi.tiangolo.com/tutorial/sql-databases/
+"""
+from typing import List, Optional
+from fastapi import APIRouter, Depends, HTTPException, status, Query
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.core.database import get_db
+from app.api.v1.schemas.task import TaskCreate, TaskUpdate, TaskResponse
+from app.services.task import TaskService
+
+
+# Create router for task endpoints
+router = APIRouter(
+    prefix="/tasks",
+    tags=["tasks"],  # Groups endpoints in API documentation
+    responses={
+        404: {"description": "Task not found"},
+        500: {"description": "Internal server error"}
+    }
+)
+
+
+@router.get(
+    "",
+    response_model=List[TaskResponse],
+    summary="List tasks",
+    description="Retrieve a list of tasks with optional filtering and pagination",
+    status_code=status.HTTP_200_OK
+)
+async def get_tasks(
+    skip: int = Query(0, ge=0, description="Number of tasks to skip"),
+    limit: int = Query(100, ge=1, le=1000, description="Maximum number of tasks to return"),
+    completed: Optional[bool] = Query(None, description="Filter by completion status"),
+    db: AsyncSession = Depends(get_db)
+) -> List[TaskResponse]:
+    """
+    Get a list of tasks
+    
+    Supports:
+    - Pagination via skip and limit parameters
+    - Filtering by completion status
+    
+    Returns:
+        List of TaskResponse objects
+    """
+    tasks = await TaskService.get_tasks(db, skip=skip, limit=limit, completed=completed)
+    return tasks
+
+
+@router.get(
+    "/{task_id}",
+    response_model=TaskResponse,
+    summary="Get task by ID",
+    description="Retrieve a single task by its ID",
+    status_code=status.HTTP_200_OK,
+    responses={
+        404: {"description": "Task not found"}
+    }
+)
+async def get_task(
+    task_id: int,
+    db: AsyncSession = Depends(get_db)
+) -> TaskResponse:
+    """
+    Get a single task by ID
+    
+    Args:
+        task_id: ID of the task to retrieve
+        
+    Returns:
+        TaskResponse object
+        
+    Raises:
+        HTTPException: If task is not found
+    """
+    task = await TaskService.get_task(db, task_id)
+    if not task:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"Task with ID {task_id} not found"
+        )
+    return task
+
+
+@router.post(
+    "",
+    response_model=TaskResponse,
+    summary="Create task",
+    description="Create a new task",
+    status_code=status.HTTP_201_CREATED
+)
+async def create_task(
+    task_data: TaskCreate,
+    db: AsyncSession = Depends(get_db)
+) -> TaskResponse:
+    """
+    Create a new task
+    
+    Args:
+        task_data: Task creation data
+        
+    Returns:
+        Created TaskResponse object
+    """
+    task = await TaskService.create_task(db, task_data)
+    return task
+
+
+@router.put(
+    "/{task_id}",
+    response_model=TaskResponse,
+    summary="Update task",
+    description="Update an existing task (all fields required)",
+    status_code=status.HTTP_200_OK,
+    responses={
+        404: {"description": "Task not found"}
+    }
+)
+async def update_task(
+    task_id: int,
+    task_data: TaskUpdate,
+    db: AsyncSession = Depends(get_db)
+) -> TaskResponse:
+    """
+    Update an existing task
+    
+    All fields in TaskUpdate are optional, allowing partial updates.
+    Only provided fields will be updated.
+    
+    Args:
+        task_id: ID of the task to update
+        task_data: Task update data
+        
+    Returns:
+        Updated TaskResponse object
+        
+    Raises:
+        HTTPException: If task is not found
+    """
+    task = await TaskService.update_task(db, task_id, task_data)
+    if not task:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"Task with ID {task_id} not found"
+        )
+    return task
+
+
+@router.delete(
+    "/{task_id}",
+    summary="Delete task",
+    description="Delete a task by ID",
+    status_code=status.HTTP_204_NO_CONTENT,
+    responses={
+        404: {"description": "Task not found"},
+        204: {"description": "Task deleted successfully"}
+    }
+)
+async def delete_task(
+    task_id: int,
+    db: AsyncSession = Depends(get_db)
+):
+    """
+    Delete a task
+    
+    Args:
+        task_id: ID of the task to delete
+        
+    Raises:
+        HTTPException: If task is not found
+    """
+    deleted = await TaskService.delete_task(db, task_id)
+    if not deleted:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"Task with ID {task_id} not found"
+        )
+    return None  # 204 No Content
+

fastapi_auth_starter-0.1.3.data/data/app/api/v1/routes/user.py

@@ -0,0 +1,144 @@
+from typing import List
+from fastapi import APIRouter, Depends, HTTPException, Query, status
+from workos.exceptions import BadRequestException
+from app.api.v1.schemas.auth import WorkOSUserResponse
+from app.api.v1.schemas.user import UserResponse, UserUpdate
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.core.database import get_db
+# from app.core.exceptions import InvalidPasswordException
+from app.core.dependencies import get_current_user
+from app.services.user import UserService
+import logging
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(
+    prefix="/users",
+    tags=["users"],
+)
+
+@router.get("", response_model=List[UserResponse])
+async def get_users(
+    skip: int = Query(0, ge=0, description="Number of users to skip"),
+    limit: int = Query(100, ge=1, le=1000, description="Maximum number of users to return"),
+    current_user: WorkOSUserResponse = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db)
+) -> List[UserResponse]:
+    """
+    Get a list of users
+    
+    Args:
+        skip: Number of users to skip (for pagination)
+        limit: Maximum number of users to return (for pagination)
+        db: Database session
+
+    Returns:
+        List of UserResponse objects
+    """
+    user_service = UserService()
+    users = await user_service.get_users(db, skip=skip, limit=limit)
+    return users
+
+
+@router.get("/{user_id}", response_model=UserResponse)
+async def get_user(
+    user_id: str,
+    db: AsyncSession = Depends(get_db)
+) -> UserResponse:
+    """
+    Get a user by ID
+    """
+    user_service = UserService()
+    user = await user_service.get_user(db, user_id)
+    if not user:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail="User not found"
+        )
+    return user
+
+# POST /users removed - use POST /auth/signup for user registration instead
+
+@router.patch(
+    "/{user_id}",
+    response_model=UserResponse,
+    summary="Update user",
+    description="Update a user by ID",
+    status_code=status.HTTP_200_OK
+)
+async def update_user(
+    user_id: str,
+    user_data: UserUpdate,
+    db: AsyncSession = Depends(get_db)
+):
+    """
+    Update a user by ID
+    
+    Args:
+        user_id: ID of the user to update
+        user_data: User update data
+        
+    Returns:
+        Updated UserResponse object
+    """
+    user_service = UserService()
+    try:
+        user = await user_service.update_user(db, user_id, user_data)
+        if not user:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail="User not found"
+            )
+        return user
+    except BadRequestException as e:
+        logger.error(f"Bad request updating user: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail=f"Failed to update user: {e.message if hasattr(e, 'message') else str(e)}"
+        ) from e
+    except Exception as e:
+        logger.error(f"Unexpected error updating user: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="An unexpected error occurred while updating the user"
+        ) from e
+
+@router.delete(
+    "/{user_id}",
+    summary="Delete user",
+    description="Delete a user by ID",
+    status_code=status.HTTP_204_NO_CONTENT,
+    responses={
+        404: {"description": "User not found"},
+        204: {"description": "User deleted successfully"}
+    }
+)
+async def delete_user(
+    user_id: str,
+    db: AsyncSession = Depends(get_db)
+):
+    """
+    Delete a user by ID
+    
+    Args:
+        user_id: ID of the user to delete
+        
+    Returns:
+        None
+    """
+    user_service = UserService()
+    try:
+        deleted = await user_service.delete_user(db, user_id)
+        if not deleted:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail="User not found"
+            )
+        return None 
+    except Exception as e:
+        logger.error(f"Unexpected error deleting user: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="An unexpected error occurred while deleting the user"
+        ) from e

fastapi_auth_starter-0.1.3.data/data/app/api/v1/schemas/__init__.py

@@ -0,0 +1,8 @@
+"""
+Pydantic schemas for API request/response models
+"""
+
+from app.api.v1.schemas.task import TaskCreate, TaskUpdate, TaskResponse
+
+__all__ = ["TaskCreate", "TaskUpdate", "TaskResponse"]
+

fastapi_auth_starter-0.1.3.data/data/app/api/v1/schemas/auth.py

@@ -0,0 +1,198 @@
+from typing import Optional
+from pydantic import BaseModel, Field, field_validator, model_validator
+from datetime import datetime
+
+from app.api.v1.schemas.user import WorkOSUserResponse
+
+class EmailVerificationRequiredResponse(BaseModel):
+    message: str
+    pending_authentication_token: str
+    email_verification_id: str
+    email: str
+    requires_verification: bool = True
+
+class VerifyEmailRequest(BaseModel):
+    pending_authentication_token: str = Field(..., description="Pending authentication token")
+    code: str = Field(..., description="Code")
+
+class WorkOsVerifyEmailRequest(VerifyEmailRequest):
+    ip_address: str = Field(..., description="User IP address")
+    user_agent: str = Field(..., description="User user agent")
+
+
+
+class LoginRequest(BaseModel):
+    email: str = Field(..., description="User email")
+    password: str = Field(..., description="User password")
+
+class SignupRequest(BaseModel):
+    """
+    Schema for user signup/registration.
+    
+    Used for public self-registration endpoint.
+    Includes password validation and confirmation.
+    """
+    email: str = Field(..., min_length=1, max_length=255, description="User email")
+    password: str = Field(..., min_length=8, max_length=255, description="User password")
+    confirm_password: str = Field(..., min_length=8, max_length=255, description="Password confirmation")
+    first_name: Optional[str] = Field(None, max_length=255, description="User first name")
+    last_name: Optional[str] = Field(None, max_length=255, description="User last name")
+    
+    @field_validator('password')
+    def validate_password(cls, v: str) -> str:
+        """Validate password strength."""
+        if len(v) < 8:
+            raise ValueError("Password must be at least 8 characters long")
+        if not any(char.isdigit() for char in v):
+            raise ValueError("Password must contain at least one number")
+        if not any(char.isalpha() for char in v):
+            raise ValueError("Password must contain at least one letter")
+        if not any(char.isupper() for char in v):
+            raise ValueError("Password must contain at least one uppercase letter")
+        if not any(char.islower() for char in v):
+            raise ValueError("Password must contain at least one lowercase letter")
+        return v
+    
+    @model_validator(mode='after')
+    def validate_confirm_password(self) -> 'SignupRequest':
+        """Ensure password and confirm_password match."""
+        if self.password != self.confirm_password:
+            raise ValueError("Password and confirm password do not match")
+        return self
+
+class WorkOSLoginRequest(LoginRequest):
+    ip_address: str = Field(..., description="User IP address")
+    user_agent: str = Field(..., description="User user agent")
+
+class LoginResponse(BaseModel):
+    user: WorkOSUserResponse = Field(..., description="User")
+    organization_id: str | None = Field(None, description="Organization ID")
+    access_token: str = Field(..., description="Access token")
+    refresh_token: str = Field(..., description="Refresh token")
+
+class SignupResponse(BaseModel):
+    """
+    Response for user signup.
+    
+    Returns user information without tokens since email verification is required.
+    User must verify email and then login to get tokens.
+    """
+    user: WorkOSUserResponse = Field(..., description="Created user")
+    message: str = Field(default="User created successfully. Please verify your email to login.", description="Success message")
+
+
+class ForgotPasswordRequest(BaseModel):
+    email: str = Field(..., description="User email")
+
+
+class ForgotPasswordResponse(BaseModel):
+    message: str = Field(
+        default="If an account exists with this email address, a password reset link has been sent.",
+        description="Generic success message"
+    )
+
+class WorkOSResetPasswordRequest(BaseModel):
+    token: str = Field(..., description="Reset password token")
+    new_password: str = Field(..., description="New password")
+
+class ResetPasswordRequest(WorkOSResetPasswordRequest):
+    confirm_new_password: str = Field(..., description="Confirm new password")
+
+    @field_validator('new_password')
+    def validate_new_password(cls, v: str) -> str:
+        """Validate new password strength."""
+        if len(v) < 8:
+            raise ValueError("Password must be at least 8 characters long")
+        if not any(char.isdigit() for char in v):
+            raise ValueError("Password must contain at least one number")
+        if not any(char.isalpha() for char in v):
+            raise ValueError("Password must contain at least one letter")
+        if not any(char.isupper() for char in v):
+            raise ValueError("Password must contain at least one uppercase letter")
+        if not any(char.islower() for char in v):
+            raise ValueError("Password must contain at least one lowercase letter")
+        return v
+    
+    @model_validator(mode='after')
+    def validate_confirm_new_password(self) -> 'ResetPasswordRequest':
+        """Ensure new password and confirm_new_password match."""
+        if self.new_password != self.confirm_new_password:
+            raise ValueError("New password and confirm new password do not match")
+        return self
+
+class WorkOSImpersonatorResponse(BaseModel):
+    email: str | None = Field(None, description="Impersonator email")
+    reason: str | None = Field(None, description="Impersonation reason")
+
+
+class VerifyEmailResponse(BaseModel):
+    access_token: str | None = Field(None, description="Access token")
+    refresh_token: str | None = Field(None, description="Refresh token")
+    authentication_method: str | None = Field(None, description="Authentication method")
+    impersonator: WorkOSImpersonatorResponse | None = Field(None, description="Impersonator")
+    organization_id: str | None = Field(None, description="Organization ID")
+    user: WorkOSUserResponse | None = Field(None, description="User")
+    sealed_session: str | None = Field(None, description="Sealed session")
+
+
+class AuthorizationRequest(BaseModel):
+    """
+    Request to generate OAuth2 authorization URL.
+    
+    Supports two patterns:
+    1. AuthKit: Use provider="authkit" (unified interface)
+    2. SSO: Use connection_id (direct provider connection)
+    
+    Exactly one of provider or connection_id must be provided.
+    """
+    provider: str | None = Field(
+        None,
+        description="AuthKit provider (use 'authkit' for unified interface). Mutually exclusive with connection_id."
+    )
+    connection_id: str | None = Field(
+        None,
+        description="WorkOS SSO connection ID for direct provider (e.g., Google, Microsoft). Mutually exclusive with provider."
+    )
+    redirect_uri: str = Field(
+        ...,
+        description="URI to redirect to after authentication. Must be in allowed list."
+    )
+    state: str | None = Field(
+        None,
+        description="Optional state parameter for CSRF protection"
+    )
+    
+    @model_validator(mode='after')
+    def validate_provider_or_connection(self):
+        """Ensure exactly one of provider or connection_id is provided"""
+        has_provider = self.provider is not None
+        has_connection = self.connection_id is not None
+        
+        if not has_provider and not has_connection:
+            raise ValueError("Either 'provider' or 'connection_id' must be provided")
+        
+        if has_provider and has_connection:
+            raise ValueError("'provider' and 'connection_id' are mutually exclusive. Provide only one.")
+        
+        return self
+
+class AuthorizationUrlResponse(BaseModel):
+    authorization_url: str = Field(..., description="Authorization URL")
+
+class WorkOSAuthorizationRequest(AuthorizationRequest):
+    pass
+
+class OAuthCallbackRequest(BaseModel):
+    code: str = Field(..., description="Authorization code from OAuth callback")
+    state: str | None = Field(None, description="State parameter for CSRF verification")
+
+class RefreshTokenRequest(BaseModel):
+    refresh_token: str = Field(..., description="Refresh token")
+
+class WorkOSRefreshTokenRequest(RefreshTokenRequest):
+    ip_address: str = Field(..., description="User IP address")
+    user_agent: str = Field(..., description="User user agent")
+
+class RefreshTokenResponse(BaseModel):
+    access_token: str = Field(..., description="Access token")
+    refresh_token: str = Field(..., description="Refresh token")

fastapi_auth_starter-0.1.3.data/data/app/api/v1/schemas/task.py

@@ -0,0 +1,61 @@
+"""
+Task Pydantic schemas
+Request and response models for Task API endpoints
+Reference: https://fastapi.tiangolo.com/tutorial/body/
+"""
+from datetime import datetime
+from typing import Optional
+from pydantic import BaseModel, Field
+
+
+class TaskBase(BaseModel):
+    """
+    Base schema with common Task fields
+    Used as base for create and update schemas
+    """
+    title: str = Field(..., min_length=1, max_length=200, description="Task title")
+    description: Optional[str] = Field(None, max_length=1000, description="Task description")
+    completed: bool = Field(default=False, description="Whether the task is completed")
+
+
+class TaskCreate(TaskBase):
+    """
+    Schema for creating a new task
+    Inherits from TaskBase
+    """
+    pass
+
+
+class TaskUpdate(BaseModel):
+    """
+    Schema for updating a task
+    All fields are optional for partial updates
+    Reference: https://fastapi.tiangolo.com/tutorial/body-updates/
+    """
+    title: Optional[str] = Field(None, min_length=1, max_length=200, description="Task title")
+    description: Optional[str] = Field(None, max_length=1000, description="Task description")
+    completed: Optional[bool] = Field(None, description="Whether the task is completed")
+
+
+class TaskResponse(TaskBase):
+    """
+    Schema for task response
+    Includes all fields from TaskBase plus database-generated fields
+    """
+    id: int = Field(..., description="Task ID")
+    # Timestamps are optional because they may not be immediately available
+    # after flush() in serverless environments (database sets them, but asyncpg
+    # may not return them without refresh which can cause connection issues)
+    created_at: Optional[datetime] = Field(None, description="Timestamp when task was created")
+    updated_at: Optional[datetime] = Field(None, description="Timestamp when task was last updated")
+    
+    class Config:
+        """
+        Pydantic configuration
+        Reference: https://docs.pydantic.dev/latest/concepts/config/
+        """
+        from_attributes = True  # Allow creation from ORM objects (SQLAlchemy models)
+        json_encoders = {
+            datetime: lambda v: v.isoformat()  # Convert datetime to ISO format in JSON
+        }
+

fastapi_auth_starter-0.1.3.data/data/app/api/v1/schemas/user.py

@@ -0,0 +1,96 @@
+from datetime import datetime
+from typing import Optional
+from uuid import UUID
+from pydantic import BaseModel, ConfigDict, Field, field_validator, model_serializer, model_validator
+
+
+class UserBase(BaseModel):
+    """
+    Base schema with common User fields
+    Used as base for create schemas
+    """
+    first_name: Optional[str] = Field(None, max_length=255, description="User first name")
+    last_name: Optional[str] = Field(None, max_length=255, description="User last name")
+    email: str = Field(..., min_length=1, max_length=255, description="User email")
+    password: str = Field(..., min_length=8, max_length=255, description="User password")
+
+class UserCreate(UserBase):
+    """
+    Schema for creating a new user
+    Inherits from UserBase
+    Attributes:
+        first_name: User first name (optional)
+        last_name: User last name (optional)
+        email: User email (required)
+        password: User password (required)
+        confirm_password: User confirm password (required)
+    Reference: https://fastapi.tiangolo.com/tutorial/body/
+    """
+    confirm_password: str = Field(..., min_length=8, max_length=255, description="User confirm password")
+    
+    @field_validator('password')
+    def validate_password(cls, v: str) -> str:
+        if len(v) < 8:
+            raise ValueError("Password must be at least 8 characters long")
+        if not any(char.isdigit() for char in v):
+            raise ValueError("Password must contain at least one number")
+        if not any(char.isalpha() for char in v):
+            raise ValueError("Password must contain at least one letter")
+        if not any(char.isupper() for char in v):
+            raise ValueError("Password must contain at least one uppercase letter")
+        if not any(char.islower() for char in v):
+            raise ValueError("Password must contain at least one lowercase letter")
+        return v
+
+    @model_validator(mode='after')
+    def validate_confirm_password(self) -> 'UserCreate':
+        if self.password != self.confirm_password:
+            raise ValueError("Password and confirm password do not match")
+        return self
+    
+
+
+class UserResponse(BaseModel):
+    """
+    Schema for user response
+    Includes all fields from UserBase plus database-generated fields
+    Attributes:
+        id: User ID (required)
+        email: User email (required)
+        first_name: User first name (optional)
+        last_name: User last name (optional)
+        created_at: Timestamp when user was created (optional)
+        updated_at: Timestamp when user was last updated (optional)
+    Reference: https://fastapi.tiangolo.com/tutorial/response-model/
+    """
+    id: str = Field(..., description="User ID")
+    first_name: Optional[str] = Field(None, max_length=255, description="User first name")
+    last_name: Optional[str] = Field(None, max_length=255, description="User last name")
+    email: str = Field(..., min_length=1, max_length=255, description="User email")
+    created_at: Optional[datetime] = Field(None, description="Timestamp when user was created")
+    updated_at: Optional[datetime] = Field(None, description="Timestamp when user was last updated")
+
+    model_config = ConfigDict(from_attributes=True)
+
+class UserUpdate(BaseModel):
+    """
+    Schema for updating a user
+    All fields are optional for partial updates
+    """
+    first_name: Optional[str] = Field(None, max_length=255, description="User first name")
+    last_name: Optional[str] = Field(None, max_length=255, description="User last name")
+
+
+class WorkOSUserResponse(BaseModel):
+    object: str = Field(..., description="Object")
+    id: str = Field(..., description="User ID")
+    email: str = Field(..., description="User email")
+    first_name: str | None = Field(None, description="User first name")
+    last_name: str | None = Field(None, description="User last name") 
+    email_verified: bool = Field(..., description="User email verified")
+    profile_picture_url: str | None = Field(None, description="User profile picture URL")
+    created_at: datetime = Field(..., description="User created at")
+    updated_at: datetime = Field(..., description="User updated at")
+
+    class Config:
+        from_attributes = True

fastapi_auth_starter-0.1.3.data/data/app/core/__init__.py

@@ -0,0 +1,4 @@
+"""
+Core application configuration and utilities
+"""
+