@studious-lms/server 1.1.24 → 1.2.6

package/tests/user.test.ts

@@ -0,0 +1,136 @@
+import { test, expect, describe, beforeEach } from 'vitest';
+import { user1Caller, user2Caller } from './setup';
+import { expectUnauth } from './helpers';
+
+describe('User Router', () => {
+  describe('getProfile', () => {
+    test('should get user profile successfully', async () => {
+      const profile = await user1Caller.user.getProfile();
+      
+      expect(profile).toBeDefined();
+      expect(profile.id).toBeDefined();
+      expect(profile.username).toBe('testuser1');
+      expect(profile.profile).toBeDefined();
+      expect(profile.profile.displayName).toBeNull();
+      expect(profile.profile.bio).toBeNull();
+      expect(profile.profile.location).toBeNull();
+      expect(profile.profile.website).toBeNull();
+      expect(profile.profile.profilePicture).toBeNull();
+    });
+
+    test('should fail without authentication', () =>
+      expectUnauth((c) => c.user.getProfile()));
+  });
+
+  describe('updateProfile', () => {
+    test('should update profile with display name and bio', async () => {
+      const updated = await user1Caller.user.updateProfile({
+        profile: {
+          displayName: 'Test User One',
+          bio: 'This is a test bio',
+          location: 'Test City',
+          website: 'https://example.com',
+        },
+      });
+
+      expect(updated).toBeDefined();
+      expect(updated.profile.displayName).toBe('Test User One');
+      expect(updated.profile.bio).toBe('This is a test bio');
+      expect(updated.profile.location).toBe('Test City');
+      expect(updated.profile.website).toBe('https://example.com');
+    });
+
+    test('should update profile with partial data', async () => {
+      const updated = await user2Caller.user.updateProfile({
+        profile: {
+          displayName: 'Test User Two',
+        },
+      });
+
+      expect(updated.profile.displayName).toBe('Test User Two');
+    });
+
+    test('should update profile with DiceBear avatar', async () => {
+      const updated = await user1Caller.user.updateProfile({
+        dicebearAvatar: {
+          url: 'https://api.dicebear.com/7.x/avataaars/svg?seed=test',
+        },
+      });
+
+      expect(updated.profile.profilePicture).toBe('https://api.dicebear.com/7.x/avataaars/svg?seed=test');
+    });
+
+    // test('should clear profile fields when set to null', async () => {
+    //   // First set some values
+    //   await user1Caller.user.updateProfile({
+    //     profile: {
+    //       displayName: 'Test Name',
+    //       bio: 'Test Bio',
+    //     },
+    //   });
+
+    //   // Then clear them
+    //   const cleared = await user1Caller.user.updateProfile({
+    //     profile: {
+    //       displayName: null,
+    //       bio: null,
+    //     },
+    //   });
+
+    //   expect(cleared.profile.displayName).toBeNull();
+    //   expect(cleared.profile.bio).toBeNull();
+    // });
+
+    test('should fail without authentication', () =>
+      expectUnauth((c) => c.user.updateProfile({
+        profile: { displayName: 'Test' },
+      })));
+  });
+
+  describe('getUploadUrl', () => {
+    test('should generate upload URL for valid image file', async () => {
+      const result = await user1Caller.user.getUploadUrl({
+        fileName: 'profile.jpg',
+        fileType: 'image/jpeg',
+      });
+
+      expect(result).toBeDefined();
+      expect(result.uploadUrl).toBeDefined();
+      expect(result.filePath).toBeDefined();
+      expect(result.fileName).toBeDefined();
+      expect(result.filePath).toContain('users/');
+      expect(result.filePath).toContain('/profile/');
+    });
+
+    test('should generate upload URL for PNG file', async () => {
+      const result = await user1Caller.user.getUploadUrl({
+        fileName: 'avatar.png',
+        fileType: 'image/png',
+      });
+
+      expect(result).toBeDefined();
+      expect(result.fileName).toContain('.png');
+    });
+
+    test('should fail for invalid file type', async () => {
+      await expect(user1Caller.user.getUploadUrl({
+        fileName: 'document.pdf',
+        fileType: 'application/pdf',
+      })).rejects.toThrow();
+    });
+
+    test('should fail for empty file name', async () => {
+      await expect(user1Caller.user.getUploadUrl({
+        fileName: '',
+        fileType: 'image/jpeg',
+      })).rejects.toThrow();
+    });
+
+    test('should fail without authentication', () =>
+      expectUnauth((c) => c.user.getUploadUrl({
+        fileName: 'test.jpg',
+        fileType: 'image/jpeg',
+      })));
+  });
+});
+

package/tests/utils/aiUser.test.ts

@@ -0,0 +1,22 @@
+import { describe, test, expect } from 'vitest';
+import { getAIUserId, isAIUser } from '../../src/utils/aiUser.js';
+
+describe('aiUser utils', () => {
+  describe('getAIUserId', () => {
+    test('returns AI_ASSISTANT constant', () => {
+      expect(getAIUserId()).toBe('AI_ASSISTANT');
+    });
+  });
+
+  describe('isAIUser', () => {
+    test('returns true for AI_ASSISTANT', () => {
+      expect(isAIUser('AI_ASSISTANT')).toBe(true);
+    });
+
+    test('returns false for other user ids', () => {
+      expect(isAIUser('user-123')).toBe(false);
+      expect(isAIUser('')).toBe(false);
+      expect(isAIUser('ai-assistant')).toBe(false); // case sensitive
+    });
+  });
+});

package/tests/utils/generateInviteCode.test.ts

@@ -0,0 +1,24 @@
+import { describe, test, expect } from 'vitest';
+import { generateInviteCode } from '../../src/utils/generateInviteCode.js';
+
+describe('generateInviteCode', () => {
+  test('returns a string of length 5', () => {
+    const code = generateInviteCode();
+    expect(code).toHaveLength(5);
+    expect(typeof code).toBe('string');
+  });
+
+  test('returns alphanumeric characters only', () => {
+    const code = generateInviteCode();
+    expect(code).toMatch(/^[a-z0-9]{5}$/);
+  });
+
+  test('produces different codes on multiple calls', () => {
+    const codes = new Set<string>();
+    for (let i = 0; i < 50; i++) {
+      codes.add(generateInviteCode());
+    }
+    // With 50 calls, we expect at least some uniqueness (collision very unlikely)
+    expect(codes.size).toBeGreaterThan(1);
+  });
+});

package/tests/utils/logger.test.ts

@@ -0,0 +1,74 @@
+import { describe, test, expect, vi, beforeEach, afterEach } from 'vitest';
+import { logger } from '../../src/utils/logger.js';
+
+describe('Logger', () => {
+  let consoleSpy: { log: ReturnType<typeof vi.spyOn>; warn: ReturnType<typeof vi.spyOn>; error: ReturnType<typeof vi.spyOn>; debug: ReturnType<typeof vi.spyOn> };
+
+  beforeEach(() => {
+    consoleSpy = {
+      log: vi.spyOn(console, 'log').mockImplementation(() => {}),
+      warn: vi.spyOn(console, 'warn').mockImplementation(() => {}),
+      error: vi.spyOn(console, 'error').mockImplementation(() => {}),
+      debug: vi.spyOn(console, 'debug').mockImplementation(() => {}),
+    };
+  });
+
+  afterEach(() => {
+    logger.setMode('silent'); // reset for test env default
+    vi.restoreAllMocks();
+  });
+
+  test('logger has info, warn, error, debug methods', () => {
+    expect(typeof logger.info).toBe('function');
+    expect(typeof logger.warn).toBe('function');
+    expect(typeof logger.error).toBe('function');
+    expect(typeof logger.debug).toBe('function');
+  });
+
+  test('in silent mode only error is logged', () => {
+    logger.setMode('silent');
+    logger.info('info');
+    logger.warn('warn');
+    logger.debug('debug');
+    logger.error('error');
+
+    expect(consoleSpy.log).not.toHaveBeenCalled();
+    expect(consoleSpy.warn).not.toHaveBeenCalled();
+    expect(consoleSpy.debug).not.toHaveBeenCalled();
+    expect(consoleSpy.error).toHaveBeenCalledWith(expect.stringContaining('error'));
+  });
+
+  test('in normal mode info, warn, error are logged', () => {
+    logger.setMode('normal');
+    logger.info('info msg');
+    logger.warn('warn msg');
+    logger.error('error msg');
+
+    expect(consoleSpy.log).toHaveBeenCalledWith(expect.stringContaining('info msg'));
+    expect(consoleSpy.warn).toHaveBeenCalledWith(expect.stringContaining('warn msg'));
+    expect(consoleSpy.error).toHaveBeenCalledWith(expect.stringContaining('error msg'));
+  });
+
+  test('in verbose mode debug is logged', () => {
+    logger.setMode('verbose');
+    logger.debug('debug msg');
+    expect(consoleSpy.debug).toHaveBeenCalledWith(expect.stringContaining('debug msg'));
+  });
+
+  test('formatted output includes level and message', () => {
+    logger.setMode('normal');
+    logger.info('test message');
+    const call = consoleSpy.log.mock.calls[0][0];
+    expect(call).toContain('INFO');
+    expect(call).toContain('test message');
+    expect(call).toMatch(/\[\d{4}-\d{2}-\d{2}T/); // ISO timestamp
+  });
+
+  test('context is included when provided', () => {
+    logger.setMode('normal');
+    logger.info('msg', { key: 'value' });
+    const call = consoleSpy.log.mock.calls[0][0];
+    expect(call).toContain('Context:');
+    expect(call).toContain('"key": "value"');
+  });
+});

package/tests/utils/prismaErrorHandler.test.ts

@@ -0,0 +1,101 @@
+import { describe, test, expect } from 'vitest';
+import {
+  handlePrismaError,
+  getFieldDisplayName,
+} from '../../src/utils/prismaErrorHandler.js';
+import {
+  PrismaClientKnownRequestError,
+  PrismaClientValidationError,
+  PrismaClientUnknownRequestError,
+} from '@prisma/client/runtime/library';
+
+describe('prismaErrorHandler', () => {
+  describe('handlePrismaError', () => {
+    test('handles PrismaClientKnownRequestError P2002 (unique constraint)', () => {
+      const error = new PrismaClientKnownRequestError('Unique constraint', {
+        code: 'P2002',
+        clientVersion: '6.0.0',
+        meta: { target: ['email'] },
+      });
+      const result = handlePrismaError(error);
+      expect(result.code).toBe('P2002');
+      expect(result.message).toContain('already exists');
+      expect(result.details).toContain('Unique constraint');
+    });
+
+    test('handles P2002 with array target', () => {
+      const error = new PrismaClientKnownRequestError('Unique', {
+        code: 'P2002',
+        clientVersion: '6.0.0',
+        meta: { target: ['username', 'email'] },
+      });
+      const result = handlePrismaError(error);
+      expect(result.message).toContain('username, email');
+    });
+
+    test('handles PrismaClientKnownRequestError P2025 (record not found)', () => {
+      const error = new PrismaClientKnownRequestError('Record not found', {
+        code: 'P2025',
+        clientVersion: '6.0.0',
+      });
+      const result = handlePrismaError(error);
+      expect(result.code).toBe('P2025');
+      expect(result.message).toContain('does not exist');
+    });
+
+    test('handles PrismaClientKnownRequestError P2003 (foreign key)', () => {
+      const error = new PrismaClientKnownRequestError('Foreign key', {
+        code: 'P2003',
+        clientVersion: '6.0.0',
+        meta: { field_name: 'classId' },
+      });
+      const result = handlePrismaError(error);
+      expect(result.code).toBe('P2003');
+      expect(result.message).toContain('referenced by other records');
+    });
+
+    test('handles PrismaClientValidationError', () => {
+      const error = new PrismaClientValidationError('Invalid data', {
+        clientVersion: '6.0.0',
+      });
+      const result = handlePrismaError(error);
+      expect(result.message).toBe('The data you provided is not valid');
+      expect(result.meta?.type).toBe('validation_error');
+    });
+
+    test('handles PrismaClientUnknownRequestError', () => {
+      const error = new PrismaClientUnknownRequestError('Unknown DB error', {
+        clientVersion: '6.0.0',
+      });
+      const result = handlePrismaError(error);
+      expect(result.message).toBe('An unexpected database error occurred');
+      expect(result.meta?.type).toBe('unknown_request_error');
+    });
+
+    test('handles generic Error', () => {
+      const error = new Error('Something went wrong');
+      const result = handlePrismaError(error);
+      expect(result.message).toBe('Something went wrong');
+      expect(result.details).toBeDefined();
+    });
+
+    test('handles non-Error unknown', () => {
+      const result = handlePrismaError('string error');
+      expect(result.message).toBe('An unknown database error occurred');
+      expect(result.details).toBe('string error');
+    });
+  });
+
+  describe('getFieldDisplayName', () => {
+    test('returns mapped display names for known fields', () => {
+      expect(getFieldDisplayName('username')).toBe('username');
+      expect(getFieldDisplayName('email')).toBe('email address');
+      expect(getFieldDisplayName('classId')).toBe('class');
+      expect(getFieldDisplayName('assignmentId')).toBe('assignment');
+    });
+
+    test('returns field name as-is for unknown fields', () => {
+      expect(getFieldDisplayName('unknownField')).toBe('unknownField');
+    });
+  });
+});

package/tests/utils/prismaWrapper.test.ts

@@ -0,0 +1,82 @@
+import { describe, test, expect, vi } from 'vitest';
+import {
+  withPrismaErrorHandling,
+  prismaWrapper,
+} from '../../src/utils/prismaWrapper.js';
+import { TRPCError } from '@trpc/server';
+import { PrismaClientKnownRequestError } from '@prisma/client/runtime/library';
+
+// Suppress console.error in tests
+vi.spyOn(console, 'error').mockImplementation(() => {});
+
+describe('prismaWrapper', () => {
+  describe('withPrismaErrorHandling', () => {
+    test('returns result when operation succeeds', async () => {
+      const result = await withPrismaErrorHandling(
+        async () => ({ id: '1', name: 'test' }),
+        'test op'
+      );
+      expect(result).toEqual({ id: '1', name: 'test' });
+    });
+
+    test('throws TRPCError with user-friendly message on Prisma P2002', async () => {
+      const error = new PrismaClientKnownRequestError('Unique', {
+        code: 'P2002',
+        clientVersion: '6.0.0',
+        meta: { target: ['email'] },
+      });
+      await expect(
+        withPrismaErrorHandling(async () => {
+          throw error;
+        }, 'create user')
+      ).rejects.toThrow(TRPCError);
+
+      try {
+        await withPrismaErrorHandling(async () => {
+          throw error;
+        }, 'create user');
+      } catch (e) {
+        expect(e).toBeInstanceOf(TRPCError);
+        expect((e as TRPCError).code).toBe('CONFLICT');
+        expect((e as TRPCError).message).toContain('already exists');
+      }
+    });
+
+    test('throws TRPCError with NOT_FOUND on P2025', async () => {
+      const error = new PrismaClientKnownRequestError('Not found', {
+        code: 'P2025',
+        clientVersion: '6.0.0',
+      });
+      try {
+        await withPrismaErrorHandling(async () => {
+          throw error;
+        });
+      } catch (e) {
+        expect(e).toBeInstanceOf(TRPCError);
+        expect((e as TRPCError).code).toBe('NOT_FOUND');
+      }
+    });
+  });
+
+  describe('prismaWrapper helpers', () => {
+    test('findUnique returns result', async () => {
+      const result = await prismaWrapper.findUnique(
+        async () => ({ id: '1' }),
+        'test'
+      );
+      expect(result).toEqual({ id: '1' });
+    });
+
+    test('create propagates Prisma errors as TRPCError', async () => {
+      const error = new PrismaClientKnownRequestError('Unique', {
+        code: 'P2002',
+        clientVersion: '6.0.0',
+      });
+      await expect(
+        prismaWrapper.create(async () => {
+          throw error;
+        })
+      ).rejects.toThrow(TRPCError);
+    });
+  });
+});

package/tests/worksheet.test.ts

@@ -0,0 +1,181 @@
+import { test, expect, describe, beforeAll } from 'vitest';
+import { user1Caller } from './setup';
+
+describe('Worksheet Router', () => {
+  let testClass: any;
+  let worksheetId: string;
+  let questionId: string;
+  let secondQuestionId: string;
+
+  beforeAll(async () => {
+    testClass = await user1Caller.class.create({
+      name: 'Worksheet Test Class',
+      subject: 'Physics',
+      section: '12th Grade',
+    });
+  });
+
+  describe('create', () => {
+    test('should create a worksheet', async () => {
+      const worksheet = await user1Caller.worksheet.create({
+        classId: testClass.id,
+        name: 'Chapter 1 Quiz',
+      });
+
+      expect(worksheet).toBeDefined();
+      expect(worksheet.name).toBe('Chapter 1 Quiz');
+      expect(worksheet.classId).toBe(testClass.id);
+      worksheetId = worksheet.id;
+    });
+  });
+
+  describe('listWorksheets', () => {
+    test('should list worksheets for a class', async () => {
+      const worksheets = await user1Caller.worksheet.listWorksheets({
+        classId: testClass.id,
+      });
+
+      expect(Array.isArray(worksheets)).toBe(true);
+      expect(worksheets.length).toBeGreaterThanOrEqual(1);
+      expect(worksheets.some((w) => w.id === worksheetId)).toBe(true);
+    });
+  });
+
+  describe('getWorksheet', () => {
+    test('should get a worksheet by ID', async () => {
+      const worksheet = await user1Caller.worksheet.getWorksheet({
+        worksheetId,
+      });
+
+      expect(worksheet).toBeDefined();
+      expect(worksheet.id).toBe(worksheetId);
+      expect(worksheet.name).toBe('Chapter 1 Quiz');
+    });
+
+    test('should fail for non-existent worksheet', async () => {
+      await expect(
+        user1Caller.worksheet.getWorksheet({ worksheetId: 'nonexistent' }),
+      ).rejects.toThrow();
+    });
+  });
+
+  describe('updateWorksheet', () => {
+    test('should update worksheet name', async () => {
+      const updated = await user1Caller.worksheet.updateWorksheet({
+        worksheetId,
+        name: 'Chapter 1 Test',
+      });
+
+      expect(updated.name).toBe('Chapter 1 Test');
+    });
+  });
+
+  describe('addQuestion', () => {
+    test('should add a short answer question', async () => {
+      const question = await user1Caller.worksheet.addQuestion({
+        worksheetId,
+        question: 'What is Newton\'s second law?',
+        answer: 'F = ma',
+        points: 5,
+        type: 'SHORT_ANSWER',
+      });
+
+      expect(question).toBeDefined();
+      expect(question.question).toBe('What is Newton\'s second law?');
+      expect(question.answer).toBe('F = ma');
+      expect(question.points).toBe(5);
+      questionId = question.id;
+    });
+
+    test('should add a multiple choice question', async () => {
+      const question = await user1Caller.worksheet.addQuestion({
+        worksheetId,
+        question: 'What is the SI unit of force?',
+        answer: 'Newton',
+        points: 3,
+        type: 'MULTIPLE_CHOICE',
+        options: [
+          { id: 'a', text: 'Joule', isCorrect: false },
+          { id: 'b', text: 'Newton', isCorrect: true },
+          { id: 'c', text: 'Watt', isCorrect: false },
+          { id: 'd', text: 'Pascal', isCorrect: false },
+        ],
+      });
+
+      expect(question).toBeDefined();
+      expect(question.type).toBe('MULTIPLE_CHOICE');
+      secondQuestionId = question.id;
+    });
+
+    test('should fail for non-existent worksheet', async () => {
+      await expect(
+        user1Caller.worksheet.addQuestion({
+          worksheetId: 'nonexistent',
+          question: 'Test',
+          answer: 'Test',
+          type: 'SHORT_ANSWER',
+        }),
+      ).rejects.toThrow();
+    });
+  });
+
+  describe('updateQuestion', () => {
+    test('should update a question', async () => {
+      const updated = await user1Caller.worksheet.updateQuestion({
+        worksheetId,
+        questionId,
+        question: 'State Newton\'s second law of motion.',
+        points: 10,
+      });
+
+      expect(updated.question).toBe('State Newton\'s second law of motion.');
+      expect(updated.points).toBe(10);
+    });
+  });
+
+  describe('reorderQuestions', () => {
+    test('should reorder questions', async () => {
+      const result = await user1Caller.worksheet.reorderQuestions({
+        worksheetId,
+        movedId: secondQuestionId,
+        position: 'before',
+        targetId: questionId,
+      });
+
+      expect(Array.isArray(result)).toBe(true);
+      expect(result.length).toBe(2);
+      const ids = result.map((r) => r.id);
+      expect(ids).toContain(questionId);
+      expect(ids).toContain(secondQuestionId);
+    });
+  });
+
+  describe('deleteQuestion', () => {
+    test('should delete a question', async () => {
+      const result = await user1Caller.worksheet.deleteQuestion({
+        worksheetId,
+        questionId: secondQuestionId,
+      });
+
+      expect(result.id).toBe(secondQuestionId);
+
+      const worksheet = await user1Caller.worksheet.getWorksheet({ worksheetId });
+      expect(worksheet.questions.length).toBe(1);
+    });
+  });
+
+  describe('deleteWorksheet', () => {
+    test('should delete a worksheet', async () => {
+      const toDelete = await user1Caller.worksheet.create({
+        classId: testClass.id,
+        name: 'Temporary Worksheet',
+      });
+
+      const result = await user1Caller.worksheet.deleteWorksheet({
+        worksheetId: toDelete.id,
+      });
+
+      expect(result.id).toBe(toDelete.id);
+    });
+  });
+});

package/tsconfig.json

@@ -9,9 +9,16 @@
     "skipLibCheck": true,
     "forceConsistentCasingInFileNames": true,
     "outDir": "dist",
-    "baseUrl": ".", 
+    "baseUrl": ".",
     "declaration": true,
-    "declarationMap": true
+    "declarationMap": true,
+    "sourceMap": true,
+    "inlineSources": true,
+
+    // Set `sourceRoot` to  "/" to strip the build path prefix
+    // from generated source code references.
+    // This improves issue grouping in Sentry.
+    "sourceRoot": "/"
   },
   "include": ["src/**/*"],
   "exclude": ["node_modules", "dist"]

package/vitest.config.ts

@@ -1,11 +1,40 @@
 import { defineConfig } from 'vitest/config';
+import { config } from 'dotenv';
+import { resolve } from 'path';
+
+// Load test environment variables before anything else
+config({ path: resolve(process.cwd(), '.env.test'), override: true });
 
 export default defineConfig({
   test: {
     globals: true,
     environment: 'node',
     hookTimeout: 60000, // 60 seconds
+    testTimeout: 30000, // 30 seconds per test
     include: ['tests/**/*.test.ts'],
-    setupFiles: ['./tests/setup.ts'], // run setup before tests
+    globalSetup: ['./tests/globalSetup.ts'],
+    setupFiles: ['./tests/setup.ts'],
+    sequence: {
+      concurrent: false,
+    },
+    coverage: {
+      exclude: [
+        "src/types/trpc.ts",
+        "src/instrument.ts",
+        "*.config.ts",
+        "tests/**",
+        "generated/**",
+        "prisma/**",
+        "scripts/**",
+        "src/lib/prisma.ts",
+        "src/seedDatabase.ts",
+        "src/socket/**",
+        "**/node_modules/**",
+        "**/dist/**",
+      ],
+    },
+    env: {
+      NODE_ENV: 'test',
+    },
   },
 });