@koalarx/nest 0.0.8 → 0.1.0

package/common/backgroud-services/event-service/event-queue.js

@@ -5,7 +5,7 @@ class EventQueue {
     static handlersMap = {};
     static markedAggregates = [];
     static markAggregateForDispatch(aggregate) {
-        const aggregateFound = !!this.findMarkedAggregateByID(aggregate.id);
+        const aggregateFound = !!this.findMarkedAggregateByID(aggregate._id);
         if (!aggregateFound) {
             this.markedAggregates.push(aggregate);
         }
@@ -39,7 +39,7 @@ class EventQueue {
         this.markedAggregates.splice(index, 1);
     }
     static findMarkedAggregateByID(id) {
-        return this.markedAggregates.find((aggregate) => aggregate.id === id);
+        return this.markedAggregates.find((aggregate) => aggregate._id === id);
     }
     static dispatch(event) {
         const eventClassName = event.constructor.name;

package/common/controllers/created-registre-response.base.js

@@ -5,6 +5,9 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CreatedRegistreResponseBase = void 0;
 const swagger_1 = require("@nestjs/swagger");
@@ -13,5 +16,6 @@ class CreatedRegistreResponseBase {
 }
 exports.CreatedRegistreResponseBase = CreatedRegistreResponseBase;
 __decorate([
-    (0, swagger_1.ApiProperty)()
+    (0, swagger_1.ApiProperty)({ type: 'string' }),
+    __metadata("design:type", Object)
 ], CreatedRegistreResponseBase.prototype, "id", void 0);

package/common/controllers/list-response.base.js

@@ -5,6 +5,9 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ListResponseBase = void 0;
 const swagger_1 = require("@nestjs/swagger");
@@ -13,5 +16,6 @@ class ListResponseBase {
 }
 exports.ListResponseBase = ListResponseBase;
 __decorate([
-    (0, swagger_1.ApiProperty)()
+    (0, swagger_1.ApiProperty)(),
+    __metadata("design:type", Number)
 ], ListResponseBase.prototype, "count", void 0);

package/common/mediator/request-validator.base.js

@@ -9,7 +9,7 @@ class RequestValidatorBase {
     validate() {
         const requestParsed = this.schema.safeParse(this._request);
         if (requestParsed.success) {
-            return requestParsed.data;
+            return Object.assign(this._request, requestParsed.data);
         }
         throw requestParsed.error;
     }

package/common/models/pagination-params.js

@@ -5,6 +5,9 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PaginationParams = exports.QueryFilterParams = void 0;
 const swagger_1 = require("@nestjs/swagger");
@@ -37,24 +40,28 @@ __decorate([
         required: false,
         format: 'int32',
         default: exports.QueryFilterParams.page,
-    })
+    }),
+    __metadata("design:type", Number)
 ], PaginationParams.prototype, "page", void 0);
 __decorate([
     (0, swagger_1.ApiProperty)({
         required: false,
         format: 'int32',
         default: exports.QueryFilterParams.limit,
-    })
+    }),
+    __metadata("design:type", Number)
 ], PaginationParams.prototype, "limit", void 0);
 __decorate([
     (0, swagger_1.ApiProperty)({
         required: false,
-    })
+    }),
+    __metadata("design:type", String)
 ], PaginationParams.prototype, "orderBy", void 0);
 __decorate([
     (0, swagger_1.ApiProperty)({
         required: false,
         enum: ['asc', 'desc'],
         default: exports.QueryFilterParams.direction,
-    })
+    }),
+    __metadata("design:type", String)
 ], PaginationParams.prototype, "direction", void 0);

package/core/database/entity.d.ts

@@ -1,8 +1,8 @@
 import { Optional } from '../@types';
 import { IComparable, IComparableId } from '../utils/interfaces/icomparable';
-export type EntityProps<T extends IComparable<T>> = Omit<Optional<T, 'id'>, 'equals'>;
+export type EntityProps<T extends IComparable<T>> = Omit<Optional<T, '_id'>, 'equals'>;
 export declare abstract class Entity<T extends IComparable<T>> implements IComparable<T> {
-    id: IComparableId;
-    protected create(props: EntityProps<T>): void;
+    _id: IComparableId;
+    protected automap(props: EntityProps<T>): void;
     equals(obj: Entity<T>): boolean;
 }

package/core/database/entity.js

@@ -1,31 +1,28 @@
 "use strict";
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Entity = void 0;
-const automapper_classes_1 = require("automapper-classes");
 const list_1 = require("../utils/list");
 class Entity {
-    id;
-    create(props) {
-        Object.keys(props).forEach((key) => {
+    _id;
+    automap(props) {
+        Object.keys(props ?? {}).forEach((key) => {
             if (Array.isArray(props[key]) && this[key] instanceof list_1.List) {
-                this[key] = new list_1.List(props[key]);
+                let value = props[key];
+                if (this[key].entityType) {
+                    value = value.map((item) => new this[key].entityType(item));
+                }
+                this[key].setList(value);
             }
             else {
+                if (key === 'id') {
+                    this._id = props[key];
+                }
                 this[key] = props[key];
             }
         });
     }
     equals(obj) {
-        return obj.id === this.id;
+        return obj._id === this._id;
     }
 }
 exports.Entity = Entity;
-__decorate([
-    (0, automapper_classes_1.AutoMap)()
-], Entity.prototype, "id", void 0);

package/core/database/repository.base.d.ts

@@ -1,17 +1,38 @@
+import { Type } from '@nestjs/common';
 import { PaginationParams } from '../../common/models/pagination-params';
-import { PrismaClientWithCustomTransaction } from '../../services/prisma/prisma-client-with-custom-transaction.interface';
 import { PrismaTransactionalClient } from '../../services/prisma/prisma-transactional-client';
-import { ModelName } from '../../services/prisma/prisma.types';
+import { ListResponse } from '../@types';
+import { IComparableId } from '../utils/interfaces/icomparable';
 import { Entity } from './entity';
 export interface FindAllProps<TPaginateAndOrdering extends PaginationParams, TWhere, TInclude = any> {
     where: TWhere;
     paginateAndOrderingProps?: TPaginateAndOrdering;
     include?: TInclude;
 }
+type RepositoryInclude<TEntity> = {
+    [key in keyof TEntity]?: boolean | RepositoryInclude<TEntity[keyof TEntity]>;
+};
+interface RepositoryInitProps<TEntity> {
+    context: PrismaTransactionalClient;
+    modelName: Type<TEntity>;
+    transactionContext?: Type<PrismaTransactionalClient>;
+    include?: RepositoryInclude<TEntity>;
+}
 export declare abstract class RepositoryBase<TEntity extends Entity<TEntity>> {
-    protected prisma: PrismaClientWithCustomTransaction;
+    protected _context: PrismaTransactionalClient;
+    private _transactionContext?;
     private readonly _modelName;
-    constructor(prisma: PrismaClientWithCustomTransaction, _modelName: ModelName);
+    private readonly _include?;
+    constructor({ context, transactionContext, modelName, include, }: RepositoryInitProps<TEntity>);
     withTransaction(fn: (prisma: PrismaTransactionalClient) => Promise<any>): Promise<any>;
-    protected repository(transactionalClient?: PrismaTransactionalClient): import(".prisma/client").Prisma.TestDelegate<import("@prisma/client/runtime/library").DefaultArgs>;
+    protected findById(id: IComparableId): Promise<TEntity | null>;
+    protected findMany<T>(where: T, pagination?: PaginationParams): Promise<any>;
+    protected findManyAndCount<T>(where: T, pagination?: PaginationParams): Promise<ListResponse<TEntity>>;
+    protected saveChanges(entity: TEntity): any;
+    protected delete(id: IComparableId): any;
+    private listToRelationActionList;
+    private entityToPrisma;
+    private context;
+    private findManySchema;
 }
+export {};

package/core/database/repository.base.js

@@ -1,27 +1,152 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RepositoryBase = void 0;
-const prisma_transactional_client_1 = require("../../services/prisma/prisma-transactional-client");
-const prisma_types_1 = require("../../services/prisma/prisma.types");
+const string_1 = require("@koalarx/utils/operators/string");
+const pagination_params_1 = require("../../common/models/pagination-params");
+const list_1 = require("../utils/list");
+const entity_1 = require("./entity");
 class RepositoryBase {
-    prisma;
+    _context;
+    _transactionContext;
     _modelName;
-    constructor(prisma, _modelName) {
-        this.prisma = prisma;
-        this._modelName = _modelName;
+    _include;
+    constructor({ context, transactionContext, modelName, include, }) {
+        this._context = context;
+        this._transactionContext = transactionContext;
+        this._modelName = modelName;
+        this._include = include;
     }
     withTransaction(fn) {
-        return this.prisma.withTransaction(async (client) => {
-            return fn(new prisma_transactional_client_1.PrismaTransactionalClient(client));
+        return this._context.withTransaction(async (client) => {
+            return fn(new this._transactionContext(client));
         });
     }
-    repository(transactionalClient) {
-        const modelName = this._modelName;
-        const prisma = (transactionalClient ?? this.prisma);
-        const repository = (0, prisma_types_1.getPrismaDelegate)(modelName, prisma);
-        if (!repository)
-            throw new Error('Entidade não mapeada no repositório do prisma');
-        return repository;
+    async findById(id) {
+        return this.context()
+            .findFirst({
+            include: this._include,
+            where: { id },
+        })
+            .then((response) => {
+            if (response) {
+                return new this._modelName(response);
+            }
+            return null;
+        });
+    }
+    async findMany(where, pagination) {
+        return this.context()
+            .findMany(this.findManySchema(where, pagination))
+            .then((result) => {
+            return result.map((response) => {
+                return new this._modelName(response);
+            });
+        });
+    }
+    async findManyAndCount(where, pagination) {
+        const count = await this.context().count({ where });
+        if (count > 0) {
+            const items = await this.findMany(where, Object.assign(new pagination_params_1.PaginationParams(), pagination));
+            return { items, count };
+        }
+        return { items: [], count };
+    }
+    saveChanges(entity) {
+        const prismaEntity = this.entityToPrisma(entity);
+        const isCreate = !entity._id;
+        if (isCreate) {
+            return this.context().create({
+                data: prismaEntity,
+            });
+        }
+        else {
+            return this.withTransaction((client) => this.context(client)
+                .update({
+                where: { id: entity._id },
+                data: prismaEntity,
+            })
+                .then(() => {
+                const { relationUpdates, relationDeletes } = this.listToRelationActionList(entity);
+                return Promise.all([
+                    ...relationUpdates.map((relation) => client[relation.modelName].updateMany(relation.schema)),
+                    ...relationDeletes.map((relation) => client[relation.modelName].deleteMany(relation.schema)),
+                ]);
+            }));
+        }
+    }
+    delete(id) {
+        return this.context().delete({
+            where: { id },
+        });
+    }
+    listToRelationActionList(entity) {
+        const relationUpdates = [];
+        const relationDeletes = [];
+        Object.keys(entity).forEach((key) => {
+            if (entity[key] instanceof list_1.List) {
+                const list = entity[key];
+                const modelName = list.entityType?.name;
+                if (modelName) {
+                    list.toArray('removed').forEach((item) => {
+                        relationDeletes.push({
+                            modelName: (0, string_1.toCamelCase)(modelName),
+                            schema: { where: { id: item._id } },
+                        });
+                    });
+                    list.toArray('updated').forEach((item) => {
+                        relationUpdates.push({
+                            modelName: (0, string_1.toCamelCase)(modelName),
+                            schema: {
+                                where: { id: item._id },
+                                data: this.entityToPrisma(item),
+                            },
+                        });
+                    });
+                }
+            }
+        });
+        return { relationUpdates, relationDeletes };
+    }
+    entityToPrisma(entity) {
+        const prismaSchema = {};
+        Object.keys(entity)
+            .filter((key) => key !== 'id' && key !== '_id')
+            .forEach((key) => {
+            if (entity[key] instanceof list_1.List) {
+                prismaSchema[key] = {
+                    createMany: {
+                        data: entity[key].toArray('added').map((item) => {
+                            return this.entityToPrisma(item);
+                        }),
+                    },
+                };
+            }
+            else if (entity[key] instanceof entity_1.Entity) {
+                prismaSchema[key] = this.entityToPrisma(entity[key]);
+            }
+            else {
+                prismaSchema[key] = entity[key];
+            }
+        });
+        return prismaSchema;
+    }
+    context(transactionalClient) {
+        const modelName = this._modelName?.name;
+        if (!modelName)
+            throw new Error('modelName não informado no contrutor do repositorio');
+        if (transactionalClient) {
+            return transactionalClient[(0, string_1.toCamelCase)(modelName)];
+        }
+        return this._context[modelName];
+    }
+    findManySchema(where, pagination) {
+        return {
+            include: this._include,
+            where,
+            orderBy: pagination?.generateOrderBy(),
+            skip: pagination?.skip(),
+            take: (pagination?.limit ?? 0) > 0 ? pagination?.limit : undefined,
+        };
     }
 }
 exports.RepositoryBase = RepositoryBase;

package/core/koala-nest-database.module.d.ts

@@ -6,9 +6,9 @@ export interface KoalaNestDatabaseRepositoryConfig {
     class: Type<RepositoryBase<any>>;
 }
 interface KoalaNestDatabaseModuleConfig {
-    repositories?: KoalaNestDatabaseRepositoryConfig[];
+    repositories: KoalaNestDatabaseRepositoryConfig[];
 }
 export declare class KoalaNestDatabaseModule {
-    static forRoot(config: KoalaNestDatabaseModuleConfig): DynamicModule;
+    static register(config: KoalaNestDatabaseModuleConfig): DynamicModule;
 }
 export {};

package/core/koala-nest-database.module.js

@@ -13,26 +13,26 @@ const env_service_1 = require("../services/env/env.service");
 const prisma_service_1 = require("../services/prisma/prisma.service");
 exports.PRISMA_TOKEN = 'PRISMA_SERVICE_TOKEN';
 let KoalaNestDatabaseModule = exports.KoalaNestDatabaseModule = KoalaNestDatabaseModule_1 = class KoalaNestDatabaseModule {
-    static forRoot(config) {
+    static register(config) {
+        const repositoriesToExport = config.repositories?.map((repository) => repository.interface) ?? [];
+        const repositoriesToProvide = config.repositories?.map((repository) => ({
+            provide: repository.interface,
+            useClass: repository.class,
+        })) ?? [];
         return {
             module: KoalaNestDatabaseModule_1,
-            providers: config.repositories?.map((repository) => ({
-                provide: repository.interface,
-                useClass: repository.class,
-            })),
-            exports: config.repositories?.map((repository) => repository.interface),
+            providers: [
+                {
+                    provide: exports.PRISMA_TOKEN,
+                    useClass: prisma_service_1.PrismaService,
+                },
+                ...repositoriesToProvide,
+                env_service_1.EnvService,
+            ],
+            exports: [exports.PRISMA_TOKEN, ...repositoriesToExport],
         };
     }
 };
 exports.KoalaNestDatabaseModule = KoalaNestDatabaseModule = KoalaNestDatabaseModule_1 = __decorate([
-    (0, common_1.Module)({
-        providers: [
-            {
-                provide: exports.PRISMA_TOKEN,
-                useClass: prisma_service_1.PrismaService,
-            },
-            env_service_1.EnvService,
-        ],
-        exports: [exports.PRISMA_TOKEN],
-    })
+    (0, common_1.Module)({})
 ], KoalaNestDatabaseModule);

package/core/koala-nest-http.module.d.ts

@@ -2,11 +2,11 @@ import { DynamicModule, MiddlewareConsumer, NestMiddleware, NestModule, Provider
 import { AutomapperProfile } from 'automapper-nestjs';
 interface KoalaNestHttpModuleConfig {
     automapperProfile: Provider<AutomapperProfile>;
-    middlewares: Type<NestMiddleware>[];
+    middlewares?: Type<NestMiddleware>[];
 }
 export declare class KoalaNestHttpModule implements NestModule {
     private static _config;
-    static forRoot(config: KoalaNestHttpModuleConfig): DynamicModule;
+    static register(config: KoalaNestHttpModuleConfig): DynamicModule;
     configure(consumer: MiddlewareConsumer): void;
 }
 export {};

package/core/koala-nest-http.module.js

@@ -15,24 +15,22 @@ const env_service_1 = require("../services/env/env.service");
 let KoalaNestHttpModule = exports.KoalaNestHttpModule = class KoalaNestHttpModule {
     static { KoalaNestHttpModule_1 = this; }
     static _config;
-    static forRoot(config) {
+    static register(config) {
         this._config = config;
         return {
             module: KoalaNestHttpModule_1,
-            providers: [config.automapperProfile],
+            imports: [
+                automapper_nestjs_1.AutomapperModule.forRoot({
+                    strategyInitializer: (0, automapper_classes_1.classes)(),
+                }),
+            ],
+            providers: [config.automapperProfile, env_service_1.EnvService],
         };
     }
     configure(consumer) {
-        KoalaNestHttpModule_1._config.middlewares.forEach((middleware) => consumer.apply(middleware).forRoutes('*'));
+        KoalaNestHttpModule_1._config.middlewares?.forEach((middleware) => consumer.apply(middleware).forRoutes('*'));
     }
 };
 exports.KoalaNestHttpModule = KoalaNestHttpModule = KoalaNestHttpModule_1 = __decorate([
-    (0, common_1.Module)({
-        imports: [
-            automapper_nestjs_1.AutomapperModule.forRoot({
-                strategyInitializer: (0, automapper_classes_1.classes)(),
-            }),
-        ],
-        providers: [env_service_1.EnvService],
-    })
+    (0, common_1.Module)({})
 ], KoalaNestHttpModule);

package/core/koala-nest.module.d.ts

@@ -1,13 +1,11 @@
 import { DynamicModule, Provider } from '@nestjs/common';
 import { ZodType } from 'zod';
 import { ILoggingService } from '../services/logging/ilogging.service';
-import { KoalaNestDatabaseRepositoryConfig } from './koala-nest-database.module';
 interface KoalaNestModuleConfig {
     logging?: Provider<ILoggingService>;
     env?: ZodType;
-    repositories?: KoalaNestDatabaseRepositoryConfig[];
 }
 export declare class KoalaNestModule {
-    static forRoot({ env, logging, repositories, }: KoalaNestModuleConfig): DynamicModule;
+    static register(config?: KoalaNestModuleConfig): DynamicModule;
 }
 export {};

package/core/koala-nest.module.js

@@ -11,6 +11,7 @@ exports.KoalaNestModule = void 0;
 const common_1 = require("@nestjs/common");
 const config_1 = require("@nestjs/config");
 const env_1 = require("../services/env/env");
+const env_module_1 = require("../services/env/env.module");
 const env_service_1 = require("../services/env/env.service");
 const ilogging_service_1 = require("../services/logging/ilogging.service");
 const logging_service_1 = require("../services/logging/logging.service");
@@ -18,35 +19,29 @@ const iredis_service_1 = require("../services/redis/iredis.service");
 const redis_service_1 = require("../services/redis/redis.service");
 const ired_lock_service_1 = require("../services/redlock/ired-lock.service");
 const red_lock_service_1 = require("../services/redlock/red-lock.service");
-const koala_nest_database_module_1 = require("./koala-nest-database.module");
 let KoalaNestModule = exports.KoalaNestModule = KoalaNestModule_1 = class KoalaNestModule {
-    static forRoot({ env, logging, repositories, }) {
+    static register(config) {
         return {
             module: KoalaNestModule_1,
             imports: [
                 config_1.ConfigModule.forRoot({
-                    validate: (envData) => (env ?? env_1.envSchema).parse(envData),
+                    validate: (envData) => (config?.env ?? env_1.envSchema).parse(envData),
                     isGlobal: true,
                 }),
-                koala_nest_database_module_1.KoalaNestDatabaseModule.forRoot({
-                    repositories,
-                }),
+                env_module_1.EnvModule,
             ],
             providers: [
                 {
                     provide: ilogging_service_1.ILoggingService,
-                    useValue: logging ?? logging_service_1.LoggingService,
+                    useValue: config?.logging ?? logging_service_1.LoggingService,
                 },
+                { provide: iredis_service_1.IRedisService, useClass: redis_service_1.RedisService },
+                { provide: ired_lock_service_1.IRedLockService, useClass: red_lock_service_1.RedLockService },
+                env_service_1.EnvService,
             ],
         };
     }
 };
 exports.KoalaNestModule = KoalaNestModule = KoalaNestModule_1 = __decorate([
-    (0, common_1.Module)({
-        providers: [
-            { provide: iredis_service_1.IRedisService, useClass: redis_service_1.RedisService },
-            { provide: ired_lock_service_1.IRedLockService, useClass: red_lock_service_1.RedLockService },
-            env_service_1.EnvService,
-        ],
-    })
+    (0, common_1.Module)({})
 ], KoalaNestModule);

package/core/utils/interfaces/icomparable.d.ts

@@ -1,5 +1,5 @@
 export type IComparableId = string | number;
 export declare abstract class IComparable<T = any> {
-    abstract id: IComparableId;
+    abstract _id: IComparableId;
     abstract equals(obj: IComparable<T>): boolean;
 }

package/core/utils/list.d.ts

@@ -1,16 +1,24 @@
+import { Type } from '@nestjs/common';
 import { IComparableId } from './interfaces/icomparable';
 export type ListActionType = 'added' | 'updated' | 'removed';
+export interface ListProps<T> {
+    list?: T[];
+    entityType?: Type<T>;
+}
 export declare class List<T> {
+    readonly entityType?: Type<T> | undefined;
     private _list;
     private _addedItemsList;
     private _updatedItemsList;
     private _removedItemsList;
-    constructor(list?: T[]);
+    constructor(entityType?: Type<T> | undefined);
     get length(): number;
     findById(id: IComparableId): T | null;
     findByValue(value: any): T | null;
+    setList(list: T[]): void;
     add(item: T): void;
     remove(item: T): void;
+    update(items: T[]): void;
     clear(): void;
     forEach(callback: (item: T, index: number) => void): void;
     forEachAsync(callback: (item: T, index: number) => Promise<void>): Promise<void[]>;