add: project-defined-roles

Author: fazlulShanto

apps/api/package.json

@@ -37,6 +37,7 @@
     "zod": "^3.24.1"
   },
   "devDependencies": {
+    "@faker-js/faker": "^9.8.0",
     "@repo/eslint-config": "workspace:*",
     "@repo/typescript-config": "workspace:*",
     "@types/jsonwebtoken": "^9.0.8",

apps/api/src/modules/index.ts

@@ -5,6 +5,7 @@ import auth from "./auth";
 import userRoutes from "./user";
 import project from "./project";
 import labels from "./labels";
+import statuses from "./statuses";
 
 const getOptionsWithPrefix = (
   options: FastifyPluginOptions,
@@ -33,6 +34,10 @@ export default fastifyPlugin(
         labels,
         getOptionsWithPrefix(options, "/edge/projects/:projectId/labels")
       ),
+      fastify.register(
+        statuses,
+        getOptionsWithPrefix(options, "/edge/projects/:projectId/statuses")
+      ),
     ]);
   }
 );

apps/api/src/modules/statuses/index.ts

@@ -0,0 +1,9 @@
+import type { FastifyInstance, FastifyPluginOptions } from "fastify";
+import { fastifyPlugin } from "fastify-plugin";
+import StatusRoute from "./status.route";
+
+export default fastifyPlugin(
+  async (fastify: FastifyInstance, options: FastifyPluginOptions) => {
+    await fastify.register(StatusRoute, options);
+  }
+);

apps/api/src/modules/statuses/status.controller.ts

@@ -0,0 +1,94 @@
+import type { FastifyReply, FastifyRequest } from "fastify";
+import type StatusService from "./status.service";
+
+export default class StatusController {
+  constructor(private statusService: StatusService) {}
+
+  async createStatus(
+    request: FastifyRequest<{
+      Body: {
+        name: string;
+        color: string;
+        description: string;
+        order: number;
+      };
+      Params: { projectId: string };
+    }>,
+    reply: FastifyReply
+  ) {
+    const status = await this.statusService.createStatus({
+      ...request.body,
+      projectId: request.params.projectId,
+      creatorId: request.jwtUser.id,
+    });
+
+    return reply.status(201).send({ status });
+  }
+
+  async getStatusById(
+    request: FastifyRequest<{
+      Params: { statusId: string };
+    }>,
+    reply: FastifyReply
+  ) {
+    const status = await this.statusService.getStatusById(
+      request.params.statusId
+    );
+
+    if (!status) {
+      return reply.status(404).send({
+        statusCode: 404,
+        error: "Not Found",
+        message: "Status not found",
+      });
+    }
+
+    return reply.send({ status });
+  }
+
+  async getStatusesByProjectId(
+    request: FastifyRequest<{
+      Params: { projectId: string };
+    }>,
+    reply: FastifyReply
+  ) {
+    const statuses = await this.statusService.getStatusesByProjectId(
+      request.params.projectId
+    );
+
+    return reply.send({ statuses });
+  }
+
+  async updateStatus(
+    request: FastifyRequest<{
+      Params: { statusId: string };
+      Body: {
+        name?: string;
+        color?: string;
+        description?: string;
+        order?: number;
+      };
+    }>,
+    reply: FastifyReply
+  ) {
+    const status = await this.statusService.updateStatus(
+      request.params.statusId,
+      request.body
+    );
+
+    return reply.send({ status });
+  }
+
+  async deleteStatus(
+    request: FastifyRequest<{
+      Params: { statusId: string };
+    }>,
+    reply: FastifyReply
+  ) {
+    const status = await this.statusService.deleteStatus(
+      request.params.statusId
+    );
+
+    return reply.send({ status });
+  }
+}

apps/api/src/modules/statuses/status.route.ts

@@ -0,0 +1,93 @@
+import type { FastifyInstance } from "fastify";
+import StatusController from "./status.controller";
+import StatusService from "./status.service";
+import { statusSchemas, statusSchemaRef } from "./status.schema";
+
+export default function StatusRoutes(fastify: FastifyInstance) {
+  // Register schemas
+  for (const schema of statusSchemas) {
+    fastify.addSchema(schema);
+  }
+
+  const statusController = new StatusController(new StatusService());
+
+  // Create a new status
+  fastify.post(
+    "/",
+    {
+      onRequest: [fastify.jwtAuth],
+      schema: {
+        tags: ["Task Statuses"],
+        description: "Create a new task status",
+        body: statusSchemaRef("createStatusSchema"),
+        response: {
+          201: statusSchemaRef("statusResponse"),
+          400: statusSchemaRef("errorResponse"),
+        },
+      },
+    },
+    // @ts-expect-error - this is a bug in fastify-zod
+    statusController.createStatus.bind(statusController)
+  );
+
+  // Get all statuses of a project
+  fastify.get(
+    "/",
+    {
+      onRequest: [fastify.jwtAuth],
+      schema: {
+        tags: ["Task Statuses"],
+        description: "Get all task statuses of a project",
+        params: {
+          type: "object",
+          properties: {
+            projectId: { type: "string" },
+          },
+          required: ["projectId"],
+        },
+        response: {
+          200: statusSchemaRef("statusesResponse"),
+        },
+      },
+    },
+    // @ts-expect-error - this is a bug in fastify-zod
+    statusController.getStatusesByProjectId.bind(statusController)
+  );
+
+  // Update a status
+  fastify.put(
+    "/:statusId",
+    {
+      onRequest: [fastify.jwtAuth],
+      schema: {
+        tags: ["Task Statuses"],
+        description: "Update a task status",
+        body: statusSchemaRef("updateStatusSchema"),
+        response: {
+          200: statusSchemaRef("statusResponse"),
+          400: statusSchemaRef("errorResponse"),
+        },
+      },
+    },
+    // @ts-expect-error - this is a bug in fastify-zod
+    statusController.updateStatus.bind(statusController)
+  );
+
+  // Delete a status
+  fastify.delete(
+    "/:statusId",
+    {
+      onRequest: [fastify.jwtAuth],
+      schema: {
+        tags: ["Task Statuses"],
+        description: "Delete a task status",
+        response: {
+          200: statusSchemaRef("statusResponse"),
+          400: statusSchemaRef("errorResponse"),
+        },
+      },
+    },
+    // @ts-expect-error - this is a bug in fastify-zod
+    statusController.deleteStatus.bind(statusController)
+  );
+}

apps/api/src/modules/statuses/status.schema.ts

@@ -0,0 +1,57 @@
+import { z } from "zod";
+import { buildJsonSchemas } from "fastify-zod";
+
+const ProjectStatus = {
+  id: z.string().uuid(),
+  name: z.string(),
+  color: z.string(),
+  description: z.string(),
+  projectId: z.string().uuid(),
+  creatorId: z.string().uuid(),
+  order: z.number().int(),
+};
+
+const createStatusSchema = z.object({
+  name: z.string().min(1).max(50),
+  color: z.string(),
+  description: z.string(),
+  order: z.number().int().min(0),
+});
+
+const updateStatusSchema = z.object({
+  name: z.string().min(1).max(50).optional(),
+  color: z.string().optional(),
+  description: z.string().optional(),
+  order: z.number().int().min(0).optional(),
+});
+
+const statusResponseSchema = z.object({
+  status: z.object(ProjectStatus),
+});
+
+const statusesResponseSchema = z.object({
+  statuses: z.array(z.object(ProjectStatus)),
+});
+
+const errorResponseSchema = z.object({
+  statusCode: z.number(),
+  error: z.string(),
+  message: z.string(),
+});
+
+const statusSchemaWithId = z.object({
+  id: z.string().uuid(),
+});
+
+export const { schemas: statusSchemas, $ref: statusSchemaRef } =
+  buildJsonSchemas(
+    {
+      createStatusSchema,
+      updateStatusSchema,
+      statusResponse: statusResponseSchema,
+      statusesResponse: statusesResponseSchema,
+      errorResponse: errorResponseSchema,
+      statusSchemaWithId,
+    } as const,
+    { $id: "StatusSchema" }
+  );

apps/api/src/modules/statuses/status.service.ts

@@ -0,0 +1,26 @@
+import { StatusDal, type DbNewStatus, type DbStatus } from "@taskcord/database";
+
+export default class StatusService {
+  public async createStatus(input: DbNewStatus) {
+    return StatusDal.createStatus(input);
+  }
+
+  public async getStatusById(id: string) {
+    return StatusDal.getStatusById(id);
+  }
+
+  public async getStatusesByProjectId(projectId: string): Promise<DbStatus[]> {
+    return StatusDal.getStatusesByProjectId(projectId);
+  }
+
+  public async updateStatus(
+    id: string,
+    data: Partial<DbNewStatus>
+  ): Promise<DbStatus | null> {
+    return StatusDal.updateStatus(id, data);
+  }
+
+  public async deleteStatus(id: string): Promise<DbStatus | null> {
+    return StatusDal.deleteStatus(id);
+  }
+}

apps/api/src/modules/user/user.controller.ts

@@ -43,4 +43,13 @@ export default class UserController {
 
     return reply.send(discordServerList);
   }
+
+  public async createDummyUsers(
+    request: FastifyRequest<{ Querystring: { userCount?: number } }>,
+    reply: FastifyReply
+  ) {
+    const userCount = request.query.userCount || 10;
+    const createdUsers = await this.userService.createDummyUser(userCount);
+    return reply.send(createdUsers);
+  }
 }

apps/api/src/modules/user/user.route.ts

@@ -27,6 +27,7 @@ export default function AuthRoute(fastify: FastifyInstance) {
     },
     userController.me.bind(userController)
   );
+
   fastify.get(
     "/discord/guilds",
     {
@@ -42,4 +43,25 @@ export default function AuthRoute(fastify: FastifyInstance) {
     },
     userController.getUserDiscordServerList.bind(userController)
   );
+
+  if (["local", "staging"].includes(process.env.NODE_ENV)) {
+    fastify.post(
+      "/dummy",
+      {
+        onRequest: [fastify.jwtAuth],
+        schema: {
+          tags: ["User"],
+          description: "Create dummy users",
+          query: {
+            type: "object",
+            properties: {
+              userCount: { type: "number" },
+            },
+          },
+        },
+      },
+      // @ts-expect-error - this is a bug in fastify-zod
+      userController.createDummyUsers.bind(userController)
+    );
+  }
 }