Sporadic set logging added

server/prisma/schema.prisma

@@ -25,6 +25,7 @@ model User {
   exercises    Exercise[]
   plans        WorkoutPlan[]
   weightRecords BodyWeightRecord[]
+  sporadicSets SporadicSet[]
 }
 
 model BodyWeightRecord {
@@ -59,6 +60,7 @@ model Exercise {
   isArchived           Boolean  @default(false)
   
   sets                 WorkoutSet[]
+  sporadicSets         SporadicSet[]
 }
 
 model WorkoutSession {
@@ -100,3 +102,23 @@ model WorkoutPlan {
   createdAt   DateTime @default(now())
   updatedAt   DateTime @updatedAt
 }
+
+model SporadicSet {
+  id                   String   @id @default(uuid())
+  userId               String
+  user                 User     @relation(fields: [userId], references: [id], onDelete: Cascade)
+  exerciseId           String
+  exercise             Exercise @relation(fields: [exerciseId], references: [id])
+  
+  weight               Float?
+  reps                 Int?
+  distanceMeters       Float?
+  durationSeconds      Int?
+  height               Float?
+  bodyWeightPercentage Float?
+  
+  timestamp            DateTime @default(now())
+  note                 String?
+  
+  @@index([userId, timestamp])
+}

server/src/index.ts

@@ -7,6 +7,7 @@ import sessionRoutes from './routes/sessions';
 import planRoutes from './routes/plans';
 import aiRoutes from './routes/ai';
 import weightRoutes from './routes/weight';
+import sporadicSetsRoutes from './routes/sporadic-sets';
 import bcrypt from 'bcryptjs';
 import { PrismaClient } from '@prisma/client';
 
@@ -61,6 +62,7 @@ app.use('/api/sessions', sessionRoutes);
 app.use('/api/plans', planRoutes);
 app.use('/api/ai', aiRoutes);
 app.use('/api/weight', weightRoutes);
+app.use('/api/sporadic-sets', sporadicSetsRoutes);
 
 app.get('/', (req, res) => {
     res.send('GymFlow AI API is running');

server/src/routes/sporadic-sets.ts

@@ -0,0 +1,182 @@
+import express from 'express';
+import { PrismaClient } from '@prisma/client';
+import jwt from 'jsonwebtoken';
+
+const router = express.Router();
+const prisma = new PrismaClient();
+const JWT_SECRET = process.env.JWT_SECRET || 'secret';
+
+const authenticate = (req: any, res: any, next: any) => {
+    const token = req.headers.authorization?.split(' ')[1];
+    if (!token) return res.status(401).json({ error: 'Unauthorized' });
+
+    try {
+        const decoded = jwt.verify(token, JWT_SECRET) as any;
+        req.user = decoded;
+        next();
+    } catch {
+        res.status(401).json({ error: 'Invalid token' });
+    }
+};
+
+router.use(authenticate);
+
+// Get all sporadic sets for the authenticated user
+router.get('/', async (req: any, res) => {
+    try {
+        const userId = req.user.userId;
+        const sporadicSets = await prisma.sporadicSet.findMany({
+            where: { userId },
+            include: { exercise: true },
+            orderBy: { timestamp: 'desc' }
+        });
+
+        // Map to include exercise name and type
+        const mappedSets = sporadicSets.map(set => ({
+            id: set.id,
+            exerciseId: set.exerciseId,
+            exerciseName: set.exercise.name,
+            type: set.exercise.type,
+            weight: set.weight,
+            reps: set.reps,
+            distanceMeters: set.distanceMeters,
+            durationSeconds: set.durationSeconds,
+            height: set.height,
+            bodyWeightPercentage: set.bodyWeightPercentage,
+            timestamp: set.timestamp.getTime(),
+            note: set.note
+        }));
+
+        res.json({ success: true, sporadicSets: mappedSets });
+    } catch (error) {
+        console.error(error);
+        res.status(500).json({ error: 'Server error' });
+    }
+});
+
+// Create a new sporadic set
+router.post('/', async (req: any, res) => {
+    try {
+        const userId = req.user.userId;
+        const { exerciseId, weight, reps, distanceMeters, durationSeconds, height, bodyWeightPercentage, note } = req.body;
+
+        if (!exerciseId) {
+            return res.status(400).json({ error: 'Exercise ID is required' });
+        }
+
+        const sporadicSet = await prisma.sporadicSet.create({
+            data: {
+                userId,
+                exerciseId,
+                weight: weight ? parseFloat(weight) : null,
+                reps: reps ? parseInt(reps) : null,
+                distanceMeters: distanceMeters ? parseFloat(distanceMeters) : null,
+                durationSeconds: durationSeconds ? parseInt(durationSeconds) : null,
+                height: height ? parseFloat(height) : null,
+                bodyWeightPercentage: bodyWeightPercentage ? parseFloat(bodyWeightPercentage) : null,
+                note: note || null
+            },
+            include: { exercise: true }
+        });
+
+        const mappedSet = {
+            id: sporadicSet.id,
+            exerciseId: sporadicSet.exerciseId,
+            exerciseName: sporadicSet.exercise.name,
+            type: sporadicSet.exercise.type,
+            weight: sporadicSet.weight,
+            reps: sporadicSet.reps,
+            distanceMeters: sporadicSet.distanceMeters,
+            durationSeconds: sporadicSet.durationSeconds,
+            height: sporadicSet.height,
+            bodyWeightPercentage: sporadicSet.bodyWeightPercentage,
+            timestamp: sporadicSet.timestamp.getTime(),
+            note: sporadicSet.note
+        };
+
+        res.json({ success: true, sporadicSet: mappedSet });
+    } catch (error) {
+        console.error(error);
+        res.status(500).json({ error: 'Server error' });
+    }
+});
+
+// Update a sporadic set
+router.put('/:id', async (req: any, res) => {
+    try {
+        const userId = req.user.userId;
+        const { id } = req.params;
+        const { weight, reps, distanceMeters, durationSeconds, height, bodyWeightPercentage, note } = req.body;
+
+        // Verify ownership
+        const existing = await prisma.sporadicSet.findFirst({
+            where: { id, userId }
+        });
+
+        if (!existing) {
+            return res.status(404).json({ error: 'Sporadic set not found' });
+        }
+
+        const updated = await prisma.sporadicSet.update({
+            where: { id },
+            data: {
+                weight: weight !== undefined ? (weight ? parseFloat(weight) : null) : undefined,
+                reps: reps !== undefined ? (reps ? parseInt(reps) : null) : undefined,
+                distanceMeters: distanceMeters !== undefined ? (distanceMeters ? parseFloat(distanceMeters) : null) : undefined,
+                durationSeconds: durationSeconds !== undefined ? (durationSeconds ? parseInt(durationSeconds) : null) : undefined,
+                height: height !== undefined ? (height ? parseFloat(height) : null) : undefined,
+                bodyWeightPercentage: bodyWeightPercentage !== undefined ? (bodyWeightPercentage ? parseFloat(bodyWeightPercentage) : null) : undefined,
+                note: note !== undefined ? note : undefined
+            },
+            include: { exercise: true }
+        });
+
+        const mappedSet = {
+            id: updated.id,
+            exerciseId: updated.exerciseId,
+            exerciseName: updated.exercise.name,
+            type: updated.exercise.type,
+            weight: updated.weight,
+            reps: updated.reps,
+            distanceMeters: updated.distanceMeters,
+            durationSeconds: updated.durationSeconds,
+            height: updated.height,
+            bodyWeightPercentage: updated.bodyWeightPercentage,
+            timestamp: updated.timestamp.getTime(),
+            note: updated.note
+        };
+
+        res.json({ success: true, sporadicSet: mappedSet });
+    } catch (error) {
+        console.error(error);
+        res.status(500).json({ error: 'Server error' });
+    }
+});
+
+// Delete a sporadic set
+router.delete('/:id', async (req: any, res) => {
+    try {
+        const userId = req.user.userId;
+        const { id } = req.params;
+
+        // Verify ownership
+        const existing = await prisma.sporadicSet.findFirst({
+            where: { id, userId }
+        });
+
+        if (!existing) {
+            return res.status(404).json({ error: 'Sporadic set not found' });
+        }
+
+        await prisma.sporadicSet.delete({
+            where: { id }
+        });
+
+        res.json({ success: true });
+    } catch (error) {
+        console.error(error);
+        res.status(500).json({ error: 'Server error' });
+    }
+});
+
+export default router;