@weirdfingers/baseboards 0.9.6 → 0.9.7

package/templates/api/src/boards/api/app.py

@@ -1,172 +0,0 @@
-"""
-Main FastAPI application for Boards backend
-"""
-
-import os
-from contextlib import asynccontextmanager
-
-from fastapi import FastAPI
-from fastapi.middleware.cors import CORSMiddleware
-
-from ..config import initialize_generator_api_keys, settings
-from ..database import init_database
-from ..generators.loader import load_generators_from_config
-from ..logging import configure_logging, get_logger
-from ..middleware import LoggingContextMiddleware, TenantRoutingMiddleware
-
-# Configure logging before creating logger
-configure_logging(debug=settings.debug)
-logger = get_logger(__name__)
-
-
-@asynccontextmanager
-async def lifespan(app: FastAPI):
-    """Application lifespan manager."""
-    # Startup
-    logger.info("Starting Boards API...")
-    init_database()
-    logger.info("Database initialized")
-
-    # Initialize generator API keys from settings
-    initialize_generator_api_keys()
-    logger.info("Generator API keys initialized")
-
-    # Load generators based on configuration
-    try:
-        load_generators_from_config()
-        logger.info(
-            "Generators configured and registered",
-            names=list(
-                __import__(
-                    "boards.generators.registry", fromlist=["registry"]
-                ).registry.list_names()
-            ),
-        )
-    except Exception as e:
-        # Fail fast: strict mode default may raise here
-        logger.error("Failed to configure generators", error=str(e))
-        raise
-
-    # Run comprehensive startup validation
-    try:
-        from ..validation import (
-            ValidationError,
-            get_startup_recommendations,
-            validate_startup_configuration,
-        )
-
-        validation_results = await validate_startup_configuration()
-
-        if not validation_results["overall_valid"]:
-            # Log detailed error information
-            logger.error(
-                "Application configuration validation failed - some features may not work properly",
-                database_errors=validation_results.get("database", {}).get("errors", []),
-                tenant_errors=validation_results["tenant"].get("errors", []),
-                auth_errors=validation_results["auth"].get("errors", []),
-            )
-
-            # In production, we might want to fail hard here
-            if settings.environment.lower() in ("production", "prod"):
-                raise ValidationError("Critical configuration validation failed in production")
-
-        # Log recommendations
-        recommendations = get_startup_recommendations(validation_results)
-        if recommendations:
-            logger.info("Configuration recommendations", recommendations=recommendations)
-
-    except ValidationError:
-        # Re-raise validation errors to fail startup
-        raise
-    except Exception as e:
-        logger.error(
-            "Unexpected error during startup validation",
-            error=str(e),
-            note="Application will continue but may have configuration issues",
-        )
-
-    yield
-
-    # Shutdown
-    logger.info("Shutting down Boards API...")
-
-
-def create_app() -> FastAPI:
-    """Create and configure the FastAPI application."""
-
-    app = FastAPI(
-        title="Boards API",
-        description="Open-source creative toolkit for AI-generated content",
-        version="0.1.0",
-        lifespan=lifespan,
-        debug=settings.debug,
-    )
-
-    # Add tenant routing middleware first (runs before logging)
-    app.add_middleware(TenantRoutingMiddleware)
-
-    # Add logging context middleware
-    app.add_middleware(LoggingContextMiddleware)
-
-    # CORS configuration
-    app.add_middleware(
-        CORSMiddleware,
-        allow_origins=settings.cors_origins,
-        allow_credentials=True,
-        allow_methods=["*"],
-        allow_headers=["*"],
-    )
-
-    # Health check endpoint
-    @app.get("/health")
-    async def health_check():  # pyright: ignore [reportUnusedFunction]
-        """Health check endpoint."""
-        return {"status": "healthy", "version": "0.1.0"}
-
-    # GraphQL endpoint (allow disabling for tests)
-    if not os.getenv("BOARDS_DISABLE_GRAPHQL"):
-        try:
-            from ..graphql.schema import create_graphql_router, validate_schema
-
-            # Validate schema at startup to catch circular reference errors early
-            logger.info("Validating GraphQL schema...")
-            validate_schema()
-
-            # Create and mount the GraphQL router
-            graphql_router = create_graphql_router()
-            app.include_router(graphql_router, prefix="")
-            logger.info("GraphQL endpoint initialized successfully", endpoint="/graphql")
-        except Exception as e:  # pragma: no cover
-            logger.error("Failed to initialize GraphQL endpoint", error=str(e))
-            # Re-raise to fail fast - server should not start with broken GraphQL
-            raise
-
-    # REST API endpoints (for SSE, webhooks, etc.)
-    from .endpoints import jobs, setup, sse, storage, tenant_registration, uploads, webhooks
-
-    app.include_router(sse.router, prefix="/api/sse", tags=["SSE"])
-    app.include_router(jobs.router, prefix="/api/jobs", tags=["Jobs"])
-    app.include_router(webhooks.router, prefix="/api/webhooks", tags=["Webhooks"])
-    app.include_router(storage.router, prefix="/api/storage", tags=["Storage"])
-    app.include_router(setup.router, prefix="/api/setup", tags=["Setup"])
-    app.include_router(uploads.router, prefix="/api", tags=["Uploads"])
-    app.include_router(
-        tenant_registration.router, prefix="/api/tenants", tags=["Tenant Registration"]
-    )
-
-    return app
-
-
-# Create the main application instance
-app = create_app()
-
-if __name__ == "__main__":
-    import uvicorn
-
-    uvicorn.run(
-        "boards.api.app:app",
-        host=settings.api_host,
-        port=settings.api_port,
-        reload=settings.api_reload,
-        log_level=settings.log_level.lower(),
-    )

package/templates/api/src/boards/api/auth.py

@@ -1,75 +0,0 @@
-"""Authentication dependencies for API endpoints."""
-
-from __future__ import annotations
-
-from uuid import UUID
-
-from fastapi import Depends, HTTPException
-from pydantic import BaseModel
-
-from ..auth import AuthContext, get_auth_context, get_auth_context_optional
-from ..logging import get_logger
-
-logger = get_logger(__name__)
-
-
-class AuthenticatedUser(BaseModel):
-    """Represents an authenticated user."""
-
-    user_id: UUID
-    tenant_id: UUID
-    email: str | None = None
-
-
-async def get_current_user(
-    auth_context: AuthContext = Depends(get_auth_context),
-) -> AuthenticatedUser:
-    """
-    Get the current authenticated user from the auth context.
-
-    Args:
-        auth_context: Authentication context from middleware
-
-    Returns:
-        AuthenticatedUser object with user information
-
-    Raises:
-        HTTPException: If user is not authenticated
-    """
-    if not auth_context.is_authenticated or not auth_context.user_id:
-        raise HTTPException(
-            status_code=401,
-            detail="Authentication required",
-            headers={"WWW-Authenticate": "Bearer"},
-        )
-
-    return AuthenticatedUser(
-        user_id=auth_context.user_id,
-        tenant_id=auth_context.tenant_id,
-        email=auth_context.principal.get("email") if auth_context.principal else None,
-    )
-
-
-async def get_current_user_optional(
-    auth_context: AuthContext = Depends(get_auth_context_optional),
-) -> AuthenticatedUser | None:
-    """
-    Optional authentication - returns None if not authenticated.
-
-    Use this for endpoints that can work both authenticated and unauthenticated,
-    but may provide different functionality based on auth status.
-    """
-    if not auth_context.is_authenticated or not auth_context.user_id:
-        return None
-
-    return AuthenticatedUser(
-        user_id=auth_context.user_id,
-        tenant_id=auth_context.tenant_id,
-        email=auth_context.principal.get("email") if auth_context.principal else None,
-    )
-
-
-# Legacy support - keep the old function names for backward compatibility
-async def get_auth_context_dependency() -> AuthContext:
-    """Get auth context directly (for advanced use cases)."""
-    return await get_auth_context()

package/templates/api/src/boards/api/endpoints/__init__.py

@@ -1,3 +0,0 @@
-"""
-API endpoint modules for Boards backend
-"""

package/templates/api/src/boards/api/endpoints/jobs.py

@@ -1,76 +0,0 @@
-"""Job submission endpoints."""
-
-from __future__ import annotations
-
-from uuid import UUID
-
-from fastapi import APIRouter, Depends, HTTPException
-from pydantic import BaseModel
-from sqlalchemy.ext.asyncio import AsyncSession
-
-from ...database.connection import get_db_session
-from ...jobs import repository as jobs_repo
-from ...logging import get_logger
-from ...workers.actors import process_generation
-from ..auth import AuthenticatedUser, get_current_user
-
-logger = get_logger(__name__)
-
-
-router = APIRouter()
-
-
-class SubmitGenerationRequest(BaseModel):
-    tenant_id: UUID
-    board_id: UUID
-    user_id: UUID
-    generator_name: str
-    artifact_type: str
-    input_params: dict
-
-
-class SubmitGenerationResponse(BaseModel):
-    generation_id: UUID
-
-
-@router.post("/generations", response_model=SubmitGenerationResponse)
-async def submit_generation(
-    body: SubmitGenerationRequest,
-    db: AsyncSession = Depends(get_db_session),
-    current_user: AuthenticatedUser = Depends(get_current_user),
-) -> SubmitGenerationResponse:
-    """Submit a new generation job.
-
-    Requires authentication. The authenticated user's ID and tenant will be used
-    for the generation, overriding any values provided in the request body.
-    """
-    try:
-        # Validate that user has access to the specified board
-        # TODO: Add board access validation logic here
-
-        # Override user_id and tenant_id with authenticated values for security
-        # This prevents users from submitting jobs on behalf of others
-        gen = await jobs_repo.create_generation(
-            db,
-            tenant_id=current_user.tenant_id,  # Use authenticated tenant
-            board_id=body.board_id,
-            user_id=current_user.user_id,  # Use authenticated user
-            generator_name=body.generator_name,
-            artifact_type=body.artifact_type,
-            input_params=body.input_params,
-        )
-
-        # Commit the transaction to ensure job is persisted before enqueueing
-        await db.commit()
-        logger.info(f"Created generation job {gen.id} for user {current_user.user_id}")
-
-        # Enqueue job for processing
-        process_generation.send(str(gen.id))
-        logger.info(f"Enqueued generation job {gen.id}")
-
-        return SubmitGenerationResponse(generation_id=gen.id)
-
-    except Exception as e:
-        logger.error(f"Failed to submit generation: {e}")
-        await db.rollback()
-        raise HTTPException(status_code=500, detail=f"Failed to submit generation: {str(e)}") from e