Scrum4Me/lib/solo-workspace-server.ts

import 'server-only'

import { prisma } from '@/lib/prisma'
import { getAccessibleProduct } from '@/lib/product-access'
import { resolveActiveSprint } from '@/lib/active-sprint'
import type {
  SoloTask,
  SoloUnassignedStory,
  SoloWorkspaceSnapshot,
} from '@/stores/solo-workspace/types'

export async function getSoloWorkspaceSnapshot(
  productId: string,
  userId: string,
  sprintId?: string | null,
): Promise<SoloWorkspaceSnapshot | null> {
  const product = await getAccessibleProduct(productId, userId)
  if (!product) return null

  const active = sprintId ? { id: sprintId } : await resolveActiveSprint(productId, userId)
  const sprint = active
    ? await prisma.sprint.findFirst({ where: { id: active.id, product_id: productId } })
    : null
  if (!sprint) return null

  const [rawTasks, rawUnassigned] = await Promise.all([
    prisma.task.findMany({
      where: {
        story: {
          sprint_id: sprint.id,
          assignee_id: userId,
        },
      },
      include: {
        story: {
          select: {
            id: true,
            code: true,
            title: true,
            tasks: { select: { id: true }, orderBy: { sort_order: 'asc' } },
            pbi: { select: { code: true, title: true, description: true } },
          },
        },
      },
      orderBy: [
        { story: { pbi: { priority: 'asc' } } },
        { story: { pbi: { sort_order: 'asc' } } },
        { story: { sort_order: 'asc' } },
        { priority: 'asc' },
        { sort_order: 'asc' },
      ],
    }),
    prisma.story.findMany({
      where: { sprint_id: sprint.id, assignee_id: null },
      select: {
        id: true,
        code: true,
        title: true,
        tasks: {
          select: { id: true, title: true, description: true, priority: true, status: true },
          orderBy: [{ priority: 'asc' }, { sort_order: 'asc' }],
        },
      },
      orderBy: { sort_order: 'asc' },
    }),
  ])

  const tasks: SoloTask[] = rawTasks.map((task) => ({
    id: task.id,
    title: task.title,
    description: task.description,
    implementation_plan: task.implementation_plan,
    priority: task.priority,
    sort_order: task.sort_order,
    status: task.status as SoloTask['status'],
    verify_only: task.verify_only,
    verify_required: task.verify_required as SoloTask['verify_required'],
    story_id: task.story.id,
    story_code: task.story.code,
    story_title: task.story.title,
    task_code: task.code,
    pbi_code: task.story.pbi?.code ?? null,
    pbi_title: task.story.pbi?.title ?? null,
    pbi_description: task.story.pbi?.description ?? null,
  }))

  const unassignedStories: SoloUnassignedStory[] = rawUnassigned.map((story) => ({
    id: story.id,
    code: story.code,
    title: story.title,
    tasks: story.tasks.map((task) => ({
      id: task.id,
      title: task.title,
      description: task.description,
      priority: task.priority,
      status: task.status,
    })),
  }))

  return {
    product: { id: product.id, name: product.name, repo_url: product.repo_url },
    sprint: { id: sprint.id, sprint_goal: sprint.sprint_goal },
    activeUserId: userId,
    tasks,
    unassignedStories,
  }
}