feat: add crash count fields to versions API client (#160)

* feat: add DashboardApiClient for BFF endpoint

Add a new DashboardApiClient that calls /api/dashboard.php to fetch all
dashboard data in a single request. Includes request/response types and
unit tests.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* fix: make startDate/endDate optional in DashboardApiRequest

Support "All Time" queries where no date range is specified. Only includes
date params in the URL when provided.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* feat: add totalThrottled fields to DashboardApiResponse

Add totalThrottled and totalThrottledPrevious to the DashboardApiResponse
interface to support rejected crashes on the dashboard.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* fix: add lastCrashTime to DashboardApiResponse

Add `lastCrashTime: string | null` field to the response type to
support the new unfiltered last crash time from the dashboard BFF.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* feat: add crash count fields to versions API client

Add totalCrashCount and periodCrashCount to VersionsApiRow. Extend
getVersions() to accept optional crashCountStartDate/crashCountEndDate
params, and add extraParams support to TableDataClient.getData().

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* test: add tests for crash count fields and extraParams

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>

Author: bobbyg603

src/common/data/table-data/table-data-client/table-data-client.spec.ts

@@ -24,6 +24,7 @@ describe('TableDataClient', () => {
             'withSortColumn',
             'withSortOrder',
             'build',
+            'entries',
         ]);
         dataTableFormDataBuilder.withDatabase.and.returnValue(dataTableFormDataBuilder);
         dataTableFormDataBuilder.withColumnGroups.and.returnValue(dataTableFormDataBuilder);
@@ -33,6 +34,7 @@ describe('TableDataClient', () => {
         dataTableFormDataBuilder.withSortColumn.and.returnValue(dataTableFormDataBuilder);
         dataTableFormDataBuilder.withSortOrder.and.returnValue(dataTableFormDataBuilder);
         dataTableFormDataBuilder.build.and.returnValue(formData);
+        dataTableFormDataBuilder.entries.and.returnValue(formData);
         spyOn(TableDataFormDataBuilder, 'TableDataFormDataBuilder').and.returnValue(
             dataTableFormDataBuilder
         );
@@ -155,4 +157,75 @@ describe('TableDataClient', () => {
             }
         });
     });
+
+    describe('getData (GET)', () => {
+        let database;
+        let result;
+
+        beforeEach(async () => {
+            database = 'TestDatabase';
+            const resp = await service.getData({ database });
+            if (isErrorResponse(resp)) {
+                throw new Error((await resp.json()).message);
+            }
+            result = await resp.json();
+        });
+
+        it('should call fetch with a GET request using query params', () => {
+            const expectedQueryString = new URLSearchParams(formData).toString();
+            expect(bugSplatApiClient.fetch).toHaveBeenCalledWith(
+                `${url}?${expectedQueryString}`,
+                jasmine.objectContaining({
+                    method: 'GET',
+                })
+            );
+        });
+
+        it('should call entries on DataTableFormDataBuilder', () => {
+            expect(dataTableFormDataBuilder.entries).toHaveBeenCalled();
+        });
+
+        it('should return value from api', () => {
+            expect(result).toEqual(
+                jasmine.objectContaining({
+                    rows: response.rows,
+                    pageData: response.pageData,
+                })
+            );
+        });
+
+        describe('with extraParams', () => {
+            it('should merge extraParams into the query string', async () => {
+                const extraParams = {
+                    crashCountStartDate: '2024-01-01',
+                    crashCountEndDate: '2024-12-31'
+                };
+
+                await service.getData({ database }, extraParams);
+
+                const mergedParams = { ...formData, ...extraParams };
+                const expectedQueryString = new URLSearchParams(mergedParams).toString();
+                expect(bugSplatApiClient.fetch).toHaveBeenCalledWith(
+                    `${url}?${expectedQueryString}`,
+                    jasmine.objectContaining({
+                        method: 'GET',
+                    })
+                );
+            });
+        });
+
+        describe('without extraParams', () => {
+            it('should use only the base form data params in the query string', async () => {
+                await service.getData({ database });
+
+                const expectedQueryString = new URLSearchParams(formData).toString();
+                expect(bugSplatApiClient.fetch).toHaveBeenCalledWith(
+                    `${url}?${expectedQueryString}`,
+                    jasmine.objectContaining({
+                        method: 'GET',
+                    })
+                );
+            });
+        });
+    });
 });

src/common/data/table-data/table-data-client/table-data-client.ts

@@ -31,7 +31,8 @@ export class TableDataClient {
     }
 
     async getData<T, U = Record<string, unknown> | undefined>(
-        request: TableDataRequest
+        request: TableDataRequest,
+        extraParams?: Record<string, string>
     ): Promise<BugSplatResponse<TableDataResponse<T, U>> | BugSplatResponse<ErrorResponse>> {
         const factory = () => this._apiClient.createFormData();
         const formData = new TableDataFormDataBuilder(factory)
@@ -43,6 +44,11 @@ export class TableDataClient {
             .withSortColumn(request.sortColumn)
             .withSortOrder(request.sortOrder)
             .entries();
+
+        if (extraParams) {
+            Object.assign(formData, extraParams);
+        }
+
         const requestInit = {
             method: 'GET',
             cache: 'no-cache',

src/versions/versions-api-client/versions-api-client.spec.ts

@@ -74,6 +74,33 @@ describe('VersionsApiClient', () => {
                 ])
             );
         });
+
+        describe('with crash count date options', () => {
+            it('should call getData with extraParams when both dates are provided', async () => {
+                const options = {
+                    crashCountStartDate: '2024-01-01',
+                    crashCountEndDate: '2024-12-31'
+                };
+
+                await versionsApiClient.getVersions({ database }, options);
+
+                expect(tableDataClient.getData).toHaveBeenCalledWith(
+                    jasmine.objectContaining({ database }),
+                    jasmine.objectContaining({
+                        crashCountStartDate: '2024-01-01',
+                        crashCountEndDate: '2024-12-31'
+                    })
+                );
+            });
+
+            it('should call getData without extraParams when no options are provided', async () => {
+                await versionsApiClient.getVersions({ database });
+
+                expect(tableDataClient.getData).toHaveBeenCalledWith(
+                    jasmine.objectContaining({ database })
+                );
+            });
+        });
     });
 
     describe('deleteVersions', () => {

src/versions/versions-api-client/versions-api-client.ts

@@ -23,8 +23,23 @@ export class VersionsApiClient {
         this._tableDataClient = new TableDataClient(this._client, this.route);
     }
 
-    async getVersions(request: TableDataRequest): Promise<TableDataResponse<VersionsApiRow>> {
-        const response = await this._tableDataClient.getData<VersionsApiResponseRow>(request);
+    async getVersions(
+        request: TableDataRequest,
+        options?: { crashCountStartDate?: string; crashCountEndDate?: string }
+    ): Promise<TableDataResponse<VersionsApiRow>> {
+        const extraParams: Record<string, string> = {};
+        if (options?.crashCountStartDate) {
+            extraParams.crashCountStartDate = options.crashCountStartDate;
+        }
+        if (options?.crashCountEndDate) {
+            extraParams.crashCountEndDate = options.crashCountEndDate;
+        }
+
+        const hasExtraParams = Object.keys(extraParams).length > 0;
+        const response = hasExtraParams
+            ? await this._tableDataClient.getData<VersionsApiResponseRow>(request, extraParams)
+            : await this._tableDataClient.getData<VersionsApiResponseRow>(request);
+
         if (isErrorResponse(response)) {
             throw new Error((await response.json()).message);
         }

src/versions/versions-api-row/version-api-row.spec.ts

@@ -32,4 +32,36 @@ describe('VersionApiRow', () => {
 
         expect(result.retired).toEqual(false);
     });
+
+    it('should convert totalCrashCount string to number', () => {
+        const row = { totalCrashCount: '100' };
+
+        const result = new VersionsApiRow(row as any);
+
+        expect(result.totalCrashCount).toEqual(100);
+    });
+
+    it('should convert periodCrashCount string to number', () => {
+        const row = { periodCrashCount: '50' };
+
+        const result = new VersionsApiRow(row as any);
+
+        expect(result.periodCrashCount).toEqual(50);
+    });
+
+    it('should default totalCrashCount to 0 when undefined', () => {
+        const row = {};
+
+        const result = new VersionsApiRow(row as any);
+
+        expect(result.totalCrashCount).toEqual(0);
+    });
+
+    it('should default periodCrashCount to 0 when undefined', () => {
+        const row = {};
+
+        const result = new VersionsApiRow(row as any);
+
+        expect(result.periodCrashCount).toEqual(0);
+    });
 });

src/versions/versions-api-row/versions-api-row.ts

@@ -12,6 +12,8 @@ export interface VersionsApiResponseRow {
   rejectedCount: string;
   retired: '0' | '1';
   fullDumps: '0' | '1';
+  totalCrashCount: string;
+  periodCrashCount: string;
 }
 
 export class VersionsApiRow {
@@ -26,6 +28,8 @@ export class VersionsApiRow {
   rejectedCount: number;
   retired: boolean;
   fullDumps: boolean;
+  totalCrashCount: number;
+  periodCrashCount: number;
 
   constructor(rawApiRow: VersionsApiResponseRow) {
     ac.assertType(rawApiRow, Object, 'rawApiRow');
@@ -52,6 +56,8 @@ export class VersionsApiRow {
     this.rejectedCount = Number(rawApiRow.rejectedCount);
     this.retired = Boolean(Number(rawApiRow.retired));
     this.fullDumps = Boolean(Number(rawApiRow.fullDumps));
+    this.totalCrashCount = Number(rawApiRow.totalCrashCount ?? 0);
+    this.periodCrashCount = Number(rawApiRow.periodCrashCount ?? 0);
 
     Object.freeze(this);
   }