@commonpub/server 0.1.0

package/dist/learning/learning.js

@@ -0,0 +1,681 @@
+import { eq, and, desc, sql, asc, inArray } from 'drizzle-orm';
+import { learningPaths, learningModules, learningLessons, enrollments, lessonProgress, certificates, users, contentItems, } from '@commonpub/schema';
+import { calculatePathProgress, isPathComplete } from '@commonpub/learning';
+import { generateVerificationCode } from '@commonpub/learning';
+import { generateSlug } from '../utils.js';
+import { ensureUniqueSlugFor, USER_REF_SELECT, normalizePagination, countRows } from '../query.js';
+// --- Path CRUD ---
+export async function listPaths(db, filters = {}) {
+    const conditions = [];
+    if (filters.status) {
+        conditions.push(eq(learningPaths.status, filters.status));
+    }
+    if (filters.difficulty) {
+        conditions.push(eq(learningPaths.difficulty, filters.difficulty));
+    }
+    if (filters.authorId) {
+        conditions.push(eq(learningPaths.authorId, filters.authorId));
+    }
+    const where = conditions.length > 0 ? and(...conditions) : undefined;
+    const { limit, offset } = normalizePagination(filters);
+    const moduleCountSubquery = db
+        .select({
+        pathId: learningModules.pathId,
+        moduleCount: sql `count(*)::int`.as('module_count'),
+    })
+        .from(learningModules)
+        .groupBy(learningModules.pathId)
+        .as('mc');
+    const [rows, total] = await Promise.all([
+        db
+            .select({
+            path: learningPaths,
+            author: {
+                id: users.id,
+                username: users.username,
+                displayName: users.displayName,
+                avatarUrl: users.avatarUrl,
+            },
+            moduleCount: sql `coalesce(${moduleCountSubquery.moduleCount}, 0)`.mapWith(Number),
+        })
+            .from(learningPaths)
+            .innerJoin(users, eq(learningPaths.authorId, users.id))
+            .leftJoin(moduleCountSubquery, eq(learningPaths.id, moduleCountSubquery.pathId))
+            .where(where)
+            .orderBy(desc(learningPaths.createdAt))
+            .limit(limit)
+            .offset(offset),
+        countRows(db, learningPaths, where),
+    ]);
+    const items = rows.map((row) => ({
+        id: row.path.id,
+        title: row.path.title,
+        slug: row.path.slug,
+        description: row.path.description,
+        coverImageUrl: row.path.coverImageUrl,
+        difficulty: row.path.difficulty,
+        estimatedHours: row.path.estimatedHours,
+        enrollmentCount: row.path.enrollmentCount,
+        completionCount: row.path.completionCount,
+        averageRating: row.path.averageRating,
+        moduleCount: row.moduleCount,
+        status: row.path.status,
+        createdAt: row.path.createdAt,
+        author: row.author,
+    }));
+    return { items, total };
+}
+export async function getPathBySlug(db, slug, requesterId) {
+    const rows = await db
+        .select({
+        path: learningPaths,
+        author: USER_REF_SELECT,
+    })
+        .from(learningPaths)
+        .innerJoin(users, eq(learningPaths.authorId, users.id))
+        .where(eq(learningPaths.slug, slug))
+        .limit(1);
+    if (rows.length === 0)
+        return null;
+    const row = rows[0];
+    const path = row.path;
+    if (path.status !== 'published' && path.authorId !== requesterId) {
+        return null;
+    }
+    const modules = await db
+        .select()
+        .from(learningModules)
+        .where(eq(learningModules.pathId, path.id))
+        .orderBy(asc(learningModules.sortOrder));
+    const moduleIds = modules.map((m) => m.id);
+    let lessons = [];
+    if (moduleIds.length > 0) {
+        lessons = await db
+            .select()
+            .from(learningLessons)
+            .where(inArray(learningLessons.moduleId, moduleIds))
+            .orderBy(asc(learningLessons.sortOrder));
+    }
+    let enrollment = null;
+    let isEnrolled = false;
+    if (requesterId) {
+        const enrollmentRows = await db
+            .select()
+            .from(enrollments)
+            .where(and(eq(enrollments.userId, requesterId), eq(enrollments.pathId, path.id)))
+            .limit(1);
+        if (enrollmentRows.length > 0) {
+            const e = enrollmentRows[0];
+            enrollment = {
+                id: e.id,
+                progress: e.progress,
+                startedAt: e.startedAt,
+                completedAt: e.completedAt,
+            };
+            isEnrolled = true;
+        }
+    }
+    const modulesWithLessons = modules.map((mod) => ({
+        id: mod.id,
+        title: mod.title,
+        description: mod.description,
+        sortOrder: mod.sortOrder,
+        lessons: lessons
+            .filter((l) => l.moduleId === mod.id)
+            .map((l) => ({
+            id: l.id,
+            title: l.title,
+            slug: l.slug,
+            type: l.type,
+            duration: l.duration,
+            sortOrder: l.sortOrder,
+            contentItemId: l.contentItemId ?? null,
+        })),
+    }));
+    return {
+        id: path.id,
+        title: path.title,
+        slug: path.slug,
+        description: path.description,
+        coverImageUrl: path.coverImageUrl,
+        difficulty: path.difficulty,
+        estimatedHours: path.estimatedHours,
+        enrollmentCount: path.enrollmentCount,
+        completionCount: path.completionCount,
+        averageRating: path.averageRating,
+        moduleCount: modulesWithLessons.length,
+        reviewCount: path.reviewCount,
+        status: path.status,
+        createdAt: path.createdAt,
+        updatedAt: path.updatedAt,
+        author: row.author,
+        modules: modulesWithLessons,
+        isEnrolled,
+        enrollment,
+    };
+}
+export async function createPath(db, authorId, input) {
+    const slug = await ensureUniqueSlugFor(db, learningPaths, learningPaths.slug, learningPaths.id, generateSlug(input.title), 'untitled');
+    const [path] = await db
+        .insert(learningPaths)
+        .values({
+        authorId,
+        title: input.title,
+        slug,
+        description: input.description ?? null,
+        difficulty: input.difficulty ?? null,
+        estimatedHours: input.estimatedHours?.toString() ?? null,
+        status: 'draft',
+    })
+        .returning();
+    return (await getPathBySlug(db, path.slug, authorId));
+}
+export async function updatePath(db, pathId, authorId, input) {
+    const existing = await db
+        .select()
+        .from(learningPaths)
+        .where(and(eq(learningPaths.id, pathId), eq(learningPaths.authorId, authorId)))
+        .limit(1);
+    if (existing.length === 0)
+        return null;
+    const current = existing[0];
+    const updates = { updatedAt: new Date() };
+    if (input.title !== undefined) {
+        updates.title = input.title;
+        if (input.title !== current.title) {
+            updates.slug = await ensureUniqueSlugFor(db, learningPaths, learningPaths.slug, learningPaths.id, generateSlug(input.title), 'untitled', pathId);
+        }
+    }
+    if (input.description !== undefined)
+        updates.description = input.description;
+    if (input.difficulty !== undefined)
+        updates.difficulty = input.difficulty;
+    if (input.estimatedHours !== undefined)
+        updates.estimatedHours = input.estimatedHours.toString();
+    if (input.coverImageUrl !== undefined)
+        updates.coverImageUrl = input.coverImageUrl;
+    await db.update(learningPaths).set(updates).where(eq(learningPaths.id, pathId));
+    const slug = updates.slug ?? current.slug;
+    return (await getPathBySlug(db, slug, authorId));
+}
+export async function deletePath(db, pathId, authorId) {
+    const result = await db
+        .update(learningPaths)
+        .set({ status: 'archived', updatedAt: new Date() })
+        .where(and(eq(learningPaths.id, pathId), eq(learningPaths.authorId, authorId)));
+    return (result.rowCount ?? 0) > 0;
+}
+export async function publishPath(db, pathId, authorId) {
+    const existing = await db
+        .select()
+        .from(learningPaths)
+        .where(and(eq(learningPaths.id, pathId), eq(learningPaths.authorId, authorId)))
+        .limit(1);
+    if (existing.length === 0)
+        return null;
+    await db
+        .update(learningPaths)
+        .set({ status: 'published', updatedAt: new Date() })
+        .where(eq(learningPaths.id, pathId));
+    return (await getPathBySlug(db, existing[0].slug, authorId));
+}
+// --- Module CRUD ---
+export async function createModule(db, authorId, input) {
+    const path = await db
+        .select()
+        .from(learningPaths)
+        .where(and(eq(learningPaths.id, input.pathId), eq(learningPaths.authorId, authorId)))
+        .limit(1);
+    if (path.length === 0)
+        throw new Error('Not authorized');
+    let sortOrder = input.sortOrder;
+    if (sortOrder === undefined) {
+        const maxSort = await db
+            .select({ max: sql `coalesce(max(${learningModules.sortOrder}), -1)` })
+            .from(learningModules)
+            .where(eq(learningModules.pathId, input.pathId));
+        sortOrder = (maxSort[0]?.max ?? -1) + 1;
+    }
+    const [mod] = await db
+        .insert(learningModules)
+        .values({
+        pathId: input.pathId,
+        title: input.title,
+        description: input.description ?? null,
+        sortOrder,
+    })
+        .returning();
+    return mod;
+}
+export async function updateModule(db, moduleId, authorId, input) {
+    const mod = await db
+        .select({ module: learningModules, path: learningPaths })
+        .from(learningModules)
+        .innerJoin(learningPaths, eq(learningModules.pathId, learningPaths.id))
+        .where(and(eq(learningModules.id, moduleId), eq(learningPaths.authorId, authorId)))
+        .limit(1);
+    if (mod.length === 0)
+        return null;
+    const updates = {};
+    if (input.title !== undefined)
+        updates.title = input.title;
+    if (input.description !== undefined)
+        updates.description = input.description;
+    if (Object.keys(updates).length === 0)
+        return mod[0].module;
+    const [updated] = await db
+        .update(learningModules)
+        .set(updates)
+        .where(eq(learningModules.id, moduleId))
+        .returning();
+    return updated;
+}
+export async function deleteModule(db, moduleId, authorId) {
+    const mod = await db
+        .select({ module: learningModules, path: learningPaths })
+        .from(learningModules)
+        .innerJoin(learningPaths, eq(learningModules.pathId, learningPaths.id))
+        .where(and(eq(learningModules.id, moduleId), eq(learningPaths.authorId, authorId)))
+        .limit(1);
+    if (mod.length === 0)
+        return false;
+    await db.delete(learningModules).where(eq(learningModules.id, moduleId));
+    return true;
+}
+export async function reorderModules(db, pathId, authorId, moduleIds) {
+    const path = await db
+        .select()
+        .from(learningPaths)
+        .where(and(eq(learningPaths.id, pathId), eq(learningPaths.authorId, authorId)))
+        .limit(1);
+    if (path.length === 0)
+        return false;
+    await db.transaction(async (tx) => {
+        for (let i = 0; i < moduleIds.length; i++) {
+            await tx
+                .update(learningModules)
+                .set({ sortOrder: i })
+                .where(and(eq(learningModules.id, moduleIds[i]), eq(learningModules.pathId, pathId)));
+        }
+    });
+    return true;
+}
+// --- Lesson CRUD ---
+export async function createLesson(db, authorId, input) {
+    const mod = await db
+        .select({ module: learningModules, path: learningPaths })
+        .from(learningModules)
+        .innerJoin(learningPaths, eq(learningModules.pathId, learningPaths.id))
+        .where(and(eq(learningModules.id, input.moduleId), eq(learningPaths.authorId, authorId)))
+        .limit(1);
+    if (mod.length === 0)
+        throw new Error('Not authorized');
+    // If linking to existing content, validate it
+    let resolvedType = input.type;
+    if (input.contentItemId) {
+        const item = await db
+            .select({ id: contentItems.id, type: contentItems.type, authorId: contentItems.authorId })
+            .from(contentItems)
+            .where(eq(contentItems.id, input.contentItemId))
+            .limit(1);
+        if (item.length === 0)
+            throw new Error('Content item not found');
+        if (item[0].authorId !== authorId)
+            throw new Error('You can only link your own content');
+        resolvedType = item[0].type;
+    }
+    const slug = generateSlug(input.title) || `lesson-${Date.now()}`;
+    const maxSort = await db
+        .select({ max: sql `coalesce(max(${learningLessons.sortOrder}), -1)` })
+        .from(learningLessons)
+        .where(eq(learningLessons.moduleId, input.moduleId));
+    const [lesson] = await db
+        .insert(learningLessons)
+        .values({
+        moduleId: input.moduleId,
+        title: input.title,
+        slug,
+        type: resolvedType,
+        content: input.contentItemId ? null : (input.content ?? null),
+        contentItemId: input.contentItemId ?? null,
+        duration: input.durationMinutes ?? null,
+        sortOrder: (maxSort[0]?.max ?? -1) + 1,
+    })
+        .returning();
+    return lesson;
+}
+export async function updateLesson(db, lessonId, authorId, input) {
+    const lesson = await db
+        .select({ lesson: learningLessons, module: learningModules, path: learningPaths })
+        .from(learningLessons)
+        .innerJoin(learningModules, eq(learningLessons.moduleId, learningModules.id))
+        .innerJoin(learningPaths, eq(learningModules.pathId, learningPaths.id))
+        .where(and(eq(learningLessons.id, lessonId), eq(learningPaths.authorId, authorId)))
+        .limit(1);
+    if (lesson.length === 0)
+        return null;
+    const updates = { updatedAt: new Date() };
+    if (input.title !== undefined) {
+        updates.title = input.title;
+        updates.slug = generateSlug(input.title) || lesson[0].lesson.slug;
+    }
+    if (input.type !== undefined)
+        updates.type = input.type;
+    if (input.content !== undefined)
+        updates.content = input.content;
+    if (input.contentItemId !== undefined) {
+        updates.contentItemId = input.contentItemId;
+        if (input.contentItemId === null) {
+            // Unlinking — clear the reference
+        }
+        else {
+            // Linking — validate content item belongs to author
+            const item = await db
+                .select({ id: contentItems.id, type: contentItems.type, authorId: contentItems.authorId })
+                .from(contentItems)
+                .where(eq(contentItems.id, input.contentItemId))
+                .limit(1);
+            if (item.length === 0)
+                throw new Error('Content item not found');
+            if (item[0].authorId !== authorId)
+                throw new Error('You can only link your own content');
+            updates.type = item[0].type;
+            updates.content = null;
+        }
+    }
+    if (input.durationMinutes !== undefined)
+        updates.duration = input.durationMinutes;
+    const [updated] = await db
+        .update(learningLessons)
+        .set(updates)
+        .where(eq(learningLessons.id, lessonId))
+        .returning();
+    return updated;
+}
+export async function deleteLesson(db, lessonId, authorId) {
+    const lesson = await db
+        .select({ lesson: learningLessons, module: learningModules, path: learningPaths })
+        .from(learningLessons)
+        .innerJoin(learningModules, eq(learningLessons.moduleId, learningModules.id))
+        .innerJoin(learningPaths, eq(learningModules.pathId, learningPaths.id))
+        .where(and(eq(learningLessons.id, lessonId), eq(learningPaths.authorId, authorId)))
+        .limit(1);
+    if (lesson.length === 0)
+        return false;
+    await db.delete(learningLessons).where(eq(learningLessons.id, lessonId));
+    return true;
+}
+export async function reorderLessons(db, moduleId, authorId, lessonIds) {
+    const mod = await db
+        .select({ module: learningModules, path: learningPaths })
+        .from(learningModules)
+        .innerJoin(learningPaths, eq(learningModules.pathId, learningPaths.id))
+        .where(and(eq(learningModules.id, moduleId), eq(learningPaths.authorId, authorId)))
+        .limit(1);
+    if (mod.length === 0)
+        return false;
+    await db.transaction(async (tx) => {
+        for (let i = 0; i < lessonIds.length; i++) {
+            await tx
+                .update(learningLessons)
+                .set({ sortOrder: i })
+                .where(and(eq(learningLessons.id, lessonIds[i]), eq(learningLessons.moduleId, moduleId)));
+        }
+    });
+    return true;
+}
+// --- Enrollment ---
+export async function enroll(db, userId, pathId) {
+    const existing = await db
+        .select()
+        .from(enrollments)
+        .where(and(eq(enrollments.userId, userId), eq(enrollments.pathId, pathId)))
+        .limit(1);
+    if (existing.length > 0)
+        return existing[0];
+    const path = await db
+        .select()
+        .from(learningPaths)
+        .where(and(eq(learningPaths.id, pathId), eq(learningPaths.status, 'published')))
+        .limit(1);
+    if (path.length === 0)
+        throw new Error('Path not found or not published');
+    const [enrollment] = await db.insert(enrollments).values({ userId, pathId }).returning();
+    await db
+        .update(learningPaths)
+        .set({ enrollmentCount: sql `${learningPaths.enrollmentCount} + 1` })
+        .where(eq(learningPaths.id, pathId));
+    return enrollment;
+}
+export async function unenroll(db, userId, pathId) {
+    const existing = await db
+        .select()
+        .from(enrollments)
+        .where(and(eq(enrollments.userId, userId), eq(enrollments.pathId, pathId)))
+        .limit(1);
+    if (existing.length === 0)
+        return false;
+    await db
+        .delete(enrollments)
+        .where(and(eq(enrollments.userId, userId), eq(enrollments.pathId, pathId)));
+    await db
+        .update(learningPaths)
+        .set({ enrollmentCount: sql `GREATEST(${learningPaths.enrollmentCount} - 1, 0)` })
+        .where(eq(learningPaths.id, pathId));
+    return true;
+}
+// --- Progress ---
+export async function markLessonComplete(db, userId, lessonId, quizScore, quizPassed) {
+    const lessonRow = await db
+        .select({ lesson: learningLessons, module: learningModules })
+        .from(learningLessons)
+        .innerJoin(learningModules, eq(learningLessons.moduleId, learningModules.id))
+        .where(eq(learningLessons.id, lessonId))
+        .limit(1);
+    if (lessonRow.length === 0)
+        throw new Error('Lesson not found');
+    const pathId = lessonRow[0].module.pathId;
+    return db.transaction(async (tx) => {
+        const enrollmentRow = await tx
+            .select()
+            .from(enrollments)
+            .where(and(eq(enrollments.userId, userId), eq(enrollments.pathId, pathId)))
+            .for('update')
+            .limit(1);
+        if (enrollmentRow.length === 0)
+            throw new Error('Not enrolled');
+        const existingProgress = await tx
+            .select()
+            .from(lessonProgress)
+            .where(and(eq(lessonProgress.userId, userId), eq(lessonProgress.lessonId, lessonId)))
+            .limit(1);
+        if (existingProgress.length === 0) {
+            await tx.insert(lessonProgress).values({
+                userId,
+                lessonId,
+                completed: true,
+                completedAt: new Date(),
+                quizScore: quizScore?.toString() ?? null,
+                quizPassed: quizPassed ?? null,
+            });
+        }
+        else {
+            await tx
+                .update(lessonProgress)
+                .set({
+                completed: true,
+                completedAt: new Date(),
+                quizScore: quizScore?.toString() ?? existingProgress[0].quizScore,
+                quizPassed: quizPassed ?? existingProgress[0].quizPassed,
+            })
+                .where(and(eq(lessonProgress.userId, userId), eq(lessonProgress.lessonId, lessonId)));
+        }
+        const totalLessons = await tx
+            .select({ count: sql `count(*)::int` })
+            .from(learningLessons)
+            .innerJoin(learningModules, eq(learningLessons.moduleId, learningModules.id))
+            .where(eq(learningModules.pathId, pathId));
+        const completedLessons = await tx
+            .select({ count: sql `count(*)::int` })
+            .from(lessonProgress)
+            .innerJoin(learningLessons, eq(lessonProgress.lessonId, learningLessons.id))
+            .innerJoin(learningModules, eq(learningLessons.moduleId, learningModules.id))
+            .where(and(eq(lessonProgress.userId, userId), eq(lessonProgress.completed, true), eq(learningModules.pathId, pathId)));
+        const total = totalLessons[0]?.count ?? 0;
+        const completed = completedLessons[0]?.count ?? 0;
+        const progress = calculatePathProgress(total, completed);
+        const enrollmentUpdates = { progress: progress.toString() };
+        if (isPathComplete(progress)) {
+            enrollmentUpdates.completedAt = new Date();
+        }
+        await tx
+            .update(enrollments)
+            .set(enrollmentUpdates)
+            .where(eq(enrollments.id, enrollmentRow[0].id));
+        let certificateIssued = false;
+        if (isPathComplete(progress)) {
+            const existingCert = await tx
+                .select()
+                .from(certificates)
+                .where(and(eq(certificates.userId, userId), eq(certificates.pathId, pathId)))
+                .limit(1);
+            if (existingCert.length === 0) {
+                await tx.insert(certificates).values({
+                    userId,
+                    pathId,
+                    verificationCode: generateVerificationCode(),
+                });
+                certificateIssued = true;
+                await tx
+                    .update(learningPaths)
+                    .set({ completionCount: sql `${learningPaths.completionCount} + 1` })
+                    .where(eq(learningPaths.id, pathId));
+            }
+        }
+        return { progress, certificateIssued };
+    });
+}
+// --- Queries ---
+export async function getEnrollment(db, userId, pathId) {
+    const rows = await db
+        .select()
+        .from(enrollments)
+        .where(and(eq(enrollments.userId, userId), eq(enrollments.pathId, pathId)))
+        .limit(1);
+    return rows[0] ?? null;
+}
+export async function getUserEnrollments(db, userId) {
+    const rows = await db
+        .select({
+        enrollment: enrollments,
+        path: {
+            id: learningPaths.id,
+            title: learningPaths.title,
+            slug: learningPaths.slug,
+            coverImageUrl: learningPaths.coverImageUrl,
+            difficulty: learningPaths.difficulty,
+        },
+    })
+        .from(enrollments)
+        .innerJoin(learningPaths, eq(enrollments.pathId, learningPaths.id))
+        .where(eq(enrollments.userId, userId))
+        .orderBy(desc(enrollments.startedAt));
+    return rows.map((row) => ({
+        id: row.enrollment.id,
+        progress: row.enrollment.progress,
+        startedAt: row.enrollment.startedAt,
+        completedAt: row.enrollment.completedAt,
+        path: row.path,
+    }));
+}
+export async function getUserCertificates(db, userId) {
+    const rows = await db
+        .select({
+        certificate: certificates,
+        path: {
+            id: learningPaths.id,
+            title: learningPaths.title,
+            slug: learningPaths.slug,
+        },
+    })
+        .from(certificates)
+        .innerJoin(learningPaths, eq(certificates.pathId, learningPaths.id))
+        .where(eq(certificates.userId, userId))
+        .orderBy(desc(certificates.issuedAt));
+    return rows.map((row) => ({
+        id: row.certificate.id,
+        verificationCode: row.certificate.verificationCode,
+        issuedAt: row.certificate.issuedAt,
+        path: row.path,
+    }));
+}
+export async function getCertificateByCode(db, code) {
+    const rows = await db
+        .select({
+        certificate: certificates,
+        path: {
+            title: learningPaths.title,
+            slug: learningPaths.slug,
+        },
+        user: {
+            displayName: users.displayName,
+            username: users.username,
+        },
+    })
+        .from(certificates)
+        .innerJoin(learningPaths, eq(certificates.pathId, learningPaths.id))
+        .innerJoin(users, eq(certificates.userId, users.id))
+        .where(eq(certificates.verificationCode, code))
+        .limit(1);
+    return rows[0] ?? null;
+}
+export async function getLessonBySlug(db, pathSlug, lessonSlug) {
+    const path = await db
+        .select()
+        .from(learningPaths)
+        .where(eq(learningPaths.slug, pathSlug))
+        .limit(1);
+    if (path.length === 0)
+        return null;
+    const rows = await db
+        .select({ lesson: learningLessons, module: learningModules })
+        .from(learningLessons)
+        .innerJoin(learningModules, eq(learningLessons.moduleId, learningModules.id))
+        .where(and(eq(learningLessons.slug, lessonSlug), eq(learningModules.pathId, path[0].id)))
+        .limit(1);
+    if (rows.length === 0)
+        return null;
+    const result = {
+        lesson: rows[0].lesson,
+        module: rows[0].module,
+        pathId: path[0].id,
+    };
+    // Resolve linked content item if present
+    if (rows[0].lesson.contentItemId) {
+        const items = await db
+            .select({
+            id: contentItems.id,
+            title: contentItems.title,
+            slug: contentItems.slug,
+            type: contentItems.type,
+            content: contentItems.content,
+        })
+            .from(contentItems)
+            .where(eq(contentItems.id, rows[0].lesson.contentItemId))
+            .limit(1);
+        if (items.length > 0) {
+            result.linkedContent = items[0];
+        }
+    }
+    return result;
+}
+export async function getCompletedLessonIds(db, userId, pathId) {
+    const rows = await db
+        .select({ lessonId: lessonProgress.lessonId })
+        .from(lessonProgress)
+        .innerJoin(learningLessons, eq(lessonProgress.lessonId, learningLessons.id))
+        .innerJoin(learningModules, eq(learningLessons.moduleId, learningModules.id))
+        .where(and(eq(lessonProgress.userId, userId), eq(lessonProgress.completed, true), eq(learningModules.pathId, pathId)));
+    return new Set(rows.map((r) => r.lessonId));
+}
+//# sourceMappingURL=learning.js.map