feat(server): add education and institution modules

apps/server/prisma/migrations/20251026204100_add_application_and_education_entities/migration.sql

···
+/*
+  Warnings:
+
+  - You are about to drop the column `education` on the `cvs` table. All the data in the column will be lost.
+
+*/
+-- AlterTable
+ALTER TABLE "cvs" DROP COLUMN "education";
+
+-- CreateTable
+CREATE TABLE "applications" (
+    "id" TEXT NOT NULL,
+    "userId" TEXT NOT NULL,
+    "vacancyId" TEXT NOT NULL,
+    "cvId" TEXT,
+    "coverLetter" TEXT,
+    "status" TEXT NOT NULL DEFAULT 'pending',
+    "appliedAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" TIMESTAMP(3) NOT NULL,
+
+    CONSTRAINT "applications_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable
+CREATE TABLE "educations" (
+    "id" TEXT NOT NULL,
+    "name" TEXT NOT NULL,
+    "description" TEXT,
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" TIMESTAMP(3) NOT NULL,
+
+    CONSTRAINT "educations_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable
+CREATE TABLE "user_educations" (
+    "id" TEXT NOT NULL,
+    "userId" TEXT NOT NULL,
+    "cvId" TEXT,
+    "institutionId" TEXT NOT NULL,
+    "degree" TEXT NOT NULL,
+    "fieldOfStudy" TEXT,
+    "startDate" TIMESTAMP(3) NOT NULL,
+    "endDate" TIMESTAMP(3),
+    "description" TEXT,
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" TIMESTAMP(3) NOT NULL,
+
+    CONSTRAINT "user_educations_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateIndex
+CREATE UNIQUE INDEX "applications_userId_vacancyId_key" ON "applications"("userId", "vacancyId");
+
+-- CreateIndex
+CREATE UNIQUE INDEX "educations_name_key" ON "educations"("name");
+
+-- AddForeignKey
+ALTER TABLE "applications" ADD CONSTRAINT "applications_userId_fkey" FOREIGN KEY ("userId") REFERENCES "users"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "applications" ADD CONSTRAINT "applications_vacancyId_fkey" FOREIGN KEY ("vacancyId") REFERENCES "vacancies"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "applications" ADD CONSTRAINT "applications_cvId_fkey" FOREIGN KEY ("cvId") REFERENCES "cvs"("id") ON DELETE SET NULL ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "user_educations" ADD CONSTRAINT "user_educations_userId_fkey" FOREIGN KEY ("userId") REFERENCES "users"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "user_educations" ADD CONSTRAINT "user_educations_cvId_fkey" FOREIGN KEY ("cvId") REFERENCES "cvs"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "user_educations" ADD CONSTRAINT "user_educations_institutionId_fkey" FOREIGN KEY ("institutionId") REFERENCES "educations"("id") ON DELETE CASCADE ON UPDATE CASCADE;

apps/server/prisma/migrations/20251026204243_rename_education_to_institution/migration.sql

···
+/*
+  Warnings:
+
+  - You are about to drop the column `name` on the `educations` table. All the data in the column will be lost.
+  - You are about to drop the `user_educations` table. If the table is not empty, all the data it contains will be lost.
+  - Added the required column `degree` to the `educations` table without a default value. This is not possible if the table is not empty.
+  - Added the required column `institutionId` to the `educations` table without a default value. This is not possible if the table is not empty.
+  - Added the required column `startDate` to the `educations` table without a default value. This is not possible if the table is not empty.
+  - Added the required column `userId` to the `educations` table without a default value. This is not possible if the table is not empty.
+
+*/
+-- DropForeignKey
+ALTER TABLE "public"."user_educations" DROP CONSTRAINT "user_educations_cvId_fkey";
+
+-- DropForeignKey
+ALTER TABLE "public"."user_educations" DROP CONSTRAINT "user_educations_institutionId_fkey";
+
+-- DropForeignKey
+ALTER TABLE "public"."user_educations" DROP CONSTRAINT "user_educations_userId_fkey";
+
+-- DropIndex
+DROP INDEX "public"."educations_name_key";
+
+-- AlterTable
+ALTER TABLE "educations" DROP COLUMN "name",
+ADD COLUMN     "cvId" TEXT,
+ADD COLUMN     "degree" TEXT NOT NULL,
+ADD COLUMN     "endDate" TIMESTAMP(3),
+ADD COLUMN     "fieldOfStudy" TEXT,
+ADD COLUMN     "institutionId" TEXT NOT NULL,
+ADD COLUMN     "startDate" TIMESTAMP(3) NOT NULL,
+ADD COLUMN     "userId" TEXT NOT NULL;
+
+-- DropTable
+DROP TABLE "public"."user_educations";
+
+-- CreateTable
+CREATE TABLE "institutions" (
+    "id" TEXT NOT NULL,
+    "name" TEXT NOT NULL,
+    "description" TEXT,
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" TIMESTAMP(3) NOT NULL,
+
+    CONSTRAINT "institutions_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateIndex
+CREATE UNIQUE INDEX "institutions_name_key" ON "institutions"("name");
+
+-- AddForeignKey
+ALTER TABLE "educations" ADD CONSTRAINT "educations_userId_fkey" FOREIGN KEY ("userId") REFERENCES "users"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "educations" ADD CONSTRAINT "educations_cvId_fkey" FOREIGN KEY ("cvId") REFERENCES "cvs"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "educations" ADD CONSTRAINT "educations_institutionId_fkey" FOREIGN KEY ("institutionId") REFERENCES "institutions"("id") ON DELETE CASCADE ON UPDATE CASCADE;

apps/server/prisma/migrations/20251026204502_remove_education_from_cv/migration.sql

···
+/*
+  Warnings:
+
+  - You are about to drop the column `cvId` on the `educations` table. All the data in the column will be lost.
+
+*/
+-- DropForeignKey
+ALTER TABLE "public"."educations" DROP CONSTRAINT "educations_cvId_fkey";
+
+-- AlterTable
+ALTER TABLE "educations" DROP COLUMN "cvId";

apps/server/prisma/migrations/20251103203729_add_skills_to_education/migration.sql

···
+-- CreateTable
+CREATE TABLE "_EducationToSkill" (
+    "A" TEXT NOT NULL,
+    "B" TEXT NOT NULL,
+
+    CONSTRAINT "_EducationToSkill_AB_pkey" PRIMARY KEY ("A","B")
+);
+
+-- CreateIndex
+CREATE INDEX "_EducationToSkill_B_index" ON "_EducationToSkill"("B");
+
+-- AddForeignKey
+ALTER TABLE "_EducationToSkill" ADD CONSTRAINT "_EducationToSkill_A_fkey" FOREIGN KEY ("A") REFERENCES "educations"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "_EducationToSkill" ADD CONSTRAINT "_EducationToSkill_B_fkey" FOREIGN KEY ("B") REFERENCES "skills"("id") ON DELETE CASCADE ON UPDATE CASCADE;

apps/server/src/modules/education/education.entity.ts

···
+import { BaseEntity } from "@/domain/base.entity";
+import type { Skill } from "@/modules/job-experience/skill/skill.entity";
+import { User } from "@/modules/user/user.entity";
+import { Institution } from "./institution.entity";
+
+export class Education extends BaseEntity {
+  constructor(
+    id: string,
+    public readonly userId: string,
+    public readonly user: User | null,
+    public readonly institutionId: string,
+    public readonly institution: Institution | null,
+    public readonly degree: string,
+    public readonly fieldOfStudy: string | null,
+    public readonly startDate: Date,
+    public readonly endDate: Date | null,
+    public readonly description: string | null,
+    createdAt: Date,
+    updatedAt: Date,
+    public readonly skills?: Skill[],
+  ) {
+    super(id, createdAt, updatedAt);
+    if (skills !== undefined) {
+      this.skills = skills;
+    }
+  }
+}

apps/server/src/modules/education/education.mapper.ts

···
+import { Injectable } from "@nestjs/common";
+import type { Prisma } from "@prisma/client";
+import type { BaseMapper } from "@/modules/base/mapper.interface";
+import { SkillMapper } from "@/modules/job-experience/skill/skill.mapper";
+import { UserMapper } from "@/modules/user/user.mapper";
+import { Education } from "./education.entity";
+import { InstitutionMapper } from "./institution.mapper";
+
+type PrismaEducation = Prisma.EducationGetPayload<{
+  include: {
+    institution: true;
+    user: true;
+    skills: true;
+  };
+}>;
+
+@Injectable()
+export class EducationMapper implements BaseMapper<PrismaEducation, Education> {
+  constructor(
+    private readonly institutionMapper: InstitutionMapper,
+    private readonly userMapper: UserMapper,
+    private readonly skillMapper: SkillMapper,
+  ) {}
+
+  /**
+   * Maps a Prisma Education entity to a domain Education entity
+   * Uses overloads to return the correct type based on input
+   */
+  toDomain(prismaEducation: null): null;
+  toDomain(prismaEducation: PrismaEducation): Education;
+  toDomain(prismaEducation: PrismaEducation | null): Education | null;
+  toDomain(prismaEducation: PrismaEducation | null): Education | null {
+    if (!prismaEducation) {
+      return null;
+    }
+
+    return new Education(
+      prismaEducation.id,
+      prismaEducation.userId,
+      this.userMapper.toDomain(prismaEducation.user),
+      prismaEducation.institutionId,
+      this.institutionMapper.toDomain(prismaEducation.institution),
+      prismaEducation.degree,
+      prismaEducation.fieldOfStudy,
+      prismaEducation.startDate,
+      prismaEducation.endDate,
+      prismaEducation.description,
+      prismaEducation.createdAt,
+      prismaEducation.updatedAt,
+      prismaEducation.skills
+        ? this.skillMapper.mapToDomain(prismaEducation.skills)
+        : undefined,
+    );
+  }
+
+  mapToDomain(prismaEducations: PrismaEducation[]): Education[] {
+    return prismaEducations
+      .map((education) => this.toDomain(education))
+      .filter((education): education is Education => education !== null);
+  }
+}

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

···
+import { Module } from "@nestjs/common";
+import { AuthModule } from "@/modules/auth/auth.module";
+import { BaseModule } from "@/modules/base/base.module";
+import { DatabaseModule } from "@/modules/database/database.module";
+import { SkillModule } from "@/modules/job-experience/skill/skill.module";
+import { UserModule } from "@/modules/user/user.module";
+import { EducationMapper } from "./education.mapper";
+import { EducationService } from "./education.service";
+import { EducationResolver } from "./graphql/education.resolver";
+import { InstitutionResolver } from "./graphql/institution.resolver";
+import { EducationUserFieldResolver } from "./graphql/user-field.resolver";
+import { InstitutionMapper } from "./institution.mapper";
+import { InstitutionService } from "./institution.service";
+
+@Module({
+  imports: [DatabaseModule, BaseModule, AuthModule, UserModule, SkillModule],
+  providers: [
+    EducationService,
+    EducationMapper,
+    EducationResolver,
+    InstitutionService,
+    InstitutionMapper,
+    InstitutionResolver,
+    EducationUserFieldResolver,
+  ],
+  exports: [EducationService, EducationMapper],
+})
+export class EducationModule {}

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

···
+import { Injectable } from "@nestjs/common";
+import type { Prisma } from "@prisma/client";
+import { notFound } from "@/modules/base/not-found.util";
+import { PaginationService } from "@/modules/base/pagination.service";
+import type {
+  PaginationOptions,
+  PaginationResult,
+} from "@/modules/base/pagination.types";
+import { PrismaService } from "@/modules/database/prisma.service";
+import { Education } from "./education.entity";
+import { EducationMapper } from "./education.mapper";
+
+@Injectable()
+export class EducationService {
+  constructor(
+    private readonly prisma: PrismaService,
+    private readonly educationMapper: EducationMapper,
+    private readonly paginationService: PaginationService,
+  ) {}
+
+  async findMany(
+    userId?: string,
+    options: PaginationOptions = {},
+  ): Promise<PaginationResult<Education>> {
+    const where: Prisma.EducationWhereInput = userId ? { userId } : {};
+    const queryOptions = this.paginationService.buildQueryOptions(
+      where,
+      { startDate: "desc" },
+      options,
+    );
+
+    const [items, totalCount] = await Promise.all([
+      this.prisma["education"].findMany({
+        ...queryOptions,
+        include: {
+          institution: true,
+          user: true,
+          skills: true,
+        },
+      }),
+      this.count(userId),
+    ]);
+
+    const domainEducations = this.educationMapper.mapToDomain(items);
+    return this.paginationService.buildPaginationResult(
+      domainEducations,
+      totalCount,
+      options,
+    );
+  }
+
+  async findManyForUser(
+    userId: string,
+    options: PaginationOptions = {},
+  ): Promise<PaginationResult<Education>> {
+    return this.findMany(userId, options);
+  }
+
+  async findById(id: string): Promise<Education | null> {
+    const education = await this.prisma["education"].findUnique({
+      where: { id },
+      include: {
+        institution: true,
+        user: true,
+        skills: true,
+      },
+    });
+    return this.educationMapper.toDomain(education);
+  }
+
+  async count(userId?: string): Promise<number> {
+    const where: Prisma.EducationWhereInput = userId ? { userId } : {};
+    return this.prisma["education"].count({
+      where,
+    });
+  }
+
+  async create(
+    userId: string,
+    data: {
+      institutionId: string;
+      degree: string;
+      fieldOfStudy?: string | null;
+      startDate: Date;
+      endDate?: Date | null;
+      description?: string | null;
+      skillIds?: string[];
+    },
+  ): Promise<Education> {
+    const createData: Prisma.EducationCreateInput = {
+      user: { connect: { id: userId } },
+      institution: { connect: { id: data.institutionId } },
+      degree: data.degree,
+      fieldOfStudy: data.fieldOfStudy ?? null,
+      startDate: data.startDate,
+      endDate: data.endDate ?? null,
+      description: data.description ?? null,
+    };
+
+    if (data.skillIds && data.skillIds.length > 0) {
+      createData.skills = {
+        connect: data.skillIds.map((id) => ({ id })),
+      };
+    }
+
+    const education = await this.prisma["education"].create({
+      data: createData,
+      include: {
+        institution: true,
+        user: true,
+        skills: true,
+      },
+    });
+    const domainEducation = this.educationMapper.toDomain(education);
+    if (!domainEducation) {
+      throw new Error("Failed to create education");
+    }
+    return domainEducation;
+  }
+
+  async findByIdOrFail(id: string): Promise<Education> {
+    const education = await this.findById(id);
+    return education ?? notFound("Education", "id", id);
+  }
+
+  async delete(id: string, userId: string): Promise<void> {
+    // Verify the education belongs to the user
+    const education = await this.findById(id);
+    if (!education || education.userId !== userId) {
+      throw new Error("Education not found or does not belong to user");
+    }
+
+    await this.prisma["education"].delete({
+      where: { id },
+    });
+  }
+}

apps/server/src/modules/education/graphql/education-connection.type.ts

···
+import { Field, Int, ObjectType } from "@nestjs/graphql";
+import { PageInfo, PaginationResult } from "@/modules/base/pagination.types";
+import type { Education as EducationEntity } from "../education.entity";
+import { Education } from "./education.type";
+import { EducationEdge } from "./education-edge.type";
+
+@ObjectType()
+export class EducationConnection {
+  @Field(() => [EducationEdge])
+  edges: EducationEdge[];
+
+  @Field(() => PageInfo)
+  pageInfo: PageInfo;
+
+  @Field(() => Int)
+  totalCount: number;
+
+  constructor(edges: EducationEdge[], pageInfo: PageInfo, totalCount: number) {
+    this.edges = edges;
+    this.pageInfo = pageInfo;
+    this.totalCount = totalCount;
+  }
+
+  /**
+   * Static factory method to create a connection from pagination result
+   */
+  static fromPaginationResult(
+    result: PaginationResult<EducationEntity>,
+  ): EducationConnection {
+    const edges = result.edges.map((edge) =>
+      EducationEdge.fromPaginationEdge({
+        cursor: edge.cursor,
+        node: Education.fromDomain(edge.node),
+      }),
+    );
+    return new EducationConnection(edges, result.pageInfo, result.totalCount);
+  }
+}

apps/server/src/modules/education/graphql/education-edge.type.ts

···
+import { Field, ObjectType } from "@nestjs/graphql";
+import { GraphQLString } from "graphql";
+import { BaseEdge } from "@/modules/base/connection.types";
+import { Education } from "./education.type";
+
+@ObjectType()
+export class EducationEdge extends BaseEdge<Education> {
+  @Field(() => GraphQLString)
+  declare cursor: string;
+
+  @Field(() => Education)
+  declare node: Education;
+}

apps/server/src/modules/education/graphql/education.resolver.ts

···
+import { UseGuards } from "@nestjs/common";
+import { Args, Mutation, Query, Resolver } from "@nestjs/graphql";
+import { CurrentUser } from "@/modules/auth/current-user.decorator";
+import { JwtAuthGuard } from "@/modules/auth/jwt-auth.guard";
+import { User } from "@/modules/user/user.type";
+import { EducationService } from "../education.service";
+import { Education } from "./education.type";
+
+@Resolver(() => Education)
+@UseGuards(JwtAuthGuard)
+export class EducationResolver {
+  constructor(private readonly educationService: EducationService) {}
+
+  @Query(() => [Education])
+  async myEducationHistory(@CurrentUser() user: User): Promise<Education[]> {
+    const result = await this.educationService.findManyForUser(user.id);
+    return result.edges
+      .map((edge) => edge.node)
+      .map((education) => Education.fromDomain(education));
+  }
+
+  @Mutation(() => Education)
+  async createEducation(
+    @CurrentUser() user: User,
+    @Args("institutionId") institutionId: string,
+    @Args("degree") degree: string,
+    @Args("startDate") startDate: Date,
+    @Args("fieldOfStudy", { nullable: true }) fieldOfStudy?: string,
+    @Args("endDate", { nullable: true }) endDate?: Date,
+    @Args("description", { nullable: true }) description?: string,
+    @Args("skillIds", { type: () => [String], nullable: true })
+    skillIds?: string[],
+  ): Promise<Education> {
+    const education = await this.educationService.create(user.id, {
+      institutionId,
+      degree,
+      fieldOfStudy: fieldOfStudy ?? null,
+      startDate,
+      endDate: endDate ?? null,
+      description: description ?? null,
+      ...(skillIds !== undefined && skillIds.length > 0 ? { skillIds } : {}),
+    });
+    return Education.fromDomain(education);
+  }
+
+  @Mutation(() => Boolean)
+  async deleteEducation(
+    @CurrentUser() user: User,
+    @Args("id") id: string,
+  ): Promise<boolean> {
+    await this.educationService.delete(id, user.id);
+    return true;
+  }
+}

apps/server/src/modules/education/graphql/education.type.ts

···
+import { Field, ObjectType } from "@nestjs/graphql";
+import { Skill } from "@/modules/job-experience/skill/graphql/skill.type";
+import { Education as EducationEntity } from "../education.entity";
+import { Institution } from "./institution.type";
+
+@ObjectType()
+export class Education {
+  @Field(() => String)
+  id: string;
+
+  @Field(() => String)
+  userId: string;
+
+  @Field(() => String)
+  institutionId: string;
+
+  @Field(() => Institution, { nullable: true })
+  institution: Institution | null;
+
+  @Field(() => String)
+  degree: string;
+
+  @Field(() => String, { nullable: true })
+  fieldOfStudy: string | null;
+
+  @Field(() => Date)
+  startDate: Date;
+
+  @Field(() => Date, { nullable: true })
+  endDate: Date | null;
+
+  @Field(() => String, { nullable: true })
+  description: string | null;
+
+  @Field(() => [Skill], { nullable: true })
+  skills: Skill[] | null;
+
+  @Field(() => Date)
+  createdAt: Date;
+
+  @Field(() => Date)
+  updatedAt: Date;
+
+  constructor(data: {
+    id: string;
+    userId: string;
+    institutionId: string;
+    institution: Institution | null;
+    degree: string;
+    fieldOfStudy: string | null;
+    startDate: Date;
+    endDate: Date | null;
+    description: string | null;
+    skills: Skill[] | null;
+    createdAt: Date;
+    updatedAt: Date;
+  }) {
+    this.id = data.id;
+    this.userId = data.userId;
+    this.institutionId = data.institutionId;
+    this.institution = data.institution;
+    this.degree = data.degree;
+    this.fieldOfStudy = data.fieldOfStudy;
+    this.startDate = data.startDate;
+    this.endDate = data.endDate;
+    this.description = data.description;
+    this.skills = data.skills;
+    this.createdAt = data.createdAt;
+    this.updatedAt = data.updatedAt;
+  }
+
+  static fromDomain(education: EducationEntity): Education {
+    return new Education({
+      id: education.id,
+      userId: education.userId,
+      institutionId: education.institutionId,
+      institution: education.institution
+        ? Institution.fromDomain(education.institution)
+        : null,
+      degree: education.degree,
+      fieldOfStudy: education.fieldOfStudy,
+      startDate: education.startDate,
+      endDate: education.endDate,
+      description: education.description,
+      skills: education.skills
+        ? education.skills.map((skill) => Skill.fromDomain(skill))
+        : null,
+      createdAt: education.createdAt,
+      updatedAt: education.updatedAt,
+    });
+  }
+}

apps/server/src/modules/education/graphql/institution.resolver.ts

···
+import { UseGuards } from "@nestjs/common";
+import { Args, Mutation, Query, Resolver } from "@nestjs/graphql";
+import { JwtAuthGuard } from "@/modules/auth/jwt-auth.guard";
+import { InstitutionService } from "../institution.service";
+import { Institution } from "./institution.type";
+
+@Resolver(() => Institution)
+@UseGuards(JwtAuthGuard)
+export class InstitutionResolver {
+  constructor(private readonly institutionService: InstitutionService) {}
+
+  @Query(() => [Institution])
+  async institutions(): Promise<Institution[]> {
+    const institutions = await this.institutionService.findMany();
+    return institutions.map((institution) =>
+      Institution.fromDomain(institution),
+    );
+  }
+
+  @Mutation(() => Institution)
+  async createInstitution(
+    @Args("name") name: string,
+    @Args("description", { nullable: true }) description?: string,
+  ): Promise<Institution> {
+    const institution = await this.institutionService.create({
+      name,
+      description: description ?? null,
+    });
+    return Institution.fromDomain(institution);
+  }
+}

apps/server/src/modules/education/graphql/institution.type.ts

···
+import { Field, ObjectType } from "@nestjs/graphql";
+import { Institution as InstitutionEntity } from "../institution.entity";
+
+@ObjectType()
+export class Institution {
+  @Field(() => String)
+  id: string;
+
+  @Field(() => String)
+  name: string;
+
+  @Field(() => String, { nullable: true })
+  description: string | null;
+
+  @Field(() => Date)
+  createdAt: Date;
+
+  @Field(() => Date)
+  updatedAt: Date;
+
+  constructor(data: {
+    id: string;
+    name: string;
+    description: string | null;
+    createdAt: Date;
+    updatedAt: Date;
+  }) {
+    this.id = data.id;
+    this.name = data.name;
+    this.description = data.description;
+    this.createdAt = data.createdAt;
+    this.updatedAt = data.updatedAt;
+  }
+
+  static fromDomain(institution: InstitutionEntity): Institution {
+    return new Institution({
+      id: institution.id,
+      name: institution.name,
+      description: institution.description,
+      createdAt: institution.createdAt,
+      updatedAt: institution.updatedAt,
+    });
+  }
+}

apps/server/src/modules/education/graphql/user-field.resolver.ts

···
+import { UseGuards } from "@nestjs/common";
+import { Args, Parent, ResolveField, Resolver } from "@nestjs/graphql";
+import { JwtAuthGuard } from "@/modules/auth/jwt-auth.guard";
+import { PaginationService } from "@/modules/base/pagination.service";
+import { PaginationArgs } from "@/modules/base/pagination.types";
+import { User } from "@/modules/user/user.type";
+import { EducationService } from "../education.service";
+import { EducationConnection } from "./education-connection.type";
+
+@Resolver(() => User)
+@UseGuards(JwtAuthGuard)
+export class EducationUserFieldResolver {
+  constructor(
+    private readonly educationService: EducationService,
+    private readonly paginationService: PaginationService,
+  ) {}
+
+  @ResolveField(() => EducationConnection, { nullable: true })
+  async educationHistory(
+    @Parent() user: User,
+    @Args() args: PaginationArgs = {},
+  ): Promise<EducationConnection> {
+    const options = this.paginationService.parsePaginationArgs(args);
+    const result = await this.educationService.findManyForUser(
+      user.id,
+      options,
+    );
+    return EducationConnection.fromPaginationResult(result);
+  }
+}

apps/server/src/modules/education/institution.entity.ts

···
+import { BaseEntity } from "@/domain/base.entity";
+
+export class Institution extends BaseEntity {
+  constructor(
+    id: string,
+    public readonly name: string,
+    public readonly description: string | null,
+    createdAt: Date,
+    updatedAt: Date,
+  ) {
+    super(id, createdAt, updatedAt);
+  }
+}

apps/server/src/modules/education/institution.mapper.ts

···
+import { Injectable } from "@nestjs/common";
+import type { Prisma } from "@prisma/client";
+import type { BaseMapper } from "@/modules/base/mapper.interface";
+import { Institution } from "./institution.entity";
+
+type PrismaInstitution = Prisma.InstitutionGetPayload<Record<string, never>>;
+
+@Injectable()
+export class InstitutionMapper
+  implements BaseMapper<PrismaInstitution, Institution>
+{
+  /**
+   * Maps a Prisma Institution entity to a domain Institution entity
+   * Uses overloads to return the correct type based on input
+   */
+  toDomain(prismaInstitution: null): null;
+  toDomain(prismaInstitution: PrismaInstitution): Institution;
+  toDomain(prismaInstitution: PrismaInstitution | null): Institution | null;
+  toDomain(prismaInstitution: PrismaInstitution | null): Institution | null {
+    if (!prismaInstitution) {
+      return null;
+    }
+
+    return new Institution(
+      prismaInstitution.id,
+      prismaInstitution.name,
+      prismaInstitution.description,
+      prismaInstitution.createdAt,
+      prismaInstitution.updatedAt,
+    );
+  }
+
+  mapToDomain(prismaInstitutions: PrismaInstitution[]): Institution[] {
+    return prismaInstitutions
+      .map((institution) => this.toDomain(institution))
+      .filter(
+        (institution): institution is Institution => institution !== null,
+      );
+  }
+}

apps/server/src/modules/education/institution.service.ts

···
+import { Injectable } from "@nestjs/common";
+import { notFound } from "@/modules/base/not-found.util";
+import { PrismaService } from "@/modules/database/prisma.service";
+import { Institution } from "./institution.entity";
+import { InstitutionMapper } from "./institution.mapper";
+
+@Injectable()
+export class InstitutionService {
+  constructor(
+    private readonly prisma: PrismaService,
+    private readonly institutionMapper: InstitutionMapper,
+  ) {}
+
+  async findMany(): Promise<Institution[]> {
+    const institutions = await this.prisma["institution"].findMany({
+      orderBy: { name: "asc" },
+    });
+    return this.institutionMapper.mapToDomain(institutions);
+  }
+
+  async findById(id: string): Promise<Institution | null> {
+    const institution = await this.prisma["institution"].findUnique({
+      where: { id },
+    });
+    return this.institutionMapper.toDomain(institution);
+  }
+
+  async findByIdOrFail(id: string): Promise<Institution> {
+    const institution = await this.findById(id);
+    return institution ?? notFound("Institution", "id", id);
+  }
+
+  async create(data: {
+    name: string;
+    description?: string | null;
+  }): Promise<Institution> {
+    const institution = await this.prisma["institution"].create({
+      data: {
+        name: data.name,
+        description: data.description ?? null,
+      },
+    });
+    const domainInstitution = this.institutionMapper.toDomain(institution);
+    if (!domainInstitution) {
+      throw new Error("Failed to create institution");
+    }
+    return domainInstitution;
+  }
+}