@studious-lms/server 1.0.6 → 1.0.8

package/tests/auth.test.ts

@@ -0,0 +1,25 @@
+import { test, expect } from 'vitest';
+import { appRouter } from '../src/routers/_app';
+import { createTRPCContext } from '../src/trpc';
+import { prisma } from '../src/lib/prisma';
+import { caller, login1, login2, session1, session2, user1Caller, verification1, verification2 } from './setup';
+
+test('registration', async () => {
+    expect(session1).toBeDefined();
+    expect(session2).toBeDefined();
+});
+
+test('email verification', async () => {
+    expect(verification1).toBeDefined();
+    expect(verification2).toBeDefined();
+});
+
+test('login', async () => {
+    expect(login1).toBeDefined();
+    expect(login2).toBeDefined();
+});
+
+test('logout', async () => {
+    const logout = await user1Caller.auth.logout();
+    expect(logout).toBeDefined();
+});

package/tests/class.test.ts

@@ -0,0 +1,281 @@
+import { test, expect, describe, beforeEach } from 'vitest';
+import { appRouter } from '../src/routers/_app';
+import { createTRPCContext } from '../src/trpc';
+import { prisma } from '../src/lib/prisma';
+import { caller, user1Caller, user2Caller } from './setup';
+
+describe('Class Router', () => {
+  let testClass: any;
+  let testClass2: any;
+
+  beforeEach(async () => {
+    // Create test classes for each test
+    testClass = await user1Caller.class.create({
+      name: 'Test Class 1',
+      subject: 'Mathematics',
+      section: '10th Grade',
+    });
+
+    testClass2 = await user2Caller.class.create({
+      name: 'Test Class 2',
+      subject: 'Science',
+      section: '11th Grade',
+    });
+  });
+
+  describe('create', () => {
+    test('should create a class successfully', async () => {
+      expect(testClass).toBeDefined();
+      expect(testClass.name).toBe('Test Class 1');
+      expect(testClass.subject).toBe('Mathematics');
+      expect(testClass.section).toBe('10th Grade');
+    });
+
+    test('should create multiple classes', async () => {
+      expect(testClass).toBeDefined();
+      expect(testClass2).toBeDefined();
+      expect(testClass.id).not.toBe(testClass2.id);
+    });
+
+    test('should fail to create class without authentication', async () => {
+      const invalidCaller = await createTRPCContext({
+        req: { headers: {} } as any,
+        res: {} as any,
+      });
+      const router = appRouter.createCaller(invalidCaller);
+      
+      await expect(router.class.create({
+        name: 'Test Class',
+        subject: 'Mathematics',
+        section: '10th Grade',
+      })).rejects.toThrow();
+    });
+
+    test('should fail to create class with missing required fields', async () => {
+      await expect(user1Caller.class.create({
+        name: '',
+        subject: 'Mathematics',
+        section: '10th Grade',
+      })).rejects.toThrow();
+    });
+  });
+
+  describe('getAll', () => {
+    test('should get all classes for authenticated user', async () => {
+      const classes = await user1Caller.class.getAll();
+      expect(classes).toBeDefined();
+      expect(classes.teacherInClass).toBeDefined();
+      expect(classes.studentInClass).toBeDefined();
+      expect(Array.isArray(classes.teacherInClass)).toBe(true);
+      expect(Array.isArray(classes.studentInClass)).toBe(true);
+    });
+
+    test('should include user\'s own classes as teacher', async () => {
+      const classes = await user1Caller.class.getAll();
+      const userClass = classes.teacherInClass.find((c: any) => c.name === 'Test Class 1');
+      expect(userClass).toBeDefined();
+    });
+
+    test('should fail to get classes without authentication', async () => {
+      const invalidCaller = await createTRPCContext({
+        req: { headers: {} } as any,
+        res: {} as any,
+      });
+      const router = appRouter.createCaller(invalidCaller);
+      
+      await expect(router.class.getAll()).rejects.toThrow();
+    });
+  });
+
+  describe('get', () => {
+    test('should get class by ID successfully', async () => {
+      const classData = await user1Caller.class.get({ classId: testClass.id });
+      expect(classData).toBeDefined();
+      expect(classData.class).toBeDefined();
+      expect(classData.class.id).toBe(testClass.id);
+      expect(classData.class.name).toBe('Test Class 1');
+    });
+
+    test('should fail to get non-existent class', async () => {
+      await expect(user1Caller.class.get({ classId: 'non-existent-id' })).rejects.toThrow();
+    });
+
+    test('should fail to get class without authentication', async () => {
+      const invalidCaller = await createTRPCContext({
+        req: { headers: {} } as any,
+        res: {} as any,
+      });
+      const router = appRouter.createCaller(invalidCaller);
+      
+      await expect(router.class.get({ classId: testClass.id })).rejects.toThrow();
+    });
+  });
+
+  describe('update', () => {
+    test('should update class successfully', async () => {
+      const updatedClass = await user1Caller.class.update({
+        classId: testClass.id,
+        name: 'Updated Test Class',
+        subject: 'Physics',
+        section: '12th Grade',
+      });
+
+      expect(updatedClass).toBeDefined();
+      expect(updatedClass.updatedClass).toBeDefined();
+      expect(updatedClass.updatedClass.name).toBe('Updated Test Class');
+      expect(updatedClass.updatedClass.subject).toBe('Physics');
+      expect(updatedClass.updatedClass.section).toBe('12th Grade');
+    });
+
+    test('should fail to update class user is not teacher of', async () => {
+      await expect(user2Caller.class.update({
+        classId: testClass.id,
+        name: 'Updated Test Class',
+        subject: 'Physics',
+        section: '12th Grade',
+      })).rejects.toThrow();
+    });
+
+    test('should fail to update non-existent class', async () => {
+      await expect(user1Caller.class.update({
+        classId: 'non-existent-id',
+        name: 'Updated Test Class',
+        subject: 'Physics',
+        section: '12th Grade',
+      })).rejects.toThrow();
+    });
+  });
+
+  describe('delete', () => {
+    test('should delete class successfully', async () => {
+      const result = await user1Caller.class.delete({ classId: testClass.id, id: testClass.id });
+      expect(result).toBeDefined();
+      expect(result.deletedClass).toBeDefined();
+      expect(result.deletedClass.id).toBe(testClass.id);
+    });
+
+    test('should fail to delete class user is not teacher of', async () => {
+      await expect(user2Caller.class.delete({ classId: testClass.id, id: testClass.id })).rejects.toThrow();
+    });
+
+    test('should fail to delete non-existent class', async () => {
+      await expect(user1Caller.class.delete({ classId: 'non-existent-id', id: 'non-existent-id' })).rejects.toThrow();
+    });
+  });
+
+  describe('addStudent', () => {
+    test('should add student successfully', async () => {
+      const user2Profile = await user2Caller.user.getProfile();
+      const result = await user1Caller.class.addStudent({
+        classId: testClass.id,
+        studentId: user2Profile.id,
+      });
+      expect(result).toBeDefined();
+      expect(result.updatedClass).toBeDefined();
+      expect(result.newStudent).toBeDefined();
+    });
+
+    test('should fail to add student if user is not class teacher', async () => {
+      const user1Profile = await user1Caller.user.getProfile();
+      await expect(user2Caller.class.addStudent({
+        classId: testClass.id,
+        studentId: user1Profile.id,
+      })).rejects.toThrow();
+    });
+  });
+
+  describe('changeRole', () => {
+    test('should change user role successfully', async () => {
+      const user2Profile = await user2Caller.user.getProfile();
+      const result = await user1Caller.class.changeRole({
+        classId: testClass.id,
+        userId: user2Profile.id,
+        type: 'teacher',
+      });
+      expect(result).toBeDefined();
+      expect(result.updatedClass).toBeDefined();
+      expect(result.user).toBeDefined();
+      expect(result.user.type).toBe('teacher');
+    });
+
+    test('should fail to change role if user is not class teacher', async () => {
+      const user1Profile = await user1Caller.user.getProfile();
+      await expect(user2Caller.class.changeRole({
+        classId: testClass.id,
+        userId: user1Profile.id,
+        type: 'teacher',
+      })).rejects.toThrow();
+    });
+  });
+
+  describe('removeMember', () => {
+    test('should remove member successfully', async () => {
+      // First add a student
+      const user2Profile = await user2Caller.user.getProfile();
+      await user1Caller.class.addStudent({
+        classId: testClass.id,
+        studentId: user2Profile.id,
+      });
+      
+      // Then remove them
+      const result = await user1Caller.class.removeMember({
+        classId: testClass.id,
+        userId: user2Profile.id,
+      });
+      expect(result).toBeDefined();
+      expect(result.updatedClass).toBeDefined();
+      expect(result.removedUserId).toBe(user2Profile.id);
+    });
+
+    test('should fail to remove member if user is not class teacher', async () => {
+      const user1Profile = await user1Caller.user.getProfile();
+      await expect(user2Caller.class.removeMember({
+        classId: testClass.id,
+        userId: user1Profile.id,
+      })).rejects.toThrow();
+    });
+  });
+
+  describe('join', () => {
+    test('should join class with class code successfully', async () => {
+      // First create an invite code
+      const inviteCode = await user1Caller.class.createInviteCode({ classId: testClass.id });
+      
+      // Then join with the code
+      const result = await user2Caller.class.join({ classCode: inviteCode.code });
+      expect(result).toBeDefined();
+      expect(result.joinedClass).toBeDefined();
+      expect(result.joinedClass.id).toBe(testClass.id);
+    });
+
+    test('should fail to join with invalid class code', async () => {
+      await expect(user2Caller.class.join({ classCode: 'invalid-code' })).rejects.toThrow();
+    });
+  });
+
+  describe('getInviteCode', () => {
+    test('should get invite code successfully', async () => {
+      const result = await user1Caller.class.getInviteCode({ classId: testClass.id });
+      expect(result).toBeDefined();
+      expect(result.code).toBeDefined();
+      expect(typeof result.code).toBe('string');
+    });
+
+    test('should fail to get invite code if user is not class teacher', async () => {
+      await expect(user2Caller.class.getInviteCode({ classId: testClass.id })).rejects.toThrow();
+    });
+  });
+
+  describe('createInviteCode', () => {
+    test('should create invite code successfully', async () => {
+      const result = await user1Caller.class.createInviteCode({ classId: testClass.id });
+      expect(result).toBeDefined();
+      expect(result.code).toBeDefined();
+      expect(typeof result.code).toBe('string');
+    });
+
+    test('should fail to create invite code if user is not class teacher', async () => {
+      await expect(user2Caller.class.createInviteCode({ classId: testClass.id })).rejects.toThrow();
+    });
+  });
+}); 

package/tests/setup.ts

@@ -0,0 +1,98 @@
+import { execSync } from 'child_process';
+import { prisma } from '../src/lib/prisma';
+import { beforeAll, beforeEach, afterAll, afterEach } from 'vitest';
+import { logger } from '../src/utils/logger';
+import { appRouter } from '../src/routers/_app';
+import { createTRPCContext } from '../src/trpc';
+import { Session } from '@prisma/client';
+
+const getCaller = async (token: string) => {
+  const ctx = await createTRPCContext({
+    req: { headers: {
+      authorization: `Bearer ${token}`,
+      'x-user': token,
+    } } as any,
+    res: {} as any,
+  });
+  return appRouter.createCaller(ctx);
+};
+
+  // Before the entire test suite runs
+  beforeAll(async () => {
+  //   // Run migrations so the test DB has the latest schema
+  //   try {
+  //     logger.info('Setting up test database');
+  //     execSync('rm -f prisma/test.db');
+  //     execSync('npx prisma db push --force-reset --schema=prisma/schema.prisma');
+    
+  //   } catch (error) {
+  //     logger.error('Error initializing test database');
+  //   }
+
+    logger.info('Getting caller');
+
+    caller = await getCaller('');
+
+    const user1 = await caller.auth.register({
+      username: 'testuser1',
+      email: 'test@test.com',
+      password: 'password_is_1234',
+      confirmPassword: 'password_is_1234',
+    });
+
+    const user2 = await caller.auth.register({
+      username: 'testuser2',
+      email: 'test2@test.com',
+      password: 'password_is_1234',
+      confirmPassword: 'password_is_1234',
+    });
+
+    session1 = await prisma.session.findFirst({
+      where: {
+        userId: user1.user.id,
+      },
+    }) as Session;
+
+    session2 = (await prisma.session.findFirst({
+      where: {
+        userId: user2.user.id,
+      },
+    })) as Session;
+
+    verification1 = await caller.auth.verify({
+      token: session1.id,
+    });
+
+    verification2 = await caller.auth.verify({
+      token: session2.id,
+    });
+
+    login1 = await caller.auth.login({
+      username: 'testuser1',
+      password: 'password_is_1234',
+    });
+
+    login2 = await caller.auth.login({
+      username: 'testuser2',
+      password: 'password_is_1234',
+    });
+
+    user1Caller = await getCaller(login1.token);
+    user2Caller = await getCaller(login2.token);
+  });
+
+
+  // After all tests, close the DB
+  afterAll(async () => {
+    await prisma.$disconnect();
+  });
+
+export let user1Caller: ReturnType<typeof appRouter.createCaller>;
+export let user2Caller: ReturnType<typeof appRouter.createCaller>;
+export let caller: ReturnType<typeof appRouter.createCaller>;
+export let session1: Session;
+export let session2: Session;
+export let verification1: any;
+export let verification2: any;
+export let login1: any;
+export let login2: any;

package/tests/startup.test.ts

@@ -0,0 +1,5 @@
+import { expect, test } from "vitest";
+
+test('setup works', () => {
+    expect(1).toBe(1);
+});

package/tsconfig.json

@@ -1,10 +1,11 @@
 {
   "compilerOptions": {
     "target": "ES2020",
-    "module": "CommonJS",
+    "module": "ESNext",
     "moduleResolution": "node",
     "esModuleInterop": true,
     "strict": true,
+    "noImplicitAny": false,
     "skipLibCheck": true,
     "forceConsistentCasingInFileNames": true,
     "outDir": "dist",

package/vitest.config.ts

@@ -0,0 +1,11 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: 'node',
+    hookTimeout: 60000, // 60 seconds
+    include: ['tests/**/*.test.ts'],
+    setupFiles: ['./tests/setup.ts'], // run setup before tests
+  },
+});

package/dist/logger.d.ts

@@ -1,26 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,135 +0,0 @@
-"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();