refactor(server): update core modules and services

apps/server/src/modules/app/app.resolver.ts

···
 export class AppResolver {
   constructor(private readonly appService: AppService) {}
 
-  @Query(() => String)
-  hello(): string {
-    return this.appService.getHello();
-  }
-
   @Query(() => HealthResponse)
   health(): HealthResponse {
     return new HealthResponse(this.appService.getHealth());

apps/server/src/modules/app/app.service.ts

···
 export class AppService {
   private readonly startTime = Date.now();
 
-  getHello(): string {
-    return "Hello from NestJS server";
-  }
-
   getHealth(): HealthResponse {
     const now = new Date();
     return {

apps/server/src/modules/auth/auth.dto.ts

···
 
 export interface AuthResponse {
   access_token: string;
+  refresh_token: string;
+  expires_at: Date;
   user: {
     id: string;
     email: string;
···
     createdAt: Date;
   };
 }
+
+export interface RefreshTokenDto {
+  refresh_token: string;
+}
+
+export interface RefreshTokenResponse {
+  access_token: string;
+  refresh_token: string;
+  expires_at: Date;
+}

apps/server/src/modules/auth/auth.module.ts

···
-import { Global, Module } from "@nestjs/common";
+import { Module } from "@nestjs/common";
 import { ConfigModule, ConfigService } from "@nestjs/config";
 import { JwtModule } from "@nestjs/jwt";
-import { DatabaseModule } from "../database/database.module";
+import { DatabaseModule } from "@/modules/database/database.module";
+import { UserModule } from "@/modules/user/user.module";
 import { AuthResolver } from "./auth.resolver";
 import { AuthService } from "./auth.service";
 import { JwtAuthGuard } from "./jwt-auth.guard";
 import { MeResolver } from "./me.resolver";
-import { UserMapper } from "./user.mapper";
-import { UserService } from "./user.service";
 
-@Global()
 @Module({
   imports: [
     ConfigModule,
     DatabaseModule,
+    UserModule,
     JwtModule.registerAsync({
       imports: [ConfigModule],
       useFactory: async (configService: ConfigService) => {
···
       inject: [ConfigService],
     }),
   ],
-  providers: [
-    AuthService,
-    UserService,
-    AuthResolver,
-    MeResolver,
-    JwtAuthGuard,
-    UserMapper,
-  ],
-  exports: [AuthService, UserService, JwtModule, JwtAuthGuard, UserMapper],
+  providers: [AuthService, AuthResolver, MeResolver, JwtAuthGuard],
+  exports: [AuthService, JwtModule, JwtAuthGuard],
 })
 export class AuthModule {}

apps/server/src/modules/auth/auth.resolver.ts

···
 import { Args, Mutation, Resolver } from "@nestjs/graphql";
 import { AuthService } from "./auth.service";
-import { AuthResponse } from "./auth.type";
+import { AuthResponse, RefreshTokenResponse } from "./auth.type";
 
 @Resolver()
 export class AuthResolver {
···
     @Args("email") email: string,
     @Args("password") password: string,
   ): Promise<AuthResponse> {
-    return this.authService.login({ email, password });
+    const result = await this.authService.login({ email, password });
+    return AuthResponse.fromDomain(result);
   }
 
   @Mutation(() => AuthResponse)
···
     @Args("email") email: string,
     @Args("password") password: string,
   ): Promise<AuthResponse> {
-    return this.authService.register({ name, email, password });
+    const result = await this.authService.register({ name, email, password });
+    return AuthResponse.fromDomain(result);
+  }
+
+  @Mutation(() => RefreshTokenResponse)
+  async refreshToken(
+    @Args("refresh_token") refresh_token: string,
+  ): Promise<RefreshTokenResponse> {
+    const result = await this.authService.refreshToken({ refresh_token });
+    return RefreshTokenResponse.fromDomain(result);
   }
 }

apps/server/src/modules/auth/auth.service.ts

···
 } from "@nestjs/common";
 import { JwtService } from "@nestjs/jwt";
 import * as bcrypt from "bcryptjs";
-import type { AuthResponse, LoginDto, RegisterDto } from "./auth.dto";
-import type { User } from "./user.entity";
-import { UserService } from "./user.service";
+import { JwtConfigService } from "@/config/jwt.config";
+import type { User } from "@/modules/user/user.entity";
+import { UserService } from "@/modules/user/user.service";
+import type {
+  AuthResponse,
+  LoginDto,
+  RefreshTokenDto,
+  RefreshTokenResponse,
+  RegisterDto,
+} from "./auth.dto";
 
 @Injectable()
 export class AuthService {
   constructor(
     private userService: UserService,
     private jwtService: JwtService,
+    private jwtConfig: JwtConfigService,
   ) {}
 
+  private generateTokens(user: User): {
+    access_token: string;
+    refresh_token: string;
+    expires_at: Date;
+  } {
+    const payload = { sub: user.id, email: user.email };
+
+    // Get token expiration times from config
+    const accessTokenExpiry = this.jwtConfig.getAccessTokenExpiry();
+    const refreshTokenExpiry = this.jwtConfig.getRefreshTokenExpiry();
+
+    // Access token (short-lived)
+    const access_token = this.jwtService.sign(payload, {
+      expiresIn: accessTokenExpiry,
+    });
+
+    // Refresh token (long-lived)
+    const refresh_token = this.jwtService.sign(
+      { sub: user.id, type: "refresh" },
+      { expiresIn: refreshTokenExpiry },
+    );
+
+    // Calculate expiry time based on the access token expiry
+    const expires_at = this.jwtConfig.calculateAccessTokenExpiryDate();
+
+    return { access_token, refresh_token, expires_at };
+  }
+
   async register({
     email,
     name,
···
 
     const user = await this.userService.create(email, name, hashedPassword);
 
-    const payload = { sub: user.id, email: user.email };
-    const access_token = this.jwtService.sign(payload);
+    const tokens = this.generateTokens(user);
 
     return {
-      access_token,
+      ...tokens,
       user: {
         id: user.id,
         email: user.email,
···
 
       const user = await this.userService.findByEmailOrFail(email);
 
-      const payload = { sub: user.id, email: user.email };
-      const access_token = this.jwtService.sign(payload);
+      const tokens = this.generateTokens(user);
 
       return {
-        access_token,
+        ...tokens,
         user: {
           id: user.id,
           email: user.email,
···
       }
       // If user not found, throw unauthorized for security
       throw new UnauthorizedException("Invalid credentials");
+    }
+  }
+
+  async refreshToken({
+    refresh_token,
+  }: RefreshTokenDto): Promise<RefreshTokenResponse> {
+    try {
+      // Verify the refresh token
+      const payload = await this.jwtService.verifyAsync(refresh_token);
+
+      // Ensure this is actually a refresh token
+      if (payload.type !== "refresh") {
+        throw new UnauthorizedException("Invalid refresh token");
+      }
+
+      // Get the user
+      const user = await this.userService.findByIdOrFail(payload.sub);
+
+      // Generate new tokens
+      const tokens = this.generateTokens(user);
+
+      return tokens;
+    } catch (_error) {
+      throw new UnauthorizedException("Invalid or expired refresh token");
     }
   }
 

apps/server/src/modules/auth/auth.type.ts

···
 import { Field, ObjectType } from "@nestjs/graphql";
-import { User } from "./user.type";
+import { User } from "@/modules/user/user.type";
 
 @ObjectType()
 export class AuthResponse {
   @Field()
   access_token: string;
 
+  @Field()
+  refresh_token: string;
+
+  @Field()
+  expires_at: string;
+
   @Field(() => User)
   user: User;
 
-  constructor(access_token: string, user: User) {
+  constructor(
+    access_token: string,
+    refresh_token: string,
+    expires_at: Date,
+    user: User,
+  ) {
     this.access_token = access_token;
+    this.refresh_token = refresh_token;
+    this.expires_at = expires_at.toISOString();
     this.user = user;
   }
 
   static fromDomain(domainAuth: {
     access_token: string;
+    refresh_token: string;
+    expires_at: Date;
     user: User;
   }): AuthResponse {
-    return new AuthResponse(domainAuth.access_token, domainAuth.user);
+    return new AuthResponse(
+      domainAuth.access_token,
+      domainAuth.refresh_token,
+      domainAuth.expires_at,
+      domainAuth.user,
+    );
+  }
+}
+
+@ObjectType()
+export class RefreshTokenResponse {
+  @Field()
+  access_token: string;
+
+  @Field()
+  refresh_token: string;
+
+  @Field()
+  expires_at: string;
+
+  constructor(access_token: string, refresh_token: string, expires_at: Date) {
+    this.access_token = access_token;
+    this.refresh_token = refresh_token;
+    this.expires_at = expires_at.toISOString();
+  }
+
+  static fromDomain(tokens: {
+    access_token: string;
+    refresh_token: string;
+    expires_at: Date;
+  }): RefreshTokenResponse {
+    return new RefreshTokenResponse(
+      tokens.access_token,
+      tokens.refresh_token,
+      tokens.expires_at,
+    );
   }
 }

apps/server/src/modules/auth/me.resolver.ts

···
 import { UseGuards } from "@nestjs/common";
 import { Query, Resolver } from "@nestjs/graphql";
+import { UserService } from "@/modules/user/user.service";
+import { User } from "@/modules/user/user.type";
 import { CurrentUser } from "./current-user.decorator";
 import { JwtAuthGuard } from "./jwt-auth.guard";
-import { UserService } from "./user.service";
-import { User } from "./user.type";
 
 @Resolver(() => User)
 @UseGuards(JwtAuthGuard)

apps/server/src/modules/auth/user.entity.ts

···
-import type { Organization as PrismaOrganization } from "@prisma/client";
-import { BaseEntity } from "../base/base.entity";
-
-export class User extends BaseEntity {
-  email: string;
-  name: string;
-  organizations?: PrismaOrganization[] | undefined;
-
-  constructor(
-    id: string,
-    email: string,
-    name: string,
-    createdAt: Date,
-    updatedAt: Date,
-    organizations?: PrismaOrganization[] | undefined,
-  ) {
-    super(id, createdAt, updatedAt);
-    this.email = email;
-    this.name = name;
-    this.organizations = organizations;
-  }
-}

apps/server/src/modules/auth/user.mapper.ts

···
-import { Injectable } from "@nestjs/common";
-import type {
-  Organization as PrismaOrganization,
-  User as PrismaUser,
-} from "@prisma/client";
-import type { BaseMapper } from "../base/mapper.interface";
-import { User } from "./user.entity";
-
-/**
- * Mapper service for converting between Prisma User entities and domain User entities
- */
-@Injectable()
-export class UserMapper implements BaseMapper<PrismaUser, User> {
-  /**
-   * Maps a Prisma User entity to a domain User entity
-   * Uses overloads to return the correct type based on input
-   */
-  toDomain(prismaUser: null): null;
-  toDomain(prismaUser: PrismaUser): User;
-  toDomain(prismaUser: PrismaUser | null): User | null;
-  toDomain(prismaUser: PrismaUser | null): User | null {
-    if (prismaUser === null) {
-      return null;
-    }
-    return new User(
-      prismaUser.id,
-      prismaUser.email,
-      prismaUser.name,
-      prismaUser.createdAt,
-      prismaUser.updatedAt,
-    );
-  }
-
-  /**
-   * Maps an array of Prisma User entities to domain User entities
-   */
-  mapToDomain(prismaUsers: PrismaUser[]): User[] {
-    return prismaUsers.map((user) => this.toDomain(user));
-  }
-
-  /**
-   * Maps a Prisma user with joined organizations to a domain User preserving organizations
-   */
-  toDomainWithOrganizations(
-    prismaUser:
-      | (PrismaUser & {
-          organizations: Array<{ organization: PrismaOrganization }>;
-        })
-      | null,
-  ): User | null {
-    if (prismaUser === null) return null;
-    const organizations = prismaUser.organizations.map(
-      (uo: { organization: PrismaOrganization }) => uo.organization,
-    );
-    return new User(
-      prismaUser.id,
-      prismaUser.email,
-      prismaUser.name,
-      prismaUser.createdAt,
-      prismaUser.updatedAt,
-      organizations,
-    );
-  }
-}

apps/server/src/modules/auth/user.service.ts

···
-import { Injectable, NotFoundException } from "@nestjs/common";
-import { PrismaService } from "../database/prisma.service";
-import { User } from "./user.entity";
-import { UserMapper } from "./user.mapper";
-
-@Injectable()
-export class UserService {
-  constructor(
-    private prisma: PrismaService,
-    private userMapper: UserMapper,
-  ) {}
-
-  async create(email: string, name: string, password: string): Promise<User> {
-    const prismaUser = await this.prisma.user.create({
-      data: {
-        email,
-        name,
-        password,
-      },
-    });
-
-    return this.userMapper.toDomain(prismaUser);
-  }
-
-  async findByEmail(email: string): Promise<User | null> {
-    const prismaUser = await this.prisma.user.findUnique({
-      where: { email },
-    });
-
-    return this.userMapper.toDomain(prismaUser);
-  }
-
-  async findById(id: string): Promise<User | null> {
-    const prismaUser = await this.prisma.user.findUnique({
-      where: { id },
-    });
-
-    return this.userMapper.toDomain(prismaUser);
-  }
-
-  async exists(email: string): Promise<boolean> {
-    const user = await this.prisma.user.findUnique({
-      where: { email },
-      select: { id: true },
-    });
-
-    return user !== null;
-  }
-
-  /**
-   * Validates user password at the Prisma level (for authentication only)
-   * This method bypasses the domain entity to handle password concerns
-   */
-  async validatePassword(email: string, password: string): Promise<boolean> {
-    const prismaUser = await this.prisma.user.findUnique({
-      where: { email },
-      select: { password: true },
-    });
-
-    if (!prismaUser) {
-      return false;
-    }
-
-    // This will be handled by bcrypt in the auth service
-    return prismaUser.password === password;
-  }
-
-  /**
-   * Gets user password hash for authentication (Prisma level only)
-   */
-  async getPasswordHash(email: string): Promise<string | null> {
-    const prismaUser = await this.prisma.user.findUnique({
-      where: { email },
-      select: { password: true },
-    });
-
-    return prismaUser?.password ?? null;
-  }
-
-  async findByEmailOrFail(email: string): Promise<User> {
-    const user = await this.findByEmail(email);
-    if (!user) {
-      throw new NotFoundException(`User with email ${email} not found`);
-    }
-    return user;
-  }
-
-  async findByIdOrFail(id: string): Promise<User> {
-    const user = await this.findById(id);
-    if (!user) {
-      throw new NotFoundException(`User with id ${id} not found`);
-    }
-    return user;
-  }
-
-  async findByIdWithOrganizations(id: string): Promise<User> {
-    const prismaUser = await this.prisma.user.findUnique({
-      where: { id },
-      include: {
-        organizations: {
-          include: {
-            organization: true,
-          },
-        },
-      },
-    });
-
-    if (!prismaUser) {
-      throw new NotFoundException(`User with id ${id} not found`);
-    }
-
-    const user = this.userMapper.toDomainWithOrganizations(prismaUser);
-    // user is non-null due to guard above
-    return user as User;
-  }
-}

apps/server/src/modules/auth/user.type.ts

···
-import { Field, ID, ObjectType } from "@nestjs/graphql";
-import { UserJobExperience } from "../job-experience/employment/user-job-experience.type";
-import { Organization } from "../organization/organization.entity";
-import type { User as DomainUser } from "./user.entity";
-
-@ObjectType()
-export class User {
-  @Field(() => ID)
-  id: string;
-
-  @Field()
-  email: string;
-
-  @Field()
-  name: string;
-
-  @Field(() => Date)
-  createdAt: Date;
-
-  @Field(() => [Organization], { nullable: true })
-  organizations?: Organization[] | undefined;
-
-  @Field(() => [UserJobExperience], { nullable: true })
-  experience?: UserJobExperience[] | undefined;
-
-  constructor(
-    id: string,
-    email: string,
-    name: string,
-    createdAt: Date,
-    organizations?: Organization[] | undefined,
-    experience?: UserJobExperience[] | undefined,
-  ) {
-    this.id = id;
-    this.email = email;
-    this.name = name;
-    this.createdAt = createdAt;
-    this.organizations = organizations ?? undefined;
-    this.experience = experience ?? undefined;
-  }
-
-  static fromDomain(
-    domainUser: DomainUser,
-    organizations?: Organization[],
-    experience?: UserJobExperience[],
-  ): User {
-    return new User(
-      domainUser.id,
-      domainUser.email,
-      domainUser.name,
-      domainUser.createdAt,
-      organizations,
-      experience,
-    );
-  }
-}

apps/server/src/modules/database/database.module.ts

···
-import { Global, Module } from "@nestjs/common";
+import { Module } from "@nestjs/common";
 import { PrismaService } from "./prisma.service";
 
-@Global()
 @Module({
   providers: [PrismaService],
   exports: [PrismaService],

apps/server/src/modules/database/prisma.service.ts

···
   }
 
   async onModuleInit() {
-    await this.$connect();
+    await this["$connect"]();
   }
 
   async onModuleDestroy() {
-    await this.$disconnect();
+    await this["$disconnect"]();
   }
 }