@studious-lms/server 1.4.4 → 1.4.5

package/src/services/search.ts

@@ -0,0 +1,397 @@
+import { prisma } from "../lib/prisma.js";
+
+type SearchScope =
+  | "class"
+  | "assignment"
+  | "event"
+  | "syllabus"
+  | "worksheet"
+  | "file"
+  | "announcement"
+  | "section";
+
+type SearchResult = {
+  id: string;
+  type: SearchScope;
+  title: string;
+  subtitle: string;
+  classId: string;
+  className: string;
+  href: string;
+  matchedText?: string | null;
+  date?: Date | null;
+};
+
+const SEARCH_LIMIT = 12;
+
+const contains = (query: string) => ({
+  contains: query,
+  mode: "insensitive" as const,
+});
+
+const includesToken = (query: string, ...tokens: string[]) =>
+  tokens.some((token) => token.includes(query.toLowerCase()));
+
+const excerpt = (value: string | null | undefined, query: string) => {
+  if (!value) return null;
+  const trimmed = value.replace(/\s+/g, " ").trim();
+  if (!trimmed) return null;
+  if (!query) return trimmed.slice(0, 140);
+
+  const index = trimmed.toLowerCase().indexOf(query.toLowerCase());
+  if (index < 0) return trimmed.slice(0, 140);
+
+  const start = Math.max(0, index - 48);
+  const end = Math.min(trimmed.length, index + query.length + 92);
+  return `${start > 0 ? "..." : ""}${trimmed.slice(start, end)}${end < trimmed.length ? "..." : ""}`;
+};
+
+const trimResults = (results: SearchResult[], limit: number) =>
+  results
+    .sort((a, b) => {
+      const priority: Record<SearchScope, number> = {
+        class: 0,
+        assignment: 1,
+        event: 2,
+        syllabus: 3,
+        worksheet: 4,
+        file: 5,
+        announcement: 6,
+        section: 7,
+      };
+      const priorityDiff = priority[a.type] - priority[b.type];
+      if (priorityDiff !== 0) return priorityDiff;
+      return (b.date?.getTime() ?? 0) - (a.date?.getTime() ?? 0);
+    })
+    .slice(0, limit);
+
+export async function searchGlobalClasses(
+  userId: string,
+  input: { query?: string; limit?: number }
+) {
+  const rawQuery = input.query?.trim() ?? "";
+  const query = rawQuery.slice(0, 80);
+  const limit = Math.min(Math.max(input.limit ?? SEARCH_LIMIT, 1), 30);
+
+  const memberships = await prisma.class.findMany({
+    where: {
+      OR: [
+        { teachers: { some: { id: userId } } },
+        { students: { some: { id: userId } } },
+      ],
+    },
+    select: {
+      id: true,
+      name: true,
+      section: true,
+      subject: true,
+      syllabus: true,
+      teachers: { where: { id: userId }, select: { id: true } },
+      students: { where: { id: userId }, select: { id: true } },
+    },
+  });
+
+  const allClassIds = memberships.map((cls) => cls.id);
+  if (allClassIds.length === 0) {
+    return { query, results: [] as SearchResult[] };
+  }
+
+  const teacherClassIds = memberships
+    .filter((cls) => cls.teachers.length > 0)
+    .map((cls) => cls.id);
+  const studentClassIds = memberships
+    .filter((cls) => cls.students.length > 0 && cls.teachers.length === 0)
+    .map((cls) => cls.id);
+  const classById = new Map(memberships.map((cls) => [cls.id, cls]));
+
+  const queryFilters = query
+    ? {
+        class: [
+          { name: contains(query) },
+          { section: contains(query) },
+          { subject: contains(query) },
+        ],
+        assignment: [
+          { title: contains(query) },
+          { instructions: contains(query) },
+        ],
+        event: [
+          { name: contains(query) },
+          { location: contains(query) },
+          { remarks: contains(query) },
+        ],
+        worksheet: [{ name: contains(query) }],
+        file: [{ name: contains(query) }, { type: contains(query) }],
+        announcement: [{ remarks: contains(query) }],
+        section: [{ name: contains(query) }],
+      }
+    : null;
+
+  const assignmentAccess = [
+    ...(teacherClassIds.length > 0
+      ? [{ classId: { in: teacherClassIds } }]
+      : []),
+    ...(studentClassIds.length > 0
+      ? [
+          {
+            classId: { in: studentClassIds },
+            OR: [
+              { assignedTo: { some: { id: userId } } },
+              { assignedTo: { none: {} } },
+            ],
+          },
+        ]
+      : []),
+  ];
+
+  const [
+    classes,
+    assignments,
+    events,
+    worksheets,
+    files,
+    announcements,
+    sections,
+  ] = await Promise.all([
+    prisma.class.findMany({
+      where: {
+        id: { in: allClassIds },
+        ...(queryFilters ? { OR: queryFilters.class } : {}),
+      },
+      select: { id: true, name: true, section: true, subject: true },
+      take: limit,
+    }),
+    prisma.assignment.findMany({
+      where: {
+        template: false,
+        AND: [
+          ...(queryFilters ? [{ OR: queryFilters.assignment }] : []),
+          ...(assignmentAccess.length > 0 ? [{ OR: assignmentAccess }] : []),
+        ],
+      },
+      select: {
+        id: true,
+        title: true,
+        instructions: true,
+        dueDate: true,
+        modifiedAt: true,
+        classId: true,
+        class: { select: { name: true } },
+      },
+      orderBy: { dueDate: "asc" },
+      take: limit,
+    }),
+    prisma.event.findMany({
+      where: {
+        classId: { in: allClassIds },
+        ...(queryFilters ? { OR: queryFilters.event } : {}),
+      },
+      select: {
+        id: true,
+        name: true,
+        location: true,
+        remarks: true,
+        startTime: true,
+        classId: true,
+        class: { select: { name: true } },
+      },
+      orderBy: { startTime: "asc" },
+      take: limit,
+    }),
+    prisma.worksheet.findMany({
+      where: {
+        classId: { in: allClassIds },
+        ...(queryFilters && !includesToken(query, "worksheet", "worksheets")
+          ? { OR: queryFilters.worksheet }
+          : {}),
+      },
+      select: {
+        id: true,
+        name: true,
+        updatedAt: true,
+        classId: true,
+        class: { select: { name: true } },
+      },
+      orderBy: { updatedAt: "desc" },
+      take: limit,
+    }),
+    prisma.file.findMany({
+      where: {
+        ...(queryFilters ? { OR: queryFilters.file } : {}),
+        AND: [
+          {
+            OR: [
+              { folder: { classId: { in: allClassIds } } },
+              { classDraftId: { in: teacherClassIds } },
+              {
+                assignment: {
+                  OR: assignmentAccess,
+                },
+              },
+              { announcement: { classId: { in: allClassIds } } },
+            ],
+          },
+        ],
+      },
+      select: {
+        id: true,
+        name: true,
+        type: true,
+        uploadedAt: true,
+        folder: { select: { classId: true, class: { select: { name: true } } } },
+        classDraft: { select: { id: true, name: true } },
+        assignment: { select: { classId: true, class: { select: { name: true } } } },
+        announcement: { select: { classId: true, class: { select: { name: true } } } },
+      },
+      orderBy: { uploadedAt: "desc" },
+      take: limit,
+    }),
+    prisma.announcement.findMany({
+      where: {
+        classId: { in: allClassIds },
+        ...(queryFilters ? { OR: queryFilters.announcement } : {}),
+      },
+      select: {
+        id: true,
+        remarks: true,
+        createdAt: true,
+        classId: true,
+        class: { select: { name: true } },
+      },
+      orderBy: { createdAt: "desc" },
+      take: limit,
+    }),
+    prisma.section.findMany({
+      where: {
+        classId: { in: allClassIds },
+        ...(queryFilters && !includesToken(query, "section", "sections", "assignment", "assignments")
+          ? { OR: queryFilters.section }
+          : {}),
+      },
+      select: {
+        id: true,
+        name: true,
+        classId: true,
+        class: { select: { name: true } },
+      },
+      take: limit,
+    }),
+  ]);
+
+  const results: SearchResult[] = [
+    ...classes.map((cls) => ({
+      id: cls.id,
+      type: "class" as const,
+      title: cls.name,
+      subtitle: [cls.subject, cls.section].filter(Boolean).join(" · "),
+      classId: cls.id,
+      className: cls.name,
+      href: `/class/${cls.id}`,
+    })),
+    ...assignments.map((assignment) => ({
+      id: assignment.id,
+      type: "assignment" as const,
+      title: assignment.title,
+      subtitle: `${assignment.class.name} · Assignment`,
+      classId: assignment.classId,
+      className: assignment.class.name,
+      href: `/class/${assignment.classId}/assignment/${assignment.id}`,
+      matchedText: excerpt(assignment.instructions, query),
+      date: assignment.dueDate ?? assignment.modifiedAt,
+    })),
+    ...events.map((event) => ({
+      id: event.id,
+      type: "event" as const,
+      title: event.name || "Untitled event",
+      subtitle: `${event.class?.name ?? "Class"} · Event`,
+      classId: event.classId!,
+      className: event.class?.name ?? "Class",
+      href: `/class/${event.classId}/attendance/${event.id}`,
+      matchedText: excerpt(event.location || event.remarks, query),
+      date: event.startTime,
+    })),
+    ...memberships
+      .filter((cls) => {
+        if (!cls.syllabus) return false;
+        if (!query) return true;
+        return (
+          includesToken(query, "syllabus") ||
+          cls.name.toLowerCase().includes(query.toLowerCase()) ||
+          cls.subject.toLowerCase().includes(query.toLowerCase()) ||
+          cls.syllabus.toLowerCase().includes(query.toLowerCase())
+        );
+      })
+      .slice(0, limit)
+      .map((cls) => ({
+        id: `${cls.id}:syllabus`,
+        type: "syllabus" as const,
+        title: `${cls.name} syllabus`,
+        subtitle: `${cls.subject} · Syllabus`,
+        classId: cls.id,
+        className: cls.name,
+        href: `/class/${cls.id}/syllabus`,
+        matchedText: excerpt(cls.syllabus, query),
+      })),
+    ...worksheets.map((worksheet) => ({
+      id: worksheet.id,
+      type: "worksheet" as const,
+      title: worksheet.name,
+      subtitle: `${worksheet.class?.name ?? "Class"} · Worksheet`,
+      classId: worksheet.classId,
+      className: worksheet.class?.name ?? "Class",
+      href: `/class/${worksheet.classId}/worksheets`,
+      date: worksheet.updatedAt,
+    })),
+    ...files.flatMap((file) => {
+      const classId =
+        file.folder?.classId ??
+        file.classDraft?.id ??
+        file.assignment?.classId ??
+        file.announcement?.classId;
+      const className =
+        file.folder?.class?.name ??
+        file.classDraft?.name ??
+        file.assignment?.class?.name ??
+        file.announcement?.class?.name ??
+        (classId ? classById.get(classId)?.name : undefined);
+
+      if (!classId || !className) return [];
+
+      return [
+        {
+          id: file.id,
+          type: "file" as const,
+          title: file.name,
+          subtitle: `${className} · File`,
+          classId,
+          className,
+          href: `/class/${classId}/files`,
+          matchedText: file.type,
+          date: file.uploadedAt,
+        },
+      ];
+    }),
+    ...announcements.map((announcement) => ({
+      id: announcement.id,
+      type: "announcement" as const,
+      title: excerpt(announcement.remarks, query) ?? "Announcement",
+      subtitle: `${announcement.class.name} · Announcement`,
+      classId: announcement.classId,
+      className: announcement.class.name,
+      href: `/class/${announcement.classId}`,
+      matchedText: excerpt(announcement.remarks, query),
+      date: announcement.createdAt,
+    })),
+    ...sections.map((section) => ({
+      id: section.id,
+      type: "section" as const,
+      title: section.name,
+      subtitle: `${section.class.name} · Section`,
+      classId: section.classId,
+      className: section.class.name,
+      href: `/class/${section.classId}/assignments`,
+    })),
+  ];
+
+  return { query, results: trimResults(results, limit) };
+}

package/tests/routers/conversation.test.ts

@@ -1,17 +1,35 @@
 import { test, expect, describe, beforeAll } from 'vitest';
+import { prisma } from '../../src/lib/prisma';
 import { user1Caller, user2Caller, user3Caller } from '../setup';
 import { expectUnauth } from '../helpers';
 
 describe('Conversation Router', () => {
   let dmConversation: any;
   let groupConversation: any;
+  let user1Id: string;
   let user3Id: string;
+  let hideConversationCounter = 0;
 
   beforeAll(async () => {
-    const profile = await user3Caller.user.getProfile();
-    user3Id = profile.id;
+    const [user1Profile, user3Profile] = await Promise.all([
+      user1Caller.user.getProfile(),
+      user3Caller.user.getProfile(),
+    ]);
+
+    user1Id = user1Profile.id;
+    user3Id = user3Profile.id;
   });
 
+  async function createHideableConversation() {
+    hideConversationCounter += 1;
+
+    return user1Caller.conversation.create({
+      type: 'GROUP',
+      name: `Hide Test Group Chat ${hideConversationCounter}`,
+      memberIds: ['testuser2'],
+    });
+  }
+
   describe('create', () => {
     test('should create a DM conversation', async () => {
       dmConversation = await user1Caller.conversation.create({
@@ -36,6 +54,13 @@ describe('Conversation Router', () => {
       expect(groupConversation.name).toBe('Test Group Chat');
     });
 
+    test('should create a hideable GROUP conversation', async () => {
+      const conversation = await createHideableConversation();
+
+      expect(conversation).toBeDefined();
+      expect(conversation.type).toBe('GROUP');
+    });
+
     test('should fail to create duplicate DM', async () => {
       await expect(
         user1Caller.conversation.create({
@@ -125,6 +150,93 @@ describe('Conversation Router', () => {
     });
   });
 
+  describe('hide', () => {
+    test('should hide a conversation only for the requesting member', async () => {
+      const conversation = await createHideableConversation();
+
+      const result = await user1Caller.conversation.hide({
+        conversationId: conversation.id,
+      });
+
+      expect(result).toEqual({ success: true });
+
+      const membership = await prisma.conversationMember.findUniqueOrThrow({
+        where: {
+          userId_conversationId: {
+            userId: user1Id,
+            conversationId: conversation.id,
+          },
+        },
+        select: { hiddenAt: true },
+      });
+
+      expect(membership.hiddenAt).not.toBeNull();
+
+      const user1Conversations = await user1Caller.conversation.list();
+      const user2Conversations = await user2Caller.conversation.list();
+
+      expect(user1Conversations.map((item) => item.id)).not.toContain(
+        conversation.id,
+      );
+      expect(user2Conversations.map((item) => item.id)).toContain(
+        conversation.id,
+      );
+    });
+
+    test('should keep hidden conversations accessible by id', async () => {
+      const conversation = await createHideableConversation();
+
+      await user1Caller.conversation.hide({
+        conversationId: conversation.id,
+      });
+
+      const hiddenConversation = await user1Caller.conversation.get({
+        conversationId: conversation.id,
+      });
+
+      expect(hiddenConversation.id).toBe(conversation.id);
+    });
+
+    test('should unhide a hidden conversation after new activity', async () => {
+      const conversation = await createHideableConversation();
+
+      await user1Caller.conversation.hide({
+        conversationId: conversation.id,
+      });
+
+      await user2Caller.message.send({
+        conversationId: conversation.id,
+        content: 'Bringing this conversation back',
+      });
+
+      const membership = await prisma.conversationMember.findUniqueOrThrow({
+        where: {
+          userId_conversationId: {
+            userId: user1Id,
+            conversationId: conversation.id,
+          },
+        },
+        select: { hiddenAt: true },
+      });
+
+      expect(membership.hiddenAt).toBeNull();
+
+      const conversations = await user1Caller.conversation.list();
+
+      expect(conversations.map((item) => item.id)).toContain(conversation.id);
+    });
+
+    test('should fail for non-members', async () => {
+      const conversation = await createHideableConversation();
+
+      await expect(
+        user3Caller.conversation.hide({
+          conversationId: conversation.id,
+        }),
+      ).rejects.toThrow('Not a member of this conversation');
+    });
+  });
+
   describe('removeMember', () => {
     test('should remove member from conversation', async () => {
       await user1Caller.conversation.removeMember({

package/tests/routers/search.test.ts

@@ -0,0 +1,109 @@
+import { describe, expect, test, beforeAll } from "vitest";
+import { expectUnauth } from "../helpers";
+import { user1Caller, user2Caller, user3Caller } from "../setup";
+
+describe("Search Router", () => {
+  let testClass: any;
+  let assignment: any;
+  let event: any;
+  let worksheet: any;
+
+  beforeAll(async () => {
+    testClass = await user1Caller.class.create({
+      name: "Global Search Biology",
+      subject: "Biology",
+      section: "STU-65",
+    });
+
+    await user1Caller.class.addStudent({
+      classId: testClass.id,
+      studentId: (await user2Caller.user.getProfile()).id,
+    });
+
+    await user1Caller.class.updateSyllabus({
+      classId: testClass.id,
+      contents: "Photosynthesis lab policies and chlorophyll grading overview.",
+    });
+
+    assignment = await user1Caller.assignment.create({
+      classId: testClass.id,
+      title: "Chlorophyll Response",
+      instructions: "Explain the photosynthesis command palette experiment.",
+      dueDate: new Date(Date.now() + 86400000).toISOString(),
+      type: "HOMEWORK",
+    });
+
+    event = await user1Caller.event.create({
+      classId: testClass.id,
+      name: "Photosynthesis Attendance Lab",
+      location: "Room 65",
+      startTime: new Date(Date.now() + 3600000).toISOString(),
+      endTime: new Date(Date.now() + 7200000).toISOString(),
+    });
+
+    worksheet = await user1Caller.worksheet.create({
+      classId: testClass.id,
+      name: "Chloroplast Worksheet",
+    });
+  });
+
+  test("returns matching class resources for a teacher", async () => {
+    const results = await user1Caller.search.global({
+      query: "photosynthesis",
+      limit: 20,
+    });
+
+    expect(results.query).toBe("photosynthesis");
+    expect(results.results).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          type: "assignment",
+          id: assignment.id,
+          href: `/class/${testClass.id}/assignment/${assignment.id}`,
+        }),
+        expect.objectContaining({
+          type: "event",
+          id: event.event.id,
+          href: `/class/${testClass.id}/attendance/${event.event.id}`,
+        }),
+        expect.objectContaining({
+          type: "syllabus",
+          href: `/class/${testClass.id}/syllabus`,
+        }),
+      ])
+    );
+  });
+
+  test("returns visible class resources for an enrolled student", async () => {
+    const results = await user2Caller.search.global({
+      query: "chloroplast",
+      limit: 20,
+    });
+
+    expect(results.results).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          type: "worksheet",
+          id: worksheet.id,
+          href: `/class/${testClass.id}/worksheets`,
+        }),
+      ])
+    );
+  });
+
+  test("does not expose resources to non-members", async () => {
+    const results = await user3Caller.search.global({
+      query: "photosynthesis",
+      limit: 20,
+    });
+
+    expect(results.results).not.toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ classId: testClass.id }),
+      ])
+    );
+  });
+
+  test("fails without authentication", () =>
+    expectUnauth((c) => c.search.global({ query: "biology" })));
+});