add health check rest service

src/main.ts

@@ -4,28 +4,30 @@ import { join } from 'path';
 import { AppModule } from './app.module';
 
 async function bootstrap() {
-  const app = await NestFactory.createMicroservice<MicroserviceOptions>(
-    AppModule,
-    {
-      transport: Transport.GRPC,
-      options: {
-        package: ['authentication', 'authorization', 'health'],
-        protoPath: [
-          join(
-            __dirname,
-            'modules/authentication/adapters/primaries/authentication.proto',
-          ),
-          join(
-            __dirname,
-            'modules/authorization/adapters/primaries/authorization.proto',
-          ),
-          join(__dirname, 'modules/health/adapters/primaries/health.proto'),
-        ],
-        url: process.env.SERVICE_URL + ':' + process.env.SERVICE_PORT,
-        loader: { keepCase: true, enums: String },
-      },
+  const app = await NestFactory.create(AppModule);
+  app.connectMicroservice<MicroserviceOptions>({
+    transport: Transport.TCP,
+  });
+  app.connectMicroservice<MicroserviceOptions>({
+    transport: Transport.GRPC,
+    options: {
+      package: ['authentication', 'authorization', 'health'],
+      protoPath: [
+        join(
+          __dirname,
+          'modules/authentication/adapters/primaries/authentication.proto',
+        ),
+        join(
+          __dirname,
+          'modules/authorization/adapters/primaries/authorization.proto',
+        ),
+        join(__dirname, 'modules/health/adapters/primaries/health.proto'),
+      ],
+      url: process.env.SERVICE_URL + ':' + process.env.SERVICE_PORT,
+      loader: { keepCase: true, enums: String },
     },
-  );
-  await app.listen();
+  });
+  await app.startAllMicroservices();
+  await app.listen(process.env.HEALTH_SERVICE_PORT);
 }
 bootstrap();

src/modules/database/src/adapters/secondaries/prisma-repository.abstract.ts

@@ -180,4 +180,21 @@ export abstract class PrismaRepository<T> implements IRepository<T> {
       }
     }
   }
+
+  async healthCheck(): Promise<boolean> {
+    try {
+      await this._prisma.$queryRaw`SELECT 1`;
+      return true;
+    } catch (e) {
+      if (e instanceof PrismaClientKnownRequestError) {
+        throw new DatabaseException(
+          PrismaClientKnownRequestError.name,
+          e.code,
+          e.message,
+        );
+      } else {
+        throw new DatabaseException();
+      }
+    }
+  }
 }

src/modules/database/tests/unit/prisma-repository.spec.ts

@@ -57,6 +57,23 @@ const mockPrismaService = {
 
     return Promise.resolve([fakeEntities, fakeEntities.length]);
   }),
+  $queryRaw: jest
+    .fn()
+    .mockImplementationOnce(() => {
+      throw new PrismaClientKnownRequestError('unknown request', {
+        code: 'code',
+        clientVersion: 'version',
+      });
+    })
+    .mockImplementationOnce(() => {
+      return true;
+    })
+    .mockImplementation(() => {
+      throw new PrismaClientKnownRequestError('Database unavailable', {
+        code: 'code',
+        clientVersion: 'version',
+      });
+    }),
   fake: {
     create: jest
       .fn()
@@ -422,4 +439,23 @@ describe('PrismaRepository', () => {
       ).rejects.toBeInstanceOf(DatabaseException);
     });
   });
+
+  describe('healthCheck', () => {
+    it('should throw a DatabaseException for client error', async () => {
+      await expect(fakeRepository.healthCheck()).rejects.toBeInstanceOf(
+        DatabaseException,
+      );
+    });
+
+    it('should return a healthy result', async () => {
+      const res = await fakeRepository.healthCheck();
+      expect(res).toBeTruthy();
+    });
+
+    it('should throw an exception if database is not available', async () => {
+      await expect(fakeRepository.healthCheck()).rejects.toBeInstanceOf(
+        DatabaseException,
+      );
+    });
+  });
 });

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

@@ -0,0 +1,43 @@
+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;
+}
+
+// this controller responds to gRPC health check service
+@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,35 @@
-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()
+// this controller responds to rest GET /health
+@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.auth.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 { AuthenticationRepository } from '../../../authentication/adapters/secondaries/authentication.repository';
+
+@Injectable()
+export class PrismaHealthIndicatorUseCase extends HealthIndicator {
+  constructor(private readonly _repository: AuthenticationRepository) {
+    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 { AuthenticationRepository } from '../authentication/adapters/secondaries/authentication.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, AuthenticationRepository, 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('test.create.info', 'my-test');
+    expect(mockAmqpConnection.publish).toHaveBeenCalledTimes(1);
+  });
+});

src/modules/health/tests/unit/prisma.health-indicator.usecase.spec.ts

@@ -0,0 +1,58 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { PrismaHealthIndicatorUseCase } from '../../domain/usecases/prisma.health-indicator.usecase';
+import { AuthenticationRepository } from '../../../authentication/adapters/secondaries/authentication.repository';
+import { PrismaClientKnownRequestError } from '@prisma/client/runtime';
+import { HealthCheckError, HealthIndicatorResult } from '@nestjs/terminus';
+
+const mockAuthenticationRepository = {
+  healthCheck: jest
+    .fn()
+    .mockImplementationOnce(() => {
+      return Promise.resolve(true);
+    })
+    .mockImplementation(() => {
+      throw new PrismaClientKnownRequestError('Service unavailable', {
+        code: 'code',
+        clientVersion: 'version',
+      });
+    }),
+};
+
+describe('PrismaHealthIndicatorUseCase', () => {
+  let prismaHealthIndicatorUseCase: PrismaHealthIndicatorUseCase;
+
+  beforeAll(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [
+        {
+          provide: AuthenticationRepository,
+          useValue: mockAuthenticationRepository,
+        },
+        PrismaHealthIndicatorUseCase,
+      ],
+    }).compile();
+
+    prismaHealthIndicatorUseCase = module.get<PrismaHealthIndicatorUseCase>(
+      PrismaHealthIndicatorUseCase,
+    );
+  });
+
+  it('should be defined', () => {
+    expect(prismaHealthIndicatorUseCase).toBeDefined();
+  });
+
+  describe('execute', () => {
+    it('should check health successfully', async () => {
+      const healthIndicatorResult: HealthIndicatorResult =
+        await prismaHealthIndicatorUseCase.isHealthy('prisma');
+
+      expect(healthIndicatorResult['prisma'].status).toBe('up');
+    });
+
+    it('should throw an error if database is unavailable', async () => {
+      await expect(
+        prismaHealthIndicatorUseCase.isHealthy('prisma'),
+      ).rejects.toBeInstanceOf(HealthCheckError);
+    });
+  });
+});