Merge pull request #236 from mchestr/feature/jellyfin-authentication

Add Jellyfin authentication and multi-service support

Author: mchestr

__tests__/actions/onboarding.test.ts

@@ -75,7 +75,10 @@ describe('Onboarding Actions', () => {
   describe('getOnboardingStatus', () => {
     it('should return status when authenticated', async () => {
       mockGetServerSession.mockResolvedValue({ user: { id: 'user-1' } } as any)
-      mockPrisma.user.findUnique.mockResolvedValue({ onboardingCompleted: false } as any)
+      mockPrisma.user.findUnique.mockResolvedValue({
+        onboardingStatus: { plex: false, jellyfin: false },
+        primaryAuthService: 'plex'
+      } as any)
 
       const result = await getOnboardingStatus()
 
@@ -92,22 +95,55 @@ describe('Onboarding Actions', () => {
   })
 
   describe('completeOnboarding', () => {
-    it('should mark user as complete', async () => {
+    it('should mark user as complete for plex service', async () => {
+      mockGetServerSession.mockResolvedValue({ user: { id: 'user-1' } } as any)
+      mockPrisma.user.findUnique.mockResolvedValue({
+        onboardingStatus: { plex: false, jellyfin: false }
+      } as any)
+
+      const result = await completeOnboarding('plex')
+
+      expect(result.success).toBe(true)
+      expect(mockPrisma.user.update).toHaveBeenCalledWith({
+        where: { id: 'user-1' },
+        data: { onboardingStatus: { plex: true, jellyfin: false } },
+      })
+    })
+
+    it('should mark user as complete for jellyfin service', async () => {
       mockGetServerSession.mockResolvedValue({ user: { id: 'user-1' } } as any)
+      mockPrisma.user.findUnique.mockResolvedValue({
+        onboardingStatus: { plex: false, jellyfin: false }
+      } as any)
+
+      const result = await completeOnboarding('jellyfin')
+
+      expect(result.success).toBe(true)
+      expect(mockPrisma.user.update).toHaveBeenCalledWith({
+        where: { id: 'user-1' },
+        data: { onboardingStatus: { plex: false, jellyfin: true } },
+      })
+    })
+
+    it('should preserve existing service completion status', async () => {
+      mockGetServerSession.mockResolvedValue({ user: { id: 'user-1' } } as any)
+      mockPrisma.user.findUnique.mockResolvedValue({
+        onboardingStatus: { plex: true, jellyfin: false }
+      } as any)
 
-      const result = await completeOnboarding()
+      const result = await completeOnboarding('jellyfin')
 
       expect(result.success).toBe(true)
       expect(mockPrisma.user.update).toHaveBeenCalledWith({
         where: { id: 'user-1' },
-        data: { onboardingCompleted: true },
+        data: { onboardingStatus: { plex: true, jellyfin: true } },
       })
     })
 
     it('should fail if unauthenticated', async () => {
       mockGetServerSession.mockResolvedValue(null)
 
-      const result = await completeOnboarding()
+      const result = await completeOnboarding('plex')
 
       expect(result.success).toBe(false)
       expect(mockPrisma.user.update).not.toHaveBeenCalled()

actions/onboarding.ts

@@ -3,52 +3,102 @@
 import { authOptions } from "@/lib/auth"
 import { prisma } from "@/lib/prisma"
 import { createLogger } from "@/lib/utils/logger"
+import type { AuthService } from "@/types/onboarding"
 import { getServerSession } from "next-auth"
+import { z } from "zod"
 
 const logger = createLogger("ONBOARDING")
 
 /**
- * Check if the current user has completed onboarding
+ * Zod schema for onboarding status
+ * Validates the onboardingStatus JSON field from the database
  */
-export async function getOnboardingStatus() {
+const OnboardingStatusSchema = z.object({
+  plex: z.boolean(),
+  jellyfin: z.boolean(),
+})
+
+interface OnboardingStatusRecord {
+  plex: boolean
+  jellyfin: boolean
+}
+
+/**
+ * Check if the current user has completed onboarding for a specific service
+ * @param service - The auth service ("plex" or "jellyfin"). If not specified, uses primaryAuthService
+ */
+export async function getOnboardingStatus(service?: AuthService) {
   try {
     const session = await getServerSession(authOptions)
     if (!session?.user?.id) {
-      return { isComplete: true } // If not logged in, assume complete to avoid blocking
+      return { isComplete: true, service: service || "plex" } // If not logged in, assume complete to avoid blocking
     }
 
     const user = await prisma.user.findUnique({
       where: { id: session.user.id },
-      select: { onboardingCompleted: true },
+      select: {
+        onboardingStatus: true,
+        primaryAuthService: true,
+      },
     })
 
+    const validation = OnboardingStatusSchema.safeParse(user?.onboardingStatus)
+    const status: OnboardingStatusRecord = validation.success
+      ? validation.data
+      : { plex: false, jellyfin: false }
+
+    // If no service specified, use primary auth service
+    const targetService: AuthService = service || (user?.primaryAuthService as AuthService) || "plex"
+
     return {
-      isComplete: user?.onboardingCompleted ?? false,
+      isComplete: status[targetService] || false,
+      service: targetService,
+      allStatuses: status,
     }
   } catch (error) {
-    logger.error("Error checking onboarding status", error)
-    return { isComplete: true } // On error, assume complete to avoid blocking
+    logger.error("Error checking onboarding status", error, { service })
+    return { isComplete: true, service: service || "plex" } // On error, assume complete to avoid blocking
   }
 }
 
 /**
- * Mark onboarding as complete for the current user
+ * Mark onboarding as complete for a specific service
+ * @param service - The auth service ("plex" or "jellyfin")
  */
-export async function completeOnboarding() {
+export async function completeOnboarding(service: AuthService) {
   try {
     const session = await getServerSession(authOptions)
     if (!session?.user?.id) {
       return { success: false, error: "Not authenticated" }
     }
 
+    // Get current onboarding status
+    const user = await prisma.user.findUnique({
+      where: { id: session.user.id },
+      select: { onboardingStatus: true },
+    })
+
+    const validation = OnboardingStatusSchema.safeParse(user?.onboardingStatus)
+    const currentStatus: OnboardingStatusRecord = validation.success
+      ? validation.data
+      : { plex: false, jellyfin: false }
+
+    // Update the status for the specified service
+    const updatedStatus = {
+      ...currentStatus,
+      [service]: true,
+    }
+
     await prisma.user.update({
       where: { id: session.user.id },
-      data: { onboardingCompleted: true },
+      data: { onboardingStatus: updatedStatus },
     })
 
+    logger.info("Onboarding completed", { userId: session.user.id, service })
+
     return { success: true }
   } catch (error) {
-    logger.error("Error completing onboarding", error)
+    logger.error("Error completing onboarding", error, { service })
     return { success: false, error: "Failed to complete onboarding" }
   }
 }

app/(app)/page.tsx

@@ -1,44 +1,78 @@
 import { getActiveAnnouncements } from "@/actions/announcements";
 import { getPrometheusStatus } from "@/actions/prometheus-status";
 import { getUserFirstWatchDate } from "@/actions/users";
-import { PlexSignInButton } from "@/components/auth/plex-sign-in-button";
+import { ServiceSignInToggle } from "@/components/auth/service-sign-in-toggle";
 import { UserDashboard } from "@/components/dashboard/user-dashboard";
 import { authOptions } from "@/lib/auth";
 import { prisma } from "@/lib/prisma";
+import type { AuthService } from "@/types/onboarding";
 import { getServerSession } from "next-auth";
 import { redirect } from "next/navigation";
+import { z } from "zod";
 
 export const dynamic = 'force-dynamic'
 
+const OnboardingStatusSchema = z.object({
+  plex: z.boolean(),
+  jellyfin: z.boolean(),
+})
+
+interface OnboardingStatusRecord {
+  plex: boolean
+  jellyfin: boolean
+}
+
 export default async function Home() {
   const session = await getServerSession(authOptions);
-  const [plexServer, discordIntegration, announcements, overseerr, prometheusStatus] = await Promise.all([
+  const [plexServer, jellyfinServer, discordIntegration, announcements, overseerr, prometheusStatus] = await Promise.all([
     prisma.plexServer.findFirst({
       where: { isActive: true },
     }),
+    prisma.jellyfinServer.findFirst({
+      where: { isActive: true },
+    }),
     prisma.discordIntegration.findUnique({ where: { id: "discord" } }),
     getActiveAnnouncements(),
     prisma.overseerr.findFirst({ where: { isActive: true } }),
     getPrometheusStatus(),
   ]);
-  const serverName = plexServer?.name || "Plex";
+
+  // Determine server name based on what's configured
+  const serverName = plexServer?.name || jellyfinServer?.name || "Media Server";
   const discordEnabled = Boolean(discordIntegration?.isEnabled && discordIntegration?.clientId && discordIntegration?.clientSecret);
   const overseerrUrl = overseerr?.publicUrl || overseerr?.url || null;
 
   // Handle redirect logic for authenticated users
   if (session?.user?.id) {
     const userPromise = prisma.user.findUnique({
       where: { id: session.user.id },
-      select: { onboardingCompleted: true, createdAt: true, plexUserId: true, email: true }
+      select: {
+        onboardingStatus: true,
+        primaryAuthService: true,
+        createdAt: true,
+        plexUserId: true,
+        jellyfinUserId: true,
+        email: true,
+      }
     });
     const discordConnectionPromise = discordEnabled
       ? prisma.discordConnection.findUnique({ where: { userId: session.user.id } })
       : Promise.resolve(null);
 
     const [user, discordConnection] = await Promise.all([userPromise, discordConnectionPromise]);
 
-    if (user && !user.onboardingCompleted) {
-      redirect("/onboarding");
+    // Check service-specific onboarding completion
+    if (user) {
+      const validation = OnboardingStatusSchema.safeParse(user.onboardingStatus)
+      const status: OnboardingStatusRecord = validation.success
+        ? validation.data
+        : { plex: false, jellyfin: false };
+      const primaryService: AuthService = (user.primaryAuthService as AuthService) || "plex";
+
+      // Redirect to onboarding if primary service onboarding not complete
+      if (!status[primaryService]) {
+        redirect("/onboarding");
+      }
     }
 
     // Get first watch date from Tautulli for accurate membership duration
@@ -61,6 +95,11 @@ export default async function Home() {
         }
       : null;
 
+    // Determine media server URL based on primary auth service
+    const mediaServerUrl = user?.primaryAuthService === "jellyfin"
+      ? jellyfinServer?.url
+      : plexServer?.url;
+
     return (
       <UserDashboard
         userId={session.user.id}
@@ -73,24 +112,41 @@ export default async function Home() {
         overseerrUrl={overseerrUrl}
         prometheusStatus={prometheusStatus}
         memberSince={memberSince}
+        primaryAuthService={user?.primaryAuthService}
+        mediaServerUrl={mediaServerUrl}
       />
     );
   }
 
+  // Unauthenticated: Show sign-in options
+  const hasPlex = !!plexServer;
+  const hasJellyfin = !!jellyfinServer;
+
+  if (!hasPlex && !hasJellyfin) {
+    return (
+      <main className="fixed inset-0 flex flex-col items-center justify-center bg-gradient-to-b from-slate-900 via-slate-800 to-slate-900 px-4">
+        <div className="flex flex-col items-center gap-6 sm:gap-8 text-center">
+          <h1 className="text-4xl sm:text-5xl md:text-6xl font-bold bg-gradient-to-r from-cyan-400 via-purple-400 to-pink-400 bg-clip-text text-transparent">
+            Media Server
+          </h1>
+          <p className="text-slate-400 text-lg">No media servers configured. Please contact your administrator.</p>
+        </div>
+      </main>
+    );
+  }
+
   return (
     <main className="fixed inset-0 flex flex-col items-center justify-center bg-gradient-to-b from-slate-900 via-slate-800 to-slate-900 px-4">
-      <div className="flex flex-col items-center gap-6 sm:gap-8">
+      <div className="flex flex-col items-center gap-6 sm:gap-8 w-full max-w-md">
         <h1 className="text-4xl sm:text-5xl md:text-6xl font-bold bg-gradient-to-r from-cyan-400 via-purple-400 to-pink-400 bg-clip-text text-transparent text-center">
           {serverName}
         </h1>
-        <PlexSignInButton
-          serverName={serverName}
-          showWarning={true}
-          warningDelay={3000}
-          showDisclaimer={false}
-          buttonText="Sign in with Plex"
-          loadingText="Signing in..."
-          buttonClassName="px-6 sm:px-8 py-3 sm:py-4 flex justify-center items-center gap-3 text-white text-base sm:text-lg font-semibold rounded-xl bg-gradient-to-r from-cyan-600 via-purple-600 to-pink-600 hover:from-cyan-500 hover:via-purple-500 hover:to-pink-500 focus:outline-none focus:ring-2 focus:ring-offset-2 focus:ring-purple-500/50 disabled:opacity-50 disabled:cursor-not-allowed transition-all duration-200 shadow-lg"
+
+        <ServiceSignInToggle
+          hasPlex={hasPlex}
+          hasJellyfin={hasJellyfin}
+          plexServerName={plexServer?.name}
+          jellyfinServerName={jellyfinServer?.name}
         />
       </div>
     </main>

app/onboarding/page.tsx

@@ -1,6 +1,24 @@
 import { OnboardingWizard } from "@/components/onboarding/onboarding-wizard"
+import { authOptions } from "@/lib/auth"
+import { prisma } from "@/lib/prisma"
+import type { AuthService } from "@/types/onboarding"
+import { getServerSession } from "next-auth"
+import { redirect } from "next/navigation"
 
 export default async function OnboardingPage() {
-  return <OnboardingWizard currentStep={1} />
+  const session = await getServerSession(authOptions)
+
+  if (!session?.user?.id) {
+    redirect("/")
+  }
+
+  const user = await prisma.user.findUnique({
+    where: { id: session.user.id },
+    select: { primaryAuthService: true },
+  })
+
+  const service: AuthService = (user?.primaryAuthService as AuthService) || "plex"
+
+  return <OnboardingWizard currentStep={1} service={service} />
 }