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

clean using es6

This commit is contained in:
sbriat 2023-05-05 16:39:28 +02:00
parent 15e0e32e2e
commit 68d37ba2cc
31 changed files with 214 additions and 208 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
Dockerfile
View File

@ -12,8 +12,12 @@ WORKDIR /usr/src/app
# Copying this first prevents re-running npm install on every code change.
COPY --chown=node:node package*.json ./
# Copy prisma (needed for prisma error types)
COPY --chown=node:node ./prisma prisma
# Install app dependencies using the `npm ci` command instead of `npm install`
RUN npm ci
RUN npx prisma generate
# Bundle app source
COPY --chown=node:node . .

16
src/modules/configuration/adapters/primaries/configuration-messager.controller.ts
View File

@ -11,8 +11,8 @@ import { Configuration } from '../../domain/entities/configuration';
@Controller()
export class ConfigurationMessagerController {
constructor(
private readonly _commandBus: CommandBus,
private readonly _configService: ConfigService,
private readonly commandBus: CommandBus,
private readonly configService: ConfigService,
) {}
@RabbitSubscribe({
@ -22,14 +22,14 @@ export class ConfigurationMessagerController {
const configuration: Configuration = JSON.parse(message);
if (
configuration.domain ==
this._configService.get<string>('SERVICE_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(
await this.commandBus.execute(
new SetConfigurationCommand(setConfigurationRequest),
);
}
@ -42,12 +42,12 @@ export class ConfigurationMessagerController {
const deletedConfiguration: Configuration = JSON.parse(message);
if (
deletedConfiguration.domain ==
this._configService.get<string>('SERVICE_CONFIGURATION_DOMAIN')
this.configService.get<string>('SERVICE_CONFIGURATION_DOMAIN')
) {
const deleteConfigurationRequest = new DeleteConfigurationRequest();
deleteConfigurationRequest.domain = deletedConfiguration.domain;
deleteConfigurationRequest.key = deletedConfiguration.key;
await this._commandBus.execute(
await this.commandBus.execute(
new DeleteConfigurationCommand(deleteConfigurationRequest),
);
}
@ -61,14 +61,14 @@ export class ConfigurationMessagerController {
configurations.forEach(async (configuration) => {
if (
configuration.domain ==
this._configService.get<string>('SERVICE_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(
await this.commandBus.execute(
new SetConfigurationCommand(setConfigurationRequest),
);
}

8
src/modules/configuration/adapters/secondaries/redis-configuration.repository.ts
View File

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

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

@ -4,13 +4,15 @@ import { DeleteConfigurationCommand } from '../../commands/delete-configuration.
@CommandHandler(DeleteConfigurationCommand)
export class DeleteConfigurationUseCase {
constructor(private _configurationRepository: RedisConfigurationRepository) {}
constructor(private configurationRepository: RedisConfigurationRepository) {}
async execute(deleteConfigurationCommand: DeleteConfigurationCommand) {
await this._configurationRepository.del(
execute = async (
deleteConfigurationCommand: DeleteConfigurationCommand,
): Promise<void> => {
await this.configurationRepository.del(
deleteConfigurationCommand.deleteConfigurationRequest.domain +
':' +
deleteConfigurationCommand.deleteConfigurationRequest.key,
);
}
};
}

9
src/modules/configuration/domain/usecases/get-configuration.usecase.ts
View File

@ -4,11 +4,12 @@ import { GetConfigurationQuery } from '../../queries/get-configuration.query';
@QueryHandler(GetConfigurationQuery)
export class GetConfigurationUseCase {
constructor(private _configurationRepository: RedisConfigurationRepository) {}
constructor(private configurationRepository: RedisConfigurationRepository) {}
async execute(getConfigurationQuery: GetConfigurationQuery): Promise<string> {
return this._configurationRepository.get(
execute = async (
getConfigurationQuery: GetConfigurationQuery,
): Promise<string> =>
this.configurationRepository.get(
getConfigurationQuery.domain + ':' + getConfigurationQuery.key,
);
}
}

10
src/modules/configuration/domain/usecases/set-configuration.usecase.ts
View File

@ -4,14 +4,16 @@ import { SetConfigurationCommand } from '../../commands/set-configuration.comman
@CommandHandler(SetConfigurationCommand)
export class SetConfigurationUseCase {
constructor(private _configurationRepository: RedisConfigurationRepository) {}
constructor(private configurationRepository: RedisConfigurationRepository) {}
async execute(setConfigurationCommand: SetConfigurationCommand) {
await this._configurationRepository.set(
execute = async (
setConfigurationCommand: SetConfigurationCommand,
): Promise<void> => {
await this.configurationRepository.set(
setConfigurationCommand.setConfigurationRequest.domain +
':' +
setConfigurationCommand.setConfigurationRequest.key,
setConfigurationCommand.setConfigurationRequest.value,
);
}
};
}

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

@ -1,5 +1,5 @@
import { Injectable } from '@nestjs/common';
import { PrismaClientKnownRequestError } from '@prisma/client/runtime';
import { Prisma } from '@prisma/client';
import { DatabaseException } from '../../exceptions/database.exception';
import { ICollection } from '../../interfaces/collection.interface';
import { IRepository } from '../../interfaces/repository.interface';
@ -10,24 +10,24 @@ import { PrismaService } from './prisma-service';
*/
@Injectable()
export abstract class PrismaRepository<T> implements IRepository<T> {
protected _model: string;
protected model: string;
constructor(protected readonly _prisma: PrismaService) {}
constructor(protected readonly prisma: PrismaService) {}
async findAll(
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({
): 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({
this.prisma[this.model].count({
where,
}),
]);
@ -35,19 +35,19 @@ export abstract class PrismaRepository<T> implements IRepository<T> {
data,
total,
});
}
};
async findOneByUuid(uuid: string): Promise<T> {
findOneByUuid = async (uuid: string): Promise<T> => {
try {
const entity = await this._prisma[this._model].findUnique({
const entity = await this.prisma[this.model].findUnique({
where: { uuid },
});
return entity;
} catch (e) {
if (e instanceof PrismaClientKnownRequestError) {
if (e instanceof Prisma.PrismaClientKnownRequestError) {
throw new DatabaseException(
PrismaClientKnownRequestError.name,
Prisma.PrismaClientKnownRequestError.name,
e.code,
e.message,
);
@ -55,39 +55,42 @@ export abstract class PrismaRepository<T> implements IRepository<T> {
throw new DatabaseException();
}
}
}
};
async findOne(where: any, include?: any): Promise<T> {
findOne = async (where: any, include?: any): Promise<T> => {
try {
const entity = await this._prisma[this._model].findFirst({
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);
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 ?
async create(entity: Partial<T> | any, include?: any): Promise<T> {
create = async (entity: Partial<T> | any, include?: any): Promise<T> => {
try {
const res = await this._prisma[this._model].create({
const res = await this.prisma[this.model].create({
data: entity,
include: include,
});
return res;
} catch (e) {
if (e instanceof PrismaClientKnownRequestError) {
if (e instanceof Prisma.PrismaClientKnownRequestError) {
throw new DatabaseException(
PrismaClientKnownRequestError.name,
Prisma.PrismaClientKnownRequestError.name,
e.code,
e.message,
);
@ -95,19 +98,19 @@ export abstract class PrismaRepository<T> implements IRepository<T> {
throw new DatabaseException();
}
}
}
};
async update(uuid: string, entity: Partial<T>): Promise<T> {
update = async (uuid: string, entity: Partial<T>): Promise<T> => {
try {
const updatedEntity = await this._prisma[this._model].update({
const updatedEntity = await this.prisma[this.model].update({
where: { uuid },
data: entity,
});
return updatedEntity;
} catch (e) {
if (e instanceof PrismaClientKnownRequestError) {
if (e instanceof Prisma.PrismaClientKnownRequestError) {
throw new DatabaseException(
PrismaClientKnownRequestError.name,
Prisma.PrismaClientKnownRequestError.name,
e.code,
e.message,
);
@ -115,15 +118,15 @@ export abstract class PrismaRepository<T> implements IRepository<T> {
throw new DatabaseException();
}
}
}
};
async updateWhere(
updateWhere = async (
where: any,
entity: Partial<T> | any,
include?: any,
): Promise<T> {
): Promise<T> => {
try {
const updatedEntity = await this._prisma[this._model].update({
const updatedEntity = await this.prisma[this.model].update({
where: where,
data: entity,
include: include,
@ -131,9 +134,9 @@ export abstract class PrismaRepository<T> implements IRepository<T> {
return updatedEntity;
} catch (e) {
if (e instanceof PrismaClientKnownRequestError) {
if (e instanceof Prisma.PrismaClientKnownRequestError) {
throw new DatabaseException(
PrismaClientKnownRequestError.name,
Prisma.PrismaClientKnownRequestError.name,
e.code,
e.message,
);
@ -141,19 +144,19 @@ export abstract class PrismaRepository<T> implements IRepository<T> {
throw new DatabaseException();
}
}
}
};
async delete(uuid: string): Promise<T> {
delete = async (uuid: string): Promise<T> => {
try {
const entity = await this._prisma[this._model].delete({
const entity = await this.prisma[this.model].delete({
where: { uuid },
});
return entity;
} catch (e) {
if (e instanceof PrismaClientKnownRequestError) {
if (e instanceof Prisma.PrismaClientKnownRequestError) {
throw new DatabaseException(
PrismaClientKnownRequestError.name,
Prisma.PrismaClientKnownRequestError.name,
e.code,
e.message,
);
@ -161,19 +164,19 @@ export abstract class PrismaRepository<T> implements IRepository<T> {
throw new DatabaseException();
}
}
}
};
async deleteMany(where: any): Promise<void> {
deleteMany = async (where: any): Promise<void> => {
try {
const entity = await this._prisma[this._model].deleteMany({
const entity = await this.prisma[this.model].deleteMany({
where: where,
});
return entity;
} catch (e) {
if (e instanceof PrismaClientKnownRequestError) {
if (e instanceof Prisma.PrismaClientKnownRequestError) {
throw new DatabaseException(
PrismaClientKnownRequestError.name,
Prisma.PrismaClientKnownRequestError.name,
e.code,
e.message,
);
@ -181,32 +184,32 @@ export abstract class PrismaRepository<T> implements IRepository<T> {
throw new DatabaseException();
}
}
}
};
async findAllByQuery(
include: Array<string>,
where: Array<string>,
): Promise<ICollection<T>> {
findAllByQuery = async (
include: string[],
where: string[],
): Promise<ICollection<T>> => {
const query = `SELECT ${include.join(',')} FROM ${
this._model
this.model
} WHERE ${where.join(' AND ')}`;
const data: Array<T> = await this._prisma.$queryRawUnsafe(query);
const data: T[] = await this.prisma.$queryRawUnsafe(query);
return Promise.resolve({
data,
total: data.length,
});
}
};
async createWithFields(fields: object): Promise<number> {
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);
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 PrismaClientKnownRequestError) {
if (e instanceof Prisma.PrismaClientKnownRequestError) {
throw new DatabaseException(
PrismaClientKnownRequestError.name,
Prisma.PrismaClientKnownRequestError.name,
e.code,
e.message,
);
@ -214,20 +217,20 @@ export abstract class PrismaRepository<T> implements IRepository<T> {
throw new DatabaseException();
}
}
}
};
async updateWithFields(uuid: string, entity: Partial<T>): Promise<number> {
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(
const command = `UPDATE ${this.model} SET ${values.join(
', ',
)} WHERE uuid = '${uuid}'`;
return await this._prisma.$executeRawUnsafe(command);
return await this.prisma.$executeRawUnsafe(command);
} catch (e) {
if (e instanceof PrismaClientKnownRequestError) {
if (e instanceof Prisma.PrismaClientKnownRequestError) {
throw new DatabaseException(
PrismaClientKnownRequestError.name,
Prisma.PrismaClientKnownRequestError.name,
e.code,
e.message,
);
@ -235,16 +238,16 @@ export abstract class PrismaRepository<T> implements IRepository<T> {
throw new DatabaseException();
}
}
}
};
async healthCheck(): Promise<boolean> {
healthCheck = async (): Promise<boolean> => {
try {
await this._prisma.$queryRaw`SELECT 1`;
await this.prisma.$queryRaw`SELECT 1`;
return true;
} catch (e) {
if (e instanceof PrismaClientKnownRequestError) {
if (e instanceof Prisma.PrismaClientKnownRequestError) {
throw new DatabaseException(
PrismaClientKnownRequestError.name,
Prisma.PrismaClientKnownRequestError.name,
e.code,
e.message,
);
@ -252,5 +255,5 @@ export abstract class PrismaRepository<T> implements IRepository<T> {
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 { TerritoryRepository } from './src/domain/territory-repository';
import { PrismaService } from './adapters/secondaries/prisma-service';
import { TerritoryRepository } from './domain/territory-repository';
@Module({
providers: [PrismaService, TerritoryRepository],

0
src/modules/database/src/domain/point.type.ts → src/modules/database/domain/point.type.ts
View File

19
src/modules/database/src/domain/territory-repository.ts → src/modules/database/domain/territory-repository.ts
View File

@ -6,16 +6,15 @@ import { Territory } from 'src/modules/territory/domain/entities/territory';
import { DatabaseException } from '../exceptions/database.exception';
export class TerritoryRepository<T> extends PrismaRepository<T> {
async findForPoint(point: Point): Promise<ICollection<T>> {
return await this.findAllByQuery(
findForPoint = async (point: Point): Promise<ICollection<T>> =>
await this.findAllByQuery(
['uuid', 'name'],
[
`ST_Intersects(ST_GeomFromText('POINT(${point.lon} ${point.lat})',4326),shape) = true`,
],
);
}
async findForPoints(points: Point[]): Promise<ICollection<T>> {
findForPoints = async (points: Point[]): Promise<ICollection<T>> => {
const multipoint = points
.map((point) => '(' + point.lon + ' ' + point.lat + ')')
.join(', ');
@ -25,9 +24,9 @@ export class TerritoryRepository<T> extends PrismaRepository<T> {
`ST_Intersects(ST_GeomFromText('MULTIPOINT(${multipoint})',4326),shape) = true`,
],
);
}
};
async createTerritory(territory: Partial<Territory>): Promise<T> {
createTerritory = async (territory: Partial<Territory>): Promise<T> => {
try {
const affectedRowNumber = await this.createWithFields({
uuid: `'${uuidv4()}'`,
@ -43,12 +42,12 @@ export class TerritoryRepository<T> extends PrismaRepository<T> {
} catch (e) {
throw e;
}
}
};
async updateTerritory(
updateTerritory = async (
uuid: string,
territory: Partial<Territory>,
): Promise<T> {
): Promise<T> => {
try {
const fields = {};
if (territory.name) fields['name'] = `'${territory.name}'`;
@ -66,5 +65,5 @@ export class TerritoryRepository<T> extends PrismaRepository<T> {
} catch (e) {
throw e;
}
}
};
}

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

32
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 {
@ -66,7 +66,7 @@ const mockPrismaService = {
.mockResolvedValueOnce(fakeEntityCreated)
// eslint-disable-next-line @typescript-eslint/no-unused-vars
.mockImplementationOnce((fields: object) => {
throw new PrismaClientKnownRequestError('unknown request', {
throw new Prisma.PrismaClientKnownRequestError('unknown request', {
code: 'code',
clientVersion: 'version',
});
@ -78,7 +78,7 @@ const mockPrismaService = {
.mockResolvedValueOnce(fakeEntityCreated)
// eslint-disable-next-line @typescript-eslint/no-unused-vars
.mockImplementationOnce((fields: object) => {
throw new PrismaClientKnownRequestError('unknown request', {
throw new Prisma.PrismaClientKnownRequestError('unknown request', {
code: 'code',
clientVersion: 'version',
});
@ -90,7 +90,7 @@ const mockPrismaService = {
$queryRaw: jest
.fn()
.mockImplementationOnce(() => {
throw new PrismaClientKnownRequestError('unknown request', {
throw new Prisma.PrismaClientKnownRequestError('unknown request', {
code: 'code',
clientVersion: 'version',
});
@ -99,7 +99,7 @@ const mockPrismaService = {
return true;
})
.mockImplementation(() => {
throw new PrismaClientKnownRequestError('Database unavailable', {
throw new Prisma.PrismaClientKnownRequestError('Database unavailable', {
code: 'code',
clientVersion: 'version',
});
@ -110,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',
});
@ -139,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',
});
@ -161,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',
});
@ -175,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',
});
@ -212,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',
});
@ -236,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',
});

8
src/modules/database/tests/unit/territory-repository.spec.ts
View File

@ -1,10 +1,10 @@
import { Injectable } from '@nestjs/common';
import { Test, TestingModule } from '@nestjs/testing';
import { PrismaService } from '../../src/adapters/secondaries/prisma-service';
import { TerritoryRepository } from '../../src/domain/territory-repository';
import { PrismaService } from '../../adapters/secondaries/prisma-service';
import { TerritoryRepository } from '../../domain/territory-repository';
import { Territory } from '../../../territory/domain/entities/territory';
import { Point } from '../../../territory/domain/entities/point';
import { DatabaseException } from '../../src/exceptions/database.exception';
import { DatabaseException } from '../../exceptions/database.exception';
const mockTerritories: Array<Territory> = [
{
@ -33,7 +33,7 @@ const territoryUpdated: Territory = {
@Injectable()
class TerritoriesRepository extends TerritoryRepository<Territory> {
protected _model = 'territory';
protected model = 'territory';
}
const mockPrismaService = {

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.territory.health.crit',
JSON.stringify(healthCheckResult.error),
);

10
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,
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);
};
}

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

@ -8,18 +8,18 @@ import { TerritoriesRepository } from '../../../territory/adapters/secondaries/t
@Injectable()
export class PrismaHealthIndicatorUseCase extends HealthIndicator {
constructor(private readonly _repository: TerritoriesRepository) {
constructor(private readonly repository: TerritoriesRepository) {
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,
});
}
}
};
}

4
src/modules/territory/adapters/primaries/territory.controller.ts
View File

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

10
src/modules/territory/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);
};
}

4
src/modules/territory/adapters/secondaries/territories.repository.ts
View File

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

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

@ -12,30 +12,30 @@ import { TerritoryPresenter } from '../../adapters/secondaries/territory.present
@CommandHandler(CreateTerritoryCommand)
export class CreateTerritoryUseCase {
constructor(
private readonly _repository: TerritoriesRepository,
private readonly _messager: Messager,
@InjectMapper() private readonly _mapper: Mapper,
private readonly repository: TerritoriesRepository,
private readonly messager: Messager,
@InjectMapper() private readonly mapper: Mapper,
) {}
async execute(command: CreateTerritoryCommand): Promise<Territory> {
const entity = this._mapper.map(
execute = async (command: CreateTerritoryCommand): Promise<Territory> => {
const entity = this.mapper.map(
command.createTerritoryRequest,
CreateTerritoryRequest,
Territory,
);
try {
const territory = await this._repository.createTerritory(entity);
this._messager.publish(
const territory = await this.repository.createTerritory(entity);
this.messager.publish(
'territory.create',
JSON.stringify(
this._mapper.map(territory, Territory, TerritoryPresenter),
this.mapper.map(territory, Territory, TerritoryPresenter),
),
);
this._messager.publish(
this.messager.publish(
'logging.territory.create.info',
JSON.stringify(
this._mapper.map(territory, Territory, TerritoryLoggingPresenter),
this.mapper.map(territory, Territory, TerritoryLoggingPresenter),
),
);
return territory;
@ -44,7 +44,7 @@ export class CreateTerritoryUseCase {
if (error.message.includes('already exists')) {
key = 'logging.territory.create.warning';
}
this._messager.publish(
this.messager.publish(
key,
JSON.stringify({
command,
@ -53,5 +53,5 @@ export class CreateTerritoryUseCase {
);
throw error;
}
}
};
}

4
src/modules/territory/domain/usecases/delete-territory.usecase.ts
View File

@ -11,7 +11,7 @@ export class DeleteTerritoryUseCase {
private readonly _messager: Messager,
) {}
async execute(command: DeleteTerritoryCommand): Promise<Territory> {
execute = async (command: DeleteTerritoryCommand): Promise<Territory> => {
try {
const territory = await this._repository.delete(command.uuid);
this._messager.publish(
@ -33,5 +33,5 @@ export class DeleteTerritoryUseCase {
);
throw error;
}
}
};
}

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

@ -1,5 +1,5 @@
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 { TerritoriesRepository } from '../../adapters/secondaries/territories.repository';
import { FindAllTerritoriesForPointQuery } from '../../queries/find-all-territories-for-point.query';
import { Territory } from '../entities/territory';
@ -7,16 +7,15 @@ import { Point } from '../entities/point';
@QueryHandler(FindAllTerritoriesForPointQuery)
export class FindAllTerritoriesForPointUseCase {
constructor(private readonly _repository: TerritoriesRepository) {}
constructor(private readonly repository: TerritoriesRepository) {}
async execute(
execute = async (
findAllTerritoriesForPointQuery: FindAllTerritoriesForPointQuery,
): Promise<ICollection<Territory>> {
return this._repository.findForPoint(
): Promise<ICollection<Territory>> =>
this.repository.findForPoint(
new Point(
findAllTerritoriesForPointQuery.point.lon,
findAllTerritoriesForPointQuery.point.lat,
),
);
}
}

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

@ -1,18 +1,15 @@
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 { TerritoriesRepository } from '../../adapters/secondaries/territories.repository';
import { FindAllTerritoriesForPointsQuery } from '../../queries/find-all-territories-for-points.query';
import { Territory } from '../entities/territory';
@QueryHandler(FindAllTerritoriesForPointsQuery)
export class FindAllTerritoriesForPointsUseCase {
constructor(private readonly _repository: TerritoriesRepository) {}
constructor(private readonly repository: TerritoriesRepository) {}
async execute(
execute = async (
findAllTerritoriesForPointsQuery: FindAllTerritoriesForPointsQuery,
): Promise<ICollection<Territory>> {
return this._repository.findForPoints(
findAllTerritoriesForPointsQuery.points,
);
}
): Promise<ICollection<Territory>> =>
this.repository.findForPoints(findAllTerritoriesForPointsQuery.points);
}

11
src/modules/territory/domain/usecases/find-all-territories.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 { TerritoriesRepository } from '../../adapters/secondaries/territories.repository';
import { FindAllTerritoriesQuery } from '../../queries/find-all-territories.query';
import { Territory } from '../entities/territory';
@QueryHandler(FindAllTerritoriesQuery)
export class FindAllTerritoriesUseCase {
constructor(private readonly _repository: TerritoriesRepository) {}
constructor(private readonly repository: TerritoriesRepository) {}
async execute(
execute = async (
findAllTerritoriesQuery: FindAllTerritoriesQuery,
): Promise<ICollection<Territory>> {
return this._repository.findAll(
): Promise<ICollection<Territory>> =>
this.repository.findAll(
findAllTerritoriesQuery.page,
findAllTerritoriesQuery.perPage,
);
}
}

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

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

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

@ -12,35 +12,35 @@ import { TerritoryPresenter } from '../../adapters/secondaries/territory.present
@CommandHandler(UpdateTerritoryCommand)
export class UpdateTerritoryUseCase {
constructor(
private readonly _repository: TerritoriesRepository,
private readonly _messager: Messager,
@InjectMapper() private readonly _mapper: Mapper,
private readonly repository: TerritoriesRepository,
private readonly messager: Messager,
@InjectMapper() private readonly mapper: Mapper,
) {}
async execute(command: UpdateTerritoryCommand): Promise<Territory> {
execute = async (command: UpdateTerritoryCommand): Promise<Territory> => {
try {
const territory = await this._repository.updateTerritory(
const territory = await this.repository.updateTerritory(
command.updateTerritoryRequest.uuid,
this._mapper.map(
this.mapper.map(
command.updateTerritoryRequest,
UpdateTerritoryRequest,
Territory,
),
);
this._messager.publish(
this.messager.publish(
'territory.update',
JSON.stringify(
this._mapper.map(
this.mapper.map(
command.updateTerritoryRequest,
UpdateTerritoryRequest,
TerritoryPresenter,
),
),
);
this._messager.publish(
this.messager.publish(
'logging.territory.update.info',
JSON.stringify(
this._mapper.map(
this.mapper.map(
command.updateTerritoryRequest,
UpdateTerritoryRequest,
TerritoryLoggingPresenter,
@ -49,7 +49,7 @@ export class UpdateTerritoryUseCase {
);
return territory;
} catch (error) {
this._messager.publish(
this.messager.publish(
'logging.territory.update.crit',
JSON.stringify({
command,
@ -58,5 +58,5 @@ export class UpdateTerritoryUseCase {
);
throw error;
}
}
};
}

4
src/modules/territory/tests/integration/territories.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 { TerritoriesRepository } from '../../adapters/secondaries/territories.repository';
import { v4 as uuidv4 } from 'uuid';
import { Territory } from '../../domain/entities/territory';