@weirdfingers/baseboards 0.9.5 → 0.9.7

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

@@ -1,262 +0,0 @@
-"""
-Configuration validation for Boards application.
-
-This module provides validation functions to ensure the application
-is properly configured before startup.
-"""
-
-from __future__ import annotations
-
-from typing import Any
-
-from .config import settings
-from .database.connection import get_async_session, test_database_connection
-from .database.seed_data import ensure_default_tenant
-from .logging import get_logger
-
-logger = get_logger(__name__)
-
-
-class ValidationError(Exception):
-    """Raised when application validation fails."""
-
-    pass
-
-
-async def validate_database_connection() -> dict[str, Any]:
-    """
-    Validate that the database is accessible and responsive.
-
-    This runs before other validation checks to catch connection issues early
-    with clear error messages.
-
-    Returns a dictionary with validation results and connection details.
-    """
-    results = {
-        "valid": True,
-        "warnings": [],
-        "errors": [],
-        "connection_info": None,
-    }
-
-    success, error_message = await test_database_connection()
-
-    if success:
-        results["connection_info"] = {
-            "status": "connected",
-            "message": "Database connection successful",
-        }
-        logger.info("Database connection validation successful")
-    else:
-        results["valid"] = False
-        results["errors"].append(error_message)
-        logger.error("Database connection validation failed", error=error_message)
-
-    return results
-
-
-async def validate_tenant_configuration() -> dict[str, Any]:
-    """
-    Validate tenant configuration and setup.
-
-    Returns a dictionary with validation results and recommendations.
-    Raises ValidationError if critical validation fails.
-    """
-    results = {
-        "valid": True,
-        "warnings": [],
-        "errors": [],
-        "tenant_info": None,
-    }
-
-    try:
-        async with get_async_session() as db:
-            if settings.multi_tenant_mode:
-                # Multi-tenant mode - just validate database connection
-                results["tenant_info"] = {
-                    "mode": "multi_tenant",
-                    "message": "Multi-tenant mode enabled - tenants managed dynamically",
-                }
-                logger.info("Tenant validation: Multi-tenant mode configured")
-
-            else:
-                # Single-tenant mode - ensure default tenant exists
-                try:
-                    tenant_id = await ensure_default_tenant(db)
-                    results["tenant_info"] = {
-                        "mode": "single_tenant",
-                        "tenant_id": str(tenant_id),
-                        "slug": settings.default_tenant_slug,
-                        "message": f"Default tenant exists: {tenant_id}",
-                    }
-                    logger.info(
-                        "Tenant validation: Default tenant verified",
-                        tenant_id=str(tenant_id),
-                        slug=settings.default_tenant_slug,
-                    )
-
-                except Exception as e:
-                    error_msg = f"Failed to ensure default tenant exists: {str(e)}"
-                    results["errors"].append(error_msg)
-                    results["valid"] = False
-                    logger.error("Tenant validation failed", error=str(e))
-
-    except Exception as e:
-        error_msg = f"Database connection failed during tenant validation: {str(e)}"
-        results["errors"].append(error_msg)
-        results["valid"] = False
-        logger.error("Database validation failed", error=str(e))
-
-    return results
-
-
-async def validate_auth_configuration() -> dict[str, Any]:
-    """
-    Validate authentication configuration.
-
-    Returns validation results and security recommendations.
-    """
-    results = {
-        "valid": True,
-        "warnings": [],
-        "errors": [],
-        "auth_info": {
-            "provider": settings.auth_provider,
-            "multi_tenant_mode": settings.multi_tenant_mode,
-        },
-    }
-
-    # Validate auth provider configuration
-    if settings.auth_provider == "none":
-        if settings.environment.lower() in ("production", "prod"):
-            warning = "No-auth mode detected in production environment - this is a security risk!"
-            results["warnings"].append(warning)
-            logger.warning(warning)
-        else:
-            logger.info("Auth validation: No-auth mode enabled for development")
-
-    elif settings.auth_provider == "jwt":
-        if not settings.jwt_secret:
-            error = "JWT authentication enabled but JWT_SECRET not configured"
-            results["errors"].append(error)
-            results["valid"] = False
-            logger.error(error)
-        else:
-            logger.info("Auth validation: JWT authentication configured")
-
-    else:
-        logger.info(f"Auth validation: Using {settings.auth_provider} provider")
-
-    return results
-
-
-async def validate_startup_configuration() -> dict[str, Any]:
-    """
-    Comprehensive startup validation.
-
-    This function should be called during application startup to ensure
-    all critical configuration is valid.
-    """
-    logger.info("Starting application configuration validation")
-
-    # Test database connection first - this catches common issues early
-    db_results = await validate_database_connection()
-
-    # Only proceed with other validations if database is accessible
-    if db_results["valid"]:
-        tenant_results = await validate_tenant_configuration()
-        auth_results = await validate_auth_configuration()
-    else:
-        # Skip tenant/auth validation if database is not accessible
-        logger.warning("Skipping tenant and auth validation due to database connection failure")
-        tenant_results = {
-            "valid": False,
-            "warnings": [],
-            "errors": ["Skipped due to database connection failure"],
-            "tenant_info": None,
-        }
-        auth_results = await validate_auth_configuration()  # Auth can validate without DB
-
-    # Combine results
-    combined_results = {
-        "overall_valid": db_results["valid"] and tenant_results["valid"] and auth_results["valid"],
-        "database": db_results,
-        "tenant": tenant_results,
-        "auth": auth_results,
-        "environment": {
-            "auth_provider": settings.auth_provider,
-            "multi_tenant_mode": settings.multi_tenant_mode,
-            "environment": settings.environment,
-            "debug": settings.debug,
-        },
-    }
-
-    # Log summary
-    if combined_results["overall_valid"]:
-        logger.info("Application configuration validation completed successfully")
-    else:
-        all_errors = (
-            db_results.get("errors", [])
-            + tenant_results.get("errors", [])
-            + auth_results.get("errors", [])
-        )
-        logger.error(
-            "Application configuration validation failed",
-            errors=all_errors,
-        )
-
-    # Log warnings
-    all_warnings = (
-        db_results.get("warnings", [])
-        + tenant_results.get("warnings", [])
-        + auth_results.get("warnings", [])
-    )
-    if all_warnings:
-        logger.warning(
-            "Configuration warnings detected",
-            warnings=all_warnings,
-        )
-
-    return combined_results
-
-
-def get_startup_recommendations(validation_results: dict[str, Any]) -> list[str]:
-    """
-    Generate startup recommendations based on validation results.
-    """
-    recommendations = []
-
-    # Database recommendations
-    if not validation_results.get("database", {}).get("valid", False):
-        recommendations.append(
-            "Database connection failed - check that PostgreSQL is running and accessible"
-        )
-        return recommendations  # Return early if database is not accessible
-
-    # Tenant recommendations
-    tenant_info = validation_results["tenant"].get("tenant_info")
-    if tenant_info and tenant_info["mode"] == "single_tenant":
-        recommendations.append(f"Single-tenant mode active with tenant: {tenant_info['tenant_id']}")
-
-    # Auth recommendations
-    auth_info = validation_results["auth"]["auth_info"]
-    if auth_info["provider"] == "none" and settings.environment.lower() not in (
-        "development",
-        "dev",
-    ):
-        recommendations.append(
-            "Consider configuring a proper authentication provider for non-development environments"
-        )
-
-    # Error recommendations
-    if not validation_results["overall_valid"]:
-        recommendations.append("Fix configuration errors before deploying to production")
-
-    # Success recommendations
-    if validation_results["overall_valid"] and not recommendations:
-        if auth_info["multi_tenant_mode"]:
-            recommendations.append("Multi-tenant configuration is ready for operation")
-        else:
-            recommendations.append("Single-tenant configuration is ready for operation")
-
-    return recommendations

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

@@ -1 +0,0 @@
-"""Workers package: Dramatiq actors and execution utilities."""

package/templates/api/src/boards/workers/actors.py

@@ -1,274 +0,0 @@
-"""Dramatiq actors for generation processing."""
-
-from __future__ import annotations
-
-import traceback
-from typing import Any
-
-import dramatiq
-from dramatiq import actor
-from dramatiq.brokers.redis import RedisBroker
-from dramatiq.middleware import AsyncIO
-
-from ..config import Settings
-from ..database.connection import get_async_session
-from ..generators.registry import registry as generator_registry
-from ..jobs import repository as jobs_repo
-from ..logging import get_logger
-from ..progress.models import ProgressUpdate
-from ..progress.publisher import ProgressPublisher
-from ..storage.factory import create_storage_manager
-from .context import GeneratorExecutionContext
-from .middleware import GeneratorLoaderMiddleware
-
-logger = get_logger(__name__)
-
-
-settings = Settings()
-broker = RedisBroker(url=settings.redis_url)
-dramatiq.set_broker(broker)
-
-# Enable async actor support - Dramatiq will manage event loops per thread
-# This avoids the event loop conflicts from using asyncio.run()
-broker.add_middleware(AsyncIO())
-
-# Load generators when worker process starts via middleware
-# Middleware runs before_worker_boot hook once per worker process at startup
-broker.add_middleware(GeneratorLoaderMiddleware())
-
-
-@actor(queue_name="boards-jobs", max_retries=3, min_backoff=5000, max_backoff=30000)
-async def process_generation(generation_id: str) -> None:
-    """Entry actor: load job context and dispatch to the generator.
-
-    Retry policy:
-    - max_retries: 3 attempts
-    - min_backoff: 5 seconds
-    - max_backoff: 30 seconds
-
-    Note: This is an async actor. Dramatiq manages the event loop lifecycle properly,
-    avoiding the event loop conflicts that would occur with asyncio.run().
-
-    Process a generation job with comprehensive error handling.
-    """
-    logger.info("Starting generation processing", generation_id=generation_id)
-
-    publisher = ProgressPublisher(settings)
-
-    try:
-        # Initialize processing
-        await publisher.publish_progress(
-            generation_id,
-            ProgressUpdate(
-                job_id=generation_id,
-                status="processing",
-                progress=0.0,
-                phase="initializing",
-            ),
-        )
-
-        # Load generation from DB
-        async with get_async_session() as session:
-            gen = await jobs_repo.get_generation(session, generation_id)
-            # Access all attributes while session is active to avoid DetachedInstanceError
-            generator_name = gen.generator_name
-            input_params = gen.input_params
-            gen_id = gen.id
-            tenant_id = gen.tenant_id
-            board_id = gen.board_id
-            user_id = gen.user_id
-            artifact_type = gen.artifact_type
-
-        # Initialize storage manager
-        # This will use the default storage configuration from environment/config
-        storage_manager = create_storage_manager()
-
-        # Validate generator exists
-        generator = generator_registry.get(generator_name)
-        if generator is None:
-            error_msg = "Unknown generator"
-            logger.error(error_msg, generator_name=generator_name)
-            raise RuntimeError(f"Unknown generator: {generator_name}")
-
-        # Build and validate typed inputs
-        # First resolve any artifact fields (generation IDs -> artifact objects)
-        # This happens automatically via type introspection
-        lineage_metadata: list[dict[str, Any]] = []
-        try:
-            input_schema = generator.get_input_schema()
-
-            # Automatically resolve generation IDs to artifacts before validation
-            from ..generators.artifact_resolution import resolve_input_artifacts
-
-            async with get_async_session() as session:
-                resolved_params, lineage_metadata = await resolve_input_artifacts(
-                    input_params,
-                    input_schema,  # Schema is introspected to find artifact fields
-                    session,
-                    tenant_id,
-                )
-
-                # Store lineage metadata in the generation
-                if lineage_metadata:
-                    generation = await jobs_repo.get_generation(session, generation_id)
-                    generation.input_artifacts = lineage_metadata
-                    await session.commit()
-
-            typed_inputs = input_schema.model_validate(resolved_params)
-        except Exception as e:
-            error_msg = "Invalid input parameters"
-            logger.error(error_msg, generation_id=generation_id, error=str(e))
-            raise ValueError(f"Invalid input parameters: {e}") from e
-
-        # Build context and run generator
-        context = GeneratorExecutionContext(
-            gen_id,
-            publisher,
-            storage_manager,
-            tenant_id,
-            board_id,
-            user_id,
-            generator_name,
-            artifact_type,
-            input_params,
-        )
-
-        await publisher.publish_progress(
-            generation_id,
-            ProgressUpdate(
-                job_id=generation_id,
-                status="processing",
-                progress=0.05,
-                phase="processing",
-                message="Starting generation",
-            ),
-        )
-
-        # Execute generator
-        logger.info(
-            "Executing generator",
-            generator_name=generator_name,
-            generation_id=generation_id,
-        )
-        # TODO: Consider implementing credit refund logic on failure
-        # await refund_credits(gen.user_id, gen.estimated_cost)
-        output = await generator.generate(typed_inputs, context)
-        logger.info(
-            "Generator completed successfully",
-            generator_name=generator_name,
-            generation_id=generation_id,
-            artifact_count=len(output.outputs),
-        )
-
-        # Find the artifact with matching generation_id (primary generation)
-        # Generators should return exactly one artifact with the matching generation_id
-        matching_artifacts = [art for art in output.outputs if art.generation_id == generation_id]
-
-        if len(matching_artifacts) == 0:
-            raise RuntimeError(
-                f"No artifact found with generation_id {generation_id} in generator output. "
-                f"Generator returned {len(output.outputs)} artifact(s) but none matched."
-            )
-
-        if len(matching_artifacts) > 1:
-            logger.warning(
-                "Generator returned multiple artifacts with same generation_id, using first one",
-                generation_id=generation_id,
-                artifact_count=len(matching_artifacts),
-            )
-
-        artifact = matching_artifacts[0]
-
-        # Extract storage URL and convert artifact to dict
-        storage_url = artifact.storage_url
-        output_metadata = artifact.model_dump()
-
-        # If this was a batch generation, add batch metadata to primary generation
-        if context._batch_id is not None:
-            output_metadata["batch_id"] = context._batch_id
-            output_metadata["batch_index"] = 0
-            output_metadata["batch_size"] = len(output.outputs)
-            logger.info(
-                "Primary generation is part of batch",
-                generation_id=generation_id,
-                batch_id=context._batch_id,
-                batch_size=len(output.outputs),
-            )
-
-        # Finalize DB with storage URL and output metadata
-        async with get_async_session() as session:
-            await jobs_repo.finalize_success(
-                session,
-                generation_id,
-                storage_url=storage_url,
-                output_metadata=output_metadata,
-            )
-
-        # Finalize all batch generation records (if any)
-        if context._batch_id is not None:
-            batch_artifacts = [art for art in output.outputs if art.generation_id != generation_id]
-            logger.info(
-                "Finalizing batch generation records",
-                batch_id=context._batch_id,
-                batch_count=len(batch_artifacts),
-            )
-            for batch_artifact in batch_artifacts:
-                async with get_async_session() as session:
-                    batch_metadata = batch_artifact.model_dump()
-                    # Add batch metadata to each batch generation
-                    batch_metadata["batch_id"] = context._batch_id
-                    # batch_index was set during generation creation via create_batch_generation()
-                    batch_metadata["batch_size"] = len(output.outputs)
-
-                    await jobs_repo.finalize_success(
-                        session,
-                        batch_artifact.generation_id,
-                        storage_url=batch_artifact.storage_url,
-                        output_metadata=batch_metadata,
-                    )
-                    logger.info(
-                        "Batch generation finalized",
-                        batch_generation_id=batch_artifact.generation_id,
-                        batch_id=context._batch_id,
-                    )
-
-        logger.info("Job finalized successfully", generation_id=generation_id)
-
-        # Publish completion (DB already updated by finalize_success)
-        await publisher.publish_only(
-            generation_id,
-            ProgressUpdate(
-                job_id=generation_id,
-                status="completed",
-                progress=1.0,
-                phase="finalizing",
-                message="Completed",
-            ),
-        )
-
-    except Exception as e:
-        # Log the full traceback for debugging
-        logger.error(
-            "Job failed with error",
-            generation_id=generation_id,
-            error=str(e),
-            traceback=traceback.format_exc(),
-        )
-
-        # Publish failure status (this also persists to DB via ProgressPublisher)
-        try:
-            await publisher.publish_progress(
-                generation_id,
-                ProgressUpdate(
-                    job_id=generation_id,
-                    status="failed",
-                    progress=0.0,
-                    phase="finalizing",
-                    message=str(e),
-                ),
-            )
-        except Exception as pub_error:
-            logger.error("Failed to publish error status", error=str(pub_error))
-
-        # Re-raise for Dramatiq retry mechanism
-        # raise

package/templates/api/src/boards/workers/cli.py

@@ -1,125 +0,0 @@
-#!/usr/bin/env python3
-"""
-CLI entry point for Boards background workers.
-
-For auto-reload during development, use a file watcher like entr or nodemon:
-
-    # Using entr (recommended):
-    make dev-worker-watch
-
-    # Or manually with entr:
-    find packages/backend/src -name '*.py' | entr -r uv run boards-worker
-
-    # Using nodemon:
-    nodemon --watch packages/backend/src --exec "uv run boards-worker"
-"""
-
-import sys
-
-import click
-
-from boards import __version__
-from boards.logging import configure_logging, get_logger
-
-logger = get_logger(__name__)
-
-
-def start_worker(
-    processes: int,
-    threads: int,
-    queue_list: list[str],
-    log_level: str,
-) -> None:
-    """Start the Dramatiq worker process."""
-    # Configure logging
-    configure_logging(debug=(log_level == "debug"))
-
-    try:
-        # Import workers to register them (if they exist)
-        try:
-            from boards.workers import actors  # noqa: F401
-        except ImportError:
-            logger.warning("No worker actors found - continuing with empty worker")
-
-        # Start the worker
-        from dramatiq.cli import main as dramatiq_main
-
-        # Build dramatiq CLI args
-        args = [
-            "dramatiq",
-            "boards.workers.actors",
-            f"--processes={processes}",
-            f"--threads={threads}",
-        ]
-
-        for queue in queue_list:
-            args.extend(["--queues", queue])
-
-        # Override sys.argv for dramatiq CLI
-        original_argv = sys.argv
-        sys.argv = args
-
-        dramatiq_main()
-
-    except KeyboardInterrupt:
-        logger.info("Worker shutdown requested by user")
-    except Exception as e:
-        logger.error("Worker startup failed", error=str(e))
-        sys.exit(1)
-    finally:
-        # Restore original argv
-        sys.argv = original_argv
-
-
-@click.command()
-@click.option(
-    "--processes",
-    default=1,
-    type=int,
-    help="Number of worker processes (default: 1)",
-)
-@click.option(
-    "--threads",
-    default=1,
-    type=int,
-    help="Number of worker threads per process (default: 1)",
-)
-@click.option(
-    "--queues",
-    default="boards-jobs",
-    help="Comma-separated list of queues to process (default: boards-jobs)",
-)
-@click.option(
-    "--log-level",
-    default="info",
-    type=click.Choice(["debug", "info", "warning", "error"]),
-    help="Log level (default: info)",
-)
-@click.version_option(version=__version__, prog_name="boards-worker")
-def main(
-    processes: int,
-    threads: int,
-    queues: str,
-    log_level: str,
-) -> None:
-    """Start Boards background workers."""
-
-    # Configure logging
-    configure_logging(debug=(log_level == "debug"))
-
-    queue_list = [q.strip() for q in queues.split(",")]
-
-    logger.info(
-        "Starting Boards workers",
-        processes=processes,
-        threads=threads,
-        queues=queue_list,
-        log_level=log_level,
-    )
-
-    start_worker(processes, threads, queue_list, log_level)
-
-
-# meaningless
-if __name__ == "__main__":
-    main()