@studious-lms/server 1.0.0

package/dist/lib/thumbnailGenerator.js

@@ -0,0 +1,180 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateMediaThumbnail = generateMediaThumbnail;
+exports.generateThumbnail = generateThumbnail;
+exports.storeThumbnail = storeThumbnail;
+const sharp_1 = __importDefault(require("sharp"));
+const prisma_1 = require("./prisma");
+const googleCloudStorage_1 = require("./googleCloudStorage");
+// Thumbnail size configuration
+const THUMBNAIL_WIDTH = 200;
+const THUMBNAIL_HEIGHT = 200;
+// File type configurations
+const SUPPORTED_IMAGE_TYPES = [
+    'image/jpeg',
+    'image/png',
+    'image/gif',
+    'image/webp',
+    'image/tiff',
+    'image/bmp',
+    'image/avif'
+];
+const DOCUMENT_TYPES = [
+    'application/pdf',
+    'application/msword',
+    'application/vnd.openxmlformats-officedocument.wordprocessingml.document', // .docx
+    'application/vnd.ms-excel',
+    'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet', // .xlsx
+    'application/vnd.ms-powerpoint',
+    'application/vnd.openxmlformats-officedocument.presentationml.presentation', // .pptx
+    'text/plain',
+    'text/csv',
+    'application/json',
+    'text/html',
+    'text/javascript',
+    'text/css'
+];
+const VIDEO_TYPES = [
+    'video/mp4',
+    'video/webm',
+    'video/ogg',
+    'video/quicktime'
+];
+const AUDIO_TYPES = [
+    'audio/mpeg',
+    'audio/ogg',
+    'audio/wav',
+    'audio/webm'
+];
+/**
+ * Generates a thumbnail for an image or PDF file
+ * @param fileBuffer The file buffer
+ * @param fileType The MIME type of the file
+ * @returns Thumbnail buffer
+ */
+async function generateMediaThumbnail(fileBuffer, fileType) {
+    if (fileType === 'application/pdf') {
+        // For PDFs, we need to use a different approach
+        try {
+            return await (0, sharp_1.default)(fileBuffer, {
+                density: 300, // Higher density for better quality
+                page: 0 // First page only
+            })
+                .resize(THUMBNAIL_WIDTH, THUMBNAIL_HEIGHT, {
+                fit: 'inside',
+                withoutEnlargement: true,
+            })
+                .jpeg({ quality: 80 })
+                .toBuffer();
+        }
+        catch (error) {
+            console.warn('Failed to generate PDF thumbnail:', error);
+            return generateGenericThumbnail(fileType);
+        }
+    }
+    // For regular images
+    return (0, sharp_1.default)(fileBuffer)
+        .resize(THUMBNAIL_WIDTH, THUMBNAIL_HEIGHT, {
+        fit: 'inside',
+        withoutEnlargement: true,
+    })
+        .jpeg({ quality: 80 })
+        .toBuffer();
+}
+/**
+ * Generates a generic icon-based thumbnail for a file type
+ * @param fileType The MIME type of the file
+ * @returns Thumbnail buffer
+ */
+async function generateGenericThumbnail(fileType) {
+    // Create a blank canvas with a colored background based on file type
+    const canvas = (0, sharp_1.default)({
+        create: {
+            width: THUMBNAIL_WIDTH,
+            height: THUMBNAIL_HEIGHT,
+            channels: 4,
+            background: { r: 245, g: 245, b: 245, alpha: 1 }
+        }
+    });
+    // Add a colored overlay based on file type
+    let color = { r: 200, g: 200, b: 200, alpha: 0.5 }; // Default gray
+    if (DOCUMENT_TYPES.includes(fileType)) {
+        color = { r: 52, g: 152, b: 219, alpha: 0.5 }; // Blue for documents
+    }
+    else if (VIDEO_TYPES.includes(fileType)) {
+        color = { r: 231, g: 76, b: 60, alpha: 0.5 }; // Red for videos
+    }
+    else if (AUDIO_TYPES.includes(fileType)) {
+        color = { r: 46, g: 204, b: 113, alpha: 0.5 }; // Green for audio
+    }
+    return canvas
+        .composite([{
+            input: Buffer.from([color.r, color.g, color.b, Math.floor(color.alpha * 255)]),
+            raw: {
+                width: 1,
+                height: 1,
+                channels: 4
+            },
+            tile: true,
+            blend: 'overlay'
+        }])
+        .jpeg({ quality: 80 })
+        .toBuffer();
+}
+/**
+ * Generates a thumbnail for a file
+ * @param fileName The name of the file in Google Cloud Storage
+ * @param fileType The MIME type of the file
+ * @returns The thumbnail buffer or null if thumbnail generation is not supported
+ */
+async function generateThumbnail(fileName, fileType) {
+    try {
+        const signedUrl = await (0, googleCloudStorage_1.getSignedUrl)(fileName);
+        const response = await fetch(signedUrl);
+        if (!response.ok) {
+            throw new Error(`Failed to download file from storage: ${response.status} ${response.statusText}`);
+        }
+        const fileBuffer = await response.arrayBuffer();
+        if (SUPPORTED_IMAGE_TYPES.includes(fileType) || fileType === 'application/pdf') {
+            try {
+                const thumbnail = await generateMediaThumbnail(Buffer.from(fileBuffer), fileType);
+                return thumbnail;
+            }
+            catch (error) {
+                return generateGenericThumbnail(fileType);
+            }
+        }
+        else if ([...DOCUMENT_TYPES, ...VIDEO_TYPES, ...AUDIO_TYPES].includes(fileType)) {
+            return generateGenericThumbnail(fileType);
+        }
+        return null; // Unsupported file type
+    }
+    catch (error) {
+        return null;
+    }
+}
+/**
+ * Stores a thumbnail in Google Cloud Storage and creates a File entry
+ * @param thumbnailBuffer The thumbnail buffer to store
+ * @param originalFileName The original file name
+ * @param userId The user ID who owns the file
+ * @returns The ID of the created thumbnail File
+ */
+async function storeThumbnail(thumbnailBuffer, originalFileName, userId) {
+    // Convert buffer to base64 for uploadFile function
+    const base64Data = `data:image/jpeg;base64,${thumbnailBuffer.toString('base64')}`;
+    const thumbnailFileName = await (0, googleCloudStorage_1.uploadFile)(base64Data, `thumbnails/${originalFileName}_thumb`, 'image/jpeg');
+    // Create a new File entry for the thumbnail
+    const newThumbnail = await prisma_1.prisma.file.create({
+        data: {
+            name: `${originalFileName}_thumb.jpg`,
+            path: thumbnailFileName,
+            type: 'image/jpeg',
+            userId: userId,
+        },
+    });
+    return newThumbnail.id;
+}

package/dist/logger.d.ts

@@ -0,0 +1,26 @@
+export declare enum LogLevel {
+    INFO = "info",
+    WARN = "warn",
+    ERROR = "error",
+    DEBUG = "debug"
+}
+type LogMode = 'silent' | 'minimal' | 'normal' | 'verbose';
+declare class Logger {
+    private static instance;
+    private isDevelopment;
+    private mode;
+    private levelEmojis;
+    private constructor();
+    static getInstance(): Logger;
+    setMode(mode: LogMode): void;
+    private shouldLog;
+    private formatMessage;
+    private log;
+    info(message: string, context?: Record<string, any>): void;
+    warn(message: string, context?: Record<string, any>): void;
+    error(message: string, context?: Record<string, any>): void;
+    debug(message: string, context?: Record<string, any>): void;
+}
+export declare const logger: Logger;
+export {};
+//# sourceMappingURL=logger.d.ts.map

package/dist/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../src/logger.ts"],"names":[],"mappings":"AAAA,oBAAY,QAAQ;IAClB,IAAI,SAAS;IACb,IAAI,SAAS;IACb,KAAK,UAAU;IACf,KAAK,UAAU;CAChB;AAED,KAAK,OAAO,GAAG,QAAQ,GAAG,SAAS,GAAG,QAAQ,GAAG,SAAS,CAAC;AAuC3D,cAAM,MAAM;IACV,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAS;IAChC,OAAO,CAAC,aAAa,CAAU;IAC/B,OAAO,CAAC,IAAI,CAAU;IACtB,OAAO,CAAC,WAAW,CAA2B;IAE9C,OAAO;WAYO,WAAW,IAAI,MAAM;IAO5B,OAAO,CAAC,IAAI,EAAE,OAAO;IAI5B,OAAO,CAAC,SAAS;IAWjB,OAAO,CAAC,aAAa;IA8BrB,OAAO,CAAC,GAAG;IA6BJ,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;IAInD,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;IAInD,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;IAIpD,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;CAG5D;AAED,eAAO,MAAM,MAAM,QAAuB,CAAC"}

package/dist/logger.js

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = exports.LogLevel = void 0;
+var LogLevel;
+(function (LogLevel) {
+    LogLevel["INFO"] = "info";
+    LogLevel["WARN"] = "warn";
+    LogLevel["ERROR"] = "error";
+    LogLevel["DEBUG"] = "debug";
+})(LogLevel || (exports.LogLevel = LogLevel = {}));
+// Environment detection
+const isNode = typeof process !== 'undefined' && process.versions != null && process.versions.node != null;
+const isBrowser = typeof window !== 'undefined' && typeof window.document !== 'undefined';
+// ANSI color codes for Node.js
+const ansiColors = {
+    reset: '\x1b[0m',
+    bright: '\x1b[1m',
+    dim: '\x1b[2m',
+    red: '\x1b[31m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    blue: '\x1b[34m',
+    magenta: '\x1b[35m',
+    cyan: '\x1b[36m',
+    white: '\x1b[37m',
+    gray: '\x1b[90m'
+};
+// CSS color codes for browser console
+const cssColors = {
+    reset: '%c',
+    info: 'color: #2196F3; font-weight: bold;',
+    warn: 'color: #FFC107; font-weight: bold;',
+    error: 'color: #F44336; font-weight: bold;',
+    debug: 'color: #9C27B0; font-weight: bold;',
+    gray: 'color: #9E9E9E;',
+    context: 'color: #757575; font-style: italic;'
+};
+class Logger {
+    constructor() {
+        this.isDevelopment = process.env.NODE_ENV === 'development';
+        this.mode = process.env.LOG_MODE || 'normal';
+        this.levelEmojis = {
+            [LogLevel.INFO]: 'ℹ️',
+            [LogLevel.WARN]: '⚠️',
+            [LogLevel.ERROR]: '❌',
+            [LogLevel.DEBUG]: '🔍'
+        };
+    }
+    static getInstance() {
+        if (!Logger.instance) {
+            Logger.instance = new Logger();
+        }
+        return Logger.instance;
+    }
+    setMode(mode) {
+        this.mode = mode;
+    }
+    shouldLog(level) {
+        const silent = [LogLevel.ERROR];
+        const minimal = [LogLevel.ERROR, LogLevel.WARN];
+        const normal = [LogLevel.ERROR, LogLevel.WARN, LogLevel.INFO];
+        if (this.mode === 'silent')
+            return silent.includes(level);
+        if (this.mode === 'minimal')
+            return minimal.includes(level);
+        if (this.mode === 'normal')
+            return normal.includes(level);
+        return true; // verbose mode
+    }
+    formatMessage(logMessage) {
+        const { level, message, timestamp, context } = logMessage;
+        const emoji = this.levelEmojis[level];
+        const timestampStr = `[${timestamp}]`;
+        const levelStr = `[${level.toUpperCase()}]`;
+        const messageStr = `${emoji} ${message}`;
+        const contextStr = context
+            ? `\nContext: ${JSON.stringify(context, null, 2)}`
+            : '';
+        if (isNode) {
+            const color = ansiColors[level === LogLevel.INFO ? 'blue' :
+                level === LogLevel.WARN ? 'yellow' :
+                    level === LogLevel.ERROR ? 'red' : 'magenta'];
+            return `${ansiColors.gray}${timestampStr}${ansiColors.reset} ${color}${levelStr}${ansiColors.reset} ${messageStr}${contextStr}`;
+        }
+        else {
+            const color = cssColors[level];
+            return [
+                `${timestampStr} ${levelStr} ${messageStr}${contextStr}`,
+                cssColors.reset,
+                color,
+                cssColors.gray,
+                cssColors.context
+            ];
+        }
+    }
+    log(level, message, context) {
+        if (!this.shouldLog(level))
+            return;
+        const logMessage = {
+            level,
+            message,
+            timestamp: new Date().toISOString(),
+            context
+        };
+        const formattedMessage = this.formatMessage(logMessage);
+        switch (level) {
+            case LogLevel.ERROR:
+                console.error(...(Array.isArray(formattedMessage) ? formattedMessage : [formattedMessage]));
+                break;
+            case LogLevel.WARN:
+                console.warn(...(Array.isArray(formattedMessage) ? formattedMessage : [formattedMessage]));
+                break;
+            case LogLevel.DEBUG:
+                if (this.isDevelopment) {
+                    console.debug(...(Array.isArray(formattedMessage) ? formattedMessage : [formattedMessage]));
+                }
+                break;
+            default:
+                console.log(...(Array.isArray(formattedMessage) ? formattedMessage : [formattedMessage]));
+        }
+    }
+    info(message, context) {
+        this.log(LogLevel.INFO, message, context);
+    }
+    warn(message, context) {
+        this.log(LogLevel.WARN, message, context);
+    }
+    error(message, context) {
+        this.log(LogLevel.ERROR, message, context);
+    }
+    debug(message, context) {
+        this.log(LogLevel.DEBUG, message, context);
+    }
+}
+exports.logger = Logger.getInstance();

package/dist/middleware/auth.d.ts

@@ -0,0 +1,7 @@
+export declare const createAuthMiddleware: (t: any) => {
+    isAuthed: any;
+    addComputedFlags: any;
+    isMemberInClass: any;
+    isTeacherInClass: any;
+};
+//# sourceMappingURL=auth.d.ts.map

package/dist/middleware/auth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth.d.ts","sourceRoot":"","sources":["../../src/middleware/auth.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,oBAAoB,GAAI,GAAG,GAAG;;;;;CA0L1C,CAAC"}

package/dist/middleware/auth.js

@@ -0,0 +1,170 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAuthMiddleware = void 0;
+const server_1 = require("@trpc/server");
+const prisma_1 = require("@lib/prisma");
+const createAuthMiddleware = (t) => {
+    // Auth middleware
+    const isAuthed = t.middleware(async ({ next, ctx }) => {
+        const startTime = Date.now();
+        // Get user from request headers
+        const userHeader = ctx.req.headers['x-user'];
+        if (!userHeader) {
+            throw new server_1.TRPCError({
+                code: 'UNAUTHORIZED',
+                message: 'Not authenticated - no token found',
+            });
+        }
+        try {
+            const token = typeof userHeader === 'string' ? userHeader : userHeader[0];
+            // Find user by session token
+            const user = await prisma_1.prisma.user.findFirst({
+                where: {
+                    sessions: {
+                        some: {
+                            id: token
+                        }
+                    }
+                },
+                select: {
+                    id: true,
+                    username: true,
+                    // institutionId: true,
+                }
+            });
+            if (!user) {
+                throw new server_1.TRPCError({
+                    code: 'UNAUTHORIZED',
+                    message: 'Invalid or expired session',
+                });
+            }
+            console.log(user);
+            return next({
+                ctx: {
+                    ...ctx,
+                    user,
+                },
+            });
+        }
+        catch (error) {
+            console.log(error);
+            throw new server_1.TRPCError({
+                code: 'UNAUTHORIZED',
+                message: 'Invalid user data',
+            });
+        }
+    });
+    // Add computed flags middleware
+    const addComputedFlags = t.middleware(async ({ next, ctx }) => {
+        if (!ctx.user) {
+            throw new server_1.TRPCError({
+                code: 'UNAUTHORIZED',
+                message: 'Not authenticated',
+            });
+        }
+        // Get all classes where user is a teacher
+        const teacherClasses = await prisma_1.prisma.class.findMany({
+            where: {
+                teachers: {
+                    some: {
+                        id: ctx.user.id
+                    }
+                }
+            },
+            select: {
+                id: true
+            }
+        });
+        return next({
+            ctx: {
+                ...ctx,
+                isTeacher: teacherClasses.length > 0,
+                teacherClassIds: teacherClasses.map((c) => c.id)
+            }
+        });
+    });
+    // Student middleware
+    const isMemberInClass = t.middleware(async ({ next, ctx, input }) => {
+        if (!ctx.user) {
+            throw new server_1.TRPCError({
+                code: 'UNAUTHORIZED',
+                message: 'Not authenticated',
+            });
+        }
+        const classId = input?.classId;
+        if (!classId) {
+            throw new server_1.TRPCError({
+                code: 'BAD_REQUEST',
+                message: 'classId is required',
+            });
+        }
+        const isMember = await prisma_1.prisma.class.findFirst({
+            where: {
+                id: classId,
+                OR: [
+                    {
+                        students: {
+                            some: {
+                                id: ctx.user.id
+                            }
+                        }
+                    },
+                    {
+                        teachers: {
+                            some: {
+                                id: ctx.user.id
+                            }
+                        }
+                    }
+                ]
+            }
+        });
+        if (!isMember) {
+            throw new server_1.TRPCError({
+                code: 'FORBIDDEN',
+                message: 'Not a member in this class',
+            });
+        }
+        return next();
+    });
+    // Teacher middleware
+    const isTeacherInClass = t.middleware(async ({ next, ctx, input }) => {
+        if (!ctx.user) {
+            throw new server_1.TRPCError({
+                code: 'UNAUTHORIZED',
+                message: 'Not authenticated',
+            });
+        }
+        const classId = input.classId;
+        if (!classId) {
+            throw new server_1.TRPCError({
+                code: 'BAD_REQUEST',
+                message: 'classId is required',
+            });
+        }
+        const isTeacher = await prisma_1.prisma.class.findFirst({
+            where: {
+                id: classId,
+                teachers: {
+                    some: {
+                        id: ctx.user.id
+                    }
+                }
+            }
+        });
+        if (!isTeacher) {
+            throw new server_1.TRPCError({
+                code: 'FORBIDDEN',
+                message: 'Not a teacher in this class',
+            });
+        }
+        return next();
+    });
+    return {
+        isAuthed,
+        addComputedFlags,
+        isMemberInClass,
+        isTeacherInClass,
+    };
+};
+exports.createAuthMiddleware = createAuthMiddleware;

package/dist/middleware/logging.d.ts

@@ -0,0 +1,2 @@
+export declare const createLoggingMiddleware: (t: any) => any;
+//# sourceMappingURL=logging.d.ts.map

package/dist/middleware/logging.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logging.d.ts","sourceRoot":"","sources":["../../src/middleware/logging.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,uBAAuB,GAAI,GAAG,GAAG,QAkD7C,CAAC"}

package/dist/middleware/logging.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLoggingMiddleware = void 0;
+const logger_1 = require("@/logger");
+const createLoggingMiddleware = (t) => {
+    return t.middleware(async ({ path, type, next, ctx }) => {
+        const start = Date.now();
+        const requestId = crypto.randomUUID();
+        // Log request
+        logger_1.logger.info('tRPC Request', {
+            requestId,
+            path,
+            type,
+            // input,
+            timestamp: new Date().toISOString(),
+        });
+        try {
+            const result = await next();
+            const durationMs = Date.now() - start;
+            // Log successful response
+            logger_1.logger.info('tRPC Response', {
+                requestId,
+                path,
+                type,
+                durationMs,
+                ok: result.ok,
+                timestamp: new Date().toISOString(),
+            });
+            return result;
+        }
+        catch (error) {
+            const durationMs = Date.now() - start;
+            // Log error response
+            logger_1.logger.error('tRPC Error' + path, {
+                requestId,
+                path,
+                type,
+                durationMs,
+                error: error instanceof Error ? {
+                    path,
+                    name: error.name,
+                    message: error.message,
+                    stack: error.stack,
+                } : error,
+                timestamp: new Date().toISOString(),
+            });
+            throw error;
+        }
+    });
+};
+exports.createLoggingMiddleware = createLoggingMiddleware;