212 socker debounce (#103)

* Debounce socket events emit

Visual-Regression-Tracker/Visual-Regression-Tracker#212

Author: pashidlos

src/builds/builds.controller.ts

@@ -26,7 +26,7 @@ import { ModifyBuildDto } from './dto/build-modify.dto';
 @Controller('builds')
 @ApiTags('builds')
 export class BuildsController {
-  constructor(private buildsService: BuildsService) { }
+  constructor(private buildsService: BuildsService) {}
 
   @Get()
   @ApiOkResponse({ type: PaginatedBuildDto })

src/builds/builds.service.spec.ts

@@ -57,7 +57,7 @@ const initService = async ({
         provide: EventsGateway,
         useValue: {
           buildUpdated: eventsBuildUpdatedMock,
-          buildCreated: eventsBuildCreatedMock
+          buildCreated: eventsBuildCreatedMock,
         },
       },
       {
@@ -286,28 +286,27 @@ describe('BuildsService', () => {
     mocked(BuildDto).mockReturnValueOnce(buildDto);
     service = await initService({ buildUpdateMock, eventsBuildUpdatedMock });
 
-    const result = await service.update(id, { "isRunning": false });
+    const result = await service.update(id, { isRunning: false });
 
     expect(buildUpdateMock).toHaveBeenCalledWith({
       where: { id },
       include: {
         testRuns: true,
       },
-      data: { "isRunning": false }
+      data: { isRunning: false },
     });
-    expect(eventsBuildUpdatedMock).toHaveBeenCalledWith(buildDto);
+    expect(eventsBuildUpdatedMock).toHaveBeenCalledWith(id);
     expect(result).toBe(buildDto);
   });
 
   it('approve', async () => {
-    const eventsBuildUpdatedMock = jest.fn();
     const buildFindUniqueMock = jest.fn().mockResolvedValueOnce(build);
     const testRunApproveMock = jest.fn().mockResolvedValueOnce({
       ...build.testRuns[0],
       status: TestStatus.approved,
     });
     mocked(BuildDto).mockReturnValueOnce(buildDto);
-    service = await initService({ eventsBuildUpdatedMock, buildFindUniqueMock, testRunApproveMock });
+    service = await initService({ buildFindUniqueMock, testRunApproveMock });
 
     await service.approve('someId', true);
 
@@ -333,6 +332,5 @@ describe('BuildsService', () => {
         },
       ],
     });
-    expect(eventsBuildUpdatedMock).toHaveBeenCalledWith(buildDto);
   });
 });

src/builds/builds.service.ts

@@ -18,7 +18,7 @@ export class BuildsService {
     private testRunsService: TestRunsService,
     @Inject(forwardRef(() => ProjectsService))
     private projectService: ProjectsService
-  ) { }
+  ) {}
 
   async findOne(id: string): Promise<BuildDto> {
     return this.prismaService.build
@@ -106,11 +106,10 @@ export class BuildsService {
       include: {
         testRuns: true,
       },
-      data: modifyBuildDto
+      data: modifyBuildDto,
     });
-    const buildDto = new BuildDto(build);
-    this.eventsGateway.buildUpdated(buildDto);
-    return buildDto;
+    this.eventsGateway.buildUpdated(id);
+    return new BuildDto(build);
   }
 
   async remove(id: string): Promise<Build> {
@@ -146,8 +145,6 @@ export class BuildsService {
       build.testRuns.map((testRun) => this.testRunsService.approve(testRun.id, merge))
     );
 
-    const buildDto = new BuildDto(build);
-    this.eventsGateway.buildUpdated(buildDto);
-    return buildDto;
+    return new BuildDto(build);
   }
 }

src/builds/dto/build.dto.ts

@@ -64,6 +64,7 @@ export class BuildDto {
       // calculate statistics
       build.testRuns.forEach((testRun) => {
         switch (testRun.status) {
+          case TestStatus.autoApproved:
           case TestStatus.approved:
           case TestStatus.ok: {
             this.passedCount += 1;

src/shared/events/events.gateway.ts

@@ -1,30 +1,112 @@
 import { WebSocketGateway, WebSocketServer } from '@nestjs/websockets';
 import { Server } from 'socket.io';
-import { TestRun } from '@prisma/client';
+import { Build, TestRun } from '@prisma/client';
 import { BuildDto } from '../../builds/dto/build.dto';
+import { debounce } from 'lodash';
+import { PrismaService } from '../../prisma/prisma.service';
 
 @WebSocketGateway()
 export class EventsGateway {
   @WebSocketServer()
   server: Server;
 
+  constructor(private prismaService: PrismaService) {}
+
+  private debounceTimeout = 1500;
+  private maxWait = 3000;
+  private testRunsCreatedQueued: Array<TestRun> = [];
+  private testRunsDeletedQueued: Array<TestRun> = [];
+  private testRunsUpdatedQueued: Array<TestRun> = [];
+  private buildsUpdatedQueued: Array<string> = [];
+
   buildCreated(build: BuildDto): void {
     this.server.emit('build_created', build);
   }
 
-  buildUpdated(build: BuildDto): void {
-    this.server.emit('build_updated', build);
+  buildUpdated(id: string): void {
+    this.buildsUpdatedQueued.push(id);
+    this.buildUpdatedDebounced();
   }
 
   testRunCreated(testRun: TestRun): void {
-    this.server.emit('testRun_created', testRun);
+    this.testRunsCreatedQueued.push(testRun);
+    this.testRunCreatedDebounced();
+    this.buildUpdated(testRun.buildId);
   }
 
   testRunUpdated(testRun: TestRun): void {
-    this.server.emit('testRun_updated', testRun);
+    this.testRunsUpdatedQueued.push(testRun);
+    this.testRunUpdatedDebounced();
+    this.buildUpdated(testRun.buildId);
   }
 
   testRunDeleted(testRun: TestRun): void {
-    this.server.emit('testRun_deleted', testRun);
+    this.testRunsDeletedQueued.push(testRun);
+    this.testRunDeletedDebounced();
+    this.buildUpdated(testRun.buildId);
   }
+
+  private testRunUpdatedDebounced = debounce(
+    () => {
+      this.server.emit('testRun_updated', this.testRunsUpdatedQueued);
+      this.testRunsUpdatedQueued = [];
+    },
+    this.debounceTimeout,
+    {
+      leading: true,
+      maxWait: this.maxWait,
+    }
+  );
+
+  private testRunCreatedDebounced = debounce(
+    () => {
+      this.server.emit('testRun_created', this.testRunsCreatedQueued);
+      this.testRunsCreatedQueued = [];
+    },
+    this.debounceTimeout,
+    {
+      leading: true,
+      maxWait: this.maxWait,
+    }
+  );
+
+  private testRunDeletedDebounced = debounce(
+    () => {
+      this.server.emit('testRun_deleted', this.testRunsDeletedQueued);
+      this.testRunsDeletedQueued = [];
+    },
+    this.debounceTimeout,
+    {
+      leading: true,
+      maxWait: this.maxWait,
+    }
+  );
+
+  private buildUpdatedDebounced = debounce(
+    () => {
+      this.prismaService.build
+        .findMany({
+          where: {
+            id: {
+              in: this.buildsUpdatedQueued,
+            },
+          },
+          include: {
+            testRuns: true,
+          },
+        })
+        .then((builds: Array<Build>) => {
+          this.server.emit(
+            'build_updated',
+            builds.map((build: Build) => new BuildDto(build))
+          );
+        });
+      this.buildsUpdatedQueued = [];
+    },
+    this.debounceTimeout,
+    {
+      leading: true,
+      maxWait: this.maxWait,
+    }
+  );
 }

src/shared/shared.module.ts

@@ -1,12 +1,13 @@
 import { Global, Module } from '@nestjs/common';
 import { StaticService } from './static/static.service';
 import { EventsGateway } from '../shared/events/events.gateway';
+import { PrismaService } from '../prisma/prisma.service';
 
 @Global()
 @Module({
-    providers: [StaticService, EventsGateway],
-    exports: [StaticService, EventsGateway],
-    imports: [],
-    controllers: [],
+  providers: [StaticService, EventsGateway, PrismaService],
+  exports: [StaticService, EventsGateway, PrismaService],
+  imports: [],
+  controllers: [],
 })
-export class SharedModule {}
+export class SharedModule {}

src/test-runs/test-runs.controller.ts

@@ -36,14 +36,6 @@ export class TestRunsController {
     return this.testRunsService.findMany(buildId);
   }
 
-  @Get('recalculateDiff/:id')
-  @ApiParam({ name: 'id', required: true })
-  @ApiBearerAuth()
-  @UseGuards(JwtAuthGuard)
-  recalculateDiff(@Param('id', new ParseUUIDPipe()) id: string): Promise<TestRun> {
-    return this.testRunsService.recalculateDiff(id);
-  }
-
   @Get('approve')
   @ApiQuery({ name: 'id', required: true })
   @ApiQuery({ name: 'merge', required: false })