@mondart/nestjs-common-module 1.1.72 → 2.0.0

package/dist/index.d.ts

@@ -1,6 +1,5 @@
 import 'reflect-metadata';
 export * from './constants';
-export * from './controllers';
 export * from './decorators';
 export * from './dto';
 export * from './entities';
@@ -10,6 +9,5 @@ export * from './helpers';
 export * from './interceptors';
 export * from './interfaces';
 export * from './lib';
-export * from './services';
 export * from './strategy';
 export * from './validators';

package/dist/index.js

@@ -16,7 +16,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 require("reflect-metadata");
 __exportStar(require("./constants"), exports);
-__exportStar(require("./controllers"), exports);
 __exportStar(require("./decorators"), exports);
 __exportStar(require("./dto"), exports);
 __exportStar(require("./entities"), exports);
@@ -26,6 +25,5 @@ __exportStar(require("./helpers"), exports);
 __exportStar(require("./interceptors"), exports);
 __exportStar(require("./interfaces"), exports);
 __exportStar(require("./lib"), exports);
-__exportStar(require("./services"), exports);
 __exportStar(require("./strategy"), exports);
 __exportStar(require("./validators"), exports);

package/dist/interfaces/index.d.ts

@@ -1,4 +1,3 @@
-export * from './crud-service.option';
 export * from './custom-validation-arguments.interface';
 export * from './get-agent.interface';
 export * from './get-user.interface';

package/dist/interfaces/index.js

@@ -14,7 +14,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./crud-service.option"), exports);
 __exportStar(require("./custom-validation-arguments.interface"), exports);
 __exportStar(require("./get-agent.interface"), exports);
 __exportStar(require("./get-user.interface"), exports);

package/dist/lib/core-crud/core-crud.controller.d.ts

@@ -0,0 +1,24 @@
+import { PaginateConfig } from 'nestjs-paginate/lib/paginate';
+import { CoreCrudService } from './core-crud.service';
+import { CoreBaseServiceOption, CoreFindAllWithPaginationServiceOption, CoreFindOneByIdServiceOption, CoreUpdateServiceOption } from './crud-service-options.interface';
+import { BaseModelEntity } from '../../entities';
+import { BaseResponse, IdDto, SuccessResponse } from '../../dto';
+import { PaginationQueryCustom } from '../../interfaces';
+export declare class CoreCrudController<T extends BaseModelEntity, CreateDto, UpdateDto, ResponseDto extends BaseResponse> {
+    protected readonly coreService: CoreCrudService<T, CreateDto, UpdateDto>;
+    protected readonly responseDto: {
+        new (init?: Partial<BaseResponse>): ResponseDto;
+    };
+    static responseDto: {
+        new (init?: Partial<BaseResponse>): any;
+    };
+    protected constructor(coreService: CoreCrudService<T, CreateDto, UpdateDto>, responseDto: {
+        new (init?: Partial<BaseResponse>): ResponseDto;
+    });
+    findAllWithPagination(query: PaginationQueryCustom, paginateConfig: PaginateConfig<T>, options?: CoreFindAllWithPaginationServiceOption<T>, ...args: any[]): Promise<SuccessResponse<ResponseDto[]>>;
+    findOneById(id: number, options?: CoreFindOneByIdServiceOption<T>, ...args: any[]): Promise<SuccessResponse<ResponseDto>>;
+    create(createDto: CreateDto, options?: CoreBaseServiceOption, ...args: any[]): Promise<SuccessResponse<ResponseDto>>;
+    update({ id }: IdDto, updateDto: UpdateDto, options?: CoreUpdateServiceOption<T>, ...args: any[]): Promise<SuccessResponse<ResponseDto>>;
+    deleteById({ id }: IdDto, options?: CoreBaseServiceOption, ...args: any[]): Promise<SuccessResponse<void>>;
+    softDeleteById({ id }: IdDto, options?: CoreBaseServiceOption, ...args: any[]): Promise<SuccessResponse<void>>;
+}

package/dist/lib/core-crud/core-crud.controller.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CoreCrudController = void 0;
+const common_1 = require("@nestjs/common");
+const dto_1 = require("../../dto");
+const enums_1 = require("../../enums");
+class CoreCrudController {
+    constructor(coreService, responseDto) {
+        this.coreService = coreService;
+        this.responseDto = responseDto;
+        CoreCrudController.responseDto = responseDto;
+    }
+    async findAllWithPagination(query, paginateConfig, options, ...args) {
+        const response = await this.coreService.findAllWithPagination(query, paginateConfig, options);
+        if (!response)
+            throw new common_1.NotFoundException(enums_1.SharedMessages.FETCH_FAILED);
+        const serializedData = response.data.map((item) => new this.responseDto(item));
+        return new dto_1.SuccessResponse(serializedData, enums_1.SharedMessages.SUCCESSFUL, common_1.HttpStatus.OK, { ...response.meta, links: response.links });
+    }
+    async findOneById(id, options, ...args) {
+        const response = await this.coreService.findOneById(id, options);
+        if (!response)
+            throw new common_1.NotFoundException(enums_1.SharedMessages.RESOURCE_NOT_FOUND);
+        return new dto_1.SuccessResponse(new this.responseDto(response), enums_1.SharedMessages.SUCCESSFUL, common_1.HttpStatus.OK);
+    }
+    async create(createDto, options, ...args) {
+        const response = await this.coreService.create(createDto, options);
+        if (!response)
+            throw new common_1.BadRequestException(enums_1.SharedMessages.CREATE_FAILED);
+        return new dto_1.SuccessResponse(new this.responseDto(response), enums_1.SharedMessages.SUCCESSFUL, common_1.HttpStatus.CREATED);
+    }
+    async update({ id }, updateDto, options, ...args) {
+        const response = await this.coreService.update(id, updateDto, options);
+        if (!response)
+            throw new common_1.BadRequestException(enums_1.SharedMessages.UPDATE_FAILED);
+        const foundItem = await this.coreService.findOneById(id, options);
+        return new dto_1.SuccessResponse(new this.responseDto(foundItem), enums_1.SharedMessages.SUCCESSFUL, common_1.HttpStatus.OK);
+    }
+    async deleteById({ id }, options, ...args) {
+        const result = await this.coreService.deleteById(id, options);
+        if (!result)
+            throw new common_1.BadRequestException(enums_1.SharedMessages.DELETE_FAILED);
+        return new dto_1.SuccessResponse(undefined, enums_1.SharedMessages.SUCCESSFUL, common_1.HttpStatus.OK);
+    }
+    async softDeleteById({ id }, options, ...args) {
+        const result = await this.coreService.softDeleteById(id, options);
+        if (!result)
+            throw new common_1.BadRequestException(enums_1.SharedMessages.DELETE_FAILED);
+        return new dto_1.SuccessResponse(undefined, enums_1.SharedMessages.SUCCESSFUL, common_1.HttpStatus.OK);
+    }
+}
+exports.CoreCrudController = CoreCrudController;

package/dist/lib/core-crud/core-crud.service.d.ts

@@ -0,0 +1,36 @@
+import { DeepPartial, DeleteResult, FindManyOptions, FindOptionsWhere, Repository, UpdateResult } from 'typeorm';
+import { QueryDeepPartialEntity } from 'typeorm/query-builder/QueryPartialEntity';
+import { Paginated } from 'nestjs-paginate';
+import { PaginateConfig } from 'nestjs-paginate/lib/paginate';
+import { InsertResult } from 'typeorm/query-builder/result/InsertResult';
+import { UpsertOptions } from 'typeorm/repository/UpsertOptions';
+import { CoreBaseServiceOption, CoreFindAllServiceOption, CoreFindAllWithPaginationServiceOption, CoreFindOneByIdServiceOption, CoreFindOneServiceOption, CoreUpdateServiceOption } from './crud-service-options.interface';
+import { BaseModelEntity } from '../../entities';
+import { PaginationQueryCustom } from '../../interfaces';
+export declare abstract class CoreCrudService<T extends BaseModelEntity, CreateDto, UpdateDto> {
+    protected readonly repository: Repository<T>;
+    private readonly relationsPath;
+    protected constructor(repository: Repository<T>);
+    create(createDto: CreateDto, options?: CoreBaseServiceOption): Promise<T>;
+    update(id: number, updateDto: Partial<UpdateDto> | DeepPartial<T> | QueryDeepPartialEntity<T>, options?: CoreUpdateServiceOption<T>): Promise<UpdateResult>;
+    updateMany(query: FindManyOptions<T>, updateDto: Partial<UpdateDto> | DeepPartial<T> | QueryDeepPartialEntity<T>, options?: CoreUpdateServiceOption<T>): Promise<void>;
+    upsert(upsertDto: QueryDeepPartialEntity<T>, upsertOptions: UpsertOptions<T>, options?: CoreBaseServiceOption): Promise<InsertResult>;
+    findAllWithPagination(query: PaginationQueryCustom, paginateConfig: PaginateConfig<T>, options?: CoreFindAllWithPaginationServiceOption<T>): Promise<Paginated<T>>;
+    findAll(query: FindManyOptions<T>, options?: CoreFindAllServiceOption): Promise<T[]>;
+    findOneById(id: number, options?: CoreFindOneByIdServiceOption<T>): Promise<T>;
+    findOne(query: FindManyOptions<T>, options?: CoreFindOneServiceOption): Promise<T>;
+    isExists(query: FindManyOptions<T>, options?: CoreBaseServiceOption): Promise<boolean>;
+    count(query: FindManyOptions<T>, options?: CoreBaseServiceOption): Promise<number>;
+    softDelete(query: FindOptionsWhere<T>, options?: CoreBaseServiceOption): Promise<UpdateResult>;
+    softDeleteById(id: string | string[] | number | number[], options?: CoreBaseServiceOption): Promise<UpdateResult>;
+    restore(query: FindOptionsWhere<T>, options?: CoreBaseServiceOption): Promise<UpdateResult>;
+    restoreById(id: string | string[] | number | number[], options?: CoreBaseServiceOption): Promise<UpdateResult>;
+    delete(query: FindOptionsWhere<T>, options?: CoreBaseServiceOption): Promise<DeleteResult>;
+    deleteById(id: string | string[] | number | number[], options?: CoreBaseServiceOption): Promise<DeleteResult>;
+    private relatedPropertyTransformer;
+    private whereQueryTransformer;
+    private isObject;
+    private isArray;
+    private isArrayOfObjectId;
+    private isArrayOfNumbers;
+}

package/dist/{services → lib/core-crud}/core-crud.service.js

@@ -4,8 +4,8 @@ exports.CoreCrudService = void 0;
 const typeorm_1 = require("typeorm");
 const common_1 = require("@nestjs/common");
 const nestjs_paginate_1 = require("nestjs-paginate");
-const enums_1 = require("../enums");
-const helpers_1 = require("../helpers");
+const helpers_1 = require("../../helpers");
+const enums_1 = require("../../enums");
 class CoreCrudService {
     constructor(repository) {
         this.repository = repository;
@@ -22,10 +22,104 @@ class CoreCrudService {
             return await this.repository.save(entity);
         }
     }
+    async update(id, updateDto, options) {
+        updateDto = this.relatedPropertyTransformer(updateDto);
+        if (!options?.entityManager) {
+            const selectFields = Object.keys(updateDto);
+            const fetchedItem = await this.repository.findOne({
+                where: { id },
+                select: ['id', ...selectFields],
+                relations: options?.relations
+                    ? options?.relations
+                    : options?.enableFirstLevelRelation
+                        ? this.relationsPath
+                        : undefined,
+            });
+            if (!fetchedItem)
+                throw new common_1.NotFoundException(helpers_1.MessageFormatter.replace(enums_1.SharedMessages.RESOURCE_NOT_FOUND, `${helpers_1.ConvertStringCaseHelper.toKebabCase(this.repository.metadata?.tableName)}`));
+            const merged = this.repository.merge(fetchedItem, updateDto);
+            await this.repository.save(merged);
+            return {
+                generatedMaps: [],
+                raw: merged,
+                affected: 1,
+            };
+        }
+        else {
+            const selectFields = Object.keys(updateDto);
+            const fetchedItem = await options?.entityManager.findOne(this.repository.target, {
+                where: { id },
+                select: ['id', ...selectFields],
+                relations: options?.relations
+                    ? options?.relations
+                    : options?.enableFirstLevelRelation
+                        ? this.relationsPath
+                        : undefined,
+            });
+            if (!fetchedItem)
+                throw new common_1.NotFoundException(helpers_1.MessageFormatter.replace(enums_1.SharedMessages.RESOURCE_NOT_FOUND, `${helpers_1.ConvertStringCaseHelper.toKebabCase(this.repository.metadata?.tableName)}`));
+            const merged = options?.entityManager.merge(this.repository.target, fetchedItem, updateDto);
+            await options?.entityManager.save(merged);
+            return {
+                generatedMaps: [],
+                raw: merged,
+                affected: 1,
+            };
+        }
+    }
+    async updateMany(query, updateDto, options) {
+        const foundEntities = await this.findAll(query, options);
+        for await (const entity of foundEntities) {
+            await this.update(entity.id, updateDto, options).catch((err) => console.log(err));
+        }
+    }
+    async upsert(upsertDto, upsertOptions, options) {
+        try {
+            upsertDto = this.relatedPropertyTransformer(upsertDto);
+            let conflictPaths = [];
+            let findWhereQuery = {};
+            if (this.isArray(upsertOptions.conflictPaths)) {
+                conflictPaths = upsertOptions.conflictPaths ?? [];
+            }
+            else {
+                conflictPaths = Object.keys(upsertOptions.conflictPaths);
+            }
+            conflictPaths.map((path) => {
+                findWhereQuery = {
+                    ...findWhereQuery,
+                    [path]: upsertDto[path],
+                };
+            });
+            const formatedQuery = this.whereQueryTransformer(findWhereQuery) ?? undefined;
+            if (!options?.entityManager) {
+                const existEntity = await this.repository.findOne({
+                    where: formatedQuery,
+                    select: ['id'],
+                });
+                return await this.repository.upsert({ id: existEntity.id, ...upsertDto }, upsertOptions);
+            }
+            else {
+                const existEntity = await options?.entityManager.findOne(this.repository.target, {
+                    where: formatedQuery,
+                    select: ['id'],
+                });
+                return await options?.entityManager.upsert(this.repository.target, { id: existEntity.id, ...upsertDto }, upsertOptions);
+            }
+        }
+        catch (error) {
+            throw new common_1.BadRequestException(helpers_1.MessageFormatter.replace(enums_1.SharedMessages.UPSERT_FAILED, error));
+        }
+    }
     async findAllWithPagination(query, paginateConfig, options) {
-        return await (0, nestjs_paginate_1.paginate)(query, this.repository, {
+        return await (0, nestjs_paginate_1.paginate)(query, options?.selectQueryBuilder
+            ? options.selectQueryBuilder
+            : this.repository, {
             ...paginateConfig,
-            relations: options?.relations ? options?.relations : this.relationsPath,
+            relations: options?.relations
+                ? options?.relations
+                : options?.enableFirstLevelRelation
+                    ? this.relationsPath
+                    : undefined,
         });
     }
     async findAll(query, options) {
@@ -33,15 +127,19 @@ class CoreCrudService {
         query.where = this.whereQueryTransformer(query.where) ?? undefined;
         if (!options?.entityManager)
             result = await this.repository.find({
-                relations: options?.relations ? options?.relations : this.relationsPath,
+                relations: options?.enableFirstLevelRelation
+                    ? this.relationsPath
+                    : undefined,
                 ...query,
             });
         else
             result = await options.entityManager.find(this.repository.target, {
-                relations: options?.relations ? options?.relations : this.relationsPath,
+                relations: options?.enableFirstLevelRelation
+                    ? this.relationsPath
+                    : undefined,
                 ...query,
             });
-        if (options?.existsCheck && !result) {
+        if (options?.existsCheck && !result.length) {
             throw new common_1.NotFoundException(helpers_1.MessageFormatter.replace(enums_1.SharedMessages.RESOURCE_NOT_FOUND, `${helpers_1.ConvertStringCaseHelper.toKebabCase(this.repository.metadata?.tableName)}`));
         }
         return result;
@@ -53,7 +151,11 @@ class CoreCrudService {
                 where: {
                     id,
                 },
-                relations: options?.relations ? options?.relations : this.relationsPath,
+                relations: options?.relations
+                    ? options?.relations
+                    : options?.enableFirstLevelRelation
+                        ? this.relationsPath
+                        : undefined,
             });
         }
         else {
@@ -61,7 +163,11 @@ class CoreCrudService {
                 where: {
                     id,
                 },
-                relations: options?.relations ? options?.relations : this.relationsPath,
+                relations: options?.relations
+                    ? options?.relations
+                    : options?.enableFirstLevelRelation
+                        ? this.relationsPath
+                        : undefined,
             });
         }
         if (options?.existsCheck && !result) {
@@ -74,13 +180,17 @@ class CoreCrudService {
         query.where = this.whereQueryTransformer(query.where) ?? undefined;
         if (options?.entityManager) {
             result = await options?.entityManager.findOne(this.repository.target, {
-                relations: options?.relations ? options?.relations : this.relationsPath,
+                relations: options?.enableFirstLevelRelation
+                    ? this.relationsPath
+                    : undefined,
                 ...query,
             });
         }
         else {
             result = await this.repository.findOne({
-                relations: options?.relations ? options?.relations : this.relationsPath,
+                relations: options?.enableFirstLevelRelation
+                    ? this.relationsPath
+                    : undefined,
                 ...query,
             });
         }
@@ -93,16 +203,10 @@ class CoreCrudService {
         let result;
         query.where = this.whereQueryTransformer(query.where) ?? undefined;
         if (options?.entityManager) {
-            result = await options?.entityManager.exists(this.repository.target, {
-                relations: options?.relations ? options?.relations : this.relationsPath,
-                ...query,
-            });
+            result = await options?.entityManager.exists(this.repository.target, query);
         }
         else {
-            result = await this.repository.exists({
-                relations: options?.relations ? options?.relations : this.relationsPath,
-                ...query,
-            });
+            result = await this.repository.exists(query);
         }
         return result;
     }
@@ -110,95 +214,13 @@ class CoreCrudService {
         let result;
         query.where = this.whereQueryTransformer(query.where) ?? undefined;
         if (options?.entityManager) {
-            result = await options?.entityManager.count(this.repository.target, {
-                relations: options?.relations ? options?.relations : this.relationsPath,
-                ...query,
-            });
+            result = await options?.entityManager.count(this.repository.target, query);
         }
         else {
-            result = await this.repository.count({
-                relations: options?.relations ? options?.relations : this.relationsPath,
-                ...query,
-            });
+            result = await this.repository.count(query);
         }
         return result;
     }
-    async upsert(upsertDto, upsertOptions, options) {
-        try {
-            upsertDto = this.relatedPropertyTransformer(upsertDto);
-            let conflictPaths = [];
-            let findWhereQuery = {};
-            if (this.isArray(upsertOptions.conflictPaths)) {
-                conflictPaths = upsertOptions.conflictPaths ?? [];
-            }
-            else {
-                conflictPaths = Object.keys(upsertOptions.conflictPaths);
-            }
-            conflictPaths.map((path) => {
-                findWhereQuery = {
-                    ...findWhereQuery,
-                    [path]: upsertDto[path],
-                };
-            });
-            const formatedQuery = this.whereQueryTransformer(findWhereQuery) ?? undefined;
-            if (!options?.entityManager) {
-                const existEntity = await this.repository.findOne({
-                    where: formatedQuery,
-                    select: ['id'],
-                });
-                return await this.repository.upsert({ id: existEntity.id, ...upsertDto }, upsertOptions);
-            }
-            else {
-                const existEntity = await options?.entityManager.findOne(this.repository.target, {
-                    where: formatedQuery,
-                    select: ['id'],
-                });
-                return await options?.entityManager.upsert(this.repository.target, { id: existEntity.id, ...upsertDto }, upsertOptions);
-            }
-        }
-        catch (error) {
-            throw new common_1.BadRequestException(helpers_1.MessageFormatter.replace(enums_1.SharedMessages.UPSERT_FAILED, error));
-        }
-    }
-    async update(id, updateDto, options) {
-        updateDto = this.relatedPropertyTransformer(updateDto);
-        if (!options?.entityManager) {
-            const selectFields = Object.keys(updateDto);
-            const fetchedItem = await this.repository.findOne({
-                where: { id },
-                select: ['id', ...selectFields],
-                relations: options?.relations ? options?.relations : this.relationsPath,
-            });
-            if (!fetchedItem)
-                throw new common_1.NotFoundException(helpers_1.MessageFormatter.replace(enums_1.SharedMessages.RESOURCE_NOT_FOUND, `${helpers_1.ConvertStringCaseHelper.toKebabCase(this.repository.metadata?.tableName)}`));
-            const merged = this.repository.merge(fetchedItem, updateDto);
-            await this.repository.save(merged);
-            return {
-                generatedMaps: [],
-                raw: merged,
-                affected: 1,
-            };
-        }
-        else {
-            const selectFields = Object.keys(updateDto);
-            const fetchedItem = await options?.entityManager.findOne(this.repository.target, {
-                where: { id },
-                select: ['id', ...selectFields],
-                relations: options?.relations
-                    ? options?.relations
-                    : this.relationsPath,
-            });
-            if (!fetchedItem)
-                throw new common_1.NotFoundException(helpers_1.MessageFormatter.replace(enums_1.SharedMessages.RESOURCE_NOT_FOUND, `${helpers_1.ConvertStringCaseHelper.toKebabCase(this.repository.metadata?.tableName)}`));
-            const merged = options?.entityManager.merge(this.repository.target, fetchedItem, updateDto);
-            await options?.entityManager.save(merged);
-            return {
-                generatedMaps: [],
-                raw: merged,
-                affected: 1,
-            };
-        }
-    }
     async softDelete(query, options) {
         const formatedQuery = this.whereQueryTransformer(query) ?? undefined;
         if (options?.entityManager) {

package/dist/lib/core-crud/crud-service-options.interface.d.ts

@@ -0,0 +1,27 @@
+import { EntityManager, SelectQueryBuilder } from 'typeorm';
+import { FindOptionsRelations } from 'typeorm/find-options/FindOptionsRelations';
+export interface CoreFindOneServiceOption extends CoreBaseServiceOption {
+    enableFirstLevelRelation?: boolean;
+    existsCheck?: boolean;
+}
+export interface CoreFindOneByIdServiceOption<T> extends CoreBaseServiceOption {
+    enableFirstLevelRelation?: boolean;
+    relations?: FindOptionsRelations<T>;
+    existsCheck?: boolean;
+}
+export interface CoreFindAllServiceOption extends CoreBaseServiceOption {
+    enableFirstLevelRelation?: boolean;
+    existsCheck?: boolean;
+}
+export interface CoreFindAllWithPaginationServiceOption<T> {
+    selectQueryBuilder?: SelectQueryBuilder<T>;
+    relations?: FindOptionsRelations<T>;
+    enableFirstLevelRelation?: boolean;
+}
+export interface CoreUpdateServiceOption<T> extends CoreBaseServiceOption {
+    relations?: FindOptionsRelations<T>;
+    enableFirstLevelRelation?: boolean;
+}
+export interface CoreBaseServiceOption {
+    entityManager?: EntityManager;
+}

package/dist/lib/core-crud/crud-service-options.interface.js

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

package/dist/lib/core-crud/index.d.ts

@@ -0,0 +1,3 @@
+export * from './core-crud.controller';
+export * from './core-crud.service';
+export * from './crud-service-options.interface';

package/dist/{controllers → lib/core-crud}/index.js

@@ -15,3 +15,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./core-crud.controller"), exports);
+__exportStar(require("./core-crud.service"), exports);
+__exportStar(require("./crud-service-options.interface"), exports);

package/dist/lib/index.d.ts

@@ -2,3 +2,4 @@ export * from './kafka';
 export * from './saga';
 export * from './caching';
 export * from './keycloak';
+export * from './core-crud';

package/dist/lib/index.js

@@ -18,3 +18,4 @@ __exportStar(require("./kafka"), exports);
 __exportStar(require("./saga"), exports);
 __exportStar(require("./caching"), exports);
 __exportStar(require("./keycloak"), exports);
+__exportStar(require("./core-crud"), exports);