@studious-lms/server 1.23.0 → 1.25.0

package/dist/services/marketplace.js

@@ -0,0 +1,631 @@
+/**
+ * Marketplace service — publish / search / import for shareable markschemes,
+ * worksheets, and files. Exercise/poll types are out of scope for B1 v1.
+ */
+
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="b0ba201b-83d8-5de3-a820-a6105cef2863")}catch(e){}}();
+import { TRPCError } from "@trpc/server";
+import { v4 as uuidv4 } from "uuid";
+import { prisma } from "../lib/prisma.js";
+import { copyFile } from "../lib/googleCloudStorage.js";
+import { classTeacherOrSchoolAdminWhere } from "../models/access.js";
+import { findOrCreateScopeRoot } from "../models/cloudStorage.js";
+import { createMarketplaceListing, deleteMarketplaceListing, findMarketplaceListingById, incrementMarketplaceReportCount, searchMarketplaceListings, setMarketplaceListingHidden, } from "../models/marketplace.js";
+import { findActiveSchoolAdminMembership, findSchoolMembership, listUserSchoolMemberships, } from "../models/school.js";
+import { duplicateWorksheetWithClient } from "../models/worksheet.js";
+function normalizeTags(tags) {
+    if (!tags?.length)
+        return [];
+    const seen = new Set();
+    const out = [];
+    for (const raw of tags) {
+        const tag = raw.trim().replace(/\s+/g, " ").slice(0, 40);
+        if (!tag)
+            continue;
+        const key = tag.toLowerCase();
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        out.push(tag);
+        if (out.length >= 12)
+            break;
+    }
+    return out;
+}
+async function requireActiveSchoolMember(schoolId, userId) {
+    const membership = await findSchoolMembership(schoolId, userId);
+    if (!membership || membership.status !== "ACTIVE") {
+        throw new TRPCError({
+            code: "FORBIDDEN",
+            message: "You are not a member of this school",
+        });
+    }
+    return membership;
+}
+async function assertCanTeachClass(classId, userId) {
+    const cls = await prisma.class.findFirst({
+        where: { id: classId, ...classTeacherOrSchoolAdminWhere(userId) },
+        select: { id: true, schoolId: true, departmentId: true },
+    });
+    if (!cls) {
+        throw new TRPCError({
+            code: "FORBIDDEN",
+            message: "You don't have permission to use this class",
+        });
+    }
+    return cls;
+}
+async function assertCanAccessListing(listing, userId) {
+    if (listing.authorId === userId)
+        return;
+    if (listing.isHidden) {
+        throw new TRPCError({ code: "NOT_FOUND", message: "Listing not found" });
+    }
+    if (listing.visibility === "PUBLIC")
+        return;
+    if (!listing.schoolId) {
+        throw new TRPCError({ code: "FORBIDDEN", message: "Listing is not available" });
+    }
+    await requireActiveSchoolMember(listing.schoolId, userId);
+}
+function asPayload(raw) {
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+        throw new TRPCError({
+            code: "INTERNAL_SERVER_ERROR",
+            message: "Listing payload is invalid",
+        });
+    }
+    const kind = raw.kind;
+    if (kind === "MARKSCHEME" || kind === "WORKSHEET" || kind === "FILE") {
+        return raw;
+    }
+    throw new TRPCError({
+        code: "INTERNAL_SERVER_ERROR",
+        message: "Listing payload is invalid",
+    });
+}
+export async function listMarketplace(userId, input) {
+    const memberships = await listUserSchoolMemberships(userId);
+    if (input.schoolId &&
+        !memberships.some((m) => m.schoolId === input.schoolId)) {
+        return { items: [], nextCursor: undefined };
+    }
+    const schoolIds = input.schoolId
+        ? [input.schoolId]
+        : memberships.map((m) => m.schoolId);
+    return searchMarketplaceListings({
+        schoolIds,
+        scopeSchoolId: input.schoolId,
+        type: input.type,
+        search: input.search,
+        tags: input.tags,
+        cursor: input.cursor,
+        limit: input.limit ?? 20,
+        authorId: userId,
+    });
+}
+export async function getMarketplaceListing(userId, listingId) {
+    const listing = await findMarketplaceListingById(listingId);
+    if (!listing) {
+        throw new TRPCError({ code: "NOT_FOUND", message: "Listing not found" });
+    }
+    await assertCanAccessListing(listing, userId);
+    return listing;
+}
+export async function publishMarkSchemeListing(userId, input) {
+    const markScheme = await prisma.markScheme.findUnique({
+        where: { id: input.markSchemeId },
+        select: {
+            id: true,
+            name: true,
+            structured: true,
+            classId: true,
+            departmentId: true,
+            class: { select: { schoolId: true } },
+            department: { select: { schoolId: true } },
+        },
+    });
+    if (!markScheme) {
+        throw new TRPCError({ code: "NOT_FOUND", message: "Mark scheme not found" });
+    }
+    let schoolId = input.schoolId ??
+        markScheme.class?.schoolId ??
+        markScheme.department?.schoolId ??
+        null;
+    if (markScheme.classId) {
+        await assertCanTeachClass(markScheme.classId, userId);
+    }
+    else if (markScheme.departmentId && schoolId) {
+        const admin = await findActiveSchoolAdminMembership(schoolId, userId);
+        if (!admin) {
+            throw new TRPCError({
+                code: "FORBIDDEN",
+                message: "Only school admins can publish department mark schemes",
+            });
+        }
+    }
+    else {
+        throw new TRPCError({
+            code: "BAD_REQUEST",
+            message: "Mark scheme is not scoped to a class or department",
+        });
+    }
+    if (input.visibility === "SCHOOL") {
+        if (!schoolId) {
+            throw new TRPCError({
+                code: "BAD_REQUEST",
+                message: "schoolId is required for SCHOOL visibility",
+            });
+        }
+        await requireActiveSchoolMember(schoolId, userId);
+    }
+    else if (schoolId) {
+        await requireActiveSchoolMember(schoolId, userId);
+    }
+    const payload = {
+        kind: "MARKSCHEME",
+        name: markScheme.name,
+        structured: markScheme.structured,
+    };
+    return createMarketplaceListing({
+        type: "MARKSCHEME",
+        title: input.title.trim(),
+        description: input.description?.trim() || null,
+        authorId: userId,
+        schoolId,
+        visibility: input.visibility,
+        markSchemeId: markScheme.id,
+        payload,
+        tags: normalizeTags(input.tags),
+    });
+}
+export async function publishWorksheetListing(userId, input) {
+    const worksheet = await prisma.worksheet.findFirst({
+        where: {
+            id: input.worksheetId,
+            class: classTeacherOrSchoolAdminWhere(userId),
+        },
+        include: {
+            questions: { orderBy: { order: "asc" } },
+            class: { select: { schoolId: true } },
+        },
+    });
+    if (!worksheet) {
+        throw new TRPCError({
+            code: "NOT_FOUND",
+            message: "Worksheet not found or you don't have permission to publish it",
+        });
+    }
+    const schoolId = input.schoolId ?? worksheet.class?.schoolId ?? null;
+    if (input.visibility === "SCHOOL") {
+        if (!schoolId) {
+            throw new TRPCError({
+                code: "BAD_REQUEST",
+                message: "schoolId is required for SCHOOL visibility",
+            });
+        }
+        await requireActiveSchoolMember(schoolId, userId);
+    }
+    else if (schoolId) {
+        await requireActiveSchoolMember(schoolId, userId);
+    }
+    const payload = {
+        kind: "WORKSHEET",
+        name: worksheet.name,
+        questions: worksheet.questions.map((q) => ({
+            type: q.type,
+            question: q.question,
+            answer: q.answer,
+            options: q.options ?? {},
+            markScheme: q.markScheme ?? {},
+            points: q.points,
+            order: q.order,
+        })),
+    };
+    return createMarketplaceListing({
+        type: "WORKSHEET",
+        title: input.title.trim(),
+        description: input.description?.trim() || null,
+        authorId: userId,
+        schoolId,
+        visibility: input.visibility,
+        worksheetId: worksheet.id,
+        payload,
+        tags: normalizeTags(input.tags),
+    });
+}
+export async function publishFileListing(userId, input) {
+    const file = await prisma.file.findUnique({
+        where: { id: input.fileId },
+        select: {
+            id: true,
+            name: true,
+            type: true,
+            size: true,
+            path: true,
+            userId: true,
+            folderId: true,
+            uploadStatus: true,
+            folder: {
+                select: {
+                    classId: true,
+                    schoolStorageId: true,
+                    personalOwnerId: true,
+                    class: { select: { schoolId: true } },
+                },
+            },
+        },
+    });
+    if (!file || file.uploadStatus === "FAILED" || file.uploadStatus === "CANCELLED") {
+        throw new TRPCError({ code: "NOT_FOUND", message: "File not found" });
+    }
+    const isOwner = file.userId === userId;
+    const isPersonal = file.folder?.personalOwnerId === userId;
+    let canPublish = isOwner || isPersonal;
+    let schoolId = input.schoolId ?? file.folder?.schoolStorageId ?? file.folder?.class?.schoolId ?? null;
+    if (!canPublish && file.folder?.classId) {
+        await assertCanTeachClass(file.folder.classId, userId);
+        canPublish = true;
+    }
+    if (!canPublish && file.folder?.schoolStorageId) {
+        const admin = await findActiveSchoolAdminMembership(file.folder.schoolStorageId, userId);
+        if (!admin) {
+            throw new TRPCError({
+                code: "FORBIDDEN",
+                message: "You don't have permission to publish this file",
+            });
+        }
+        canPublish = true;
+        schoolId = schoolId ?? file.folder.schoolStorageId;
+    }
+    if (!canPublish) {
+        throw new TRPCError({
+            code: "FORBIDDEN",
+            message: "You don't have permission to publish this file",
+        });
+    }
+    if (input.visibility === "SCHOOL") {
+        if (!schoolId) {
+            throw new TRPCError({
+                code: "BAD_REQUEST",
+                message: "schoolId is required for SCHOOL visibility",
+            });
+        }
+        await requireActiveSchoolMember(schoolId, userId);
+    }
+    else if (schoolId) {
+        await requireActiveSchoolMember(schoolId, userId);
+    }
+    const payload = {
+        kind: "FILE",
+        name: file.name,
+        type: file.type,
+        size: file.size,
+        path: file.path,
+    };
+    return createMarketplaceListing({
+        type: "FILE",
+        title: input.title.trim(),
+        description: input.description?.trim() || null,
+        authorId: userId,
+        schoolId,
+        visibility: input.visibility,
+        fileId: file.id,
+        payload,
+        tags: normalizeTags(input.tags),
+    });
+}
+/**
+ * Import a listing into the caller's workspace:
+ * - MARKSCHEME → class mark scheme (or department template when departmentId given)
+ * - WORKSHEET → class worksheet copy
+ * - FILE → personal / class / school folder copy (GCS object copied)
+ */
+export async function importMarketplaceListing(userId, input) {
+    const listing = await findMarketplaceListingById(input.listingId);
+    if (!listing) {
+        throw new TRPCError({ code: "NOT_FOUND", message: "Listing not found" });
+    }
+    await assertCanAccessListing(listing, userId);
+    const payload = asPayload(listing.payload);
+    const name = input.name?.trim();
+    if (listing.type === "MARKSCHEME") {
+        if (payload.kind !== "MARKSCHEME") {
+            throw new TRPCError({
+                code: "INTERNAL_SERVER_ERROR",
+                message: "Mark scheme payload mismatch",
+            });
+        }
+        if (input.departmentId) {
+            const department = await prisma.department.findUnique({
+                where: { id: input.departmentId },
+                select: { id: true, schoolId: true },
+            });
+            if (!department) {
+                throw new TRPCError({ code: "NOT_FOUND", message: "Department not found" });
+            }
+            const admin = await findActiveSchoolAdminMembership(department.schoolId, userId);
+            if (!admin) {
+                throw new TRPCError({
+                    code: "FORBIDDEN",
+                    message: "Only school admins can import into a department",
+                });
+            }
+            return {
+                type: "MARKSCHEME",
+                markScheme: await prisma.markScheme.create({
+                    data: {
+                        department: { connect: { id: department.id } },
+                        name: name || payload.name || listing.title,
+                        structured: payload.structured,
+                    },
+                    select: { id: true, name: true, departmentId: true, classId: true },
+                }),
+            };
+        }
+        if (!input.classId) {
+            throw new TRPCError({
+                code: "BAD_REQUEST",
+                message: "classId is required to import a mark scheme",
+            });
+        }
+        await assertCanTeachClass(input.classId, userId);
+        return {
+            type: "MARKSCHEME",
+            markScheme: await prisma.markScheme.create({
+                data: {
+                    class: { connect: { id: input.classId } },
+                    name: name || payload.name || listing.title,
+                    structured: payload.structured,
+                },
+                select: { id: true, name: true, departmentId: true, classId: true },
+            }),
+        };
+    }
+    if (listing.type === "WORKSHEET") {
+        if (payload.kind !== "WORKSHEET") {
+            throw new TRPCError({
+                code: "INTERNAL_SERVER_ERROR",
+                message: "Worksheet payload mismatch",
+            });
+        }
+        if (!input.classId) {
+            throw new TRPCError({
+                code: "BAD_REQUEST",
+                message: "classId is required to import a worksheet",
+            });
+        }
+        await assertCanTeachClass(input.classId, userId);
+        // Prefer live source clone when still available; otherwise rebuild from snapshot.
+        if (listing.worksheetId) {
+            const created = await prisma.$transaction((tx) => duplicateWorksheetWithClient(tx, listing.worksheetId, input.classId, name || payload.name || listing.title));
+            if (created) {
+                return { type: "WORKSHEET", worksheet: created };
+            }
+        }
+        const created = await prisma.worksheet.create({
+            data: {
+                classId: input.classId,
+                name: name || payload.name || listing.title,
+                questions: {
+                    create: payload.questions.map((q) => ({
+                        type: q.type,
+                        question: q.question,
+                        answer: q.answer,
+                        options: q.options ?? {},
+                        markScheme: q.markScheme ?? {},
+                        points: q.points,
+                        order: q.order,
+                    })),
+                },
+            },
+            select: { id: true, name: true, classId: true },
+        });
+        return { type: "WORKSHEET", worksheet: created };
+    }
+    if (listing.type === "FILE") {
+        if (payload.kind !== "FILE") {
+            throw new TRPCError({
+                code: "INTERNAL_SERVER_ERROR",
+                message: "File payload mismatch",
+            });
+        }
+        let targetFolderId = input.folderId;
+        if (!targetFolderId) {
+            if (input.classId) {
+                await assertCanTeachClass(input.classId, userId);
+                const root = await findOrCreateScopeRoot({
+                    kind: "CLASS",
+                    classId: input.classId,
+                });
+                targetFolderId = root.id;
+            }
+            else {
+                const root = await findOrCreateScopeRoot({
+                    kind: "PERSONAL",
+                    userId,
+                });
+                targetFolderId = root.id;
+            }
+        }
+        else {
+            const folder = await prisma.folder.findUnique({
+                where: { id: targetFolderId },
+                select: {
+                    id: true,
+                    classId: true,
+                    schoolStorageId: true,
+                    personalOwnerId: true,
+                },
+            });
+            if (!folder) {
+                throw new TRPCError({ code: "NOT_FOUND", message: "Folder not found" });
+            }
+            if (folder.personalOwnerId && folder.personalOwnerId !== userId) {
+                throw new TRPCError({
+                    code: "FORBIDDEN",
+                    message: "You don't have permission to import into this folder",
+                });
+            }
+            if (folder.classId) {
+                await assertCanTeachClass(folder.classId, userId);
+            }
+            if (folder.schoolStorageId) {
+                const admin = await findActiveSchoolAdminMembership(folder.schoolStorageId, userId);
+                if (!admin) {
+                    throw new TRPCError({
+                        code: "FORBIDDEN",
+                        message: "Only school admins can import into school storage",
+                    });
+                }
+            }
+        }
+        const ext = payload.name.includes(".")
+            ? payload.name.slice(payload.name.lastIndexOf("."))
+            : "";
+        const newPath = `marketplace/${uuidv4()}${ext}`;
+        await copyFile(payload.path, newPath);
+        const created = await prisma.file.create({
+            data: {
+                name: name || payload.name || listing.title,
+                type: payload.type,
+                size: payload.size ?? undefined,
+                path: newPath,
+                userId,
+                folderId: targetFolderId,
+                uploadStatus: "COMPLETED",
+                uploadedAt: new Date(),
+            },
+            select: { id: true, name: true, folderId: true, path: true, type: true },
+        });
+        return { type: "FILE", file: created };
+    }
+    throw new TRPCError({
+        code: "BAD_REQUEST",
+        message: "Unsupported listing type",
+    });
+}
+export async function reportMarketplaceListing(userId, listingId) {
+    const listing = await findMarketplaceListingById(listingId);
+    if (!listing) {
+        throw new TRPCError({ code: "NOT_FOUND", message: "Listing not found" });
+    }
+    await assertCanAccessListing(listing, userId);
+    // C10 light stub — increment only; no reporter dedupe table yet.
+    return incrementMarketplaceReportCount(listingId);
+}
+export async function hideMarketplaceListing(userId, listingId, isHidden) {
+    const listing = await findMarketplaceListingById(listingId);
+    if (!listing) {
+        throw new TRPCError({ code: "NOT_FOUND", message: "Listing not found" });
+    }
+    const isAuthor = listing.authorId === userId;
+    const isSchoolAdmin = listing.schoolId != null &&
+        Boolean(await findActiveSchoolAdminMembership(listing.schoolId, userId));
+    if (!isAuthor && !isSchoolAdmin) {
+        throw new TRPCError({
+            code: "FORBIDDEN",
+            message: "Only the author or a school admin can hide this listing",
+        });
+    }
+    return setMarketplaceListingHidden(listingId, isHidden);
+}
+export async function unpublishMarketplaceListing(userId, listingId) {
+    const listing = await findMarketplaceListingById(listingId);
+    if (!listing) {
+        throw new TRPCError({ code: "NOT_FOUND", message: "Listing not found" });
+    }
+    if (listing.authorId !== userId) {
+        const isSchoolAdmin = listing.schoolId != null &&
+            Boolean(await findActiveSchoolAdminMembership(listing.schoolId, userId));
+        if (!isSchoolAdmin) {
+            throw new TRPCError({
+                code: "FORBIDDEN",
+                message: "Only the author or a school admin can unpublish this listing",
+            });
+        }
+        await setMarketplaceListingHidden(listingId, true);
+        return { success: true, deleted: false };
+    }
+    const result = await deleteMarketplaceListing(listingId, userId);
+    return { success: true, deleted: result.count > 0 };
+}
+/** Publishable sources for the current user (for the publish dialog). */
+export async function listPublishableSources(userId, input) {
+    const classFilter = input.classId
+        ? { id: input.classId, ...classTeacherOrSchoolAdminWhere(userId) }
+        : classTeacherOrSchoolAdminWhere(userId);
+    const [markSchemes, worksheets, files] = await Promise.all([
+        prisma.markScheme.findMany({
+            where: {
+                OR: [
+                    { class: classFilter },
+                    ...(input.schoolId
+                        ? [
+                            {
+                                department: {
+                                    schoolId: input.schoolId,
+                                    school: {
+                                        memberships: {
+                                            some: {
+                                                userId,
+                                                role: "ADMIN",
+                                                status: "ACTIVE",
+                                            },
+                                        },
+                                    },
+                                },
+                            },
+                        ]
+                        : []),
+                ],
+            },
+            select: {
+                id: true,
+                name: true,
+                classId: true,
+                departmentId: true,
+                class: { select: { name: true } },
+                department: { select: { name: true } },
+            },
+            take: 50,
+            orderBy: { id: "desc" },
+        }),
+        prisma.worksheet.findMany({
+            where: { class: classFilter },
+            select: {
+                id: true,
+                name: true,
+                classId: true,
+                class: { select: { name: true } },
+                _count: { select: { questions: true } },
+            },
+            take: 50,
+            orderBy: { updatedAt: "desc" },
+        }),
+        prisma.file.findMany({
+            where: {
+                uploadStatus: "COMPLETED",
+                OR: [
+                    { userId },
+                    { folder: { personalOwnerId: userId } },
+                    ...(input.classId
+                        ? [{ folder: { classId: input.classId, class: classFilter } }]
+                        : [{ folder: { class: classFilter } }]),
+                ],
+            },
+            select: {
+                id: true,
+                name: true,
+                type: true,
+                size: true,
+                folderId: true,
+            },
+            take: 50,
+            orderBy: { uploadedAt: "desc" },
+        }),
+    ]);
+    return { markSchemes, worksheets, files };
+}
+//# sourceMappingURL=marketplace.js.map
+//# debugId=b0ba201b-83d8-5de3-a820-a6105cef2863