Allow getting a profile by id or username

Author: hussein-m-kandil

src/api/v1/profiles/profiles.router.ts

@@ -24,9 +24,9 @@ profilesRouter.get('/followers', Validators.authValidator, async (req, res) => {
   res.json(await Service.getAllFollowers(userId, filters));
 });
 
-profilesRouter.get('/:id', Validators.authValidator, async (req, res) => {
+profilesRouter.get('/:idOrUsername', Validators.authValidator, async (req, res) => {
   const userId = Utils.getCurrentUserIdFromReq(req)!;
-  res.json(await Service.getProfileById(req.params.id, userId));
+  res.json(await Service.getProfileByIdOrUsername(req.params.idOrUsername, userId));
 });
 
 profilesRouter.patch('/', Validators.authValidator, async (req, res) => {

src/api/v1/profiles/profiles.service.ts

@@ -1,7 +1,7 @@
 import * as Types from '@/types';
 import * as Utils from '@/lib/utils';
 import * as Schema from './profile.schema';
-import { AppNotFoundError, AppUniqueConstraintViolationError } from '@/lib/app-error';
+import * as AppError from '@/lib/app-error';
 import { Prisma, Profile, User } from '@/../prisma/client';
 import db from '@/lib/db';
 
@@ -76,7 +76,29 @@ export const getProfileById = async (profileId: Profile['id'], userId: User['id'
     }),
   );
   if (profile) return prepareProfileData(profile, userId);
-  throw new AppNotFoundError('Profile not found');
+  throw new AppError.AppNotFoundError('Profile not found');
+};
+
+export const getProfileByUsername = async (username: User['username'], userId: User['id']) => {
+  const profiles = await Utils.handleDBKnownErrors(
+    db.profile.findMany({
+      ...getExtendedProfileAggregationArgs(userId),
+      where: { user: { username } },
+    }),
+  );
+  if (profiles.length === 1) return prepareProfileData(profiles[0], userId);
+  throw new AppError.AppNotFoundError('Profile not found');
+};
+
+export const getProfileByIdOrUsername = async (idOrUsername: string, userId: User['id']) => {
+  try {
+    return await getProfileByUsername(idOrUsername, userId);
+  } catch (error) {
+    if (error instanceof AppError.AppNotFoundError) {
+      return await getProfileById(idOrUsername, userId);
+    }
+    throw error;
+  }
 };
 
 export const updateProfileByUserId = async (userId: User['id'], data: Schema.ValidProfile) => {
@@ -102,7 +124,7 @@ export const createFollowing = async (userId: User['id'], { profileId }: Schema.
       }),
     );
   } catch (error) {
-    if (error instanceof AppUniqueConstraintViolationError) return;
+    if (error instanceof AppError.AppUniqueConstraintViolationError) return;
     throw error;
   }
 };
@@ -112,7 +134,7 @@ export const deleteFollowing = async (userId: User['id'], { profileId }: Schema.
     await Utils.handleDBKnownErrors(
       db.$transaction(async (prismaClient) => {
         const currentProfile = await prismaClient.profile.findUnique({ where: { userId } });
-        if (!currentProfile) throw new AppNotFoundError('Profile not found');
+        if (!currentProfile) throw new AppError.AppNotFoundError('Profile not found');
         await prismaClient.follows.delete({
           where: { profileId_followerId: { followerId: currentProfile.id, profileId } },
         });

src/tests/api/v1/profiles.int.test.ts

@@ -145,21 +145,33 @@ describe('Profile', async () => {
         });
       });
 
-      describe(`${PROFILES_URL}/:id`, () => {
-        it('should respond with 401 on an unauthenticated request', async () => {
-          const res = await api.get(`${PROFILES_URL}/${dbUserOne.profile!.id}`);
-          assertUnauthorizedErrorRes(res);
-        });
-
-        it('should respond with a profile, on an authenticated request', async () => {
-          const { authorizedApi } = await prepForAuthorizedTest(userOneData);
-          const res = await authorizedApi.get(`${PROFILES_URL}/${dbUserOne.profile!.id}`);
-          const profile = res.body as Types.PublicProfile;
-          expect(res.statusCode).toBe(200);
-          expect(res.type).toMatch(/json/);
-          assertPublicProfile(profile);
+      const getProfileTestData = [
+        { key: 'id', value: dbUserOne.profile!.id },
+        { key: 'username', value: dbUserOne.username },
+      ];
+      for (const { key, value } of getProfileTestData) {
+        describe(`${PROFILES_URL}/:${key}`, () => {
+          it('should respond with 401 on an unauthenticated request', async () => {
+            const res = await api.get(`${PROFILES_URL}/${value}`);
+            assertUnauthorizedErrorRes(res);
+          });
+
+          it(`should respond with 400 on an invalid ${key}`, async () => {
+            const { authorizedApi } = await prepForAuthorizedTest(userOneData);
+            const res = await authorizedApi.get(`${PROFILES_URL}/invalid`);
+            assertInvalidIdErrorRes(res);
+          });
+
+          it('should respond with a profile', async () => {
+            const { authorizedApi } = await prepForAuthorizedTest(userOneData);
+            const res = await authorizedApi.get(`${PROFILES_URL}/${value}`);
+            const profile = res.body as Types.PublicProfile;
+            expect(res.statusCode).toBe(200);
+            expect(res.type).toMatch(/json/);
+            assertPublicProfile(profile);
+          });
         });
-      });
+      }
 
       describe(`${PROFILES_URL}/following`, () => {
         const sortedUsers = dbAllUsersSorted.filter((u) => u.id !== dbUserOne.id);