add configuration module

src/app.module.ts

@@ -2,6 +2,7 @@ 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 { UsersModule } from './modules/users/users.module';
 
 @Module({
@@ -9,6 +10,7 @@ import { UsersModule } from './modules/users/users.module';
     ConfigModule.forRoot({ isGlobal: true }),
     AutomapperModule.forRoot({ strategyInitializer: classes() }),
     UsersModule,
+    ConfigurationModule,
   ],
   controllers: [],
   providers: [],

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

@@ -0,0 +1,48 @@
+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';
+
+@Controller()
+export class ConfigurationMessagerController {
+  constructor(
+    private readonly _commandBus: CommandBus,
+    private readonly _configService: ConfigService,
+  ) {}
+
+  @RabbitSubscribe({
+    exchange: 'configuration',
+    routingKey: ['create', 'update'],
+    queue: 'configuration-update',
+  })
+  public async setConfigurationHandler(message: string) {
+    const configuration = JSON.parse(message);
+    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: 'configuration-delete',
+  })
+  public async configurationDeletedHandler(message: string) {
+    const deletedConfiguration = JSON.parse(message);
+    const deleteConfigurationRequest = new DeleteConfigurationRequest();
+    deleteConfigurationRequest.domain = deletedConfiguration.domain;
+    deleteConfigurationRequest.key = deletedConfiguration.key;
+    await this._commandBus.execute(
+      new DeleteConfigurationCommand(deleteConfigurationRequest),
+    );
+  }
+}

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,34 @@
+import { RedisModule, RedisModuleOptions } from '@liaoliaots/nestjs-redis';
+import { Module } from '@nestjs/common';
+import { ConfigModule, ConfigService } from '@nestjs/config';
+import { CqrsModule } from '@nestjs/cqrs';
+import { RedisConfigurationRepository } from './adapters/secondaries/redis-configuration.repository';
+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> => {
+        return {
+          config: {
+            host: configService.get<string>('REDIS_HOST'),
+            port: configService.get<number>('REDIS_PORT'),
+          },
+        };
+      },
+    }),
+  ],
+  controllers: [],
+  providers: [
+    GetConfigurationUseCase,
+    SetConfigurationUseCase,
+    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,15 @@
+import { AutoMap } from '@automapper/classes';
+
+export class Configuration {
+  @AutoMap()
+  uuid: string;
+
+  @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);
+    });
+  });
+});