Adding auth0

apps/api/package.json

@@ -18,9 +18,16 @@
     "@isaacs/brace-expansion": "^5.0.0",
     "@nestjs/common": "^11.0.0",
     "@nestjs/core": "^11.0.0",
+    "@nestjs/jwt": "^11.0.1",
+    "@nestjs/mapped-types": "*",
+    "@nestjs/passport": "^11.0.5",
     "@nestjs/platform-express": "^11.0.0",
     "@repo/api": "*",
     "ansis": "^4.1.0",
+    "jwks-rsa": "^3.2.0",
+    "passport": "^0.7.0",
+    "passport-auth0": "^1.4.4",
+    "passport-jwt": "^4.0.1",
     "reflect-metadata": "^0.2.0",
     "rxjs": "^7.8.1"
   },
@@ -36,6 +43,8 @@
     "@types/express": "^4.17.17",
     "@types/jest": "^30.0.0",
     "@types/node": "^22.10.7",
+    "@types/passport-auth0": "^1.0.9",
+    "@types/passport-jwt": "^4.0.1",
     "@types/supertest": "^6.0.0",
     "jest": "^29.7.0",
     "source-map-support": "^0.5.21",

apps/api/src/app.controller.ts

@@ -1,5 +1,7 @@
 import { Controller, Get } from '@nestjs/common';
 import { AppService } from './app.service';
+import { PrismaService } from './prisma.service';
+import { User, Prisma } from './../../../packages/database/generated/client';
 
 @Controller()
 export class AppController {
@@ -9,4 +11,5 @@ export class AppController {
   getHello(): string {
     return this.appService.getHello();
   }
-}
+
+}

apps/api/src/app.module.ts

@@ -4,10 +4,18 @@ import { LinksModule } from './links/links.module';
 
 import { AppService } from './app.service';
 import { AppController } from './app.controller';
+import { PrismaService } from './prisma.service';
+import { UsersModule } from './users/users.module';
+import { CoursesModule } from './courses/courses.module';
+import { EnrollmentModule } from './enrollment/enrollment.module';
+import { AssignmentsModule } from './assignments/assignments.module';
+import { SubmissionsModule } from './submissions/submissions.module';
+import { FeedbackModule } from './feedback/feedback.module';
+import { AuthModule } from './auth/auth.module';
 
 @Module({
-  imports: [LinksModule],
+  imports: [LinksModule, UsersModule, CoursesModule, EnrollmentModule, AssignmentsModule, SubmissionsModule, FeedbackModule, AuthModule],
   controllers: [AppController],
-  providers: [AppService],
+  providers: [AppService, PrismaService],
 })
-export class AppModule {}
+export class AppModule {}

apps/api/src/app.service.ts

@@ -1,8 +1,12 @@
 import { Injectable } from '@nestjs/common';
+import { PrismaService } from './prisma.service';
 
 @Injectable()
 export class AppService {
+    constructor(private prisma: PrismaService) {}
+
   getHello(): string {
     return 'Hello World!';
   }
+
 }

apps/api/src/assignments/assignments.controller.spec.ts

@@ -0,0 +1,20 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { AssignmentsController } from './assignments.controller';
+import { AssignmentsService } from './assignments.service';
+
+describe('AssignmentsController', () => {
+  let controller: AssignmentsController;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      controllers: [AssignmentsController],
+      providers: [AssignmentsService],
+    }).compile();
+
+    controller = module.get<AssignmentsController>(AssignmentsController);
+  });
+
+  it('should be defined', () => {
+    expect(controller).toBeDefined();
+  });
+});

apps/api/src/assignments/assignments.controller.ts

@@ -0,0 +1,22 @@
+import { Controller, Get, Param } from '@nestjs/common';
+import { AssignmentsService } from './assignments.service';
+
+@Controller('assignments')
+export class AssignmentsController {
+  constructor(private readonly assignmentsService: AssignmentsService) {}
+
+  @Get()
+    findAll() {
+      return this.assignmentsService.findAll();
+    }
+
+  @Get(':id')
+  findOne(@Param('id') id: string) {
+    return this.assignmentsService.findOne(id);
+  }
+
+  @Get('course/:course_id')
+  findCourseAssignments(@Param('course_id') course_id: string) {
+    return this.assignmentsService.findCourseAssignments(course_id);
+  }
+}

apps/api/src/assignments/assignments.module.ts

@@ -0,0 +1,10 @@
+import { Module } from '@nestjs/common';
+import { AssignmentsService } from './assignments.service';
+import { AssignmentsController } from './assignments.controller';
+import { PrismaService } from '../prisma.service';
+
+@Module({
+  controllers: [AssignmentsController],
+  providers: [AssignmentsService, PrismaService],
+})
+export class AssignmentsModule {}

apps/api/src/assignments/assignments.service.spec.ts

@@ -0,0 +1,18 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { AssignmentsService } from './assignments.service';
+
+describe('AssignmentsService', () => {
+  let service: AssignmentsService;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [AssignmentsService],
+    }).compile();
+
+    service = module.get<AssignmentsService>(AssignmentsService);
+  });
+
+  it('should be defined', () => {
+    expect(service).toBeDefined();
+  });
+});

apps/api/src/assignments/assignments.service.ts

@@ -0,0 +1,20 @@
+import { Injectable } from '@nestjs/common';
+import { PrismaService } from '../prisma.service';
+
+@Injectable()
+export class AssignmentsService {
+    constructor(private prisma: PrismaService) {}
+
+    async findAll() {
+        return this.prisma.assignment.findMany();
+    }
+
+    async findOne(id) {
+        return this.prisma.assignment.findUnique( {where: {assignment_id: id}} );
+    }
+
+    async findCourseAssignments(course_id) {
+        return this.prisma.assignment.findMany( {where: {assignment_course_id: course_id}})
+    }
+
+}

apps/api/src/auth/auth.controller.spec.ts

@@ -0,0 +1,18 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { AuthController } from './auth.controller';
+
+describe('AuthController', () => {
+  let controller: AuthController;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      controllers: [AuthController],
+    }).compile();
+
+    controller = module.get<AuthController>(AuthController);
+  });
+
+  it('should be defined', () => {
+    expect(controller).toBeDefined();
+  });
+});

apps/api/src/auth/auth.controller.ts

@@ -0,0 +1,4 @@
+import { Controller } from '@nestjs/common';
+
+@Controller('auth')
+export class AuthController {}

apps/api/src/auth/auth.module.ts

@@ -0,0 +1,14 @@
+import { Module } from '@nestjs/common';
+import { AuthController } from './auth.controller';
+import { AuthService } from './auth.service';
+import { PassportModule } from '@nestjs/passport';
+import { JwtStrategy } from './jwt.strategy';
+import { PrismaService } from 'src/prisma.service';
+
+@Module({
+  imports: [PassportModule.register({ defaultStrategy: 'jwt' })],
+  controllers: [AuthController],
+  providers: [AuthService, JwtStrategy, PrismaService],
+  exports: [PassportModule],
+})
+export class AuthModule {}

apps/api/src/auth/auth.service.spec.ts

@@ -0,0 +1,18 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { AuthService } from './auth.service';
+
+describe('AuthService', () => {
+  let service: AuthService;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [AuthService],
+    }).compile();
+
+    service = module.get<AuthService>(AuthService);
+  });
+
+  it('should be defined', () => {
+    expect(service).toBeDefined();
+  });
+});

apps/api/src/auth/auth.service.ts

@@ -0,0 +1,4 @@
+import { Injectable } from '@nestjs/common';
+
+@Injectable()
+export class AuthService {}

apps/api/src/auth/current-user.decorator.ts

@@ -0,0 +1,9 @@
+import { createParamDecorator, ExecutionContext } from '@nestjs/common';
+import { JwtUser } from './jwt.strategy';
+
+export const CurrentUser = createParamDecorator(
+  (data: unknown, ctx: ExecutionContext): JwtUser => {
+    const req = ctx.switchToHttp().getRequest();
+    return req.user as JwtUser;
+  },
+);

apps/api/src/auth/jwt.strategy.ts

@@ -0,0 +1,96 @@
+import { Injectable } from '@nestjs/common';
+import { PassportStrategy } from '@nestjs/passport';
+import { ExtractJwt, Strategy } from 'passport-jwt';
+import { passportJwtSecret } from 'jwks-rsa';
+import * as dotenv from 'dotenv';
+import { PrismaService } from 'src/prisma.service';
+
+dotenv.config();
+
+type JwtPayload = {
+  sub: string; // e.g. "auth0|abc123" or "google-oauth2|xyz"
+  iss: string;
+  aud: string | string[];
+  scope?: string;
+};
+
+export interface JwtUser {
+  userId: string;
+  provider: string;
+  providerId: string;
+  sub: string;
+  scopes: string[];
+}
+
+function splitSub(sub: string) {
+  // "provider|id" → { provider, providerId }
+  const [provider, ...rest] = sub.split('|');
+  return { provider, providerId: rest.join('|') };
+}
+
+@Injectable()
+export class JwtStrategy extends PassportStrategy(Strategy) {
+  constructor(private readonly prisma: PrismaService) {
+    super({
+      secretOrKeyProvider: passportJwtSecret({
+        cache: true,
+        rateLimit: true,
+        jwksRequestsPerMinute: 5,
+        jwksUri: `${process.env.AUTH0_ISSUER_URL}.well-known/jwks.json`,
+      }),
+
+      jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(),
+      audience: process.env.AUTH0_AUDIENCE,
+      issuer: `${process.env.AUTH0_ISSUER_URL}`,
+      algorithms: ['RS256'],
+    });
+  }
+
+  async validate(payload: JwtPayload): Promise<JwtUser> {
+    // You can see the JWT here
+    // console.log('JWT payload', payload);
+
+    const { sub } = payload;
+    const { provider, providerId } = splitSub(sub);
+
+    // 1) Find Authentication by provider+providerId
+    let auth = await this.prisma.authentication.findFirst({
+      where: { authentication_provider: provider, authentication_provider_id: providerId },
+      include: { user: true },
+    });
+
+    // 2) If missing, create User + Authentication (using whatever claims we have)
+    if (!auth) {
+      const user = await this.prisma.user.create({
+        data: {
+          user_name: payload['name'] ?? 'New User',
+          user_email: 
+            (payload as any)?.email ??
+            `${providerId}@${provider}.example.com`,
+            user_role: 'STUDENT',
+          user_authentication: {
+            create: {
+              authentication_provider: provider,
+              authentication_provider_id: providerId,
+            },
+          },
+        },
+      });
+      auth = { ...auth, user } as any;
+    } else {
+      // 3) Update user profile fields opportunistically (don’t overwrite with nulls)
+      await this.prisma.user.update({
+        where: { user_id: auth.authentication_user_id },
+        data: {},
+      });
+    }
+
+    return {
+      userId: auth.authentication_user_id,
+      provider,
+      providerId,
+      sub,
+      scopes: (payload.scope ?? '').split(' ').filter(Boolean),
+    } as JwtUser;
+  }
+}

apps/api/src/courses/courses.controller.spec.ts

@@ -0,0 +1,20 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { CoursesController } from './courses.controller';
+import { CoursesService } from './courses.service';
+
+describe('CoursesController', () => {
+  let controller: CoursesController;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      controllers: [CoursesController],
+      providers: [CoursesService],
+    }).compile();
+
+    controller = module.get<CoursesController>(CoursesController);
+  });
+
+  it('should be defined', () => {
+    expect(controller).toBeDefined();
+  });
+});