@koalarx/nest 3.0.3 → 3.0.4

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;
+}

package/core/dtos/pagination.dto.js

@@ -0,0 +1,49 @@
+"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.PaginationDto = void 0;
+const query_params_1 = require("../constants/query-params");
+const auto_mapping_decorator_1 = require("../mapping/auto-mapping.decorator");
+class PaginationDto {
+    page = 0;
+    limit = query_params_1.QUERY_FILTER_PARAMS.limit;
+    orderBy = '';
+    direction = 'asc';
+    skip() {
+        return (this.limit ?? 0) * (this.page ?? query_params_1.QUERY_FILTER_PARAMS.page);
+    }
+    generateOrderBy() {
+        if (this.orderBy) {
+            const orderByField = this.orderBy.split('.');
+            return orderByField.reduceRight((acc, item, index) => ({
+                [item]: index === orderByField.length - 1 ? this.direction : acc,
+            }), {});
+        }
+        return undefined;
+    }
+}
+exports.PaginationDto = PaginationDto;
+__decorate([
+    (0, auto_mapping_decorator_1.AutoMap)(),
+    __metadata("design:type", Number)
+], PaginationDto.prototype, "page", void 0);
+__decorate([
+    (0, auto_mapping_decorator_1.AutoMap)(),
+    __metadata("design:type", Number)
+], PaginationDto.prototype, "limit", void 0);
+__decorate([
+    (0, auto_mapping_decorator_1.AutoMap)(),
+    __metadata("design:type", String)
+], PaginationDto.prototype, "orderBy", void 0);
+__decorate([
+    (0, auto_mapping_decorator_1.AutoMap)(),
+    __metadata("design:type", String)
+], PaginationDto.prototype, "direction", void 0);

package/core/errors/bad-request.error.d.ts

@@ -0,0 +1,5 @@
+import { ErrorBase } from './error.base';
+import { UseCaseError } from './use-case-error';
+export declare class BadRequestError extends ErrorBase implements UseCaseError {
+    constructor(message?: string, data?: any);
+}

package/core/errors/bad-request.error.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BadRequestError = void 0;
+const error_base_1 = require("./error.base");
+class BadRequestError extends error_base_1.ErrorBase {
+    constructor(message, data) {
+        super(message ?? 'Bad Request', data);
+    }
+}
+exports.BadRequestError = BadRequestError;

package/core/errors/conflict.error.d.ts

@@ -0,0 +1,4 @@
+import { ErrorBase } from './error.base';
+export declare class ConflictError extends ErrorBase {
+    constructor(identifier: string, data?: any);
+}

package/core/errors/conflict.error.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConflictError = void 0;
+const error_base_1 = require("./error.base");
+class ConflictError extends error_base_1.ErrorBase {
+    constructor(identifier, data) {
+        super(`O registro ${identifier} já existe.`, data);
+    }
+}
+exports.ConflictError = ConflictError;

package/core/errors/error.base.d.ts

@@ -0,0 +1,4 @@
+export declare abstract class ErrorBase extends Error {
+    readonly data?: any | undefined;
+    constructor(message: string, data?: any | undefined);
+}

package/core/errors/error.base.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ErrorBase = void 0;
+class ErrorBase extends Error {
+    data;
+    constructor(message, data) {
+        super(message);
+        this.data = data;
+    }
+}
+exports.ErrorBase = ErrorBase;

package/core/errors/no-content.error.d.ts

@@ -0,0 +1,5 @@
+import { ErrorBase } from './error.base';
+import { UseCaseError } from './use-case-error';
+export declare class NoContentError extends ErrorBase implements UseCaseError {
+    constructor(message?: string, data?: any);
+}

package/core/errors/no-content.error.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NoContentError = void 0;
+const error_base_1 = require("./error.base");
+class NoContentError extends error_base_1.ErrorBase {
+    constructor(message, data) {
+        super(message ?? 'No Content', data);
+    }
+}
+exports.NoContentError = NoContentError;

package/core/errors/not-allowed.error.d.ts

@@ -0,0 +1,5 @@
+import { ErrorBase } from './error.base';
+import { UseCaseError } from './use-case-error';
+export declare class NotAllowedError extends ErrorBase implements UseCaseError {
+    constructor(message?: string, data?: any);
+}

package/core/errors/not-allowed.error.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotAllowedError = void 0;
+const error_base_1 = require("./error.base");
+class NotAllowedError extends error_base_1.ErrorBase {
+    constructor(message, data) {
+        super(message ?? 'Você não tem permissão para utilizar esse recurso.', data);
+    }
+}
+exports.NotAllowedError = NotAllowedError;

package/core/errors/resource-not-found.error.d.ts

@@ -0,0 +1,5 @@
+import { ErrorBase } from './error.base';
+import { UseCaseError } from './use-case-error';
+export declare class ResourceNotFoundError extends ErrorBase implements UseCaseError {
+    constructor(name?: string, data?: any);
+}

package/core/errors/resource-not-found.error.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResourceNotFoundError = void 0;
+const error_base_1 = require("./error.base");
+class ResourceNotFoundError extends error_base_1.ErrorBase {
+    constructor(name = 'Recurso', data) {
+        super(`${name} não encontrado(a).`, data);
+    }
+}
+exports.ResourceNotFoundError = ResourceNotFoundError;

package/{src/core/errors/use-case-error.ts → core/errors/use-case-error.d.ts}

@@ -1,3 +1,3 @@
 export interface UseCaseError {
-  message: string
+    message: string;
 }

package/core/errors/use-case-error.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/core/errors/user-already-exist.error.d.ts

@@ -0,0 +1,4 @@
+import { ErrorBase } from './error.base';
+export declare class UserAlreadyExist extends ErrorBase {
+    constructor(identifier: string, data?: any);
+}

package/core/errors/user-already-exist.error.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserAlreadyExist = void 0;
+const error_base_1 = require("./error.base");
+class UserAlreadyExist extends error_base_1.ErrorBase {
+    constructor(identifier, data) {
+        super(`User ${identifier} already exists`, data);
+    }
+}
+exports.UserAlreadyExist = UserAlreadyExist;

package/core/errors/wrong-credentials.error.d.ts

@@ -0,0 +1,4 @@
+import { ErrorBase } from './error.base';
+export declare class WrongCredentialsError extends ErrorBase {
+    constructor(data?: any);
+}

package/core/errors/wrong-credentials.error.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WrongCredentialsError = void 0;
+const error_base_1 = require("./error.base");
+class WrongCredentialsError extends error_base_1.ErrorBase {
+    constructor(data) {
+        super('Credentials are not valid', data);
+    }
+}
+exports.WrongCredentialsError = WrongCredentialsError;

package/core/health-check/health-check.controller.d.ts

@@ -0,0 +1,5 @@
+export declare class HealthCheckController {
+    healthCheck(): {
+        status: string;
+    };
+}

package/core/health-check/health-check.controller.js

@@ -0,0 +1,32 @@
+"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.HealthCheckController = void 0;
+const is_public_decorator_1 = require("../../decorators/is-public.decorator");
+const common_1 = require("@nestjs/common");
+const swagger_1 = require("@nestjs/swagger");
+let HealthCheckController = class HealthCheckController {
+    healthCheck() {
+        return { status: 'ok' };
+    }
+};
+exports.HealthCheckController = HealthCheckController;
+__decorate([
+    (0, common_1.Get)(),
+    (0, is_public_decorator_1.IsPublic)(),
+    (0, swagger_1.ApiExcludeEndpoint)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], HealthCheckController.prototype, "healthCheck", null);
+exports.HealthCheckController = HealthCheckController = __decorate([
+    (0, common_1.Controller)('health')
+], HealthCheckController);

package/core/health-check/health-check.module.d.ts

@@ -0,0 +1,2 @@
+export declare class HealthCheckModule {
+}

package/core/health-check/health-check.module.js

@@ -0,0 +1,19 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HealthCheckModule = void 0;
+const common_1 = require("@nestjs/common");
+const health_check_controller_1 = require("./health-check.controller");
+let HealthCheckModule = class HealthCheckModule {
+};
+exports.HealthCheckModule = HealthCheckModule;
+exports.HealthCheckModule = HealthCheckModule = __decorate([
+    (0, common_1.Module)({
+        controllers: [health_check_controller_1.HealthCheckController],
+    })
+], HealthCheckModule);

package/core/index.d.ts

@@ -0,0 +1,18 @@
+export type FileType = Express.Multer.File;
+export type Optional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+export type Overwrite<T, U> = Pick<T, Exclude<keyof T, keyof U>> & U;
+export type CreatedRegister<TypeId = string> = {
+    id: TypeId;
+};
+export type ListResponse<TItem = any> = {
+    items: Array<TItem>;
+    count: number;
+};
+export type FileResponse = {
+    filename: string;
+    type: string;
+    base64: string;
+};
+export type QueryDirectionType = 'asc' | 'desc';
+export { setPrismaClient } from './database/prisma-resolver';
+export { setPrismaClientOptions } from './database/prisma.service';