@studious-lms/server 1.2.53 → 1.3.0

package/src/services/notification.ts

@@ -0,0 +1,50 @@
+/**
+ * Notification service – list, send, and mark notifications as read.
+ */
+import {
+  findNotificationsByReceiverId,
+  findNotificationById,
+  createNotification,
+  createManyNotifications,
+  markNotificationAsRead,
+} from "../models/notification.js";
+
+/** List notifications for a user. */
+export async function listNotifications(userId: string) {
+  return findNotificationsByReceiverId(userId);
+}
+
+/** Get a single notification by ID. */
+export async function getNotification(id: string) {
+  return findNotificationById(id);
+}
+
+/** Send a notification to one user. */
+export async function sendNotification(input: {
+  receiverId: string;
+  title: string;
+  content: string;
+}) {
+  return createNotification(input);
+}
+
+/** Send the same notification to multiple users. */
+export async function sendToMultiple(input: {
+  receiverIds: string[];
+  title: string;
+  content: string;
+}) {
+  const result = await createManyNotifications(
+    input.receiverIds.map((receiverId) => ({
+      receiverId,
+      title: input.title,
+      content: input.content,
+    }))
+  );
+  return result;
+}
+
+/** Mark a notification as read. */
+export async function markAsRead(id: string) {
+  return markNotificationAsRead(id);
+}

package/src/services/section.ts

@@ -0,0 +1,283 @@
+/**
+ * Section service – CRUD for class sections. Handles reordering of sections
+ * and assignments in a unified list.
+ */
+import { TRPCError } from "@trpc/server";
+import {
+  findSectionById,
+  findClassWithTeacher,
+  createSection,
+  findSectionsByClassId,
+  findAssignmentsByClassId,
+  updateSectionOrder,
+  updateAssignmentOrder,
+  updateSection,
+  deleteSectionById,
+  findSectionByClassAndId,
+} from "../models/section.js";
+import { prisma } from "../lib/prisma.js";
+
+/** Check if a section exists. */
+export async function sectionExists(id: string) {
+  const section = await findSectionById(id);
+  return !!section;
+}
+
+/** Create a section and reorder the unified section/assignment list. */
+export async function createSectionRecord(
+  userId: string,
+  input: {
+    classId: string;
+    id?: string;
+    name: string;
+    color?: string;
+  }
+) {
+  const classData = await findClassWithTeacher(input.classId, userId);
+  if (!classData) {
+    throw new TRPCError({
+      code: "NOT_FOUND",
+      message: "Class not found or you are not a teacher",
+    });
+  }
+
+  const section = await createSection({
+    id: input.id,
+    name: input.name,
+    order: 0,
+    classId: input.classId,
+    color: input.color,
+  });
+
+  const [sections, assignments] = await Promise.all([
+    findSectionsByClassId(input.classId),
+    findAssignmentsByClassId(input.classId),
+  ]);
+
+  const unified = [
+    ...sections.map((s) => ({ id: s.id, order: s.order, type: "section" as const })),
+    ...assignments.map((a) => ({ id: a.id, order: a.order, type: "assignment" as const })),
+  ].sort((a, b) => (a.order ?? Number.MAX_SAFE_INTEGER) - (b.order ?? Number.MAX_SAFE_INTEGER));
+
+  const withoutNew = unified.filter(
+    (item) => !(item.id === section.id && item.type === "section")
+  );
+  const reindexed = [
+    { id: section.id, type: "section" as const },
+    ...withoutNew.map((item) => ({ id: item.id, type: item.type })),
+  ];
+
+  await Promise.all(
+    reindexed.map((item, index) =>
+      item.type === "section"
+        ? updateSectionOrder(item.id, index + 1)
+        : updateAssignmentOrder(item.id, index + 1)
+    )
+  );
+
+  return section;
+}
+
+export async function reorderSection(
+  userId: string,
+  input: {
+    classId: string;
+    movedId: string;
+    position: "start" | "end" | "before" | "after";
+    targetId?: string;
+  }
+) {
+  const classData = await findClassWithTeacher(input.classId, userId);
+  if (!classData) {
+    throw new TRPCError({
+      code: "UNAUTHORIZED",
+      message: "Not authorized",
+    });
+  }
+
+  const moved = await findSectionByClassAndId(input.movedId, input.classId);
+  if (!moved) {
+    throw new TRPCError({
+      code: "NOT_FOUND",
+      message: "Section not found",
+    });
+  }
+
+  if (
+    (input.position === "before" || input.position === "after") &&
+    !input.targetId
+  ) {
+    throw new TRPCError({
+      code: "BAD_REQUEST",
+      message: "targetId required for before/after",
+    });
+  }
+
+  const result = await prisma.$transaction(async (tx) => {
+    const [sections, assignments] = await Promise.all([
+      tx.section.findMany({
+        where: { classId: input.classId },
+        select: { id: true, order: true },
+      }),
+      tx.assignment.findMany({
+        where: { classId: input.classId },
+        select: { id: true, order: true },
+      }),
+    ]);
+
+    const unified = [
+      ...sections.map((s) => ({ id: s.id, order: s.order, type: "section" as const })),
+      ...assignments.map((a) => ({ id: a.id, order: a.order, type: "assignment" as const })),
+    ].sort((a, b) => (a.order ?? Number.MAX_SAFE_INTEGER) - (b.order ?? Number.MAX_SAFE_INTEGER));
+
+    const movedIdx = unified.findIndex(
+      (item) => item.id === input.movedId && item.type === "section"
+    );
+    if (movedIdx === -1) {
+      throw new TRPCError({
+        code: "NOT_FOUND",
+        message: "Section not found in unified list",
+      });
+    }
+
+    const withoutMoved = unified.filter(
+      (item) => !(item.id === input.movedId && item.type === "section")
+    );
+
+    let next: Array<{ id: string; type: "section" | "assignment" }> = [];
+
+    if (input.position === "start") {
+      next = [
+        { id: input.movedId, type: "section" },
+        ...withoutMoved.map((item) => ({ id: item.id, type: item.type })),
+      ];
+    } else if (input.position === "end") {
+      next = [
+        ...withoutMoved.map((item) => ({ id: item.id, type: item.type })),
+        { id: input.movedId, type: "section" },
+      ];
+    } else {
+      const targetIdx = withoutMoved.findIndex((item) => item.id === input.targetId);
+      if (targetIdx === -1) {
+        throw new TRPCError({
+          code: "BAD_REQUEST",
+          message: "targetId not found in unified list",
+        });
+      }
+      if (input.position === "before") {
+        next = [
+          ...withoutMoved.slice(0, targetIdx).map((item) => ({ id: item.id, type: item.type })),
+          { id: input.movedId, type: "section" },
+          ...withoutMoved.slice(targetIdx).map((item) => ({ id: item.id, type: item.type })),
+        ];
+      } else {
+        next = [
+          ...withoutMoved
+            .slice(0, targetIdx + 1)
+            .map((item) => ({ id: item.id, type: item.type })),
+          { id: input.movedId, type: "section" },
+          ...withoutMoved
+            .slice(targetIdx + 1)
+            .map((item) => ({ id: item.id, type: item.type })),
+        ];
+      }
+    }
+
+    await Promise.all(
+      next.map((item, index) =>
+        item.type === "section"
+          ? tx.section.update({ where: { id: item.id }, data: { order: index + 1 } })
+          : tx.assignment.update({ where: { id: item.id }, data: { order: index + 1 } })
+      )
+    );
+
+    return tx.section.findUnique({ where: { id: input.movedId } });
+  });
+
+  return result;
+}
+
+export async function updateSectionRecord(
+  userId: string,
+  input: {
+    id: string;
+    classId: string;
+    name: string;
+    color?: string;
+  }
+) {
+  const classData = await findClassWithTeacher(input.classId, userId);
+  if (!classData) {
+    throw new TRPCError({
+      code: "NOT_FOUND",
+      message: "Class not found or you are not a teacher",
+    });
+  }
+
+  return updateSection(input.id, {
+    name: input.name,
+    color: input.color,
+  });
+}
+
+export async function reOrderSection(
+  userId: string,
+  input: { id: string; classId: string; order: number }
+) {
+  const classData = await findClassWithTeacher(input.classId, userId);
+  if (!classData) {
+    throw new TRPCError({
+      code: "NOT_FOUND",
+      message: "Class not found or you are not a teacher",
+    });
+  }
+
+  await prisma.$transaction(async (tx) => {
+    await tx.section.update({
+      where: { id: input.id },
+      data: { order: input.order },
+    });
+
+    const [sections, assignments] = await Promise.all([
+      tx.section.findMany({
+        where: { classId: input.classId },
+        select: { id: true, order: true },
+      }),
+      tx.assignment.findMany({
+        where: { classId: input.classId },
+        select: { id: true, order: true },
+      }),
+    ]);
+
+    const unified = [
+      ...sections.map((s) => ({ id: s.id, order: s.order, type: "section" as const })),
+      ...assignments.map((a) => ({ id: a.id, order: a.order, type: "assignment" as const })),
+    ].sort((a, b) => (a.order ?? Number.MAX_SAFE_INTEGER) - (b.order ?? Number.MAX_SAFE_INTEGER));
+
+    await Promise.all(
+      unified.map((item, index) =>
+        item.type === "section"
+          ? tx.section.update({ where: { id: item.id }, data: { order: index + 1 } })
+          : tx.assignment.update({ where: { id: item.id }, data: { order: index + 1 } })
+      )
+    );
+  });
+
+  return { id: input.id };
+}
+
+export async function deleteSectionRecord(
+  userId: string,
+  input: { id: string; classId: string }
+) {
+  const classData = await findClassWithTeacher(input.classId, userId);
+  if (!classData) {
+    throw new TRPCError({
+      code: "NOT_FOUND",
+      message: "Class not found or you are not a teacher",
+    });
+  }
+
+  await deleteSectionById(input.id);
+  return { id: input.id };
+}

package/src/services/user.ts

@@ -0,0 +1,172 @@
+/**
+ * User service – profile get/update, profile picture upload URLs.
+ */
+import { TRPCError } from "@trpc/server";
+import { logger } from "../utils/logger.js";
+import { env } from "../lib/config/env.js";
+import { findUserById, findUserProfileByUserId, upsertUserProfile } from "../models/user.js";
+
+function getFileUrl(filePath: string | null): string | null {
+  if (!filePath) return null;
+  if (filePath.startsWith("http")) {
+    return filePath;
+  }
+  const backendUrl = env.BACKEND_URL || "http://localhost:3001";
+  return `${backendUrl}/api/files/${encodeURIComponent(filePath)}`;
+}
+
+/** Get user profile with display info and profile picture URLs. */
+export async function getProfile(userId: string) {
+  const user = await findUserById(userId);
+  if (!user) {
+    throw new TRPCError({
+      code: "NOT_FOUND",
+      message: "User not found",
+    });
+  }
+
+  const userProfile = await findUserProfileByUserId(userId);
+
+  return {
+    id: user.id,
+    username: user.username,
+    profile: userProfile
+      ? {
+          displayName: (userProfile as any).displayName || null,
+          bio: (userProfile as any).bio || null,
+          location: (userProfile as any).location || null,
+          website: (userProfile as any).website || null,
+          profilePicture: getFileUrl((userProfile as any).profilePicture),
+          profilePictureThumbnail: getFileUrl(
+            (userProfile as any).profilePictureThumbnail
+          ),
+        }
+      : {
+          displayName: null,
+          bio: null,
+          location: null,
+          website: null,
+          profilePicture: null,
+          profilePictureThumbnail: null,
+        },
+  };
+}
+
+/** Update user profile (display name, bio, etc.) and/or profile picture. */
+export async function updateProfile(
+  userId: string,
+  input: {
+    profile?: {
+      displayName?: string | null;
+      bio?: string | null;
+      location?: string | null;
+      website?: string | null;
+    };
+    profilePicture?: {
+      filePath: string;
+      fileName: string;
+      fileType: string;
+      fileSize: number;
+    };
+    dicebearAvatar?: { url: string };
+  }
+) {
+  let profilePictureUrl: string | null = null;
+  let profilePictureThumbnail: string | null = null;
+
+  if (input.profilePicture) {
+    try {
+      profilePictureUrl = input.profilePicture.filePath;
+      profilePictureThumbnail = null;
+    } catch (error) {
+      logger.error("Profile picture processing failed", {
+        userId,
+        error: error instanceof Error ? error.message : "Unknown error",
+      });
+      throw new TRPCError({
+        code: "INTERNAL_SERVER_ERROR",
+        message: "Failed to process profile picture. Please try again.",
+      });
+    }
+  }
+
+  if (input.dicebearAvatar) {
+    profilePictureUrl = input.dicebearAvatar.url;
+    profilePictureThumbnail = null;
+  }
+
+  const updateData: any = {};
+  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;
+
+  const updatedProfile = await upsertUserProfile(userId, updateData);
+  const user = await findUserById(userId);
+
+  return {
+    id: userId,
+    username: user?.username || "",
+    profile: {
+      displayName: (updatedProfile as any).displayName || null,
+      bio: (updatedProfile as any).bio || null,
+      location: (updatedProfile as any).location || null,
+      website: (updatedProfile as any).website || null,
+      profilePicture: getFileUrl((updatedProfile as any).profilePicture),
+      profilePictureThumbnail: getFileUrl(
+        (updatedProfile as any).profilePictureThumbnail
+      ),
+    },
+  };
+}
+
+export async function getUploadUrl(
+  userId: string,
+  fileName: string,
+  fileType: string
+) {
+  try {
+    const fileExtension = fileName.split(".").pop();
+    const uniqueFilename = `${userId}-${Date.now()}.${fileExtension}`;
+    const filePath = `users/${userId}/profile/${uniqueFilename}`;
+
+    const backendUrl = env.BACKEND_URL || "http://localhost:3001";
+    const uploadUrl = `${backendUrl}/api/upload/${encodeURIComponent(filePath)}`;
+
+    logger.info("Generated upload URL", {
+      userId,
+      filePath,
+      fileName: uniqueFilename,
+      fileType,
+      uploadUrl,
+    });
+
+    return {
+      uploadUrl,
+      filePath,
+      fileName: uniqueFilename,
+    };
+  } catch (error) {
+    logger.error("Failed to generate upload URL", {
+      userId,
+      error: error instanceof Error ? error.message : "Unknown error",
+    });
+    throw new TRPCError({
+      code: "INTERNAL_SERVER_ERROR",
+      message: "Failed to generate upload URL",
+    });
+  }
+}