Updates for MM submission list performance

Author: jmgasper

src/api/submission/submission.service.spec.ts

@@ -1190,6 +1190,72 @@ describe('SubmissionService', () => {
       ]);
     });
 
+    it('filters latest submissions before pagination when isLatest=true', async () => {
+      const latestSubmission = {
+        id: 'submission-new',
+        challengeId: 'challenge-1',
+        memberId: 'member-1',
+        submittedDate: new Date('2024-01-02T12:00:00Z'),
+        createdAt: new Date('2024-01-02T12:00:00Z'),
+        updatedAt: new Date('2024-01-02T12:00:00Z'),
+        type: SubmissionType.CONTEST_SUBMISSION,
+        status: SubmissionStatus.ACTIVE,
+        review: [],
+        reviewSummation: [],
+        legacyChallengeId: null,
+        prizeId: null,
+      };
+
+      prismaMock.$queryRaw.mockResolvedValue([{ id: 'submission-new' }]);
+      prismaMock.submission.findMany.mockResolvedValue([
+        { ...latestSubmission },
+      ]);
+      prismaMock.submission.count.mockResolvedValue(1);
+
+      const result = await listService.listSubmission(
+        { isMachine: false } as any,
+        { challengeId: 'challenge-1', isLatest: 'true' } as any,
+        { page: 1, perPage: 50 } as any,
+      );
+
+      expect(prismaMock.$queryRaw).toHaveBeenCalled();
+      expect(prismaMock.submission.findMany).toHaveBeenCalledWith(
+        expect.objectContaining({
+          where: expect.objectContaining({
+            challengeId: 'challenge-1',
+            id: { in: ['submission-new'] },
+          }),
+          skip: 0,
+          take: 50,
+        }),
+      );
+      expect(prismaMock.submission.count).toHaveBeenCalledWith({
+        where: expect.objectContaining({
+          challengeId: 'challenge-1',
+          id: { in: ['submission-new'] },
+        }),
+      });
+      expect(result.meta.totalCount).toBe(1);
+      expect(result.data).toEqual([
+        expect.objectContaining({
+          id: 'submission-new',
+          isLatest: true,
+        }),
+      ]);
+    });
+
+    it('requires challengeId when filtering by isLatest', async () => {
+      await expect(
+        listService.listSubmission(
+          { isMachine: false } as any,
+          { isLatest: 'true' } as any,
+          { page: 1, perPage: 50 } as any,
+        ),
+      ).rejects.toBeInstanceOf(BadRequestException);
+
+      expect(prismaMock.submission.findMany).not.toHaveBeenCalled();
+    });
+
     it('enriches reviews with review type names when typeId is present', async () => {
       const submissions = [
         {

src/api/submission/submission.service.ts

@@ -71,6 +71,47 @@ type ActiveChallengeRow = {
   id: string | null;
 };
 
+/**
+ * Parses optional boolean-like query parameters used by submission listing filters.
+ *
+ * @param value - Raw query parameter value from Nest's query DTO.
+ * @param fieldName - Query field name used in validation error messages.
+ * @returns A boolean when the query parameter is present, otherwise null.
+ * @throws BadRequestException when the value is not a supported boolean token.
+ */
+function parseOptionalBooleanQuery(
+  value: unknown,
+  fieldName: string,
+): boolean | null {
+  if (value === undefined || value === null || value === '') {
+    return null;
+  }
+  if (typeof value === 'boolean') {
+    return value;
+  }
+  if (typeof value !== 'string' && typeof value !== 'number') {
+    throw new BadRequestException({
+      message: `${fieldName} must be true or false`,
+      code: 'INVALID_BOOLEAN_QUERY_PARAMETER',
+      details: { fieldName },
+    });
+  }
+
+  const normalized = value.toString().trim().toLowerCase();
+  if (normalized === 'true' || normalized === '1') {
+    return true;
+  }
+  if (normalized === 'false' || normalized === '0') {
+    return false;
+  }
+
+  throw new BadRequestException({
+    message: `${fieldName} must be true or false`,
+    code: 'INVALID_BOOLEAN_QUERY_PARAMETER',
+    details: { fieldName, value },
+  });
+}
+
 export type SubmissionScanRetryOptions = {
   now?: Date;
   limit?: number;
@@ -3195,6 +3236,10 @@ export class SubmissionService {
       if (queryDto.submissionPhaseId) {
         submissionWhereClause.submissionPhaseId = queryDto.submissionPhaseId;
       }
+      const isLatestFilter = parseOptionalBooleanQuery(
+        queryDto.isLatest,
+        'isLatest',
+      );
 
       const isPrivilegedRequester = authUser?.isMachine || isAdmin(authUser);
       const requesterUserId =
@@ -3287,6 +3332,14 @@ export class SubmissionService {
         }
       }
 
+      if (isLatestFilter !== null) {
+        const latestSubmissionIds =
+          await this.findLatestSubmissionIdsForQuery(queryDto);
+        whereClause.id = isLatestFilter
+          ? { in: latestSubmissionIds }
+          : { notIn: latestSubmissionIds };
+      }
+
       // find entities by filters
       let submissions = await this.prisma.submission.findMany({
         where: whereClause,
@@ -3403,7 +3456,13 @@ export class SubmissionService {
         totalCount = submissions.length;
       }
 
-      await this.populateLatestSubmissionFlags(submissions);
+      if (isLatestFilter !== null) {
+        for (const submission of submissions) {
+          (submission as any).isLatest = isLatestFilter;
+        }
+      } else {
+        await this.populateLatestSubmissionFlags(submissions);
+      }
       this.stripSubmitterSubmissionDetails(
         authUser,
         submissions,
@@ -4793,6 +4852,84 @@ export class SubmissionService {
     }
   }
 
+  /**
+   * Finds submission ids that are latest within each challenge/member pair for
+   * the supplied submission-list filters. The result is used to constrain the
+   * main list and count queries before pagination, so callers can request a
+   * compact member-level view without fetching historical attempts first.
+   *
+   * @param queryDto - Submission list filters from the request query string.
+   * @returns Submission ids that represent the latest attempt per member.
+   * @throws BadRequestException when isLatest is requested without challengeId.
+   */
+  private async findLatestSubmissionIdsForQuery(
+    queryDto: SubmissionQueryDto,
+  ): Promise<string[]> {
+    if (!queryDto.challengeId) {
+      throw new BadRequestException({
+        message: 'isLatest filtering requires challengeId',
+        code: 'LATEST_SUBMISSION_FILTER_REQUIRES_CHALLENGE',
+        details: { fieldName: 'challengeId' },
+      });
+    }
+
+    const filters: Prisma.Sql[] = [
+      Prisma.sql`"challengeId" = ${queryDto.challengeId}`,
+      Prisma.sql`"memberId" IS NOT NULL`,
+    ];
+
+    if (queryDto.type) {
+      filters.push(Prisma.sql`"type" = ${queryDto.type}`);
+    }
+    if (queryDto.url) {
+      filters.push(Prisma.sql`"url" = ${queryDto.url}`);
+    }
+    if (queryDto.memberId) {
+      filters.push(Prisma.sql`"memberId" = ${String(queryDto.memberId)}`);
+    }
+    if (queryDto.legacySubmissionId) {
+      filters.push(
+        Prisma.sql`"legacySubmissionId" = ${queryDto.legacySubmissionId}`,
+      );
+    }
+    if (queryDto.legacyUploadId) {
+      filters.push(Prisma.sql`"legacyUploadId" = ${queryDto.legacyUploadId}`);
+    }
+    if (queryDto.submissionPhaseId) {
+      filters.push(
+        Prisma.sql`"submissionPhaseId" = ${queryDto.submissionPhaseId}`,
+      );
+    }
+
+    const whereSql = filters.reduce(
+      (combined, filter) => Prisma.sql`${combined} AND ${filter}`,
+    );
+
+    const latestEntries = await this.prisma.$queryRaw<Array<{ id: string }>>(
+      Prisma.sql`
+        SELECT "id"
+        FROM (
+          SELECT
+            "id",
+            ROW_NUMBER() OVER (
+              PARTITION BY "challengeId", "memberId"
+              ORDER BY "submittedDate" DESC NULLS LAST,
+                       "createdAt" DESC,
+                       "updatedAt" DESC NULLS LAST,
+                       "id" DESC
+            ) AS row_num
+          FROM "submission"
+          WHERE ${whereSql}
+        ) ranked
+        WHERE row_num = 1
+      `,
+    );
+
+    return latestEntries
+      .map((entry) => String(entry.id ?? '').trim())
+      .filter((id) => id.length > 0);
+  }
+
   private async getActiveSubmitterRestrictedChallengeIds(
     userId: string,
     challengeId?: string,

src/dto/submission.dto.ts

@@ -97,6 +97,16 @@ export class SubmissionQueryDto {
   @IsString()
   @IsNotEmpty()
   submissionPhaseId?: string;
+
+  @ApiProperty({
+    name: 'isLatest',
+    description:
+      'When true, only the latest submission per challenge/member pair is returned. When false, latest submissions are excluded.',
+    required: false,
+  })
+  @IsOptional()
+  @IsIn(['true', 'false', '1', '0', 'TRUE', 'FALSE'])
+  isLatest?: string;
 }
 
 export class SubmissionRequestBaseDto {