@koalarx/nest 0.1.0 → 1.0.0

package/core/backgroud-services/cron-service/cron-job.d.ts

@@ -0,0 +1,14 @@
+import { ILoggingService } from '../../../services/logging/ilogging.service';
+import { IRedLockService } from '../../../services/redlock/ired-lock.service';
+import { RequestResult } from '../../request-overflow/request-result';
+export type CronJobResponse = RequestResult<Error, null>;
+export declare abstract class CronJob {
+    private readonly redlockService;
+    private readonly loggingService;
+    private readonly _timeout;
+    constructor(redlockService: IRedLockService, loggingService: ILoggingService);
+    protected abstract run(): Promise<CronJobResponse>;
+    protected abstract isActive(): Promise<boolean>;
+    protected abstract defineTimeInMinutes(): number;
+    start(): Promise<void>;
+}

package/{common → core}/backgroud-services/cron-service/cron-job.js

@@ -2,27 +2,24 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CronJob = void 0;
 const delay_1 = require("@koalarx/utils/operators/delay");
+const koala_global_vars_1 = require("../../koala-global-vars");
 class CronJob {
     redlockService;
     loggingService;
-    loggedUsername;
-    appName;
-    timeout;
-    constructor(redlockService, loggingService, loggedUsername, appName, timeInMinutes) {
+    _timeout;
+    constructor(redlockService, loggingService) {
         this.redlockService = redlockService;
         this.loggingService = loggingService;
-        this.loggedUsername = loggedUsername;
-        this.appName = appName;
-        this.timeout = timeInMinutes * 60 * 1000;
+        this._timeout = this.defineTimeInMinutes() * 60 * 1000;
     }
-    async start(job) {
+    async start() {
         const name = this.constructor.name;
         while (true) {
             if (await this.isActive()) {
-                const ttlSecondsLock = this.timeout / 1000;
+                const ttlSecondsLock = this._timeout / 1000;
                 const acquiredLock = await this.redlockService.acquiredLock(name, ttlSecondsLock);
                 if (acquiredLock) {
-                    const error = await job()
+                    const error = await this.run()
                         .then((result) => {
                         if (result.isFailure()) {
                             return result.value;
@@ -31,15 +28,20 @@ class CronJob {
                     })
                         .catch((error) => error);
                     if (error) {
-                        this.loggingService.report({
-                            error,
-                            packageName: this.appName,
-                            loggedUsername: this.loggedUsername,
-                        });
+                        try {
+                            await this.loggingService.report({
+                                error,
+                                packageName: koala_global_vars_1.KoalaGlobalVars.appName,
+                                loggedUsername: koala_global_vars_1.KoalaGlobalVars.internalUserName,
+                            });
+                        }
+                        catch {
+                            console.error(error);
+                        }
                     }
                 }
             }
-            await (0, delay_1.klDelay)(this.timeout);
+            await (0, delay_1.klDelay)(this._timeout);
             await this.redlockService.releaseLock(name);
         }
     }

package/core/backgroud-services/cron-service/cron-job.spec.d.ts

@@ -0,0 +1,8 @@
+import { CronJob, CronJobResponse } from './cron-job';
+export declare class CronJobTest extends CronJob {
+    constructor();
+    static isCalled(): Promise<CronJobResponse>;
+    protected run(): Promise<CronJobResponse>;
+    protected isActive(): Promise<boolean>;
+    protected defineTimeInMinutes(): number;
+}

package/core/backgroud-services/cron-service/cron-job.spec.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CronJobTest = void 0;
+const delay_1 = require("@koalarx/utils/operators/delay");
+const vitest_1 = require("vitest");
+const fake_logging_service_1 = require("../../../test/services/fake-logging.service");
+const fake_red_lock_service_1 = require("../../../test/services/fake-red-lock.service");
+const request_result_1 = require("../../request-overflow/request-result");
+const cron_job_1 = require("./cron-job");
+class CronJobTest extends cron_job_1.CronJob {
+    constructor() {
+        super(new fake_red_lock_service_1.FakeRedLockService(), new fake_logging_service_1.FakeLoggingService());
+    }
+    static async isCalled() {
+        return (0, request_result_1.ok)(null);
+    }
+    run() {
+        return CronJobTest.isCalled();
+    }
+    async isActive() {
+        return true;
+    }
+    defineTimeInMinutes() {
+        return 0.01;
+    }
+}
+exports.CronJobTest = CronJobTest;
+test('cron job', async () => {
+    const callbackSpy = vitest_1.vi.spyOn(CronJobTest, 'isCalled');
+    new CronJobTest().start();
+    await (0, delay_1.klDelay)(100);
+    expect(callbackSpy).toHaveBeenCalled();
+});

package/core/backgroud-services/event-service/event-class.d.ts

@@ -0,0 +1,5 @@
+export declare abstract class EventClass<TEntity = any> {
+    data?: TEntity | undefined;
+    ocurredAt: Date;
+    constructor(data?: TEntity | undefined);
+}

package/{common → core}/backgroud-services/event-service/event-class.js

@@ -2,10 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EventClass = void 0;
 class EventClass {
-    eventJob;
+    data;
     ocurredAt = new Date();
-    constructor(eventJob) {
-        this.eventJob = eventJob;
+    constructor(data) {
+        this.data = data;
     }
 }
 exports.EventClass = EventClass;

package/core/backgroud-services/event-service/event-handler.d.ts

@@ -0,0 +1,5 @@
+import { EventClass } from './event-class';
+export declare abstract class EventHandler<TEvent extends EventClass<any>> {
+    setupSubscriptions(): void;
+    abstract handleEvent(event: TEvent): Promise<void>;
+}

package/core/backgroud-services/event-service/event-job.d.ts

@@ -0,0 +1,13 @@
+import { Type } from '@nestjs/common';
+import { EventClass } from './event-class';
+import { EventHandler } from './event-handler';
+import { EventQueue } from './event-queue';
+export declare abstract class EventJob<TEntity> {
+    _id: `${string}-${string}-${string}-${string}-${string}`;
+    private _eventQueue;
+    constructor();
+    abstract defineHandlers(): Array<Type<EventHandler<any>>>;
+    get eventQueue(): EventQueue[];
+    clearQueue(): void;
+    addEvent(event: EventClass<TEntity>): void;
+}

package/{common → core}/backgroud-services/event-service/event-job.js

@@ -1,10 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EventJob = void 0;
-const entity_1 = require("../../../core/database/entity");
 const event_queue_1 = require("./event-queue");
-class EventJob extends entity_1.Entity {
+const node_crypto_1 = require("node:crypto");
+class EventJob {
+    _id = (0, node_crypto_1.randomUUID)();
     _eventQueue = [];
+    constructor() { }
     get eventQueue() {
         return this._eventQueue;
     }

package/{common → core}/backgroud-services/event-service/event-queue.js

@@ -35,17 +35,20 @@ class EventQueue {
         aggregate.eventQueue.forEach((event) => this.dispatch(event));
     }
     static removeAggregateFromMarkedDispatchList(aggregate) {
-        const index = this.markedAggregates.findIndex((a) => a.equals(aggregate));
+        const index = this.markedAggregates.findIndex((a) => a._id === aggregate._id);
         this.markedAggregates.splice(index, 1);
     }
     static findMarkedAggregateByID(id) {
         return this.markedAggregates.find((aggregate) => aggregate._id === id);
     }
     static dispatch(event) {
-        const eventClassName = event.constructor.name;
-        const isEventRegistered = eventClassName in this.handlersMap;
+        const eventJobHandlers = this.markedAggregates.find((a) => a.eventQueue.find((e) => e === event));
+        const eventHandler = Object.keys(this.handlersMap).find((handlerName) => eventJobHandlers
+            ?.defineHandlers()
+            .find((handler) => handler.name === handlerName));
+        const isEventRegistered = !!eventHandler;
         if (isEventRegistered) {
-            const handlers = this.handlersMap[eventClassName];
+            const handlers = this.handlersMap[eventHandler];
             for (const handler of handlers) {
                 handler(event);
             }

package/core/backgroud-services/event-service/event-queue.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/core/backgroud-services/event-service/event-queue.spec.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const event_class_1 = require("./event-class");
+const event_handler_1 = require("./event-handler");
+const event_job_1 = require("./event-job");
+const event_queue_1 = require("./event-queue");
+class CustomEvent extends event_class_1.EventClass {
+}
+class CustomEventHandler extends event_handler_1.EventHandler {
+    static async isCalled() {
+        return null;
+    }
+    async handleEvent(event) {
+        await CustomEventHandler.isCalled();
+    }
+}
+class CustomEventJob extends event_job_1.EventJob {
+    defineHandlers() {
+        return [CustomEventHandler];
+    }
+}
+describe('event queue', () => {
+    it('should be able to dispatch and listen to events', () => {
+        const callbackSpy = vitest_1.vi.spyOn(CustomEventHandler, 'isCalled');
+        new CustomEventHandler().setupSubscriptions();
+        const jobs = new CustomEventJob();
+        jobs.addEvent(new CustomEvent());
+        expect(jobs.eventQueue).toHaveLength(1);
+        event_queue_1.EventQueue.dispatchEventsForAggregate(jobs._id);
+        expect(callbackSpy).toHaveBeenCalled();
+        expect(jobs.eventQueue).toHaveLength(0);
+    });
+});

package/core/controllers/created-registre-response.base.d.ts

@@ -0,0 +1,4 @@
+import { IComparableId } from '../../core/utils/interfaces/icomparable';
+export declare abstract class CreatedRegistreResponseBase<TId = IComparableId> {
+    id: TId;
+}

package/core/controllers/schemas/boolean.schema.d.ts

@@ -0,0 +1,2 @@
+import { z } from 'zod';
+export declare function booleanSchema(): z.ZodEffects<z.ZodString, boolean | undefined, string>;

package/core/controllers/schemas/boolean.schema.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.booleanSchema = void 0;
+const zod_1 = require("zod");
+function booleanSchema() {
+    return zod_1.z.coerce
+        .string()
+        .transform((value) => {
+        if (value !== undefined) {
+            return value === 'true';
+        }
+        return undefined;
+    });
+}
+exports.booleanSchema = booleanSchema;

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

@@ -0,0 +1,9 @@
+import { IComparable, IComparableId } from '../utils/interfaces/icomparable';
+export type EntityProps<T extends IComparable<T>> = Omit<{
+    [K in keyof T as T[K] extends Function ? never : K]: T[K];
+}, '_id'>;
+export declare abstract class EntityBase<T extends IComparable<T>> implements IComparable<T> {
+    _id: IComparableId;
+    automap(props?: EntityProps<T>): void;
+    equals(obj: EntityBase<T>): boolean;
+}

package/core/database/entity.base.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntityBase = void 0;
+const list_1 = require("../utils/list");
+class EntityBase {
+    _id;
+    automap(props) {
+        if (props) {
+            for (const key of Object.keys(props)) {
+                if (Array.isArray(props[key]) && this[key] instanceof list_1.List) {
+                    let value = props[key];
+                    if (this[key].entityType) {
+                        value = value.map((item) => {
+                            const entity = new this[key].entityType();
+                            entity.automap(item);
+                            return entity;
+                        });
+                    }
+                    this[key].setList(value);
+                }
+                else if (this[key] instanceof EntityBase) {
+                    const entity = new this[key].constructor();
+                    entity.automap(props[key]);
+                    this[key] = entity;
+                }
+                else {
+                    if (key === 'id') {
+                        this._id = props[key];
+                    }
+                    this[key] = props[key];
+                }
+            }
+        }
+    }
+    equals(obj) {
+        return obj._id === this._id;
+    }
+}
+exports.EntityBase = EntityBase;

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

@@ -1,14 +1,9 @@
 import { Type } from '@nestjs/common';
-import { PaginationParams } from '../../common/models/pagination-params';
-import { PrismaTransactionalClient } from '../../services/prisma/prisma-transactional-client';
 import { ListResponse } from '../@types';
+import { PaginationParams } from '../models/pagination-params';
 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;
-}
+import { EntityBase } from './entity.base';
+import { PrismaTransactionalClient } from './prisma-transactional-client';
 type RepositoryInclude<TEntity> = {
     [key in keyof TEntity]?: boolean | RepositoryInclude<TEntity[keyof TEntity]>;
 };
@@ -18,12 +13,11 @@ interface RepositoryInitProps<TEntity> {
     transactionContext?: Type<PrismaTransactionalClient>;
     include?: RepositoryInclude<TEntity>;
 }
-export declare abstract class RepositoryBase<TEntity extends Entity<TEntity>> {
+export declare abstract class RepositoryBase<TEntity extends EntityBase<TEntity>> {
     protected _context: PrismaTransactionalClient;
-    private _transactionContext?;
     private readonly _modelName;
     private readonly _include?;
-    constructor({ context, transactionContext, modelName, include, }: RepositoryInitProps<TEntity>);
+    constructor({ context, modelName, include, }: RepositoryInitProps<TEntity>);
     withTransaction(fn: (prisma: PrismaTransactionalClient) => Promise<any>): Promise<any>;
     protected findById(id: IComparableId): Promise<TEntity | null>;
     protected findMany<T>(where: T, pagination?: PaginationParams): Promise<any>;
@@ -34,5 +28,6 @@ export declare abstract class RepositoryBase<TEntity extends Entity<TEntity>> {
     private entityToPrisma;
     private context;
     private findManySchema;
+    private createEntity;
 }
 export {};

package/core/database/repository.base.js

@@ -2,23 +2,22 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RepositoryBase = void 0;
 const string_1 = require("@koalarx/utils/operators/string");
-const pagination_params_1 = require("../../common/models/pagination-params");
+const koala_global_vars_1 = require("../koala-global-vars");
+const pagination_params_1 = require("../models/pagination-params");
 const list_1 = require("../utils/list");
-const entity_1 = require("./entity");
+const entity_base_1 = require("./entity.base");
 class RepositoryBase {
     _context;
-    _transactionContext;
     _modelName;
     _include;
-    constructor({ context, transactionContext, modelName, include, }) {
+    constructor({ context, modelName, include, }) {
         this._context = context;
-        this._transactionContext = transactionContext;
         this._modelName = modelName;
         this._include = include;
     }
     withTransaction(fn) {
         return this._context.withTransaction(async (client) => {
-            return fn(new this._transactionContext(client));
+            return fn(new koala_global_vars_1.KoalaGlobalVars.dbTransactionContext(client));
         });
     }
     async findById(id) {
@@ -29,7 +28,7 @@ class RepositoryBase {
         })
             .then((response) => {
             if (response) {
-                return new this._modelName(response);
+                return this.createEntity(response);
             }
             return null;
         });
@@ -37,11 +36,7 @@ class RepositoryBase {
     async findMany(where, pagination) {
         return this.context()
             .findMany(this.findManySchema(where, pagination))
-            .then((result) => {
-            return result.map((response) => {
-                return new this._modelName(response);
-            });
-        });
+            .then((result) => result.map((response) => this.createEntity(response)));
     }
     async findManyAndCount(where, pagination) {
         const count = await this.context().count({ where });
@@ -113,15 +108,17 @@ class RepositoryBase {
             .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);
-                        }),
-                    },
-                };
+                if (entity[key].toArray('added').length > 0) {
+                    prismaSchema[key] = {
+                        createMany: {
+                            data: entity[key].toArray('added').map((item) => {
+                                return this.entityToPrisma(item);
+                            }),
+                        },
+                    };
+                }
             }
-            else if (entity[key] instanceof entity_1.Entity) {
+            else if (entity[key] instanceof entity_base_1.EntityBase) {
                 prismaSchema[key] = this.entityToPrisma(entity[key]);
             }
             else {
@@ -131,7 +128,7 @@ class RepositoryBase {
         return prismaSchema;
     }
     context(transactionalClient) {
-        const modelName = this._modelName?.name;
+        const modelName = this._modelName.name;
         if (!modelName)
             throw new Error('modelName não informado no contrutor do repositorio');
         if (transactionalClient) {
@@ -148,5 +145,10 @@ class RepositoryBase {
             take: (pagination?.limit ?? 0) > 0 ? pagination?.limit : undefined,
         };
     }
+    createEntity(data) {
+        const entity = new this._modelName();
+        entity.automap(data);
+        return entity;
+    }
 }
 exports.RepositoryBase = RepositoryBase;

package/core/koala-app.d.ts

@@ -1,23 +1,22 @@
 import { INestApplication, Type } from '@nestjs/common';
 import { BaseExceptionFilter } from '@nestjs/core';
-import { CronJob } from '../common/backgroud-services/cron-service/cron-job';
-import { EventHandler } from '../common/backgroud-services/event-service/event-handler';
+import { CronJob } from '../core/backgroud-services/cron-service/cron-job';
+import { EventHandler } from '../core/backgroud-services/event-service/event-handler';
+import { PrismaTransactionalClient } from './database/prisma-transactional-client';
 interface ApiDocConfig {
     endpoint: string;
     title: string;
+    ui?: 'swagger' | 'scalar';
     description?: string;
     externalDoc?: {
         message: string;
         url: string;
     };
     version: string;
-    accessDocWithCredentials?: {
-        username: string;
-        password: string;
-    };
     withAuthorization?: boolean;
 }
 type CronJobClass = string | symbol | Function | Type<CronJob>;
+type EventJobClass = string | symbol | Function | Type<EventHandler<any>>;
 export declare class KoalaApp {
     private readonly app;
     private _globalExceptionFilter;
@@ -28,13 +27,16 @@ export declare class KoalaApp {
     private _eventJobs;
     constructor(app: INestApplication<any>);
     addCronJob(job: CronJobClass): this;
-    addEventJob(eventJob: EventHandler<any>): this;
+    addEventJob(eventJob: EventJobClass): this;
     addCustomGlobalExceptionFilter(filter: BaseExceptionFilter): this;
     addCustomPrismaValidationExceptionFilter(filter: BaseExceptionFilter): this;
     addCustomDomainExceptionFilter(filter: BaseExceptionFilter): this;
     addCustomZodExceptionFilter(filter: BaseExceptionFilter): this;
-    includeSwagger(config: ApiDocConfig): this;
+    useDoc(config: ApiDocConfig): this;
     enableCors(): this;
+    setAppName(name: string): this;
+    setInternalUserName(name: string): this;
+    setDbTransactionContext(transactionContext: Type<PrismaTransactionalClient>): this;
     build(): Promise<INestApplication<any>>;
 }
 export {};

package/core/koala-app.js

@@ -1,13 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.KoalaApp = void 0;
+const common_1 = require("@nestjs/common");
 const core_1 = require("@nestjs/core");
 const swagger_1 = require("@nestjs/swagger");
-const express_basic_auth_1 = require("express-basic-auth");
+const nestjs_api_reference_1 = require("@scalar/nestjs-api-reference");
+const expressBasicAuth = require("express-basic-auth");
 const domain_errors_filter_1 = require("../filters/domain-errors.filter");
 const global_exception_filter_1 = require("../filters/global-exception.filter");
 const prisma_validation_exception_filter_1 = require("../filters/prisma-validation-exception.filter");
 const zod_errors_filter_1 = require("../filters/zod-errors.filter");
+const koala_global_vars_1 = require("./koala-global-vars");
 const env_config_1 = require("./utils/env.config");
 class KoalaApp {
     app;
@@ -50,12 +53,16 @@ class KoalaApp {
         this._zodExceptionFilter = filter;
         return this;
     }
-    includeSwagger(config) {
-        if (env_config_1.EnvConfig.isEnvDevelop && config.accessDocWithCredentials) {
-            this.app.use([config.endpoint], (0, express_basic_auth_1.default)({
+    useDoc(config) {
+        const credentials = {
+            username: process.env.SWAGGER_USERNAME ?? '',
+            password: process.env.SWAGGER_PASSWORD ?? ''
+        };
+        if (env_config_1.EnvConfig.isEnvDevelop && credentials.username && credentials.password) {
+            this.app.use([config.endpoint], expressBasicAuth({
                 challenge: true,
                 users: {
-                    [config.accessDocWithCredentials.username]: config.accessDocWithCredentials.password,
+                    [credentials.username]: credentials.password
                 },
             }));
         }
@@ -73,7 +80,15 @@ class KoalaApp {
         }
         const document = swagger_1.SwaggerModule.createDocument(this.app, documentBuilder.build());
         const swaggerEndpoint = config.endpoint;
-        swagger_1.SwaggerModule.setup(swaggerEndpoint, this.app, document);
+        if (config.ui === 'scalar' && swaggerEndpoint === '/') {
+            throw new common_1.InternalServerErrorException("O endpoint de documentação não pode ser '/' para UI Scalar.");
+        }
+        swagger_1.SwaggerModule.setup(swaggerEndpoint, this.app, document, {
+            swaggerUiEnabled: config.ui !== 'scalar',
+        });
+        if (config.ui === 'scalar') {
+            this.app.use(swaggerEndpoint, (0, nestjs_api_reference_1.apiReference)({ spec: { content: document } }));
+        }
         return this;
     }
     enableCors() {
@@ -84,10 +99,28 @@ class KoalaApp {
         });
         return this;
     }
+    setAppName(name) {
+        koala_global_vars_1.KoalaGlobalVars.appName = name;
+        return this;
+    }
+    setInternalUserName(name) {
+        koala_global_vars_1.KoalaGlobalVars.internalUserName = name;
+        return this;
+    }
+    setDbTransactionContext(transactionContext) {
+        koala_global_vars_1.KoalaGlobalVars.dbTransactionContext = transactionContext;
+        return this;
+    }
     async build() {
         this.app.useGlobalFilters(this._globalExceptionFilter, this._prismaValidationExceptionFilter, this._domainExceptionFilter, this._zodExceptionFilter);
-        Promise.all(this._cronJobs.map((job) => this.app.resolve(job))).then((cronJobs) => cronJobs.forEach((job) => job.run()));
-        this._eventJobs.forEach((eventJob) => eventJob.setupSubscriptions());
+        const cronJobs = await Promise.all(this._cronJobs.map((job) => this.app.resolve(job)));
+        for (const cronJob of cronJobs) {
+            cronJob.start();
+        }
+        const eventJobs = await Promise.all(this._eventJobs.map((job) => this.app.resolve(job)));
+        for (const eventJob of eventJobs) {
+            eventJob.setupSubscriptions();
+        }
         return this.app;
     }
 }

package/core/koala-global-vars.d.ts

@@ -0,0 +1,7 @@
+import { Type } from "@nestjs/common";
+import { PrismaTransactionalClient } from "./database/prisma-transactional-client";
+export declare class KoalaGlobalVars {
+    static appName: string;
+    static internalUserName: string;
+    static dbTransactionContext?: Type<PrismaTransactionalClient>;
+}

package/core/koala-global-vars.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KoalaGlobalVars = void 0;
+class KoalaGlobalVars {
+    static appName = 'koala-nest';
+    static internalUserName = 'internal';
+    static dbTransactionContext;
+}
+exports.KoalaGlobalVars = KoalaGlobalVars;

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

@@ -9,8 +9,8 @@ var KoalaNestDatabaseModule_1;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.KoalaNestDatabaseModule = exports.PRISMA_TOKEN = void 0;
 const common_1 = require("@nestjs/common");
-const env_service_1 = require("../services/env/env.service");
-const prisma_service_1 = require("../services/prisma/prisma.service");
+const env_service_1 = require("../env/env.service");
+const prisma_service_1 = require("./database/prisma.service");
 exports.PRISMA_TOKEN = 'PRISMA_SERVICE_TOKEN';
 let KoalaNestDatabaseModule = exports.KoalaNestDatabaseModule = KoalaNestDatabaseModule_1 = class KoalaNestDatabaseModule {
     static register(config) {

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

@@ -1,7 +1,7 @@
-import { DynamicModule, MiddlewareConsumer, NestMiddleware, NestModule, Provider, Type } from '@nestjs/common';
-import { AutomapperProfile } from 'automapper-nestjs';
+import { DynamicModule, MiddlewareConsumer, NestMiddleware, NestModule, Type } from '@nestjs/common';
+import { AutoMappingProfile } from './mapping/auto-mapping-profile';
 interface KoalaNestHttpModuleConfig {
-    automapperProfile: Provider<AutomapperProfile>;
+    automapperProfile: Type<AutoMappingProfile>;
     middlewares?: Type<NestMiddleware>[];
 }
 export declare class KoalaNestHttpModule implements NestModule {