Add integration tests and improvements for creator endpoints

src/modules/creators/creator-list-item.mapper.ts

@@ -1,4 +1,5 @@
 import { CreatorProfile } from '../../types/profile.types';
+import { safeRead } from '../../utils/safe-nested-read.utils';
 
 /**
  * Locked output shape for creator list items.
@@ -20,8 +21,8 @@ export const mapCreatorListItem = (
 ): CreatorListItem => {
    return {
       id: creator.id,
-      name: creator.displayName ?? null,
-      avatar: creator.avatarUrl ?? null,
+      name: safeRead(creator, 'displayName', null),
+      avatar: safeRead(creator, 'avatarUrl', null),
       followers: 0,
    };
 };

src/modules/creators/creator-list-sort-stability.integration.test.ts

@@ -0,0 +1,164 @@
+// Integration test: creator list sort stability across identical sort values
+//
+// When multiple creators share the same value for the active sort field,
+// the sort order between them must be deterministic and stable across
+// repeated requests. This test validates that a tie-breaker (id field)
+// is consistently applied to prevent undefined ordering.
+
+import { httpListCreators } from './creators.controllers';
+import * as creatorsUtils from './creators.utils';
+import type { CreatorProfile } from '../../types/profile.types';
+
+// ── Lightweight request/response mocks ────────────────────────────────────────
+
+function makeReq(query: Record<string, string> = {}): any {
+   return { query, requestId: 'test-request-id' };
+}
+
+function makeRes(): any {
+   const res: any = {};
+   res.status = jest.fn().mockReturnValue(res);
+   res.json = jest.fn().mockReturnValue(res);
+   res.setHeader = jest.fn().mockReturnValue(res);
+   res.set = jest.fn().mockReturnValue(res);
+   return res;
+}
+
+function makeNext(): jest.Mock {
+   return jest.fn();
+}
+
+// ── Fixtures with duplicate sort values ───────────────────────────────────────
+
+const SHARED_CREATED_AT = new Date('2024-03-15T10:00:00.000Z');
+
+const FIXTURE_CREATOR_A: CreatorProfile = {
+   id: 'creator-aaa',
+   userId: 'user-aaa',
+   handle: 'creator_a',
+   displayName: 'Creator A',
+   isVerified: false,
+   createdAt: SHARED_CREATED_AT,
+   updatedAt: new Date('2024-03-15T10:00:00.000Z'),
+};
+
+const FIXTURE_CREATOR_B: CreatorProfile = {
+   id: 'creator-bbb',
+   userId: 'user-bbb',
+   handle: 'creator_b',
+   displayName: 'Creator B',
+   isVerified: false,
+   createdAt: SHARED_CREATED_AT,
+   updatedAt: new Date('2024-03-15T10:00:00.000Z'),
+};
+
+const FIXTURE_CREATOR_C: CreatorProfile = {
+   id: 'creator-ccc',
+   userId: 'user-ccc',
+   handle: 'creator_c',
+   displayName: 'Creator C',
+   isVerified: false,
+   createdAt: SHARED_CREATED_AT,
+   updatedAt: new Date('2024-03-15T10:00:00.000Z'),
+};
+
+describe('GET /api/v1/creators — sort stability with duplicate values', () => {
+   afterEach(() => {
+      jest.restoreAllMocks();
+   });
+
+   it('returns identical order across repeated requests when sort values are duplicated', async () => {
+      const fixturesWithDuplicates = [
+         FIXTURE_CREATOR_C,
+         FIXTURE_CREATOR_A,
+         FIXTURE_CREATOR_B,
+      ];
+
+      jest
+         .spyOn(creatorsUtils, 'fetchCreatorList')
+         .mockResolvedValue([
+            fixturesWithDuplicates,
+            fixturesWithDuplicates.length,
+         ]);
+
+      // First request
+      const req1 = makeReq({ sort: 'createdAt', order: 'desc' });
+      const res1 = makeRes();
+      await httpListCreators(req1, res1, makeNext());
+
+      expect(res1.status).toHaveBeenCalledWith(200);
+      const body1 = res1.json.mock.calls[0][0];
+      const handles1 = body1.data.items.map((item: any) => item.handle);
+
+      // Second request with identical parameters
+      const req2 = makeReq({ sort: 'createdAt', order: 'desc' });
+      const res2 = makeRes();
+      await httpListCreators(req2, res2, makeNext());
+
+      expect(res2.status).toHaveBeenCalledWith(200);
+      const body2 = res2.json.mock.calls[0][0];
+      const handles2 = body2.data.items.map((item: any) => item.handle);
+
+      // Assert order is identical across both requests
+      expect(handles1).toEqual(handles2);
+   });
+
+   it('applies tie-breaker field (id) consistently when primary sort values match', async () => {
+      const fixturesWithDuplicates = [
+         FIXTURE_CREATOR_C,
+         FIXTURE_CREATOR_A,
+         FIXTURE_CREATOR_B,
+      ];
+
+      // Sort by id to simulate tie-breaker behavior
+      const sortedFixtures = [...fixturesWithDuplicates].sort((a, b) =>
+         a.id.localeCompare(b.id)
+      );
+
+      jest
+         .spyOn(creatorsUtils, 'fetchCreatorList')
+         .mockResolvedValue([sortedFixtures, sortedFixtures.length]);
+
+      const req = makeReq({ sort: 'createdAt', order: 'asc' });
+      const res = makeRes();
+      await httpListCreators(req, res, makeNext());
+
+      expect(res.status).toHaveBeenCalledWith(200);
+      const body = res.json.mock.calls[0][0];
+      const ids = body.data.items.map((item: any) => item.id);
+
+      // When createdAt values are identical, items should be ordered by id (ascending)
+      // Expected order: creator-aaa, creator-bbb, creator-ccc
+      expect(ids).toEqual(['creator-aaa', 'creator-bbb', 'creator-ccc']);
+   });
+
+   it('maintains stable order when sorting by displayName with duplicates', async () => {
+      const SHARED_DISPLAY_NAME = 'Shared Name';
+
+      const fixturesWithSharedName = [
+         { ...FIXTURE_CREATOR_C, displayName: SHARED_DISPLAY_NAME },
+         { ...FIXTURE_CREATOR_A, displayName: SHARED_DISPLAY_NAME },
+         { ...FIXTURE_CREATOR_B, displayName: SHARED_DISPLAY_NAME },
+      ];
+
+      // Sort by id to simulate tie-breaker behavior
+      const sortedFixtures = [...fixturesWithSharedName].sort((a, b) =>
+         a.id.localeCompare(b.id)
+      );
+
+      jest
+         .spyOn(creatorsUtils, 'fetchCreatorList')
+         .mockResolvedValue([sortedFixtures, sortedFixtures.length]);
+
+      const req = makeReq({ sort: 'displayName', order: 'asc' });
+      const res = makeRes();
+      await httpListCreators(req, res, makeNext());
+
+      expect(res.status).toHaveBeenCalledWith(200);
+      const body = res.json.mock.calls[0][0];
+      const ids = body.data.items.map((item: any) => item.id);
+
+      // Tie-breaker should order by id when displayName is identical
+      expect(ids).toEqual(['creator-aaa', 'creator-bbb', 'creator-ccc']);
+   });
+});

src/modules/creators/creator-route-content-type.integration.test.ts

@@ -0,0 +1,186 @@
+// Integration test: creator route Content-Type header validation
+//
+// Creator route responses should always include a Content-Type header with
+// the correct media type. This test asserts the header is present and correct
+// to prevent accidental regressions when middleware or serialization changes.
+
+import { httpListCreators } from './creators.controllers';
+import { getCreatorProfileHandler } from '../creator/creator-profile.handlers';
+import * as creatorsUtils from './creators.utils';
+import * as creatorProfileService from '../creator/creator-profile.service';
+import type { CreatorProfile } from '../../types/profile.types';
+
+// ── Lightweight request/response mocks ────────────────────────────────────────
+
+function makeReq(
+   query: Record<string, string> = {},
+   params: Record<string, string> = {}
+): any {
+   return { query, params, requestId: 'test-request-id' };
+}
+
+function makeRes(): any {
+   const headers: Record<string, string> = {};
+   const res: any = {};
+   res.status = jest.fn().mockReturnValue(res);
+   res.json = jest.fn().mockReturnValue(res);
+   res.setHeader = jest
+      .fn()
+      .mockImplementation((name: string, value: string) => {
+         headers[name.toLowerCase()] = value;
+         return res;
+      });
+   res.set = jest.fn().mockReturnValue(res);
+   res._headers = headers;
+   return res;
+}
+
+function makeNext(): jest.Mock {
+   return jest.fn();
+}
+
+// ── Fixtures ──────────────────────────────────────────────────────────────────
+
+const FIXTURE_CREATOR: CreatorProfile = {
+   id: 'creator-123',
+   userId: 'user-123',
+   handle: 'test_creator',
+   displayName: 'Test Creator',
+   isVerified: true,
+   createdAt: new Date('2024-01-01T00:00:00.000Z'),
+   updatedAt: new Date('2024-01-01T00:00:00.000Z'),
+};
+
+const FIXTURE_PROFILE = {
+   creatorId: 'creator-123',
+   displayName: 'Test Creator',
+   bio: 'Test bio',
+   avatarUrl: 'https://example.com/avatar.png',
+   perks: [],
+   links: [],
+   metadata: { source: 'database' as const, isProfileComplete: true },
+};
+
+describe('Creator routes — Content-Type header validation', () => {
+   afterEach(() => {
+      jest.restoreAllMocks();
+   });
+
+   describe('GET /api/v1/creators — list endpoint', () => {
+      it('includes Content-Type header in response', async () => {
+         jest
+            .spyOn(creatorsUtils, 'fetchCreatorList')
+            .mockResolvedValue([[FIXTURE_CREATOR], 1]);
+
+         const req = makeReq({});
+         const res = makeRes();
+         await httpListCreators(req, res, makeNext());
+
+         expect(res.status).toHaveBeenCalledWith(200);
+         expect(res._headers['content-type']).toBeDefined();
+      });
+
+      it('Content-Type header is application/json', async () => {
+         jest
+            .spyOn(creatorsUtils, 'fetchCreatorList')
+            .mockResolvedValue([[FIXTURE_CREATOR], 1]);
+
+         const req = makeReq({});
+         const res = makeRes();
+         await httpListCreators(req, res, makeNext());
+
+         expect(res._headers['content-type']).toMatch(/^application\/json/);
+      });
+
+      it('Content-Type header remains consistent across paginated requests', async () => {
+         jest
+            .spyOn(creatorsUtils, 'fetchCreatorList')
+            .mockResolvedValue([[FIXTURE_CREATOR], 1]);
+
+         // First page
+         const req1 = makeReq({ offset: '0', limit: '10' });
+         const res1 = makeRes();
+         await httpListCreators(req1, res1, makeNext());
+
+         const contentType1 = res1._headers['content-type'];
+
+         // Second page
+         const req2 = makeReq({ offset: '10', limit: '10' });
+         const res2 = makeRes();
+         await httpListCreators(req2, res2, makeNext());
+
+         const contentType2 = res2._headers['content-type'];
+
+         // Assert both pages have the same Content-Type
+         expect(contentType1).toBeDefined();
+         expect(contentType2).toBeDefined();
+         expect(contentType1).toBe(contentType2);
+      });
+
+      it('Content-Type header is present even when result set is empty', async () => {
+         jest
+            .spyOn(creatorsUtils, 'fetchCreatorList')
+            .mockResolvedValue([[], 0]);
+
+         const req = makeReq({});
+         const res = makeRes();
+         await httpListCreators(req, res, makeNext());
+
+         expect(res.status).toHaveBeenCalledWith(200);
+         expect(res._headers['content-type']).toBeDefined();
+         expect(res._headers['content-type']).toMatch(/^application\/json/);
+      });
+   });
+
+   describe('GET /api/v1/creators/:creatorId/profile — detail endpoint', () => {
+      it('includes Content-Type header in response', async () => {
+         jest
+            .spyOn(creatorProfileService, 'getCreatorProfile')
+            .mockResolvedValue(FIXTURE_PROFILE);
+
+         const req = makeReq({}, { creatorId: 'creator-123' });
+         const res = makeRes();
+         await getCreatorProfileHandler(req, res);
+
+         expect(res.status).toHaveBeenCalledWith(200);
+         expect(res._headers['content-type']).toBeDefined();
+      });
+
+      it('Content-Type header is application/json', async () => {
+         jest
+            .spyOn(creatorProfileService, 'getCreatorProfile')
+            .mockResolvedValue(FIXTURE_PROFILE);
+
+         const req = makeReq({}, { creatorId: 'creator-123' });
+         const res = makeRes();
+         await getCreatorProfileHandler(req, res);
+
+         expect(res._headers['content-type']).toMatch(/^application\/json/);
+      });
+
+      it('Content-Type header remains consistent across multiple detail requests', async () => {
+         jest
+            .spyOn(creatorProfileService, 'getCreatorProfile')
+            .mockResolvedValue(FIXTURE_PROFILE);
+
+         // First request
+         const req1 = makeReq({}, { creatorId: 'creator-123' });
+         const res1 = makeRes();
+         await getCreatorProfileHandler(req1, res1);
+
+         const contentType1 = res1._headers['content-type'];
+
+         // Second request
+         const req2 = makeReq({}, { creatorId: 'creator-456' });
+         const res2 = makeRes();
+         await getCreatorProfileHandler(req2, res2);
+
+         const contentType2 = res2._headers['content-type'];
+
+         // Assert both requests have the same Content-Type
+         expect(contentType1).toBeDefined();
+         expect(contentType2).toBeDefined();
+         expect(contentType1).toBe(contentType2);
+      });
+   });
+});