···

       
208
       
 
       
		}),

     

       
209
       
 
       
	});

     

       
210
       
 
       


     

       
211
       
-
       
	if (registerResponse.status !== 200) {

     

       
212
       
 
       
		const error = await registerResponse.json();

     

       
213
       
 
       
		throw new Error(`Registration failed: ${JSON.stringify(error)}`);

     

       
214
       
 
       
	}

     
···

       
275
       
 
       
				}),

     

       
276
       
 
       
			});

     

       
277
       
 
       


     

       
278
       
-
       
			if (response.status !== 200) {

     

       
279
       
 
       
				const error = await response.json();

     

       
280
       
 
       
				console.error("Registration failed:", response.status, error);

     

       
281
       
 
       
			}

     

       
282
       
 
       


     

       
283
       
-
       
			expect(response.status).toBe(200);

     

       
284
       
 
       
			

     

       
285
       
 
       
			const data = await response.json();

     

       
286
       
 
       
			expect(data.user).toBeDefined();

     
···

       
348
       
 
       
				}),

     

       
349
       
 
       
			});

     

       
350
       
 
       


     

       
351
       
-
       
			expect(response.status).toBe(400);

     

       
352
       
 
       
			const data = await response.json();

     

       
353
       
 
       
			expect(data.error).toBe("Email already registered");

     

       
354
       
 
       
		});

     
···

       
431
       
 
       
				},

     

       
432
       
 
       
			);

     

       
433
       
 
       


     

       
434
       
-
       
			expect(response.status).toBe(200);

     

       
435
       
-
       
			const data = await response.json();

     

       
436
       
-
       
			expect(data.success).toBe(true);

     

       
437
       
 
       


     

       
438
       
 
       
			// Verify user is deleted

     

       
439
       
 
       
			const verifyResponse = await authRequest(

     
···

       
505
       
 
       
				},

     

       
506
       
 
       
			);

     

       
507
       
 
       


     

       
508
       
-
       
			expect(response.status).toBe(400);

     

       
509
       
 
       
			const data = await response.json();

     

       
510
       
 
       
			expect(data.error).toBe("Email already in use");

     

       
511
       
 
       
		});

     
···

       
586
       
 
       
			);

     

       
587
       
 
       


     

       
588
       
 
       
			expect(response.status).toBe(200);

     

       
589
       
-
       
			const data = await response.json();

     

       
590
       
-
       
			expect(data.success).toBe(true);

     

       
591
       
 
       


     

       
592
       
 
       
			// Verify name updated

     

       
593
       
 
       
			const meResponse = await authRequest(

     
···

       
720
       
 
       
				},

     

       
721
       
 
       
			);

     

       
722
       
 
       


     

       
723
       
-
       
			expect(response.status).toBe(200);

     

       
724
       
 
       
			const data = await response.json();

     

       
725
       
 
       
			expect(data.id).toBeDefined();

     

       
726
       
 
       
			expect(data.message).toContain("Upload successful");

     
···

       
881
       
 
       
				},

     

       
882
       
 
       
			);

     

       
883
       
 
       


     

       
884
       
-
       
			expect(response.status).toBe(200);

     

       
885
       
-
       
			const data = await response.json();

     

       
886
       
-
       
			expect(data.success).toBe(true);

     

       
887
       
 
       


     

       
888
       
 
       
			// Verify user is deleted

     

       
889
       
 
       
			const verifyResponse = await authRequest(

     
···

       
919
       
 
       
			);

     

       
920
       
 
       


     

       
921
       
 
       
			expect(response.status).toBe(200);

     

       
922
       
-
       
			const data = await response.json();

     

       
923
       
-
       
			expect(data.success).toBe(true);

     

       
924
       
 
       


     

       
925
       
 
       
			// Verify role updated

     

       
926
       
 
       
			const meResponse = await authRequest(

     
···

       
1033
       
 
       
				},

     

       
1034
       
 
       
			);

     

       
1035
       
 
       


     

       
1036
       
-
       
			expect(response.status).toBe(400);

     

       
1037
       
 
       
			const data = await response.json();

     

       
1038
       
 
       
			expect(data.error).toBe("Email already in use");

     

       
1039
       
 
       
		});

     
···

       
1062
       
 
       
				},

     

       
1063
       
 
       
			);

     

       
1064
       
 
       


     

       
1065
       
-
       
			expect(response.status).toBe(200);

     

       
1066
       
-
       
			const data = await response.json();

     

       
1067
       
-
       
			expect(data.success).toBe(true);

     

       
1068
       
 
       


     

       
1069
       
 
       
			// Verify sessions are deleted

     

       
1070
       
 
       
			const verifyResponse = await authRequest(

     

···

       
208
       
 
       
		}),

     

       
209
       
 
       
	});

     

       
210
       
 
       


     

       
211
       
+
       
	if (registerResponse.status !== 201) {

     

       
212
       
 
       
		const error = await registerResponse.json();

     

       
213
       
 
       
		throw new Error(`Registration failed: ${JSON.stringify(error)}`);

     

       
214
       
 
       
	}

     
···

       
275
       
 
       
				}),

     

       
276
       
 
       
			});

     

       
277
       
 
       


     

       
278
       
+
       
			if (response.status !== 201) {

     

       
279
       
 
       
				const error = await response.json();

     

       
280
       
 
       
				console.error("Registration failed:", response.status, error);

     

       
281
       
 
       
			}

     

       
282
       
 
       


     

       
283
       
+
       
			expect(response.status).toBe(201);

     

       
284
       
 
       
			

     

       
285
       
 
       
			const data = await response.json();

     

       
286
       
 
       
			expect(data.user).toBeDefined();

     
···

       
348
       
 
       
				}),

     

       
349
       
 
       
			});

     

       
350
       
 
       


     

       
351
       
+
       
			expect(response.status).toBe(409);

     

       
352
       
 
       
			const data = await response.json();

     

       
353
       
 
       
			expect(data.error).toBe("Email already registered");

     

       
354
       
 
       
		});

     
···

       
431
       
 
       
				},

     

       
432
       
 
       
			);

     

       
433
       
 
       


     

       
434
       
+
       
			expect(response.status).toBe(204);

     

       
0
       
 
       

     

       
0
       
 
       

     

       
435
       
 
       


     

       
436
       
 
       
			// Verify user is deleted

     

       
437
       
 
       
			const verifyResponse = await authRequest(

     
···

       
503
       
 
       
				},

     

       
504
       
 
       
			);

     

       
505
       
 
       


     

       
506
       
+
       
			expect(response.status).toBe(409);

     

       
507
       
 
       
			const data = await response.json();

     

       
508
       
 
       
			expect(data.error).toBe("Email already in use");

     

       
509
       
 
       
		});

     
···

       
584
       
 
       
			);

     

       
585
       
 
       


     

       
586
       
 
       
			expect(response.status).toBe(200);

     

       
0
       
 
       

     

       
0
       
 
       

     

       
587
       
 
       


     

       
588
       
 
       
			// Verify name updated

     

       
589
       
 
       
			const meResponse = await authRequest(

     
···

       
716
       
 
       
				},

     

       
717
       
 
       
			);

     

       
718
       
 
       


     

       
719
       
+
       
			expect(response.status).toBe(201);

     

       
720
       
 
       
			const data = await response.json();

     

       
721
       
 
       
			expect(data.id).toBeDefined();

     

       
722
       
 
       
			expect(data.message).toContain("Upload successful");

     
···

       
877
       
 
       
				},

     

       
878
       
 
       
			);

     

       
879
       
 
       


     

       
880
       
+
       
			expect(response.status).toBe(204);

     

       
0
       
 
       

     

       
0
       
 
       

     

       
881
       
 
       


     

       
882
       
 
       
			// Verify user is deleted

     

       
883
       
 
       
			const verifyResponse = await authRequest(

     
···

       
913
       
 
       
			);

     

       
914
       
 
       


     

       
915
       
 
       
			expect(response.status).toBe(200);

     

       
0
       
 
       

     

       
0
       
 
       

     

       
916
       
 
       


     

       
917
       
 
       
			// Verify role updated

     

       
918
       
 
       
			const meResponse = await authRequest(

     
···

       
1025
       
 
       
				},

     

       
1026
       
 
       
			);

     

       
1027
       
 
       


     

       
1028
       
+
       
			expect(response.status).toBe(409);

     

       
1029
       
 
       
			const data = await response.json();

     

       
1030
       
 
       
			expect(data.error).toBe("Email already in use");

     

       
1031
       
 
       
		});

     
···

       
1054
       
 
       
				},

     

       
1055
       
 
       
			);

     

       
1056
       
 
       


     

       
1057
       
+
       
			expect(response.status).toBe(204);

     

       
0
       
 
       

     

       
0
       
 
       

     

       
1058
       
 
       


     

       
1059
       
 
       
			// Verify sessions are deleted

     

       
1060
       
 
       
			const verifyResponse = await authRequest(

     

···

       
400
       
 
       
							email_verification_required: true,

     

       
401
       
 
       
							verification_code_sent_at: sentAt,

     

       
402
       
 
       
						},

     

       
403
       
-
       
						{ status: 200 },

     

       
404
       
 
       
					);

     

       
405
       
 
       
				} catch (err: unknown) {

     

       
406
       
 
       
					const error = err as { message?: string };

     

       
407
       
 
       
					if (error.message?.includes("UNIQUE constraint failed")) {

     

       
408
       
 
       
						return Response.json(

     

       
409
       
 
       
							{ error: "Email already registered" },

     

       
410
       
-
       
							{ status: 400 },

     

       
411
       
 
       
						);

     

       
412
       
 
       
					}

     

       
413
       
 
       
					console.error("[Auth] Registration error:", err);

     
···

       
1065
       
 
       
					}

     

       
1066
       
 
       


     

       
1067
       
 
       
					updatePasskeyName(passkeyId, user.id, name);

     

       
1068
       
-
       
					return Response.json({ success: true });

     

       
1069
       
 
       
				} catch (err) {

     

       
1070
       
 
       
					return handleError(err);

     

       
1071
       
 
       
				}

     
···

       
1081
       
 
       


     

       
1082
       
 
       
					const passkeyId = req.params.id;

     

       
1083
       
 
       
					deletePasskey(passkeyId, user.id);

     

       
1084
       
-
       
					return Response.json({ success: true });

     

       
1085
       
 
       
				} catch (err) {

     

       
1086
       
 
       
					return handleError(err);

     

       
1087
       
 
       
				}

     
···

       
1147
       
 
       
					// Verify the session belongs to the user

     

       
1148
       
 
       
					const targetSession = getSession(targetSessionId);

     

       
1149
       
 
       
					if (!targetSession || targetSession.user_id !== user.id) {

     

       
1150
       
-
       
						return Response.json({ error: "Session not found" }, { status: 404 });

     

       
1151
       
 
       
					}

     

       
1152
       
 
       
					deleteSession(targetSessionId);

     

       
1153
       
-
       
					return Response.json({ success: true });

     

       
1154
       
 
       
				} catch (err) {

     

       
1155
       
 
       
					return handleError(err);

     

       
1156
       
 
       
				}

     
···

       
1168
       
 
       
					if (rateLimitError) return rateLimitError;

     

       
1169
       
 
       


     

       
1170
       
 
       
					await deleteUser(user.id);

     

       
1171
       
-
       
					return Response.json(

     

       
1172
       
-
       
						{ success: true },

     

       
1173
       
-
       
						{

     

       
1174
       
-
       
							headers: {

     

       
1175
       
-
       
								"Set-Cookie":

     

       
1176
       
-
       
									"session=; HttpOnly; Secure; Path=/; Max-Age=0; SameSite=Lax",

     

       
1177
       
-
       
							},

     

       
1178
       
 
       
						},

     

       
1179
       
-
       
					);

     

       
1180
       
 
       
				} catch (err) {

     

       
1181
       
 
       
					return handleError(err);

     

       
1182
       
 
       
				}

     
···

       
1204
       
 
       
					if (existingUser) {

     

       
1205
       
 
       
						return Response.json(

     

       
1206
       
 
       
							{ error: "Email already in use" },

     

       
1207
       
-
       
							{ status: 400 },

     

       
1208
       
 
       
						);

     

       
1209
       
 
       
					}

     

       
1210
       
 
       


     
···

       
1649
       
 
       
					// Allow access if: owner, admin, or enrolled in the class

     

       
1650
       
 
       
					if (!isOwner && !isAdmin && !isClassMember) {

     

       
1651
       
 
       
						return Response.json(

     

       
1652
       
-
       
							{ error: "Transcription not found" },

     

       
1653
       
-
       
							{ status: 404 },

     

       
1654
       
 
       
						);

     

       
1655
       
 
       
					}

     

       
1656
       
 
       


     
···

       
1892
       
 
       
					// Allow access if: owner, admin, or enrolled in the class

     

       
1893
       
 
       
					if (!isOwner && !isAdmin && !isClassMember) {

     

       
1894
       
 
       
						return Response.json(

     

       
1895
       
-
       
							{ error: "Transcription not found" },

     

       
1896
       
-
       
							{ status: 404 },

     

       
1897
       
 
       
						);

     

       
1898
       
 
       
					}

     

       
1899
       
 
       


     
···

       
1910
       
 
       
					if (transcription.status !== "completed") {

     

       
1911
       
 
       
						return Response.json(

     

       
1912
       
 
       
							{ error: "Transcription not completed yet" },

     

       
1913
       
-
       
							{ status: 400 },

     

       
1914
       
 
       
						);

     

       
1915
       
 
       
					}

     

       
1916
       
 
       


     
···

       
2000
       
 
       
					// Allow access if: owner, admin, or enrolled in the class

     

       
2001
       
 
       
					if (!isOwner && !isAdmin && !isClassMember) {

     

       
2002
       
 
       
						return Response.json(

     

       
2003
       
-
       
							{ error: "Transcription not found" },

     

       
2004
       
-
       
							{ status: 404 },

     

       
2005
       
 
       
						);

     

       
2006
       
 
       
					}

     

       
2007
       
 
       


     
···

       
2302
       
 
       
					// Don't auto-start transcription - admin will select recordings

     

       
2303
       
 
       
					// whisperService.startTranscription(transcriptionId, filename);

     

       
2304
       
 
       


     

       
2305
       
-
       
					return Response.json({

     

       
2306
       
-
       
						id: transcriptionId,

     

       
2307
       
-
       
						message: "Upload successful",

     

       
2308
       
-
       
					});

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
2309
       
 
       
				} catch (error) {

     

       
2310
       
 
       
					return handleError(error);

     

       
2311
       
 
       
				}

     
···

       
2377
       
 
       
					requireAdmin(req);

     

       
2378
       
 
       
					const id = req.params.id;

     

       
2379
       
 
       
					deleteWaitlistEntry(id);

     

       
2380
       
-
       
					return Response.json({ success: true });

     

       
2381
       
 
       
				} catch (error) {

     

       
2382
       
 
       
					return handleError(error);

     

       
2383
       
 
       
				}

     
···

       
2389
       
 
       
					requireAdmin(req);

     

       
2390
       
 
       
					const transcriptionId = req.params.id;

     

       
2391
       
 
       
					deleteTranscription(transcriptionId);

     

       
2392
       
-
       
					return Response.json({ success: true });

     

       
2393
       
 
       
				} catch (error) {

     

       
2394
       
 
       
					return handleError(error);

     

       
2395
       
 
       
				}

     
···

       
2404
       
 
       
						return Response.json({ error: "Invalid user ID" }, { status: 400 });

     

       
2405
       
 
       
					}

     

       
2406
       
 
       
					await deleteUser(userId);

     

       
2407
       
-
       
					return Response.json({ success: true });

     

       
2408
       
 
       
				} catch (error) {

     

       
2409
       
 
       
					return handleError(error);

     

       
2410
       
 
       
				}

     
···

       
2654
       
 
       


     

       
2655
       
 
       
					const { passkeyId } = req.params;

     

       
2656
       
 
       
					deletePasskey(passkeyId, userId);

     

       
2657
       
-
       
					return Response.json({ success: true });

     

       
2658
       
 
       
				} catch (error) {

     

       
2659
       
 
       
					return handleError(error);

     

       
2660
       
 
       
				}

     
···

       
2720
       
 
       
					if (existing) {

     

       
2721
       
 
       
						return Response.json(

     

       
2722
       
 
       
							{ error: "Email already in use" },

     

       
2723
       
-
       
							{ status: 400 },

     

       
2724
       
 
       
						);

     

       
2725
       
 
       
					}

     

       
2726
       
 
       


     
···

       
2805
       
 
       
					}

     

       
2806
       
 
       


     

       
2807
       
 
       
					deleteAllUserSessions(userId);

     

       
2808
       
-
       
					return Response.json({ success: true });

     

       
2809
       
 
       
				} catch (error) {

     

       
2810
       
 
       
					return handleError(error);

     

       
2811
       
 
       
				}

     
···

       
2830
       
 
       
						);

     

       
2831
       
 
       
					}

     

       
2832
       
 
       


     

       
2833
       
-
       
					return Response.json({ success: true });

     

       
2834
       
 
       
				} catch (error) {

     

       
2835
       
 
       
					return handleError(error);

     

       
2836
       
 
       
				}

     
···

       
3013
       
 
       
						meeting_times,

     

       
3014
       
 
       
					});

     

       
3015
       
 
       


     

       
3016
       
-
       
					return Response.json(newClass);

     

       
3017
       
 
       
				} catch (error) {

     

       
3018
       
 
       
					return handleError(error);

     

       
3019
       
 
       
				}

     
···

       
3073
       
 
       
						return Response.json({ error: result.error }, { status: 400 });

     

       
3074
       
 
       
					}

     

       
3075
       
 
       


     

       
3076
       
-
       
					return Response.json({ success: true });

     

       
3077
       
 
       
				} catch (error) {

     

       
3078
       
 
       
					return handleError(error);

     

       
3079
       
 
       
				}

     
···

       
3149
       
 
       
						meetingTimes || null,

     

       
3150
       
 
       
					);

     

       
3151
       
 
       


     

       
3152
       
-
       
					return Response.json({ success: true, id });

     

       
3153
       
 
       
				} catch (error) {

     

       
3154
       
 
       
					return handleError(error);

     

       
3155
       
 
       
				}

     
···

       
3199
       
 
       
					}

     

       
3200
       
 
       


     

       
3201
       
 
       
					deleteClass(classId);

     

       
3202
       
-
       
					return Response.json({ success: true });

     

       
3203
       
 
       
				} catch (error) {

     

       
3204
       
 
       
					return handleError(error);

     

       
3205
       
 
       
				}

     
···

       
3227
       
 
       
					}

     

       
3228
       
 
       


     

       
3229
       
 
       
					toggleClassArchive(classId, archived);

     

       
3230
       
-
       
					return Response.json({ success: true });

     

       
3231
       
 
       
				} catch (error) {

     

       
3232
       
 
       
					return handleError(error);

     

       
3233
       
 
       
				}

     
···

       
3268
       
 
       
					}

     

       
3269
       
 
       


     

       
3270
       
 
       
					enrollUserInClass(user.id, classId);

     

       
3271
       
-
       
					return Response.json({ success: true });

     

       
3272
       
 
       
				} catch (error) {

     

       
3273
       
 
       
					return handleError(error);

     

       
3274
       
 
       
				}

     
···

       
3292
       
 
       
					}

     

       
3293
       
 
       


     

       
3294
       
 
       
					removeUserFromClass(userId, classId);

     

       
3295
       
-
       
					return Response.json({ success: true });

     

       
3296
       
 
       
				} catch (error) {

     

       
3297
       
 
       
					return handleError(error);

     

       
3298
       
 
       
				}

     
···

       
3337
       
 
       
					}

     

       
3338
       
 
       


     

       
3339
       
 
       
					const meetingTime = createMeetingTime(classId, label);

     

       
3340
       
-
       
					return Response.json(meetingTime);

     

       
3341
       
 
       
				} catch (error) {

     

       
3342
       
 
       
					return handleError(error);

     

       
3343
       
 
       
				}

     
···

       
3362
       
 
       
					}

     

       
3363
       
 
       


     

       
3364
       
 
       
					updateMeetingTime(meetingId, label);

     

       
3365
       
-
       
					return Response.json({ success: true });

     

       
3366
       
 
       
				} catch (error) {

     

       
3367
       
 
       
					return handleError(error);

     

       
3368
       
 
       
				}

     
···

       
3379
       
 
       
					}

     

       
3380
       
 
       


     

       
3381
       
 
       
					deleteMeetingTime(meetingId);

     

       
3382
       
-
       
					return Response.json({ success: true });

     

       
3383
       
 
       
				} catch (error) {

     

       
3384
       
 
       
					return handleError(error);

     

       
3385
       
 
       
				}

     
···

       
3427
       
 
       
						transcription.filename,

     

       
3428
       
 
       
					);

     

       
3429
       
 
       


     

       
3430
       
-
       
					return Response.json({ success: true });

     

       
3431
       
 
       
				} catch (error) {

     

       
3432
       
 
       
					return handleError(error);

     

       
3433
       
 
       
				}

     

···

       
400
       
 
       
							email_verification_required: true,

     

       
401
       
 
       
							verification_code_sent_at: sentAt,

     

       
402
       
 
       
						},

     

       
403
       
+
       
						{ status: 201 },

     

       
404
       
 
       
					);

     

       
405
       
 
       
				} catch (err: unknown) {

     

       
406
       
 
       
					const error = err as { message?: string };

     

       
407
       
 
       
					if (error.message?.includes("UNIQUE constraint failed")) {

     

       
408
       
 
       
						return Response.json(

     

       
409
       
 
       
							{ error: "Email already registered" },

     

       
410
       
+
       
							{ status: 409 },

     

       
411
       
 
       
						);

     

       
412
       
 
       
					}

     

       
413
       
 
       
					console.error("[Auth] Registration error:", err);

     
···

       
1065
       
 
       
					}

     

       
1066
       
 
       


     

       
1067
       
 
       
					updatePasskeyName(passkeyId, user.id, name);

     

       
1068
       
+
       
					return new Response(null, { status: 204 });

     

       
1069
       
 
       
				} catch (err) {

     

       
1070
       
 
       
					return handleError(err);

     

       
1071
       
 
       
				}

     
···

       
1081
       
 
       


     

       
1082
       
 
       
					const passkeyId = req.params.id;

     

       
1083
       
 
       
					deletePasskey(passkeyId, user.id);

     

       
1084
       
+
       
					return new Response(null, { status: 204 });

     

       
1085
       
 
       
				} catch (err) {

     

       
1086
       
 
       
					return handleError(err);

     

       
1087
       
 
       
				}

     
···

       
1147
       
 
       
					// Verify the session belongs to the user

     

       
1148
       
 
       
					const targetSession = getSession(targetSessionId);

     

       
1149
       
 
       
					if (!targetSession || targetSession.user_id !== user.id) {

     

       
1150
       
+
       
						return Response.json({ error: "Forbidden" }, { status: 403 });

     

       
1151
       
 
       
					}

     

       
1152
       
 
       
					deleteSession(targetSessionId);

     

       
1153
       
+
       
					return new Response(null, { status: 204 });

     

       
1154
       
 
       
				} catch (err) {

     

       
1155
       
 
       
					return handleError(err);

     

       
1156
       
 
       
				}

     
···

       
1168
       
 
       
					if (rateLimitError) return rateLimitError;

     

       
1169
       
 
       


     

       
1170
       
 
       
					await deleteUser(user.id);

     

       
1171
       
+
       
					return new Response(null, {

     

       
1172
       
+
       
						status: 204,

     

       
1173
       
+
       
						headers: {

     

       
1174
       
+
       
							"Set-Cookie":

     

       
1175
       
+
       
								"session=; HttpOnly; Secure; Path=/; Max-Age=0; SameSite=Lax",

     

       
0
       
 
       

     

       
0
       
 
       

     

       
1176
       
 
       
						},

     

       
1177
       
+
       
					});

     

       
1178
       
 
       
				} catch (err) {

     

       
1179
       
 
       
					return handleError(err);

     

       
1180
       
 
       
				}

     
···

       
1202
       
 
       
					if (existingUser) {

     

       
1203
       
 
       
						return Response.json(

     

       
1204
       
 
       
							{ error: "Email already in use" },

     

       
1205
       
+
       
							{ status: 409 },

     

       
1206
       
 
       
						);

     

       
1207
       
 
       
					}

     

       
1208
       
 
       


     
···

       
1647
       
 
       
					// Allow access if: owner, admin, or enrolled in the class

     

       
1648
       
 
       
					if (!isOwner && !isAdmin && !isClassMember) {

     

       
1649
       
 
       
						return Response.json(

     

       
1650
       
+
       
							{ error: "Forbidden" },

     

       
1651
       
+
       
							{ status: 403 },

     

       
1652
       
 
       
						);

     

       
1653
       
 
       
					}

     

       
1654
       
 
       


     
···

       
1890
       
 
       
					// Allow access if: owner, admin, or enrolled in the class

     

       
1891
       
 
       
					if (!isOwner && !isAdmin && !isClassMember) {

     

       
1892
       
 
       
						return Response.json(

     

       
1893
       
+
       
							{ error: "Forbidden" },

     

       
1894
       
+
       
							{ status: 403 },

     

       
1895
       
 
       
						);

     

       
1896
       
 
       
					}

     

       
1897
       
 
       


     
···

       
1908
       
 
       
					if (transcription.status !== "completed") {

     

       
1909
       
 
       
						return Response.json(

     

       
1910
       
 
       
							{ error: "Transcription not completed yet" },

     

       
1911
       
+
       
							{ status: 409 },

     

       
1912
       
 
       
						);

     

       
1913
       
 
       
					}

     

       
1914
       
 
       


     
···

       
1998
       
 
       
					// Allow access if: owner, admin, or enrolled in the class

     

       
1999
       
 
       
					if (!isOwner && !isAdmin && !isClassMember) {

     

       
2000
       
 
       
						return Response.json(

     

       
2001
       
+
       
							{ error: "Forbidden" },

     

       
2002
       
+
       
							{ status: 403 },

     

       
2003
       
 
       
						);

     

       
2004
       
 
       
					}

     

       
2005
       
 
       


     
···

       
2300
       
 
       
					// Don't auto-start transcription - admin will select recordings

     

       
2301
       
 
       
					// whisperService.startTranscription(transcriptionId, filename);

     

       
2302
       
 
       


     

       
2303
       
+
       
					return Response.json(

     

       
2304
       
+
       
						{

     

       
2305
       
+
       
							id: transcriptionId,

     

       
2306
       
+
       
							message: "Upload successful",

     

       
2307
       
+
       
						},

     

       
2308
       
+
       
						{ status: 201 },

     

       
2309
       
+
       
					);

     

       
2310
       
 
       
				} catch (error) {

     

       
2311
       
 
       
					return handleError(error);

     

       
2312
       
 
       
				}

     
···

       
2378
       
 
       
					requireAdmin(req);

     

       
2379
       
 
       
					const id = req.params.id;

     

       
2380
       
 
       
					deleteWaitlistEntry(id);

     

       
2381
       
+
       
					return new Response(null, { status: 204 });

     

       
2382
       
 
       
				} catch (error) {

     

       
2383
       
 
       
					return handleError(error);

     

       
2384
       
 
       
				}

     
···

       
2390
       
 
       
					requireAdmin(req);

     

       
2391
       
 
       
					const transcriptionId = req.params.id;

     

       
2392
       
 
       
					deleteTranscription(transcriptionId);

     

       
2393
       
+
       
					return new Response(null, { status: 204 });

     

       
2394
       
 
       
				} catch (error) {

     

       
2395
       
 
       
					return handleError(error);

     

       
2396
       
 
       
				}

     
···

       
2405
       
 
       
						return Response.json({ error: "Invalid user ID" }, { status: 400 });

     

       
2406
       
 
       
					}

     

       
2407
       
 
       
					await deleteUser(userId);

     

       
2408
       
+
       
					return new Response(null, { status: 204 });

     

       
2409
       
 
       
				} catch (error) {

     

       
2410
       
 
       
					return handleError(error);

     

       
2411
       
 
       
				}

     
···

       
2655
       
 
       


     

       
2656
       
 
       
					const { passkeyId } = req.params;

     

       
2657
       
 
       
					deletePasskey(passkeyId, userId);

     

       
2658
       
+
       
					return new Response(null, { status: 204 });

     

       
2659
       
 
       
				} catch (error) {

     

       
2660
       
 
       
					return handleError(error);

     

       
2661
       
 
       
				}

     
···

       
2721
       
 
       
					if (existing) {

     

       
2722
       
 
       
						return Response.json(

     

       
2723
       
 
       
							{ error: "Email already in use" },

     

       
2724
       
+
       
							{ status: 409 },

     

       
2725
       
 
       
						);

     

       
2726
       
 
       
					}

     

       
2727
       
 
       


     
···

       
2806
       
 
       
					}

     

       
2807
       
 
       


     

       
2808
       
 
       
					deleteAllUserSessions(userId);

     

       
2809
       
+
       
					return new Response(null, { status: 204 });

     

       
2810
       
 
       
				} catch (error) {

     

       
2811
       
 
       
					return handleError(error);

     

       
2812
       
 
       
				}

     
···

       
2831
       
 
       
						);

     

       
2832
       
 
       
					}

     

       
2833
       
 
       


     

       
2834
       
+
       
					return new Response(null, { status: 204 });

     

       
2835
       
 
       
				} catch (error) {

     

       
2836
       
 
       
					return handleError(error);

     

       
2837
       
 
       
				}

     
···

       
3014
       
 
       
						meeting_times,

     

       
3015
       
 
       
					});

     

       
3016
       
 
       


     

       
3017
       
+
       
					return Response.json(newClass, { status: 201 });

     

       
3018
       
 
       
				} catch (error) {

     

       
3019
       
 
       
					return handleError(error);

     

       
3020
       
 
       
				}

     
···

       
3074
       
 
       
						return Response.json({ error: result.error }, { status: 400 });

     

       
3075
       
 
       
					}

     

       
3076
       
 
       


     

       
3077
       
+
       
					return new Response(null, { status: 204 });

     

       
3078
       
 
       
				} catch (error) {

     

       
3079
       
 
       
					return handleError(error);

     

       
3080
       
 
       
				}

     
···

       
3150
       
 
       
						meetingTimes || null,

     

       
3151
       
 
       
					);

     

       
3152
       
 
       


     

       
3153
       
+
       
					return Response.json({ success: true, id }, { status: 201 });

     

       
3154
       
 
       
				} catch (error) {

     

       
3155
       
 
       
					return handleError(error);

     

       
3156
       
 
       
				}

     
···

       
3200
       
 
       
					}

     

       
3201
       
 
       


     

       
3202
       
 
       
					deleteClass(classId);

     

       
3203
       
+
       
					return new Response(null, { status: 204 });

     

       
3204
       
 
       
				} catch (error) {

     

       
3205
       
 
       
					return handleError(error);

     

       
3206
       
 
       
				}

     
···

       
3228
       
 
       
					}

     

       
3229
       
 
       


     

       
3230
       
 
       
					toggleClassArchive(classId, archived);

     

       
3231
       
+
       
					return new Response(null, { status: 204 });

     

       
3232
       
 
       
				} catch (error) {

     

       
3233
       
 
       
					return handleError(error);

     

       
3234
       
 
       
				}

     
···

       
3269
       
 
       
					}

     

       
3270
       
 
       


     

       
3271
       
 
       
					enrollUserInClass(user.id, classId);

     

       
3272
       
+
       
					return new Response(null, { status: 201 });

     

       
3273
       
 
       
				} catch (error) {

     

       
3274
       
 
       
					return handleError(error);

     

       
3275
       
 
       
				}

     
···

       
3293
       
 
       
					}

     

       
3294
       
 
       


     

       
3295
       
 
       
					removeUserFromClass(userId, classId);

     

       
3296
       
+
       
					return new Response(null, { status: 204 });

     

       
3297
       
 
       
				} catch (error) {

     

       
3298
       
 
       
					return handleError(error);

     

       
3299
       
 
       
				}

     
···

       
3338
       
 
       
					}

     

       
3339
       
 
       


     

       
3340
       
 
       
					const meetingTime = createMeetingTime(classId, label);

     

       
3341
       
+
       
					return Response.json(meetingTime, { status: 201 });

     

       
3342
       
 
       
				} catch (error) {

     

       
3343
       
 
       
					return handleError(error);

     

       
3344
       
 
       
				}

     
···

       
3363
       
 
       
					}

     

       
3364
       
 
       


     

       
3365
       
 
       
					updateMeetingTime(meetingId, label);

     

       
3366
       
+
       
					return new Response(null, { status: 204 });

     

       
3367
       
 
       
				} catch (error) {

     

       
3368
       
 
       
					return handleError(error);

     

       
3369
       
 
       
				}

     
···

       
3380
       
 
       
					}

     

       
3381
       
 
       


     

       
3382
       
 
       
					deleteMeetingTime(meetingId);

     

       
3383
       
+
       
					return new Response(null, { status: 204 });

     

       
3384
       
 
       
				} catch (error) {

     

       
3385
       
 
       
					return handleError(error);

     

       
3386
       
 
       
				}

     
···

       
3428
       
 
       
						transcription.filename,

     

       
3429
       
 
       
					);

     

       
3430
       
 
       


     

       
3431
       
+
       
					return new Response(null, { status: 204 });

     

       
3432
       
 
       
				} catch (error) {

     

       
3433
       
 
       
					return handleError(error);

     

       
3434
       
 
       
				}