feat: Add new API handlers for user, project, and task management; update package dependencies

tasker-server/src/handlers/createProject.ts

@@ -0,0 +1,40 @@
+import { DynamoDB } from "aws-sdk";
+import { v4 as uuidv4 } from "uuid";
+
+const SLS_REGION = process.env.SLS_REGION;
+const TASKER_PROJECT_TABLE_NAME = process.env.TASKER_PROJECT_TABLE_NAME || "";
+
+const docClient = new DynamoDB.DocumentClient({ region: SLS_REGION });
+
+export const handler = async (event: any): Promise<any> => {
+  const { name, description, startDate, endDate } = event.body;
+  try {
+    const newProject = {
+      type: "projects",
+      projectId: `project#${uuidv4()}`,
+      name,
+      description,
+      startDate,
+      endDate,
+    };
+
+    const params = {
+      TableName: TASKER_PROJECT_TABLE_NAME,
+      Item: newProject,
+    };
+
+    await docClient.put(params).promise();
+
+    return {
+      status: 201,
+      body: JSON.stringify(newProject),
+    };
+  } catch (error: any) {
+    return {
+      status: 500,
+      body: JSON.stringify({
+        message: `Error creating project: ${error.message}`,
+      }),
+    };
+  }
+};

tasker-server/src/handlers/createTask.ts

@@ -0,0 +1,59 @@
+import { DynamoDB } from "aws-sdk";
+import { v4 as uuidv4 } from "uuid";
+
+const SLS_REGION = process.env.SLS_REGION;
+const TASKER_TASK_TABLE_NAME = process.env.TASKER_TASK_TABLE_NAME || "";
+
+const docClient = new DynamoDB.DocumentClient({ region: SLS_REGION });
+
+export const handler = async (event: any): Promise<any> => {
+  const {
+    title,
+    description,
+    status,
+    priority,
+    tags,
+    startDate,
+    dueDate,
+    points,
+    projectId,
+    authorUserId,
+    assignedUserId,
+  } = event.body;
+  try {
+    const newTask = {
+      type: "tasks",
+      taskId: `task#${uuidv4()}`,
+      title,
+      description,
+      status,
+      priority,
+      tags,
+      startDate,
+      dueDate,
+      points,
+      projectId,
+      authorUserId,
+      assignedUserId,
+    };
+
+    const params = {
+      TableName: TASKER_TASK_TABLE_NAME,
+      Item: newTask,
+    };
+
+    await docClient.put(params).promise();
+
+    return {
+      status: 201,
+      body: JSON.stringify(newTask),
+    };
+  } catch (error: any) {
+    return {
+      status: 500,
+      body: JSON.stringify({
+        message: `Error creating task: ${error.message}`,
+      }),
+    };
+  }
+};

tasker-server/src/handlers/createUser.ts

@@ -0,0 +1,43 @@
+import { fetchRandomTeamId } from "@/lib/util";
+import { DynamoDB } from "aws-sdk";
+import { v4 as uuidv4 } from "uuid";
+
+const SLS_REGION = process.env.SLS_REGION;
+const TASKER_USER_TABLE_NAME = process.env.TASKER_USER_TABLE_NAME || "";
+
+const docClient = new DynamoDB.DocumentClient({ region: SLS_REGION });
+
+export const handler = async (event: any): Promise<any> => {
+  const { username, cognitoId, profilePictureUrl = "i0.jpg" } = event.body;
+  const teamId = fetchRandomTeamId();
+
+  try {
+    const newUser = {
+      type: "users",
+      cognitoId,
+      userId: `user#${uuidv4()}`,
+      username,
+      profilePictureUrl,
+      teamId,
+    };
+
+    const params = {
+      TableName: TASKER_USER_TABLE_NAME,
+      Item: newUser,
+    };
+
+    await docClient.put(params).promise();
+
+    return {
+      status: 201,
+      body: JSON.stringify(newUser),
+    };
+  } catch (error: any) {
+    return {
+      status: 500,
+      body: JSON.stringify({
+        message: `Error creating user: ${error.message}`,
+      }),
+    };
+  }
+};

tasker-server/src/handlers/getProjects.ts

@@ -0,0 +1,32 @@
+import { DynamoDB } from "aws-sdk";
+
+const SLS_REGION = process.env.SLS_REGION;
+const TASKER_PROJECT_TABLE_NAME = process.env.TASKER_PROJECT_TABLE_NAME || "";
+
+const docClient = new DynamoDB.DocumentClient({ region: SLS_REGION });
+
+export const handler = async (event: any): Promise<any> => {
+  try {
+    const params = {
+      TableName: TASKER_PROJECT_TABLE_NAME,
+      KeyConditionExpression: "type = :type",
+      ExpressionAttributeValues: {
+        ":type": "projects",
+      },
+    };
+
+    const projects = await docClient.query(params).promise();
+
+    return {
+      status: 200,
+      body: JSON.stringify(projects.Items),
+    };
+  } catch (error: any) {
+    return {
+      status: 500,
+      body: JSON.stringify({
+        message: `Error retrieving projects: ${error.message}`,
+      }),
+    };
+  }
+};

tasker-server/src/handlers/getTasks.ts

@@ -0,0 +1,65 @@
+import {
+  fetchAttachments,
+  fetchComments,
+  fetchUserWithUserId,
+} from "@/lib/util";
+import { DynamoDB } from "aws-sdk";
+
+const SLS_REGION = process.env.SLS_REGION;
+const TASKER_TASK_TABLE_NAME = process.env.TASKER_TASK_TABLE_NAME || "";
+
+const docClient = new DynamoDB.DocumentClient({ region: SLS_REGION });
+
+export const handler = async (event: any): Promise<any> => {
+  const { projectId } = event.queryStringParameters;
+  try {
+    const params = {
+      TableName: TASKER_TASK_TABLE_NAME,
+      KeyConditionExpression: "type = :type AND projectId = :projectId",
+      IndexName: "GSI-project-id",
+      ExpressionAttributeValues: {
+        ":type": "tasks",
+        ":projectId": projectId,
+      },
+    };
+
+    const result = await docClient.query(params).promise();
+    const tasks = result.Items || [];
+
+    const tasksWithDetails = await Promise.all(
+      tasks.map(async (task: any) => {
+        const author = task.authorUserId
+          ? await fetchUserWithUserId(task.authorUserId)
+          : null;
+
+        const assignee = task.assignedUserId
+          ? await fetchUserWithUserId(task.assignedUserId)
+          : null;
+
+        const comments = await fetchComments(task.taskId);
+
+        const attachments = await fetchAttachments(task.taskId);
+
+        return {
+          ...task,
+          author,
+          assignee,
+          comments,
+          attachments,
+        };
+      })
+    );
+
+    return {
+      status: 200,
+      body: JSON.stringify(tasksWithDetails),
+    };
+  } catch (error: any) {
+    return {
+      status: 500,
+      body: JSON.stringify({
+        message: `Error retrieving tasks: ${error.message}`,
+      }),
+    };
+  }
+};

tasker-server/src/handlers/getTeams.ts

@@ -0,0 +1,52 @@
+import { fetchUserWithUserId } from "@/lib/util";
+import { DynamoDB } from "aws-sdk";
+
+const SLS_REGION = process.env.SLS_REGION;
+const TASKER_TEAM_TABLE_NAME = process.env.TASKER_TEAM_TABLE_NAME || "";
+
+const docClient = new DynamoDB.DocumentClient({ region: SLS_REGION });
+
+export const handler = async (event: any): Promise<any> => {
+  try {
+    const params = {
+      TableName: TASKER_TEAM_TABLE_NAME,
+      KeyConditionExpression: "type = :type",
+      ExpressionAttributeValues: {
+        ":type": "teams",
+      },
+    };
+
+    const result = await docClient.query(params).promise();
+    const teams = result.Items || [];
+
+    const teamsWithUsernames = await Promise.all(
+      teams.map(async (team: any) => {
+        const productOwnerUsername = team.productOwnerUserId
+          ? (await fetchUserWithUserId(team.productOwnerUserId))?.username
+          : null;
+
+        const projectManagerUsername = team.projectManagerUserId
+          ? (await fetchUserWithUserId(team.projectManagerUserId))?.username
+          : null;
+
+        return {
+          ...team,
+          productOwnerUsername,
+          projectManagerUsername,
+        };
+      })
+    );
+
+    return {
+      status: 200,
+      body: JSON.stringify(teamsWithUsernames),
+    };
+  } catch (error: any) {
+    return {
+      status: 500,
+      body: JSON.stringify({
+        message: `Error retrieving teams: ${error.message}`,
+      }),
+    };
+  }
+};

tasker-server/src/handlers/getUser.ts

@@ -0,0 +1,34 @@
+import { DynamoDB } from "aws-sdk";
+
+const SLS_REGION = process.env.SLS_REGION;
+const TASKER_USER_TABLE_NAME = process.env.TASKER_USER_TABLE_NAME || "";
+
+const docClient = new DynamoDB.DocumentClient({ region: SLS_REGION });
+
+export const handler = async (event: any): Promise<any> => {
+  const { cognitoId } = event.pathParameters;
+  try {
+    const params = {
+      TableName: TASKER_USER_TABLE_NAME,
+      KeyConditionExpression: "type = :type AND cognitoId = :cognitoId",
+      ExpressionAttributeValues: {
+        ":type": "users",
+        ":cognitoId": cognitoId,
+      },
+    };
+
+    const user = await docClient.query(params).promise();
+
+    return {
+      status: 200,
+      body: JSON.stringify(user.Items?.[0] || {}),
+    };
+  } catch (error: any) {
+    return {
+      status: 500,
+      body: JSON.stringify({
+        message: `Error retrieving user: ${error.message}`,
+      }),
+    };
+  }
+};

tasker-server/src/handlers/getUserTasks.ts

@@ -0,0 +1,32 @@
+import { queryTasks } from "@/lib/util";
+
+export const handler = async (event: any): Promise<any> => {
+  const { userId } = event.pathParameters;
+  try {
+    const authorTasks = await queryTasks(
+      userId,
+      "GSI-author-user-id",
+      "authorUserId"
+    );
+
+    const assigneeTasks = await queryTasks(
+      userId,
+      "GSI-assigned-user-id",
+      "assignedUserId"
+    );
+
+    const userTasks = [...authorTasks, ...assigneeTasks];
+
+    return {
+      status: 200,
+      body: JSON.stringify(userTasks),
+    };
+  } catch (error: any) {
+    return {
+      status: 500,
+      body: JSON.stringify({
+        message: `Error retrieving tasks for user: ${error.message}`,
+      }),
+    };
+  }
+};

tasker-server/src/handlers/getUsers.ts

@@ -0,0 +1,32 @@
+import { DynamoDB } from "aws-sdk";
+
+const SLS_REGION = process.env.SLS_REGION;
+const TASKER_USER_TABLE_NAME = process.env.TASKER_USER_TABLE_NAME || "";
+
+const docClient = new DynamoDB.DocumentClient({ region: SLS_REGION });
+
+export const handler = async (event: any): Promise<any> => {
+  try {
+    const params = {
+      TableName: TASKER_USER_TABLE_NAME,
+      KeyConditionExpression: "type = :type",
+      ExpressionAttributeValues: {
+        ":type": "users",
+      },
+    };
+
+    const users = await docClient.query(params).promise();
+
+    return {
+      status: 200,
+      body: JSON.stringify(users.Items),
+    };
+  } catch (error: any) {
+    return {
+      status: 500,
+      body: JSON.stringify({
+        message: `Error retrieving users: ${error.message}`,
+      }),
+    };
+  }
+};

tasker-server/src/handlers/updateTaskStatus.ts

@@ -0,0 +1,42 @@
+import { DynamoDB } from "aws-sdk";
+
+const SLS_REGION = process.env.SLS_REGION;
+const TASKER_TASK_TABLE_NAME = process.env.TASKER_TASK_TABLE_NAME || "";
+
+const docClient = new DynamoDB.DocumentClient({ region: SLS_REGION });
+
+export const handler = async (event: any): Promise<any> => {
+  const { taskId } = event.pathParameters;
+  const { status } = event.body;
+  try {
+    const params = {
+      TableName: TASKER_TASK_TABLE_NAME,
+      Key: {
+        type: "tasks",
+        taskId,
+      },
+      UpdateExpression: "set #status = :status",
+      ExpressionAttributeNames: {
+        "#status": "status",
+      },
+      ExpressionAttributeValues: {
+        ":status": status,
+      },
+      ReturnValues: "ALL_NEW",
+    };
+
+    const updatedTask = await docClient.update(params).promise();
+
+    return {
+      status: 200,
+      body: JSON.stringify(updatedTask.Attributes),
+    };
+  } catch (error: any) {
+    return {
+      status: 500,
+      body: JSON.stringify({
+        message: `Error updating task: ${error.message}`,
+      }),
+    };
+  }
+};

tasker-server/src/lib/util.ts

@@ -0,0 +1,95 @@
+import { DynamoDB } from "aws-sdk";
+
+const SLS_REGION = process.env.SLS_REGION;
+const TASKER_PROJECT_TABLE_NAME = process.env.TASKER_PROJECT_TABLE_NAME || "";
+const TASKER_USER_TABLE_NAME = process.env.TASKER_USER_TABLE_NAME || "";
+const TASKER_TASK_TABLE_NAME = process.env.TASKER_TASK_TABLE_NAME || "";
+const TASKER_TASK_EXTRA_TABLE_NAME =
+  process.env.TASKER_TASK_EXTRA_TABLE_NAME || "";
+
+const docClient = new DynamoDB.DocumentClient({ region: SLS_REGION });
+
+export const fetchRandomTeamId = async () => {
+  const params = {
+    TableName: TASKER_PROJECT_TABLE_NAME,
+    KeyConditionExpression: "type = :type",
+    ExpressionAttributeValues: {
+      ":type": "teams",
+    },
+  };
+
+  const projects = await docClient.query(params).promise();
+  if (!projects.Items) {
+    return null;
+  }
+  const randomProject =
+    projects.Items[Math.floor(Math.random() * projects.Items.length)];
+  return randomProject.id;
+};
+
+export const fetchUserWithUserId = async (userId: string): Promise<any> => {
+  const params: DynamoDB.DocumentClient.QueryInput = {
+    TableName: TASKER_USER_TABLE_NAME,
+    KeyConditionExpression: "type = :type AND userId = :userId",
+    IndexName: "GSI-user-id",
+    ExpressionAttributeValues: {
+      ":type": "users",
+      ":userId": userId,
+    },
+  };
+
+  const result = await docClient.query(params).promise();
+  return result.Items?.[0];
+};
+
+export const fetchComments = async (taskId: string): Promise<any> => {
+  const params: DynamoDB.DocumentClient.QueryInput = {
+    TableName: TASKER_TASK_EXTRA_TABLE_NAME,
+    KeyConditionExpression: "type = :type AND taskId = :taskId",
+    IndexName: "GSI-task-id",
+    ExpressionAttributeValues: {
+      ":type": "comments",
+      ":taskId": taskId,
+    },
+  };
+
+  const result = await docClient.query(params).promise();
+  return result.Items;
+};
+
+export const fetchAttachments = async (taskId: string): Promise<any> => {
+  const params: DynamoDB.DocumentClient.QueryInput = {
+    TableName: TASKER_TASK_EXTRA_TABLE_NAME,
+    KeyConditionExpression: "type = :type AND taskId = :taskId",
+    IndexName: "GSI-task-id",
+    ExpressionAttributeValues: {
+      ":type": "attachments",
+      ":taskId": taskId,
+    },
+  };
+
+  const result = await docClient.query(params).promise();
+  return result.Items;
+};
+
+export const queryTasks = async (
+  userId: string,
+  indexName: string,
+  key: string
+): Promise<DynamoDB.ItemList> => {
+  const params = {
+    TableName: TASKER_TASK_TABLE_NAME,
+    KeyConditionExpression: "type = :type AND #key = :userId",
+    IndexName: indexName,
+    ExpressionAttributeValues: {
+      ":type": "tasks",
+      ":userId": userId,
+    },
+    ExpressionAttributeNames: {
+      "#key": key,
+    },
+  };
+
+  const result = await docClient.query(params).promise();
+  return result.Items ?? [];
+};