feat(server): add CV template system with GraphQL support

apps/server/prisma/migrations/20251025120015_add_cv_template_system/migration.sql

···
+-- CreateTable
+CREATE TABLE "cv_templates" (
+    "id" TEXT NOT NULL,
+    "name" TEXT NOT NULL,
+    "description" TEXT,
+    "category" TEXT NOT NULL,
+    "isDefault" BOOLEAN NOT NULL DEFAULT false,
+    "isActive" BOOLEAN NOT NULL DEFAULT true,
+    "thumbnail" TEXT,
+    "config" JSONB NOT NULL,
+    "html" TEXT NOT NULL,
+    "css" TEXT NOT NULL,
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" TIMESTAMP(3) NOT NULL,
+
+    CONSTRAINT "cv_templates_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable
+CREATE TABLE "cvs" (
+    "id" TEXT NOT NULL,
+    "userId" TEXT NOT NULL,
+    "templateId" TEXT NOT NULL,
+    "title" TEXT NOT NULL,
+    "content" JSONB NOT NULL,
+    "isPublic" BOOLEAN NOT NULL DEFAULT false,
+    "isActive" BOOLEAN NOT NULL DEFAULT true,
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" TIMESTAMP(3) NOT NULL,
+
+    CONSTRAINT "cvs_pkey" PRIMARY KEY ("id")
+);
+
+-- AddForeignKey
+ALTER TABLE "cvs" ADD CONSTRAINT "cvs_userId_fkey" FOREIGN KEY ("userId") REFERENCES "users"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "cvs" ADD CONSTRAINT "cvs_templateId_fkey" FOREIGN KEY ("templateId") REFERENCES "cv_templates"("id") ON DELETE RESTRICT ON UPDATE CASCADE;

apps/server/prisma/migrations/20251026154204_simplify_cv_template_schema/migration.sql

···
+-- AlterTable
+ALTER TABLE "cv_templates" DROP COLUMN "category",
+DROP COLUMN "config",
+DROP COLUMN "css",
+DROP COLUMN "html",
+DROP COLUMN "isActive",
+DROP COLUMN "isDefault",
+DROP COLUMN "thumbnail";
+
+-- AlterTable
+ALTER TABLE "cvs" DROP COLUMN "content",
+DROP COLUMN "isActive",
+DROP COLUMN "isPublic";
+

apps/server/prisma/migrations/20251026203242_add_cv_fields/migration.sql

···
+-- AlterTable
+ALTER TABLE "cvs" ADD COLUMN     "education" JSONB,
+ADD COLUMN     "introduction" TEXT;
+
+-- AlterTable
+ALTER TABLE "memberships" RENAME CONSTRAINT "user_organizations_pkey" TO "memberships_pkey";
+
+-- RenameForeignKey
+ALTER TABLE "memberships" RENAME CONSTRAINT "user_organizations_organizationId_fkey" TO "memberships_organizationId_fkey";
+
+-- RenameForeignKey
+ALTER TABLE "memberships" RENAME CONSTRAINT "user_organizations_organizationRoleId_fkey" TO "memberships_organizationRoleId_fkey";
+
+-- RenameForeignKey
+ALTER TABLE "memberships" RENAME CONSTRAINT "user_organizations_userId_fkey" TO "memberships_userId_fkey";
+
+-- RenameIndex
+ALTER INDEX "user_organizations_userId_organizationId_key" RENAME TO "memberships_userId_organizationId_key";

apps/server/src/modules/cv-template/cv-template.mapper.ts

···
+import type { CVTemplate as PrismaCVTemplate } from "@prisma/client";
+import { CVTemplate } from "./graphql/cv-template.type";
+
+export const cvTemplateMapper = {
+  toDomain: (template: PrismaCVTemplate): CVTemplate => {
+    return new CVTemplate({
+      id: template.id,
+      name: template.name,
+      description: template.description,
+      createdAt: template.createdAt,
+      updatedAt: template.updatedAt,
+    });
+  },
+
+  mapToDomain: (templates: PrismaCVTemplate[]): CVTemplate[] => {
+    return templates.map((template) => cvTemplateMapper.toDomain(template));
+  },
+};

apps/server/src/modules/cv-template/cv-template.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 { CVService } from "./cv.service";
+import { CVTemplateService } from "./cv-template.service";
+import { CVResolver, CVTemplateResolver } from "./graphql/cv-template.resolver";
+import { CVUserFieldResolver } from "./graphql/user-field.resolver";
+import { CVTemplateSeedService } from "./seed/cv-template.seed";
+
+@Module({
+  imports: [DatabaseModule, BaseModule, AuthModule],
+  providers: [
+    CVTemplateService,
+    CVService,
+    CVTemplateResolver,
+    CVResolver,
+    CVTemplateSeedService,
+    CVUserFieldResolver,
+  ],
+  exports: [CVTemplateService, CVService],
+})
+export class CVTemplateModule {}

apps/server/src/modules/cv-template/cv-template.service.ts

···
+import { Injectable } from "@nestjs/common";
+import { notFound } from "@/modules/base/not-found.util";
+import { PrismaService } from "@/modules/database/prisma.service";
+import { cvTemplateMapper } from "./cv-template.mapper";
+
+type CVTemplateFilters = Record<string, never>;
+
+@Injectable()
+export class CVTemplateService {
+  constructor(private readonly prisma: PrismaService) {}
+
+  async findMany(filters: CVTemplateFilters = {}) {
+    const templates = await this.prisma["cVTemplate"].findMany({
+      orderBy: { createdAt: "desc" },
+    });
+
+    return cvTemplateMapper.mapToDomain(templates);
+  }
+
+  async count(filters: CVTemplateFilters = {}) {
+    return this.prisma["cVTemplate"].count();
+  }
+
+  async findById(id: string) {
+    const template = await this.prisma["cVTemplate"].findUnique({
+      where: { id },
+    });
+
+    return template ? cvTemplateMapper.toDomain(template) : null;
+  }
+
+  async findByIdOrFail(id: string) {
+    const template = await this.findById(id);
+    return template ?? notFound("CVTemplate", "id", id);
+  }
+}

apps/server/src/modules/cv-template/cv.mapper.ts

···
+import type {
+  CV as PrismaCV,
+  CVTemplate as PrismaCVTemplate,
+} from "@prisma/client";
+import { cvTemplateMapper } from "./cv-template.mapper";
+import { CV } from "./graphql/cv.type";
+
+export type PrismaCVWithTemplate = PrismaCV & {
+  template: PrismaCVTemplate;
+};
+
+export const cvMapper = {
+  toDomain: (cv: PrismaCVWithTemplate): CV => {
+    return new CV({
+      id: cv.id,
+      title: cv.title,
+      introduction: cv.introduction ?? null,
+      template: cvTemplateMapper.toDomain(cv.template),
+      createdAt: cv.createdAt,
+      updatedAt: cv.updatedAt,
+    });
+  },
+
+  mapToDomain: (cvs: PrismaCVWithTemplate[]): CV[] => {
+    return cvs.map((cv) => cvMapper.toDomain(cv));
+  },
+};

apps/server/src/modules/cv-template/cv.service.ts

···
+import { Injectable } from "@nestjs/common";
+import { notFound } from "@/modules/base/not-found.util";
+import { PrismaService } from "@/modules/database/prisma.service";
+import { cvMapper } from "./cv.mapper";
+
+type CVFilters = {
+  userId: string;
+};
+
+@Injectable()
+export class CVService {
+  constructor(private readonly prisma: PrismaService) {}
+
+  async findMany(filters: CVFilters) {
+    const cvs = await this.prisma["cV"].findMany({
+      where: { userId: filters.userId },
+      orderBy: { updatedAt: "desc" },
+      include: {
+        template: true,
+      },
+    });
+
+    return cvMapper.mapToDomain(cvs);
+  }
+
+  async count(filters: CVFilters) {
+    return this.prisma["cV"].count({
+      where: { userId: filters.userId },
+    });
+  }
+
+  async findById(id: string) {
+    const cv = await this.prisma["cV"].findUnique({
+      where: { id },
+      include: {
+        template: true,
+      },
+    });
+
+    return cv ? cvMapper.toDomain(cv) : null;
+  }
+
+  async findByIdOrFail(id: string) {
+    const cv = await this.findById(id);
+    return cv ?? notFound("CV", "id", id);
+  }
+
+  async create(
+    userId: string,
+    data: {
+      templateId: string;
+      title: string;
+    },
+  ) {
+    const cv = await this.prisma["cV"].create({
+      data: {
+        userId,
+        templateId: data.templateId,
+        title: data.title,
+      },
+      include: {
+        template: true,
+      },
+    });
+
+    return cvMapper.toDomain(cv);
+  }
+
+  async update(
+    id: string,
+    data: {
+      title?: string;
+    },
+  ) {
+    const updateData: Record<string, unknown> = {};
+
+    if (data.title !== undefined) {
+      updateData["title"] = data.title;
+    }
+
+    const cv = await this.prisma["cV"].update({
+      where: { id },
+      data: updateData,
+      include: {
+        template: true,
+      },
+    });
+
+    return cvMapper.toDomain(cv);
+  }
+
+  async delete(id: string): Promise<void> {
+    await this.prisma["cV"].delete({
+      where: { id },
+    });
+  }
+}

apps/server/src/modules/cv-template/graphql/cv-args.type.ts

···
+import { ArgsType, Field, Int } from "@nestjs/graphql";
+
+@ArgsType()
+export class CVArgs {
+  @Field(() => Int, { nullable: true })
+  first?: number | null;
+
+  @Field(() => String, { nullable: true })
+  after?: string | null;
+
+  @Field(() => Int, { nullable: true })
+  last?: number | null;
+
+  @Field(() => String, { nullable: true })
+  before?: string | null;
+}

apps/server/src/modules/cv-template/graphql/cv-connection.type.ts

···
+import { Field, Int, ObjectType } from "@nestjs/graphql";
+import { PageInfo, PaginationResult } from "@/modules/base/pagination.types";
+import { CV } from "./cv.type";
+import { CVEdge } from "./cv-edge.type";
+
+@ObjectType()
+export class CVConnection {
+  @Field(() => [CVEdge])
+  edges: CVEdge[];
+
+  @Field(() => PageInfo)
+  pageInfo: PageInfo;
+
+  @Field(() => Int)
+  totalCount: number;
+
+  constructor(edges: CVEdge[], 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<CV>): CVConnection {
+    const edges = result.edges.map((edge) =>
+      CVEdge.fromPaginationEdge({
+        cursor: edge.cursor,
+        node: edge.node,
+      }),
+    );
+    return new CVConnection(edges, result.pageInfo, result.totalCount);
+  }
+}

apps/server/src/modules/cv-template/graphql/cv-edge.type.ts

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

apps/server/src/modules/cv-template/graphql/cv-input.type.ts

···
+import { Field, InputType } from "@nestjs/graphql";
+
+@InputType()
+export class CreateCVInput {
+  @Field(() => String)
+  templateId!: string;
+
+  @Field(() => String)
+  title!: string;
+}
+
+@InputType()
+export class UpdateCVInput {
+  @Field(() => String, { nullable: true })
+  title?: string;
+}

apps/server/src/modules/cv-template/graphql/cv-template-args.type.ts

···
+import { ArgsType, Field, Int } from "@nestjs/graphql";
+
+@ArgsType()
+export class CVTemplateArgs {
+  @Field(() => Int, { nullable: true })
+  first?: number | null;
+
+  @Field(() => String, { nullable: true })
+  after?: string | null;
+
+  @Field(() => Int, { nullable: true })
+  last?: number | null;
+
+  @Field(() => String, { nullable: true })
+  before?: string | null;
+}

apps/server/src/modules/cv-template/graphql/cv-template-connection.type.ts

···
+import { Field, Int, ObjectType } from "@nestjs/graphql";
+import { PageInfo, PaginationResult } from "@/modules/base/pagination.types";
+import { CVTemplate } from "./cv-template.type";
+import { CVTemplateEdge } from "./cv-template-edge.type";
+
+@ObjectType()
+export class CVTemplateConnection {
+  @Field(() => [CVTemplateEdge])
+  edges: CVTemplateEdge[];
+
+  @Field(() => PageInfo)
+  pageInfo: PageInfo;
+
+  @Field(() => Int)
+  totalCount: number;
+
+  constructor(edges: CVTemplateEdge[], 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<CVTemplate>,
+  ): CVTemplateConnection {
+    const edges = result.edges.map((edge) =>
+      CVTemplateEdge.fromPaginationEdge({
+        cursor: edge.cursor,
+        node: edge.node,
+      }),
+    );
+    return new CVTemplateConnection(edges, result.pageInfo, result.totalCount);
+  }
+}

apps/server/src/modules/cv-template/graphql/cv-template-edge.type.ts

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

apps/server/src/modules/cv-template/graphql/cv-template.resolver.ts

···
+import { UseGuards } from "@nestjs/common";
+import { Args, Context, Mutation, Query, Resolver } from "@nestjs/graphql";
+import { JwtAuthGuard } from "@/modules/auth/jwt-auth.guard";
+import { PaginationService } from "@/modules/base/pagination.service";
+import { CVService } from "../cv.service";
+import { CVTemplateService } from "../cv-template.service";
+import { CV } from "./cv.type";
+import { CVArgs } from "./cv-args.type";
+import { CVConnection } from "./cv-connection.type";
+import { CreateCVInput, UpdateCVInput } from "./cv-input.type";
+import { CVTemplate } from "./cv-template.type";
+import { CVTemplateArgs } from "./cv-template-args.type";
+import { CVTemplateConnection } from "./cv-template-connection.type";
+
+@Resolver(() => CVTemplate)
+export class CVTemplateResolver {
+  constructor(
+    private readonly cvTemplateService: CVTemplateService,
+    private readonly paginationService: PaginationService,
+  ) {}
+
+  @Query(() => CVTemplateConnection)
+  async cvTemplates(
+    @Args() args: CVTemplateArgs = {},
+  ): Promise<CVTemplateConnection> {
+    const options = this.paginationService.parsePaginationArgs(args);
+
+    const [items, totalCount] = await Promise.all([
+      this.cvTemplateService.findMany({}),
+      this.cvTemplateService.count({}),
+    ]);
+
+    const result = this.paginationService.buildPaginationResult(
+      items,
+      totalCount,
+      options,
+    );
+
+    return CVTemplateConnection.fromPaginationResult(result);
+  }
+
+  @Query(() => CVTemplate, { nullable: true })
+  async cvTemplate(@Args("id") id: string) {
+    return this.cvTemplateService.findById(id);
+  }
+}
+
+@Resolver(() => CV)
+export class CVResolver {
+  constructor(
+    private readonly cvService: CVService,
+    private readonly paginationService: PaginationService,
+  ) {}
+
+  @Query(() => CVConnection)
+  @UseGuards(JwtAuthGuard)
+  async myCVs(
+    @Args() args: CVArgs = {},
+    @Context() context: { req: { user: { id: string } } },
+  ): Promise<CVConnection> {
+    const userId = context.req.user.id;
+    const options = this.paginationService.parsePaginationArgs(args);
+
+    const [items, totalCount] = await Promise.all([
+      this.cvService.findMany({ userId }),
+      this.cvService.count({ userId }),
+    ]);
+
+    const result = this.paginationService.buildPaginationResult(
+      items,
+      totalCount,
+      options,
+    );
+
+    return CVConnection.fromPaginationResult(result);
+  }
+
+  @Query(() => CV, { nullable: true })
+  @UseGuards(JwtAuthGuard)
+  async cv(@Args("id") id: string) {
+    return this.cvService.findById(id);
+  }
+
+  @Mutation(() => CV)
+  @UseGuards(JwtAuthGuard)
+  async createCV(
+    @Args("input") input: CreateCVInput,
+    @Context() context: { req: { user: { id: string } } },
+  ) {
+    const userId = context.req.user.id;
+    return this.cvService.create(userId, input);
+  }
+
+  @Mutation(() => CV)
+  @UseGuards(JwtAuthGuard)
+  async updateCV(@Args("id") id: string, @Args("input") input: UpdateCVInput) {
+    return this.cvService.update(id, input);
+  }
+
+  @Mutation(() => Boolean)
+  @UseGuards(JwtAuthGuard)
+  async deleteCV(@Args("id") id: string) {
+    return this.cvService.delete(id);
+  }
+}

apps/server/src/modules/cv-template/graphql/cv-template.type.ts

···
+import { Field, ID, ObjectType } from "@nestjs/graphql";
+
+@ObjectType()
+export class CVTemplate {
+  @Field(() => ID)
+  id: string;
+
+  @Field(() => Date)
+  createdAt: Date;
+
+  @Field(() => Date)
+  updatedAt: Date;
+
+  @Field(() => String)
+  name: string;
+
+  @Field(() => String, { nullable: true })
+  description?: string | null;
+
+  constructor(data: {
+    id: string;
+    name: string;
+    description?: string | null;
+    createdAt: Date;
+    updatedAt: Date;
+  }) {
+    this.id = data.id;
+    this.createdAt = data.createdAt;
+    this.updatedAt = data.updatedAt;
+    this.name = data.name;
+    this.description = data.description ?? null;
+  }
+}

apps/server/src/modules/cv-template/graphql/cv.type.ts

···
+import { Field, ID, ObjectType } from "@nestjs/graphql";
+import { CVTemplate } from "./cv-template.type";
+
+@ObjectType()
+export class CV {
+  @Field(() => ID)
+  id: string;
+
+  @Field(() => Date)
+  createdAt: Date;
+
+  @Field(() => Date)
+  updatedAt: Date;
+
+  @Field(() => String)
+  title: string;
+
+  @Field(() => String, { nullable: true })
+  introduction: string | null;
+
+  @Field(() => CVTemplate)
+  template: CVTemplate;
+
+  constructor(data: {
+    id: string;
+    title: string;
+    introduction?: string | null;
+    template: CVTemplate;
+    createdAt: Date;
+    updatedAt: Date;
+  }) {
+    this.id = data.id;
+    this.createdAt = data.createdAt;
+    this.updatedAt = data.updatedAt;
+    this.title = data.title;
+    this.introduction = data.introduction ?? null;
+    this.template = data.template;
+  }
+}

apps/server/src/modules/cv-template/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 { User } from "@/modules/user/user.type";
+import { CVService } from "../cv.service";
+import { CVArgs } from "./cv-args.type";
+import { CVConnection } from "./cv-connection.type";
+
+@Resolver(() => User)
+@UseGuards(JwtAuthGuard)
+export class CVUserFieldResolver {
+  constructor(
+    private readonly cvService: CVService,
+    private readonly paginationService: PaginationService,
+  ) {}
+
+  @ResolveField(() => CVConnection, { nullable: true })
+  async cvs(
+    @Parent() user: User,
+    @Args() args: CVArgs = {},
+  ): Promise<CVConnection> {
+    const options = this.paginationService.parsePaginationArgs(args);
+    const [items, totalCount] = await Promise.all([
+      this.cvService.findMany({ userId: user.id }),
+      this.cvService.count({ userId: user.id }),
+    ]);
+    const result = this.paginationService.buildPaginationResult(
+      items,
+      totalCount,
+      options,
+    );
+    return CVConnection.fromPaginationResult(result);
+  }
+}