@koalarx/nest 3.0.2 → 3.0.4

package/core/database/prisma-resolver.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setPrismaClient = setPrismaClient;
+exports.getPrismaClientClass = getPrismaClientClass;
+const path = require("path");
+const fs = require("fs");
+let cachedPrismaClient = null;
+function findPrismaClient() {
+    const possiblePaths = [
+        path.join(process.cwd(), 'prisma/generated/client.js'),
+        path.join(__dirname, '../../../../../prisma/generated/client.js'),
+        path.join(process.cwd(), 'prisma/generated/client.ts'),
+        path.join(__dirname, '../../../../../prisma/generated/client.ts'),
+        ...(require.main?.filename
+            ? [
+                path.join(path.dirname(require.main.filename), '../prisma/generated/client.js'),
+                path.join(path.dirname(require.main.filename), '../prisma/generated/client.ts'),
+            ]
+            : []),
+    ];
+    for (const prismaPath of possiblePaths) {
+        if (fs.existsSync(prismaPath)) {
+            return prismaPath;
+        }
+    }
+    return null;
+}
+async function resolvePrismaClient() {
+    if (cachedPrismaClient) {
+        return cachedPrismaClient;
+    }
+    const prismaPath = findPrismaClient();
+    if (!prismaPath) {
+        throw new Error(`
+      Não foi possível carregar o Prisma Client automaticamente.
+      
+      Certifique-se de que você:
+      1. Executou 'bunx prisma generate' no seu projeto
+      2. Tem a pasta 'prisma/generated/client' no seu projeto
+      3. A lib @koalarx/nest está instalada como dependência
+      
+      Se o problema persistir, você pode registrar manualmente o Prisma Client:
+      
+      import { setPrismaClient } from '@koalarx/nest'
+      import { PrismaClient } from './prisma/generated/client'
+      
+      setPrismaClient(PrismaClient)
+      `.trim());
+    }
+    try {
+        const module = await Promise.resolve(`${prismaPath}`).then(s => require(s));
+        cachedPrismaClient = module.PrismaClient || module.default || module;
+        return cachedPrismaClient;
+    }
+    catch (error) {
+        throw new Error(`
+      Erro ao carregar o Prisma Client de ${prismaPath}:
+      ${error instanceof Error ? error.message : String(error)}
+      
+      Certifique-se de que 'bunx prisma generate' foi executado com sucesso.
+      `.trim());
+    }
+}
+let manualPrismaClient = null;
+function setPrismaClient(prismaClientClass) {
+    manualPrismaClient = prismaClientClass;
+    cachedPrismaClient = null;
+}
+function getPrismaClientClass() {
+    if (manualPrismaClient) {
+        return manualPrismaClient;
+    }
+    return resolvePrismaClient();
+}

package/core/database/prisma-transactional-client.d.ts

@@ -0,0 +1,11 @@
+import { Prisma } from 'prisma/generated/client';
+export declare abstract class PrismaTransactionalClient {
+    protected readonly transactionalClient: Prisma.TransactionClient;
+    [key: symbol]: any;
+    constructor(transactionalClient: Prisma.TransactionClient);
+    withTransaction<F>(fn: (prisma: Prisma.TransactionClient) => Promise<F>): Promise<F>;
+    $executeRaw(query: TemplateStringsArray | Prisma.Sql, ...values: any[]): Prisma.PrismaPromise<number>;
+    $executeRawUnsafe(query: string, ...values: any[]): Prisma.PrismaPromise<number>;
+    $queryRaw<T = unknown>(query: TemplateStringsArray | Prisma.Sql, ...values: any[]): Prisma.PrismaPromise<T>;
+    $queryRawUnsafe<T = unknown>(query: string, ...values: any[]): Prisma.PrismaPromise<T>;
+}

package/core/database/prisma-transactional-client.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PrismaTransactionalClient = void 0;
+class PrismaTransactionalClient {
+    transactionalClient;
+    constructor(transactionalClient) {
+        this.transactionalClient = transactionalClient;
+    }
+    async withTransaction(fn) {
+        return await fn(this.transactionalClient);
+    }
+    $executeRaw(query, ...values) {
+        return this.transactionalClient.$executeRaw(query, ...values);
+    }
+    $executeRawUnsafe(query, ...values) {
+        return this.transactionalClient.$executeRawUnsafe(query, ...values);
+    }
+    $queryRaw(query, ...values) {
+        return this.transactionalClient.$queryRaw(query, ...values);
+    }
+    $queryRawUnsafe(query, ...values) {
+        return this.transactionalClient.$queryRawUnsafe(query, ...values);
+    }
+}
+exports.PrismaTransactionalClient = PrismaTransactionalClient;

package/core/database/prisma.service.d.ts

@@ -0,0 +1,24 @@
+import { EnvService } from '@koalarx/nest/env/env.service';
+import { OnModuleDestroy, OnModuleInit } from '@nestjs/common';
+import { PrismaClientWithCustomTransaction } from './prisma-client-with-custom-transaction.interface';
+import type { Prisma } from 'prisma/generated/client';
+export declare function setPrismaClientOptions(options: Prisma.PrismaClientOptions): void;
+export declare class PrismaService implements OnModuleInit, OnModuleDestroy, PrismaClientWithCustomTransaction {
+    private readonly env;
+    private prismaInstance;
+    constructor(env: EnvService);
+    initialize(): Promise<void>;
+    onModuleInit(): Promise<any>;
+    onModuleDestroy(): any;
+    withTransaction<F>(fn: (prisma: Prisma.TransactionClient) => Promise<F>, options?: {
+        maxWait?: number;
+        timeout?: number;
+        isolationLevel?: Prisma.TransactionIsolationLevel;
+    }): Promise<F>;
+    [Symbol.toPrimitive](): any;
+    toString(): string;
+    get $connect(): any;
+    get $disconnect(): any;
+    get $transaction(): any;
+    get $on(): any;
+}

package/core/database/prisma.service.js

@@ -0,0 +1,104 @@
+"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;
+};
+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;
+exports.setPrismaClientOptions = setPrismaClientOptions;
+const env_service_1 = require("../../env/env.service");
+const common_1 = require("@nestjs/common");
+const prisma_resolver_1 = require("./prisma-resolver");
+let globalPrismaOptions = {};
+function setPrismaClientOptions(options) {
+    globalPrismaOptions = options;
+}
+let PrismaClientClass = null;
+async function loadPrismaClient() {
+    if (!PrismaClientClass) {
+        PrismaClientClass = await (0, prisma_resolver_1.getPrismaClientClass)();
+    }
+    return PrismaClientClass;
+}
+let PrismaService = class PrismaService {
+    env;
+    prismaInstance;
+    constructor(env) {
+        this.env = env;
+        return new Proxy(this, {
+            get: (target, prop, receiver) => {
+                if (prop in target) {
+                    const value = Reflect.get(target, prop, receiver);
+                    if (typeof value === 'function') {
+                        return value.bind(target);
+                    }
+                    return value;
+                }
+                if (target.prismaInstance && typeof prop === 'string') {
+                    const value = target.prismaInstance[prop];
+                    if (typeof value === 'function') {
+                        return value.bind(target.prismaInstance);
+                    }
+                    return value;
+                }
+                return Reflect.get(target, prop, receiver);
+            },
+        });
+    }
+    async initialize() {
+        const PrismaClientType = await loadPrismaClient();
+        this.prismaInstance = new PrismaClientType({
+            log: [{ emit: 'event', level: 'query' }],
+            ...globalPrismaOptions,
+        });
+    }
+    async onModuleInit() {
+        await this.initialize();
+        if (this.env.get('PRISMA_QUERY_LOG')) {
+            this.prismaInstance?.$on?.('query', async (e) => {
+                console.log(`${e.query} ${e.params}`);
+            });
+        }
+        return this.prismaInstance?.$connect?.();
+    }
+    onModuleDestroy() {
+        return this.prismaInstance?.$disconnect?.();
+    }
+    async withTransaction(fn, options) {
+        return this.prismaInstance?.$transaction?.(fn, options ?? {
+            maxWait: 20000,
+            timeout: 20000,
+        });
+    }
+    [Symbol.toPrimitive]() {
+        return this.prismaInstance;
+    }
+    toString() {
+        return '[PrismaService]';
+    }
+    get $connect() {
+        return this.prismaInstance?.$connect?.bind(this.prismaInstance);
+    }
+    get $disconnect() {
+        return this.prismaInstance?.$disconnect?.bind(this.prismaInstance);
+    }
+    get $transaction() {
+        return this.prismaInstance?.$transaction?.bind(this.prismaInstance);
+    }
+    get $on() {
+        return this.prismaInstance?.$on?.bind(this.prismaInstance);
+    }
+    [Symbol.for('nodejs.util.inspect.custom')]() {
+        return this.prismaInstance;
+    }
+};
+exports.PrismaService = PrismaService;
+exports.PrismaService = PrismaService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [env_service_1.EnvService])
+], PrismaService);

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

@@ -0,0 +1,44 @@
+import { Type } from '@nestjs/common';
+import { ListResponse } from '..';
+import { PaginationDto } from '../dtos/pagination.dto';
+import { IComparableId } from '../utils/interfaces/icomparable';
+import { List } from '../utils/list';
+import { EntityBase } from './entity.base';
+import { PrismaTransactionalClient } from './prisma-transactional-client';
+type RepositoryInclude<TEntity> = Omit<{
+    [K in keyof TEntity as TEntity[K] extends Function ? never : K]?: boolean | (TEntity[K] extends List<infer U> ? RepositoryInclude<U> : RepositoryInclude<TEntity[K]>);
+}, '_id' | '_action'>;
+interface RepositoryInitProps<TEntity extends EntityBase<TEntity>, TContext extends PrismaTransactionalClient> {
+    context: TContext;
+    modelName: Type<TEntity>;
+    transactionContext?: Type<TContext>;
+    include?: RepositoryInclude<TEntity>;
+}
+export declare abstract class RepositoryBase<TEntity extends EntityBase<TEntity>, TContext extends PrismaTransactionalClient = PrismaTransactionalClient, TModelKey extends keyof TContext = keyof TContext> {
+    protected _context: TContext;
+    private readonly _modelName;
+    private readonly _include?;
+    constructor({ context, modelName, include, }: RepositoryInitProps<TEntity, TContext>);
+    private listRelationEntities;
+    private listToRelationActionList;
+    private entityToPrisma;
+    private findManySchema;
+    private createEntity;
+    private orphanRemoval;
+    private getIdPropName;
+    private getInclude;
+    private getPropNameFromEntitySource;
+    private persistRelations;
+    protected context(transactionalClient?: TContext): TContext[TModelKey];
+    protected findById(id: IComparableId): Promise<TEntity | null>;
+    protected findFirst<T>(where: T): Promise<TEntity | null>;
+    protected findUnique<T>(where: T): Promise<TEntity | null>;
+    protected findMany<T>(where: T, pagination?: PaginationDto): Promise<TEntity[]>;
+    protected findManyAndCount<T>(where: T, pagination?: PaginationDto): Promise<ListResponse<TEntity>>;
+    protected saveChanges<TWhere = any>(entity: TEntity, updateWhere?: TWhere): Promise<TEntity>;
+    protected saveMany<TWhere = any>(entities: TEntity[], updateWhere?: TWhere): Promise<void>;
+    protected remove<TWhere = any>(where: TWhere, notCascadeEntityProps?: Array<keyof TEntity>, externalServices?: Promise<any>): Promise<any>;
+    protected removeMany<TWhere = any>(where: TWhere, notCascadeEntityProps?: Array<keyof TEntity>, externalServices?: Promise<any>): Promise<void>;
+    withTransaction(fn: (prisma: TContext) => Promise<any>): Promise<any>;
+}
+export {};

package/core/database/repository.base.js

@@ -0,0 +1,360 @@
+"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 list_1 = require("../utils/list");
+const entity_base_1 = require("./entity.base");
+const auto_mapping_list_1 = require("../mapping/auto-mapping-list");
+class RepositoryBase {
+    _context;
+    _modelName;
+    _include;
+    constructor({ context, modelName, include, }) {
+        this._context = context;
+        this._modelName = modelName;
+        this._include = include;
+    }
+    listRelationEntities(entity) {
+        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);
+                    relationEntities.push(...this.listRelationEntities(item));
+                });
+                list.toArray('updated').forEach((item) => {
+                    relationEntities.push(item);
+                    relationEntities.push(...this.listRelationEntities(item));
+                });
+            }
+            else if (entity[key] instanceof entity_base_1.EntityBase) {
+                relationEntities.push(entity[key]);
+                relationEntities.push(...this.listRelationEntities(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;
+                if (modelName) {
+                    list.toArray('removed').forEach((item) => {
+                        relationDeletes.push({
+                            modelName: (0, KlString_1.toCamelCase)(modelName),
+                            entityInstance,
+                            schema: { where: { id: item._id } },
+                            relations: [],
+                        });
+                    });
+                    list.toArray('added').forEach((item) => {
+                        relationCreates.push({
+                            modelName: (0, KlString_1.toCamelCase)(modelName),
+                            entityInstance,
+                            schema: {
+                                data: {
+                                    ...this.entityToPrisma(item),
+                                    [(0, KlString_1.toCamelCase)(parentModelName)]: {
+                                        connect: {
+                                            [this.getIdPropName(entity)]: entity[this.getIdPropName(entity)],
+                                        },
+                                    },
+                                },
+                            },
+                            relations: this.listRelationEntities(item),
+                        });
+                    });
+                    list.toArray('updated').forEach((item) => {
+                        relationUpdates.push({
+                            modelName: (0, KlString_1.toCamelCase)(modelName),
+                            entityInstance,
+                            schema: {
+                                where: { id: item._id },
+                                data: this.entityToPrisma(item),
+                            },
+                            relations: this.listRelationEntities(item),
+                        });
+                    });
+                }
+            }
+        });
+        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.getIdPropName(entity)]) {
+                        prismaSchema[key] = {
+                            connectOrCreate: {
+                                where: {
+                                    [this.getIdPropName(entity)]: entity[key][this.getIdPropName(entity)],
+                                },
+                                create: this.entityToPrisma(entity[key]),
+                            },
+                        };
+                    }
+                    else {
+                        prismaSchema[key] = {
+                            create: this.entityToPrisma(entity[key]),
+                        };
+                    }
+                }
+                else {
+                    prismaSchema[key] = {
+                        update: this.entityToPrisma(entity[key]),
+                    };
+                }
+            }
+            else {
+                prismaSchema[key] = entity[key];
+            }
+        });
+        return prismaSchema;
+    }
+    findManySchema(where, pagination) {
+        return {
+            include: this.getInclude(),
+            where,
+            orderBy: pagination?.generateOrderBy(),
+            skip: pagination?.skip(),
+            take: (pagination?.limit ?? 0) > 0 ? pagination?.limit : undefined,
+        };
+    }
+    createEntity(data, entityClass) {
+        const entity = new (entityClass || this._modelName)();
+        entity._action = entity_base_1.EntityActionType.update;
+        entity.automap(data);
+        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 });
+    }
+    getIdPropName(entity) {
+        return (Reflect.getMetadata('entity:id', entity ? entity.constructor.prototype : this._modelName.prototype) ?? 'id');
+    }
+    getInclude(include) {
+        include = include ?? this._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;
+    }
+    getPropNameFromEntitySource(source, entity) {
+        return Object.keys(source).find((key) => {
+            const propDefinitions = auto_mapping_list_1.AutoMappingList.getPropDefinitions(source.constructor, key);
+            if (propDefinitions) {
+                if (propDefinitions.type === entity.name) {
+                    return true;
+                }
+                else if (source[key] instanceof list_1.List) {
+                    const list = source[key];
+                    return list.entityType?.name === entity.name;
+                }
+            }
+            return false;
+        });
+    }
+    persistRelations(transaction, entity) {
+        const { relationCreates, relationUpdates, relationDeletes } = this.listToRelationActionList(entity);
+        return Promise.all([
+            ...relationCreates.map((relationCreate) => transaction[relationCreate.modelName]
+                .create(relationCreate.schema)
+                .then((response) => {
+                return Promise.all(relationCreate.relations.map((relation) => {
+                    const relationPropName = this.getPropNameFromEntitySource(relation, relationCreate.entityInstance);
+                    if (!relationPropName) {
+                        throw new Error(`Propname not found for relation entity ${relation.constructor.name} on entity ${relationCreate.entityInstance.constructor.name}`);
+                    }
+                    const relationEntity = this.createEntity(response, relationCreate.entityInstance);
+                    relationEntity._action = entity_base_1.EntityActionType.create;
+                    relation[relationPropName] = relationEntity;
+                    return transaction[(0, KlString_1.toCamelCase)(relation.constructor.name)]
+                        .create({
+                        data: this.entityToPrisma(relation),
+                    })
+                        .then((response) => {
+                        entity[this.getIdPropName(relation)] =
+                            response[this.getIdPropName(relation)];
+                        return this.persistRelations(transaction, relation);
+                    });
+                }));
+            })),
+            ...relationUpdates.map((relation) => transaction[relation.modelName].update(relation.schema)),
+            ...relationDeletes.map((relation) => this.removeMany(relation.schema)),
+        ]);
+    }
+    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) {
+        return this.context()
+            .findFirst({
+            include: this.getInclude(),
+            where: { [this.getIdPropName()]: id },
+        })
+            .then((response) => {
+            if (response) {
+                return this.createEntity(response);
+            }
+            return null;
+        });
+    }
+    async findFirst(where) {
+        return this.context()
+            .findFirst({
+            include: this.getInclude(),
+            where,
+        })
+            .then((response) => {
+            if (response) {
+                return this.createEntity(response);
+            }
+            return null;
+        });
+    }
+    async findUnique(where) {
+        return this.context()
+            .findUnique({
+            include: this.getInclude(),
+            where,
+        })
+            .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_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,
+                include: this.getInclude(),
+            })
+                .then((response) => {
+                entity[this.getIdPropName()] = response[this.getIdPropName()];
+                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,
+            })
+                .then(() => 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

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