Deepen MocapSession lifecycle factory

src/app/api/ai-config/route.ts

@@ -2,6 +2,10 @@ import { NextResponse } from "next/server";
 import { getServerSession } from "next-auth";
 import { authOptions } from "@/lib/auth";
 import { prisma } from "@/lib/db/prisma";
+import {
+  buildUserSettingsCreateData,
+  USER_SETTINGS_DEFAULT_VALUES,
+} from "@/lib/server/userSettings";
 
 /**
  * GET /api/ai-config
@@ -32,8 +36,8 @@ export async function GET() {
     return NextResponse.json({ 
       config: settings || {
         aiConfig: null,
-        cloudAIEnabled: false,
-        maxTokens: 4000,
+        cloudAIEnabled: USER_SETTINGS_DEFAULT_VALUES.cloudAIEnabled,
+        maxTokens: USER_SETTINGS_DEFAULT_VALUES.maxTokens,
       }
     });
   } catch (error) {
@@ -71,12 +75,12 @@ export async function POST(req: Request) {
         cloudAIEnabled: configData.cloudAIEnabled,
         maxTokens: configData.maxTokens,
       },
-      create: {
-        userId: session.user.id,
+      create: buildUserSettingsCreateData(session.user.id, {
         aiConfig: configData.aiConfig,
-        cloudAIEnabled: configData.cloudAIEnabled || false,
-        maxTokens: configData.maxTokens || 4000,
-      },
+        cloudAIEnabled:
+          configData.cloudAIEnabled || USER_SETTINGS_DEFAULT_VALUES.cloudAIEnabled,
+        maxTokens: configData.maxTokens || USER_SETTINGS_DEFAULT_VALUES.maxTokens,
+      }),
       select: {
         aiConfig: true,
         cloudAIEnabled: true,

src/app/api/insights/route.ts

@@ -2,6 +2,7 @@ import { NextResponse } from "next/server";
 import { getServerSession } from "next-auth";
 import { authOptions } from "@/lib/auth";
 import { prisma } from "@/lib/db/prisma";
+import { buildUserSettingsCreateData } from "@/lib/server/userSettings";
 
 /**
  * GET /api/insights
@@ -158,19 +159,9 @@ export async function POST(req: Request) {
         update: {
           insightsRevision: settings?.sessionsRevision ?? 0,
         },
-        create: {
-          userId: session.user.id,
-          theme: 'system',
-          units: 'metric',
-          dateFormat: 'MM/DD/YYYY',
-          timeFormat: '24h',
-          language: 'en',
-          defaultChartType: 'line',
-          animationsEnabled: true,
-          cloudAIEnabled: false,
-          maxTokens: 4000,
+        create: buildUserSettingsCreateData(session.user.id, {
           insightsRevision: settings?.sessionsRevision ?? 0,
-        },
+        }),
       });
     }
 

src/app/api/mocap/sessions/[id]/finalize/route.ts

@@ -2,15 +2,7 @@ import { NextResponse } from "next/server";
 import { getServerSession } from "next-auth";
 import { z } from "zod";
 import { authOptions } from "@/lib/auth";
-import { prisma } from "@/lib/db/prisma";
-import { getMocapStorage } from "@/lib/mocap/storage";
-import { finalizePoseStreamBlob } from "@/lib/mocap/capturePersistence";
-import { analyzeAndPersistMocapSession } from "@/lib/mocap/sessionAnalysis";
-import { finalizeMocapSessionLifecycle } from "@/lib/mocap/lifecycle";
-import {
-  setMocapCaptureFinalizationState,
-  setMocapSessionStatus,
-} from "@/lib/mocap/lifecyclePrisma";
+import { getPrismaMocapSessionLifecycle } from "@/lib/mocap/lifecyclePrisma";
 
 export const dynamic = "force-dynamic";
 export const runtime = "nodejs";
@@ -45,35 +37,10 @@ export async function POST(
     );
   }
 
-  const storage = getMocapStorage();
-  const result = await finalizeMocapSessionLifecycle(
+  const result = await getPrismaMocapSessionLifecycle().finalize(
+    session.user.id,
+    id,
     {
-      storage,
-      findSession: (userId, mocapSessionId) =>
-        prisma.mocapSession.findFirst({
-          where: { id: mocapSessionId, userId },
-          select: {
-            id: true,
-            userId: true,
-            status: true,
-            rowingSessionId: true,
-            poseStreamPath: true,
-            capturePerspective: true,
-            calibrationCatchFrame: true,
-            calibrationFinishFrame: true,
-          },
-        }),
-      setStatus: setMocapSessionStatus,
-      setCaptureFinalizationState: setMocapCaptureFinalizationState,
-      finalizePoseStream: finalizePoseStreamBlob,
-      analyzePoseSegmented: analyzeAndPersistMocapSession,
-      analyzeCsvAligned: async () => {
-        throw new Error("Finalize lifecycle must use pose-segmented analysis");
-      },
-    },
-    {
-      userId: session.user.id,
-      mocapSessionId: id,
       durationSec: body.durationSec,
       qualityScore: body.qualityScore,
       qualityFlags: body.qualityFlags,

src/app/api/mocap/sessions/[id]/link/[rowingSessionId]/route.ts

@@ -1,11 +1,7 @@
 import { NextResponse } from "next/server";
 import { getServerSession } from "next-auth";
 import { authOptions } from "@/lib/auth";
-import { prisma } from "@/lib/db/prisma";
-import { getMocapStorage } from "@/lib/mocap/storage";
-import { analyzeAndPersistMocapSessionLinked } from "@/lib/mocap/sessionAnalysis";
-import { linkMocapSessionLifecycle } from "@/lib/mocap/lifecycle";
-import { setMocapSessionStatus } from "@/lib/mocap/lifecyclePrisma";
+import { getPrismaMocapSessionLifecycle } from "@/lib/mocap/lifecyclePrisma";
 
 export const dynamic = "force-dynamic";
 export const runtime = "nodejs";
@@ -21,70 +17,10 @@ export async function POST(
 
   const { id, rowingSessionId } = await params;
   const userId = session.user.id;
-  const storage = getMocapStorage();
-
-  const result = await linkMocapSessionLifecycle(
-    {
-      storage,
-      findSession: (ownerId, mocapSessionId) =>
-        prisma.mocapSession.findFirst({
-          where: { id: mocapSessionId, userId: ownerId },
-          select: {
-            id: true,
-            userId: true,
-            status: true,
-            rowingSessionId: true,
-            poseStreamPath: true,
-            capturePerspective: true,
-            calibrationCatchFrame: true,
-            calibrationFinishFrame: true,
-          },
-        }),
-      findRowingSession: (ownerId, targetRowingSessionId) =>
-        prisma.rowingSession.findFirst({
-          where: { id: targetRowingSessionId, userId: ownerId },
-          select: {
-            id: true,
-            mocapSession: { select: { id: true } },
-          },
-        }),
-      setStatus: setMocapSessionStatus,
-      assignMocapSession: async (mocapSessionId, ownerId, targetRowingSessionId) => {
-        try {
-          const update = await prisma.mocapSession.updateMany({
-            where: {
-              id: mocapSessionId,
-              userId: ownerId,
-              rowingSessionId: null,
-              status: "ready",
-            },
-            data: {
-              rowingSessionId: targetRowingSessionId,
-              status: "analyzing",
-            },
-          });
-          return update.count === 1 ? "assigned" : "mocap-conflict";
-        } catch (err) {
-          if ((err as { code?: string })?.code === "P2002") {
-            return "rowing-conflict";
-          }
-          throw err;
-        }
-      },
-      restoreMocapSessionAssignment: (mocapSessionId, restoredRowingSessionId, status) =>
-        prisma.mocapSession
-          .update({
-            where: { id: mocapSessionId },
-            data: { rowingSessionId: restoredRowingSessionId, status },
-          })
-          .then(() => undefined),
-      bumpSessionsRevision: (ownerId) => bumpSessionsRevision(ownerId),
-      analyzePoseSegmented: async () => {
-        throw new Error("Link lifecycle must use csv-aligned analysis");
-      },
-      analyzeCsvAligned: analyzeAndPersistMocapSessionLinked,
-    },
-    { userId, mocapSessionId: id, rowingSessionId },
+  const result = await getPrismaMocapSessionLifecycle().link(
+    userId,
+    id,
+    rowingSessionId,
   );
 
   if (!result.ok) {
@@ -104,25 +40,3 @@ export async function POST(
     faultCount: result.faultCount,
   });
 }
-
-async function bumpSessionsRevision(userId: string): Promise<void> {
-  await prisma.userSettings.upsert({
-    where: { userId },
-    update: {
-      sessionsRevision: { increment: 1 },
-    },
-    create: {
-      userId,
-      theme: "system",
-      units: "metric",
-      dateFormat: "MM/DD/YYYY",
-      timeFormat: "24h",
-      language: "en",
-      defaultChartType: "line",
-      animationsEnabled: true,
-      cloudAIEnabled: false,
-      maxTokens: 4000,
-      sessionsRevision: 1,
-    },
-  });
-}

src/app/api/mocap/sessions/[id]/reanalyze/route.ts

@@ -1,14 +1,7 @@
 import { NextResponse } from "next/server";
 import { getServerSession } from "next-auth";
 import { authOptions } from "@/lib/auth";
-import { prisma } from "@/lib/db/prisma";
-import { getMocapStorage } from "@/lib/mocap/storage";
-import {
-  analyzeAndPersistMocapSession,
-  analyzeAndPersistMocapSessionLinked,
-} from "@/lib/mocap/sessionAnalysis";
-import { reanalyzeMocapSessionLifecycle } from "@/lib/mocap/lifecycle";
-import { setMocapSessionStatus } from "@/lib/mocap/lifecyclePrisma";
+import { getPrismaMocapSessionLifecycle } from "@/lib/mocap/lifecyclePrisma";
 
 export const dynamic = "force-dynamic";
 export const runtime = "nodejs";
@@ -23,32 +16,9 @@ export async function POST(
   }
 
   const { id } = await params;
-  const storage = getMocapStorage();
-  const result = await reanalyzeMocapSessionLifecycle(
-    {
-      storage,
-      findSession: (userId, mocapSessionId) =>
-        prisma.mocapSession.findFirst({
-          where: { id: mocapSessionId, userId },
-          select: {
-            id: true,
-            userId: true,
-            status: true,
-            rowingSessionId: true,
-            poseStreamPath: true,
-            capturePerspective: true,
-            calibrationCatchFrame: true,
-            calibrationFinishFrame: true,
-          },
-        }),
-      setStatus: setMocapSessionStatus,
-      analyzePoseSegmented: analyzeAndPersistMocapSession,
-      analyzeCsvAligned: analyzeAndPersistMocapSessionLinked,
-    },
-    {
-      userId: session.user.id,
-      mocapSessionId: id,
-    },
+  const result = await getPrismaMocapSessionLifecycle().reanalyze(
+    session.user.id,
+    id,
   );
 
   if (!result.ok) {

src/app/api/mocap/sessions/[id]/unlink/route.ts

@@ -1,11 +1,7 @@
 import { NextResponse } from "next/server";
 import { getServerSession } from "next-auth";
 import { authOptions } from "@/lib/auth";
-import { prisma } from "@/lib/db/prisma";
-import { getMocapStorage } from "@/lib/mocap/storage";
-import { analyzeAndPersistMocapSession } from "@/lib/mocap/sessionAnalysis";
-import { unlinkMocapSessionLifecycle } from "@/lib/mocap/lifecycle";
-import { setMocapSessionStatus } from "@/lib/mocap/lifecyclePrisma";
+import { getPrismaMocapSessionLifecycle } from "@/lib/mocap/lifecyclePrisma";
 
 export const dynamic = "force-dynamic";
 export const runtime = "nodejs";
@@ -21,53 +17,7 @@ export async function POST(
 
   const { id } = await params;
   const userId = session.user.id;
-  const storage = getMocapStorage();
-
-  const result = await unlinkMocapSessionLifecycle(
-    {
-      storage,
-      findSession: (ownerId, mocapSessionId) =>
-        prisma.mocapSession.findFirst({
-          where: { id: mocapSessionId, userId: ownerId },
-          select: {
-            id: true,
-            userId: true,
-            status: true,
-            rowingSessionId: true,
-            poseStreamPath: true,
-            capturePerspective: true,
-            calibrationCatchFrame: true,
-            calibrationFinishFrame: true,
-          },
-        }),
-      setStatus: setMocapSessionStatus,
-      unassignMocapSession: async (mocapSessionId, ownerId, rowingSessionId) => {
-        const update = await prisma.mocapSession.updateMany({
-          where: {
-            id: mocapSessionId,
-            userId: ownerId,
-            rowingSessionId,
-            status: "ready",
-          },
-          data: { rowingSessionId: null, status: "analyzing" },
-        });
-        return update.count === 1;
-      },
-      restoreMocapSessionAssignment: (mocapSessionId, restoredRowingSessionId, status) =>
-        prisma.mocapSession
-          .update({
-            where: { id: mocapSessionId },
-            data: { rowingSessionId: restoredRowingSessionId, status },
-          })
-          .then(() => undefined),
-      bumpSessionsRevision: (ownerId) => bumpSessionsRevision(ownerId),
-      analyzePoseSegmented: analyzeAndPersistMocapSession,
-      analyzeCsvAligned: async () => {
-        throw new Error("Unlink lifecycle must use pose-segmented analysis");
-      },
-    },
-    { userId, mocapSessionId: id },
-  );
+  const result = await getPrismaMocapSessionLifecycle().unlink(userId, id);
 
   if (!result.ok) {
     return NextResponse.json(
@@ -85,25 +35,3 @@ export async function POST(
     faultCount: result.faultCount,
   });
 }
-
-async function bumpSessionsRevision(userId: string): Promise<void> {
-  await prisma.userSettings.upsert({
-    where: { userId },
-    update: {
-      sessionsRevision: { increment: 1 },
-    },
-    create: {
-      userId,
-      theme: "system",
-      units: "metric",
-      dateFormat: "MM/DD/YYYY",
-      timeFormat: "24h",
-      language: "en",
-      defaultChartType: "line",
-      animationsEnabled: true,
-      cloudAIEnabled: false,
-      maxTokens: 4000,
-      sessionsRevision: 1,
-    },
-  });
-}