@studious-lms/server 1.1.24 → 1.2.6

package/dist/routers/user.js

@@ -1,232 +1,62 @@
+
+!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]="7b0b6e3d-022d-5fe3-a54e-a8f4a40964f3")}catch(e){}}();
 import { z } from "zod";
 import { createTRPCRouter, protectedProcedure } from "../trpc.js";
-import { TRPCError } from "@trpc/server";
-import { prisma } from "../lib/prisma.js";
-import { logger } from "../utils/logger.js";
-// Helper function to convert file path to backend proxy URL
-function getFileUrl(filePath) {
-    if (!filePath)
-        return null;
-    // If it's already a full URL (DiceBear or external), return as is
-    if (filePath.startsWith('http')) {
-        return filePath;
-    }
-    // Convert GCS path to full backend proxy URL
-    const backendUrl = process.env.BACKEND_URL || 'http://localhost:3001';
-    return `${backendUrl}/api/files/${encodeURIComponent(filePath)}`;
-}
-// For direct file uploads (file already uploaded to GCS)
+import { getProfile, updateProfile, getUploadUrl, } from "../services/user.js";
 const fileUploadSchema = z.object({
     filePath: z.string().min(1, "File path is required"),
     fileName: z.string().min(1, "File name is required"),
-    fileType: z.string().regex(/^image\/(jpeg|jpg|png|gif|webp)$/i, "Only image files (JPEG, PNG, GIF, WebP) are allowed"),
+    fileType: z
+        .string()
+        .regex(/^image\/(jpeg|jpg|png|gif|webp)$/i, "Only image files (JPEG, PNG, GIF, WebP) are allowed"),
     fileSize: z.number().max(5 * 1024 * 1024, "File size must be less than 5MB"),
 });
-// For DiceBear avatar URL
 const dicebearSchema = z.object({
     url: z.string().url("Invalid DiceBear avatar URL"),
 });
 const profileSchema = z.object({
-    displayName: z.string().nullable().optional().transform(val => val === null ? undefined : val),
-    bio: z.string().nullable().optional().transform(val => val === null ? undefined : val),
-    location: z.string().nullable().optional().transform(val => val === null ? undefined : val),
-    website: z.union([
+    displayName: z
+        .string()
+        .nullable()
+        .optional()
+        .transform((val) => (val === null ? undefined : val)),
+    bio: z
+        .string()
+        .nullable()
+        .optional()
+        .transform((val) => (val === null ? undefined : val)),
+    location: z
+        .string()
+        .nullable()
+        .optional()
+        .transform((val) => (val === null ? undefined : val)),
+    website: z
+        .union([
         z.string().url(),
         z.literal(""),
-        z.null().transform(() => undefined)
-    ]).optional(),
+        z.null().transform(() => undefined),
+    ])
+        .optional(),
 });
 const updateProfileSchema = z.object({
     profile: profileSchema.optional(),
-    // Support both custom file upload and DiceBear avatar
     profilePicture: fileUploadSchema.optional(),
     dicebearAvatar: dicebearSchema.optional(),
 });
 const getUploadUrlSchema = z.object({
     fileName: z.string().min(1, "File name is required"),
-    fileType: z.string().regex(/^image\/(jpeg|jpg|png|gif|webp)$/i, "Only image files are allowed"),
+    fileType: z
+        .string()
+        .regex(/^image\/(jpeg|jpg|png|gif|webp)$/i, "Only image files are allowed"),
 });
 export const userRouter = createTRPCRouter({
-    getProfile: protectedProcedure
-        .query(async ({ ctx }) => {
-        if (!ctx.user) {
-            throw new TRPCError({
-                code: "UNAUTHORIZED",
-                message: "User must be authenticated",
-            });
-        }
-        const user = await prisma.user.findUnique({
-            where: { id: ctx.user.id },
-            select: {
-                id: true,
-                username: true,
-            },
-        });
-        if (!user) {
-            throw new TRPCError({
-                code: "NOT_FOUND",
-                message: "User not found",
-            });
-        }
-        // Get user profile separately
-        const userProfile = await prisma.userProfile.findUnique({
-            where: { userId: ctx.user.id },
-        });
-        return {
-            id: user.id,
-            username: user.username,
-            profile: userProfile ? {
-                displayName: userProfile.displayName || null,
-                bio: userProfile.bio || null,
-                location: userProfile.location || null,
-                website: userProfile.website || null,
-                profilePicture: getFileUrl(userProfile.profilePicture),
-                profilePictureThumbnail: getFileUrl(userProfile.profilePictureThumbnail),
-            } : {
-                displayName: null,
-                bio: null,
-                location: null,
-                website: null,
-                profilePicture: null,
-                profilePictureThumbnail: null,
-            },
-        };
-    }),
+    getProfile: protectedProcedure.query(({ ctx }) => getProfile(ctx.user.id)),
     updateProfile: protectedProcedure
         .input(updateProfileSchema)
-        .mutation(async ({ ctx, input }) => {
-        if (!ctx.user) {
-            throw new TRPCError({
-                code: "UNAUTHORIZED",
-                message: "User must be authenticated",
-            });
-        }
-        // Get current profile to clean up old profile picture
-        const currentProfile = await prisma.userProfile.findUnique({
-            where: { userId: ctx.user.id },
-        });
-        let profilePictureUrl = null;
-        let profilePictureThumbnail = null;
-        // Handle custom profile picture (already uploaded to GCS)
-        if (input.profilePicture) {
-            try {
-                // File is already uploaded to GCS, just use the path
-                profilePictureUrl = input.profilePicture.filePath;
-                // Generate thumbnail for the uploaded file
-                // TODO: Implement thumbnail generation for direct uploads
-                profilePictureThumbnail = null;
-                // Clean up old profile picture if it exists
-                if (currentProfile?.profilePicture) {
-                    // TODO: Implement file deletion logic here
-                    // await deleteFile((currentProfile as any).profilePicture);
-                }
-            }
-            catch (error) {
-                logger.error('Profile picture processing failed', {
-                    userId: ctx.user.id,
-                    error: error instanceof Error ? error.message : 'Unknown error'
-                });
-                throw new TRPCError({
-                    code: "INTERNAL_SERVER_ERROR",
-                    message: "Failed to process profile picture. Please try again.",
-                });
-            }
-        }
-        // Handle DiceBear avatar URL
-        if (input.dicebearAvatar) {
-            profilePictureUrl = input.dicebearAvatar.url;
-            // No thumbnail for DiceBear avatars since they're SVG URLs
-            profilePictureThumbnail = null;
-        }
-        // Prepare update data
-        const updateData = {};
-        if (input.profile) {
-            if (input.profile.displayName !== undefined && input.profile.displayName !== null) {
-                updateData.displayName = input.profile.displayName;
-            }
-            if (input.profile.bio !== undefined && input.profile.bio !== null) {
-                updateData.bio = input.profile.bio;
-            }
-            if (input.profile.location !== undefined && input.profile.location !== null) {
-                updateData.location = input.profile.location;
-            }
-            if (input.profile.website !== undefined && input.profile.website !== null) {
-                updateData.website = input.profile.website;
-            }
-        }
-        if (profilePictureUrl !== null)
-            updateData.profilePicture = profilePictureUrl;
-        if (profilePictureThumbnail !== null)
-            updateData.profilePictureThumbnail = profilePictureThumbnail;
-        // Upsert user profile with structured data
-        const updatedProfile = await prisma.userProfile.upsert({
-            where: { userId: ctx.user.id },
-            create: {
-                userId: ctx.user.id,
-                ...updateData,
-            },
-            update: {
-                ...updateData,
-                updatedAt: new Date(),
-            },
-        });
-        // Get username for response
-        const user = await prisma.user.findUnique({
-            where: { id: ctx.user.id },
-            select: { username: true },
-        });
-        return {
-            id: ctx.user.id,
-            username: user?.username || '',
-            profile: {
-                displayName: updatedProfile.displayName || null,
-                bio: updatedProfile.bio || null,
-                location: updatedProfile.location || null,
-                website: updatedProfile.website || null,
-                profilePicture: getFileUrl(updatedProfile.profilePicture),
-                profilePictureThumbnail: getFileUrl(updatedProfile.profilePictureThumbnail),
-            },
-        };
-    }),
+        .mutation(({ ctx, input }) => updateProfile(ctx.user.id, input)),
     getUploadUrl: protectedProcedure
         .input(getUploadUrlSchema)
-        .mutation(async ({ ctx, input }) => {
-        if (!ctx.user) {
-            throw new TRPCError({
-                code: "UNAUTHORIZED",
-                message: "User must be authenticated",
-            });
-        }
-        try {
-            // Generate unique filename
-            const fileExtension = input.fileName.split('.').pop();
-            const uniqueFilename = `${ctx.user.id}-${Date.now()}.${fileExtension}`;
-            const filePath = `users/${ctx.user.id}/profile/${uniqueFilename}`;
-            // Generate backend proxy upload URL instead of direct GCS signed URL
-            const backendUrl = process.env.BACKEND_URL || 'http://localhost:3001';
-            const uploadUrl = `${backendUrl}/api/upload/${encodeURIComponent(filePath)}`;
-            logger.info('Generated upload URL', {
-                userId: ctx.user.id,
-                filePath,
-                fileName: uniqueFilename,
-                fileType: input.fileType,
-                uploadUrl
-            });
-            return {
-                uploadUrl,
-                filePath,
-                fileName: uniqueFilename,
-            };
-        }
-        catch (error) {
-            logger.error('Failed to generate upload URL', {
-                userId: ctx.user.id,
-                error: error instanceof Error ? error.message : 'Unknown error'
-            });
-            throw new TRPCError({
-                code: "INTERNAL_SERVER_ERROR",
-                message: "Failed to generate upload URL",
-            });
-        }
-    }),
+        .mutation(({ ctx, input }) => getUploadUrl(ctx.user.id, input.fileName, input.fileType)),
 });
+//# sourceMappingURL=user.js.map
+//# debugId=7b0b6e3d-022d-5fe3-a54e-a8f4a40964f3

package/dist/routers/user.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"user.js","sources":["routers/user.ts"],"sourceRoot":"/","sourcesContent":["import { z } from \"zod\";\nimport { createTRPCRouter, protectedProcedure } from \"../trpc.js\";\nimport {\n  getProfile,\n  updateProfile,\n  getUploadUrl,\n} from \"../services/user.js\";\n\nconst fileUploadSchema = z.object({\n  filePath: z.string().min(1, \"File path is required\"),\n  fileName: z.string().min(1, \"File name is required\"),\n  fileType: z\n    .string()\n    .regex(\n      /^image\\/(jpeg|jpg|png|gif|webp)$/i,\n      \"Only image files (JPEG, PNG, GIF, WebP) are allowed\"\n    ),\n  fileSize: z.number().max(5 * 1024 * 1024, \"File size must be less than 5MB\"),\n});\n\nconst dicebearSchema = z.object({\n  url: z.string().url(\"Invalid DiceBear avatar URL\"),\n});\n\nconst profileSchema = z.object({\n  displayName: z\n    .string()\n    .nullable()\n    .optional()\n    .transform((val) => (val === null ? undefined : val)),\n  bio: z\n    .string()\n    .nullable()\n    .optional()\n    .transform((val) => (val === null ? undefined : val)),\n  location: z\n    .string()\n    .nullable()\n    .optional()\n    .transform((val) => (val === null ? undefined : val)),\n  website: z\n    .union([\n      z.string().url(),\n      z.literal(\"\"),\n      z.null().transform(() => undefined),\n    ])\n    .optional(),\n});\n\nconst updateProfileSchema = z.object({\n  profile: profileSchema.optional(),\n  profilePicture: fileUploadSchema.optional(),\n  dicebearAvatar: dicebearSchema.optional(),\n});\n\nconst getUploadUrlSchema = z.object({\n  fileName: z.string().min(1, \"File name is required\"),\n  fileType: z\n    .string()\n    .regex(\n      /^image\\/(jpeg|jpg|png|gif|webp)$/i,\n      \"Only image files are allowed\"\n    ),\n});\n\nexport const userRouter = createTRPCRouter({\n  getProfile: protectedProcedure.query(({ ctx }) =>\n    getProfile(ctx.user!.id)\n  ),\n\n  updateProfile: protectedProcedure\n    .input(updateProfileSchema)\n    .mutation(({ ctx, input }) =>\n      updateProfile(ctx.user!.id, input)\n    ),\n\n  getUploadUrl: protectedProcedure\n    .input(getUploadUrlSchema)\n    .mutation(({ ctx, input }) =>\n      getUploadUrl(ctx.user!.id, input.fileName, input.fileType)\n    ),\n});\n"],"names":[],"mappings":"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","debug_id":"7b0b6e3d-022d-5fe3-a54e-a8f4a40964f3"}

package/dist/routers/worksheet.d.ts

@@ -0,0 +1,362 @@
+import { z } from "zod";
+export declare const worksheetRouter: import("@trpc/server").TRPCBuiltRouter<{
+    ctx: import("../trpc.js").Context;
+    meta: object;
+    errorShape: {
+        data: {
+            zodError: z.typeToFlattenedError<any, string> | null;
+            prismaError: import("../utils/prismaErrorHandler.js").PrismaErrorInfo | null;
+            code: import("@trpc/server").TRPC_ERROR_CODE_KEY;
+            httpStatus: number;
+            path?: string;
+            stack?: string;
+        };
+        message: string;
+        code: import("@trpc/server").TRPC_ERROR_CODE_NUMBER;
+    };
+    transformer: false;
+}, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
+    getWorksheet: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            worksheetId: string;
+        };
+        output: {
+            class: {
+                id: string;
+                schoolId: string | null;
+                name: string;
+                subject: string;
+                color: string | null;
+                section: string;
+                syllabus: string | null;
+            } | null;
+            questions: {
+                options: import("@prisma/client/runtime/library.js").JsonValue | null;
+                type: import(".prisma/client").$Enums.WorksheetQuestionType;
+                id: string;
+                createdAt: Date;
+                updatedAt: Date;
+                order: number | null;
+                markScheme: import("@prisma/client/runtime/library.js").JsonValue | null;
+                question: string;
+                points: number;
+                worksheetId: string;
+                answer: string;
+            }[];
+        } & {
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            classId: string;
+            name: string;
+        };
+        meta: object;
+    }>;
+    exists: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            [x: string]: unknown;
+            classId: string;
+            id: string;
+        };
+        output: boolean;
+        meta: object;
+    }>;
+    listWorksheets: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            classId: string;
+        };
+        output: {
+            questionCount: number;
+            questions: {
+                id: string;
+            }[];
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            classId: string;
+            name: string;
+        }[];
+        meta: object;
+    }>;
+    updateWorksheet: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            worksheetId: string;
+            name?: string | undefined;
+        };
+        output: {
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            classId: string;
+            name: string;
+        };
+        meta: object;
+    }>;
+    deleteWorksheet: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            worksheetId: string;
+        };
+        output: {
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            classId: string;
+            name: string;
+        };
+        meta: object;
+    }>;
+    create: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            classId: string;
+            name: string;
+        };
+        output: {
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            classId: string;
+            name: string;
+        };
+        meta: object;
+    }>;
+    addQuestion: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            type: "ESSAY" | "MULTIPLE_CHOICE" | "TRUE_FALSE" | "SHORT_ANSWER" | "LONG_ANSWER" | "MATH_EXPRESSION";
+            question: string;
+            worksheetId: string;
+            answer: string;
+            options?: any;
+            markScheme?: any;
+            points?: number | undefined;
+        };
+        output: {
+            options: import("@prisma/client/runtime/library.js").JsonValue | null;
+            type: import(".prisma/client").$Enums.WorksheetQuestionType;
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            order: number | null;
+            markScheme: import("@prisma/client/runtime/library.js").JsonValue | null;
+            question: string;
+            points: number;
+            worksheetId: string;
+            answer: string;
+        };
+        meta: object;
+    }>;
+    reorderQuestions: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            worksheetId: string;
+            movedId: string;
+            position: "before" | "after";
+            targetId: string;
+        };
+        output: {
+            id: string;
+        }[];
+        meta: object;
+    }>;
+    updateQuestion: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            questionId: string;
+            worksheetId: string;
+            options?: any;
+            type?: "ESSAY" | "MULTIPLE_CHOICE" | "TRUE_FALSE" | "SHORT_ANSWER" | "LONG_ANSWER" | "MATH_EXPRESSION" | undefined;
+            markScheme?: any;
+            question?: string | undefined;
+            points?: number | undefined;
+            answer?: string | undefined;
+        };
+        output: {
+            options: import("@prisma/client/runtime/library.js").JsonValue | null;
+            type: import(".prisma/client").$Enums.WorksheetQuestionType;
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            order: number | null;
+            markScheme: import("@prisma/client/runtime/library.js").JsonValue | null;
+            question: string;
+            points: number;
+            worksheetId: string;
+            answer: string;
+        };
+        meta: object;
+    }>;
+    deleteQuestion: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            questionId: string;
+            worksheetId: string;
+        };
+        output: {
+            options: import("@prisma/client/runtime/library.js").JsonValue | null;
+            type: import(".prisma/client").$Enums.WorksheetQuestionType;
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            order: number | null;
+            markScheme: import("@prisma/client/runtime/library.js").JsonValue | null;
+            question: string;
+            points: number;
+            worksheetId: string;
+            answer: string;
+        };
+        meta: object;
+    }>;
+    getWorksheetSubmission: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            submissionId: string;
+            worksheetId: string;
+        };
+        output: {
+            responses: ({
+                comments: {
+                    id: string;
+                }[];
+            } & {
+                status: import(".prisma/client").$Enums.GenerationStatus | null;
+                id: string;
+                createdAt: Date;
+                updatedAt: Date | null;
+                feedback: string | null;
+                studentId: string;
+                response: string;
+                isCorrect: boolean;
+                markschemeState: import("@prisma/client/runtime/library.js").JsonValue | null;
+                points: number;
+                questionId: string;
+                studentWorksheetResponseId: string | null;
+            })[];
+        } & {
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            submissionId: string | null;
+            studentId: string;
+            submittedAt: Date | null;
+            submitted: boolean;
+            worksheetId: string;
+        };
+        meta: object;
+    }>;
+    answerQuestion: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            response: string;
+            questionId: string;
+            worksheetResponseId: string;
+        };
+        output: {
+            responses: {
+                status: import(".prisma/client").$Enums.GenerationStatus | null;
+                id: string;
+                createdAt: Date;
+                updatedAt: Date | null;
+                feedback: string | null;
+                studentId: string;
+                response: string;
+                isCorrect: boolean;
+                markschemeState: import("@prisma/client/runtime/library.js").JsonValue | null;
+                points: number;
+                questionId: string;
+                studentWorksheetResponseId: string | null;
+            }[];
+        } & {
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            submissionId: string | null;
+            studentId: string;
+            submittedAt: Date | null;
+            submitted: boolean;
+            worksheetId: string;
+        };
+        meta: object;
+    }>;
+    cancelGrading: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            worksheetResponseId: string;
+            progressId: string;
+        };
+        output: {
+            status: import(".prisma/client").$Enums.GenerationStatus | null;
+            id: string;
+            createdAt: Date;
+            updatedAt: Date | null;
+            feedback: string | null;
+            studentId: string;
+            response: string;
+            isCorrect: boolean;
+            markschemeState: import("@prisma/client/runtime/library.js").JsonValue | null;
+            points: number;
+            questionId: string;
+            studentWorksheetResponseId: string | null;
+        };
+        meta: object;
+    }>;
+    regradeQuestion: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            worksheetResponseId: string;
+            progressId: string;
+        };
+        output: {
+            status: import(".prisma/client").$Enums.GenerationStatus | null;
+            id: string;
+            createdAt: Date;
+            updatedAt: Date | null;
+            feedback: string | null;
+            studentId: string;
+            response: string;
+            isCorrect: boolean;
+            markschemeState: import("@prisma/client/runtime/library.js").JsonValue | null;
+            points: number;
+            questionId: string;
+            studentWorksheetResponseId: string | null;
+        };
+        meta: object;
+    }>;
+    gradeAnswer: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            isCorrect: boolean;
+            questionId: string;
+            studentWorksheetResponseId: string;
+            feedback?: string | undefined;
+            response?: string | undefined;
+            markschemeState?: any;
+            points?: number | undefined;
+            responseId?: string | undefined;
+        };
+        output: {
+            status: import(".prisma/client").$Enums.GenerationStatus | null;
+            id: string;
+            createdAt: Date;
+            updatedAt: Date | null;
+            feedback: string | null;
+            studentId: string;
+            response: string;
+            isCorrect: boolean;
+            markschemeState: import("@prisma/client/runtime/library.js").JsonValue | null;
+            points: number;
+            questionId: string;
+            studentWorksheetResponseId: string | null;
+        };
+        meta: object;
+    }>;
+    addComment: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            comment: string;
+            responseId: string;
+        };
+        output: {
+            status: import(".prisma/client").$Enums.GenerationStatus | null;
+            id: string;
+            createdAt: Date;
+            content: string;
+            modifiedAt: Date | null;
+            announcementId: string | null;
+            authorId: string;
+            parentCommentId: string | null;
+            studentQuestionProgressId: string | null;
+        };
+        meta: object;
+    }>;
+}>>;
+//# sourceMappingURL=worksheet.d.ts.map

package/dist/routers/worksheet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worksheet.d.ts","sourceRoot":"/","sources":["routers/worksheet.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAoBxB,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiO1B,CAAC"}