commit 0b3565be2bd8786fb42dd36c7d34f0aa5d125b8a · dunkirk.sh/thistle

CRUSH.md

···

       2
       2
        
       

     

       3
       3
        
       This is a Bun-based transcription service using the [Bun fullstack pattern](https://bun.com/docs/bundler/fullstack) for routing and bundled HTML.

     

       4
       4
        
       

     

       5
       5
       +
       ## Workflow

     

       6
       6
       +
       

     

       7
       7
       +
       **IMPORTANT**: Do NOT commit changes until the user explicitly asks you to commit. Always wait for user verification that changes are working correctly before making commits.

     

       8
       8
       +
       

     

       5
       9
        
       ## Project Info

     

       6
       10
        
       

     

       7
       11
        
       - Name: Thistle

src/db/schema.ts

···

       134
       134
        
             CREATE INDEX IF NOT EXISTS idx_transcriptions_whisper_job_id ON transcriptions(whisper_job_id);

     

       135
       135
        
           `,

     

       136
       136
        
       	},

     

       137
       137
       +
       	{

     

       138
       138
       +
       		version: 2,

     

       139
       139
       +
       		name: "Add section column to classes table",

     

       140
       140
       +
       		sql: `

     

       141
       141
       +
             ALTER TABLE classes ADD COLUMN section TEXT;

     

       142
       142
       +
             CREATE INDEX IF NOT EXISTS idx_classes_course_code ON classes(course_code);

     

       143
       143
       +
           `,

     

       144
       144
       +
       	},

     

       137
       145
        
       ];

     

       138
       146
        
       

     

       139
       147
        
       function getCurrentVersion(): number {

+25 -6

src/index.ts

···

       37
       37
        
       	getMeetingTimesForClass,

     

       38
       38
        
       	getTranscriptionsForClass,

     

       39
       39
        
       	isUserEnrolledInClass,

     

       40
       40
       -
       	joinClassByCode,

     

       40
       40
       +
       	joinClass,

     

       41
       41
        
       	removeUserFromClass,

     

       42
       42
       +
       	searchClassesByCourseCode,

     

       42
       43
        
       	toggleClassArchive,

     

       43
       44
        
       	updateMeetingTime,

     

       44
       45
        
       } from "./lib/classes";

     
···

       1495
       1496
        
       				}

     

       1496
       1497
        
       			},

     

       1497
       1498
        
       		},

     

       1499
       1499
       +
       		"/api/classes/search": {

     

       1500
       1500
       +
       			GET: async (req) => {

     

       1501
       1501
       +
       				try {

     

       1502
       1502
       +
       					requireAuth(req);

     

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

     

       1504
       1504
       +
       					const query = url.searchParams.get("q");

     

       1505
       1505
       +
       

     

       1506
       1506
       +
       					if (!query) {

     

       1507
       1507
       +
       						return Response.json({ classes: [] });

     

       1508
       1508
       +
       					}

     

       1509
       1509
       +
       

     

       1510
       1510
       +
       					const classes = searchClassesByCourseCode(query);

     

       1511
       1511
       +
       					return Response.json({ classes });

     

       1512
       1512
       +
       				} catch (error) {

     

       1513
       1513
       +
       					return handleError(error);

     

       1514
       1514
       +
       				}

     

       1515
       1515
       +
       			},

     

       1516
       1516
       +
       		},

     

       1498
       1517
        
       		"/api/classes/join": {

     

       1499
       1518
        
       			POST: async (req) => {

     

       1500
       1519
        
       				try {

     

       1501
       1520
        
       					const user = requireAuth(req);

     

       1502
       1521
        
       					const body = await req.json();

     

       1503
       1503
       -
       					const classCode = body.class_code;

     

       1522
       1522
       +
       					const classId = body.class_id;

     

       1504
       1523
        
       

     

       1505
       1505
       -
       					if (!classCode || typeof classCode !== "string") {

     

       1524
       1524
       +
       					if (!classId || typeof classId !== "string") {

     

       1506
       1525
        
       						return Response.json(

     

       1507
       1507
       -
       							{ error: "Class code required" },

     

       1526
       1526
       +
       							{ error: "Class ID required" },

     

       1508
       1527
        
       							{ status: 400 },

     

       1509
       1528
        
       						);

     

       1510
       1529
        
       					}

     

       1511
       1530
        
       

     

       1512
       1512
       -
       					const result = joinClassByCode(classCode.trim(), user.id);

     

       1531
       1531
       +
       					const result = joinClass(classId, user.id);

     

       1513
       1532
        
       

     

       1514
       1533
        
       					if (!result.success) {

     

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

     

       1516
       1535
        
       					}

     

       1517
       1536
        
       

     

       1518
       1518
       -
       					return Response.json({ success: true, class_id: result.classId });

     

       1537
       1537
       +
       					return Response.json({ success: true });

     

       1519
       1538
        
       				} catch (error) {

     

       1520
       1539
        
       					return handleError(error);

     

       1521
       1540
        
       				}

+28 -11

src/lib/classes.ts

···

       6
       6
        
       	course_code: string;

     

       7
       7
        
       	name: string;

     

       8
       8
        
       	professor: string;

     

       9
       9
       +
       	section: string | null;

     

       9
       10
        
       	semester: string;

     

       10
       11
        
       	year: number;

     

       11
       12
        
       	archived: boolean;

     
···

       249
       250
        
       }

     

       250
       251
        
       

     

       251
       252
        
       /**

     

       252
       252
       -
        * Join a class by class code

     

       253
       253
       +
        * Search for classes by course code

     

       253
       254
        
        */

     

       254
       254
       -
       export function joinClassByCode(

     

       255
       255
       -
       	classCode: string,

     

       256
       256
       -
       	userId: number,

     

       257
       257
       -
       ): { success: boolean; classId?: string; error?: string } {

     

       258
       258
       -
       	// Find class by code (case-insensitive)

     

       259
       259
       -
       	const cls = db

     

       255
       255
       +
       export function searchClassesByCourseCode(courseCode: string): Class[] {

     

       256
       256
       +
       	return db

     

       260
       257
        
       		.query<Class, [string]>(

     

       261
       261
       -
       			"SELECT * FROM classes WHERE UPPER(id) = UPPER(?) AND archived = 0",

     

       258
       258
       +
       			`SELECT * FROM classes 

     

       259
       259
       +
              WHERE UPPER(course_code) LIKE UPPER(?) 

     

       260
       260
       +
              AND archived = 0

     

       261
       261
       +
              ORDER BY year DESC, semester DESC, professor ASC, section ASC`,

     

       262
       262
        
       		)

     

       263
       263
       -
       		.get(classCode);

     

       263
       263
       +
       		.all(`%${courseCode}%`);

     

       264
       264
       +
       }

     

       265
       265
       +
       

     

       266
       266
       +
       /**

     

       267
       267
       +
        * Join a class by class ID

     

       268
       268
       +
        */

     

       269
       269
       +
       export function joinClass(

     

       270
       270
       +
       	classId: string,

     

       271
       271
       +
       	userId: number,

     

       272
       272
       +
       ): { success: boolean; error?: string } {

     

       273
       273
       +
       	// Find class by ID

     

       274
       274
       +
       	const cls = db

     

       275
       275
       +
       		.query<Class, [string]>("SELECT * FROM classes WHERE id = ?")

     

       276
       276
       +
       		.get(classId);

     

       264
       277
        
       

     

       265
       278
        
       	if (!cls) {

     

       266
       266
       -
       		return { success: false, error: "Class not found or is archived" };

     

       279
       279
       +
       		return { success: false, error: "Class not found" };

     

       280
       280
       +
       	}

     

       281
       281
       +
       

     

       282
       282
       +
       	if (cls.archived) {

     

       283
       283
       +
       		return { success: false, error: "This class is archived" };

     

       267
       284
        
       	}

     

       268
       285
        
       

     

       269
       286
        
       	// Check if already enrolled

     
···

       282
       299
        
       		"INSERT INTO class_members (class_id, user_id, enrolled_at) VALUES (?, ?, ?)",

     

       283
       300
        
       	).run(cls.id, userId, Math.floor(Date.now() / 1000));

     

       284
       301
        
       

     

       285
       285
       -
       	return { success: true, classId: cls.id };

     

       302
       302
       +
       	return { success: true };

     

       286
       303
        
       }

     

       287
       304