tests health

src/modules/health/adapters/primaries/health-server.controller.ts

@@ -0,0 +1,42 @@
+import { Controller } from '@nestjs/common';
+import { GrpcMethod } from '@nestjs/microservices';
+import { PrismaHealthIndicatorUseCase } from '../../domain/usecases/prisma.health-indicator.usecase';
+
+enum ServingStatus {
+  UNKNOWN = 0,
+  SERVING = 1,
+  NOT_SERVING = 2,
+}
+
+interface HealthCheckRequest {
+  service: string;
+}
+
+interface HealthCheckResponse {
+  status: ServingStatus;
+}
+
+@Controller()
+export class HealthServerController {
+  constructor(
+    private readonly _prismaHealthIndicatorUseCase: PrismaHealthIndicatorUseCase,
+  ) {}
+
+  @GrpcMethod('Health', 'Check')
+  async check(
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    data: HealthCheckRequest,
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    metadata: any,
+  ): Promise<HealthCheckResponse> {
+    const healthCheck = await this._prismaHealthIndicatorUseCase.isHealthy(
+      'prisma',
+    );
+    return {
+      status:
+        healthCheck['prisma'].status == 'up'
+          ? ServingStatus.SERVING
+          : ServingStatus.NOT_SERVING,
+    };
+  }
+}

src/modules/health/adapters/primaries/health.controller.ts

@@ -1,27 +1,34 @@
-import { Controller } from '@nestjs/common';
-import { GrpcMethod } from '@nestjs/microservices';
+import { Controller, Get } from '@nestjs/common';
+import {
+  HealthCheckService,
+  HealthCheck,
+  HealthCheckResult,
+} from '@nestjs/terminus';
+import { Messager } from '../secondaries/messager';
+import { PrismaHealthIndicatorUseCase } from '../../domain/usecases/prisma.health-indicator.usecase';
 
-enum ServingStatus {
-  UNKNOWN = 0,
-  SERVING = 1,
-  NOT_SERVING = 2,
-}
-
-interface HealthCheckRequest {
-  service: string;
-}
-
-interface HealthCheckResponse {
-  status: ServingStatus;
-}
-
-@Controller()
+@Controller('health')
 export class HealthController {
-  @GrpcMethod('Health', 'Check')
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  check(data: HealthCheckRequest, metadata: any): HealthCheckResponse {
-    return {
-      status: ServingStatus.SERVING,
-    };
+  constructor(
+    private readonly _prismaHealthIndicatorUseCase: PrismaHealthIndicatorUseCase,
+    private _healthCheckService: HealthCheckService,
+    private _messager: Messager,
+  ) {}
+
+  @Get()
+  @HealthCheck()
+  async check() {
+    try {
+      return await this._healthCheckService.check([
+        async () => this._prismaHealthIndicatorUseCase.isHealthy('prisma'),
+      ]);
+    } catch (error) {
+      const healthCheckResult: HealthCheckResult = error.response;
+      this._messager.publish(
+        'logging.user.health.crit',
+        JSON.stringify(healthCheckResult.error),
+      );
+      throw error;
+    }
   }
 }

src/modules/health/adapters/secondaries/message-broker.ts

@@ -0,0 +1,12 @@
+import { Injectable } from '@nestjs/common';
+
+@Injectable()
+export abstract class IMessageBroker {
+  exchange: string;
+
+  constructor(exchange: string) {
+    this.exchange = exchange;
+  }
+
+  abstract publish(routingKey: string, message: string): void;
+}

src/modules/health/adapters/secondaries/messager.ts

@@ -0,0 +1,18 @@
+import { AmqpConnection } from '@golevelup/nestjs-rabbitmq';
+import { Injectable } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import { IMessageBroker } from './message-broker';
+
+@Injectable()
+export class Messager extends IMessageBroker {
+  constructor(
+    private readonly _amqpConnection: AmqpConnection,
+    configService: ConfigService,
+  ) {
+    super(configService.get<string>('RMQ_EXCHANGE'));
+  }
+
+  publish(routingKey: string, message: string): void {
+    this._amqpConnection.publish(this.exchange, routingKey, message);
+  }
+}

src/modules/health/domain/usecases/prisma.health-indicator.usecase.ts

@@ -0,0 +1,25 @@
+import { Injectable } from '@nestjs/common';
+import {
+  HealthCheckError,
+  HealthIndicator,
+  HealthIndicatorResult,
+} from '@nestjs/terminus';
+import { UsersRepository } from 'src/modules/user/adapters/secondaries/users.repository';
+
+@Injectable()
+export class PrismaHealthIndicatorUseCase extends HealthIndicator {
+  constructor(private readonly _repository: UsersRepository) {
+    super();
+  }
+
+  async isHealthy(key: string): Promise<HealthIndicatorResult> {
+    try {
+      await this._repository.healthCheck();
+      return this.getStatus(key, true);
+    } catch (e) {
+      throw new HealthCheckError('Prisma', {
+        prisma: e.message,
+      });
+    }
+  }
+}

src/modules/health/health.module.ts

@@ -1,7 +1,34 @@
 import { Module } from '@nestjs/common';
+import { HealthServerController } from './adapters/primaries/health-server.controller';
+import { PrismaHealthIndicatorUseCase } from './domain/usecases/prisma.health-indicator.usecase';
+import { UsersRepository } from '../user/adapters/secondaries/users.repository';
+import { DatabaseModule } from '../database/database.module';
 import { HealthController } from './adapters/primaries/health.controller';
+import { TerminusModule } from '@nestjs/terminus';
+import { RabbitMQModule } from '@golevelup/nestjs-rabbitmq';
+import { ConfigModule, ConfigService } from '@nestjs/config';
+import { Messager } from './adapters/secondaries/messager';
 
 @Module({
-  controllers: [HealthController],
+  imports: [
+    TerminusModule,
+    RabbitMQModule.forRootAsync(RabbitMQModule, {
+      imports: [ConfigModule],
+      useFactory: async (configService: ConfigService) => ({
+        exchanges: [
+          {
+            name: configService.get<string>('RMQ_EXCHANGE'),
+            type: 'topic',
+          },
+        ],
+        uri: configService.get<string>('RMQ_URI'),
+        connectionInitOptions: { wait: false },
+      }),
+      inject: [ConfigService],
+    }),
+    DatabaseModule,
+  ],
+  controllers: [HealthServerController, HealthController],
+  providers: [PrismaHealthIndicatorUseCase, UsersRepository, Messager],
 })
 export class HealthModule {}

src/modules/health/tests/unit/messager.spec.ts

@@ -0,0 +1,47 @@
+import { AmqpConnection } from '@golevelup/nestjs-rabbitmq';
+import { ConfigService } from '@nestjs/config';
+import { Test, TestingModule } from '@nestjs/testing';
+import { Messager } from '../../adapters/secondaries/messager';
+
+const mockAmqpConnection = {
+  publish: jest.fn().mockImplementation(),
+};
+
+const mockConfigService = {
+  get: jest.fn().mockResolvedValue({
+    RMQ_EXCHANGE: 'mobicoop',
+  }),
+};
+
+describe('Messager', () => {
+  let messager: Messager;
+
+  beforeAll(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      imports: [],
+      providers: [
+        Messager,
+        {
+          provide: AmqpConnection,
+          useValue: mockAmqpConnection,
+        },
+        {
+          provide: ConfigService,
+          useValue: mockConfigService,
+        },
+      ],
+    }).compile();
+
+    messager = module.get<Messager>(Messager);
+  });
+
+  it('should be defined', () => {
+    expect(messager).toBeDefined();
+  });
+
+  it('should publish a message', async () => {
+    jest.spyOn(mockAmqpConnection, 'publish');
+    messager.publish('user.create.info', 'my-test');
+    expect(mockAmqpConnection.publish).toHaveBeenCalledTimes(1);
+  });
+});