@weirdfingers/baseboards 0.9.5 → 0.9.7

package/templates/api/src/boards/graphql/resolvers/generation.py

@@ -1,666 +0,0 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING
-from uuid import UUID
-
-import strawberry
-from sqlalchemy import or_, select
-from sqlalchemy.orm import selectinload
-
-from ...database.connection import get_async_session
-from ...dbmodels import BoardMembers, Boards, Generations, Users
-from ...generators.registry import registry as generator_registry
-from ...jobs import repository as jobs_repo
-from ...logging import get_logger
-from ...workers.actors import process_generation
-from ..access_control import can_access_board, get_auth_context_from_info
-
-if TYPE_CHECKING:
-    from ..mutations.root import CreateGenerationInput
-    from ..types.board import Board
-    from ..types.generation import ArtifactType, Generation, GenerationStatus
-    from ..types.user import User
-
-logger = get_logger(__name__)
-
-
-# Query resolvers
-async def resolve_generation_by_id(info: strawberry.Info, id: UUID) -> Generation | None:
-    """
-    Resolve a generation by its ID.
-
-    Checks authorization: user must have access to the generation's board.
-    """
-    auth_context = await get_auth_context_from_info(info)
-    if auth_context is None:
-        return None
-
-    async with get_async_session() as session:
-        # Query generation
-        stmt = select(Generations).where(Generations.id == id)
-        result = await session.execute(stmt)
-        gen = result.scalar_one_or_none()
-
-        if not gen:
-            logger.info("Generation not found", generation_id=str(id))
-            return None
-
-        # Check board access
-        board_stmt = (
-            select(Boards)
-            .where(Boards.id == gen.board_id)
-            .options(selectinload(Boards.board_members))
-        )
-        board_result = await session.execute(board_stmt)
-        board = board_result.scalar_one_or_none()
-
-        if not board or not can_access_board(board, auth_context):
-            logger.info(
-                "Access denied to generation",
-                generation_id=str(id),
-                board_id=str(gen.board_id),
-                user_id=(
-                    str(auth_context.user_id) if auth_context and auth_context.user_id else None
-                ),
-            )
-            return None
-
-        # Convert to GraphQL type
-        from ..types.generation import ArtifactType, GenerationStatus
-        from ..types.generation import Generation as GenerationType
-
-        return GenerationType(
-            id=gen.id,
-            tenant_id=gen.tenant_id,
-            board_id=gen.board_id,
-            user_id=gen.user_id,
-            generator_name=gen.generator_name,
-            artifact_type=ArtifactType(gen.artifact_type),
-            storage_url=gen.storage_url,
-            thumbnail_url=gen.thumbnail_url,
-            additional_files=gen.additional_files or [],
-            input_params=gen.input_params or {},
-            output_metadata=gen.output_metadata or {},
-            external_job_id=gen.external_job_id,
-            status=GenerationStatus(gen.status),
-            progress=float(gen.progress or 0.0),
-            error_message=gen.error_message,
-            started_at=gen.started_at,
-            completed_at=gen.completed_at,
-            created_at=gen.created_at,
-            updated_at=gen.updated_at,
-        )
-
-
-async def resolve_recent_generations(
-    info: strawberry.Info,
-    board_id: UUID | None,
-    status: GenerationStatus | None,
-    artifact_type: ArtifactType | None,
-    limit: int,
-    offset: int,
-) -> list[Generation]:
-    """
-    Resolve recent generations with filtering.
-
-    If board_id is None, returns generations from all boards the user has access to.
-    """
-    auth_context = await get_auth_context_from_info(info)
-    if not auth_context or not auth_context.is_authenticated:
-        logger.info("Unauthenticated access to recent_generations")
-        return []
-
-    async with get_async_session() as session:
-        # Build base query
-        generations_query = select(Generations)
-
-        # Apply filters
-        if board_id is not None:
-            # Check access to specific board
-            board_stmt = (
-                select(Boards)
-                .where(Boards.id == board_id)
-                .options(selectinload(Boards.board_members))
-            )
-            board_result = await session.execute(board_stmt)
-            board = board_result.scalar_one_or_none()
-
-            if not board or not can_access_board(board, auth_context):
-                logger.info(
-                    "Access denied to board for recent generations",
-                    board_id=str(board_id),
-                    user_id=str(auth_context.user_id),
-                )
-                return []
-
-            generations_query = generations_query.where(Generations.board_id == board_id)
-        else:
-            # Get all boards user has access to
-            member_board_ids = select(BoardMembers.board_id).where(
-                BoardMembers.user_id == auth_context.user_id
-            )
-            accessible_boards_condition = or_(
-                Boards.owner_id == auth_context.user_id,
-                Boards.id.in_(member_board_ids),
-                Boards.is_public,
-            )
-            accessible_boards_stmt = select(Boards.id).where(accessible_boards_condition)
-            accessible_boards_result = await session.execute(accessible_boards_stmt)
-            accessible_board_ids = [row[0] for row in accessible_boards_result.all()]
-
-            if not accessible_board_ids:
-                return []
-
-            generations_query = generations_query.where(
-                Generations.board_id.in_(accessible_board_ids)
-            )
-
-        # Apply status filter
-        if status is not None:
-            generations_query = generations_query.where(Generations.status == status.value)
-
-        # Apply artifact_type filter
-        if artifact_type is not None:
-            generations_query = generations_query.where(
-                Generations.artifact_type == artifact_type.value
-            )
-
-        # Order by created_at DESC and apply pagination
-        generations_query = (
-            generations_query.order_by(Generations.created_at.desc()).limit(limit).offset(offset)
-        )
-
-        result = await session.execute(generations_query)
-        generations = result.scalars().all()
-
-        # Convert to GraphQL types
-        from ..types.generation import ArtifactType as ArtifactTypeEnum
-        from ..types.generation import Generation as GenerationType
-        from ..types.generation import GenerationStatus as GenerationStatusEnum
-
-        return [
-            GenerationType(
-                id=gen.id,
-                tenant_id=gen.tenant_id,
-                board_id=gen.board_id,
-                user_id=gen.user_id,
-                generator_name=gen.generator_name,
-                artifact_type=ArtifactTypeEnum(gen.artifact_type),
-                storage_url=gen.storage_url,
-                thumbnail_url=gen.thumbnail_url,
-                additional_files=gen.additional_files or [],
-                input_params=gen.input_params or {},
-                output_metadata=gen.output_metadata or {},
-                external_job_id=gen.external_job_id,
-                status=GenerationStatusEnum(gen.status),
-                progress=float(gen.progress or 0.0),
-                error_message=gen.error_message,
-                started_at=gen.started_at,
-                completed_at=gen.completed_at,
-                created_at=gen.created_at,
-                updated_at=gen.updated_at,
-            )
-            for gen in generations
-        ]
-
-
-# Field resolvers
-async def resolve_generation_board(generation: Generation, info: strawberry.Info) -> Board:
-    """Resolve the board this generation belongs to."""
-    auth_context = await get_auth_context_from_info(info)
-
-    async with get_async_session() as session:
-        stmt = (
-            select(Boards)
-            .where(Boards.id == generation.board_id)
-            .options(
-                selectinload(Boards.owner),
-                selectinload(Boards.board_members).selectinload(BoardMembers.user),
-            )
-        )
-        result = await session.execute(stmt)
-        board = result.scalar_one_or_none()
-
-        if not board:
-            raise RuntimeError("Generation board not found")
-
-        if not can_access_board(board, auth_context):
-            raise RuntimeError("Access denied to generation board")
-
-        from ..types.board import Board as BoardType
-
-        return BoardType(
-            id=board.id,
-            tenant_id=board.tenant_id,
-            owner_id=board.owner_id,
-            title=board.title,
-            description=board.description,
-            is_public=board.is_public,
-            settings=board.settings or {},
-            metadata=board.metadata_ or {},
-            created_at=board.created_at,
-            updated_at=board.updated_at,
-        )
-
-
-async def resolve_generation_user(generation: Generation, info: strawberry.Info) -> User:
-    """Resolve the user who created this generation."""
-    async with get_async_session() as session:
-        stmt = select(Users).where(Users.id == generation.user_id)
-        result = await session.execute(stmt)
-        user = result.scalar_one_or_none()
-
-        if not user:
-            raise RuntimeError("Generation user not found")
-
-        from ..types.user import User as UserType
-
-        return UserType(
-            id=user.id,
-            tenant_id=user.tenant_id,
-            auth_provider=user.auth_provider,
-            auth_subject=user.auth_subject,
-            email=user.email,
-            display_name=user.display_name,
-            avatar_url=user.avatar_url,
-            created_at=user.created_at,
-            updated_at=user.updated_at,
-        )
-
-
-async def resolve_generation_parent(
-    generation: Generation, info: strawberry.Info
-) -> Generation | None:
-    """DEPRECATED: Use ancestry field instead. This resolver is no longer used."""
-    return None
-
-
-async def resolve_generation_inputs(
-    generation: Generation, info: strawberry.Info
-) -> list[Generation]:  # noqa: E501
-    """DEPRECATED: Use input_artifacts field instead. This resolver is no longer used."""
-    return []
-
-
-async def resolve_generation_children(
-    generation: Generation, info: strawberry.Info
-) -> list[Generation]:  # noqa: E501
-    """DEPRECATED: Use descendants field instead. This resolver is no longer used."""
-    return []
-
-
-# Mutation resolvers
-async def create_generation(info: strawberry.Info, input: CreateGenerationInput) -> Generation:
-    """
-    Create a new generation and enqueue it for processing.
-
-    Requires editor or owner role on the target board.
-    """
-    auth_context = await get_auth_context_from_info(info)
-    if not auth_context or not auth_context.is_authenticated or not auth_context.user_id:
-        raise RuntimeError("Authentication required to create a generation")
-
-    async with get_async_session() as session:
-        # Check board access - require editor or owner role
-        board_stmt = (
-            select(Boards)
-            .where(Boards.id == input.board_id)
-            .options(selectinload(Boards.board_members))
-        )
-        board_result = await session.execute(board_stmt)
-        board = board_result.scalar_one_or_none()
-
-        if not board:
-            raise RuntimeError("Board not found")
-
-        # Check if user is owner or editor
-        is_owner = board.owner_id == auth_context.user_id
-        is_editor = any(
-            member.user_id == auth_context.user_id and member.role in {"editor", "admin"}
-            for member in board.board_members
-        )
-
-        if not is_owner and not is_editor:
-            raise RuntimeError(
-                "Permission denied: only board owner or editor can create generations"
-            )
-
-        # Validate generator exists
-        generator = generator_registry.get(input.generator_name)
-        if generator is None:
-            raise RuntimeError(f"Unknown generator: {input.generator_name}")
-
-        # Create generation record
-        # Note: Lineage will be captured automatically during generation processing
-        # via artifact resolution in the worker (see actors.py)
-        gen = await jobs_repo.create_generation(
-            session,
-            tenant_id=auth_context.tenant_id,
-            board_id=input.board_id,
-            user_id=auth_context.user_id,
-            generator_name=input.generator_name,
-            artifact_type=input.artifact_type.value,
-            input_params=input.input_params,
-        )
-
-        await session.commit()
-        await session.refresh(gen)
-
-        logger.info(
-            "Generation created",
-            generation_id=str(gen.id),
-            board_id=str(input.board_id),
-            user_id=str(auth_context.user_id),
-            generator_name=input.generator_name,
-        )
-
-        # Enqueue job for processing
-        message = process_generation.send(str(gen.id))
-        logger.info(
-            "Generation job enqueued",
-            generation_id=str(gen.id),
-            message_id=message.message_id,
-            queue_name=message.queue_name,
-        )
-
-        # Convert to GraphQL type
-        from ..types.generation import ArtifactType, GenerationStatus
-        from ..types.generation import Generation as GenerationType
-
-        return GenerationType(
-            id=gen.id,
-            tenant_id=gen.tenant_id,
-            board_id=gen.board_id,
-            user_id=gen.user_id,
-            generator_name=gen.generator_name,
-            artifact_type=ArtifactType(gen.artifact_type),
-            storage_url=gen.storage_url,
-            thumbnail_url=gen.thumbnail_url,
-            additional_files=gen.additional_files or [],
-            input_params=gen.input_params or {},
-            output_metadata=gen.output_metadata or {},
-            external_job_id=gen.external_job_id,
-            status=GenerationStatus(gen.status),
-            progress=float(gen.progress or 0.0),
-            error_message=gen.error_message,
-            started_at=gen.started_at,
-            completed_at=gen.completed_at,
-            created_at=gen.created_at,
-            updated_at=gen.updated_at,
-        )
-
-
-async def cancel_generation(info: strawberry.Info, id: UUID) -> Generation:
-    """
-    Cancel a pending or processing generation.
-
-    Requires ownership or editor role on the board.
-    """
-    auth_context = await get_auth_context_from_info(info)
-    if not auth_context or not auth_context.is_authenticated:
-        raise RuntimeError("Authentication required to cancel a generation")
-
-    async with get_async_session() as session:
-        # Query generation
-        stmt = select(Generations).where(Generations.id == id)
-        result = await session.execute(stmt)
-        gen = result.scalar_one_or_none()
-
-        if not gen:
-            raise RuntimeError("Generation not found")
-
-        # Check board access and permissions
-        board_stmt = (
-            select(Boards)
-            .where(Boards.id == gen.board_id)
-            .options(selectinload(Boards.board_members))
-        )
-        board_result = await session.execute(board_stmt)
-        board = board_result.scalar_one_or_none()
-
-        if not board:
-            raise RuntimeError("Board not found")
-
-        # Check authorization
-        is_owner = board.owner_id == auth_context.user_id
-        is_editor = any(
-            member.user_id == auth_context.user_id and member.role in {"editor", "admin"}
-            for member in board.board_members
-        )
-        is_creator = gen.user_id == auth_context.user_id
-
-        # Owner can cancel any generation, editor can only cancel their own
-        if not is_owner and not (is_editor and is_creator):
-            raise RuntimeError(
-                "Permission denied: only board owner or generation creator can cancel"
-            )
-
-        # Validate status
-        if gen.status not in {"pending", "processing"}:
-            raise RuntimeError(
-                f"Cannot cancel generation with status '{gen.status}'. "
-                "Only pending or processing generations can be cancelled."
-            )
-
-        # Update status to cancelled
-        await jobs_repo.update_progress(
-            session,
-            id,
-            status="cancelled",
-            progress=float(gen.progress or 0.0),
-            error_message="Cancelled by user",
-        )
-        await session.commit()
-
-        # Refresh to get updated data
-        await session.refresh(gen)
-
-        logger.info(
-            "Generation cancelled",
-            generation_id=str(id),
-            user_id=str(auth_context.user_id),
-        )
-
-        # Convert to GraphQL type
-        from ..types.generation import ArtifactType, GenerationStatus
-        from ..types.generation import Generation as GenerationType
-
-        return GenerationType(
-            id=gen.id,
-            tenant_id=gen.tenant_id,
-            board_id=gen.board_id,
-            user_id=gen.user_id,
-            generator_name=gen.generator_name,
-            artifact_type=ArtifactType(gen.artifact_type),
-            storage_url=gen.storage_url,
-            thumbnail_url=gen.thumbnail_url,
-            additional_files=gen.additional_files or [],
-            input_params=gen.input_params or {},
-            output_metadata=gen.output_metadata or {},
-            external_job_id=gen.external_job_id,
-            status=GenerationStatus(gen.status),
-            progress=float(gen.progress or 0.0),
-            error_message=gen.error_message,
-            started_at=gen.started_at,
-            completed_at=gen.completed_at,
-            created_at=gen.created_at,
-            updated_at=gen.updated_at,
-        )
-
-
-async def delete_generation(info: strawberry.Info, id: UUID) -> bool:
-    """
-    Delete a generation and its associated storage artifacts.
-
-    Requires ownership or editor role on the board.
-    """
-    auth_context = await get_auth_context_from_info(info)
-    if not auth_context or not auth_context.is_authenticated:
-        raise RuntimeError("Authentication required to delete a generation")
-
-    async with get_async_session() as session:
-        # Query generation
-        stmt = select(Generations).where(Generations.id == id)
-        result = await session.execute(stmt)
-        gen = result.scalar_one_or_none()
-
-        if not gen:
-            raise RuntimeError("Generation not found")
-
-        # Check board access and permissions
-        board_stmt = (
-            select(Boards)
-            .where(Boards.id == gen.board_id)
-            .options(selectinload(Boards.board_members))
-        )
-        board_result = await session.execute(board_stmt)
-        board = board_result.scalar_one_or_none()
-
-        if not board:
-            raise RuntimeError("Board not found")
-
-        # Check authorization
-        is_owner = board.owner_id == auth_context.user_id
-        is_editor = any(
-            member.user_id == auth_context.user_id and member.role in {"editor", "admin"}
-            for member in board.board_members
-        )
-        is_creator = gen.user_id == auth_context.user_id
-
-        # Owner can delete any generation, editor can only delete their own
-        if not is_owner and not (is_editor and is_creator):
-            raise RuntimeError(
-                "Permission denied: only board owner or generation creator can delete"
-            )
-
-        # Delete storage artifacts
-        # TODO: Full storage deletion requires storage_key and storage_provider fields
-        # to be added to the Generations table. For now, we log the deletion intent.
-        # Once those fields are added, use: await storage_manager.delete_artifact(key, provider)
-
-        if gen.storage_url or gen.thumbnail_url or gen.additional_files:
-            logger.info(
-                "Storage artifact deletion",
-                generation_id=str(id),
-                has_storage_url=bool(gen.storage_url),
-                has_thumbnail=bool(gen.thumbnail_url),
-                additional_files_count=(len(gen.additional_files) if gen.additional_files else 0),
-            )
-            logger.warning(
-                "Storage artifact deletion not yet implemented - requires storage_key and "
-                "storage_provider fields in Generations table",
-                generation_id=str(id),
-            )
-
-        # Delete generation from database
-        await session.delete(gen)
-        await session.commit()
-
-        logger.info(
-            "Generation deleted",
-            generation_id=str(id),
-            user_id=str(auth_context.user_id),
-        )
-
-        return True
-
-
-async def regenerate(info: strawberry.Info, id: UUID) -> Generation:
-    """
-    Regenerate from an existing generation.
-
-    Creates a new generation with the same inputs and sets the original as parent.
-    """
-    auth_context = await get_auth_context_from_info(info)
-    if not auth_context or not auth_context.is_authenticated or not auth_context.user_id:
-        raise RuntimeError("Authentication required to regenerate")
-
-    async with get_async_session() as session:
-        # Query original generation
-        stmt = select(Generations).where(Generations.id == id)
-        result = await session.execute(stmt)
-        original = result.scalar_one_or_none()
-
-        if not original:
-            raise RuntimeError("Original generation not found")
-
-        # Check board access - require editor or owner role
-        board_stmt = (
-            select(Boards)
-            .where(Boards.id == original.board_id)
-            .options(selectinload(Boards.board_members))
-        )
-        board_result = await session.execute(board_stmt)
-        board = board_result.scalar_one_or_none()
-
-        if not board:
-            raise RuntimeError("Board not found")
-
-        # Check if user is owner or editor
-        is_owner = board.owner_id == auth_context.user_id
-        is_editor = any(
-            member.user_id == auth_context.user_id and member.role in {"editor", "admin"}
-            for member in board.board_members
-        )
-
-        if not is_owner and not is_editor:
-            raise RuntimeError("Permission denied: only board owner or editor can regenerate")
-
-        # Validate generator still exists
-        generator = generator_registry.get(original.generator_name)
-        if generator is None:
-            raise RuntimeError(f"Generator '{original.generator_name}' is no longer available")
-
-        # Create new generation with copied inputs
-        new_gen = await jobs_repo.create_generation(
-            session,
-            tenant_id=original.tenant_id,
-            board_id=original.board_id,
-            user_id=auth_context.user_id,
-            generator_name=original.generator_name,
-            artifact_type=original.artifact_type,
-            input_params=original.input_params or {},
-        )
-
-        # Note: Lineage will be captured automatically during generation processing
-        # via artifact resolution in the worker (see actors.py)
-
-        await session.commit()
-        await session.refresh(new_gen)
-
-        logger.info(
-            "Generation regenerated",
-            new_generation_id=str(new_gen.id),
-            original_generation_id=str(id),
-            user_id=str(auth_context.user_id),
-        )
-
-        # Enqueue job for processing
-        process_generation.send(str(new_gen.id))
-        logger.info("Regeneration job enqueued", generation_id=str(new_gen.id))
-
-        # Convert to GraphQL type
-        from ..types.generation import ArtifactType, GenerationStatus
-        from ..types.generation import Generation as GenerationType
-
-        return GenerationType(
-            id=new_gen.id,
-            tenant_id=new_gen.tenant_id,
-            board_id=new_gen.board_id,
-            user_id=new_gen.user_id,
-            generator_name=new_gen.generator_name,
-            artifact_type=ArtifactType(new_gen.artifact_type),
-            storage_url=new_gen.storage_url,
-            thumbnail_url=new_gen.thumbnail_url,
-            additional_files=new_gen.additional_files or [],
-            input_params=new_gen.input_params or {},
-            output_metadata=new_gen.output_metadata or {},
-            external_job_id=new_gen.external_job_id,
-            status=GenerationStatus(new_gen.status),
-            progress=float(new_gen.progress or 0.0),
-            error_message=new_gen.error_message,
-            started_at=new_gen.started_at,
-            completed_at=new_gen.completed_at,
-            created_at=new_gen.created_at,
-            updated_at=new_gen.updated_at,
-        )