@koalarx/nest 0.0.9 → 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

@@ -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);
         }
@@ -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);
+        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/{common → core}/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 → core}/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/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/{services/prisma → core/database}/prisma-transactional-client.d.ts

@@ -1,6 +1,5 @@
 import { Prisma, PrismaPromise } from '@prisma/client';
-import { PrismaClientWithCustomTransaction } from './prisma-client-with-custom-transaction.interface';
-export declare class PrismaTransactionalClient implements PrismaClientWithCustomTransaction {
+export declare abstract class PrismaTransactionalClient {
     protected readonly transactionalClient: Prisma.TransactionClient;
     constructor(transactionalClient: Prisma.TransactionClient);
     withTransaction<F>(fn: (prisma: Prisma.TransactionClient) => Promise<F>): Promise<F>;

package/{services/prisma → core/database}/prisma.service.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.PrismaService = void 0;
 const common_1 = require("@nestjs/common");
@@ -34,5 +37,6 @@ let PrismaService = exports.PrismaService = class PrismaService extends client_1
     }
 };
 exports.PrismaService = PrismaService = __decorate([
-    (0, common_1.Injectable)()
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [])
 ], PrismaService);

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

@@ -1,17 +1,33 @@
-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 { Entity } from './entity';
-export interface FindAllProps<TPaginateAndOrdering extends PaginationParams, TWhere, TInclude = any> {
-    where: TWhere;
-    paginateAndOrderingProps?: TPaginateAndOrdering;
-    include?: TInclude;
+import { Type } from '@nestjs/common';
+import { ListResponse } from '../@types';
+import { PaginationParams } from '../models/pagination-params';
+import { IComparableId } from '../utils/interfaces/icomparable';
+import { EntityBase } from './entity.base';
+import { PrismaTransactionalClient } from './prisma-transactional-client';
+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;
+export declare abstract class RepositoryBase<TEntity extends EntityBase<TEntity>> {
+    protected _context: PrismaTransactionalClient;
     private readonly _modelName;
-    constructor(prisma: PrismaClientWithCustomTransaction, _modelName: ModelName);
+    private readonly _include?;
+    constructor({ context, 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;
+    private createEntity;
 }
+export {};

package/core/database/repository.base.js

@@ -1,27 +1,154 @@
 "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 koala_global_vars_1 = require("../koala-global-vars");
+const pagination_params_1 = require("../models/pagination-params");
+const list_1 = require("../utils/list");
+const entity_base_1 = require("./entity.base");
 class RepositoryBase {
-    prisma;
+    _context;
     _modelName;
-    constructor(prisma, _modelName) {
-        this.prisma = prisma;
-        this._modelName = _modelName;
+    _include;
+    constructor({ context, modelName, include, }) {
+        this._context = context;
+        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 koala_global_vars_1.KoalaGlobalVars.dbTransactionContext(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 this.createEntity(response);
+            }
+            return null;
+        });
+    }
+    async findMany(where, pagination) {
+        return this.context()
+            .findMany(this.findManySchema(where, pagination))
+            .then((result) => result.map((response) => this.createEntity(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) {
+                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_base_1.EntityBase) {
+                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,
+        };
+    }
+    createEntity(data) {
+        const entity = new this._modelName();
+        entity.automap(data);
+        return entity;
     }
 }
 exports.RepositoryBase = RepositoryBase;