@weirdfingers/baseboards 0.2.0

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

@@ -0,0 +1,50 @@
+"""
+Generator resolvers for GraphQL API
+"""
+
+import strawberry
+
+from ...generators.registry import registry
+from ..types.generation import ArtifactType
+from ..types.generator import GeneratorInfo
+
+
+async def resolve_generators(
+    info: strawberry.Info,
+    artifact_type: str | None = None,
+) -> list[GeneratorInfo]:
+    """Get all available generators, optionally filtered by artifact type.
+
+    Args:
+        info: GraphQL info context
+        artifact_type: Optional filter by artifact type (image, video, audio, text)
+
+    Returns:
+        List of generator information
+    """
+    _ = info  # Unused but required by GraphQL interface
+
+    # Get generators from registry
+    if artifact_type:
+        generators = registry.list_by_artifact_type(artifact_type)
+    else:
+        generators = registry.list_all()
+
+    # Convert to GraphQL types
+    result = []
+    for gen in generators:
+        input_schema_class = gen.get_input_schema()
+
+        # Convert string artifact_type to enum
+        artifact_type_enum = ArtifactType(gen.artifact_type)
+
+        result.append(
+            GeneratorInfo(
+                name=gen.name,
+                description=gen.description,
+                artifact_type=artifact_type_enum,
+                input_schema=input_schema_class.model_json_schema(),
+            )
+        )
+
+    return result

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

@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import strawberry
+
+if TYPE_CHECKING:
+    from ..types.board import Board
+    from ..types.user import User
+
+
+async def resolve_current_user(info: strawberry.Info) -> User | None:
+    raise NotImplementedError
+
+
+async def resolve_user_by_id(info: strawberry.Info, id: str) -> User | None:
+    raise NotImplementedError
+
+
+async def resolve_user_boards(user: User, info: strawberry.Info) -> list[Board]:
+    raise NotImplementedError
+
+
+async def resolve_user_member_boards(user: User, info: strawberry.Info) -> list[Board]:
+    raise NotImplementedError

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

@@ -0,0 +1,81 @@
+"""
+Main GraphQL schema definition using Strawberry
+"""
+
+from typing import Any
+
+import strawberry
+from fastapi import Request
+from graphql import validate_schema as gql_validate_schema
+from strawberry.fastapi import GraphQLRouter
+
+from ..logging import get_logger
+from .mutations.root import Mutation
+from .queries.root import Query
+
+# Import types to ensure they're registered with Strawberry
+
+logger = get_logger(__name__)
+
+# Create the GraphQL schema
+schema = strawberry.Schema(
+    query=Query,
+    mutation=Mutation,
+    # Note: Introspection is enabled by default in strawberry
+    # TODO: Disable in production for security by using extensions
+)
+
+
+def validate_schema() -> None:
+    """Validate the GraphQL schema at startup.
+
+    This ensures that all type references can be resolved and catches
+    circular reference errors early, causing the server to fail fast
+    rather than returning 404s at runtime.
+
+    Raises:
+        Exception: If the schema is invalid or has unresolved types
+    """
+    try:
+        # Convert to GraphQL core schema to trigger full validation
+        graphql_schema = schema._schema
+
+        # Validate the schema structure
+        errors = gql_validate_schema(graphql_schema)
+        if errors:
+            error_messages = [str(e) for e in errors]
+            raise Exception(f"GraphQL schema validation failed: {'; '.join(error_messages)}")
+
+        # Check that introspection query works (catches most resolution issues)
+        from graphql import get_introspection_query, graphql_sync
+
+        introspection_query = get_introspection_query()
+        result = graphql_sync(graphql_schema, introspection_query)
+
+        if result.errors:
+            error_messages = [str(e) for e in result.errors]
+            raise Exception(f"GraphQL introspection failed: {'; '.join(error_messages)}")
+
+        logger.info("GraphQL schema validation successful")
+
+    except Exception as e:
+        logger.error("GraphQL schema validation failed", error=str(e))
+        raise
+
+
+# Create the GraphQL router for FastAPI integration
+def create_graphql_router() -> GraphQLRouter[dict[str, Any], None]:
+    """Create a GraphQL router for FastAPI."""
+
+    async def get_context(request: Request) -> dict[str, Any]:
+        """Get the context for GraphQL resolvers."""
+        return {
+            "request": request,
+        }
+
+    return GraphQLRouter(
+        schema,
+        path="/graphql",
+        graphiql=True,  # Enable GraphiQL IDE in development
+        context_getter=get_context,
+    )

package/templates/api/src/boards/graphql/types/board.py

@@ -0,0 +1,102 @@
+"""
+Board GraphQL type definitions
+"""
+
+from datetime import datetime
+from enum import Enum
+from typing import TYPE_CHECKING, Annotated
+from uuid import UUID
+
+import strawberry
+
+if TYPE_CHECKING:
+    from .generation import Generation
+    from .user import User
+
+
+@strawberry.enum
+class BoardRole(Enum):
+    """Board member role enumeration."""
+
+    VIEWER = "viewer"
+    EDITOR = "editor"
+    ADMIN = "admin"
+
+
+@strawberry.type
+class BoardMember:
+    """Board member type for GraphQL API."""
+
+    id: UUID
+    board_id: UUID
+    user_id: UUID
+    role: BoardRole
+    invited_by: UUID | None
+    joined_at: datetime
+
+    @strawberry.field
+    async def user(self, info: strawberry.Info) -> Annotated["User", strawberry.lazy(".user")]:
+        """Get the user for this board member."""
+        from ..resolvers.board import resolve_board_member_user
+
+        return await resolve_board_member_user(self, info)
+
+    @strawberry.field
+    async def inviter(
+        self, info: strawberry.Info
+    ) -> Annotated["User", strawberry.lazy(".user")] | None:  # noqa: E501
+        """Get the user who invited this member."""
+        if not self.invited_by:
+            return None
+        from ..resolvers.board import resolve_board_member_inviter
+
+        return await resolve_board_member_inviter(self, info)
+
+
+@strawberry.type
+class Board:
+    """Board type for GraphQL API."""
+
+    id: UUID
+    tenant_id: UUID
+    owner_id: UUID
+    title: str
+    description: str | None
+    is_public: bool
+    settings: strawberry.scalars.JSON  # type: ignore[reportInvalidTypeForm]
+    metadata: strawberry.scalars.JSON  # type: ignore[reportInvalidTypeForm]
+    created_at: datetime
+    updated_at: datetime
+
+    @strawberry.field
+    async def owner(self, info: strawberry.Info) -> Annotated["User", strawberry.lazy(".user")]:
+        """Get the owner of this board."""
+        from ..resolvers.board import resolve_board_owner
+
+        return await resolve_board_owner(self, info)
+
+    @strawberry.field
+    async def members(self, info: strawberry.Info) -> list[BoardMember]:
+        """Get members of this board."""
+        from ..resolvers.board import resolve_board_members
+
+        return await resolve_board_members(self, info)
+
+    @strawberry.field
+    async def generations(
+        self,
+        info: strawberry.Info,
+        limit: int | None = 50,
+        offset: int | None = 0,
+    ) -> list[Annotated["Generation", strawberry.lazy(".generation")]]:
+        """Get generations in this board."""
+        from ..resolvers.board import resolve_board_generations
+
+        return await resolve_board_generations(self, info, limit or 50, offset or 0)
+
+    @strawberry.field
+    async def generation_count(self, info: strawberry.Info) -> int:
+        """Get total number of generations in this board."""
+        from ..resolvers.board import resolve_board_generation_count
+
+        return await resolve_board_generation_count(self, info)

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

@@ -0,0 +1,130 @@
+"""
+Generation GraphQL type definitions
+"""
+
+from datetime import datetime
+from enum import Enum
+from typing import TYPE_CHECKING, Annotated
+from uuid import UUID
+
+import strawberry
+
+if TYPE_CHECKING:
+    from .board import Board
+    from .user import User
+
+
+@strawberry.enum
+class ArtifactType(Enum):
+    """Artifact type enumeration."""
+
+    IMAGE = "image"
+    VIDEO = "video"
+    AUDIO = "audio"
+    TEXT = "text"
+    LORA = "lora"
+    MODEL = "model"
+
+
+@strawberry.enum
+class GenerationStatus(Enum):
+    """Generation status enumeration."""
+
+    PENDING = "pending"
+    PROCESSING = "processing"
+    COMPLETED = "completed"
+    FAILED = "failed"
+    CANCELLED = "cancelled"
+
+
+@strawberry.type
+class AdditionalFile:
+    """Additional file associated with a generation."""
+
+    url: str
+    type: str
+    metadata: strawberry.scalars.JSON  # type: ignore[reportInvalidTypeForm]
+
+
+@strawberry.type
+class Generation:
+    """Generation type for GraphQL API."""
+
+    id: UUID
+    tenant_id: UUID
+    board_id: UUID
+    user_id: UUID
+
+    # Generation details
+    generator_name: str
+    artifact_type: ArtifactType
+
+    # Storage
+    storage_url: str | None
+    thumbnail_url: str | None
+    additional_files: list[AdditionalFile]
+
+    # Parameters and metadata
+    input_params: strawberry.scalars.JSON  # type: ignore[reportInvalidTypeForm]
+    output_metadata: strawberry.scalars.JSON  # type: ignore[reportInvalidTypeForm]
+
+    # Lineage
+    parent_generation_id: UUID | None
+    input_generation_ids: list[UUID]
+
+    # Job tracking
+    external_job_id: str | None
+    status: GenerationStatus
+    progress: float
+    error_message: str | None
+
+    # Timestamps
+    started_at: datetime | None
+    completed_at: datetime | None
+    created_at: datetime
+    updated_at: datetime
+
+    @strawberry.field
+    async def board(self, info: strawberry.Info) -> Annotated["Board", strawberry.lazy(".board")]:
+        """Get the board this generation belongs to."""
+        from ..resolvers.generation import resolve_generation_board
+
+        return await resolve_generation_board(self, info)
+
+    @strawberry.field
+    async def user(self, info: strawberry.Info) -> Annotated["User", strawberry.lazy(".user")]:
+        """Get the user who created this generation."""
+        from ..resolvers.generation import resolve_generation_user
+
+        return await resolve_generation_user(self, info)
+
+    @strawberry.field
+    async def parent(
+        self, info: strawberry.Info
+    ) -> Annotated["Generation", strawberry.lazy(".generation")] | None:  # noqa: E501
+        """Get the parent generation if any."""
+        if not self.parent_generation_id:
+            return None
+        from ..resolvers.generation import resolve_generation_parent
+
+        return await resolve_generation_parent(self, info)
+
+    @strawberry.field
+    async def inputs(
+        self, info: strawberry.Info
+    ) -> list[Annotated["Generation", strawberry.lazy(".generation")]]:  # noqa: E501
+        """Get input generations used for this generation."""
+        if not self.input_generation_ids:
+            return []
+        from ..resolvers.generation import resolve_generation_inputs
+
+        return await resolve_generation_inputs(self, info)
+
+    @strawberry.field
+    async def children(
+        self, info: strawberry.Info
+    ) -> list[Annotated["Generation", strawberry.lazy(".generation")]]:  # noqa: E501
+        """Get child generations derived from this one."""
+        from ..resolvers.generation import resolve_generation_children
+
+        return await resolve_generation_children(self, info)

package/templates/api/src/boards/graphql/types/generator.py

@@ -0,0 +1,17 @@
+"""
+Generator GraphQL type definitions
+"""
+
+import strawberry
+
+from .generation import ArtifactType
+
+
+@strawberry.type
+class GeneratorInfo:
+    """Information about an available generator."""
+
+    name: str
+    description: str
+    artifact_type: ArtifactType
+    input_schema: strawberry.scalars.JSON  # type: ignore[reportInvalidTypeForm]

package/templates/api/src/boards/graphql/types/user.py

@@ -0,0 +1,47 @@
+"""
+User GraphQL type definitions
+"""
+
+from datetime import datetime
+from typing import TYPE_CHECKING, Annotated
+from uuid import UUID
+
+import strawberry
+
+if TYPE_CHECKING:
+    from .board import Board
+
+
+@strawberry.type
+class User:
+    """User type for GraphQL API."""
+
+    id: UUID
+    tenant_id: UUID
+    auth_provider: str
+    auth_subject: str
+    email: str | None
+    display_name: str | None
+    avatar_url: str | None
+    created_at: datetime
+    updated_at: datetime
+
+    @strawberry.field
+    async def boards(
+        self, info: strawberry.Info
+    ) -> list[Annotated["Board", strawberry.lazy(".board")]]:  # noqa: E501
+        """Get boards owned by this user."""
+        # TODO: Implement data loader
+        from ..resolvers.user import resolve_user_boards
+
+        return await resolve_user_boards(self, info)
+
+    @strawberry.field
+    async def member_boards(
+        self, info: strawberry.Info
+    ) -> list[Annotated["Board", strawberry.lazy(".board")]]:  # noqa: E501
+        """Get boards where user is a member."""
+        # TODO: Implement data loader
+        from ..resolvers.user import resolve_user_member_boards
+
+        return await resolve_user_member_boards(self, info)

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

@@ -0,0 +1,104 @@
+"""Repository helpers for Generations job lifecycle."""
+
+from __future__ import annotations
+
+from datetime import UTC, datetime
+from decimal import Decimal
+from typing import Any
+from uuid import UUID
+
+from sqlalchemy import select, update
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from ..dbmodels import Generations
+
+
+async def get_generation(session: AsyncSession, generation_id: str | UUID) -> Generations:
+    stmt = select(Generations).where(Generations.id == str(generation_id))
+    res = await session.execute(stmt)
+    row = res.scalar_one()
+    return row
+
+
+async def update_progress(
+    session: AsyncSession,
+    generation_id: str | UUID,
+    *,
+    status: str,
+    progress: float,
+    error_message: str | None = None,
+) -> None:
+    now = datetime.now(UTC)
+    stmt = (
+        update(Generations)
+        .where(Generations.id == str(generation_id))
+        .values(
+            status=status,
+            progress=progress,
+            error_message=error_message,
+            updated_at=now,
+            started_at=now if status == "processing" else Generations.started_at,
+            completed_at=(now if status in {"completed", "failed", "cancelled"} else None),
+        )
+    )
+    await session.execute(stmt)
+
+
+async def create_generation(
+    session: AsyncSession,
+    *,
+    tenant_id: UUID,
+    board_id: UUID,
+    user_id: UUID,
+    generator_name: str,
+    artifact_type: str,
+    input_params: dict,
+) -> Generations:
+    gen = Generations()
+    gen.tenant_id = tenant_id
+    gen.board_id = board_id
+    gen.user_id = user_id
+    gen.generator_name = generator_name
+    gen.artifact_type = artifact_type
+    gen.input_params = input_params
+    gen.status = "pending"
+    gen.progress = Decimal(0.0)
+    session.add(gen)
+    await session.flush()
+    return gen
+
+
+async def set_external_job_id(
+    session: AsyncSession, generation_id: str | UUID, external_job_id: str
+) -> None:
+    stmt = (
+        update(Generations)
+        .where(Generations.id == str(generation_id))
+        .values(external_job_id=external_job_id)
+    )
+    await session.execute(stmt)
+
+
+async def finalize_success(
+    session: AsyncSession,
+    generation_id: str | UUID,
+    *,
+    storage_url: str | None = None,
+    thumbnail_url: str | None = None,
+    output_metadata: dict[str, Any] | None = None,
+) -> None:
+    now = datetime.now(UTC)
+    stmt = (
+        update(Generations)
+        .where(Generations.id == str(generation_id))
+        .values(
+            status="completed",
+            progress=100.0,
+            storage_url=storage_url,
+            thumbnail_url=thumbnail_url,
+            output_metadata=output_metadata or {},
+            updated_at=now,
+            completed_at=now,
+        )
+    )
+    await session.execute(stmt)