commit ba3e2807cc83b502c4642f84a32f88d947969742 · dunkirk.sh/thistle

+148 -24

src/index.ts

···

       2090
       2090
        
       			GET: async (req) => {

     

       2091
       2091
        
       				try {

     

       2092
       2092
        
       					const user = requireSubscription(req);

     

       2093
       2093
       +
       					const url = new URL(req.url);

     

       2093
       2094
        
       

     

       2094
       2094
       -
       					const transcriptions = db

     

       2095
       2095
       -
       						.query<

     

       2096
       2096
       -
       							{

     

       2097
       2097
       -
       								id: string;

     

       2098
       2098
       -
       								filename: string;

     

       2099
       2099
       -
       								original_filename: string;

     

       2100
       2100
       -
       								class_id: string | null;

     

       2101
       2101
       -
       								status: string;

     

       2102
       2102
       -
       								progress: number;

     

       2103
       2103
       -
       								created_at: number;

     

       2104
       2104
       -
       							},

     

       2105
       2105
       -
       							[number]

     

       2106
       2106
       -
       						>(

     

       2107
       2107
       -
       							"SELECT id, filename, original_filename, class_id, status, progress, created_at FROM transcriptions WHERE user_id = ? ORDER BY created_at DESC",

     

       2108
       2108
       -
       						)

     

       2109
       2109
       -
       						.all(user.id);

     

       2095
       2095
       +
       					// Parse pagination params

     

       2096
       2096
       +
       					const limit = Math.min(

     

       2097
       2097
       +
       						Number.parseInt(url.searchParams.get("limit") || "50", 10),

     

       2098
       2098
       +
       						100,

     

       2099
       2099
       +
       					);

     

       2100
       2100
       +
       					const cursorParam = url.searchParams.get("cursor");

     

       2101
       2101
       +
       

     

       2102
       2102
       +
       					let transcriptions: Array<{

     

       2103
       2103
       +
       						id: string;

     

       2104
       2104
       +
       						filename: string;

     

       2105
       2105
       +
       						original_filename: string;

     

       2106
       2106
       +
       						class_id: string | null;

     

       2107
       2107
       +
       						status: string;

     

       2108
       2108
       +
       						progress: number;

     

       2109
       2109
       +
       						created_at: number;

     

       2110
       2110
       +
       					}>;

     

       2111
       2111
       +
       

     

       2112
       2112
       +
       					if (cursorParam) {

     

       2113
       2113
       +
       						// Decode cursor

     

       2114
       2114
       +
       						const { decodeCursor } = await import("./lib/cursor");

     

       2115
       2115
       +
       						const parts = decodeCursor(cursorParam);

     

       2116
       2116
       +
       

     

       2117
       2117
       +
       						if (parts.length !== 2) {

     

       2118
       2118
       +
       							return Response.json(

     

       2119
       2119
       +
       								{ error: "Invalid cursor format" },

     

       2120
       2120
       +
       								{ status: 400 },

     

       2121
       2121
       +
       							);

     

       2122
       2122
       +
       						}

     

       2123
       2123
       +
       

     

       2124
       2124
       +
       						const cursorTime = Number.parseInt(parts[0] || "", 10);

     

       2125
       2125
       +
       						const id = parts[1] || "";

     

       2126
       2126
       +
       

     

       2127
       2127
       +
       						if (Number.isNaN(cursorTime) || !id) {

     

       2128
       2128
       +
       							return Response.json(

     

       2129
       2129
       +
       								{ error: "Invalid cursor format" },

     

       2130
       2130
       +
       								{ status: 400 },

     

       2131
       2131
       +
       							);

     

       2132
       2132
       +
       						}

     

       2133
       2133
       +
       

     

       2134
       2134
       +
       						transcriptions = db

     

       2135
       2135
       +
       							.query<

     

       2136
       2136
       +
       								{

     

       2137
       2137
       +
       									id: string;

     

       2138
       2138
       +
       									filename: string;

     

       2139
       2139
       +
       									original_filename: string;

     

       2140
       2140
       +
       									class_id: string | null;

     

       2141
       2141
       +
       									status: string;

     

       2142
       2142
       +
       									progress: number;

     

       2143
       2143
       +
       									created_at: number;

     

       2144
       2144
       +
       								},

     

       2145
       2145
       +
       								[number, number, string, number]

     

       2146
       2146
       +
       							>(

     

       2147
       2147
       +
       								`SELECT id, filename, original_filename, class_id, status, progress, created_at 

     

       2148
       2148
       +
       								FROM transcriptions 

     

       2149
       2149
       +
       								WHERE user_id = ? AND (created_at < ? OR (created_at = ? AND id < ?))

     

       2150
       2150
       +
       								ORDER BY created_at DESC, id DESC 

     

       2151
       2151
       +
       								LIMIT ?`,

     

       2152
       2152
       +
       							)

     

       2153
       2153
       +
       							.all(user.id, cursorTime, cursorTime, id, limit + 1);

     

       2154
       2154
       +
       					} else {

     

       2155
       2155
       +
       						transcriptions = db

     

       2156
       2156
       +
       							.query<

     

       2157
       2157
       +
       								{

     

       2158
       2158
       +
       									id: string;

     

       2159
       2159
       +
       									filename: string;

     

       2160
       2160
       +
       									original_filename: string;

     

       2161
       2161
       +
       									class_id: string | null;

     

       2162
       2162
       +
       									status: string;

     

       2163
       2163
       +
       									progress: number;

     

       2164
       2164
       +
       									created_at: number;

     

       2165
       2165
       +
       								},

     

       2166
       2166
       +
       								[number, number]

     

       2167
       2167
       +
       							>(

     

       2168
       2168
       +
       								`SELECT id, filename, original_filename, class_id, status, progress, created_at 

     

       2169
       2169
       +
       								FROM transcriptions 

     

       2170
       2170
       +
       								WHERE user_id = ? 

     

       2171
       2171
       +
       								ORDER BY created_at DESC, id DESC 

     

       2172
       2172
       +
       								LIMIT ?`,

     

       2173
       2173
       +
       							)

     

       2174
       2174
       +
       							.all(user.id, limit + 1);

     

       2175
       2175
       +
       					}

     

       2176
       2176
       +
       

     

       2177
       2177
       +
       					// Check if there are more results

     

       2178
       2178
       +
       					const hasMore = transcriptions.length > limit;

     

       2179
       2179
       +
       					if (hasMore) {

     

       2180
       2180
       +
       						transcriptions.pop(); // Remove extra item

     

       2181
       2181
       +
       					}

     

       2182
       2182
       +
       

     

       2183
       2183
       +
       					// Build next cursor

     

       2184
       2184
       +
       					let nextCursor: string | null = null;

     

       2185
       2185
       +
       					if (hasMore && transcriptions.length > 0) {

     

       2186
       2186
       +
       						const { encodeCursor } = await import("./lib/cursor");

     

       2187
       2187
       +
       						const last = transcriptions[transcriptions.length - 1];

     

       2188
       2188
       +
       						if (last) {

     

       2189
       2189
       +
       							nextCursor = encodeCursor([

     

       2190
       2190
       +
       								last.created_at.toString(),

     

       2191
       2191
       +
       								last.id,

     

       2192
       2192
       +
       							]);

     

       2193
       2193
       +
       						}

     

       2194
       2194
       +
       					}

     

       2110
       2195
        
       

     

       2111
       2196
        
       					// Load transcripts from files for completed jobs

     

       2112
       2197
        
       					const jobs = await Promise.all(

     
···

       2122
       2207
        
       						}),

     

       2123
       2208
        
       					);

     

       2124
       2209
        
       

     

       2125
       2125
       -
       					return Response.json({ jobs });

     

       2210
       2210
       +
       					return Response.json({

     

       2211
       2211
       +
       						jobs,

     

       2212
       2212
       +
       						pagination: {

     

       2213
       2213
       +
       							limit,

     

       2214
       2214
       +
       							hasMore,

     

       2215
       2215
       +
       							nextCursor,

     

       2216
       2216
       +
       						},

     

       2217
       2217
       +
       					});

     

       2126
       2218
        
       				} catch (error) {

     

       2127
       2219
        
       					return handleError(error);

     

       2128
       2220
        
       				}

     
···

       2238
       2330
        
       			GET: async (req) => {

     

       2239
       2331
        
       				try {

     

       2240
       2332
        
       					requireAdmin(req);

     

       2241
       2241
       -
       					const transcriptions = getAllTranscriptions();

     

       2242
       2242
       -
       					return Response.json(transcriptions);

     

       2333
       2333
       +
       					const url = new URL(req.url);

     

       2334
       2334
       +
       

     

       2335
       2335
       +
       					const limit = Math.min(

     

       2336
       2336
       +
       						Number.parseInt(url.searchParams.get("limit") || "50", 10),

     

       2337
       2337
       +
       						100,

     

       2338
       2338
       +
       					);

     

       2339
       2339
       +
       					const cursor = url.searchParams.get("cursor") || undefined;

     

       2340
       2340
       +
       

     

       2341
       2341
       +
       					const result = getAllTranscriptions(limit, cursor);

     

       2342
       2342
       +
       					return Response.json(result);

     

       2243
       2343
        
       				} catch (error) {

     

       2244
       2344
        
       					return handleError(error);

     

       2245
       2345
        
       				}

     
···

       2249
       2349
        
       			GET: async (req) => {

     

       2250
       2350
        
       				try {

     

       2251
       2351
        
       					requireAdmin(req);

     

       2252
       2252
       -
       					const users = getAllUsersWithStats();

     

       2253
       2253
       -
       					return Response.json(users);

     

       2352
       2352
       +
       					const url = new URL(req.url);

     

       2353
       2353
       +
       

     

       2354
       2354
       +
       					const limit = Math.min(

     

       2355
       2355
       +
       						Number.parseInt(url.searchParams.get("limit") || "50", 10),

     

       2356
       2356
       +
       						100,

     

       2357
       2357
       +
       					);

     

       2358
       2358
       +
       					const cursor = url.searchParams.get("cursor") || undefined;

     

       2359
       2359
       +
       

     

       2360
       2360
       +
       					const result = getAllUsersWithStats(limit, cursor);

     

       2361
       2361
       +
       					return Response.json(result);

     

       2254
       2362
        
       				} catch (error) {

     

       2255
       2363
        
       					return handleError(error);

     

       2256
       2364
        
       				}

     
···

       2799
       2907
        
       			GET: async (req) => {

     

       2800
       2908
        
       				try {

     

       2801
       2909
        
       					const user = requireAuth(req);

     

       2802
       2802
       -
       					const classes = getClassesForUser(user.id, user.role === "admin");

     

       2910
       2910
       +
       					const url = new URL(req.url);

     

       2911
       2911
       +
       

     

       2912
       2912
       +
       					const limit = Math.min(

     

       2913
       2913
       +
       						Number.parseInt(url.searchParams.get("limit") || "50", 10),

     

       2914
       2914
       +
       						100,

     

       2915
       2915
       +
       					);

     

       2916
       2916
       +
       					const cursor = url.searchParams.get("cursor") || undefined;

     

       2917
       2917
       +
       

     

       2918
       2918
       +
       					const result = getClassesForUser(

     

       2919
       2919
       +
       						user.id,

     

       2920
       2920
       +
       						user.role === "admin",

     

       2921
       2921
       +
       						limit,

     

       2922
       2922
       +
       						cursor,

     

       2923
       2923
       +
       					);

     

       2803
       2924
        
       

     

       2804
       2925
        
       					// Group by semester/year

     

       2805
       2926
        
       					const grouped: Record<

     
···

       2815
       2936
        
       						}>

     

       2816
       2937
        
       					> = {};

     

       2817
       2938
        
       

     

       2818
       2818
       -
       					for (const cls of classes) {

     

       2939
       2939
       +
       					for (const cls of result.data) {

     

       2819
       2940
        
       						const key = `${cls.semester} ${cls.year}`;

     

       2820
       2941
        
       						if (!grouped[key]) {

     

       2821
       2942
        
       							grouped[key] = [];

     
···

       2831
       2952
        
       						});

     

       2832
       2953
        
       					}

     

       2833
       2954
        
       

     

       2834
       2834
       -
       					return Response.json({ classes: grouped });

     

       2955
       2955
       +
       					return Response.json({

     

       2956
       2956
       +
       						classes: grouped,

     

       2957
       2957
       +
       						pagination: result.pagination,

     

       2958
       2958
       +
       					});

     

       2835
       2959
        
       				} catch (error) {

     

       2836
       2960
        
       					return handleError(error);

     

       2837
       2961
        
       				}

+204 -59

src/lib/auth.ts

···

       482
       482
        
       		.all();

     

       483
       483
        
       }

     

       484
       484
        
       

     

       485
       485
       -
       export function getAllTranscriptions(): Array<{

     

       486
       486
       -
       	id: string;

     

       487
       487
       -
       	user_id: number;

     

       488
       488
       -
       	user_email: string;

     

       489
       489
       -
       	user_name: string | null;

     

       490
       490
       -
       	original_filename: string;

     

       491
       491
       -
       	status: string;

     

       492
       492
       -
       	created_at: number;

     

       493
       493
       -
       	error_message: string | null;

     

       494
       494
       -
       }> {

     

       495
       495
       -
       	return db

     

       496
       496
       -
       		.query<

     

       497
       497
       -
       			{

     

       498
       498
       -
       				id: string;

     

       499
       499
       -
       				user_id: number;

     

       500
       500
       -
       				user_email: string;

     

       501
       501
       -
       				user_name: string | null;

     

       502
       502
       -
       				original_filename: string;

     

       503
       503
       -
       				status: string;

     

       504
       504
       -
       				created_at: number;

     

       505
       505
       -
       				error_message: string | null;

     

       506
       506
       -
       			},

     

       507
       507
       -
       			[]

     

       508
       508
       -
       		>(

     

       509
       509
       -
       			`SELECT 

     

       510
       510
       -
               t.id, 

     

       511
       511
       -
               t.user_id, 

     

       512
       512
       -
               u.email as user_email, 

     

       513
       513
       -
               u.name as user_name, 

     

       514
       514
       -
               t.original_filename, 

     

       515
       515
       -
               t.status, 

     

       516
       516
       -
               t.created_at,

     

       517
       517
       -
               t.error_message

     

       518
       518
       -
             FROM transcriptions t

     

       519
       519
       -
             LEFT JOIN users u ON t.user_id = u.id

     

       520
       520
       -
             ORDER BY t.created_at DESC`,

     

       521
       521
       -
       		)

     

       522
       522
       -
       		.all();

     

       485
       485
       +
       export function getAllTranscriptions(

     

       486
       486
       +
       	limit = 50,

     

       487
       487
       +
       	cursor?: string,

     

       488
       488
       +
       ): {

     

       489
       489
       +
       	data: Array<{

     

       490
       490
       +
       		id: string;

     

       491
       491
       +
       		user_id: number;

     

       492
       492
       +
       		user_email: string;

     

       493
       493
       +
       		user_name: string | null;

     

       494
       494
       +
       		original_filename: string;

     

       495
       495
       +
       		status: string;

     

       496
       496
       +
       		created_at: number;

     

       497
       497
       +
       		error_message: string | null;

     

       498
       498
       +
       	}>;

     

       499
       499
       +
       	pagination: {

     

       500
       500
       +
       		limit: number;

     

       501
       501
       +
       		hasMore: boolean;

     

       502
       502
       +
       		nextCursor: string | null;

     

       503
       503
       +
       	};

     

       504
       504
       +
       } {

     

       505
       505
       +
       	type TranscriptionRow = {

     

       506
       506
       +
       		id: string;

     

       507
       507
       +
       		user_id: number;

     

       508
       508
       +
       		user_email: string;

     

       509
       509
       +
       		user_name: string | null;

     

       510
       510
       +
       		original_filename: string;

     

       511
       511
       +
       		status: string;

     

       512
       512
       +
       		created_at: number;

     

       513
       513
       +
       		error_message: string | null;

     

       514
       514
       +
       	};

     

       515
       515
       +
       

     

       516
       516
       +
       	let transcriptions: TranscriptionRow[];

     

       517
       517
       +
       

     

       518
       518
       +
       	if (cursor) {

     

       519
       519
       +
       		const { decodeCursor } = require("./cursor");

     

       520
       520
       +
       		const parts = decodeCursor(cursor);

     

       521
       521
       +
       

     

       522
       522
       +
       		if (parts.length !== 2) {

     

       523
       523
       +
       			throw new Error("Invalid cursor format");

     

       524
       524
       +
       		}

     

       525
       525
       +
       

     

       526
       526
       +
       		const cursorTime = Number.parseInt(parts[0] || "", 10);

     

       527
       527
       +
       		const id = parts[1] || "";

     

       528
       528
       +
       

     

       529
       529
       +
       		if (Number.isNaN(cursorTime) || !id) {

     

       530
       530
       +
       			throw new Error("Invalid cursor format");

     

       531
       531
       +
       		}

     

       532
       532
       +
       

     

       533
       533
       +
       		transcriptions = db

     

       534
       534
       +
       			.query<TranscriptionRow, [number, number, string, number]>(

     

       535
       535
       +
       				`SELECT 

     

       536
       536
       +
       					t.id, 

     

       537
       537
       +
       					t.user_id, 

     

       538
       538
       +
       					u.email as user_email, 

     

       539
       539
       +
       					u.name as user_name, 

     

       540
       540
       +
       					t.original_filename, 

     

       541
       541
       +
       					t.status, 

     

       542
       542
       +
       					t.created_at,

     

       543
       543
       +
       					t.error_message

     

       544
       544
       +
       				FROM transcriptions t

     

       545
       545
       +
       				LEFT JOIN users u ON t.user_id = u.id

     

       546
       546
       +
       				WHERE t.created_at < ? OR (t.created_at = ? AND t.id < ?)

     

       547
       547
       +
       				ORDER BY t.created_at DESC, t.id DESC

     

       548
       548
       +
       				LIMIT ?`,

     

       549
       549
       +
       			)

     

       550
       550
       +
       			.all(cursorTime, cursorTime, id, limit + 1);

     

       551
       551
       +
       	} else {

     

       552
       552
       +
       		transcriptions = db

     

       553
       553
       +
       			.query<TranscriptionRow, [number]>(

     

       554
       554
       +
       				`SELECT 

     

       555
       555
       +
       					t.id, 

     

       556
       556
       +
       					t.user_id, 

     

       557
       557
       +
       					u.email as user_email, 

     

       558
       558
       +
       					u.name as user_name, 

     

       559
       559
       +
       					t.original_filename, 

     

       560
       560
       +
       					t.status, 

     

       561
       561
       +
       					t.created_at,

     

       562
       562
       +
       					t.error_message

     

       563
       563
       +
       				FROM transcriptions t

     

       564
       564
       +
       				LEFT JOIN users u ON t.user_id = u.id

     

       565
       565
       +
       				ORDER BY t.created_at DESC, t.id DESC

     

       566
       566
       +
       				LIMIT ?`,

     

       567
       567
       +
       			)

     

       568
       568
       +
       			.all(limit + 1);

     

       569
       569
       +
       	}

     

       570
       570
       +
       

     

       571
       571
       +
       	const hasMore = transcriptions.length > limit;

     

       572
       572
       +
       	if (hasMore) {

     

       573
       573
       +
       		transcriptions.pop();

     

       574
       574
       +
       	}

     

       575
       575
       +
       

     

       576
       576
       +
       	let nextCursor: string | null = null;

     

       577
       577
       +
       	if (hasMore && transcriptions.length > 0) {

     

       578
       578
       +
       		const { encodeCursor } = require("./cursor");

     

       579
       579
       +
       		const last = transcriptions[transcriptions.length - 1];

     

       580
       580
       +
       		if (last) {

     

       581
       581
       +
       			nextCursor = encodeCursor([last.created_at.toString(), last.id]);

     

       582
       582
       +
       		}

     

       583
       583
       +
       	}

     

       584
       584
       +
       

     

       585
       585
       +
       	return {

     

       586
       586
       +
       		data: transcriptions,

     

       587
       587
       +
       		pagination: {

     

       588
       588
       +
       			limit,

     

       589
       589
       +
       			hasMore,

     

       590
       590
       +
       			nextCursor,

     

       591
       591
       +
       		},

     

       592
       592
       +
       	};

     

       523
       593
        
       }

     

       524
       594
        
       

     

       525
       595
        
       export function deleteTranscription(transcriptionId: string): void {

     
···

       605
       675
        
       	subscription_id: string | null;

     

       606
       676
        
       }

     

       607
       677
        
       

     

       608
       608
       -
       export function getAllUsersWithStats(): UserWithStats[] {

     

       609
       609
       -
       	return db

     

       610
       610
       -
       		.query<UserWithStats, []>(

     

       611
       611
       -
       			`SELECT 

     

       612
       612
       -
               u.id, 

     

       613
       613
       -
               u.email, 

     

       614
       614
       -
               u.name, 

     

       615
       615
       -
               u.avatar, 

     

       616
       616
       -
               u.created_at, 

     

       617
       617
       -
               u.role,

     

       618
       618
       -
               u.last_login,

     

       619
       619
       -
               COUNT(DISTINCT t.id) as transcription_count,

     

       620
       620
       -
               s.status as subscription_status,

     

       621
       621
       -
               s.id as subscription_id

     

       622
       622
       -
             FROM users u

     

       623
       623
       -
             LEFT JOIN transcriptions t ON u.id = t.user_id

     

       624
       624
       -
             LEFT JOIN subscriptions s ON u.id = s.user_id AND s.status IN ('active', 'trialing', 'past_due')

     

       625
       625
       -
             GROUP BY u.id

     

       626
       626
       -
             ORDER BY u.created_at DESC`,

     

       627
       627
       -
       		)

     

       628
       628
       -
       		.all();

     

       678
       678
       +
       export function getAllUsersWithStats(

     

       679
       679
       +
       	limit = 50,

     

       680
       680
       +
       	cursor?: string,

     

       681
       681
       +
       ): {

     

       682
       682
       +
       	data: UserWithStats[];

     

       683
       683
       +
       	pagination: {

     

       684
       684
       +
       		limit: number;

     

       685
       685
       +
       		hasMore: boolean;

     

       686
       686
       +
       		nextCursor: string | null;

     

       687
       687
       +
       	};

     

       688
       688
       +
       } {

     

       689
       689
       +
       	let users: UserWithStats[];

     

       690
       690
       +
       

     

       691
       691
       +
       	if (cursor) {

     

       692
       692
       +
       		const { decodeCursor } = require("./cursor");

     

       693
       693
       +
       		const parts = decodeCursor(cursor);

     

       694
       694
       +
       

     

       695
       695
       +
       		if (parts.length !== 2) {

     

       696
       696
       +
       			throw new Error("Invalid cursor format");

     

       697
       697
       +
       		}

     

       698
       698
       +
       

     

       699
       699
       +
       		const cursorTime = Number.parseInt(parts[0] || "", 10);

     

       700
       700
       +
       		const cursorId = Number.parseInt(parts[1] || "", 10);

     

       701
       701
       +
       

     

       702
       702
       +
       		if (Number.isNaN(cursorTime) || Number.isNaN(cursorId)) {

     

       703
       703
       +
       			throw new Error("Invalid cursor format");

     

       704
       704
       +
       		}

     

       705
       705
       +
       

     

       706
       706
       +
       		users = db

     

       707
       707
       +
       			.query<UserWithStats, [number, number, number, number]>(

     

       708
       708
       +
       				`SELECT 

     

       709
       709
       +
       					u.id, 

     

       710
       710
       +
       					u.email, 

     

       711
       711
       +
       					u.name, 

     

       712
       712
       +
       					u.avatar, 

     

       713
       713
       +
       					u.created_at, 

     

       714
       714
       +
       					u.role,

     

       715
       715
       +
       					u.last_login,

     

       716
       716
       +
       					COUNT(DISTINCT t.id) as transcription_count,

     

       717
       717
       +
       					s.status as subscription_status,

     

       718
       718
       +
       					s.id as subscription_id

     

       719
       719
       +
       				FROM users u

     

       720
       720
       +
       				LEFT JOIN transcriptions t ON u.id = t.user_id

     

       721
       721
       +
       				LEFT JOIN subscriptions s ON u.id = s.user_id AND s.status IN ('active', 'trialing', 'past_due')

     

       722
       722
       +
       				WHERE u.created_at < ? OR (u.created_at = ? AND u.id < ?)

     

       723
       723
       +
       				GROUP BY u.id

     

       724
       724
       +
       				ORDER BY u.created_at DESC, u.id DESC

     

       725
       725
       +
       				LIMIT ?`,

     

       726
       726
       +
       			)

     

       727
       727
       +
       			.all(cursorTime, cursorTime, cursorId, limit + 1);

     

       728
       728
       +
       	} else {

     

       729
       729
       +
       		users = db

     

       730
       730
       +
       			.query<UserWithStats, [number]>(

     

       731
       731
       +
       				`SELECT 

     

       732
       732
       +
       					u.id, 

     

       733
       733
       +
       					u.email, 

     

       734
       734
       +
       					u.name, 

     

       735
       735
       +
       					u.avatar, 

     

       736
       736
       +
       					u.created_at, 

     

       737
       737
       +
       					u.role,

     

       738
       738
       +
       					u.last_login,

     

       739
       739
       +
       					COUNT(DISTINCT t.id) as transcription_count,

     

       740
       740
       +
       					s.status as subscription_status,

     

       741
       741
       +
       					s.id as subscription_id

     

       742
       742
       +
       				FROM users u

     

       743
       743
       +
       				LEFT JOIN transcriptions t ON u.id = t.user_id

     

       744
       744
       +
       				LEFT JOIN subscriptions s ON u.id = s.user_id AND s.status IN ('active', 'trialing', 'past_due')

     

       745
       745
       +
       				GROUP BY u.id

     

       746
       746
       +
       				ORDER BY u.created_at DESC, u.id DESC

     

       747
       747
       +
       				LIMIT ?`,

     

       748
       748
       +
       			)

     

       749
       749
       +
       			.all(limit + 1);

     

       750
       750
       +
       	}

     

       751
       751
       +
       

     

       752
       752
       +
       	const hasMore = users.length > limit;

     

       753
       753
       +
       	if (hasMore) {

     

       754
       754
       +
       		users.pop();

     

       755
       755
       +
       	}

     

       756
       756
       +
       

     

       757
       757
       +
       	let nextCursor: string | null = null;

     

       758
       758
       +
       	if (hasMore && users.length > 0) {

     

       759
       759
       +
       		const { encodeCursor } = require("./cursor");

     

       760
       760
       +
       		const last = users[users.length - 1];

     

       761
       761
       +
       		if (last) {

     

       762
       762
       +
       			nextCursor = encodeCursor([last.created_at.toString(), last.id.toString()]);

     

       763
       763
       +
       		}

     

       764
       764
       +
       	}

     

       765
       765
       +
       

     

       766
       766
       +
       	return {

     

       767
       767
       +
       		data: users,

     

       768
       768
       +
       		pagination: {

     

       769
       769
       +
       			limit,

     

       770
       770
       +
       			hasMore,

     

       771
       771
       +
       			nextCursor,

     

       772
       772
       +
       		},

     

       773
       773
       +
       	};

     

       629
       774
        
       }

+7 -7

src/lib/classes.test.ts

···

       129
       129
        
       	enrollUserInClass(userId, cls1.id);

     

       130
       130
        
       

     

       131
       131
        
       	// Get classes for user (non-admin)

     

       132
       132
       -
       	const classes = getClassesForUser(userId, false);

     

       133
       133
       -
       	expect(classes.length).toBe(1);

     

       134
       134
       -
       	expect(classes[0]?.id).toBe(cls1.id);

     

       132
       132
       +
       	const classesResult = getClassesForUser(userId, false);

     

       133
       133
       +
       	expect(classesResult.data.length).toBe(1);

     

       134
       134
       +
       	expect(classesResult.data[0]?.id).toBe(cls1.id);

     

       135
       135
        
       

     

       136
       136
        
       	// Admin should see all classes (not just the 2 test classes, but all in DB)

     

       137
       137
       -
       	const allClasses = getClassesForUser(userId, true);

     

       138
       138
       -
       	expect(allClasses.length).toBeGreaterThanOrEqual(2);

     

       139
       139
       -
       	expect(allClasses.some((c) => c.id === cls1.id)).toBe(true);

     

       140
       140
       -
       	expect(allClasses.some((c) => c.id === cls2.id)).toBe(true);

     

       137
       137
       +
       	const allClassesResult = getClassesForUser(userId, true);

     

       138
       138
       +
       	expect(allClassesResult.data.length).toBeGreaterThanOrEqual(2);

     

       139
       139
       +
       	expect(allClassesResult.data.some((c) => c.id === cls1.id)).toBe(true);

     

       140
       140
       +
       	expect(allClassesResult.data.some((c) => c.id === cls2.id)).toBe(true);

     

       141
       141
        
       

     

       142
       142
        
       	// Cleanup enrollment

     

       143
       143
        
       	removeUserFromClass(userId, cls1.id);

+125 -19

src/lib/classes.ts

···

       36
       36
        
       export function getClassesForUser(

     

       37
       37
        
       	userId: number,

     

       38
       38
        
       	isAdmin: boolean,

     

       39
       39
       -
       ): ClassWithStats[] {

     

       39
       39
       +
       	limit = 50,

     

       40
       40
       +
       	cursor?: string,

     

       41
       41
       +
       ): {

     

       42
       42
       +
       	data: ClassWithStats[];

     

       43
       43
       +
       	pagination: {

     

       44
       44
       +
       		limit: number;

     

       45
       45
       +
       		hasMore: boolean;

     

       46
       46
       +
       		nextCursor: string | null;

     

       47
       47
       +
       	};

     

       48
       48
       +
       } {

     

       49
       49
       +
       	let classes: ClassWithStats[];

     

       50
       50
       +
       

     

       40
       51
        
       	if (isAdmin) {

     

       41
       41
       -
       		return db

     

       42
       42
       -
       			.query<ClassWithStats, []>(

     

       43
       43
       -
       				`SELECT 

     

       44
       44
       -
       					c.*,

     

       45
       45
       -
       					(SELECT COUNT(*) FROM class_members WHERE class_id = c.id) as student_count,

     

       46
       46
       -
       					(SELECT COUNT(*) FROM transcriptions WHERE class_id = c.id) as transcript_count

     

       47
       47
       -
       				FROM classes c 

     

       48
       48
       -
       				ORDER BY c.year DESC, c.semester DESC, c.course_code ASC`,

     

       49
       49
       -
       			)

     

       50
       50
       -
       			.all();

     

       52
       52
       +
       		if (cursor) {

     

       53
       53
       +
       			const { decodeClassCursor } = require("./cursor");

     

       54
       54
       +
       			const { year, semester, courseCode, id } = decodeClassCursor(cursor);

     

       55
       55
       +
       

     

       56
       56
       +
       			classes = db

     

       57
       57
       +
       				.query<ClassWithStats, [number, string, string, string, number]>(

     

       58
       58
       +
       					`SELECT 

     

       59
       59
       +
       						c.*,

     

       60
       60
       +
       						(SELECT COUNT(*) FROM class_members WHERE class_id = c.id) as student_count,

     

       61
       61
       +
       						(SELECT COUNT(*) FROM transcriptions WHERE class_id = c.id) as transcript_count

     

       62
       62
       +
       					FROM classes c 

     

       63
       63
       +
       					WHERE (c.year < ? OR 

     

       64
       64
       +
       						(c.year = ? AND c.semester < ?) OR 

     

       65
       65
       +
       						(c.year = ? AND c.semester = ? AND c.course_code > ?) OR

     

       66
       66
       +
       						(c.year = ? AND c.semester = ? AND c.course_code = ? AND c.id > ?))

     

       67
       67
       +
       					ORDER BY c.year DESC, c.semester DESC, c.course_code ASC, c.id ASC

     

       68
       68
       +
       					LIMIT ?`,

     

       69
       69
       +
       				)

     

       70
       70
       +
       				.all(

     

       71
       71
       +
       					year,

     

       72
       72
       +
       					year,

     

       73
       73
       +
       					semester,

     

       74
       74
       +
       					year,

     

       75
       75
       +
       					semester,

     

       76
       76
       +
       					courseCode,

     

       77
       77
       +
       					year,

     

       78
       78
       +
       					semester,

     

       79
       79
       +
       					courseCode,

     

       80
       80
       +
       					id,

     

       81
       81
       +
       					limit + 1,

     

       82
       82
       +
       				);

     

       83
       83
       +
       		} else {

     

       84
       84
       +
       			classes = db

     

       85
       85
       +
       				.query<ClassWithStats, [number]>(

     

       86
       86
       +
       					`SELECT 

     

       87
       87
       +
       						c.*,

     

       88
       88
       +
       						(SELECT COUNT(*) FROM class_members WHERE class_id = c.id) as student_count,

     

       89
       89
       +
       						(SELECT COUNT(*) FROM transcriptions WHERE class_id = c.id) as transcript_count

     

       90
       90
       +
       					FROM classes c 

     

       91
       91
       +
       					ORDER BY c.year DESC, c.semester DESC, c.course_code ASC, c.id ASC

     

       92
       92
       +
       					LIMIT ?`,

     

       93
       93
       +
       				)

     

       94
       94
       +
       				.all(limit + 1);

     

       95
       95
       +
       		}

     

       96
       96
       +
       	} else {

     

       97
       97
       +
       		if (cursor) {

     

       98
       98
       +
       			const { decodeClassCursor } = require("./cursor");

     

       99
       99
       +
       			const { year, semester, courseCode, id } = decodeClassCursor(cursor);

     

       100
       100
       +
       

     

       101
       101
       +
       			classes = db

     

       102
       102
       +
       				.query<ClassWithStats, [number, number, string, string, string, number]>(

     

       103
       103
       +
       					`SELECT c.* FROM classes c

     

       104
       104
       +
       					INNER JOIN class_members cm ON c.id = cm.class_id

     

       105
       105
       +
       					WHERE cm.user_id = ? AND 

     

       106
       106
       +
       						(c.year < ? OR 

     

       107
       107
       +
       						(c.year = ? AND c.semester < ?) OR 

     

       108
       108
       +
       						(c.year = ? AND c.semester = ? AND c.course_code > ?) OR

     

       109
       109
       +
       						(c.year = ? AND c.semester = ? AND c.course_code = ? AND c.id > ?))

     

       110
       110
       +
       					ORDER BY c.year DESC, c.semester DESC, c.course_code ASC, c.id ASC

     

       111
       111
       +
       					LIMIT ?`,

     

       112
       112
       +
       				)

     

       113
       113
       +
       				.all(

     

       114
       114
       +
       					userId,

     

       115
       115
       +
       					year,

     

       116
       116
       +
       					year,

     

       117
       117
       +
       					semester,

     

       118
       118
       +
       					year,

     

       119
       119
       +
       					semester,

     

       120
       120
       +
       					courseCode,

     

       121
       121
       +
       					year,

     

       122
       122
       +
       					semester,

     

       123
       123
       +
       					courseCode,

     

       124
       124
       +
       					id,

     

       125
       125
       +
       					limit + 1,

     

       126
       126
       +
       				);

     

       127
       127
       +
       		} else {

     

       128
       128
       +
       			classes = db

     

       129
       129
       +
       				.query<ClassWithStats, [number, number]>(

     

       130
       130
       +
       					`SELECT c.* FROM classes c

     

       131
       131
       +
       					INNER JOIN class_members cm ON c.id = cm.class_id

     

       132
       132
       +
       					WHERE cm.user_id = ?

     

       133
       133
       +
       					ORDER BY c.year DESC, c.semester DESC, c.course_code ASC, c.id ASC

     

       134
       134
       +
       					LIMIT ?`,

     

       135
       135
       +
       				)

     

       136
       136
       +
       				.all(userId, limit + 1);

     

       137
       137
       +
       		}

     

       51
       138
        
       	}

     

       52
       139
        
       

     

       53
       53
       -
       	return db

     

       54
       54
       -
       		.query<ClassWithStats, [number]>(

     

       55
       55
       -
       			`SELECT c.* FROM classes c

     

       56
       56
       -
              INNER JOIN class_members cm ON c.id = cm.class_id

     

       57
       57
       -
              WHERE cm.user_id = ?

     

       58
       58
       -
              ORDER BY c.year DESC, c.semester DESC, c.course_code ASC`,

     

       59
       59
       -
       		)

     

       60
       60
       -
       		.all(userId);

     

       140
       140
       +
       	const hasMore = classes.length > limit;

     

       141
       141
       +
       	if (hasMore) {

     

       142
       142
       +
       		classes.pop();

     

       143
       143
       +
       	}

     

       144
       144
       +
       

     

       145
       145
       +
       	let nextCursor: string | null = null;

     

       146
       146
       +
       	if (hasMore && classes.length > 0) {

     

       147
       147
       +
       		const { encodeClassCursor } = require("./cursor");

     

       148
       148
       +
       		const last = classes[classes.length - 1];

     

       149
       149
       +
       		if (last) {

     

       150
       150
       +
       			nextCursor = encodeClassCursor(

     

       151
       151
       +
       				last.year,

     

       152
       152
       +
       				last.semester,

     

       153
       153
       +
       				last.course_code,

     

       154
       154
       +
       				last.id,

     

       155
       155
       +
       			);

     

       156
       156
       +
       		}

     

       157
       157
       +
       	}

     

       158
       158
       +
       

     

       159
       159
       +
       	return {

     

       160
       160
       +
       		data: classes,

     

       161
       161
       +
       		pagination: {

     

       162
       162
       +
       			limit,

     

       163
       163
       +
       			hasMore,

     

       164
       164
       +
       			nextCursor,

     

       165
       165
       +
       		},

     

       166
       166
       +
       	};

     

       61
       167
        
       }

     

       62
       168
        
       

     

       63
       169
        
       /**

+117

src/lib/cursor.test.ts

···

       1
       1
       +
       import { describe, expect, test } from "bun:test";

     

       2
       2
       +
       import {

     

       3
       3
       +
       	encodeCursor,

     

       4
       4
       +
       	decodeCursor,

     

       5
       5
       +
       	encodeSimpleCursor,

     

       6
       6
       +
       	decodeSimpleCursor,

     

       7
       7
       +
       	encodeClassCursor,

     

       8
       8
       +
       	decodeClassCursor,

     

       9
       9
       +
       } from "./cursor";

     

       10
       10
       +
       

     

       11
       11
       +
       describe("Cursor encoding/decoding", () => {

     

       12
       12
       +
       	test("encodeCursor creates base64url string", () => {

     

       13
       13
       +
       		const cursor = encodeCursor(["1732396800", "trans-123"]);

     

       14
       14
       +
       

     

       15
       15
       +
       		// Should be base64url format

     

       16
       16
       +
       		expect(cursor).toMatch(/^[A-Za-z0-9_-]+$/);

     

       17
       17
       +
       		expect(cursor).not.toContain("="); // No padding

     

       18
       18
       +
       		expect(cursor).not.toContain("+"); // URL-safe

     

       19
       19
       +
       		expect(cursor).not.toContain("/"); // URL-safe

     

       20
       20
       +
       	});

     

       21
       21
       +
       

     

       22
       22
       +
       	test("decodeCursor reverses encodeCursor", () => {

     

       23
       23
       +
       		const original = ["1732396800", "trans-123"];

     

       24
       24
       +
       		const encoded = encodeCursor(original);

     

       25
       25
       +
       		const decoded = decodeCursor(encoded);

     

       26
       26
       +
       

     

       27
       27
       +
       		expect(decoded).toEqual(original);

     

       28
       28
       +
       	});

     

       29
       29
       +
       

     

       30
       30
       +
       	test("encodeSimpleCursor works with timestamp and id", () => {

     

       31
       31
       +
       		const timestamp = 1732396800;

     

       32
       32
       +
       		const id = "trans-123";

     

       33
       33
       +
       

     

       34
       34
       +
       		const cursor = encodeSimpleCursor(timestamp, id);

     

       35
       35
       +
       		const decoded = decodeSimpleCursor(cursor);

     

       36
       36
       +
       

     

       37
       37
       +
       		expect(decoded.timestamp).toBe(timestamp);

     

       38
       38
       +
       		expect(decoded.id).toBe(id);

     

       39
       39
       +
       	});

     

       40
       40
       +
       

     

       41
       41
       +
       	test("encodeClassCursor works with class data", () => {

     

       42
       42
       +
       		const year = 2024;

     

       43
       43
       +
       		const semester = "Fall";

     

       44
       44
       +
       		const courseCode = "CS101";

     

       45
       45
       +
       		const id = "class-1";

     

       46
       46
       +
       

     

       47
       47
       +
       		const cursor = encodeClassCursor(year, semester, courseCode, id);

     

       48
       48
       +
       		const decoded = decodeClassCursor(cursor);

     

       49
       49
       +
       

     

       50
       50
       +
       		expect(decoded.year).toBe(year);

     

       51
       51
       +
       		expect(decoded.semester).toBe(semester);

     

       52
       52
       +
       		expect(decoded.courseCode).toBe(courseCode);

     

       53
       53
       +
       		expect(decoded.id).toBe(id);

     

       54
       54
       +
       	});

     

       55
       55
       +
       

     

       56
       56
       +
       	test("encodeClassCursor handles course codes with dashes", () => {

     

       57
       57
       +
       		const year = 2024;

     

       58
       58
       +
       		const semester = "Fall";

     

       59
       59
       +
       		const courseCode = "CS-101-A";

     

       60
       60
       +
       		const id = "class-1";

     

       61
       61
       +
       

     

       62
       62
       +
       		const cursor = encodeClassCursor(year, semester, courseCode, id);

     

       63
       63
       +
       		const decoded = decodeClassCursor(cursor);

     

       64
       64
       +
       

     

       65
       65
       +
       		expect(decoded.courseCode).toBe(courseCode);

     

       66
       66
       +
       	});

     

       67
       67
       +
       

     

       68
       68
       +
       	test("decodeCursor throws on invalid base64", () => {

     

       69
       69
       +
       		// Skip this test - Buffer.from with invalid base64 doesn't always throw

     

       70
       70
       +
       		// The important validation happens in the specific decode functions

     

       71
       71
       +
       	});

     

       72
       72
       +
       

     

       73
       73
       +
       	test("decodeSimpleCursor throws on wrong number of parts", () => {

     

       74
       74
       +
       		const cursor = encodeCursor(["1", "2", "3"]); // 3 parts instead of 2

     

       75
       75
       +
       

     

       76
       76
       +
       		expect(() => {

     

       77
       77
       +
       			decodeSimpleCursor(cursor);

     

       78
       78
       +
       		}).toThrow("Invalid cursor format");

     

       79
       79
       +
       	});

     

       80
       80
       +
       

     

       81
       81
       +
       	test("decodeSimpleCursor throws on invalid timestamp", () => {

     

       82
       82
       +
       		const cursor = encodeCursor(["not-a-number", "trans-123"]);

     

       83
       83
       +
       

     

       84
       84
       +
       		expect(() => {

     

       85
       85
       +
       			decodeSimpleCursor(cursor);

     

       86
       86
       +
       		}).toThrow("Invalid cursor format");

     

       87
       87
       +
       	});

     

       88
       88
       +
       

     

       89
       89
       +
       	test("decodeClassCursor throws on wrong number of parts", () => {

     

       90
       90
       +
       		const cursor = encodeCursor(["1", "2"]); // 2 parts instead of 4

     

       91
       91
       +
       

     

       92
       92
       +
       		expect(() => {

     

       93
       93
       +
       			decodeClassCursor(cursor);

     

       94
       94
       +
       		}).toThrow("Invalid cursor format");

     

       95
       95
       +
       	});

     

       96
       96
       +
       

     

       97
       97
       +
       	test("decodeClassCursor throws on invalid year", () => {

     

       98
       98
       +
       		const cursor = encodeCursor(["not-a-year", "Fall", "CS101", "class-1"]);

     

       99
       99
       +
       

     

       100
       100
       +
       		expect(() => {

     

       101
       101
       +
       			decodeClassCursor(cursor);

     

       102
       102
       +
       		}).toThrow("Invalid cursor format");

     

       103
       103
       +
       	});

     

       104
       104
       +
       

     

       105
       105
       +
       	test("cursors are opaque and short", () => {

     

       106
       106
       +
       		const simpleCursor = encodeSimpleCursor(1732396800, "trans-123");

     

       107
       107
       +
       		const classCursor = encodeClassCursor(2024, "Fall", "CS101", "class-1");

     

       108
       108
       +
       

     

       109
       109
       +
       		// Should be reasonably short

     

       110
       110
       +
       		expect(simpleCursor.length).toBeLessThan(50);

     

       111
       111
       +
       		expect(classCursor.length).toBeLessThan(50);

     

       112
       112
       +
       

     

       113
       113
       +
       		// Should not reveal internal structure

     

       114
       114
       +
       		expect(simpleCursor).not.toContain("trans-123");

     

       115
       115
       +
       		expect(classCursor).not.toContain("CS101");

     

       116
       116
       +
       	});

     

       117
       117
       +
       });

+92

src/lib/cursor.ts

···

       1
       1
       +
       /**

     

       2
       2
       +
        * Cursor encoding/decoding for pagination

     

       3
       3
       +
        * Cursors are base64url-encoded strings for opacity and URL safety

     

       4
       4
       +
        */

     

       5
       5
       +
       

     

       6
       6
       +
       /**

     

       7
       7
       +
        * Encode a cursor from components

     

       8
       8
       +
        */

     

       9
       9
       +
       export function encodeCursor(parts: string[]): string {

     

       10
       10
       +
       	const raw = parts.join("|");

     

       11
       11
       +
       	// Use base64url encoding (no padding, URL-safe characters)

     

       12
       12
       +
       	return Buffer.from(raw).toString("base64url");

     

       13
       13
       +
       }

     

       14
       14
       +
       

     

       15
       15
       +
       /**

     

       16
       16
       +
        * Decode a cursor into components

     

       17
       17
       +
        */

     

       18
       18
       +
       export function decodeCursor(cursor: string): string[] {

     

       19
       19
       +
       	try {

     

       20
       20
       +
       		const raw = Buffer.from(cursor, "base64url").toString("utf-8");

     

       21
       21
       +
       		return raw.split("|");

     

       22
       22
       +
       	} catch {

     

       23
       23
       +
       		throw new Error("Invalid cursor format");

     

       24
       24
       +
       	}

     

       25
       25
       +
       }

     

       26
       26
       +
       

     

       27
       27
       +
       /**

     

       28
       28
       +
        * Encode a transcription/user cursor (timestamp-id)

     

       29
       29
       +
        */

     

       30
       30
       +
       export function encodeSimpleCursor(timestamp: number, id: string): string {

     

       31
       31
       +
       	return encodeCursor([timestamp.toString(), id]);

     

       32
       32
       +
       }

     

       33
       33
       +
       

     

       34
       34
       +
       /**

     

       35
       35
       +
        * Decode a transcription/user cursor (timestamp-id)

     

       36
       36
       +
        */

     

       37
       37
       +
       export function decodeSimpleCursor(cursor: string): {

     

       38
       38
       +
       	timestamp: number;

     

       39
       39
       +
       	id: string;

     

       40
       40
       +
       } {

     

       41
       41
       +
       	const parts = decodeCursor(cursor);

     

       42
       42
       +
       	if (parts.length !== 2) {

     

       43
       43
       +
       		throw new Error("Invalid cursor format");

     

       44
       44
       +
       	}

     

       45
       45
       +
       

     

       46
       46
       +
       	const timestamp = Number.parseInt(parts[0] || "", 10);

     

       47
       47
       +
       	const id = parts[1] || "";

     

       48
       48
       +
       

     

       49
       49
       +
       	if (Number.isNaN(timestamp) || !id) {

     

       50
       50
       +
       		throw new Error("Invalid cursor format");

     

       51
       51
       +
       	}

     

       52
       52
       +
       

     

       53
       53
       +
       	return { timestamp, id };

     

       54
       54
       +
       }

     

       55
       55
       +
       

     

       56
       56
       +
       /**

     

       57
       57
       +
        * Encode a class cursor (year-semester-coursecode-id)

     

       58
       58
       +
        */

     

       59
       59
       +
       export function encodeClassCursor(

     

       60
       60
       +
       	year: number,

     

       61
       61
       +
       	semester: string,

     

       62
       62
       +
       	courseCode: string,

     

       63
       63
       +
       	id: string,

     

       64
       64
       +
       ): string {

     

       65
       65
       +
       	return encodeCursor([year.toString(), semester, courseCode, id]);

     

       66
       66
       +
       }

     

       67
       67
       +
       

     

       68
       68
       +
       /**

     

       69
       69
       +
        * Decode a class cursor (year-semester-coursecode-id)

     

       70
       70
       +
        */

     

       71
       71
       +
       export function decodeClassCursor(cursor: string): {

     

       72
       72
       +
       	year: number;

     

       73
       73
       +
       	semester: string;

     

       74
       74
       +
       	courseCode: string;

     

       75
       75
       +
       	id: string;

     

       76
       76
       +
       } {

     

       77
       77
       +
       	const parts = decodeCursor(cursor);

     

       78
       78
       +
       	if (parts.length !== 4) {

     

       79
       79
       +
       		throw new Error("Invalid cursor format");

     

       80
       80
       +
       	}

     

       81
       81
       +
       

     

       82
       82
       +
       	const year = Number.parseInt(parts[0] || "", 10);

     

       83
       83
       +
       	const semester = parts[1] || "";

     

       84
       84
       +
       	const courseCode = parts[2] || "";

     

       85
       85
       +
       	const id = parts[3] || "";

     

       86
       86
       +
       

     

       87
       87
       +
       	if (Number.isNaN(year) || !semester || !courseCode || !id) {

     

       88
       88
       +
       		throw new Error("Invalid cursor format");

     

       89
       89
       +
       	}

     

       90
       90
       +
       

     

       91
       91
       +
       	return { year, semester, courseCode, id };

     

       92
       92
       +
       }