feat: add summary client

src/common/data/table-data/table-data-form-data-builder/table-data-form-data-builder.ts

@@ -78,14 +78,14 @@ export class TableDataFormDataBuilder {
     return this;
   }
 
-  withApplications(applications: Array<string>): TableDataFormDataBuilder {
+  withApplications(applications: Array<string> | undefined): TableDataFormDataBuilder {
     if (applications && applications.length) {
       this._formParts.appNames = applications.join(',');
     }
     return this;
   }
 
-  withVersions(versions: Array<string>): TableDataFormDataBuilder {
+  withVersions(versions: Array<string> | undefined): TableDataFormDataBuilder {
     if (versions && versions.length) {
       this._formParts.versions = versions.join(',');
     }

src/crashes/crashes-api-row/crashes-api-row.ts

@@ -1,9 +1,6 @@
 interface CrashData {
-  id: string;
   groupByCount: number;
   stackKey: string;
-  stackId: string;
-  stackKeyId: string;
   appName: string;
   appVersion: string;
   appDescription: string;
@@ -22,17 +19,23 @@ interface CrashData {
   exceptionMessage: string;
 }
 
-export interface CrashDataWithMappedProperties extends CrashData {
+interface CrashDataWithMappedProperties extends CrashData {
+  id: number;
+  stackId: number;
+  stackKeyId: number;
   comments: string;
   ipAddress: string;
 }
 
 export interface CrashesApiResponseRow extends CrashData {
+  id: string;
+  stackId: string;
+  stackKeyId: string;
   Comments: string;
   IpAddress: string;
 }
 
-export class CrashesApiRow {
+export class CrashesApiRow implements CrashDataWithMappedProperties {
   public id: number;
   public groupByCount: number;
   public stackKey: string;

src/index.ts

@@ -3,4 +3,5 @@ export * from './crash';
 export * from './crashes';
 export * from './events';
 export * from './post';
+export * from './summary';
 export * from './versions';

src/summary/index.ts

@@ -0,0 +1,3 @@
+export { SummaryApiClient } from './summary-api-client/summary-api-client';
+export { SummaryApiRow } from './summary-api-row/summary-api-row';
+export { SummaryTableDataRequest } from './summary-table-data/summary-table-data-request';

src/summary/summary-api-client/summary-api-client.e2e.ts

@@ -0,0 +1,58 @@
+import { BugSplatApiClient } from '@common';
+import { config } from '@spec/config';
+import { postNativeCrashAndSymbols } from '@spec/files/native/post-native-crash';
+import { firstValueFrom, timer } from 'rxjs';
+import { SummaryApiClient } from './summary-api-client';
+
+describe('SummaryApiClient', () => {
+    let summaryClient: SummaryApiClient;
+    let application;
+    let version;
+
+    beforeEach(async () => {
+        const { host, email, password } = config;
+        const bugsplat = await BugSplatApiClient.createAuthenticatedClientForNode(email, password, host);
+        summaryClient = new SummaryApiClient(bugsplat);
+        application = 'myConsoleCrasher';
+        version = `${Math.random() * 1000000}`;
+        await postNativeCrashAndSymbols(
+            bugsplat,
+            config.database,
+            application,
+            version
+        );
+    });
+
+    describe('getSummary', () => {
+        it('should return 200 and array of stack keys', async () => {
+            const stackKey =  'myConsoleCrasher!MemoryException(150)';
+            const database = config.database;
+            const applications = [application];
+            const versions = [version];
+            const pageSize = 1;
+
+            let result;
+            for (let i = 0; i < 150; i++) {
+                result = await summaryClient.getSummary({
+                    database,
+                    applications,
+                    versions,
+                    pageSize
+                });
+
+                const isProcessed = result.rows[0].stackKeyId > 0;
+                if (isProcessed) {
+                    break;
+                }
+
+                await firstValueFrom(timer(2000));
+            }
+
+            const row = result.rows.find(row => row.stackKey === stackKey);
+            expect(result.rows).toBeTruthy();
+            expect(result.rows.length).toEqual(pageSize);
+            expect(row?.stackKeyId).toBeGreaterThanOrEqual(1);
+            expect(row?.stackKey).toEqual(stackKey);
+        });
+    });
+});

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

@@ -0,0 +1,61 @@
+import { createFakeBugSplatApiClient } from '@spec/fakes/common/bugsplat-api-client';
+import { createFakeFormData } from '@spec/fakes/common/form-data';
+import { createFakeResponseBody } from '@spec/fakes/common/response';
+import * as SummaryTableDataClientModule from '../summary-table-data/summary-table-data-client';
+import { SummaryApiClient } from './summary-api-client';
+
+describe('SummaryApiClient', () => {
+    let sut: SummaryApiClient;
+
+    let apiClient;
+    let apiClientResponse;
+    let database;
+    let fakeFormData;
+    let pageData;
+    let rows;
+    let tableDataClient;
+    let tableDataClientResponse;
+    let stackKeyId;
+    let subKeyDepth;
+    let userSum;
+
+    beforeEach(() => {
+        fakeFormData = createFakeFormData();
+        apiClientResponse = createFakeResponseBody(200);
+        apiClient = createFakeBugSplatApiClient(fakeFormData, apiClientResponse);
+
+        database = '☕️';
+        stackKeyId = '9001';
+        subKeyDepth = '7';
+        userSum = '123';
+        pageData = { coffee: 'black rifle' };
+        rows = [{ stackKeyId, subKeyDepth, userSum }];
+        tableDataClientResponse = createFakeResponseBody(200, { pageData, rows });
+        tableDataClient = jasmine.createSpyObj('SummaryTableDataClient', ['postGetData']);
+        tableDataClient.postGetData.and.resolveTo(tableDataClientResponse);
+        spyOn(SummaryTableDataClientModule, 'SummaryTableDataClient').and.returnValue(tableDataClient);
+
+        sut = new SummaryApiClient(apiClient);
+    });
+
+    describe('getSummary', () => {
+        let result;
+        let request;
+
+        beforeEach(async () => {
+            request = { database };
+            result = await sut.getSummary(request);
+        });
+
+        it('should call postGetData with request', () => {
+            expect(tableDataClient.postGetData).toHaveBeenCalledWith(request);
+        });
+
+        it('should return value with stackKeyId, subKeyDepth, and userSum values mapped to numbers', () => {
+            expect(result.pageData).toEqual(pageData);
+            expect(result.rows[0].stackKeyId).toEqual(Number(stackKeyId));
+            expect(result.rows[0].subKeyDepth).toEqual(Number(subKeyDepth));
+            expect(result.rows[0].userSum).toEqual(Number(userSum));
+        });
+    });
+});

src/summary/summary-api-client/summary-api-client.ts

@@ -0,0 +1,39 @@
+import { ApiClient, TableDataResponse } from '@common';
+import { SummaryApiResponseRow, SummaryApiRow } from '../summary-api-row/summary-api-row';
+import { SummaryTableDataClient } from '../summary-table-data/summary-table-data-client';
+import { SummaryTableDataRequest } from '../summary-table-data/summary-table-data-request';
+
+export class SummaryApiClient {
+
+    private _tableDataClient: SummaryTableDataClient;
+
+    constructor(private _client: ApiClient) {
+        this._tableDataClient = new SummaryTableDataClient(this._client, '/summary?data');
+    }
+
+    async getSummary(request: SummaryTableDataRequest): Promise<TableDataResponse<SummaryApiRow>> {
+        const response = await this._tableDataClient.postGetData(request);
+        const json = await response.json();
+        const pageData = json.pageData;
+        const rows = json.rows.map((row: SummaryApiResponseRow) => new SummaryApiRow(
+            row.stackKey,
+            Number(row.stackKeyId),
+            row.firstReport,
+            row.lastReport,
+            row.crashSum,
+            row.techSupportSubject,
+            row.stackKeyDefectId,
+            row.stackKeyDefectUrl,
+            row.stackKeyDefectLabel,
+            row.comments,
+            Number(row.subKeyDepth),
+            Number(row.userSum)
+          )
+        );
+
+        return {
+            rows,
+            pageData
+        };
+    }
+}

src/summary/summary-api-row/summary-api-row.ts

@@ -0,0 +1,41 @@
+interface SummaryData {
+  stackKey: string,
+  firstReport: string,
+  lastReport: string,
+  crashSum: string,
+  techSupportSubject: string,
+  stackKeyDefectId: string,
+  stackKeyDefectUrl: string,
+  stackKeyDefectLabel: string,
+  comments: string,
+}
+
+export interface SummaryApiResponseRow extends SummaryData {
+  stackKeyId: string;
+  subKeyDepth: string;
+  userSum: string;
+}
+
+interface SummaryDataWithMappedProperties extends SummaryData {
+  stackKeyId: number;
+  subKeyDepth: number;
+  userSum: number;
+}
+
+
+export class SummaryApiRow implements SummaryDataWithMappedProperties {
+  constructor(
+    public stackKey: string,
+    public stackKeyId: number,
+    public firstReport: string,
+    public lastReport: string,
+    public crashSum: string,
+    public techSupportSubject: string,
+    public stackKeyDefectId: string,
+    public stackKeyDefectUrl: string,
+    public stackKeyDefectLabel: string,
+    public comments: string,
+    public subKeyDepth: number,
+    public userSum: number
+  ) { }
+}

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

@@ -0,0 +1,48 @@
+import { ApiClient, BugSplatResponse, TableDataFormDataBuilder } from '@common';
+import { SummaryTableDataRequest } from './summary-table-data-request';
+
+export class SummaryTableDataClient {
+
+  constructor(private _apiClient: ApiClient, private _url: string) { }
+
+  // We use POST to get data in most cases because it supports longer queries
+  async postGetData(request: SummaryTableDataRequest): Promise<BugSplatResponse> {
+    const factory = () => this._apiClient.createFormData();
+    const formData = new TableDataFormDataBuilder(factory)
+      .withDatabase(request.database)
+      .withApplications(request.applications)
+      .withVersions(request.versions)
+      .withFilterGroups(request.filterGroups)
+      .withColumnGroups(request.columnGroups)
+      .withPage(request.page)
+      .withPageSize(request.pageSize)
+      .withSortColumn(request.sortColumn)
+      .withSortOrder(request.sortOrder)
+      .build();
+    const init = {
+      method: 'POST',
+      body: formData,
+      cache: 'no-cache',
+      credentials: 'include',
+      redirect: 'follow'
+    };
+    return this.makeRequest(this._url, <RequestInit><unknown>init);
+  }
+
+  private async makeRequest(url: string, init: RequestInit): Promise<BugSplatResponse> {
+    const response = await this._apiClient.fetch(url, init);
+    const responseData = await response.json();
+    const rows = responseData ? responseData[0]?.Rows : [];
+    const pageData = responseData ? responseData[0]?.PageData : {};
+
+    const status = response.status;
+    const json = async () => ({ rows, pageData });
+    return {
+      status,
+      json
+    };
+  }
+}
+
+
+

src/summary/summary-table-data/summary-table-data-request.ts

@@ -0,0 +1,6 @@
+import { TableDataRequest } from '@common';
+
+export interface SummaryTableDataRequest extends TableDataRequest {
+    applications?: Array<string>;
+    versions?: Array<string>;
+}