@coursebuilder/adapter-drizzle 2.1.1 → 3.0.0-canary.0.0c9beb2ae

package/src/lib/mysql/ports/progress.ts

@@ -0,0 +1,366 @@
+import { and, eq, inArray, or, sql } from 'drizzle-orm'
+import { z } from 'zod'
+
+import type { ProgressPort } from '@coursebuilder/core/ports'
+import {
+	resourceProgressSchema,
+	type ResourceProgress,
+} from '@coursebuilder/core/schemas'
+import type { ContentResource } from '@coursebuilder/core/schemas/content-resource-schema'
+import type { ModuleProgress } from '@coursebuilder/core/schemas/resource-progress-schema'
+import { logger as baseLogger } from '@coursebuilder/utils/logger'
+
+import type { MySqlContext } from '../context.js'
+
+const logger = baseLogger as unknown as {
+	error: (error: Error, attrs?: Record<string, unknown>) => void
+}
+
+/**
+ * Creates the MySQL implementation of lesson and module progress tracking.
+ *
+ * @param context - The shared MySQL client and table set.
+ * @returns All seven progress operations.
+ *
+ * @example
+ * ```ts
+ * const progressPort = createProgressPort(context)
+ * ```
+ */
+export function createProgressPort({
+	client,
+	tables,
+}: MySqlContext): ProgressPort {
+	const { contentResource, contentResourceResource, resourceProgress, users } =
+		tables
+
+	return {
+		async clearLessonProgressForUser(options: {
+			userId: string
+			lessons: { id: string; slug: string }[]
+		}): Promise<void> {
+			const lessonIds = options.lessons.map(({ id }) => id)
+			if (lessonIds.length === 0) return
+
+			await client
+				.delete(resourceProgress)
+				.where(
+					and(
+						eq(resourceProgress.userId, options.userId),
+						inArray(resourceProgress.resourceId, lessonIds),
+					),
+				)
+		},
+		async completeLessonProgressForUser(options: {
+			userId: string
+			lessonId?: string
+		}): Promise<ResourceProgress | null> {
+			if (!options.lessonId) {
+				throw new Error('No lessonId provided')
+			}
+
+			let lessonProgress = await client.query.resourceProgress.findFirst({
+				where: and(
+					eq(resourceProgress.userId, options.userId),
+					eq(resourceProgress.resourceId, options.lessonId),
+				),
+			})
+
+			const now = new Date()
+
+			if (lessonProgress) {
+				if (!lessonProgress.completedAt) {
+					await client
+						.update(resourceProgress)
+						.set({
+							completedAt: now,
+							updatedAt: now,
+						})
+						.where(
+							and(
+								eq(resourceProgress.userId, options.userId),
+								eq(resourceProgress.resourceId, options.lessonId),
+							),
+						)
+				}
+			} else {
+				await client.insert(resourceProgress).values({
+					userId: options.userId,
+					resourceId: options.lessonId,
+					completedAt: now,
+					updatedAt: now,
+				})
+			}
+			lessonProgress = await client.query.resourceProgress.findFirst({
+				where: and(
+					eq(resourceProgress.userId, options.userId),
+					eq(resourceProgress.resourceId, options.lessonId),
+				),
+			})
+			const parsedLessonProgress =
+				resourceProgressSchema.safeParse(lessonProgress)
+
+			if (!parsedLessonProgress.success) {
+				logger.error(parsedLessonProgress.error, {
+					event: 'adapter.lessonProgress.parse_failed',
+					lessonId: options.lessonId,
+					userId: options.userId,
+				})
+				return null
+			}
+
+			return parsedLessonProgress.data
+		},
+		async getLessonProgressCountsByDate(): Promise<
+			{
+				count: number
+				completedAt: string
+			}[]
+		> {
+			const completed = await client
+				.select({ completedAt: resourceProgress.completedAt })
+				.from(resourceProgress)
+				.where(sql`${resourceProgress.completedAt} IS NOT NULL`)
+
+			const counts = new Map<string, number>()
+			for (const { completedAt } of completed) {
+				if (!completedAt) continue
+				const date = completedAt.toISOString().slice(0, 10)
+				counts.set(date, (counts.get(date) ?? 0) + 1)
+			}
+
+			return Array.from(counts, ([completedAt, count]) => ({
+				count,
+				completedAt,
+			})).sort((left, right) =>
+				left.completedAt.localeCompare(right.completedAt),
+			)
+		},
+		async getLessonProgressForUser(
+			userId: string,
+		): Promise<ResourceProgress[]> {
+			const userProgress = await client.query.resourceProgress.findMany({
+				where: eq(resourceProgress.userId, userId),
+			})
+			const parsed = z.array(resourceProgressSchema).safeParse(userProgress)
+			if (!parsed.success) {
+				logger.error(parsed.error, {
+					event: 'adapter.userProgress.parse_failed',
+					userId,
+				})
+				return []
+			}
+			return parsed.data
+		},
+		async getModuleProgressForUser(
+			userIdOrEmail: string,
+			moduleIdOrSlug: string,
+		): Promise<ModuleProgress | null> {
+			// First, get the user ID
+			const user = await client.query.users.findFirst({
+				where: or(eq(users.id, userIdOrEmail), eq(users.email, userIdOrEmail)),
+				columns: {
+					id: true,
+				},
+			})
+
+			if (!user) {
+				return null
+			}
+
+			const ResultRowSchema = z.object({
+				resource_id: z.string(),
+				resource_type: z.enum(['lesson', 'exercise', 'post']),
+				resource_slug: z.string().nullable(),
+				completed_at: z
+					.string()
+					.nullable()
+					.transform((val) => (val ? new Date(val) : null)),
+			})
+
+			// Execute the optimized query - create a flattened, properly ordered list
+			const results: any = await client.execute(sql`
+				WITH RECURSIVE workshop AS (
+					SELECT id, fields->>'$.slug' AS slug
+					FROM ${contentResource}
+					WHERE id = ${moduleIdOrSlug} OR fields->>'$.slug' = ${moduleIdOrSlug}
+				),
+				-- Get all workshop resources with their positions
+				workshop_structure AS (
+					SELECT
+						w.id AS workshop_id,
+						crr.resourceId,
+						crr.position AS position,
+						cr.type AS resource_type,
+						cr.fields->>'$.slug' AS resource_slug,
+						cr.id AS resource_content_id
+					FROM workshop w
+					JOIN ${contentResourceResource} crr ON w.id = crr.resourceOfId
+					JOIN ${contentResource} cr ON crr.resourceId = cr.id
+					ORDER BY crr.position
+				),
+				-- Recursively expand sections and maintain global ordering
+				expanded_resources AS (
+					-- Base case: direct lessons/posts from workshop
+					SELECT
+						workshop_id,
+						position * 1000 AS global_order, -- Multiply by 1000 to leave room for section items
+						resource_content_id AS resource_id,
+						resource_type,
+						resource_slug
+					FROM workshop_structure
+					WHERE resource_type IN ('lesson', 'post')
+					UNION ALL
+					-- Recursive case: lessons within sections
+					SELECT
+						ws.workshop_id,
+						ws.position * 1000 + crr.position AS global_order, -- Section position * 1000 + lesson position
+						cr.id AS resource_id,
+						cr.type AS resource_type,
+						cr.fields->>'$.slug' AS resource_slug
+					FROM workshop_structure ws
+					JOIN ${contentResourceResource} crr ON ws.resource_content_id = crr.resourceOfId
+					JOIN ${contentResource} cr ON crr.resourceId = cr.id
+					WHERE ws.resource_type = 'section'
+					AND cr.type IN ('lesson', 'post')
+				)
+				SELECT
+					er.resource_id,
+					er.resource_type,
+					er.resource_slug,
+					rp.completedAt AS completed_at,
+					er.global_order
+				FROM expanded_resources er
+				LEFT JOIN ${resourceProgress} rp ON rp.resourceId = er.resource_id
+					AND rp.userId = ${user.id}
+				ORDER BY er.global_order ASC
+			`)
+			const rows = Array.isArray(results) ? results[0] : results.rows
+			const completedLessons: ResourceProgress[] = []
+			let nextResource: Partial<ContentResource> | null = null
+			let completedLessonsCount = 0
+			let totalLessonsCount = rows.length
+
+			const parsedRows = z.array(ResultRowSchema).safeParse(rows)
+
+			if (!parsedRows.success) {
+				logger.error(parsedRows.error, {
+					event: 'adapter.moduleProgress.rows.parse_failed',
+					moduleIdOrSlug,
+					userId: user.id,
+				})
+				return {
+					completedLessons: [],
+					nextResource: null,
+					percentCompleted: 0,
+					completedLessonsCount: 0,
+					totalLessonsCount,
+				}
+			}
+
+			for (const row of parsedRows.data) {
+				if (row.completed_at) {
+					completedLessonsCount++
+					completedLessons.push({
+						userId: user.id as string,
+						resourceId: row.resource_id,
+						completedAt: new Date(row.completed_at),
+						// Add other fields as needed
+					})
+				} else if (!nextResource) {
+					nextResource = {
+						id: row.resource_id,
+						type: row.resource_type,
+						fields: {
+							slug: row.resource_slug,
+						},
+					}
+				}
+			}
+
+			const percentCompleted =
+				totalLessonsCount > 0
+					? Math.ceil((completedLessonsCount / totalLessonsCount) * 100)
+					: 0
+
+			return {
+				completedLessons,
+				nextResource,
+				percentCompleted,
+				completedLessonsCount,
+				totalLessonsCount,
+			}
+		},
+		async getLessonProgresses(): Promise<ResourceProgress[]> {
+			const progresses = await client.query.resourceProgress.findMany()
+			const parsed = z.array(resourceProgressSchema).safeParse(progresses)
+			if (!parsed.success) {
+				logger.error(parsed.error, {
+					event: 'adapter.lessonProgresses.parse_failed',
+				})
+				return []
+			}
+			return parsed.data
+		},
+		async toggleLessonProgressForUser(options: {
+			userId: string
+			lessonId?: string
+		}): Promise<ResourceProgress | null> {
+			if (!options.lessonId) {
+				throw new Error('No lessonId provided')
+			}
+
+			let lessonProgress = await client.query.resourceProgress.findFirst({
+				where: and(
+					eq(resourceProgress.userId, options.userId),
+					eq(resourceProgress.resourceId, options.lessonId),
+				),
+			})
+
+			const now = new Date()
+
+			if (lessonProgress) {
+				await client
+					.update(resourceProgress)
+					.set({
+						completedAt: lessonProgress.completedAt ? null : now,
+						updatedAt: now,
+					})
+					.where(
+						and(
+							eq(resourceProgress.userId, options.userId),
+							eq(resourceProgress.resourceId, options.lessonId),
+						),
+					)
+			} else {
+				await client.insert(resourceProgress).values({
+					userId: options.userId,
+					resourceId: options.lessonId,
+					completedAt: now,
+					updatedAt: now,
+				})
+			}
+
+			lessonProgress = await client.query.resourceProgress.findFirst({
+				where: and(
+					eq(resourceProgress.userId, options.userId),
+					eq(resourceProgress.resourceId, options.lessonId),
+				),
+			})
+
+			const parsedLessonProgress =
+				resourceProgressSchema.safeParse(lessonProgress)
+
+			if (!parsedLessonProgress.success) {
+				logger.error(parsedLessonProgress.error, {
+					event: 'adapter.lessonProgress.parse_failed',
+					lessonId: options.lessonId,
+					userId: options.userId,
+				})
+				return null
+			}
+
+			return parsedLessonProgress.data
+		},
+	}
+}