@aurora-interactive/sensei-productivity 1.3.0 → 1.4.0

package/rest-api/cypress/e2e/friend-endpoints.cy.js

@@ -0,0 +1,262 @@
+describe('Friend Endpoints Unit Tests', () => {
+    beforeEach(() => {
+        cy.task('clearFriendRequestsTable');
+    });
+
+    // Friends list
+    it('Getting friends list by user ID should fail due to invalid access token', () => {
+        cy.task('prepAcceptedFriendRequests');
+
+        cy.request({
+            failOnStatusCode: false,
+            method: "get",
+            url: "users/2/friends",
+            headers: {
+                "Authorization": "Bearer invalidBearer"
+            }
+        }).then(response => {
+            expect(response.status).to.equal(401, "Getting friends list by user ID should have failed with HTTP 401; different code was found instead!");
+        });
+    });
+
+    it('Getting friends list by user ID should fail due to invalid user ID', () => {
+        cy.task('prepAcceptedFriendRequests');
+
+        cy.request({
+            failOnStatusCode: false,
+            method: "get",
+            url: "users/99/friends",
+            headers: {
+                "Authorization": "Bearer 9d2272fd048bfeedda522935244fc4450fb61a9da6f7b7cea529c6c11033e9efee6b140b6e4b372f0c81a07a6e040be5150f506922e8a5c47719f7be2c707252"
+            }
+        }).then(response => {
+            expect(response.status).to.equal(404, "Getting friends list by user ID should have failed with HTTP 404; different code was found instead!");
+        });
+    });
+
+    it('Getting friends list by user ID should succeed', () => {
+        cy.task('prepAcceptedFriendRequests');
+
+        cy.request({
+            method: "get",
+            url: "users/2/friends",
+            headers: {
+                "Authorization": "Bearer 9d2272fd048bfeedda522935244fc4450fb61a9da6f7b7cea529c6c11033e9efee6b140b6e4b372f0c81a07a6e040be5150f506922e8a5c47719f7be2c707252"
+            }
+        }).then(response => {
+            expect(response.status).to.equal(200, "Getting friends list by user ID should have succeeded; got non-success code instead!");
+            expect(response.body).to.be.an("array");
+            expect(response.body.length).to.equal(1);
+        });
+    });
+
+    // Pending friend requests
+    it('Getting pending friend requests should fail due to invalid access token', () => {
+        cy.task('prepPendingFriendRequests');
+
+        cy.request({
+            failOnStatusCode: false,
+            method: "get",
+            url: "users/friends/pending",
+            headers: {
+                "Authorization": "Bearer invalidBearer"
+            }
+        }).then(response => {
+            expect(response.status).to.equal(401, "Getting pending friend requests should have failed with HTTP 401; different code was found instead!");
+        });
+    });
+
+    it('Getting pending friend requests should succeed', () => {
+        cy.task('prepPendingFriendRequests');
+
+        cy.request({
+            method: "get",
+            url: "users/friends/pending",
+            headers: {
+                "Authorization": "Bearer 9d2272fd048bfeedda522935244fc4450fb61a9da6f7b7cea529c6c11033e9efee6b140b6e4b372f0c81a07a6e040be5150f506922e8a5c47719f7be2c707252"
+            }
+        }).then(response => {
+            expect(response.status).to.equal(200, "Getting pending friend requests should have succeeded; got non-success code instead!");
+            expect(response.body).to.be.an("array");
+        });
+    });
+
+    // Send friend request
+    it('Sending friend request should fail due to invalid bearer token', () => {
+        cy.request({
+            failOnStatusCode: false,
+            method: "post",
+            url: "users/3/friend-request",
+            headers: {
+                "Authorization": "Bearer invalidBearer"
+            }
+        }).then(response => {
+            expect(response.status).to.equal(401, "Sending friend request should have failed with HTTP 404; different code was found instead!");
+        });
+    });
+
+    it('Sending friend request should fail due to invalid user ID', () => {
+        cy.request({
+            failOnStatusCode: false,
+            method: "post",
+            url: "users/99/friend-request",
+            headers: {
+                "Authorization": "Bearer 9d2272fd048bfeedda522935244fc4450fb61a9da6f7b7cea529c6c11033e9efee6b140b6e4b372f0c81a07a6e040be5150f506922e8a5c47719f7be2c707252"
+            }
+        }).then(response => {
+            expect(response.status).to.equal(404, "Sending friend request should have failed with HTTP 404; different code was found instead!");
+        });
+    });
+
+    it('Sending friend request should succeed', () => {
+        cy.request({
+            method: "post",
+            url: "users/3/friend-request",
+            headers: {
+                "Authorization": "Bearer 9d2272fd048bfeedda522935244fc4450fb61a9da6f7b7cea529c6c11033e9efee6b140b6e4b372f0c81a07a6e040be5150f506922e8a5c47719f7be2c707252"
+            }
+        }).then(response => {
+            expect(response.status).to.equal(201, "Sending friend request should have succeeded; got non-success code instead!");
+        });
+    });
+
+    // Accept pending friend request
+    // in this group; using bearer of second test user because accepting is from
+    // the requested user's perspective
+    it('Accepting friend request should fail due to invalid bearer token', () => {
+        cy.task('prepPendingFriendRequests');
+
+        cy.request({
+            failOnStatusCode: false,
+            method: "patch",
+            url: "friend-requests/2/accept",
+            headers: {
+                "Authorization": "Bearer invalidBearer"
+            }
+        }).then(response => {
+            expect(response.status).to.equal(401, "Accepting friend request should have failed with HTTP 401; different code was found instead!");
+        });
+    });
+
+    it('Accepting friend request should fail due to invalid user ID', () => {
+        cy.task('prepPendingFriendRequests');
+
+        cy.request({
+            failOnStatusCode: false,
+            method: "patch",
+            url: "friend-requests/99/accept",
+            headers: {
+                "Authorization": "Bearer 2063fef58d79e1b052b62703399fb76d3a27c3c95014f519ddd9a756dfa0d5e7b5aaddbed059ffe269ad6304504763092e6cb8854c6ec56896f9e9d3238abf3a"
+            }
+        }).then(response => {
+            expect(response.status).to.equal(404, "Accepting friend request should have failed with HTTP 404; different code was found instead!");
+        });
+    });
+
+    it('Accepting friend request should succeed', () => {
+        cy.task('prepPendingFriendRequests');
+
+        cy.request({
+            method: "patch",
+            url: "friend-requests/2/accept",
+            headers: {
+                "Authorization": "Bearer 2063fef58d79e1b052b62703399fb76d3a27c3c95014f519ddd9a756dfa0d5e7b5aaddbed059ffe269ad6304504763092e6cb8854c6ec56896f9e9d3238abf3a"
+            }
+        }).then(response => {
+            expect(response.status).to.equal(200, "Accepting friend request should have succeeded; got non-success code instead!");
+        });
+    });
+
+    // Reject pending friend request
+    // in this group; using bearer of second test user because rejecting is from
+    // the requested user's perspective
+    it('Rejecting friend request should fail due to invalid bearer token', () => {
+        cy.task('prepPendingFriendRequests');
+
+        cy.request({
+            failOnStatusCode: false,
+            method: "patch",
+            url: "friend-requests/2/reject",
+            headers: {
+                "Authorization": "Bearer invalidBearer"
+            }
+        }).then(response => {
+            expect(response.status).to.equal(401, "Rejecting friend request should have failed with HTTP 401; different code was found instead!");
+        });
+    });
+
+    it('Rejecting friend request should fail due to invalid user ID', () => {
+        cy.task('prepPendingFriendRequests');
+
+        cy.request({
+            failOnStatusCode: false,
+            method: "patch",
+            url: "friend-requests/99/reject",
+            headers: {
+                "Authorization": "Bearer 2063fef58d79e1b052b62703399fb76d3a27c3c95014f519ddd9a756dfa0d5e7b5aaddbed059ffe269ad6304504763092e6cb8854c6ec56896f9e9d3238abf3a"
+            }
+        }).then(response => {
+            expect(response.status).to.equal(404, "Rejecting friend request should have failed with HTTP 404; different code was found instead!");
+        });
+    });
+
+    it('Rejecting friend request should succeed', () => {
+        cy.task('prepPendingFriendRequests');
+
+        cy.request({
+            method: "patch",
+            url: "friend-requests/2/reject",
+            headers: {
+                "Authorization": "Bearer 2063fef58d79e1b052b62703399fb76d3a27c3c95014f519ddd9a756dfa0d5e7b5aaddbed059ffe269ad6304504763092e6cb8854c6ec56896f9e9d3238abf3a"
+            }
+        }).then(response => {
+            expect(response.status).to.equal(200, "Rejecting friend request should have succeeded; got non-success code instead!");
+        });
+    });
+
+    // Remove friend
+    it('Removing friend should fail due to invalid bearer token', () => {
+        cy.task('prepAcceptedFriendRequests');
+
+        cy.request({
+            failOnStatusCode: false,
+            method: "delete",
+            url: "users/friends/3",
+            headers: {
+                "Authorization": "Bearer invalidBearer"
+            }
+        }).then(response => {
+            expect(response.status).to.equal(401, "Removing friend should have failed with HTTP 401; different code was found instead!");
+        });
+    });
+
+    it('Removing friend should fail due to invalid friend ID', () => {
+        cy.task('prepAcceptedFriendRequests');
+
+        cy.request({
+            failOnStatusCode: false,
+            method: "delete",
+            url: "users/friends/99",
+            headers: {
+                "Authorization": "Bearer 9d2272fd048bfeedda522935244fc4450fb61a9da6f7b7cea529c6c11033e9efee6b140b6e4b372f0c81a07a6e040be5150f506922e8a5c47719f7be2c707252"
+            }
+        }).then(response => {
+            expect(response.status).to.equal(404, "Removing friend should have failed with HTTP 404; different code was found instead!");
+        });
+    });
+
+    it('Removing friend should succeed', () => {
+        cy.task('prepAcceptedFriendRequests');
+
+        cy.request({
+            failOnStatusCode: false,
+            method: "delete",
+            url: "users/friends/3",
+            headers: {
+                "Authorization": "Bearer 9d2272fd048bfeedda522935244fc4450fb61a9da6f7b7cea529c6c11033e9efee6b140b6e4b372f0c81a07a6e040be5150f506922e8a5c47719f7be2c707252"
+            }
+        }).then(response => {
+            expect(response.status).to.equal(200, "Removing friend should have succeeded; got non-success code instead!");
+        });
+    });
+});

package/rest-api/cypress/e2e/{school-endpoints.cy.ts → school-endpoints.cy.js}

@@ -25,7 +25,7 @@ describe('School Endpoints Unit Tests', () => {
                 schoolId: 1,
                 schoolName: 'Case Western Reserve University',
                 schoolNameShorthand: 'CWRU',
-                userCount: 1,
+                userCount: 2,
             });
         })
     });

package/rest-api/cypress.config.ts

@@ -8,8 +8,15 @@ export default defineConfig({
         // drop test artifacts
         async reseedUsersTable() {
           return await prisma.$transaction([
-            prisma.$executeRaw`DELETE FROM users WHERE user_id != 2;`,
-            prisma.$executeRaw`UPDATE users SET is_soft_deleted = 0, first_name = 'Unit', last_name = 'Test', username = 'UnitTester' WHERE user_id = 2;`
+            prisma.users.deleteMany({
+              where: {
+                user_id: {
+                  notIn: [2, 3]
+                }
+              }
+            }),
+            prisma.$executeRaw`UPDATE users SET is_soft_deleted = 0, first_name = 'Unit', last_name = 'Test', username = 'UnitTester' WHERE user_id = 2;`,
+            prisma.$executeRaw`UPDATE users SET is_soft_deleted = 0, first_name = 'Unit', last_name = 'Test Jr.', username = 'UnitTester2' WHERE user_id = 3;`,
           ]);
         },
 
@@ -45,6 +52,42 @@ export default defineConfig({
           return await prisma.$transaction([
             prisma.$executeRaw`REPLACE INTO User_Activity_Posts (post_id, user_id, category_name, activity_id, post_date, post_status, caption) VALUES (1, 2, 'Professional', 1, '2026-02-28 22:15:02', 'public', 'This is a test post! Nothing much going on here...');`
           ])
+        },
+
+        // tasks used for friend request unit tests to work correctly
+        async clearFriendRequestsTable() {
+          return await prisma.$transaction([
+            prisma.friend_Requests.deleteMany({})
+          ])
+        },
+
+        async prepAcceptedFriendRequests() {
+          const [res] = await prisma.$transaction([
+            prisma.friend_Requests.create({
+              data: {
+                friend_request_id: 1,
+                initiator_user_id: 2,
+                target_user_id: 3,
+                status: "accepted"
+              }
+            })
+          ]);
+          return !!res;
+        },
+
+        async prepPendingFriendRequests() {
+          const [res] = await prisma.$transaction([
+            prisma.friend_Requests.create({
+              data: {
+                friend_request_id: 1,
+                initiator_user_id: 2,
+                target_user_id: 3,
+                status: "pending"
+              }
+            })
+          ]);
+
+          return !!res;
         }
       })
     },

package/rest-api/index.js

@@ -9,6 +9,7 @@ import * as SchoolFunctions from "./routes/SchoolFunctions.js";
 import * as CategoryFunctions from "./routes/CategoryFunctions.js";
 import * as UserActivityFunctions from "./routes/UserActivityFunctions.js";
 import * as ActivityPostFunctions from "./routes/ActivityPostFunctions.js";
+import * as FriendFunctions from "./routes/FriendFunctions.js";
 
 const spec = yamlLoad(readFileSync("./api-spec.yaml"));
 
@@ -42,7 +43,13 @@ const handler = {
   getFeed: ActivityPostFunctions.getFeedHandler,
   getPostById: ActivityPostFunctions.getPostByIdHandler,
   updatePost: ActivityPostFunctions.updatePostHandler,
-  deletePost: ActivityPostFunctions.deletePostHandler
+  deletePost: ActivityPostFunctions.deletePostHandler,
+  listFriends: FriendFunctions.listFriendsHandler,
+  sendFriendRequest: FriendFunctions.sendFriendRequestHandler,
+  acceptFriendRequest: FriendFunctions.acceptFriendRequestHandler,
+  rejectFriendRequest: FriendFunctions.rejectFriendRequestHandler,
+  pendingFriendRequests: FriendFunctions.pendingFriendRequestsHandler,
+  removeFriend: FriendFunctions.removeFriendHandler
 };
 
 fastify.register(oasFastify, { spec, handler });

package/rest-api/lib/users.js

@@ -10,16 +10,18 @@ export async function getUserAuthInfo(prisma, accessToken) {
 }
 
 export async function areUsersFriends(prisma, userId, targetPotentialFriendId) {
-    const friendInfo = await prisma.User_Friends.findFirst({
+    const friendInfo = await prisma.Friend_Requests.findFirst({
         where: {
             OR: [
                 {
-                    user_id: userId,
-                    friend_id: targetPotentialFriendId,
+                    initiator_user_id: userId,
+                    target_user_id: targetPotentialFriendId,
+                    status: "accepted"
                 },
                 {
-                    user_id: targetPotentialFriendId,
-                    friend_id: userId,
+                    initiator_user_id: targetPotentialFriendId,
+                    target_user_id: userId,
+                    status: "accepted"
                 },
             ],
         },

package/rest-api/routes/FriendFunctions.js

@@ -0,0 +1,266 @@
+import { getUserAuthInfo, areUsersFriends } from "../lib/users.js";
+
+export async function listFriendsHandler(request, reply, fastify) {
+    const accessToken = (request.headers.authorization ?? "").substring(7);
+    const userInfo = await getUserAuthInfo(fastify.prisma, accessToken);
+
+    if (userInfo === null) {
+        reply.status(401);
+        return;
+    }
+
+    const targetUserCheck = await fastify.prisma.users.findFirst({
+        where: {
+            user_id: request.params.id
+        },
+        select: {
+            user_id: true
+        }
+    });
+    if (targetUserCheck === null) {
+        reply.status(404);
+        return;
+    }
+
+    const friendsList = await fastify.prisma.Friend_Requests.findMany({
+        where: {
+            OR: [
+                { initiator_user_id: request.params.id, status: "accepted" },
+                { target_user_id: request.params.id, status: "accepted" }
+            ]
+        },
+        select: {
+            users_Friend_Requests_initiator_user_idTousers: {
+                select: {
+                    user_id: true,
+                    first_name: true,
+                    last_name: true,
+                    username: true,
+                    email: true,
+                    school: {
+                        select: { school_id: true, school_name: true }
+                    }
+                }
+            },
+            users_Friend_Requests_target_user_idTousers: {
+                select: {
+                    user_id: true,
+                    first_name: true,
+                    last_name: true,
+                    username: true,
+                    email: true,
+                    school: {
+                        select: { school_id: true, school_name: true }
+                    }
+                }
+            }
+        }
+    });
+
+    return friendsList.map(friendEntry => {
+        // determine which side of the relationship is the friend (not the current user)
+        const friend = Number(friendEntry.users_Friend_Requests_initiator_user_idTousers.user_id) === request.params.id
+            ? friendEntry.users_Friend_Requests_target_user_idTousers
+            : friendEntry.users_Friend_Requests_initiator_user_idTousers;
+
+        return {
+            userId: Number(friend.user_id),
+            firstName: friend.first_name,
+            lastName: friend.last_name,
+            username: friend.username,
+            email: friend.email,
+            schoolId: Number(friend.school.school_id),
+            schoolName: friend.school.school_name,
+        };
+    });
+}
+
+export async function pendingFriendRequestsHandler(request, reply, fastify) {
+    const accessToken = (request.headers.authorization ?? "").substring(7);
+    const userInfo = await getUserAuthInfo(fastify.prisma, accessToken);
+
+    if (userInfo === null) {
+        reply.status(401);
+        return;
+    }
+
+    const pendingFriendRequests = await fastify.prisma.Friend_Requests.findMany({
+        where: {
+            target_user_id: userInfo.user_id,
+            status: "pending"
+        },
+        select: {
+            users_Friend_Requests_initiator_user_idTousers: {
+                select: {
+                    user_id: true,
+                    first_name: true,
+                    last_name: true,
+                    username: true,
+                    email: true,
+                    school: {
+                        select: { school_id: true, school_name: true }
+                    }
+                }
+            }
+        }
+    });
+
+    return pendingFriendRequests.map(friendRequest => ({
+        userId: Number(friendRequest.users_Friend_Requests_initiator_user_idTousers.user_id),
+        firstName: friendRequest.users_Friend_Requests_initiator_user_idTousers.first_name,
+        lastName: friendRequest.users_Friend_Requests_initiator_user_idTousers.last_name,
+        username: friendRequest.users_Friend_Requests_initiator_user_idTousers.username,
+        email: friendRequest.users_Friend_Requests_initiator_user_idTousers.email,
+        schoolId: Number(friendRequest.users_Friend_Requests_initiator_user_idTousers.school.school_id),
+        schoolName: friendRequest.users_Friend_Requests_initiator_user_idTousers.school.school_name,
+    }));
+}
+
+export async function sendFriendRequestHandler(request, reply, fastify) {
+    const accessToken = (request.headers.authorization ?? "").substring(7);
+    const userInfo = await getUserAuthInfo(fastify.prisma, accessToken);
+
+    if (userInfo === null) {
+        reply.status(401);
+        return;
+    }
+
+    const targetUserInfo = await fastify.prisma.users.findFirst({
+        where: {
+            user_id: request.params.id
+        },
+        select: {
+            user_id: true
+        }
+    });
+    if (targetUserInfo === null) {
+        reply.status(404);
+        return;
+    }
+
+    const areFriends = await areUsersFriends(fastify.prisma, userInfo.user_id, request.params.id);
+    if (areFriends) {
+        reply.status(400);
+        return;
+    }
+
+    await fastify.prisma.Friend_Requests.create({
+        data: {
+            initiator_user_id: userInfo.user_id,
+            target_user_id: request.params.id
+        }
+    });
+
+    reply.status(201);
+}
+
+// TODO move the core functionality code to a separate
+// library function since accept and reject friend request
+// are both very similar
+export async function acceptFriendRequestHandler(request, reply, fastify) {
+    const accessToken = (request.headers.authorization ?? "").substring(7);
+    const userInfo = await getUserAuthInfo(fastify.prisma, accessToken);
+
+    if (userInfo === null) {
+        reply.status(401);
+        return;
+    }
+
+    const friendRequest = await fastify.prisma.Friend_Requests.findFirst({
+        where: {
+            target_user_id: userInfo.user_id,
+            initiator_user_id: request.params.id,
+            status: "pending"
+        },
+        select: {
+            friend_request_id: true
+        }
+    });
+
+    if (friendRequest === null) {
+        reply.status(404);
+        return;
+    }
+
+    await fastify.prisma.Friend_Requests.update({
+        where: {
+            friend_request_id: friendRequest.friend_request_id
+        },
+        data: {
+            status: "accepted"
+        }
+    });
+}
+
+export async function rejectFriendRequestHandler(request, reply, fastify) {
+    const accessToken = (request.headers.authorization ?? "").substring(7);
+    const userInfo = await getUserAuthInfo(fastify.prisma, accessToken);
+
+    if (userInfo === null) {
+        reply.status(401);
+        return;
+    }
+
+    const friendRequest = await fastify.prisma.Friend_Requests.findFirst({
+        where: {
+            target_user_id: userInfo.user_id,
+            initiator_user_id: request.params.id,
+            status: "pending"
+        },
+        select: {
+            friend_request_id: true
+        }
+    });
+
+    if (friendRequest === null) {
+        reply.status(404);
+        return;
+    }
+
+    await fastify.prisma.Friend_Requests.delete({
+        where: {
+            friend_request_id: friendRequest.friend_request_id
+        }
+    });
+}
+
+export async function removeFriendHandler(request, reply, fastify) {
+    const accessToken = (request.headers.authorization ?? "").substring(7);
+    const userInfo = await getUserAuthInfo(fastify.prisma, accessToken);
+
+    if (userInfo === null) {
+        reply.status(401);
+        return;
+    }
+
+    const friendship = await fastify.prisma.Friend_Requests.findFirst({
+        where: {
+            OR: [
+                {
+                    initiator_user_id: userInfo.user_id,
+                    target_user_id: request.params.friendId,
+                    status: "accepted"
+                },
+                {
+                    initiator_user_id: request.params.friendId,
+                    target_user_id: userInfo.user_id,
+                    status: "accepted"
+                },
+            ],
+        },
+        select: {
+            friend_request_id: true
+        }
+    });
+
+    if (friendship === null) {
+        reply.status(404);
+        return;
+    }
+
+    await fastify.prisma.Friend_Requests.delete({
+        where: {
+            friend_request_id: friendship.friend_request_id
+        }
+    });
+}

package/rest-api/routes/UserActivityFunctions.js

@@ -1,7 +1,7 @@
 import { getUserAuthInfo, areUsersFriends } from "../lib/users.js";
 
 export async function getUserActivitiesHandler(request, reply, fastify) {
-    const accessToken = (request.headers.authorization ?? "").substring(7)
+    const accessToken = (request.headers.authorization ?? "").substring(7);
     const targetUserId = request.params.id;
     const userInfo = await getUserAuthInfo(fastify.prisma, accessToken);