services/internal/controllers/role.controller

import { FastifyInstance } from "fastify";
import { z } from "zod";
import {
  FastifyZodOpenApiSchema,
  FastifyZodOpenApiTypeProvider,
} from "fastify-zod-openapi";
import {
  createApiResponse,
  createSuccessResponse,
  createErrorResponse,
  MessageCode,
  InternalMessageCode,
  errorResponseSchema,
} from "../../../types/api-resource";
import { RoleCreationError } from "../../../repositories/role.repository";
import { createRoleSchema, roleResponseSchema } from "../schemas/role.schema";

export function registerRoleRoutes(fastify: FastifyInstance) {
  fastify.withTypeProvider<FastifyZodOpenApiTypeProvider>().route({
    method: "POST",
    url: "/role",
    schema: {
      body: createRoleSchema,
      response: {
        201: createApiResponse(roleResponseSchema),
        400: errorResponseSchema,
        500: {
          content: {
            "application/json": {
              schema: errorResponseSchema,
            },
          },
        },
      },
      description: "Create a new role",
      tags: ["Role"],
    } satisfies FastifyZodOpenApiSchema,
    handler: async (request, reply) => {
      const { name, description, logto_id } = request.body;

      const roleRepository = fastify.roleRepository;

      const db = fastify.db;

      if (!roleRepository) {
        return reply
          .status(500)
          .send(
            createErrorResponse(
              "Role repository not found",
              MessageCode.INTERNAL_ERROR,
              500,
              InternalMessageCode.INTERNAL_ERROR
            )
          );
      }

      try {
        const role = await roleRepository.create({
          name,
          description,
          logto_id,
        });

        return reply
          .status(201)
          .send(createSuccessResponse(role, "Role created successfully", 201));
      } catch (error) {
        if (error instanceof RoleCreationError) {
          return reply
            .status(500)
            .send(
              createErrorResponse(
                error.message,
                MessageCode.INTERNAL_ERROR,
                500,
                InternalMessageCode.DATABASE_ERROR
              )
            );
        }

        return reply
          .status(500)
          .send(
            createErrorResponse(
              "Internal server error",
              MessageCode.INTERNAL_ERROR,
              500,
              InternalMessageCode.INTERNAL_ERROR
            )
          );
      }
    },
  });
}