basic requirements

src/app.module.ts

@@ -0,0 +1,18 @@
+import { classes } from '@automapper/classes';
+import { AutomapperModule } from '@automapper/nestjs';
+import { Module } from '@nestjs/common';
+import { ConfigModule } from '@nestjs/config';
+import { ConfigurationModule } from './modules/configuration/configuration.module';
+import { TerritoriesModule } from './modules/territories/territories.module';
+
+@Module({
+  imports: [
+    ConfigModule.forRoot({ isGlobal: true }),
+    AutomapperModule.forRoot({ strategyInitializer: classes() }),
+    TerritoriesModule,
+    ConfigurationModule,
+  ],
+  controllers: [],
+  providers: [],
+})
+export class AppModule {}

src/main.ts

@@ -0,0 +1,24 @@
+import { NestFactory } from '@nestjs/core';
+import { MicroserviceOptions, Transport } from '@nestjs/microservices';
+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',
+        protoPath: join(
+          __dirname,
+          'modules/territories/adapters/primaries/territory.proto',
+        ),
+        url: process.env.SERVICE_URL + ':' + process.env.SERVICE_PORT,
+        loader: { keepCase: true },
+      },
+    },
+  );
+  await app.listen();
+}
+bootstrap();

src/modules/configuration/adapters/primaries/configuration-messager.controller.ts

@@ -0,0 +1,83 @@
+import { RabbitSubscribe } from '@golevelup/nestjs-rabbitmq';
+import { Controller } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import { CommandBus } from '@nestjs/cqrs';
+import { DeleteConfigurationCommand } from '../../commands/delete-configuration.command';
+import { SetConfigurationCommand } from '../../commands/set-configuration.command';
+import { DeleteConfigurationRequest } from '../../domain/dtos/delete-configuration.request';
+import { SetConfigurationRequest } from '../../domain/dtos/set-configuration.request';
+import { Configuration } from '../../domain/entities/configuration';
+
+@Controller()
+export class ConfigurationMessagerController {
+  constructor(
+    private readonly _commandBus: CommandBus,
+    private readonly _configService: ConfigService,
+  ) {}
+
+  @RabbitSubscribe({
+    exchange: 'configuration',
+    routingKey: ['create', 'update'],
+    queue: 'territory-configuration-update',
+  })
+  public async setConfigurationHandler(message: string) {
+    const configuration: Configuration = JSON.parse(message);
+    if (
+      configuration.domain ==
+      this._configService.get<string>('SERVICE_CONFIGURATION_DOMAIN')
+    ) {
+      const setConfigurationRequest: SetConfigurationRequest =
+        new SetConfigurationRequest();
+      setConfigurationRequest.domain = configuration.domain;
+      setConfigurationRequest.key = configuration.key;
+      setConfigurationRequest.value = configuration.value;
+      await this._commandBus.execute(
+        new SetConfigurationCommand(setConfigurationRequest),
+      );
+    }
+  }
+
+  @RabbitSubscribe({
+    exchange: 'configuration',
+    routingKey: 'delete',
+    queue: 'territory-configuration-delete',
+  })
+  public async configurationDeletedHandler(message: string) {
+    const deletedConfiguration: Configuration = JSON.parse(message);
+    if (
+      deletedConfiguration.domain ==
+      this._configService.get<string>('SERVICE_CONFIGURATION_DOMAIN')
+    ) {
+      const deleteConfigurationRequest = new DeleteConfigurationRequest();
+      deleteConfigurationRequest.domain = deletedConfiguration.domain;
+      deleteConfigurationRequest.key = deletedConfiguration.key;
+      await this._commandBus.execute(
+        new DeleteConfigurationCommand(deleteConfigurationRequest),
+      );
+    }
+  }
+
+  @RabbitSubscribe({
+    exchange: 'configuration',
+    routingKey: 'propagate',
+    queue: 'territory-configuration-propagate',
+  })
+  public async propagateConfigurationsHandler(message: string) {
+    const configurations: Array<Configuration> = JSON.parse(message);
+    configurations.forEach(async (configuration) => {
+      if (
+        configuration.domain ==
+        this._configService.get<string>('SERVICE_CONFIGURATION_DOMAIN')
+      ) {
+        const setConfigurationRequest: SetConfigurationRequest =
+          new SetConfigurationRequest();
+        setConfigurationRequest.domain = configuration.domain;
+        setConfigurationRequest.key = configuration.key;
+        setConfigurationRequest.value = configuration.value;
+        await this._commandBus.execute(
+          new SetConfigurationCommand(setConfigurationRequest),
+        );
+      }
+    });
+  }
+}

src/modules/configuration/adapters/secondaries/redis-configuration.repository.ts

@@ -0,0 +1,23 @@
+import { InjectRedis } from '@liaoliaots/nestjs-redis';
+import { Injectable } from '@nestjs/common';
+import { Redis } from 'ioredis';
+import { IConfigurationRepository } from '../../domain/interfaces/configuration.repository';
+
+@Injectable()
+export class RedisConfigurationRepository extends IConfigurationRepository {
+  constructor(@InjectRedis() private readonly _redis: Redis) {
+    super();
+  }
+
+  async get(key: string): Promise<string> {
+    return await this._redis.get(key);
+  }
+
+  async set(key: string, value: string) {
+    await this._redis.set(key, value);
+  }
+
+  async del(key: string) {
+    await this._redis.del(key);
+  }
+}

src/modules/configuration/commands/delete-configuration.command.ts

@@ -0,0 +1,9 @@
+import { DeleteConfigurationRequest } from '../domain/dtos/delete-configuration.request';
+
+export class DeleteConfigurationCommand {
+  readonly deleteConfigurationRequest: DeleteConfigurationRequest;
+
+  constructor(deleteConfigurationRequest: DeleteConfigurationRequest) {
+    this.deleteConfigurationRequest = deleteConfigurationRequest;
+  }
+}

src/modules/configuration/commands/set-configuration.command.ts

@@ -0,0 +1,9 @@
+import { SetConfigurationRequest } from '../domain/dtos/set-configuration.request';
+
+export class SetConfigurationCommand {
+  readonly setConfigurationRequest: SetConfigurationRequest;
+
+  constructor(setConfigurationRequest: SetConfigurationRequest) {
+    this.setConfigurationRequest = setConfigurationRequest;
+  }
+}

src/modules/configuration/configuration.module.ts

@@ -0,0 +1,53 @@
+import { RabbitMQConfig, RabbitMQModule } from '@golevelup/nestjs-rabbitmq';
+import { RedisModule, RedisModuleOptions } from '@liaoliaots/nestjs-redis';
+import { Module } from '@nestjs/common';
+import { ConfigModule, ConfigService } from '@nestjs/config';
+import { CqrsModule } from '@nestjs/cqrs';
+import { ConfigurationMessagerController } from './adapters/primaries/configuration-messager.controller';
+import { RedisConfigurationRepository } from './adapters/secondaries/redis-configuration.repository';
+import { DeleteConfigurationUseCase } from './domain/usecases/delete-configuration.usecase';
+import { GetConfigurationUseCase } from './domain/usecases/get-configuration.usecase';
+import { SetConfigurationUseCase } from './domain/usecases/set-configuration.usecase';
+
+@Module({
+  imports: [
+    CqrsModule,
+    RedisModule.forRootAsync({
+      imports: [ConfigModule],
+      inject: [ConfigService],
+      useFactory: async (
+        configService: ConfigService,
+      ): Promise<RedisModuleOptions> => ({
+        config: {
+          host: configService.get<string>('REDIS_HOST'),
+          port: configService.get<number>('REDIS_PORT'),
+        },
+      }),
+    }),
+    RabbitMQModule.forRootAsync(RabbitMQModule, {
+      imports: [ConfigModule],
+      inject: [ConfigService],
+      useFactory: async (
+        configService: ConfigService,
+      ): Promise<RabbitMQConfig> => ({
+        exchanges: [
+          {
+            name: 'configuration',
+            type: 'topic',
+          },
+        ],
+        uri: configService.get<string>('RMQ_URI'),
+        connectionInitOptions: { wait: false },
+        enableControllerDiscovery: true,
+      }),
+    }),
+  ],
+  controllers: [ConfigurationMessagerController],
+  providers: [
+    GetConfigurationUseCase,
+    SetConfigurationUseCase,
+    DeleteConfigurationUseCase,
+    RedisConfigurationRepository,
+  ],
+})
+export class ConfigurationModule {}

src/modules/configuration/domain/dtos/delete-configuration.request.ts

@@ -0,0 +1,11 @@
+import { IsNotEmpty, IsString } from 'class-validator';
+
+export class DeleteConfigurationRequest {
+  @IsString()
+  @IsNotEmpty()
+  domain: string;
+
+  @IsString()
+  @IsNotEmpty()
+  key: string;
+}

src/modules/configuration/domain/dtos/set-configuration.request.ts

@@ -0,0 +1,15 @@
+import { IsNotEmpty, IsString } from 'class-validator';
+
+export class SetConfigurationRequest {
+  @IsString()
+  @IsNotEmpty()
+  domain: string;
+
+  @IsString()
+  @IsNotEmpty()
+  key: string;
+
+  @IsString()
+  @IsNotEmpty()
+  value: string;
+}

src/modules/configuration/domain/entities/configuration.ts

@@ -0,0 +1,12 @@
+import { AutoMap } from '@automapper/classes';
+
+export class Configuration {
+  @AutoMap()
+  domain: string;
+
+  @AutoMap()
+  key: string;
+
+  @AutoMap()
+  value: string;
+}

src/modules/configuration/domain/interfaces/configuration.repository.ts

@@ -0,0 +1,8 @@
+import { Injectable } from '@nestjs/common';
+
+@Injectable()
+export abstract class IConfigurationRepository {
+  abstract get(key: string): Promise<string>;
+  abstract set(key: string, value: string): void;
+  abstract del(key: string): void;
+}

src/modules/configuration/domain/usecases/delete-configuration.usecase.ts

@@ -0,0 +1,16 @@
+import { CommandHandler } from '@nestjs/cqrs';
+import { RedisConfigurationRepository } from '../../adapters/secondaries/redis-configuration.repository';
+import { DeleteConfigurationCommand } from '../../commands/delete-configuration.command';
+
+@CommandHandler(DeleteConfigurationCommand)
+export class DeleteConfigurationUseCase {
+  constructor(private _configurationRepository: RedisConfigurationRepository) {}
+
+  async execute(deleteConfigurationCommand: DeleteConfigurationCommand) {
+    await this._configurationRepository.del(
+      deleteConfigurationCommand.deleteConfigurationRequest.domain +
+        ':' +
+        deleteConfigurationCommand.deleteConfigurationRequest.key,
+    );
+  }
+}

src/modules/configuration/domain/usecases/get-configuration.usecase.ts

@@ -0,0 +1,14 @@
+import { QueryHandler } from '@nestjs/cqrs';
+import { RedisConfigurationRepository } from '../../adapters/secondaries/redis-configuration.repository';
+import { GetConfigurationQuery } from '../../queries/get-configuration.query';
+
+@QueryHandler(GetConfigurationQuery)
+export class GetConfigurationUseCase {
+  constructor(private _configurationRepository: RedisConfigurationRepository) {}
+
+  async execute(getConfigurationQuery: GetConfigurationQuery): Promise<string> {
+    return this._configurationRepository.get(
+      getConfigurationQuery.domain + ':' + getConfigurationQuery.key,
+    );
+  }
+}

src/modules/configuration/domain/usecases/set-configuration.usecase.ts

@@ -0,0 +1,17 @@
+import { CommandHandler } from '@nestjs/cqrs';
+import { RedisConfigurationRepository } from '../../adapters/secondaries/redis-configuration.repository';
+import { SetConfigurationCommand } from '../../commands/set-configuration.command';
+
+@CommandHandler(SetConfigurationCommand)
+export class SetConfigurationUseCase {
+  constructor(private _configurationRepository: RedisConfigurationRepository) {}
+
+  async execute(setConfigurationCommand: SetConfigurationCommand) {
+    await this._configurationRepository.set(
+      setConfigurationCommand.setConfigurationRequest.domain +
+        ':' +
+        setConfigurationCommand.setConfigurationRequest.key,
+      setConfigurationCommand.setConfigurationRequest.value,
+    );
+  }
+}

src/modules/configuration/queries/get-configuration.query.ts

@@ -0,0 +1,9 @@
+export class GetConfigurationQuery {
+  readonly domain: string;
+  readonly key: string;
+
+  constructor(domain: string, key: string) {
+    this.domain = domain;
+    this.key = key;
+  }
+}

src/modules/configuration/tests/unit/delete-configuration.usecase.spec.ts

@@ -0,0 +1,49 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { RedisConfigurationRepository } from '../../adapters/secondaries/redis-configuration.repository';
+import { DeleteConfigurationCommand } from '../../commands/delete-configuration.command';
+import { DeleteConfigurationRequest } from '../../domain/dtos/delete-configuration.request';
+import { DeleteConfigurationUseCase } from '../../domain/usecases/delete-configuration.usecase';
+
+const mockRedisConfigurationRepository = {
+  del: jest.fn().mockResolvedValue(undefined),
+};
+
+describe('DeleteConfigurationUseCase', () => {
+  let deleteConfigurationUseCase: DeleteConfigurationUseCase;
+
+  beforeAll(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [
+        {
+          provide: RedisConfigurationRepository,
+          useValue: mockRedisConfigurationRepository,
+        },
+
+        DeleteConfigurationUseCase,
+      ],
+    }).compile();
+
+    deleteConfigurationUseCase = module.get<DeleteConfigurationUseCase>(
+      DeleteConfigurationUseCase,
+    );
+  });
+
+  it('should be defined', () => {
+    expect(deleteConfigurationUseCase).toBeDefined();
+  });
+
+  describe('execute', () => {
+    it('should delete a key', async () => {
+      jest.spyOn(mockRedisConfigurationRepository, 'del');
+      const deleteConfigurationRequest: DeleteConfigurationRequest = {
+        domain: 'my-domain',
+        key: 'my-key',
+      };
+      await deleteConfigurationUseCase.execute(
+        new DeleteConfigurationCommand(deleteConfigurationRequest),
+      );
+
+      expect(mockRedisConfigurationRepository.del).toHaveBeenCalledTimes(1);
+    });
+  });
+});

src/modules/configuration/tests/unit/get-configuration.usecase.spec.ts

@@ -0,0 +1,43 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { RedisConfigurationRepository } from '../../adapters/secondaries/redis-configuration.repository';
+import { GetConfigurationUseCase } from '../../domain/usecases/get-configuration.usecase';
+import { GetConfigurationQuery } from '../../queries/get-configuration.query';
+
+const mockRedisConfigurationRepository = {
+  get: jest.fn().mockResolvedValue('my-value'),
+};
+
+describe('GetConfigurationUseCase', () => {
+  let getConfigurationUseCase: GetConfigurationUseCase;
+
+  beforeAll(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [
+        {
+          provide: RedisConfigurationRepository,
+          useValue: mockRedisConfigurationRepository,
+        },
+
+        GetConfigurationUseCase,
+      ],
+    }).compile();
+
+    getConfigurationUseCase = module.get<GetConfigurationUseCase>(
+      GetConfigurationUseCase,
+    );
+  });
+
+  it('should be defined', () => {
+    expect(getConfigurationUseCase).toBeDefined();
+  });
+
+  describe('execute', () => {
+    it('should get a value for a key', async () => {
+      const value: string = await getConfigurationUseCase.execute(
+        new GetConfigurationQuery('my-domain', 'my-key'),
+      );
+
+      expect(value).toBe('my-value');
+    });
+  });
+});

src/modules/configuration/tests/unit/set-configuration.usecase.spec.ts

@@ -0,0 +1,50 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { RedisConfigurationRepository } from '../../adapters/secondaries/redis-configuration.repository';
+import { SetConfigurationCommand } from '../../commands/set-configuration.command';
+import { SetConfigurationRequest } from '../../domain/dtos/set-configuration.request';
+import { SetConfigurationUseCase } from '../../domain/usecases/set-configuration.usecase';
+
+const mockRedisConfigurationRepository = {
+  set: jest.fn().mockResolvedValue(undefined),
+};
+
+describe('SetConfigurationUseCase', () => {
+  let setConfigurationUseCase: SetConfigurationUseCase;
+
+  beforeAll(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [
+        {
+          provide: RedisConfigurationRepository,
+          useValue: mockRedisConfigurationRepository,
+        },
+
+        SetConfigurationUseCase,
+      ],
+    }).compile();
+
+    setConfigurationUseCase = module.get<SetConfigurationUseCase>(
+      SetConfigurationUseCase,
+    );
+  });
+
+  it('should be defined', () => {
+    expect(setConfigurationUseCase).toBeDefined();
+  });
+
+  describe('execute', () => {
+    it('should set a value for a key', async () => {
+      jest.spyOn(mockRedisConfigurationRepository, 'set');
+      const setConfigurationRequest: SetConfigurationRequest = {
+        domain: 'my-domain',
+        key: 'my-key',
+        value: 'my-value',
+      };
+      await setConfigurationUseCase.execute(
+        new SetConfigurationCommand(setConfigurationRequest),
+      );
+
+      expect(mockRedisConfigurationRepository.set).toHaveBeenCalledTimes(1);
+    });
+  });
+});

src/modules/database/database.module.ts

@@ -0,0 +1,9 @@
+import { Module } from '@nestjs/common';
+import { PrismaService } from './src/adapters/secondaries/prisma-service';
+import { TerritoryRepository } from './src/domain/territory-repository';
+
+@Module({
+  providers: [PrismaService, TerritoryRepository],
+  exports: [PrismaService, TerritoryRepository],
+})
+export class DatabaseModule {}

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

@@ -0,0 +1,185 @@
+import { Injectable } from '@nestjs/common';
+import { PrismaClientKnownRequestError } from '@prisma/client/runtime';
+import { DatabaseException } from '../../exceptions/database.exception';
+import { ICollection } from '../../interfaces/collection.interface';
+import { IRepository } from '../../interfaces/repository.interface';
+import { PrismaService } from './prisma-service';
+
+/**
+ * Child classes MUST redefined _model property with appropriate model name
+ */
+@Injectable()
+export abstract class PrismaRepository<T> implements IRepository<T> {
+  protected _model: string;
+
+  constructor(protected readonly _prisma: PrismaService) {}
+
+  async findAll(
+    page = 1,
+    perPage = 10,
+    where?: any,
+    include?: any,
+  ): Promise<ICollection<T>> {
+    const [data, total] = await this._prisma.$transaction([
+      this._prisma[this._model].findMany({
+        where,
+        include,
+        skip: (page - 1) * perPage,
+        take: perPage,
+      }),
+      this._prisma[this._model].count({
+        where,
+      }),
+    ]);
+    return Promise.resolve({
+      data,
+      total,
+    });
+  }
+
+  async findOneByUuid(uuid: string): Promise<T> {
+    try {
+      const entity = await this._prisma[this._model].findUnique({
+        where: { uuid },
+      });
+
+      return entity;
+    } catch (e) {
+      if (e instanceof PrismaClientKnownRequestError) {
+        throw new DatabaseException(
+          PrismaClientKnownRequestError.name,
+          e.code,
+          e.message,
+        );
+      } else {
+        throw new DatabaseException();
+      }
+    }
+  }
+
+  async findOne(where: any, include?: any): Promise<T> {
+    try {
+      const entity = await this._prisma[this._model].findFirst({
+        where: where,
+        include: include,
+      });
+
+      return entity;
+    } catch (e) {
+      if (e instanceof PrismaClientKnownRequestError) {
+        throw new DatabaseException(PrismaClientKnownRequestError.name, e.code);
+      } else {
+        throw new DatabaseException();
+      }
+    }
+  }
+
+  // TODO : using any is not good, but needed for nested entities
+  // TODO : Refactor for good clean architecture ?
+  async create(entity: Partial<T> | any, include?: any): Promise<T> {
+    try {
+      const res = await this._prisma[this._model].create({
+        data: entity,
+        include: include,
+      });
+
+      return res;
+    } catch (e) {
+      if (e instanceof PrismaClientKnownRequestError) {
+        throw new DatabaseException(
+          PrismaClientKnownRequestError.name,
+          e.code,
+          e.message,
+        );
+      } else {
+        throw new DatabaseException();
+      }
+    }
+  }
+
+  async update(uuid: string, entity: Partial<T>): Promise<T> {
+    try {
+      const updatedEntity = await this._prisma[this._model].update({
+        where: { uuid },
+        data: entity,
+      });
+      return updatedEntity;
+    } catch (e) {
+      if (e instanceof PrismaClientKnownRequestError) {
+        throw new DatabaseException(
+          PrismaClientKnownRequestError.name,
+          e.code,
+          e.message,
+        );
+      } else {
+        throw new DatabaseException();
+      }
+    }
+  }
+
+  async updateWhere(
+    where: any,
+    entity: Partial<T> | any,
+    include?: any,
+  ): Promise<T> {
+    try {
+      const updatedEntity = await this._prisma[this._model].update({
+        where: where,
+        data: entity,
+        include: include,
+      });
+
+      return updatedEntity;
+    } catch (e) {
+      if (e instanceof PrismaClientKnownRequestError) {
+        throw new DatabaseException(
+          PrismaClientKnownRequestError.name,
+          e.code,
+          e.message,
+        );
+      } else {
+        throw new DatabaseException();
+      }
+    }
+  }
+
+  async delete(uuid: string): Promise<T> {
+    try {
+      const entity = await this._prisma[this._model].delete({
+        where: { uuid },
+      });
+
+      return entity;
+    } catch (e) {
+      if (e instanceof PrismaClientKnownRequestError) {
+        throw new DatabaseException(
+          PrismaClientKnownRequestError.name,
+          e.code,
+          e.message,
+        );
+      } else {
+        throw new DatabaseException();
+      }
+    }
+  }
+
+  async deleteMany(where: any): Promise<void> {
+    try {
+      const entity = await this._prisma[this._model].deleteMany({
+        where: where,
+      });
+
+      return entity;
+    } catch (e) {
+      if (e instanceof PrismaClientKnownRequestError) {
+        throw new DatabaseException(
+          PrismaClientKnownRequestError.name,
+          e.code,
+          e.message,
+        );
+      } else {
+        throw new DatabaseException();
+      }
+    }
+  }
+}

src/modules/database/src/adapters/secondaries/prisma-service.ts

@@ -0,0 +1,15 @@
+import { INestApplication, Injectable, OnModuleInit } from '@nestjs/common';
+import { PrismaClient } from '@prisma/client';
+
+@Injectable()
+export class PrismaService extends PrismaClient implements OnModuleInit {
+  async onModuleInit() {
+    await this.$connect();
+  }
+
+  async enableShutdownHooks(app: INestApplication) {
+    this.$on('beforeExit', async () => {
+      await app.close();
+    });
+  }
+}

src/modules/database/src/domain/territory-repository.ts

@@ -0,0 +1,3 @@
+import { PrismaRepository } from '../adapters/secondaries/prisma-repository.abstract';
+
+export class TerritoryRepository<T> extends PrismaRepository<T> {}

src/modules/database/src/exceptions/database.exception.ts

@@ -0,0 +1,24 @@
+export class DatabaseException implements Error {
+  name: string;
+  message: string;
+
+  constructor(
+    private _type: string = 'unknown',
+    private _code: string = '',
+    message?: string,
+  ) {
+    this.name = 'DatabaseException';
+    this.message = message ?? 'An error occured with the database.';
+    if (this.message.includes('Unique constraint failed')) {
+      this.message = 'Already exists.';
+    }
+  }
+
+  get type(): string {
+    return this._type;
+  }
+
+  get code(): string {
+    return this._code;
+  }
+}

src/modules/database/src/interfaces/collection.interface.ts

@@ -0,0 +1,4 @@
+export interface ICollection<T> {
+  data: T[];
+  total: number;
+}

src/modules/database/src/interfaces/repository.interface.ts

@@ -0,0 +1,17 @@
+import { ICollection } from './collection.interface';
+
+export interface IRepository<T> {
+  findAll(
+    page: number,
+    perPage: number,
+    params?: any,
+    include?: any,
+  ): Promise<ICollection<T>>;
+  findOne(where: any, include?: any): Promise<T>;
+  findOneByUuid(uuid: string, include?: any): Promise<T>;
+  create(entity: Partial<T> | any, include?: any): Promise<T>;
+  update(uuid: string, entity: Partial<T>, include?: any): Promise<T>;
+  updateWhere(where: any, entity: Partial<T> | any, include?: any): Promise<T>;
+  delete(uuid: string): Promise<T>;
+  deleteMany(where: any): Promise<void>;
+}

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

@@ -0,0 +1,425 @@
+import { Injectable } from '@nestjs/common';
+import { Test, TestingModule } from '@nestjs/testing';
+import { PrismaService } from '../../src/adapters/secondaries/prisma-service';
+import { PrismaRepository } from '../../src/adapters/secondaries/prisma-repository.abstract';
+import { DatabaseException } from '../../src/exceptions/database.exception';
+import { PrismaClientKnownRequestError } from '@prisma/client/runtime';
+
+class FakeEntity {
+  uuid?: string;
+  name: string;
+}
+
+let entityId = 2;
+const entityUuid = 'uuid-';
+const entityName = 'name-';
+
+const createRandomEntity = (): FakeEntity => {
+  const entity: FakeEntity = {
+    uuid: `${entityUuid}${entityId}`,
+    name: `${entityName}${entityId}`,
+  };
+
+  entityId++;
+
+  return entity;
+};
+
+const fakeEntityToCreate: FakeEntity = {
+  name: 'test',
+};
+
+const fakeEntityCreated: FakeEntity = {
+  ...fakeEntityToCreate,
+  uuid: 'some-uuid',
+};
+
+const fakeEntities: FakeEntity[] = [];
+Array.from({ length: 10 }).forEach(() => {
+  fakeEntities.push(createRandomEntity());
+});
+
+@Injectable()
+class FakePrismaRepository extends PrismaRepository<FakeEntity> {
+  protected _model = 'fake';
+}
+
+class FakePrismaService extends PrismaService {
+  fake: any;
+}
+
+const mockPrismaService = {
+  $transaction: jest.fn().mockImplementation(async (data: any) => {
+    const entities = await data[0];
+    if (entities.length == 1) {
+      return Promise.resolve([[fakeEntityCreated], 1]);
+    }
+
+    return Promise.resolve([fakeEntities, fakeEntities.length]);
+  }),
+  fake: {
+    create: jest
+      .fn()
+      .mockResolvedValueOnce(fakeEntityCreated)
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      .mockImplementationOnce((params?: any) => {
+        throw new PrismaClientKnownRequestError('unknown request', {
+          code: 'code',
+          clientVersion: 'version',
+        });
+      })
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      .mockImplementationOnce((params?: any) => {
+        throw new Error('an unknown error');
+      }),
+
+    findMany: jest.fn().mockImplementation((params?: any) => {
+      if (params?.where?.limit == 1) {
+        return Promise.resolve([fakeEntityCreated]);
+      }
+
+      return Promise.resolve(fakeEntities);
+    }),
+    count: jest.fn().mockResolvedValue(fakeEntities.length),
+
+    findUnique: jest.fn().mockImplementation(async (params?: any) => {
+      let entity;
+
+      if (params?.where?.uuid) {
+        entity = fakeEntities.find(
+          (entity) => entity.uuid === params?.where?.uuid,
+        );
+      }
+
+      if (!entity && params?.where?.uuid == 'unknown') {
+        throw new PrismaClientKnownRequestError('unknown request', {
+          code: 'code',
+          clientVersion: 'version',
+        });
+      } else if (!entity) {
+        throw new Error('no entity');
+      }
+
+      return entity;
+    }),
+
+    findFirst: jest
+      .fn()
+      .mockImplementationOnce((params?: any) => {
+        if (params?.where?.name) {
+          return Promise.resolve(
+            fakeEntities.find((entity) => entity.name === params?.where?.name),
+          );
+        }
+      })
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      .mockImplementationOnce((params?: any) => {
+        throw new PrismaClientKnownRequestError('unknown request', {
+          code: 'code',
+          clientVersion: 'version',
+        });
+      })
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      .mockImplementationOnce((params?: any) => {
+        throw new Error('an unknown error');
+      }),
+
+    update: jest
+      .fn()
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      .mockImplementationOnce((params?: any) => {
+        throw new PrismaClientKnownRequestError('unknown request', {
+          code: 'code',
+          clientVersion: 'version',
+        });
+      })
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      .mockImplementationOnce((params?: any) => {
+        throw new PrismaClientKnownRequestError('unknown request', {
+          code: 'code',
+          clientVersion: 'version',
+        });
+      })
+      .mockImplementationOnce((params: any) => {
+        const entity = fakeEntities.find(
+          (entity) => entity.name === params.where.name,
+        );
+        Object.entries(params.data).map(([key, value]) => {
+          entity[key] = value;
+        });
+
+        return Promise.resolve(entity);
+      })
+      .mockImplementation((params: any) => {
+        const entity = fakeEntities.find(
+          (entity) => entity.uuid === params.where.uuid,
+        );
+        Object.entries(params.data).map(([key, value]) => {
+          entity[key] = value;
+        });
+
+        return Promise.resolve(entity);
+      }),
+
+    delete: jest
+      .fn()
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      .mockImplementationOnce((params?: any) => {
+        throw new PrismaClientKnownRequestError('unknown request', {
+          code: 'code',
+          clientVersion: 'version',
+        });
+      })
+      .mockImplementation((params: any) => {
+        let found = false;
+
+        fakeEntities.forEach((entity, index) => {
+          if (entity.uuid === params?.where?.uuid) {
+            found = true;
+            fakeEntities.splice(index, 1);
+          }
+        });
+
+        if (!found) {
+          throw new Error();
+        }
+      }),
+
+    deleteMany: jest
+      .fn()
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      .mockImplementationOnce((params?: any) => {
+        throw new PrismaClientKnownRequestError('unknown request', {
+          code: 'code',
+          clientVersion: 'version',
+        });
+      })
+      .mockImplementation((params: any) => {
+        let found = false;
+
+        fakeEntities.forEach((entity, index) => {
+          if (entity.uuid === params?.where?.uuid) {
+            found = true;
+            fakeEntities.splice(index, 1);
+          }
+        });
+
+        if (!found) {
+          throw new Error();
+        }
+      }),
+  },
+};
+
+describe('PrismaRepository', () => {
+  let fakeRepository: FakePrismaRepository;
+  let prisma: FakePrismaService;
+
+  beforeAll(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [
+        FakePrismaRepository,
+        {
+          provide: PrismaService,
+          useValue: mockPrismaService,
+        },
+      ],
+    }).compile();
+
+    fakeRepository = module.get<FakePrismaRepository>(FakePrismaRepository);
+    prisma = module.get<PrismaService>(PrismaService) as FakePrismaService;
+  });
+
+  it('should be defined', () => {
+    expect(fakeRepository).toBeDefined();
+    expect(prisma).toBeDefined();
+  });
+
+  describe('findAll', () => {
+    it('should return an array of entities', async () => {
+      jest.spyOn(prisma.fake, 'findMany');
+      jest.spyOn(prisma.fake, 'count');
+      jest.spyOn(prisma, '$transaction');
+
+      const entities = await fakeRepository.findAll();
+      expect(entities).toStrictEqual({
+        data: fakeEntities,
+        total: fakeEntities.length,
+      });
+    });
+
+    it('should return an array containing only one entity', async () => {
+      const entities = await fakeRepository.findAll(1, 10, { limit: 1 });
+
+      expect(prisma.fake.findMany).toHaveBeenCalledWith({
+        skip: 0,
+        take: 10,
+        where: { limit: 1 },
+      });
+      expect(entities).toEqual({
+        data: [fakeEntityCreated],
+        total: 1,
+      });
+    });
+  });
+
+  describe('create', () => {
+    it('should create an entity', async () => {
+      jest.spyOn(prisma.fake, 'create');
+
+      const newEntity = await fakeRepository.create(fakeEntityToCreate);
+      expect(newEntity).toBe(fakeEntityCreated);
+      expect(prisma.fake.create).toHaveBeenCalledTimes(1);
+    });
+
+    it('should throw a DatabaseException for client error', async () => {
+      await expect(
+        fakeRepository.create(fakeEntityToCreate),
+      ).rejects.toBeInstanceOf(DatabaseException);
+    });
+
+    it('should throw a DatabaseException if uuid is not found', async () => {
+      await expect(
+        fakeRepository.create(fakeEntityToCreate),
+      ).rejects.toBeInstanceOf(DatabaseException);
+    });
+  });
+
+  describe('findOneByUuid', () => {
+    it('should find an entity by uuid', async () => {
+      const entity = await fakeRepository.findOneByUuid(fakeEntities[0].uuid);
+      expect(entity).toBe(fakeEntities[0]);
+    });
+
+    it('should throw a DatabaseException for client error', async () => {
+      await expect(
+        fakeRepository.findOneByUuid('unknown'),
+      ).rejects.toBeInstanceOf(DatabaseException);
+    });
+
+    it('should throw a DatabaseException if uuid is not found', async () => {
+      await expect(
+        fakeRepository.findOneByUuid('wrong-uuid'),
+      ).rejects.toBeInstanceOf(DatabaseException);
+    });
+  });
+
+  describe('findOne', () => {
+    it('should find one entity', async () => {
+      const entity = await fakeRepository.findOne({
+        name: fakeEntities[0].name,
+      });
+
+      expect(entity.name).toBe(fakeEntities[0].name);
+    });
+
+    it('should throw a DatabaseException for client error', async () => {
+      await expect(
+        fakeRepository.findOne({
+          name: fakeEntities[0].name,
+        }),
+      ).rejects.toBeInstanceOf(DatabaseException);
+    });
+
+    it('should throw a DatabaseException for unknown error', async () => {
+      await expect(
+        fakeRepository.findOne({
+          name: fakeEntities[0].name,
+        }),
+      ).rejects.toBeInstanceOf(DatabaseException);
+    });
+  });
+
+  describe('update', () => {
+    it('should throw a DatabaseException for client error', async () => {
+      await expect(
+        fakeRepository.update('fake-uuid', { name: 'error' }),
+      ).rejects.toBeInstanceOf(DatabaseException);
+      await expect(
+        fakeRepository.updateWhere({ name: 'error' }, { name: 'new error' }),
+      ).rejects.toBeInstanceOf(DatabaseException);
+    });
+
+    it('should update an entity with name', async () => {
+      const newName = 'new-random-name';
+
+      await fakeRepository.updateWhere(
+        { name: fakeEntities[0].name },
+        {
+          name: newName,
+        },
+      );
+      expect(fakeEntities[0].name).toBe(newName);
+    });
+
+    it('should update an entity with uuid', async () => {
+      const newName = 'random-name';
+
+      await fakeRepository.update(fakeEntities[0].uuid, {
+        name: newName,
+      });
+      expect(fakeEntities[0].name).toBe(newName);
+    });
+
+    it("should throw an exception if an entity doesn't exist", async () => {
+      await expect(
+        fakeRepository.update('fake-uuid', { name: 'error' }),
+      ).rejects.toBeInstanceOf(DatabaseException);
+      await expect(
+        fakeRepository.updateWhere({ name: 'error' }, { name: 'new error' }),
+      ).rejects.toBeInstanceOf(DatabaseException);
+    });
+  });
+
+  describe('delete', () => {
+    it('should throw a DatabaseException for client error', async () => {
+      await expect(fakeRepository.delete('fake-uuid')).rejects.toBeInstanceOf(
+        DatabaseException,
+      );
+    });
+
+    it('should delete an entity', async () => {
+      const savedUuid = fakeEntities[0].uuid;
+
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      const res = await fakeRepository.delete(savedUuid);
+
+      const deletedEntity = fakeEntities.find(
+        (entity) => entity.uuid === savedUuid,
+      );
+      expect(deletedEntity).toBeUndefined();
+    });
+
+    it("should throw an exception if an entity doesn't exist", async () => {
+      await expect(fakeRepository.delete('fake-uuid')).rejects.toBeInstanceOf(
+        DatabaseException,
+      );
+    });
+  });
+
+  describe('deleteMany', () => {
+    it('should throw a DatabaseException for client error', async () => {
+      await expect(
+        fakeRepository.deleteMany({ uuid: 'fake-uuid' }),
+      ).rejects.toBeInstanceOf(DatabaseException);
+    });
+
+    it('should delete entities based on their uuid', async () => {
+      const savedUuid = fakeEntities[0].uuid;
+
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      const res = await fakeRepository.deleteMany({ uuid: savedUuid });
+
+      const deletedEntity = fakeEntities.find(
+        (entity) => entity.uuid === savedUuid,
+      );
+      expect(deletedEntity).toBeUndefined();
+    });
+
+    it("should throw an exception if an entity doesn't exist", async () => {
+      await expect(
+        fakeRepository.deleteMany({ uuid: 'fake-uuid' }),
+      ).rejects.toBeInstanceOf(DatabaseException);
+    });
+  });
+});

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

@@ -0,0 +1,46 @@
+import { Mapper } from '@automapper/core';
+import { InjectMapper } from '@automapper/nestjs';
+import {
+  CacheInterceptor,
+  CacheKey,
+  Controller,
+  UseInterceptors,
+  UsePipes,
+} from '@nestjs/common';
+import { QueryBus } from '@nestjs/cqrs';
+import { GrpcMethod } from '@nestjs/microservices';
+import { Territory } from '../../domain/entities/territory';
+import { FindForPointQuery } from '../../queries/find-for-point.query';
+import { TerritoryPresenter } from './territory.presenter';
+import { ICollection } from '../../../database/src/interfaces/collection.interface';
+import { RpcValidationPipe } from '../../../../utils/pipes/rpc.validation-pipe';
+import { FindForPointRequest } from '../../domain/dtos/find-for-point.request';
+
+@UsePipes(
+  new RpcValidationPipe({
+    whitelist: true,
+    forbidUnknownValues: false,
+  }),
+)
+@Controller()
+export class TerritoriesController {
+  constructor(
+    private readonly _queryBus: QueryBus,
+    @InjectMapper() private readonly _mapper: Mapper,
+  ) {}
+
+  @GrpcMethod('TerritoriesService', 'FindForPoint')
+  @UseInterceptors(CacheInterceptor)
+  @CacheKey('TerritoriesServiceFindForPoint')
+  async findAll(data: FindForPointRequest): Promise<ICollection<Territory>> {
+    const territoryCollection = await this._queryBus.execute(
+      new FindForPointQuery(data),
+    );
+    return Promise.resolve({
+      data: territoryCollection.data.map((territory: Territory) =>
+        this._mapper.map(territory, Territory, TerritoryPresenter),
+      ),
+      total: territoryCollection.total,
+    });
+  }
+}

src/modules/territories/adapters/primaries/territory.presenter.ts

@@ -0,0 +1,9 @@
+import { AutoMap } from '@automapper/classes';
+
+export class TerritoryPresenter {
+  @AutoMap()
+  uuid: string;
+
+  @AutoMap()
+  name: string;
+}

src/modules/territories/adapters/primaries/territory.proto

@@ -0,0 +1,20 @@
+syntax = "proto3";
+
+package territory;
+
+service TerritoriesService {
+  rpc FindForPoint(Point) returns (Territories);
+}
+
+message Point {
+  float lon = 1;
+  float lat = 2;
+}
+
+message Territories {
+  repeated Territory data = 1;
+}
+
+message Territory {
+  string name = 1;
+}

src/modules/territories/adapters/secondaries/logging.messager.ts

@@ -0,0 +1,14 @@
+import { AmqpConnection } from '@golevelup/nestjs-rabbitmq';
+import { Injectable } from '@nestjs/common';
+import { IMessageBroker } from '../../domain/interfaces/message-broker';
+
+@Injectable()
+export class LoggingMessager extends IMessageBroker {
+  constructor(private readonly _amqpConnection: AmqpConnection) {
+    super('logging');
+  }
+
+  publish(routingKey: string, message: string): void {
+    this._amqpConnection.publish(this.exchange, routingKey, message);
+  }
+}

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

@@ -0,0 +1,8 @@
+import { Injectable } from '@nestjs/common';
+import { TerritoryRepository } from '../../../database/src/domain/territory-repository';
+import { Territory } from '../../domain/entities/territory';
+
+@Injectable()
+export class TerritoriesRepository extends TerritoryRepository<Territory> {
+  protected _model = 'territory';
+}

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

@@ -0,0 +1,14 @@
+import { AmqpConnection } from '@golevelup/nestjs-rabbitmq';
+import { Injectable } from '@nestjs/common';
+import { IMessageBroker } from '../../domain/interfaces/message-broker';
+
+@Injectable()
+export class TerritoryMessager extends IMessageBroker {
+  constructor(private readonly _amqpConnection: AmqpConnection) {
+    super('territory');
+  }
+
+  publish(routingKey: string, message: string): void {
+    this._amqpConnection.publish(this.exchange, routingKey, message);
+  }
+}

src/modules/territories/domain/dtos/find-for-point.request.ts

@@ -0,0 +1,11 @@
+import { IsNotEmpty, IsNumber } from 'class-validator';
+
+export class FindForPointRequest {
+  @IsNumber()
+  @IsNotEmpty()
+  lon: number;
+
+  @IsNumber()
+  @IsNotEmpty()
+  lat: number;
+}

src/modules/territories/domain/entities/territory.ts

@@ -0,0 +1,9 @@
+import { AutoMap } from '@automapper/classes';
+
+export class Territory {
+  @AutoMap()
+  uuid: string;
+
+  @AutoMap()
+  name: string;
+}

src/modules/territories/domain/interfaces/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/territories/domain/usecases/find-for-point.usecase.ts

@@ -0,0 +1,19 @@
+import { QueryHandler } from '@nestjs/cqrs';
+import { ICollection } from 'src/modules/database/src/interfaces/collection.interface';
+import { TerritoriesRepository } from '../../adapters/secondaries/territories.repository';
+import { FindForPointQuery } from '../../queries/find-for-point.query';
+import { Territory } from '../entities/territory';
+
+@QueryHandler(FindForPointQuery)
+export class FindForPointUseCase {
+  constructor(private readonly _repository: TerritoriesRepository) {}
+
+  async execute(
+    findForPointQuery: FindForPointQuery,
+  ): Promise<ICollection<Territory>> {
+    return this._repository.findAll(1, 999999, {
+      lon: findForPointQuery.lon,
+      lat: findForPointQuery.lat,
+    });
+  }
+}

src/modules/territories/mappers/territory.profile.ts

@@ -0,0 +1,18 @@
+import { createMap, Mapper } from '@automapper/core';
+import { AutomapperProfile, InjectMapper } from '@automapper/nestjs';
+import { Injectable } from '@nestjs/common';
+import { TerritoryPresenter } from '../adapters/primaries/territory.presenter';
+import { Territory } from '../domain/entities/territory';
+
+@Injectable()
+export class TerritoryProfile extends AutomapperProfile {
+  constructor(@InjectMapper() mapper: Mapper) {
+    super(mapper);
+  }
+
+  override get profile() {
+    return (mapper) => {
+      createMap(mapper, Territory, TerritoryPresenter);
+    };
+  }
+}

src/modules/territories/queries/find-for-point.query.ts

@@ -0,0 +1,11 @@
+import { FindForPointRequest } from '../domain/dtos/find-for-point.request';
+
+export class FindForPointQuery {
+  lon: number;
+  lat: number;
+
+  constructor(findForPointRequest?: FindForPointRequest) {
+    this.lon = findForPointRequest.lon;
+    this.lat = findForPointRequest.lat;
+  }
+}

src/modules/territories/territories.module.ts

@@ -0,0 +1,59 @@
+import { RabbitMQModule } from '@golevelup/nestjs-rabbitmq';
+import { RedisClientOptions } from '@liaoliaots/nestjs-redis';
+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 '../database/database.module';
+import { TerritoriesController } from './adapters/primaries/territories.controller';
+import { LoggingMessager } from './adapters/secondaries/logging.messager';
+import { TerritoriesRepository } from './adapters/secondaries/territories.repository';
+import { TerritoryMessager } from './adapters/secondaries/territory.messager';
+import { FindForPointUseCase } from './domain/usecases/find-for-point.usecase';
+import { TerritoryProfile } from './mappers/territory.profile';
+
+@Module({
+  imports: [
+    DatabaseModule,
+    CqrsModule,
+    RabbitMQModule.forRootAsync(RabbitMQModule, {
+      imports: [ConfigModule],
+      useFactory: async (configService: ConfigService) => ({
+        exchanges: [
+          {
+            name: 'territory',
+            type: 'topic',
+          },
+          {
+            name: 'logging',
+            type: 'topic',
+          },
+        ],
+        uri: configService.get<string>('RMQ_URI'),
+        connectionInitOptions: { wait: false },
+      }),
+      inject: [ConfigService],
+    }),
+    CacheModule.registerAsync<RedisClientOptions>({
+      imports: [ConfigModule],
+      useFactory: async (configService: ConfigService) => ({
+        store: await redisStore({
+          host: configService.get<string>('REDIS_HOST'),
+          port: configService.get<number>('REDIS_PORT'),
+          ttl: configService.get('CACHE_TTL'),
+        }),
+      }),
+      inject: [ConfigService],
+    }),
+  ],
+  controllers: [TerritoriesController],
+  providers: [
+    TerritoryProfile,
+    TerritoriesRepository,
+    TerritoryMessager,
+    LoggingMessager,
+    FindForPointUseCase,
+  ],
+  exports: [],
+})
+export class TerritoriesModule {}

src/modules/territories/tests/unit/find-for-point.usecase.spec.ts

@@ -0,0 +1,61 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { TerritoriesRepository } from '../../adapters/secondaries/territories.repository';
+import { FindForPointRequest } from '../../domain/dtos/find-for-point.request';
+import { FindForPointUseCase } from '../../domain/usecases/find-for-point.usecase';
+import { FindForPointQuery } from '../../queries/find-for-point.query';
+
+const findForPointRequest: FindForPointRequest = new FindForPointRequest();
+findForPointRequest.lon = 6.181455;
+findForPointRequest.lat = 48.685689;
+
+const findforPointQuery: FindForPointQuery = new FindForPointQuery(
+  findForPointRequest,
+);
+
+const mockTerritories = [
+  {
+    uuid: 'bb281075-1b98-4456-89d6-c643d3044a91',
+    name: 'Nancy',
+  },
+  {
+    uuid: 'bb281075-1b98-4456-89d6-c643d3044a92',
+    name: 'Meurthe-et-Moselle',
+  },
+];
+
+const mockTerritoriesRepository = {
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  findAll: jest.fn().mockImplementation((query?: FindForPointQuery) => {
+    return Promise.resolve(mockTerritories);
+  }),
+};
+
+describe('FindforPointUseCase', () => {
+  let findForPointUseCase: FindForPointUseCase;
+
+  beforeAll(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [
+        {
+          provide: TerritoriesRepository,
+          useValue: mockTerritoriesRepository,
+        },
+        FindForPointUseCase,
+      ],
+    }).compile();
+
+    findForPointUseCase = module.get<FindForPointUseCase>(FindForPointUseCase);
+  });
+
+  it('should be defined', () => {
+    expect(findForPointUseCase).toBeDefined();
+  });
+
+  describe('execute', () => {
+    it('should return an array filled with territories', async () => {
+      const territories = await findForPointUseCase.execute(findforPointQuery);
+
+      expect(territories).toBe(mockTerritories);
+    });
+  });
+});

src/modules/territories/tests/unit/logging.messager.usecase.spec.ts

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

src/modules/territories/tests/unit/territory.messager.usecase.spec.ts

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

src/utils/pipes/rpc.validation-pipe.ts

@@ -0,0 +1,14 @@
+import { Injectable, ValidationPipe } from '@nestjs/common';
+import { RpcException } from '@nestjs/microservices';
+
+@Injectable()
+export class RpcValidationPipe extends ValidationPipe {
+  createExceptionFactory() {
+    return (validationErrors = []) => {
+      return new RpcException({
+        code: 3,
+        message: this.flattenValidationErrors(validationErrors),
+      });
+    };
+  }
+}