Scrum4Me/actions/products.ts

'use server'

import { revalidatePath } from 'next/cache'
import { redirect } from 'next/navigation'
import { cookies } from 'next/headers'
import { getIronSession } from 'iron-session'
import { z } from 'zod'
import { prisma } from '@/lib/prisma'
import { SessionData, sessionOptions } from '@/lib/session'

const productSchema = z.object({
  name: z.string().min(1, 'Naam is verplicht').max(100, 'Naam mag maximaal 100 tekens bevatten'),
  description: z.string().max(1000, 'Beschrijving mag maximaal 1000 tekens bevatten').optional(),
  repo_url: z
    .string()
    .url('Voer een geldige URL in (inclusief https://)')
    .optional()
    .or(z.literal('')),
  definition_of_done: z
    .string()
    .min(1, 'Definition of Done is verplicht')
    .max(500, 'Definition of Done mag maximaal 500 tekens bevatten'),
})

async function getSession() {
  return getIronSession<SessionData>(await cookies(), sessionOptions)
}

export async function createProductAction(_prevState: unknown, formData: FormData) {
  const session = await getSession()
  if (!session.userId) return { error: 'Niet ingelogd' }
  if (session.isDemo) return { error: 'Niet beschikbaar in demo-modus' }

  const parsed = productSchema.safeParse({
    name: formData.get('name'),
    description: formData.get('description') || undefined,
    repo_url: formData.get('repo_url') || undefined,
    definition_of_done: formData.get('definition_of_done'),
  })

  if (!parsed.success) {
    return { error: parsed.error.flatten().fieldErrors }
  }

  const existing = await prisma.product.findFirst({
    where: { user_id: session.userId, name: parsed.data.name },
  })
  if (existing) return { error: { name: ['Een product met deze naam bestaat al'] } }

  const product = await prisma.product.create({
    data: {
      user_id: session.userId,
      name: parsed.data.name,
      description: parsed.data.description ?? null,
      repo_url: parsed.data.repo_url || null,
      definition_of_done: parsed.data.definition_of_done,
    },
  })

  redirect(`/products/${product.id}`)
}

export async function updateProductAction(_prevState: unknown, formData: FormData) {
  const session = await getSession()
  if (!session.userId) return { error: 'Niet ingelogd' }
  if (session.isDemo) return { error: 'Niet beschikbaar in demo-modus' }

  const id = formData.get('id') as string
  if (!id) return { error: 'Product niet gevonden' }

  const parsed = productSchema.safeParse({
    name: formData.get('name'),
    description: formData.get('description') || undefined,
    repo_url: formData.get('repo_url') || undefined,
    definition_of_done: formData.get('definition_of_done'),
  })

  if (!parsed.success) {
    return { error: parsed.error.flatten().fieldErrors }
  }

  // Verify ownership
  const product = await prisma.product.findFirst({
    where: { id, user_id: session.userId },
  })
  if (!product) return { error: 'Product niet gevonden' }

  // Check unique name (excluding self)
  const duplicate = await prisma.product.findFirst({
    where: { user_id: session.userId, name: parsed.data.name, NOT: { id } },
  })
  if (duplicate) return { error: { name: ['Een product met deze naam bestaat al'] } }

  await prisma.product.update({
    where: { id },
    data: {
      name: parsed.data.name,
      description: parsed.data.description ?? null,
      repo_url: parsed.data.repo_url || null,
      definition_of_done: parsed.data.definition_of_done,
    },
  })

  revalidatePath(`/products/${id}`)
  revalidatePath('/dashboard')
  return { success: true }
}

export async function archiveProductAction(id: string) {
  const session = await getSession()
  if (!session.userId) return { error: 'Niet ingelogd' }
  if (session.isDemo) return { error: 'Niet beschikbaar in demo-modus' }

  const product = await prisma.product.findFirst({
    where: { id, user_id: session.userId },
  })
  if (!product) return { error: 'Product niet gevonden' }

  await prisma.product.update({ where: { id }, data: { archived: true } })

  revalidatePath('/dashboard')
  redirect('/dashboard')
}

export async function restoreProductAction(id: string) {
  const session = await getSession()
  if (!session.userId) return { error: 'Niet ingelogd' }
  if (session.isDemo) return { error: 'Niet beschikbaar in demo-modus' }

  const product = await prisma.product.findFirst({
    where: { id, user_id: session.userId },
  })
  if (!product) return { error: 'Product niet gevonden' }

  await prisma.product.update({ where: { id }, data: { archived: false } })

  revalidatePath('/dashboard')
  return { success: true }
}