add health check rest service

src/main.ts

@@ -4,24 +4,24 @@ import { join } from 'path';
 import { AppModule } from './app.module';
 
 async function bootstrap() {
-  const app = await NestFactory.createMicroservice<MicroserviceOptions>(
-    AppModule,
-    {
-      transport: Transport.GRPC,
-      options: {
-        package: ['territory', 'health'],
-        protoPath: [
-          join(
-            __dirname,
-            'modules/territory/adapters/primaries/territory.proto',
-          ),
-          join(__dirname, 'modules/health/adapters/primaries/health.proto'),
-        ],
-        url: process.env.SERVICE_URL + ':' + process.env.SERVICE_PORT,
-        loader: { keepCase: true },
-      },
+  const app = await NestFactory.create(AppModule);
+  app.connectMicroservice<MicroserviceOptions>({
+    transport: Transport.TCP,
+  });
+  app.connectMicroservice<MicroserviceOptions>({
+    transport: Transport.GRPC,
+    options: {
+      package: ['territory', 'health'],
+      protoPath: [
+        join(__dirname, 'modules/territory/adapters/primaries/territory.proto'),
+        join(__dirname, 'modules/health/adapters/primaries/health.proto'),
+      ],
+      url: process.env.SERVICE_URL + ':' + process.env.SERVICE_PORT,
+      loader: { keepCase: true },
     },
-  );
-  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

@@ -236,4 +236,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

@@ -87,6 +87,23 @@ const mockPrismaService = {
     .mockImplementationOnce((fields: object) => {
       throw new Error('an unknown error');
     }),
+  $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()
@@ -532,4 +549,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,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.territory.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 { TerritoriesRepository } from '../../../territory/adapters/secondaries/territories.repository';
+
+@Injectable()
+export class PrismaHealthIndicatorUseCase extends HealthIndicator {
+  constructor(private readonly _repository: TerritoriesRepository) {
+    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 { TerritoriesRepository } from '../territory/adapters/secondaries/territories.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, TerritoriesRepository, 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 { TerritoriesRepository } from '../../../territory/adapters/secondaries/territories.repository';
+import { PrismaClientKnownRequestError } from '@prisma/client/runtime';
+import { HealthCheckError, HealthIndicatorResult } from '@nestjs/terminus';
+
+const mockTerritoriesRepository = {
+  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: TerritoriesRepository,
+          useValue: mockTerritoriesRepository,
+        },
+        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);
+    });
+  });
+});

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

@@ -6,7 +6,7 @@ import { GrpcMethod, RpcException } from '@nestjs/microservices';
 import { Territory } from '../../domain/entities/territory';
 import { FindAllTerritoriesForPointQuery } from '../../queries/find-all-territories-for-point.query';
 import { TerritoryPresenter } from './territory.presenter';
-import { ICollection } from '../../../databases/src/interfaces/collection.interface';
+import { ICollection } from '../../../database/src/interfaces/collection.interface';
 import { RpcValidationPipe } from '../../../../utils/pipes/rpc.validation-pipe';
 import { FindAllTerritoriesForPointRequest } from '../../domain/dtos/find-all-territories-for-point.request';
 import { FindAllTerritoriesRequest } from '../../domain/dtos/find-all-territories.request';
@@ -15,7 +15,7 @@ import { FindTerritoryByUuidRequest } from '../../domain/dtos/find-territory-by-
 import { FindTerritoryByUuidQuery } from '../../queries/find-territory-by-uuid.query';
 import { CreateTerritoryRequest } from '../../domain/dtos/create-territory.request';
 import { CreateTerritoryCommand } from '../../commands/create-territory.command';
-import { DatabaseException } from 'src/modules/databases/src/exceptions/database.exception';
+import { DatabaseException } from 'src/modules/database/src/exceptions/database.exception';
 import { UpdateTerritoryRequest } from '../../domain/dtos/update-territory.request';
 import { UpdateTerritoryCommand } from '../../commands/update-territory.command';
 import { DeleteTerritoryCommand } from '../../commands/delete-territory.command';

src/modules/territory/adapters/secondaries/territories.repository.ts

@@ -1,5 +1,5 @@
 import { Injectable } from '@nestjs/common';
-import { TerritoryRepository } from '../../../databases/src/domain/territory-repository';
+import { TerritoryRepository } from '../../../database/src/domain/territory-repository';
 import { Territory } from '../../domain/entities/territory';
 
 @Injectable()

src/modules/territory/domain/usecases/find-all-territories-for-point.usecase.ts

@@ -1,5 +1,5 @@
 import { QueryHandler } from '@nestjs/cqrs';
-import { ICollection } from 'src/modules/databases/src/interfaces/collection.interface';
+import { ICollection } from 'src/modules/database/src/interfaces/collection.interface';
 import { TerritoriesRepository } from '../../adapters/secondaries/territories.repository';
 import { FindAllTerritoriesForPointQuery } from '../../queries/find-all-territories-for-point.query';
 import { Territory } from '../entities/territory';

src/modules/territory/domain/usecases/find-all-territories-for-points.usecase.ts

@@ -1,5 +1,5 @@
 import { QueryHandler } from '@nestjs/cqrs';
-import { ICollection } from 'src/modules/databases/src/interfaces/collection.interface';
+import { ICollection } from 'src/modules/database/src/interfaces/collection.interface';
 import { TerritoriesRepository } from '../../adapters/secondaries/territories.repository';
 import { FindAllTerritoriesForPointsQuery } from '../../queries/find-all-territories-for-points.query';
 import { Territory } from '../entities/territory';

src/modules/territory/domain/usecases/find-all-territories.usecase.ts

@@ -1,5 +1,5 @@
 import { QueryHandler } from '@nestjs/cqrs';
-import { ICollection } from 'src/modules/databases/src/interfaces/collection.interface';
+import { ICollection } from 'src/modules/database/src/interfaces/collection.interface';
 import { TerritoriesRepository } from '../../adapters/secondaries/territories.repository';
 import { FindAllTerritoriesQuery } from '../../queries/find-all-territories.query';
 import { Territory } from '../entities/territory';

src/modules/territory/territory.module.ts

@@ -4,7 +4,7 @@ import { CacheModule, Module } from '@nestjs/common';
 import { ConfigModule, ConfigService } from '@nestjs/config';
 import { CqrsModule } from '@nestjs/cqrs';
 import { redisStore } from 'cache-manager-ioredis-yet';
-import { DatabaseModule } from '../databases/database.module';
+import { DatabaseModule } from '../database/database.module';
 import { TerritoryController } from './adapters/primaries/territory.controller';
 import { TerritoriesRepository } from './adapters/secondaries/territories.repository';
 import { Messager } from './adapters/secondaries/messager';

src/modules/territory/tests/integration/territories.repository.spec.ts

@@ -1,7 +1,7 @@
 import { TestingModule, Test } from '@nestjs/testing';
-import { DatabaseModule } from '../../../databases/database.module';
-import { PrismaService } from '../../../databases/src/adapters/secondaries/prisma-service';
-import { DatabaseException } from '../../../databases/src/exceptions/database.exception';
+import { DatabaseModule } from '../../../database/database.module';
+import { PrismaService } from '../../../database/src/adapters/secondaries/prisma-service';
+import { DatabaseException } from '../../../database/src/exceptions/database.exception';
 import { TerritoriesRepository } from '../../adapters/secondaries/territories.repository';
 import { v4 as uuidv4 } from 'uuid';
 import { Territory } from '../../domain/entities/territory';