@weirdfingers/baseboards 0.9.6 → 0.9.7

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

@@ -1,136 +0,0 @@
-"""
-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

@@ -1,148 +0,0 @@
-"""
-Root GraphQL mutation definitions
-"""
-
-from uuid import UUID
-
-import strawberry
-
-from ..types.board import Board, BoardRole
-from ..types.generation import ArtifactType, Generation, UploadArtifactInput
-
-
-# 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.
-
-    Note: Lineage is now captured automatically via artifact resolution.
-    Generator input parameters that reference other generations (as artifact types)
-    will be automatically resolved and lineage will be tracked.
-    """
-
-    board_id: UUID
-    generator_name: str
-    artifact_type: ArtifactType
-    input_params: strawberry.scalars.JSON  # type: ignore[reportInvalidTypeForm]
-
-
-@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)
-
-    @strawberry.mutation(name="uploadArtifact")
-    async def upload_artifact(
-        self, info: strawberry.Info, input: UploadArtifactInput
-    ) -> Generation:
-        """Upload an artifact from URL (synchronous)."""
-        from ..resolvers.upload import upload_artifact_from_url
-
-        return await upload_artifact_from_url(info, input)

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

@@ -1,116 +0,0 @@
-"""
-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

@@ -1,8 +0,0 @@
-"""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

@@ -1,12 +0,0 @@
-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