@weirdfingers/baseboards 0.2.0

package/templates/api/src/boards/graphql/access_control.py

@@ -0,0 +1,136 @@
+"""
+Shared access control logic for GraphQL resolvers
+"""
+
+from enum import Enum
+from typing import TYPE_CHECKING
+
+import strawberry
+
+from ..auth.middleware import get_auth_context_optional
+from ..logging import get_logger
+
+if TYPE_CHECKING:
+    from ..auth.context import AuthContext
+    from ..dbmodels import Boards
+
+logger = get_logger(__name__)
+
+
+@strawberry.enum
+class BoardQueryRole(Enum):
+    """Role filter for board queries"""
+
+    ANY = "any"
+    OWNER = "owner"
+    MEMBER = "member"
+
+
+@strawberry.enum
+class SortOrder(Enum):
+    """Sort order for queries"""
+
+    CREATED_ASC = "created_asc"
+    CREATED_DESC = "created_desc"
+    UPDATED_ASC = "updated_asc"
+    UPDATED_DESC = "updated_desc"
+
+
+async def get_auth_context_from_info(info: strawberry.Info) -> "AuthContext | None":
+    """
+    Extract auth context from GraphQL info object.
+
+    Returns None if request is not available or auth fails.
+    """
+    request = info.context.get("request")
+    if not request:
+        logger.error("Request not found in GraphQL context")
+        return None
+
+    return await get_auth_context_optional(
+        authorization=request.headers.get("authorization"),
+        x_tenant=request.headers.get("x-tenant"),
+    )
+
+
+def can_access_board(board: "Boards", auth_context: "AuthContext | None") -> bool:
+    """
+    Check if a user can access a board based on authorization rules.
+
+    Board is accessible if:
+    1. It's public
+    2. User is the owner
+    3. User is a member
+
+    Args:
+        board: The board to check access for
+        auth_context: The authentication context (can be None)
+
+    Returns:
+        True if access is allowed, False otherwise
+    """
+    # Public boards are accessible to everyone
+    if board.is_public:
+        return True
+
+    # Private boards require authentication
+    if not auth_context or not auth_context.is_authenticated:
+        return False
+
+    # Owner has access
+    if board.owner_id == auth_context.user_id:
+        return True
+
+    # Check if user is a member
+    return any(member.user_id == auth_context.user_id for member in board.board_members)
+
+
+def can_access_board_details(board: "Boards", auth_context: "AuthContext | None") -> bool:
+    """
+    Check if a user can access detailed board information (members, owner, etc).
+
+    Currently same as can_access_board, but separated for future customization.
+    """
+    return can_access_board(board, auth_context)
+
+
+def is_board_owner_or_member(board: "Boards", auth_context: "AuthContext | None") -> bool:
+    """
+    Check if the authenticated user is the owner or a member of the board.
+
+    This is stricter than can_access_board - public access is not sufficient.
+    """
+    if not auth_context or not auth_context.is_authenticated:
+        return False
+
+    # Owner has access
+    if board.owner_id == auth_context.user_id:
+        return True
+
+    # Check if user is a member
+    return any(member.user_id == auth_context.user_id for member in board.board_members)
+
+
+def ensure_preloaded(obj, attr_name: str, error_msg: str | None = None) -> None:
+    """
+    Ensure that a relationship attribute has been preloaded.
+
+    Args:
+        obj: The SQLAlchemy object
+        attr_name: Name of the relationship attribute
+        error_msg: Custom error message (optional)
+
+    Raises:
+        RuntimeError: If the attribute was not preloaded
+    """
+    try:
+        # Try to access the attribute
+        getattr(obj, attr_name)
+    except Exception as e:
+        if "was not loaded" in str(e) or "lazy loading" in str(e):
+            msg = error_msg or (
+                f"Relationship '{attr_name}' was not preloaded. " "Use selectinload() in the query."
+            )
+            raise RuntimeError(msg) from e
+        # Re-raise other exceptions
+        raise

package/templates/api/src/boards/graphql/mutations/root.py

@@ -0,0 +1,136 @@
+"""
+Root GraphQL mutation definitions
+"""
+
+from uuid import UUID
+
+import strawberry
+
+from ..types.board import Board, BoardRole
+from ..types.generation import ArtifactType, Generation
+
+
+# Input types for mutations
+@strawberry.input
+class CreateBoardInput:
+    """Input for creating a new board."""
+
+    title: str
+    description: str | None = None
+    is_public: bool = False
+    settings: strawberry.scalars.JSON | None = None  # type: ignore[reportInvalidTypeForm]
+
+
+@strawberry.input
+class UpdateBoardInput:
+    """Input for updating a board."""
+
+    id: UUID
+    title: str | None = None
+    description: str | None = None
+    is_public: bool | None = None
+    settings: strawberry.scalars.JSON | None = None  # type: ignore[reportInvalidTypeForm]
+
+
+@strawberry.input
+class AddBoardMemberInput:
+    """Input for adding a board member."""
+
+    board_id: UUID
+    user_id: UUID
+    role: BoardRole = BoardRole.VIEWER
+
+
+@strawberry.input
+class CreateGenerationInput:
+    """Input for creating a new generation."""
+
+    board_id: UUID
+    generator_name: str
+    artifact_type: ArtifactType
+    input_params: strawberry.scalars.JSON  # type: ignore[reportInvalidTypeForm]
+    parent_generation_id: UUID | None = None
+    input_generation_ids: list[UUID] | None = None
+
+
+@strawberry.type
+class Mutation:
+    """Root GraphQL mutation type."""
+
+    # Board mutations
+    @strawberry.mutation(name="createBoard")
+    async def create_board(self, info: strawberry.Info, input: CreateBoardInput) -> Board:
+        """Create a new board."""
+        from ..resolvers.board import create_board
+
+        return await create_board(info, input)
+
+    @strawberry.mutation(name="updateBoard")
+    async def update_board(self, info: strawberry.Info, input: UpdateBoardInput) -> Board:
+        """Update an existing board."""
+        from ..resolvers.board import update_board
+
+        return await update_board(info, input)
+
+    @strawberry.mutation(name="deleteBoard")
+    async def delete_board(self, info: strawberry.Info, id: UUID) -> bool:
+        """Delete a board."""
+        from ..resolvers.board import delete_board
+
+        return await delete_board(info, id)
+
+    @strawberry.mutation(name="addBoardMember")
+    async def add_board_member(self, info: strawberry.Info, input: AddBoardMemberInput) -> Board:
+        """Add a member to a board."""
+        from ..resolvers.board import add_board_member
+
+        return await add_board_member(info, input)
+
+    @strawberry.mutation(name="removeBoardMember")
+    async def remove_board_member(
+        self, info: strawberry.Info, board_id: UUID, user_id: UUID
+    ) -> Board:
+        """Remove a member from a board."""
+        from ..resolvers.board import remove_board_member
+
+        return await remove_board_member(info, board_id, user_id)
+
+    @strawberry.mutation(name="updateBoardMemberRole")
+    async def update_board_member_role(
+        self, info: strawberry.Info, board_id: UUID, user_id: UUID, role: BoardRole
+    ) -> Board:
+        """Update a board member's role."""
+        from ..resolvers.board import update_board_member_role
+
+        return await update_board_member_role(info, board_id, user_id, role)
+
+    # Generation mutations
+    @strawberry.mutation(name="createGeneration")
+    async def create_generation(
+        self, info: strawberry.Info, input: CreateGenerationInput
+    ) -> Generation:
+        """Create a new generation (start a job)."""
+        from ..resolvers.generation import create_generation
+
+        return await create_generation(info, input)
+
+    @strawberry.mutation(name="cancelGeneration")
+    async def cancel_generation(self, info: strawberry.Info, id: UUID) -> Generation:
+        """Cancel a pending or processing generation."""
+        from ..resolvers.generation import cancel_generation
+
+        return await cancel_generation(info, id)
+
+    @strawberry.mutation(name="deleteGeneration")
+    async def delete_generation(self, info: strawberry.Info, id: UUID) -> bool:
+        """Delete a generation."""
+        from ..resolvers.generation import delete_generation
+
+        return await delete_generation(info, id)
+
+    @strawberry.mutation
+    async def regenerate(self, info: strawberry.Info, id: UUID) -> Generation:
+        """Regenerate from an existing generation."""
+        from ..resolvers.generation import regenerate
+
+        return await regenerate(info, id)

package/templates/api/src/boards/graphql/queries/root.py

@@ -0,0 +1,116 @@
+"""
+Root GraphQL query definitions
+"""
+
+from uuid import UUID
+
+import strawberry
+
+from ..access_control import BoardQueryRole, SortOrder
+from ..types.board import Board
+from ..types.generation import ArtifactType, Generation, GenerationStatus
+from ..types.generator import GeneratorInfo
+from ..types.user import User
+
+
+@strawberry.type
+class Query:
+    """Root GraphQL query type."""
+
+    @strawberry.field
+    async def me(self, info: strawberry.Info) -> User | None:
+        """Get the current authenticated user."""
+        from ..resolvers.auth import resolve_current_user
+
+        return await resolve_current_user(info)
+
+    @strawberry.field
+    async def user(self, info: strawberry.Info, id: UUID) -> User | None:
+        """Get a user by ID."""
+        from ..resolvers.user import resolve_user_by_id
+
+        return await resolve_user_by_id(info, str(id))
+
+    @strawberry.field
+    async def board(self, info: strawberry.Info, id: UUID) -> Board | None:
+        """Get a board by ID."""
+        from ..resolvers.board import resolve_board_by_id
+
+        return await resolve_board_by_id(info, id)
+
+    @strawberry.field
+    async def my_boards(
+        self,
+        info: strawberry.Info,
+        limit: int | None = 50,
+        offset: int | None = 0,
+        role: BoardQueryRole | None = None,
+        sort: SortOrder | None = None,
+    ) -> list[Board]:
+        """Get boards owned by or shared with the current user."""
+        from ..resolvers.board import resolve_my_boards
+
+        return await resolve_my_boards(
+            info,
+            limit or 50,
+            offset or 0,
+            role or BoardQueryRole.ANY,
+            sort or SortOrder.UPDATED_DESC,
+        )
+
+    @strawberry.field
+    async def public_boards(
+        self,
+        info: strawberry.Info,
+        limit: int | None = 50,
+        offset: int | None = 0,
+        sort: SortOrder | None = None,
+    ) -> list[Board]:
+        """Get public boards."""
+        from ..resolvers.board import resolve_public_boards
+
+        return await resolve_public_boards(
+            info, limit or 50, offset or 0, sort or SortOrder.UPDATED_DESC
+        )
+
+    @strawberry.field
+    async def generation(self, info: strawberry.Info, id: UUID) -> Generation | None:
+        """Get a generation by ID."""
+        from ..resolvers.generation import resolve_generation_by_id
+
+        return await resolve_generation_by_id(info, id)
+
+    @strawberry.field
+    async def recent_generations(
+        self,
+        info: strawberry.Info,
+        board_id: UUID | None = None,
+        status: GenerationStatus | None = None,
+        artifact_type: ArtifactType | None = None,
+        limit: int | None = 50,
+        offset: int | None = 0,
+    ) -> list[Generation]:
+        """Get recent generations with optional filters."""
+        from ..resolvers.generation import resolve_recent_generations
+
+        return await resolve_recent_generations(
+            info, board_id, status, artifact_type, limit or 50, offset or 0
+        )
+
+    @strawberry.field
+    async def search_boards(
+        self, info: strawberry.Info, query: str, limit: int | None = 50, offset: int | None = 0
+    ) -> list[Board]:
+        """Search for boards by title or description."""
+        from ..resolvers.board import search_boards
+
+        return await search_boards(info, query, limit or 50, offset or 0)
+
+    @strawberry.field
+    async def generators(
+        self, info: strawberry.Info, artifact_type: str | None = None
+    ) -> list[GeneratorInfo]:
+        """Get all available generators, optionally filtered by artifact type."""
+        from ..resolvers.generator import resolve_generators
+
+        return await resolve_generators(info, artifact_type)

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

@@ -0,0 +1,8 @@
+"""Resolver package for GraphQL schema.
+
+This package provides resolver function stubs referenced by the GraphQL types,
+queries, and mutations. Implementations should be provided to connect to the
+database and application services.
+"""
+
+# Intentionally empty; functions are defined in sibling modules.

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

@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import strawberry
+
+if TYPE_CHECKING:
+    from ..types.user import User
+
+
+async def resolve_current_user(info: strawberry.Info) -> User | None:
+    raise NotImplementedError