@studious-lms/server 1.0.0

package/dist/routers/section.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sectionRouter = void 0;
+const zod_1 = require("zod");
+const trpc_1 = require("../trpc");
+const server_1 = require("@trpc/server");
+const prisma_1 = require("@lib/prisma");
+const createSectionSchema = zod_1.z.object({
+    classId: zod_1.z.string(),
+    name: zod_1.z.string(),
+});
+const updateSectionSchema = zod_1.z.object({
+    id: zod_1.z.string(),
+    classId: zod_1.z.string(),
+    name: zod_1.z.string(),
+});
+const deleteSectionSchema = zod_1.z.object({
+    id: zod_1.z.string(),
+    classId: zod_1.z.string(),
+});
+exports.sectionRouter = (0, trpc_1.createTRPCRouter)({
+    create: trpc_1.protectedProcedure
+        .input(createSectionSchema)
+        .mutation(async ({ ctx, input }) => {
+        if (!ctx.user) {
+            throw new server_1.TRPCError({
+                code: "UNAUTHORIZED",
+                message: "User must be authenticated",
+            });
+        }
+        // Verify user is a teacher of the class
+        const classData = await prisma_1.prisma.class.findFirst({
+            where: {
+                id: input.classId,
+                teachers: {
+                    some: {
+                        id: ctx.user.id,
+                    },
+                },
+            },
+        });
+        if (!classData) {
+            throw new server_1.TRPCError({
+                code: "NOT_FOUND",
+                message: "Class not found or you are not a teacher",
+            });
+        }
+        const section = await prisma_1.prisma.section.create({
+            data: {
+                name: input.name,
+                class: {
+                    connect: { id: input.classId },
+                },
+            },
+        });
+        return section;
+    }),
+    update: trpc_1.protectedProcedure
+        .input(updateSectionSchema)
+        .mutation(async ({ ctx, input }) => {
+        if (!ctx.user) {
+            throw new server_1.TRPCError({
+                code: "UNAUTHORIZED",
+                message: "User must be authenticated",
+            });
+        }
+        // Verify user is a teacher of the class
+        const classData = await prisma_1.prisma.class.findFirst({
+            where: {
+                id: input.classId,
+                teachers: {
+                    some: {
+                        id: ctx.user.id,
+                    },
+                },
+            },
+        });
+        if (!classData) {
+            throw new server_1.TRPCError({
+                code: "NOT_FOUND",
+                message: "Class not found or you are not a teacher",
+            });
+        }
+        const section = await prisma_1.prisma.section.update({
+            where: { id: input.id },
+            data: {
+                name: input.name,
+            },
+        });
+        return section;
+    }),
+    delete: trpc_1.protectedProcedure
+        .input(deleteSectionSchema)
+        .mutation(async ({ ctx, input }) => {
+        if (!ctx.user) {
+            throw new server_1.TRPCError({
+                code: "UNAUTHORIZED",
+                message: "User must be authenticated",
+            });
+        }
+        // Verify user is a teacher of the class
+        const classData = await prisma_1.prisma.class.findFirst({
+            where: {
+                id: input.classId,
+                teachers: {
+                    some: {
+                        id: ctx.user.id,
+                    },
+                },
+            },
+        });
+        if (!classData) {
+            throw new server_1.TRPCError({
+                code: "NOT_FOUND",
+                message: "Class not found or you are not a teacher",
+            });
+        }
+        await prisma_1.prisma.section.delete({
+            where: { id: input.id },
+        });
+        return { id: input.id };
+    }),
+});

package/dist/routers/user.d.ts

@@ -0,0 +1,49 @@
+import { z } from "zod";
+export declare const userRouter: import("@trpc/server/dist/unstable-core-do-not-import").BuiltRouter<{
+    ctx: import("../trpc").Context;
+    meta: object;
+    errorShape: {
+        data: {
+            zodError: z.typeToFlattenedError<any, string> | null;
+            code: import("@trpc/server/dist/unstable-core-do-not-import").TRPC_ERROR_CODE_KEY;
+            httpStatus: number;
+            path?: string;
+            stack?: string;
+        };
+        message: string;
+        code: import("@trpc/server/dist/unstable-core-do-not-import").TRPC_ERROR_CODE_NUMBER;
+    };
+    transformer: false;
+}, import("@trpc/server/dist/unstable-core-do-not-import").DecorateCreateRouterOptions<{
+    getProfile: import("@trpc/server").TRPCQueryProcedure<{
+        input: void;
+        output: {
+            id: string;
+            username: string;
+            profile: {
+                id: string;
+                userId: string;
+            } | null;
+        };
+    }>;
+    updateProfile: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            profile: Record<string, any>;
+            profilePicture?: {
+                type: string;
+                name: string;
+                data: string;
+                size: number;
+            } | undefined;
+        };
+        output: {
+            id: string;
+            username: string;
+            profile: {
+                id: string;
+                userId: string;
+            } | null;
+        };
+    }>;
+}>>;
+//# sourceMappingURL=user.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"user.d.ts","sourceRoot":"","sources":["../../src/routers/user.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAkBxB,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+DrB,CAAC"}

package/dist/routers/user.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.userRouter = void 0;
+const zod_1 = require("zod");
+const trpc_1 = require("../trpc");
+const server_1 = require("@trpc/server");
+const prisma_1 = require("@lib/prisma");
+const fileUpload_1 = require("@lib/fileUpload");
+const fileSchema = zod_1.z.object({
+    name: zod_1.z.string(),
+    type: zod_1.z.string(),
+    size: zod_1.z.number(),
+    data: zod_1.z.string(), // base64 encoded file data
+});
+const updateProfileSchema = zod_1.z.object({
+    profile: zod_1.z.record(zod_1.z.any()),
+    profilePicture: fileSchema.optional(),
+});
+exports.userRouter = (0, trpc_1.createTRPCRouter)({
+    getProfile: trpc_1.protectedProcedure
+        .query(async ({ ctx }) => {
+        if (!ctx.user) {
+            throw new server_1.TRPCError({
+                code: "UNAUTHORIZED",
+                message: "User must be authenticated",
+            });
+        }
+        const user = await prisma_1.prisma.user.findUnique({
+            where: { id: ctx.user.id },
+            select: {
+                id: true,
+                username: true,
+                profile: true,
+            },
+        });
+        if (!user) {
+            throw new server_1.TRPCError({
+                code: "NOT_FOUND",
+                message: "User not found",
+            });
+        }
+        return user;
+    }),
+    updateProfile: trpc_1.protectedProcedure
+        .input(updateProfileSchema)
+        .mutation(async ({ ctx, input }) => {
+        if (!ctx.user) {
+            throw new server_1.TRPCError({
+                code: "UNAUTHORIZED",
+                message: "User must be authenticated",
+            });
+        }
+        let uploadedFiles = [];
+        if (input.profilePicture) {
+            // Store profile picture in a user-specific directory
+            uploadedFiles = await (0, fileUpload_1.uploadFiles)([input.profilePicture], ctx.user.id, `users/${ctx.user.id}/profile`);
+            // Add profile picture path to profile data
+            input.profile.profilePicture = uploadedFiles[0].path;
+            input.profile.profilePictureThumbnail = uploadedFiles[0].thumbnailId;
+        }
+        const updatedUser = await prisma_1.prisma.user.update({
+            where: { id: ctx.user.id },
+            data: {
+                profile: input.profile,
+            },
+            select: {
+                id: true,
+                username: true,
+                profile: true,
+            },
+        });
+        return updatedUser;
+    }),
+});

package/dist/socket/handlers.d.ts

@@ -0,0 +1,3 @@
+import { Server } from 'socket.io';
+export declare const setupSocketHandlers: (io: Server) => void;
+//# sourceMappingURL=handlers.d.ts.map

package/dist/socket/handlers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handlers.d.ts","sourceRoot":"","sources":["../../src/socket/handlers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAU,MAAM,EAAE,MAAM,WAAW,CAAC;AAG3C,eAAO,MAAM,mBAAmB,GAAI,IAAI,MAAM,SA2I7C,CAAC"}

package/dist/socket/handlers.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupSocketHandlers = void 0;
+const logger_1 = require("../utils/logger");
+const setupSocketHandlers = (io) => {
+    io.on('connection', (socket) => {
+        logger_1.logger.info('Client connected', { socketId: socket.id });
+        socket.on('disconnect', (reason) => {
+            logger_1.logger.info('Client disconnected', { socketId: socket.id, reason });
+        });
+        socket.on('error', (error) => {
+            logger_1.logger.error('Socket error', { socketId: socket.id, error });
+        });
+        // Class Room Management
+        socket.on('create-class', (data) => {
+            io.emit('class-created', data.class);
+            logger_1.logger.info('Class created', { class: data.class });
+        });
+        socket.on('delete-class', (data) => {
+            io.emit('class-deleted', data.classId);
+            logger_1.logger.info('Class deleted', { classId: data.classId });
+        });
+        socket.on('update-class', (data) => {
+            io.emit('class-updated', data.class);
+            logger_1.logger.info('Class updated', { class: data.class });
+        });
+        socket.on('join-class', (classId, callback) => {
+            try {
+                socket.join(`class-${classId}`);
+                logger_1.logger.info('Client joined class room', { socketId: socket.id, classId });
+                if (callback) {
+                    callback(classId);
+                }
+                else {
+                    socket.emit('joined-class', classId);
+                }
+            }
+            catch (error) {
+                logger_1.logger.error('Error joining class room', { socketId: socket.id, classId, error });
+                if (callback) {
+                    callback(null);
+                }
+            }
+        });
+        // Assignment Events
+        socket.on('assignment-create', (data) => {
+            if (data.classId && data.assignment) {
+                io.in(`class-${data.classId}`).emit('assignment-created', data.assignment);
+                logger_1.logger.info('Assignment created', { classId: data.classId, assignmentId: data.assignment.id });
+            }
+            else {
+                logger_1.logger.error('Invalid assignment data format', { data });
+            }
+        });
+        socket.on('assignment-update', (data) => {
+            io.in(`class-${data.classId}`).emit('assignment-updated', data.assignment);
+            logger_1.logger.info('Assignment updated', { classId: data.classId, assignmentId: data.assignment.id });
+        });
+        socket.on('assignment-delete', (data) => {
+            io.in(`class-${data.classId}`).emit('assignment-deleted', data.assignmentId);
+            logger_1.logger.info('Assignment deleted', { classId: data.classId, assignmentId: data.assignmentId });
+        });
+        // Submission Events
+        socket.on('submission-update', (data) => {
+            io.in(`class-${data.classId}`).emit('submission-updated', data.submission);
+            logger_1.logger.info('Submission updated', { classId: data.classId, submissionId: data.submission.id });
+        });
+        // Announcement Events
+        socket.on('new-announcement', (data) => {
+            io.in(`class-${data.classId}`).emit('announcement-created', data.announcement);
+            logger_1.logger.info('New announcement created', { classId: data.classId, announcementId: data.announcement.id });
+        });
+        // Section Events
+        socket.on('section-create', (data) => {
+            io.in(`class-${data.classId}`).emit('section-created', data.section);
+            logger_1.logger.info('Section created', { classId: data.classId, sectionId: data.section.id });
+        });
+        socket.on('section-update', (data) => {
+            io.in(`class-${data.classId}`).emit('section-updated', data.section);
+            logger_1.logger.info('Section updated', { classId: data.classId, sectionId: data.section.id });
+        });
+        socket.on('section-delete', (data) => {
+            io.in(`class-${data.classId}`).emit('section-deleted', data.sectionId);
+            logger_1.logger.info('Section deleted', { classId: data.classId, sectionId: data.sectionId });
+        });
+        // Member Events
+        socket.on('member-update', (data) => {
+            io.in(`class-${data.classId}`).emit('member-updated', data.member);
+            logger_1.logger.info('Member updated', { classId: data.classId, memberId: data.member.id });
+        });
+        socket.on('member-delete', (data) => {
+            io.in(`class-${data.classId}`).emit('member-deleted', data.memberId);
+            logger_1.logger.info('Member deleted', { classId: data.classId, memberId: data.memberId });
+        });
+        // Attendance Events
+        socket.on('attendance-update', (data) => {
+            io.in(`class-${data.classId}`).emit('attendance-updated', data.attendance);
+            logger_1.logger.info('Attendance updated', { classId: data.classId, attendanceId: data.attendance.id });
+        });
+        // Event Events
+        socket.on('event-create', (data) => {
+            if (data.classId) {
+                io.in(`class-${data.classId}`).emit('event-created', data.event);
+            }
+            else {
+                io.emit('event-created', data.event);
+            }
+            logger_1.logger.info('Event created', { classId: data.classId, eventId: data.event.id });
+        });
+        socket.on('event-update', (data) => {
+            if (data.classId) {
+                io.in(`class-${data.classId}`).emit('event-updated', data.event);
+            }
+            else {
+                io.emit('event-updated', data.event);
+            }
+            logger_1.logger.info('Event updated', { classId: data.classId, eventId: data.event.id });
+        });
+        socket.on('event-delete', (data) => {
+            if (data.classId) {
+                io.in(`class-${data.classId}`).emit('event-deleted', data.eventId);
+            }
+            else {
+                io.emit('event-deleted', data.eventId);
+            }
+            logger_1.logger.info('Event deleted', { classId: data.classId, eventId: data.eventId });
+        });
+    });
+};
+exports.setupSocketHandlers = setupSocketHandlers;

package/dist/trpc.d.ts

@@ -0,0 +1,147 @@
+import { Request, Response } from 'express';
+import { z } from 'zod';
+interface CreateContextOptions {
+    req: Request;
+    res: Response;
+}
+export type Context = {
+    req: Request;
+    res: Response;
+    user: {
+        id: string;
+    } | null;
+    meta?: {
+        classId?: string;
+        institutionId?: string;
+    };
+};
+export declare const createTRPCContext: (opts: CreateContextOptions) => Promise<Context>;
+export declare const t: {
+    _config: import("@trpc/server/dist/unstable-core-do-not-import").RootConfig<{
+        ctx: Context;
+        meta: object;
+        errorShape: {
+            data: {
+                zodError: z.typeToFlattenedError<any, string> | null;
+                code: import("@trpc/server/dist/unstable-core-do-not-import").TRPC_ERROR_CODE_KEY;
+                httpStatus: number;
+                path?: string;
+                stack?: string;
+            };
+            message: string;
+            code: import("@trpc/server/dist/unstable-core-do-not-import").TRPC_ERROR_CODE_NUMBER;
+        };
+        transformer: false;
+    }>;
+    procedure: import("@trpc/server/dist/unstable-core-do-not-import").ProcedureBuilder<Context, object, object, typeof import("@trpc/server/dist/unstable-core-do-not-import").unsetMarker, typeof import("@trpc/server/dist/unstable-core-do-not-import").unsetMarker, typeof import("@trpc/server/dist/unstable-core-do-not-import").unsetMarker, typeof import("@trpc/server/dist/unstable-core-do-not-import").unsetMarker, false>;
+    middleware: <$ContextOverrides>(fn: import("@trpc/server/dist/unstable-core-do-not-import").MiddlewareFunction<Context, object, object, $ContextOverrides, unknown>) => import("@trpc/server/dist/unstable-core-do-not-import").MiddlewareBuilder<Context, object, $ContextOverrides, unknown>;
+    router: <TInput extends import("@trpc/server/dist/unstable-core-do-not-import").CreateRouterOptions>(input: TInput) => import("@trpc/server/dist/unstable-core-do-not-import").BuiltRouter<{
+        ctx: Context;
+        meta: object;
+        errorShape: {
+            data: {
+                zodError: z.typeToFlattenedError<any, string> | null;
+                code: import("@trpc/server/dist/unstable-core-do-not-import").TRPC_ERROR_CODE_KEY;
+                httpStatus: number;
+                path?: string;
+                stack?: string;
+            };
+            message: string;
+            code: import("@trpc/server/dist/unstable-core-do-not-import").TRPC_ERROR_CODE_NUMBER;
+        };
+        transformer: false;
+    }, import("@trpc/server/dist/unstable-core-do-not-import").DecorateCreateRouterOptions<TInput>>;
+    mergeRouters: typeof import("@trpc/server/dist/unstable-core-do-not-import").mergeRouters;
+    createCallerFactory: <TRecord extends import("@trpc/server").RouterRecord>(router: Pick<import("@trpc/server/dist/unstable-core-do-not-import").Router<{
+        ctx: Context;
+        meta: object;
+        errorShape: {
+            data: {
+                zodError: z.typeToFlattenedError<any, string> | null;
+                code: import("@trpc/server/dist/unstable-core-do-not-import").TRPC_ERROR_CODE_KEY;
+                httpStatus: number;
+                path?: string;
+                stack?: string;
+            };
+            message: string;
+            code: import("@trpc/server/dist/unstable-core-do-not-import").TRPC_ERROR_CODE_NUMBER;
+        };
+        transformer: false;
+    }, TRecord>, "_def">) => import("@trpc/server/dist/unstable-core-do-not-import").RouterCaller<{
+        ctx: Context;
+        meta: object;
+        errorShape: {
+            data: {
+                zodError: z.typeToFlattenedError<any, string> | null;
+                code: import("@trpc/server/dist/unstable-core-do-not-import").TRPC_ERROR_CODE_KEY;
+                httpStatus: number;
+                path?: string;
+                stack?: string;
+            };
+            message: string;
+            code: import("@trpc/server/dist/unstable-core-do-not-import").TRPC_ERROR_CODE_NUMBER;
+        };
+        transformer: false;
+    }, TRecord>;
+};
+export declare const createTRPCRouter: <TInput extends import("@trpc/server/dist/unstable-core-do-not-import").CreateRouterOptions>(input: TInput) => import("@trpc/server/dist/unstable-core-do-not-import").BuiltRouter<{
+    ctx: Context;
+    meta: object;
+    errorShape: {
+        data: {
+            zodError: z.typeToFlattenedError<any, string> | null;
+            code: import("@trpc/server/dist/unstable-core-do-not-import").TRPC_ERROR_CODE_KEY;
+            httpStatus: number;
+            path?: string;
+            stack?: string;
+        };
+        message: string;
+        code: import("@trpc/server/dist/unstable-core-do-not-import").TRPC_ERROR_CODE_NUMBER;
+    };
+    transformer: false;
+}, import("@trpc/server/dist/unstable-core-do-not-import").DecorateCreateRouterOptions<TInput>>;
+export declare const publicProcedure: import("@trpc/server/dist/unstable-core-do-not-import").ProcedureBuilder<Context, object, {}, typeof import("@trpc/server/dist/unstable-core-do-not-import").unsetMarker, typeof import("@trpc/server/dist/unstable-core-do-not-import").unsetMarker, typeof import("@trpc/server/dist/unstable-core-do-not-import").unsetMarker, typeof import("@trpc/server/dist/unstable-core-do-not-import").unsetMarker, false>;
+export declare const protectedProcedure: import("@trpc/server/dist/unstable-core-do-not-import").ProcedureBuilder<Context, object, {}, typeof import("@trpc/server/dist/unstable-core-do-not-import").unsetMarker, typeof import("@trpc/server/dist/unstable-core-do-not-import").unsetMarker, typeof import("@trpc/server/dist/unstable-core-do-not-import").unsetMarker, typeof import("@trpc/server/dist/unstable-core-do-not-import").unsetMarker, false>;
+export declare const protectedClassMemberProcedure: import("@trpc/server/dist/unstable-core-do-not-import").ProcedureBuilder<Context, object, {}, z.objectInputType<{
+    classId: z.ZodString;
+}, z.ZodTypeAny, "passthrough">, z.objectOutputType<{
+    classId: z.ZodString;
+}, z.ZodTypeAny, "passthrough">, typeof import("@trpc/server/dist/unstable-core-do-not-import").unsetMarker, typeof import("@trpc/server/dist/unstable-core-do-not-import").unsetMarker, false>;
+export declare const protectedTeacherProcedure: import("@trpc/server/dist/unstable-core-do-not-import").ProcedureBuilder<Context, object, {}, z.objectInputType<{
+    classId: z.ZodString;
+}, z.ZodTypeAny, "passthrough">, z.objectOutputType<{
+    classId: z.ZodString;
+}, z.ZodTypeAny, "passthrough">, typeof import("@trpc/server/dist/unstable-core-do-not-import").unsetMarker, typeof import("@trpc/server/dist/unstable-core-do-not-import").unsetMarker, false>;
+export declare const createCallerFactory: <TRecord extends import("@trpc/server").RouterRecord>(router: Pick<import("@trpc/server/dist/unstable-core-do-not-import").Router<{
+    ctx: Context;
+    meta: object;
+    errorShape: {
+        data: {
+            zodError: z.typeToFlattenedError<any, string> | null;
+            code: import("@trpc/server/dist/unstable-core-do-not-import").TRPC_ERROR_CODE_KEY;
+            httpStatus: number;
+            path?: string;
+            stack?: string;
+        };
+        message: string;
+        code: import("@trpc/server/dist/unstable-core-do-not-import").TRPC_ERROR_CODE_NUMBER;
+    };
+    transformer: false;
+}, TRecord>, "_def">) => import("@trpc/server/dist/unstable-core-do-not-import").RouterCaller<{
+    ctx: Context;
+    meta: object;
+    errorShape: {
+        data: {
+            zodError: z.typeToFlattenedError<any, string> | null;
+            code: import("@trpc/server/dist/unstable-core-do-not-import").TRPC_ERROR_CODE_KEY;
+            httpStatus: number;
+            path?: string;
+            stack?: string;
+        };
+        message: string;
+        code: import("@trpc/server/dist/unstable-core-do-not-import").TRPC_ERROR_CODE_NUMBER;
+    };
+    transformer: false;
+}, TRecord>;
+export {};
+//# sourceMappingURL=trpc.d.ts.map

package/dist/trpc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trpc.d.ts","sourceRoot":"","sources":["../src/trpc.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAC5C,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,UAAU,oBAAoB;IAC5B,GAAG,EAAE,OAAO,CAAC;IACb,GAAG,EAAE,QAAQ,CAAC;CACf;AAED,MAAM,MAAM,OAAO,GAAG;IACpB,GAAG,EAAE,OAAO,CAAC;IACb,GAAG,EAAE,QAAQ,CAAC;IACd,IAAI,EAAE;QAAE,EAAE,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC;IAC5B,IAAI,CAAC,EAAE;QACL,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,aAAa,CAAC,EAAE,MAAM,CAAC;KACxB,CAAC;CACH,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAAU,MAAM,oBAAoB,KAAG,OAAO,CAAC,OAAO,CAwBnF,CAAC;AAEF,eAAO,MAAM,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkBZ,CAAC;AAOH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;+FAAW,CAAC;AACzC,eAAO,MAAM,eAAe,sZAAqC,CAAC;AAGlE,eAAO,MAAM,kBAAkB,sZAAgC,CAAC;AAChE,eAAO,MAAM,6BAA6B;;;;+LAEnB,CAAC;AACxB,eAAO,MAAM,yBAAyB;;;;+LAEd,CAAC;AAIzB,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAAwB,CAAC"}

package/dist/trpc.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCallerFactory = exports.protectedTeacherProcedure = exports.protectedClassMemberProcedure = exports.protectedProcedure = exports.publicProcedure = exports.createTRPCRouter = exports.t = exports.createTRPCContext = void 0;
+const server_1 = require("@trpc/server");
+const zod_1 = require("zod");
+const logger_1 = require("@utils/logger");
+const prisma_1 = require("@lib/prisma");
+const logging_1 = require("./middleware/logging");
+const auth_1 = require("./middleware/auth");
+const zod_2 = require("zod");
+const createTRPCContext = async (opts) => {
+    const { req, res } = opts;
+    // Get user from session/token
+    const token = req.headers.authorization?.split(' ')[1];
+    const user = token ? await prisma_1.prisma.user.findFirst({
+        where: {
+            sessions: {
+                some: {
+                    id: token
+                }
+            },
+        },
+        select: {
+            id: true,
+        }
+    }) : null;
+    return {
+        req,
+        res,
+        user,
+        meta: {},
+    };
+};
+exports.createTRPCContext = createTRPCContext;
+exports.t = server_1.initTRPC.context().create({
+    errorFormatter({ shape, error }) {
+        logger_1.logger.error('tRPC Error', {
+            code: shape.code,
+            message: error.message,
+            cause: error.cause,
+            stack: error.stack,
+        });
+        return {
+            ...shape,
+            data: {
+                ...shape.data,
+                zodError: error.cause instanceof zod_1.ZodError ? error.cause.flatten() : null,
+            },
+        };
+    },
+});
+// Create middleware
+const loggingMiddleware = (0, logging_1.createLoggingMiddleware)(exports.t);
+const { isAuthed, isMemberInClass, isTeacherInClass } = (0, auth_1.createAuthMiddleware)(exports.t);
+// Base procedures
+exports.createTRPCRouter = exports.t.router;
+exports.publicProcedure = exports.t.procedure.use(loggingMiddleware);
+// Protected procedures
+exports.protectedProcedure = exports.publicProcedure.use(isAuthed);
+exports.protectedClassMemberProcedure = exports.protectedProcedure
+    .input(zod_2.z.object({ classId: zod_2.z.string() }).passthrough())
+    .use(isMemberInClass);
+exports.protectedTeacherProcedure = exports.protectedProcedure
+    .input(zod_2.z.object({ classId: zod_2.z.string() }).passthrough())
+    .use(isTeacherInClass);
+// Create caller factory
+exports.createCallerFactory = exports.t.createCallerFactory;

package/dist/types/trpc.d.ts

@@ -0,0 +1,16 @@
+import { inferAsyncReturnType } from '@trpc/server';
+import { createTRPCContext } from '../trpc';
+export type Context = inferAsyncReturnType<typeof createTRPCContext> & {
+    isTeacher?: boolean;
+    teacherClassIds?: string[];
+};
+export interface MiddlewareContext {
+    ctx: Context;
+    next: (opts?: {
+        ctx: Partial<Context>;
+    }) => Promise<any>;
+    input?: any;
+    path?: string;
+    type?: string;
+}
+//# sourceMappingURL=trpc.d.ts.map

package/dist/types/trpc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trpc.d.ts","sourceRoot":"","sources":["../../src/types/trpc.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAC;AACpD,OAAO,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAE5C,MAAM,MAAM,OAAO,GAAG,oBAAoB,CAAC,OAAO,iBAAiB,CAAC,GAAG;IACrE,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;CAC5B,CAAC;AAEF,MAAM,WAAW,iBAAiB;IAChC,GAAG,EAAE,OAAO,CAAC;IACb,IAAI,EAAE,CAAC,IAAI,CAAC,EAAE;QAAE,GAAG,EAAE,OAAO,CAAC,OAAO,CAAC,CAAA;KAAE,KAAK,OAAO,CAAC,GAAG,CAAC,CAAC;IACzD,KAAK,CAAC,EAAE,GAAG,CAAC;IACZ,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;CACf"}

package/dist/types/trpc.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/email.d.ts

@@ -0,0 +1,3 @@
+import nodemailer from 'nodemailer';
+export declare const transport: nodemailer.Transporter<import("nodemailer/lib/smtp-transport").SentMessageInfo, import("nodemailer/lib/smtp-transport").Options>;
+//# sourceMappingURL=email.d.ts.map

package/dist/utils/email.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"email.d.ts","sourceRoot":"","sources":["../../src/utils/email.ts"],"names":[],"mappings":"AAAA,OAAO,UAAU,MAAM,YAAY,CAAC;AAEpC,eAAO,MAAM,SAAS,kIAQlB,CAAC"}

package/dist/utils/email.js

@@ -0,0 +1,16 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transport = void 0;
+const nodemailer_1 = __importDefault(require("nodemailer"));
+exports.transport = nodemailer_1.default.createTransport({
+    host: process.env.EMAIL_HOST,
+    port: 587,
+    secure: false,
+    auth: {
+        user: process.env.EMAIL_USER,
+        pass: process.env.EMAIL_PASS,
+    },
+});

package/dist/utils/generateInviteCode.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Generates a random invite code
+ * @returns {string} The invite code with length 5
+ */
+export declare const generateInviteCode: () => string;
+//# sourceMappingURL=generateInviteCode.d.ts.map