ncaron
/
configuration
mirror of https://gitlab.com/mobicoop/v3/service/configuration.git
1
0
Fork 1
Code Issues Packages Projects Releases Wiki Activity

clean using es6

This commit is contained in:
sbriat 2023-05-05 15:54:19 +02:00
parent 27222ff3b4
commit 762b674659
28 changed files with 493 additions and 323 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
src/modules/configuration/adapters/primaries/configuration.controller.ts
View File

@ -3,8 +3,8 @@ import { InjectMapper } from '@automapper/nestjs';
import { Controller, UsePipes } from '@nestjs/common';
import { CommandBus, QueryBus } from '@nestjs/cqrs';
import { GrpcMethod, RpcException } from '@nestjs/microservices';
import { DatabaseException } from 'src/modules/database/src/exceptions/database.exception';
import { ICollection } from 'src/modules/database/src/interfaces/collection.interface';
import { DatabaseException } from 'src/modules/database/exceptions/database.exception';
import { ICollection } from 'src/modules/database/interfaces/collection.interface';
import { RpcValidationPipe } from 'src/utils/pipes/rpc.validation-pipe';
import { CreateConfigurationCommand } from '../../commands/create-configuration.command';
import { DeleteConfigurationCommand } from '../../commands/delete-configuration.command';
@ -28,21 +28,21 @@ import { ConfigurationPresenter } from './configuration.presenter';
@Controller()
export class ConfigurationController {
constructor(
private readonly _commandBus: CommandBus,
private readonly _queryBus: QueryBus,
@InjectMapper() private readonly _mapper: Mapper,
private readonly commandBus: CommandBus,
private readonly queryBus: QueryBus,
@InjectMapper() private readonly mapper: Mapper,
) {}
@GrpcMethod('ConfigurationService', 'FindAll')
async findAll(
data: FindAllConfigurationsRequest,
): Promise<ICollection<Configuration>> {
const configurationCollection = await this._queryBus.execute(
const configurationCollection = await this.queryBus.execute(
new FindAllConfigurationsQuery(data),
);
return Promise.resolve({
data: configurationCollection.data.map((configuration: Configuration) =>
this._mapper.map(configuration, Configuration, ConfigurationPresenter),
this.mapper.map(configuration, Configuration, ConfigurationPresenter),
),
total: configurationCollection.total,
});
@ -53,10 +53,10 @@ export class ConfigurationController {
data: FindConfigurationByUuidRequest,
): Promise<ConfigurationPresenter> {
try {
const configuration = await this._queryBus.execute(
const configuration = await this.queryBus.execute(
new FindConfigurationByUuidQuery(data),
);
return this._mapper.map(
return this.mapper.map(
configuration,
Configuration,
ConfigurationPresenter,
@ -74,10 +74,10 @@ export class ConfigurationController {
data: CreateConfigurationRequest,
): Promise<ConfigurationPresenter> {
try {
const configuration = await this._commandBus.execute(
const configuration = await this.commandBus.execute(
new CreateConfigurationCommand(data),
);
return this._mapper.map(
return this.mapper.map(
configuration,
Configuration,
ConfigurationPresenter,
@ -100,11 +100,11 @@ export class ConfigurationController {
data: UpdateConfigurationRequest,
): Promise<ConfigurationPresenter> {
try {
const configuration = await this._commandBus.execute(
const configuration = await this.commandBus.execute(
new UpdateConfigurationCommand(data),
);
return this._mapper.map(
return this.mapper.map(
configuration,
Configuration,
ConfigurationPresenter,
@ -127,7 +127,7 @@ export class ConfigurationController {
data: FindConfigurationByUuidRequest,
): Promise<void> {
try {
await this._commandBus.execute(new DeleteConfigurationCommand(data.uuid));
await this.commandBus.execute(new DeleteConfigurationCommand(data.uuid));
return Promise.resolve();
} catch (e) {
@ -146,7 +146,7 @@ export class ConfigurationController {
@GrpcMethod('ConfigurationService', 'Propagate')
async propagate(): Promise<void> {
try {
await this._queryBus.execute(new PropagateConfigurationsQuery());
await this.queryBus.execute(new PropagateConfigurationsQuery());
} catch (e) {
throw new RpcException({});
}

4
src/modules/configuration/adapters/secondaries/configuration.repository.ts
View File

@ -1,8 +1,8 @@
import { Injectable } from '@nestjs/common';
import { ConfigRepository } from '../../../database/src/domain/configuration.repository';
import { ConfigRepository } from '../../../database/domain/configuration.repository';
import { Configuration } from '../../domain/entities/configuration';
@Injectable()
export class ConfigurationRepository extends ConfigRepository<Configuration> {
protected _model = 'configuration';
protected model = 'configuration';
}

10
src/modules/configuration/adapters/secondaries/messager.ts
View File

@ -6,13 +6,13 @@ import { IMessageBroker } from '../../domain/interfaces/message-broker';
@Injectable()
export class Messager extends IMessageBroker {
constructor(
private readonly _amqpConnection: AmqpConnection,
configService: ConfigService,
private readonly amqpConnection: AmqpConnection,
private readonly configService: ConfigService,
) {
super(configService.get<string>('RMQ_EXCHANGE'));
}
publish(routingKey: string, message: string): void {
this._amqpConnection.publish(this.exchange, routingKey, message);
}
publish = (routingKey: string, message: string): void => {
this.amqpConnection.publish(this.exchange, routingKey, message);
};
}

2
src/modules/configuration/configuration.module.ts
View File

@ -2,7 +2,7 @@ import { RabbitMQModule } from '@golevelup/nestjs-rabbitmq';
import { Module } from '@nestjs/common';
import { ConfigModule, ConfigService } from '@nestjs/config';
import { CqrsModule } from '@nestjs/cqrs';
import { DatabaseModule } from '../database/database.module';
import { DatabaseModule } from '../databasec/database.module';
import { ConfigurationController } from './adapters/primaries/configuration.controller';
import { Messager } from './adapters/secondaries/messager';
import { ConfigurationRepository } from './adapters/secondaries/configuration.repository';

24
src/modules/configuration/domain/usecases/create-configuration.usecase.ts
View File

@ -11,31 +11,33 @@ import { Configuration } from '../entities/configuration';
@CommandHandler(CreateConfigurationCommand)
export class CreateConfigurationUseCase {
constructor(
private readonly _repository: ConfigurationRepository,
private readonly _messager: Messager,
@InjectMapper() private readonly _mapper: Mapper,
private readonly repository: ConfigurationRepository,
private readonly messager: Messager,
@InjectMapper() private readonly mapper: Mapper,
) {}
async execute(command: CreateConfigurationCommand): Promise<Configuration> {
const entity = this._mapper.map(
execute = async (
command: CreateConfigurationCommand,
): Promise<Configuration> => {
const entity = this.mapper.map(
command.createConfigurationRequest,
CreateConfigurationRequest,
Configuration,
);
try {
const configuration = await this._repository.create(entity);
this._messager.publish(
const configuration = await this.repository.create(entity);
this.messager.publish(
'configuration.create',
JSON.stringify(
this._mapper.map(
this.mapper.map(
configuration,
Configuration,
ConfigurationMessagerPresenter,
),
),
);
this._messager.publish(
this.messager.publish(
'logging.configuration.create.info',
JSON.stringify(configuration),
);
@ -45,7 +47,7 @@ export class CreateConfigurationUseCase {
if (error.message.includes('Already exists')) {
key = 'logging.configuration.create.warning';
}
this._messager.publish(
this.messager.publish(
key,
JSON.stringify({
command,
@ -54,5 +56,5 @@ export class CreateConfigurationUseCase {
);
throw error;
}
}
};
}

22
src/modules/configuration/domain/usecases/delete-configuration.usecase.ts
View File

@ -10,31 +10,33 @@ import { Configuration } from '../entities/configuration';
@CommandHandler(DeleteConfigurationCommand)
export class DeleteConfigurationUseCase {
constructor(
private readonly _repository: ConfigurationRepository,
private readonly _messager: Messager,
@InjectMapper() private readonly _mapper: Mapper,
private readonly repository: ConfigurationRepository,
private readonly messager: Messager,
@InjectMapper() private readonly mapper: Mapper,
) {}
async execute(command: DeleteConfigurationCommand): Promise<Configuration> {
execute = async (
command: DeleteConfigurationCommand,
): Promise<Configuration> => {
try {
const configuration = await this._repository.delete(command.uuid);
this._messager.publish(
const configuration = await this.repository.delete(command.uuid);
this.messager.publish(
'configuration.delete',
JSON.stringify(
this._mapper.map(
this.mapper.map(
configuration,
Configuration,
ConfigurationMessagerPresenter,
),
),
);
this._messager.publish(
this.messager.publish(
'logging.configuration.delete.info',
JSON.stringify({ uuid: configuration.uuid }),
);
return configuration;
} catch (error) {
this._messager.publish(
this.messager.publish(
'logging.configuration.delete.crit',
JSON.stringify({
command,
@ -43,5 +45,5 @@ export class DeleteConfigurationUseCase {
);
throw error;
}
}
};
}

11
src/modules/configuration/domain/usecases/find-all-configurations.usecase.ts
View File

@ -1,19 +1,18 @@
import { QueryHandler } from '@nestjs/cqrs';
import { ICollection } from 'src/modules/database/src/interfaces/collection.interface';
import { ICollection } from 'src/modules/database/interfaces/collection.interface';
import { ConfigurationRepository } from '../../adapters/secondaries/configuration.repository';
import { FindAllConfigurationsQuery } from '../../queries/find-all-configurations.query';
import { Configuration } from '../entities/configuration';
@QueryHandler(FindAllConfigurationsQuery)
export class FindAllConfigurationsUseCase {
constructor(private readonly _repository: ConfigurationRepository) {}
constructor(private readonly repository: ConfigurationRepository) {}
async execute(
execute = async (
findAllConfigurationsQuery: FindAllConfigurationsQuery,
): Promise<ICollection<Configuration>> {
return this._repository.findAll(
): Promise<ICollection<Configuration>> =>
this.repository.findAll(
findAllConfigurationsQuery.page,
findAllConfigurationsQuery.perPage,
);
}
}

14
src/modules/configuration/domain/usecases/find-configuration-by-uuid.usecase.ts
View File

@ -8,21 +8,21 @@ import { Configuration } from '../entities/configuration';
@QueryHandler(FindConfigurationByUuidQuery)
export class FindConfigurationByUuidUseCase {
constructor(
private readonly _repository: ConfigurationRepository,
private readonly _messager: Messager,
private readonly repository: ConfigurationRepository,
private readonly messager: Messager,
) {}
async execute(
execute = async (
findConfigurationByUuid: FindConfigurationByUuidQuery,
): Promise<Configuration> {
): Promise<Configuration> => {
try {
const configuration = await this._repository.findOneByUuid(
const configuration = await this.repository.findOneByUuid(
findConfigurationByUuid.uuid,
);
if (!configuration) throw new NotFoundException();
return configuration;
} catch (error) {
this._messager.publish(
this.messager.publish(
'logging.configuration.read.warning',
JSON.stringify({
query: findConfigurationByUuid,
@ -31,5 +31,5 @@ export class FindConfigurationByUuidUseCase {
);
throw error;
}
}
};
}

30
src/modules/configuration/domain/usecases/propagate-configurations.usecase.ts
View File

@ -10,20 +10,22 @@ import { Configuration } from '../entities/configuration';
@QueryHandler(PropagateConfigurationsQuery)
export class PropagateConfigurationsUseCase {
constructor(
private readonly _repository: ConfigurationRepository,
private readonly _messager: Messager,
@InjectMapper() private readonly _mapper: Mapper,
private readonly repository: ConfigurationRepository,
private readonly messager: Messager,
@InjectMapper() private readonly mapper: Mapper,
) {}
// eslint-disable-next-line @typescript-eslint/no-unused-vars
async execute(propagateConfigurationsQuery: PropagateConfigurationsQuery) {
execute = async (
// eslint-disable-next-line @typescript-eslint/no-unused-vars
propagateConfigurationsQuery: PropagateConfigurationsQuery,
) => {
try {
const configurations = await this._repository.findAll(1, 999999);
this._messager.publish(
const configurations = await this.repository.findAll(1, 999999);
this.messager.publish(
'configuration.propagate',
JSON.stringify(
configurations.data.map((configuration) =>
this._mapper.map(
this.mapper.map(
configuration,
Configuration,
ConfigurationMessagerPresenter,
@ -31,16 +33,10 @@ export class PropagateConfigurationsUseCase {
),
),
);
this._messager.publish(
'logging.configuration.update.info',
'propagation',
);
this.messager.publish('logging.configuration.update.info', 'propagation');
} catch (error) {
this._messager.publish(
'logging.configuration.update.crit',
'propagation',
);
this.messager.publish('logging.configuration.update.crit', 'propagation');
throw error;
}
}
};
}

24
src/modules/configuration/domain/usecases/update-configuration.usecase.ts
View File

@ -11,40 +11,42 @@ import { Configuration } from '../entities/configuration';
@CommandHandler(UpdateConfigurationCommand)
export class UpdateConfigurationUseCase {
constructor(
private readonly _repository: ConfigurationRepository,
private readonly _messager: Messager,
@InjectMapper() private readonly _mapper: Mapper,
private readonly repository: ConfigurationRepository,
private readonly messager: Messager,
@InjectMapper() private readonly mapper: Mapper,
) {}
async execute(command: UpdateConfigurationCommand): Promise<Configuration> {
const entity = this._mapper.map(
execute = async (
command: UpdateConfigurationCommand,
): Promise<Configuration> => {
const entity = this.mapper.map(
command.updateConfigurationRequest,
UpdateConfigurationRequest,
Configuration,
);
try {
const configuration = await this._repository.update(
const configuration = await this.repository.update(
command.updateConfigurationRequest.uuid,
entity,
);
this._messager.publish(
this.messager.publish(
'configuration.update',
JSON.stringify(
this._mapper.map(
this.mapper.map(
configuration,
Configuration,
ConfigurationMessagerPresenter,
),
),
);
this._messager.publish(
this.messager.publish(
'logging.configuration.update.info',
JSON.stringify(command.updateConfigurationRequest),
);
return configuration;
} catch (error) {
this._messager.publish(
this.messager.publish(
'logging.configuration.update.crit',
JSON.stringify({
command,
@ -53,5 +55,5 @@ export class UpdateConfigurationUseCase {
);
throw error;
}
}
};
}

4
src/modules/configuration/tests/integration/configuration.repository.spec.ts
View File

@ -1,7 +1,7 @@
import { TestingModule, Test } from '@nestjs/testing';
import { DatabaseModule } from '../../../database/database.module';
import { PrismaService } from '../../../database/src/adapters/secondaries/prisma-service';
import { DatabaseException } from '../../../database/src/exceptions/database.exception';
import { PrismaService } from '../../../database/adapters/secondaries/prisma-service';
import { DatabaseException } from '../../../database/exceptions/database.exception';
import { ConfigurationRepository } from '../../adapters/secondaries/configuration.repository';
import { Domain } from '../../domain/dtos/domain.enum';
import { Configuration } from '../../domain/entities/configuration';

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

@ -1,7 +1,7 @@
import { classes } from '@automapper/classes';
import { AutomapperModule } from '@automapper/nestjs';
import { Test, TestingModule } from '@nestjs/testing';
import { ICollection } from 'src/modules/database/src/interfaces/collection.interface';
import { ICollection } from 'src/modules/database/interfaces/collection.interface';
import { Messager } from '../../adapters/secondaries/messager';
import { ConfigurationRepository } from '../../adapters/secondaries/configuration.repository';
import { DeleteConfigurationCommand } from '../../commands/delete-configuration.command';

2
src/modules/configuration/tests/unit/find-all-configurations.usecase.spec.ts
View File

@ -1,5 +1,5 @@
import { Test, TestingModule } from '@nestjs/testing';
import { ICollection } from 'src/modules/database/src/interfaces/collection.interface';
import { ICollection } from 'src/modules/database/interfaces/collection.interface';
import { ConfigurationRepository } from '../../adapters/secondaries/configuration.repository';
import { Domain } from '../../domain/dtos/domain.enum';
import { FindAllConfigurationsRequest } from '../../domain/dtos/find-all-configurations.request';

2
src/modules/configuration/tests/unit/propagate-configurations.usecase.spec.ts
View File

@ -1,7 +1,7 @@
import { classes } from '@automapper/classes';
import { AutomapperModule } from '@automapper/nestjs';
import { Test, TestingModule } from '@nestjs/testing';
import { ICollection } from 'src/modules/database/src/interfaces/collection.interface';
import { ICollection } from 'src/modules/database/interfaces/collection.interface';
import { Messager } from '../../adapters/secondaries/messager';
import { ConfigurationRepository } from '../../adapters/secondaries/configuration.repository';
import { Domain } from '../../domain/dtos/domain.enum';

259
src/modules/database/adapters/secondaries/prisma-repository.abstract.ts Normal file
View File

@ -0,0 +1,259 @@
import { Injectable } from '@nestjs/common';
import { Prisma } from '@prisma/client';
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) {}
findAll = async (
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,
});
};
findOneByUuid = async (uuid: string): Promise<T> => {
try {
const entity = await this.prisma[this.model].findUnique({
where: { uuid },
});
return entity;
} catch (e) {
if (e instanceof Prisma.PrismaClientKnownRequestError) {
throw new DatabaseException(
Prisma.PrismaClientKnownRequestError.name,
e.code,
e.message,
);
} else {
throw new DatabaseException();
}
}
};
findOne = async (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 Prisma.PrismaClientKnownRequestError) {
throw new DatabaseException(
Prisma.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 ?
create = async (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 Prisma.PrismaClientKnownRequestError) {
throw new DatabaseException(
Prisma.PrismaClientKnownRequestError.name,
e.code,
e.message,
);
} else {
throw new DatabaseException();
}
}
};
update = async (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 Prisma.PrismaClientKnownRequestError) {
throw new DatabaseException(
Prisma.PrismaClientKnownRequestError.name,
e.code,
e.message,
);
} else {
throw new DatabaseException();
}
}
};
updateWhere = async (
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 Prisma.PrismaClientKnownRequestError) {
throw new DatabaseException(
Prisma.PrismaClientKnownRequestError.name,
e.code,
e.message,
);
} else {
throw new DatabaseException();
}
}
};
delete = async (uuid: string): Promise<T> => {
try {
const entity = await this.prisma[this.model].delete({
where: { uuid },
});
return entity;
} catch (e) {
if (e instanceof Prisma.PrismaClientKnownRequestError) {
throw new DatabaseException(
Prisma.PrismaClientKnownRequestError.name,
e.code,
e.message,
);
} else {
throw new DatabaseException();
}
}
};
deleteMany = async (where: any): Promise<void> => {
try {
const entity = await this.prisma[this.model].deleteMany({
where: where,
});
return entity;
} catch (e) {
if (e instanceof Prisma.PrismaClientKnownRequestError) {
throw new DatabaseException(
Prisma.PrismaClientKnownRequestError.name,
e.code,
e.message,
);
} else {
throw new DatabaseException();
}
}
};
findAllByQuery = async (
include: string[],
where: string[],
): Promise<ICollection<T>> => {
const query = `SELECT ${include.join(',')} FROM ${
this.model
} WHERE ${where.join(' AND ')}`;
const data: T[] = await this.prisma.$queryRawUnsafe(query);
return Promise.resolve({
data,
total: data.length,
});
};
createWithFields = async (fields: object): Promise<number> => {
try {
const command = `INSERT INTO ${this.model} ("${Object.keys(fields).join(
'","',
)}") VALUES (${Object.values(fields).join(',')})`;
return await this.prisma.$executeRawUnsafe(command);
} catch (e) {
if (e instanceof Prisma.PrismaClientKnownRequestError) {
throw new DatabaseException(
Prisma.PrismaClientKnownRequestError.name,
e.code,
e.message,
);
} else {
throw new DatabaseException();
}
}
};
updateWithFields = async (uuid: string, entity: object): Promise<number> => {
entity['"updatedAt"'] = `to_timestamp(${Date.now()} / 1000.0)`;
const values = Object.keys(entity).map((key) => `${key} = ${entity[key]}`);
try {
const command = `UPDATE ${this.model} SET ${values.join(
', ',
)} WHERE uuid = '${uuid}'`;
return await this.prisma.$executeRawUnsafe(command);
} catch (e) {
if (e instanceof Prisma.PrismaClientKnownRequestError) {
throw new DatabaseException(
Prisma.PrismaClientKnownRequestError.name,
e.code,
e.message,
);
} else {
throw new DatabaseException();
}
}
};
healthCheck = async (): Promise<boolean> => {
try {
await this.prisma.$queryRaw`SELECT 1`;
return true;
} catch (e) {
if (e instanceof Prisma.PrismaClientKnownRequestError) {
throw new DatabaseException(
Prisma.PrismaClientKnownRequestError.name,
e.code,
e.message,
);
} else {
throw new DatabaseException();
}
}
};
}

0
src/modules/database/src/adapters/secondaries/prisma-service.ts → src/modules/database/adapters/secondaries/prisma-service.ts
View File

4
src/modules/database/database.module.ts
View File

@ -1,6 +1,6 @@
import { Module } from '@nestjs/common';
import { PrismaService } from './src/adapters/secondaries/prisma-service';
import { ConfigRepository } from './src/domain/configuration.repository';
import { PrismaService } from './adapters/secondaries/prisma-service';
import { ConfigRepository } from './domain/configuration.repository';
@Module({
providers: [PrismaService, ConfigRepository],

0
src/modules/database/src/domain/configuration.repository.ts → src/modules/database/domain/configuration.repository.ts
View File

0
src/modules/database/src/exceptions/database.exception.ts → src/modules/database/exceptions/database.exception.ts
View File

0
src/modules/database/src/interfaces/collection.interface.ts → src/modules/database/interfaces/collection.interface.ts
View File

0
src/modules/database/src/interfaces/repository.interface.ts → src/modules/database/interfaces/repository.interface.ts
View File

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

@ -1,200 +0,0 @@
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();
}
}
}
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();
}
}
}
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();
}
}
}
}

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

@ -1,9 +1,9 @@
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';
import { PrismaService } from '../../adapters/secondaries/prisma-service';
import { PrismaRepository } from '../../adapters/secondaries/prisma-repository.abstract';
import { DatabaseException } from '../../exceptions/database.exception';
import { Prisma } from '@prisma/client';
class FakeEntity {
uuid?: string;
@ -41,7 +41,7 @@ Array.from({ length: 10 }).forEach(() => {
@Injectable()
class FakePrismaRepository extends PrismaRepository<FakeEntity> {
protected _model = 'fake';
protected model = 'fake';
}
class FakePrismaService extends PrismaService {
@ -57,10 +57,40 @@ const mockPrismaService = {
return Promise.resolve([fakeEntities, fakeEntities.length]);
}),
// eslint-disable-next-line @typescript-eslint/no-unused-vars
$queryRawUnsafe: jest.fn().mockImplementation((query?: string) => {
return Promise.resolve(fakeEntities);
}),
$executeRawUnsafe: jest
.fn()
.mockResolvedValueOnce(fakeEntityCreated)
// eslint-disable-next-line @typescript-eslint/no-unused-vars
.mockImplementationOnce((fields: object) => {
throw new Prisma.PrismaClientKnownRequestError('unknown request', {
code: 'code',
clientVersion: 'version',
});
})
// eslint-disable-next-line @typescript-eslint/no-unused-vars
.mockImplementationOnce((fields: object) => {
throw new Error('an unknown error');
})
.mockResolvedValueOnce(fakeEntityCreated)
// eslint-disable-next-line @typescript-eslint/no-unused-vars
.mockImplementationOnce((fields: object) => {
throw new Prisma.PrismaClientKnownRequestError('unknown request', {
code: 'code',
clientVersion: 'version',
});
})
// eslint-disable-next-line @typescript-eslint/no-unused-vars
.mockImplementationOnce((fields: object) => {
throw new Error('an unknown error');
}),
$queryRaw: jest
.fn()
.mockImplementationOnce(() => {
throw new PrismaClientKnownRequestError('unknown request', {
throw new Prisma.PrismaClientKnownRequestError('unknown request', {
code: 'code',
clientVersion: 'version',
});
@ -69,7 +99,7 @@ const mockPrismaService = {
return true;
})
.mockImplementation(() => {
throw new PrismaClientKnownRequestError('Database unavailable', {
throw new Prisma.PrismaClientKnownRequestError('Database unavailable', {
code: 'code',
clientVersion: 'version',
});
@ -80,7 +110,7 @@ const mockPrismaService = {
.mockResolvedValueOnce(fakeEntityCreated)
// eslint-disable-next-line @typescript-eslint/no-unused-vars
.mockImplementationOnce((params?: any) => {
throw new PrismaClientKnownRequestError('unknown request', {
throw new Prisma.PrismaClientKnownRequestError('unknown request', {
code: 'code',
clientVersion: 'version',
});
@ -109,7 +139,7 @@ const mockPrismaService = {
}
if (!entity && params?.where?.uuid == 'unknown') {
throw new PrismaClientKnownRequestError('unknown request', {
throw new Prisma.PrismaClientKnownRequestError('unknown request', {
code: 'code',
clientVersion: 'version',
});
@ -131,7 +161,7 @@ const mockPrismaService = {
})
// eslint-disable-next-line @typescript-eslint/no-unused-vars
.mockImplementationOnce((params?: any) => {
throw new PrismaClientKnownRequestError('unknown request', {
throw new Prisma.PrismaClientKnownRequestError('unknown request', {
code: 'code',
clientVersion: 'version',
});
@ -145,14 +175,14 @@ const mockPrismaService = {
.fn()
// eslint-disable-next-line @typescript-eslint/no-unused-vars
.mockImplementationOnce((params?: any) => {
throw new PrismaClientKnownRequestError('unknown request', {
throw new Prisma.PrismaClientKnownRequestError('unknown request', {
code: 'code',
clientVersion: 'version',
});
})
// eslint-disable-next-line @typescript-eslint/no-unused-vars
.mockImplementationOnce((params?: any) => {
throw new PrismaClientKnownRequestError('unknown request', {
throw new Prisma.PrismaClientKnownRequestError('unknown request', {
code: 'code',
clientVersion: 'version',
});
@ -182,7 +212,7 @@ const mockPrismaService = {
.fn()
// eslint-disable-next-line @typescript-eslint/no-unused-vars
.mockImplementationOnce((params?: any) => {
throw new PrismaClientKnownRequestError('unknown request', {
throw new Prisma.PrismaClientKnownRequestError('unknown request', {
code: 'code',
clientVersion: 'version',
});
@ -206,7 +236,7 @@ const mockPrismaService = {
.fn()
// eslint-disable-next-line @typescript-eslint/no-unused-vars
.mockImplementationOnce((params?: any) => {
throw new PrismaClientKnownRequestError('unknown request', {
throw new Prisma.PrismaClientKnownRequestError('unknown request', {
code: 'code',
clientVersion: 'version',
});
@ -440,6 +470,86 @@ describe('PrismaRepository', () => {
});
});
describe('findAllByquery', () => {
it('should return an array of entities', async () => {
const entities = await fakeRepository.findAllByQuery(
['uuid', 'name'],
['name is not null'],
);
expect(entities).toStrictEqual({
data: fakeEntities,
total: fakeEntities.length,
});
});
});
describe('createWithFields', () => {
it('should create an entity', async () => {
jest.spyOn(prisma, '$queryRawUnsafe');
const newEntity = await fakeRepository.createWithFields({
uuid: '804319b3-a09b-4491-9f82-7976bfce0aff',
name: 'my-name',
});
expect(newEntity).toBe(fakeEntityCreated);
expect(prisma.$queryRawUnsafe).toHaveBeenCalledTimes(1);
});
it('should throw a DatabaseException for client error', async () => {
await expect(
fakeRepository.createWithFields({
uuid: '804319b3-a09b-4491-9f82-7976bfce0aff',
name: 'my-name',
}),
).rejects.toBeInstanceOf(DatabaseException);
});
it('should throw a DatabaseException if uuid is not found', async () => {
await expect(
fakeRepository.createWithFields({
name: 'my-name',
}),
).rejects.toBeInstanceOf(DatabaseException);
});
});
describe('updateWithFields', () => {
it('should update an entity', async () => {
jest.spyOn(prisma, '$queryRawUnsafe');
const updatedEntity = await fakeRepository.updateWithFields(
'804319b3-a09b-4491-9f82-7976bfce0aff',
{
name: 'my-name',
},
);
expect(updatedEntity).toBe(fakeEntityCreated);
expect(prisma.$queryRawUnsafe).toHaveBeenCalledTimes(1);
});
it('should throw a DatabaseException for client error', async () => {
await expect(
fakeRepository.updateWithFields(
'804319b3-a09b-4491-9f82-7976bfce0aff',
{
name: 'my-name',
},
),
).rejects.toBeInstanceOf(DatabaseException);
});
it('should throw a DatabaseException if uuid is not found', async () => {
await expect(
fakeRepository.updateWithFields(
'804319b3-a09b-4491-9f82-7976bfce0aff',
{
name: 'my-name',
},
),
).rejects.toBeInstanceOf(DatabaseException);
});
});
describe('healthCheck', () => {
it('should throw a DatabaseException for client error', async () => {
await expect(fakeRepository.healthCheck()).rejects.toBeInstanceOf(

4
src/modules/health/adapters/primaries/health-server.controller.ts
View File

@ -19,7 +19,7 @@ interface HealthCheckResponse {
@Controller()
export class HealthServerController {
constructor(
private readonly _prismaHealthIndicatorUseCase: PrismaHealthIndicatorUseCase,
private readonly prismaHealthIndicatorUseCase: PrismaHealthIndicatorUseCase,
) {}
@GrpcMethod('Health', 'Check')
@ -29,7 +29,7 @@ export class HealthServerController {
// eslint-disable-next-line @typescript-eslint/no-unused-vars
metadata: any,
): Promise<HealthCheckResponse> {
const healthCheck = await this._prismaHealthIndicatorUseCase.isHealthy(
const healthCheck = await this.prismaHealthIndicatorUseCase.isHealthy(
'prisma',
);
return {

12
src/modules/health/adapters/primaries/health.controller.ts
View File

@ -10,21 +10,21 @@ import { PrismaHealthIndicatorUseCase } from '../../domain/usecases/prisma.healt
@Controller('health')
export class HealthController {
constructor(
private readonly _prismaHealthIndicatorUseCase: PrismaHealthIndicatorUseCase,
private _healthCheckService: HealthCheckService,
private _messager: Messager,
private readonly prismaHealthIndicatorUseCase: PrismaHealthIndicatorUseCase,
private readonly healthCheckService: HealthCheckService,
private readonly messager: Messager,
) {}
@Get()
@HealthCheck()
async check() {
try {
return await this._healthCheckService.check([
async () => this._prismaHealthIndicatorUseCase.isHealthy('prisma'),
return await this.healthCheckService.check([
async () => this.prismaHealthIndicatorUseCase.isHealthy('prisma'),
]);
} catch (error) {
const healthCheckResult: HealthCheckResult = error.response;
this._messager.publish(
this.messager.publish(
'logging.configuration.health.crit',
JSON.stringify(healthCheckResult.error),
);

8
src/modules/health/adapters/secondaries/messager.ts
View File

@ -6,13 +6,13 @@ import { IMessageBroker } from './message-broker';
@Injectable()
export class Messager extends IMessageBroker {
constructor(
private readonly _amqpConnection: AmqpConnection,
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);
}
publish = (routingKey: string, message: string): void => {
this.amqpConnection.publish(this.exchange, routingKey, message);
};
}

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

@ -8,18 +8,18 @@ import { ConfigurationRepository } from '../../../configuration/adapters/seconda
@Injectable()
export class PrismaHealthIndicatorUseCase extends HealthIndicator {
constructor(private readonly _repository: ConfigurationRepository) {
constructor(private readonly repository: ConfigurationRepository) {
super();
}
async isHealthy(key: string): Promise<HealthIndicatorResult> {
isHealthy = async (key: string): Promise<HealthIndicatorResult> => {
try {
await this._repository.healthCheck();
await this.repository.healthCheck();
return this.getStatus(key, true);
} catch (e) {
throw new HealthCheckError('Prisma', {
prisma: e.message,
});
}
}
};
}

2
src/modules/health/health.module.ts
View File

@ -2,7 +2,7 @@ import { Module } from '@nestjs/common';
import { HealthServerController } from './adapters/primaries/health-server.controller';
import { PrismaHealthIndicatorUseCase } from './domain/usecases/prisma.health-indicator.usecase';
import { ConfigurationRepository } from '../configuration/adapters/secondaries/configuration.repository';
import { DatabaseModule } from '../database/database.module';
import { DatabaseModule } from '../databasec/database.module';
import { HealthController } from './adapters/primaries/health.controller';
import { TerminusModule } from '@nestjs/terminus';
import { RabbitMQModule } from '@golevelup/nestjs-rabbitmq';