@koalarx/nest 3.1.49 → 4.0.1

package/core/database/repository.base.js

@@ -1,668 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RepositoryBase = void 0;
-const KlString_1 = require("@koalarx/utils/KlString");
-const pagination_dto_1 = require("../dtos/pagination.dto");
-const koala_global_vars_1 = require("../koala-global-vars");
-const auto_mapping_list_1 = require("../mapping/auto-mapping-list");
-const generate_prisma_include_schema_1 = require("../utils/generate-prisma-include-schema");
-const hydrate_entity_from_cache_1 = require("../utils/hydrate-entity-from-cache");
-const list_1 = require("../utils/list");
-const proxy_1 = require("../utils/proxy");
-const entity_base_1 = require("./entity.base");
-class RepositoryBase {
-    _context;
-    _modelName;
-    _includeFindMany;
-    constructor({ context, modelName }) {
-        this._context = context;
-        this._modelName = modelName;
-        this._includeFindMany = (0, generate_prisma_include_schema_1.generateIncludeSchema)({
-            forList: true,
-            deepLimit: 2,
-            entity: this._modelName,
-        });
-    }
-    get entityInstance() {
-        return this._modelName.prototype.constructor;
-    }
-    getIdPropName(entity) {
-        const idConfig = Reflect.getMetadata('entity:id', entity ? entity.constructor.prototype : this._modelName.prototype);
-        if (idConfig) {
-            if (idConfig.single) {
-                return idConfig.single;
-            }
-            else if (idConfig.composite) {
-                return idConfig.composite;
-            }
-        }
-        return 'id';
-    }
-    getWhereByIdSchema(entity, value) {
-        const propIdName = this.getIdPropName(entity);
-        if (Array.isArray(propIdName)) {
-            const whereSchema = {};
-            propIdName.forEach((propName) => {
-                whereSchema[propName] =
-                    typeof value === 'object' ? value[propName] : value;
-            });
-            return whereSchema;
-        }
-        return {
-            [propIdName]: typeof value === 'object' ? value[propIdName] : value,
-        };
-    }
-    getConnectPrismaSchemaForRelation(entity, data) {
-        return {
-            connect: this.getWhereByIdSchema(entity, data ?? entity),
-        };
-    }
-    checkIdHasValue(entity, value) {
-        const result = this.getWhereByIdSchema(entity, value);
-        return Object.values(result).every((val) => val !== undefined && val !== null);
-    }
-    getSelectRootPrismaSchema(entity) {
-        const selectSchema = {};
-        const entityProps = auto_mapping_list_1.AutoMappingList.getAllProps(entity);
-        entityProps.forEach((prop) => {
-            let instance;
-            try {
-                instance = new (prop.type())();
-            }
-            catch {
-                instance = null;
-            }
-            if (instance instanceof entity_base_1.EntityBase) {
-                selectSchema[prop.name] = {
-                    select: this.getWhereByIdSchema(instance, true),
-                };
-            }
-            else if (instance instanceof list_1.List) {
-                const list = new entity()[prop.name];
-                const entityInstance = list.entityType;
-                selectSchema[prop.name] = {
-                    select: this.getWhereByIdSchema(new entityInstance(), true),
-                };
-            }
-            else {
-                selectSchema[prop.name] = true;
-            }
-        });
-        return selectSchema;
-    }
-    getSelectWithRelationsId(entity) {
-        const selectSchema = {};
-        const entityProps = auto_mapping_list_1.AutoMappingList.getAllProps(entity);
-        entityProps.forEach((prop) => {
-            let instance;
-            try {
-                instance = new (prop.type())();
-            }
-            catch {
-                instance = null;
-            }
-            if (instance instanceof entity_base_1.EntityBase) {
-                selectSchema[prop.name] = {
-                    select: this.getWhereByIdSchema(instance, true),
-                };
-            }
-            else if (instance instanceof list_1.List) {
-                const list = new entity()[prop.name];
-                const entityInstance = list.entityType;
-                selectSchema[prop.name] = {
-                    select: this.getWhereByIdSchema(new entityInstance(), true),
-                };
-            }
-            else {
-                selectSchema[prop.name] = true;
-            }
-        });
-        return selectSchema;
-    }
-    getPropNameFromEntitySource(source, entity) {
-        const entityProps = auto_mapping_list_1.AutoMappingList.getAllProps(source);
-        return entityProps.find((prop) => {
-            let instance;
-            try {
-                instance = new (prop.type())();
-            }
-            catch {
-                instance = null;
-            }
-            if (instance) {
-                if (instance.constructor.name === entity.name) {
-                    return true;
-                }
-                else if (source[prop.name] instanceof list_1.List) {
-                    const list = source[prop.name];
-                    return list.entityType?.name === entity.name;
-                }
-            }
-            return false;
-        })?.name;
-    }
-    listRelationEntities(entity, fromList = false) {
-        const relationEntities = [];
-        Object.keys(entity).forEach((key) => {
-            if (entity[key] instanceof list_1.List) {
-                const list = entity[key];
-                list.toArray('added').forEach((item) => {
-                    relationEntities.push(item);
-                });
-                list.toArray('updated').forEach((item) => {
-                    relationEntities.push(item);
-                });
-            }
-            else if (entity[key] instanceof entity_base_1.EntityBase && !fromList) {
-                relationEntities.push(entity[key]);
-            }
-        });
-        return relationEntities;
-    }
-    listToRelationActionList(entity) {
-        const relationCreates = [];
-        const relationUpdates = [];
-        const relationDeletes = [];
-        Object.keys(entity).forEach((key) => {
-            if (entity[key] instanceof list_1.List) {
-                const list = entity[key];
-                const entityInstance = list.entityType;
-                const modelName = entityInstance.name;
-                const parentModelName = entity.constructor.name;
-                const parentPropName = this.getPropNameFromEntitySource(entityInstance, entity.constructor) ?? (0, KlString_1.toCamelCase)(parentModelName);
-                if (modelName) {
-                    list.toArray('removed').forEach((item) => {
-                        relationDeletes.push({
-                            modelName: (0, KlString_1.toCamelCase)(modelName),
-                            entityInstance,
-                            schema: this.getWhereByIdSchema(item, item),
-                            relations: [],
-                        });
-                    });
-                    list.toArray('added').forEach((item) => {
-                        relationCreates.push({
-                            modelName: (0, KlString_1.toCamelCase)(modelName),
-                            entityInstance,
-                            schema: {
-                                data: {
-                                    ...this.entityToPrisma(item),
-                                    [parentPropName]: this.getConnectPrismaSchemaForRelation(entity),
-                                },
-                                select: this.getSelectRootPrismaSchema(item.constructor),
-                            },
-                            relations: this.listRelationEntities(item, true),
-                        });
-                    });
-                    list.toArray('updated').forEach((item) => {
-                        relationUpdates.push({
-                            modelName: (0, KlString_1.toCamelCase)(modelName),
-                            entityInstance,
-                            schema: {
-                                where: this.getWhereByIdSchema(item, item),
-                                data: this.entityToPrisma(item),
-                                select: this.getSelectRootPrismaSchema(item.constructor),
-                            },
-                            relations: this.listRelationEntities(item, true),
-                        });
-                    });
-                }
-            }
-            else if (entity[key] instanceof entity_base_1.EntityBase) {
-                const entityInstance = entity[key];
-                const modelName = entity[key].constructor.name;
-                if (entity[key]._action === entity_base_1.EntityActionType.update &&
-                    entity[key]._hasUpdate) {
-                    relationUpdates.push({
-                        modelName: (0, KlString_1.toCamelCase)(modelName),
-                        entityInstance,
-                        schema: {
-                            where: { id: entityInstance._id },
-                            data: this.entityToPrisma(entityInstance),
-                            select: this.getSelectRootPrismaSchema(entityInstance.constructor),
-                        },
-                        relations: this.listRelationEntities(entityInstance),
-                    });
-                }
-                else if (entity[key]._action === entity_base_1.EntityActionType.create) {
-                    relationCreates.push({
-                        modelName: (0, KlString_1.toCamelCase)(modelName),
-                        entityInstance,
-                        schema: {
-                            data: this.entityToPrisma(entityInstance),
-                            select: this.getSelectRootPrismaSchema(entityInstance.constructor),
-                        },
-                        relations: this.listRelationEntities(entityInstance),
-                    });
-                }
-            }
-        });
-        return { relationCreates, relationUpdates, relationDeletes };
-    }
-    entityToPrisma(entity) {
-        const prismaSchema = {};
-        Object.keys(entity)
-            .filter((key) => !['id', '_id', '_action'].includes(key))
-            .filter((key) => !(entity[key] instanceof Function || entity[key] instanceof list_1.List))
-            .forEach((key) => {
-            if (entity[key] instanceof entity_base_1.EntityBase) {
-                if (entity[key]._action === entity_base_1.EntityActionType.create) {
-                    if (entity[key] && this.checkIdHasValue(entity, entity[key])) {
-                        prismaSchema[key] = {
-                            connectOrCreate: {
-                                where: this.getWhereByIdSchema(entity[key].constructor, entity[key]),
-                                create: this.entityToPrisma(entity[key]),
-                            },
-                        };
-                    }
-                    else {
-                        prismaSchema[key] = {
-                            create: this.entityToPrisma(entity[key]),
-                        };
-                    }
-                }
-                else {
-                    prismaSchema[key] = entity[key]._hasUpdate
-                        ? { update: this.entityToPrisma(entity[key]) }
-                        : this.getConnectPrismaSchemaForRelation(entity[key]);
-                }
-            }
-            else if (entity[key] === null) {
-                const propDefinitions = auto_mapping_list_1.AutoMappingList.getPropDefinitions(entity.constructor, key);
-                const relationEntity = auto_mapping_list_1.AutoMappingList.getSourceByName(propDefinitions?.type ?? '');
-                if (relationEntity) {
-                    prismaSchema[key] = {
-                        disconnect: true,
-                    };
-                }
-            }
-            else if (!(entity[key] instanceof list_1.List)) {
-                prismaSchema[key] = entity[key];
-            }
-        });
-        return prismaSchema;
-    }
-    getInclude(include) {
-        include = include ?? {};
-        const result = {};
-        Object.keys(include).forEach((key) => {
-            if (typeof include[key] === 'boolean') {
-                result[key] = include[key];
-            }
-            else {
-                result[key] = {
-                    include: this.getInclude(include[key]),
-                };
-            }
-        });
-        return result;
-    }
-    findManySchema(where, pagination) {
-        return {
-            include: this.getInclude(this._includeFindMany),
-            where,
-            orderBy: pagination?.generateOrderBy(),
-            skip: pagination?.skip(),
-            take: (pagination?.limit ?? 0) > 0 ? pagination?.limit : undefined,
-        };
-    }
-    createEntity(data, entityClass) {
-        const entity = new (entityClass || this._modelName)();
-        const trackedEntity = entity;
-        if (typeof trackedEntity.stopHasUpdateTracking === 'function') {
-            trackedEntity.stopHasUpdateTracking();
-        }
-        entity._action = entity_base_1.EntityActionType.update;
-        entity.automap(data);
-        if (typeof trackedEntity.startHasUpdateTracking === 'function') {
-            trackedEntity.startHasUpdateTracking();
-        }
-        return entity;
-    }
-    orphanRemoval(client, entity) {
-        const where = {};
-        Object.keys(entity)
-            .filter((key) => key === 'id' || key.includes('Id'))
-            .forEach((key) => (where[key] = entity[key]));
-        return client[(0, KlString_1.toCamelCase)(entity.constructor.name)].delete({ where });
-    }
-    getIdOnEntity(entity, data) {
-        const propIdName = this.getIdPropName(entity);
-        if (Array.isArray(propIdName)) {
-            const idValues = [];
-            propIdName.forEach((propName) => {
-                idValues.push(data[propName]);
-            });
-            return idValues.join('-');
-        }
-        return data[propIdName];
-    }
-    async loadRelationForEntity(where, entity, cache) {
-        return this._context[(0, KlString_1.toCamelCase)((0, KlString_1.toCamelCase)(entity.name))]
-            .findFirst({
-            select: this.getSelectRootPrismaSchema(entity),
-            where,
-        })
-            .then((data) => this.enrichEntityWithRelations(entity, (0, proxy_1.createProxy)(data), cache));
-    }
-    loadEntityFromCache(entity, data, cache) {
-        return (0, hydrate_entity_from_cache_1.hydrateEntityFromCache)({
-            entity: entity,
-            data,
-            cache,
-            dependencies: {
-                getAllProps: (sourceEntity) => auto_mapping_list_1.AutoMappingList.getAllProps(sourceEntity),
-                getPropDefinitions: (sourceEntity, propName) => auto_mapping_list_1.AutoMappingList.getPropDefinitions(sourceEntity, propName),
-                getSourceByName: (sourceName) => auto_mapping_list_1.AutoMappingList.getSourceByName(sourceName),
-                getListEntityType: (sourceEntity, propName) => {
-                    const list = new sourceEntity()[propName];
-                    if (list instanceof list_1.List) {
-                        return list.entityType;
-                    }
-                    return null;
-                },
-                getIdOnEntity: (currentEntity, value) => this.getIdOnEntity(currentEntity, value),
-                createEntity: (sourceEntity) => new sourceEntity(),
-            },
-        });
-    }
-    async enrichEntityWithRelations(entity, data, cache = new Map()) {
-        if (!data) {
-            return null;
-        }
-        const allProps = auto_mapping_list_1.AutoMappingList.getAllProps(entity);
-        for (const prop of allProps) {
-            const propName = prop.name;
-            const propDef = auto_mapping_list_1.AutoMappingList.getPropDefinitions(entity, propName);
-            if (propDef?.type === list_1.List.name) {
-                const list = new entity()[prop.name];
-                const entityInstance = list.entityType;
-                for (const item of data[propName] || []) {
-                    const cacheKey = `${entityInstance.name}-${this.getIdOnEntity(new entityInstance(), item)}`;
-                    if (cache.has(cacheKey)) {
-                        continue;
-                    }
-                    cache.set(cacheKey, item);
-                    await this.loadRelationForEntity(this.getWhereByIdSchema(new entityInstance(), item), entityInstance, cache).then((response) => cache.set(cacheKey, response));
-                }
-                continue;
-            }
-            const relationEntity = auto_mapping_list_1.AutoMappingList.getSourceByName(propDef?.type ?? '');
-            if (relationEntity && data[propName]) {
-                const cacheKey = `${relationEntity.name}-${this.getIdOnEntity(new relationEntity(), data[propName])}`;
-                if (cache.has(cacheKey)) {
-                    continue;
-                }
-                cache.set(cacheKey, data[propName]);
-                await this.loadRelationForEntity(this.getWhereByIdSchema(new relationEntity(), data[propName]), relationEntity, cache).then((response) => cache.set(cacheKey, response));
-            }
-        }
-        return data;
-    }
-    async persistRelations(transaction, entity) {
-        const { relationCreates, relationUpdates, relationDeletes } = this.listToRelationActionList(entity);
-        if (relationDeletes.length > 0) {
-            await Promise.all(relationDeletes.map((relation) => transaction[relation.modelName].deleteMany({
-                where: relation.schema,
-            })));
-        }
-        if (relationUpdates.length > 0) {
-            await Promise.all([
-                ...relationUpdates.map((relationUpdate) => transaction[relationUpdate.modelName]
-                    .update(relationUpdate.schema)
-                    .then(() => {
-                    if (relationUpdate.relations.length === 0) {
-                        return Promise.all([]);
-                    }
-                    return Promise.all(relationUpdate.relations.map((relation) => {
-                        if (relation._action === entity_base_1.EntityActionType.update &&
-                            relation._hasUpdate) {
-                            return this.persistRelations(transaction, relation);
-                        }
-                        else if (relation._action === entity_base_1.EntityActionType.create) {
-                            const relationPropName = this.getPropNameFromEntitySource(relation.constructor, relationUpdate.entityInstance);
-                            if (relationPropName &&
-                                !(relation[relationPropName] instanceof list_1.List)) {
-                                relation[relationPropName] =
-                                    this.getConnectPrismaSchemaForRelation(relationUpdate.entityInstance, relation[relationPropName] ??
-                                        relationUpdate.schema.where);
-                            }
-                            return transaction[(0, KlString_1.toCamelCase)(relation.constructor.name)]
-                                .create({
-                                data: this.entityToPrisma(relation),
-                                select: this.getSelectRootPrismaSchema(relation.constructor),
-                            })
-                                .then((response) => {
-                                const idPropName = this.getIdPropName(relation);
-                                if (!Array.isArray(idPropName)) {
-                                    relation[idPropName] = response[idPropName];
-                                }
-                                else {
-                                    idPropName.forEach((propName) => {
-                                        relation[propName] = response[propName];
-                                    });
-                                }
-                                return this.persistRelations(transaction, relation);
-                            });
-                        }
-                    }));
-                })),
-            ]);
-        }
-        if (relationCreates.length > 0) {
-            await Promise.all([
-                ...relationCreates.map((relationCreate) => transaction[relationCreate.modelName]
-                    .create(relationCreate.schema)
-                    .then((response) => {
-                    if (relationCreate.relations.length === 0) {
-                        return Promise.all([]);
-                    }
-                    return Promise.all(relationCreate.relations.map((relation) => {
-                        if (relation._action === entity_base_1.EntityActionType.update &&
-                            relation._hasUpdate) {
-                            return this.persistRelations(transaction, relation);
-                        }
-                        else if (relation._action === entity_base_1.EntityActionType.create) {
-                            const relationPropName = this.getPropNameFromEntitySource(relation.constructor, relationCreate.entityInstance);
-                            if (relationPropName &&
-                                !(relation[relationPropName] instanceof list_1.List)) {
-                                relation[relationPropName] =
-                                    this.getConnectPrismaSchemaForRelation(relationCreate.entityInstance, response);
-                            }
-                            return transaction[(0, KlString_1.toCamelCase)(relation.constructor.name)]
-                                .create({
-                                data: this.entityToPrisma(relation),
-                                select: this.getSelectRootPrismaSchema(relation.constructor),
-                            })
-                                .then((response) => {
-                                const idPropName = this.getIdPropName(relation);
-                                if (!Array.isArray(idPropName)) {
-                                    relation[idPropName] = response[idPropName];
-                                }
-                                else {
-                                    idPropName.forEach((propName) => {
-                                        relation[propName] = response[propName];
-                                    });
-                                }
-                                return this.persistRelations(transaction, relation);
-                            });
-                        }
-                    }));
-                })),
-            ]);
-        }
-    }
-    setIdOnEntity(entityInstance, data) {
-        const idPropName = this.getIdPropName(entityInstance);
-        if (!Array.isArray(idPropName)) {
-            entityInstance[idPropName] = data[idPropName];
-            entityInstance._id = data[idPropName];
-        }
-        else {
-            idPropName.forEach((propName) => {
-                entityInstance[propName] = data[propName];
-            });
-            entityInstance._id = idPropName.map((name) => data[name]).join('-');
-        }
-        entityInstance._action = entity_base_1.EntityActionType.update;
-        entityInstance._hasUpdate = false;
-    }
-    autofillCreatedId(entity, response) {
-        this.setIdOnEntity(entity, response);
-        Object.keys(entity).forEach((key) => {
-            if (entity[key] instanceof entity_base_1.EntityBase && response[key]) {
-                this.setIdOnEntity(entity[key], response[key]);
-            }
-        });
-    }
-    context(transactionalClient) {
-        const modelName = this._modelName.name;
-        if (!modelName)
-            throw new Error('modelName não informado no contrutor do repositorio');
-        const contextKey = (0, KlString_1.toCamelCase)(modelName);
-        if (transactionalClient) {
-            return transactionalClient[contextKey];
-        }
-        return this._context[contextKey];
-    }
-    async findById(id) {
-        const data = await this.context().findFirst({
-            select: this.getSelectWithRelationsId(this.entityInstance),
-            where: this.getWhereByIdSchema(this.entityInstance, {
-                id,
-            }),
-        });
-        if (!data)
-            return null;
-        const cache = new Map();
-        return this.enrichEntityWithRelations(this.entityInstance, (0, proxy_1.createProxy)(data), cache)
-            .then((response) => this.loadEntityFromCache(this.entityInstance, response, cache))
-            .then((response) => this.createEntity(response));
-    }
-    async findFirst(where) {
-        const data = await this.context().findFirst({
-            select: this.getSelectWithRelationsId(this.entityInstance),
-            where,
-        });
-        if (!data)
-            return null;
-        const cache = new Map();
-        return this.enrichEntityWithRelations(this.entityInstance, (0, proxy_1.createProxy)(data), cache)
-            .then((response) => this.loadEntityFromCache(this.entityInstance, response, cache))
-            .then((response) => this.createEntity(response));
-    }
-    async findUnique(where) {
-        const data = await this.context().findUnique({
-            select: this.getSelectWithRelationsId(this.entityInstance),
-            where,
-        });
-        if (!data)
-            return null;
-        const cache = new Map();
-        return this.enrichEntityWithRelations(this.entityInstance, (0, proxy_1.createProxy)(data), cache)
-            .then((response) => this.loadEntityFromCache(this.entityInstance, response, cache))
-            .then((response) => this.createEntity(response));
-    }
-    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_dto_1.PaginationDto(), pagination));
-            return { items, count };
-        }
-        return { items: [], count };
-    }
-    async saveChanges(entity, updateWhere) {
-        const prismaEntity = this.entityToPrisma(entity);
-        if (entity._action === entity_base_1.EntityActionType.create) {
-            return this.withTransaction((client) => this.context(client)
-                .create({
-                data: prismaEntity,
-                select: this.getSelectRootPrismaSchema(entity.constructor),
-            })
-                .then((response) => {
-                this.autofillCreatedId(entity, response);
-                return this.persistRelations(client, entity).then(() => entity);
-            }));
-        }
-        else {
-            const where = updateWhere ?? { id: entity._id };
-            return this.withTransaction((client) => this.context(client)
-                .update({
-                where,
-                data: prismaEntity,
-                select: this.getSelectRootPrismaSchema(entity.constructor),
-            })
-                .then((response) => {
-                this.autofillCreatedId(entity, response);
-                return this.persistRelations(client, entity);
-            })).then(() => this.findUnique(where));
-        }
-    }
-    async saveMany(entities, updateWhere) {
-        await this.withTransaction(async (client) => {
-            const prismaEntities = entities.map((entity) => this.entityToPrisma(entity));
-            return Promise.all([
-                this.context(client).createMany({
-                    data: prismaEntities,
-                    skipDuplicates: true,
-                }),
-                ...entities
-                    .filter((entity) => !!entity._id)
-                    .map((entity) => this.context(client).update({
-                    data: entity,
-                    where: updateWhere ?? { id: entity._id },
-                })),
-            ]);
-        });
-    }
-    async remove(where, notCascadeEntityProps, externalServices) {
-        const entity = await this.findUnique(where);
-        if (!entity) {
-            throw new Error(`Entity not found for where: ${JSON.stringify(where)}`);
-        }
-        const relationEntity = [];
-        Object.keys(entity).forEach((key) => {
-            if (entity[key] instanceof entity_base_1.EntityBase &&
-                !notCascadeEntityProps?.includes(key)) {
-                relationEntity.push(entity[key]);
-            }
-        });
-        return this.withTransaction((client) => (externalServices
-            ? externalServices.then(() => client)
-            : Promise.resolve(client)).then((client) => this.context(client)
-            .delete({ where })
-            .then((response) => Promise.all(relationEntity.map((entity) => this.orphanRemoval(client, entity))).then(() => response))));
-    }
-    async removeMany(where, notCascadeEntityProps, externalServices) {
-        const entities = await this.findMany(where);
-        if (entities.length === 0) {
-            throw new Error(`Entities not found for where: ${JSON.stringify(where)}`);
-        }
-        return this.withTransaction((client) => (externalServices
-            ? externalServices.then(() => client)
-            : Promise.resolve(client)).then(async (client) => {
-            const relationEntity = [];
-            for (const entity of entities) {
-                Object.keys(entity).forEach((key) => {
-                    if (entity[key] instanceof entity_base_1.EntityBase &&
-                        !notCascadeEntityProps?.includes(key)) {
-                        relationEntity.push(entity[key]);
-                    }
-                });
-            }
-            return this.context(client)
-                .deleteMany({ where })
-                .then((response) => Promise.all(relationEntity.map((entity) => this.orphanRemoval(client, entity))).then(() => response));
-        }));
-    }
-    withTransaction(fn) {
-        return this._context.withTransaction(async (client) => {
-            return fn(new koala_global_vars_1.KoalaGlobalVars.dbTransactionContext(client));
-        });
-    }
-}
-exports.RepositoryBase = RepositoryBase;

package/core/dtos/pagination.dto.d.ts

@@ -1,9 +0,0 @@
-import type { QueryDirectionType } from '..';
-export declare class PaginationDto {
-    page?: number;
-    limit?: number;
-    orderBy?: string;
-    direction?: QueryDirectionType;
-    skip(): number;
-    generateOrderBy(): {} | undefined;
-}