@flusys/nestjs-shared 1.1.0-beta → 1.2.0-rc.1

package/fesm/classes/api-service.class.js

@@ -11,130 +11,129 @@ function _define_property(obj, key, value) {
     }
     return obj;
 }
-import { ErrorHandler } from '../utils/error-handler.util';
-import { Logger, NotFoundException } from '@nestjs/common';
-import { In } from 'typeorm';
-/** Generic API service with CRUD operations and caching support */ export class ApiService {
+function _ts_decorate(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;
+}
+function _ts_metadata(k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+import { Injectable, InternalServerErrorException, NotFoundException, Scope } from '@nestjs/common';
+import { EntityTarget, In } from 'typeorm';
+import { ERROR_MESSAGES, SYSTEM_MESSAGES } from '../constants';
+import { LogAction } from '../decorators/log-action.decorator';
+import { DeleteDto } from '../dtos';
+import { IDataSourceProvider } from '../interfaces';
+import { UtilsService } from '../modules/utils/utils.service';
+import { HybridCache } from './hybrid-cache.class';
+export class ApiService {
+    resolveEntity() {
+        return this._entity;
+    }
+    getDataSourceProvider() {
+        return this._dataSourceProvider;
+    }
+    async ensureDataSourceRepository() {
+        if (!this.repositoryInitialized) {
+            const entity = this.resolveEntity();
+            const provider = this.getDataSourceProvider();
+            this.repository = await provider.getRepository(entity);
+            this.repositoryInitialized = true;
+        }
+    }
+    async resolveRepositories(entities) {
+        const provider = this.getDataSourceProvider();
+        const repositories = [];
+        for (const entity of entities){
+            repositories.push(await provider.getRepository(entity));
+        }
+        return repositories;
+    }
+    async getDataSourceForService() {
+        return this.getDataSourceProvider().getDataSource();
+    }
     async insert(dto, user) {
-        await this.ensureRepositoryInitialized();
-        const qr = this.repository.manager.connection.createQueryRunner();
-        await qr.connect();
-        await qr.startTransaction();
-        try {
+        return this.executeInTransaction('insert', async (qr)=>{
             await this.beforeInsertOperation(dto, user, qr);
             const entities = await this.convertRequestDtoToEntity(dto, user);
             const saved = await qr.manager.save(this.repository.target, entities);
-            await this.afterInsertOperation(saved, user, qr);
-            await qr.commitTransaction();
-            if (this.isCacheable) await Promise.all([
-                this.clearCacheForAll(),
-                this.clearCacheForId(Array.isArray(saved) ? saved : [
-                    saved
-                ])
-            ]);
-            const first = Array.isArray(saved) ? saved[0] : saved;
-            return this.convertEntityToResponseDto(first, false);
-        } catch (error) {
-            await qr.rollbackTransaction();
-            this.handleError(error, 'insert');
-        } finally{
-            await qr.release();
-        }
+            await this.afterInsertOperation(this.ensureArray(saved), dto, user, qr);
+            return {
+                saved,
+                returnFirst: true
+            };
+        });
     }
     async insertMany(dtos, user) {
-        await this.ensureRepositoryInitialized();
-        const qr = this.repository.manager.connection.createQueryRunner();
-        await qr.connect();
-        await qr.startTransaction();
-        try {
+        return this.executeInTransaction('insertMany', async (qr)=>{
             await this.beforeInsertOperation(dtos, user, qr);
             const entities = await this.convertRequestDtoToEntity(dtos, user);
             const saved = await qr.manager.save(this.repository.target, entities);
-            await this.afterInsertOperation(Array.isArray(saved) ? saved : [
-                saved
-            ], user, qr);
-            await qr.commitTransaction();
-            if (this.isCacheable) await Promise.all([
-                this.clearCacheForAll(),
-                this.clearCacheForId(Array.isArray(saved) ? saved : [
-                    saved
-                ])
-            ]);
-            const list = (Array.isArray(saved) ? saved : [
-                saved
-            ]).map((e)=>this.convertEntityToResponseDto(e, false));
-            return list;
-        } catch (error) {
-            await qr.rollbackTransaction();
-            this.handleError(error, 'insertMany');
-        } finally{
-            await qr.release();
-        }
+            await this.afterInsertOperation(this.ensureArray(saved), dtos, user, qr);
+            return {
+                saved,
+                returnFirst: false
+            };
+        });
     }
     async update(dto, user) {
-        await this.ensureRepositoryInitialized();
-        const qr = this.repository.manager.connection.createQueryRunner();
-        await qr.connect();
-        await qr.startTransaction();
-        try {
+        return this.executeInTransaction('update', async (qr)=>{
             await this.beforeUpdateOperation(dto, user, qr);
             const entities = await this.convertRequestDtoToEntity(dto, user);
             const saved = await qr.manager.save(this.repository.target, entities);
-            await this.afterUpdateOperation(saved, user, qr);
-            await qr.commitTransaction();
-            if (this.isCacheable) await Promise.all([
-                this.clearCacheForAll(),
-                this.clearCacheForId(Array.isArray(saved) ? saved : [
-                    saved
-                ])
-            ]);
-            const first = Array.isArray(saved) ? saved[0] : saved;
-            return this.convertEntityToResponseDto(first, false);
-        } catch (error) {
-            await qr.rollbackTransaction();
-            this.handleError(error, 'update');
-        } finally{
-            await qr.release();
-        }
+            await this.afterUpdateOperation(this.ensureArray(saved), dto, user, qr);
+            return {
+                saved,
+                returnFirst: true
+            };
+        });
     }
     async updateMany(dtos, user) {
-        await this.ensureRepositoryInitialized();
-        const qr = this.repository.manager.connection.createQueryRunner();
-        await qr.connect();
-        await qr.startTransaction();
-        try {
+        return this.executeInTransaction('updateMany', async (qr)=>{
             await this.beforeUpdateOperation(dtos, user, qr);
             const entities = await this.convertRequestDtoToEntity(dtos, user);
             const saved = await qr.manager.save(this.repository.target, entities);
-            await this.afterUpdateOperation(Array.isArray(saved) ? saved : [
-                saved
-            ], user, qr);
-            await qr.commitTransaction();
-            if (this.isCacheable) await Promise.all([
-                this.clearCacheForAll(),
-                this.clearCacheForId(Array.isArray(saved) ? saved : [
-                    saved
-                ])
-            ]);
-            const list = (Array.isArray(saved) ? saved : [
-                saved
-            ]).map((e)=>this.convertEntityToResponseDto(e, false));
-            return list;
-        } catch (error) {
-            await qr.rollbackTransaction();
-            this.handleError(error, 'updateMany');
-        } finally{
-            await qr.release();
-        }
+            await this.afterUpdateOperation(this.ensureArray(saved), dtos, user, qr);
+            return {
+                saved,
+                returnFirst: false
+            };
+        });
+    }
+    async bulkUpsert(toInsert, toUpdate, user) {
+        return this.executeInTransaction('bulkUpsert', async (qr)=>{
+            const allResults = [];
+            if (toInsert.length > 0) {
+                await this.beforeInsertOperation(toInsert, user, qr);
+                const insertedEntities = await this.convertRequestDtoToEntity(toInsert, user);
+                const insertedSaved = await qr.manager.save(this.repository.target, insertedEntities);
+                await this.afterInsertOperation(this.ensureArray(insertedSaved), toInsert, user, qr);
+                allResults.push(...this.ensureArray(insertedSaved));
+            }
+            if (toUpdate.length > 0) {
+                await this.beforeUpdateOperation(toUpdate, user, qr);
+                const updatedEntities = await this.convertRequestDtoToEntity(toUpdate, user);
+                const updatedSaved = await qr.manager.save(this.repository.target, updatedEntities);
+                await this.afterUpdateOperation(this.ensureArray(updatedSaved), toUpdate, user, qr);
+                allResults.push(...this.ensureArray(updatedSaved));
+            }
+            return {
+                saved: allResults,
+                returnFirst: false
+            };
+        });
     }
-    async findByIds(ids, user) {
-        await this.ensureRepositoryInitialized();
+    async findByIds(ids, user, select) {
+        await this.ensureDataSourceRepository();
         try {
             const query = this.repository.createQueryBuilder(this.entityName);
             query.where({
                 id: In(ids)
             });
-            const { query: finalQuery, isRaw } = await this.getSelectQuery(query, user);
+            const selectArray = typeof select === 'string' ? select.split(',').map((s)=>s.trim()) : select;
+            const { query: finalQuery, isRaw } = await this.getSelectQuery(query, user, selectArray);
             let output;
             if (isRaw) {
                 output = await finalQuery.getRawMany();
@@ -142,7 +141,10 @@ import { In } from 'typeorm';
                 output = await finalQuery.getMany();
             }
             const result = this.convertEntityListToResponseListDto(output, isRaw);
-            if (!result || !result.length) throw new NotFoundException('No Data Found');
+            if (!result || !result.length) throw new NotFoundException({
+                message: 'No Data Found',
+                messageKey: ERROR_MESSAGES.NOT_FOUND
+            });
             return result;
         } catch (error) {
             if (error instanceof NotFoundException) {
@@ -152,7 +154,7 @@ import { In } from 'typeorm';
         }
     }
     async findById(id, user, select) {
-        await this.ensureRepositoryInitialized();
+        await this.ensureDataSourceRepository();
         try {
             const query = this.repository.createQueryBuilder(this.entityName);
             query.where({
@@ -166,15 +168,17 @@ import { In } from 'typeorm';
                 result = await this.cacheManager.get(cacheKey);
             }
             if (!result) {
-                let output;
                 if (isRaw) {
-                    output = await finalQuery.getRawMany();
-                    const convertResult = this.convertEntityListToResponseListDto(output, isRaw);
+                    const rawOutput = await finalQuery.getRawMany();
+                    const convertResult = this.convertEntityListToResponseListDto(rawOutput, isRaw);
                     if (convertResult.length) result = convertResult[0];
                 } else {
-                    output = await finalQuery.getOne();
-                    if (!output) throw new NotFoundException('No Data Found');
-                    result = this.convertEntityToResponseDto(output, false);
+                    const singleOutput = await finalQuery.getOne();
+                    if (!singleOutput) throw new NotFoundException({
+                        message: 'No Data Found',
+                        messageKey: ERROR_MESSAGES.NOT_FOUND
+                    });
+                    result = this.convertEntityToResponseDto(singleOutput, false);
                 }
                 if (this.isCacheable) {
                     await this.cacheManager.set(cacheKey, result);
@@ -190,43 +194,34 @@ import { In } from 'typeorm';
         }
     }
     async getAll(search, filterAndPaginationDto, user) {
-        await this.ensureRepositoryInitialized();
+        await this.ensureDataSourceRepository();
         try {
             let data;
             let total;
             let isRaw = false;
             let query = this.repository.createQueryBuilder(this.entityName);
-            // Apply filters
             if (filterAndPaginationDto.filter) {
                 const { query: filterQuery, isRaw: filterIsRaw } = await this.getFilterQuery(query, filterAndPaginationDto.filter, user);
                 query = filterQuery;
                 isRaw = isRaw || filterIsRaw;
             }
-            // Apply search
             if (search) {
                 const { query: searchQuery, isRaw: searchIsRaw } = await this.getGlobalSearchQuery(query, search, user);
                 query = searchQuery;
                 isRaw = isRaw || searchIsRaw;
             }
-            // Apply select
-            if (filterAndPaginationDto.select) {
-                const { query: selectQuery, isRaw: selectIsRaw } = await this.getSelectQuery(query, user, filterAndPaginationDto.select);
-                query = selectQuery;
-                isRaw = isRaw || selectIsRaw;
-            }
-            // Apply sort
+            const { query: selectQuery, isRaw: selectIsRaw } = await this.getSelectQuery(query, user, filterAndPaginationDto.select);
+            query = selectQuery;
+            isRaw = isRaw || selectIsRaw;
             if (filterAndPaginationDto.sort) {
                 const { query: sortQuery, isRaw: sortIsRaw } = await this.getSortQuery(query, filterAndPaginationDto.sort, user);
                 query = sortQuery;
                 isRaw = isRaw || sortIsRaw;
             }
-            // Include soft-deleted if requested
             if (filterAndPaginationDto.withDeleted) query.withDeleted();
-            // Extra manipulation
             const { query: extraQuery, isRaw: extraIsRaw } = await this.getExtraManipulateQuery(query, filterAndPaginationDto, user);
             query = extraQuery;
             isRaw = isRaw || extraIsRaw;
-            // Pagination
             if (filterAndPaginationDto.pagination) {
                 const offset = filterAndPaginationDto.pagination.currentPage * filterAndPaginationDto.pagination.pageSize;
                 const limit = filterAndPaginationDto.pagination.pageSize;
@@ -236,7 +231,6 @@ import { In } from 'typeorm';
                     query.skip(offset).take(limit);
                 }
             }
-            // Generate cache key
             let cacheKey = '';
             if (this.isCacheable) {
                 cacheKey = this.utilsService.getCacheKey(this.entityName, {
@@ -250,8 +244,9 @@ import { In } from 'typeorm';
                 }
             }
             if (isRaw) {
-                // Handle raw query count manually
-                const rawSubQuery = query.clone().offset(undefined).limit(undefined).distinct(true);
+                const rawSubQuery = query.clone().offset(undefined).limit(undefined);
+                rawSubQuery.expressionMap.orderBys = {};
+                rawSubQuery.distinct(true);
                 const countSql = `
             SELECT COUNT(*) as count
             FROM (
@@ -262,10 +257,20 @@ import { In } from 'typeorm';
           `;
                 const parameters = rawSubQuery.getParameters();
                 const orderedValues = [];
+                const isPostgres = this.repository.manager.connection.options.type === 'postgres';
+                let paramIndex = 0;
                 const convertedQuery = countSql.replace(/:(\w+)/g, (_, key)=>{
-                    if (!(key in parameters)) throw new Error(`Missing parameter value for: ${key}`);
+                    if (!(key in parameters)) {
+                        throw new InternalServerErrorException({
+                            message: `Missing parameter value for: ${key}`,
+                            messageKey: SYSTEM_MESSAGES.MISSING_PARAMETER,
+                            messageVariables: {
+                                key
+                            }
+                        });
+                    }
                     orderedValues.push(parameters[key]);
-                    return '?';
+                    return isPostgres ? `$${++paramIndex}` : '?';
                 });
                 const result = await this.repository.query(convertedQuery, orderedValues);
                 total = Number(result[0]?.count || 0);
@@ -288,7 +293,7 @@ import { In } from 'typeorm';
         }
     }
     async delete(option, user) {
-        await this.ensureRepositoryInitialized();
+        await this.ensureDataSourceRepository();
         const queryRunner = this.repository.manager.connection.createQueryRunner();
         await queryRunner.connect();
         await queryRunner.startTransaction();
@@ -314,13 +319,12 @@ import { In } from 'typeorm';
                     id
                 };
             });
-            await this.afterDeleteOperation(ids, user, queryRunner);
+            await this.afterDeleteOperation(ids, option, user, queryRunner);
             await queryRunner.commitTransaction();
             await Promise.all([
                 this.clearCacheForAll(),
                 this.clearCacheForId(ids)
             ]);
-            // return null per IService contract
             return null;
         } catch (error) {
             await queryRunner.rollbackTransaction();
@@ -329,29 +333,58 @@ import { In } from 'typeorm';
             await queryRunner.release();
         }
     }
-    // Caching
     async clearCacheForAll() {
         await this.utilsService.clearCache(this.entityName, this.cacheManager);
     }
     async clearCacheForId(entities) {
         await Promise.all(entities.map((item)=>this.utilsService.clearCache(this.entityName, this.cacheManager, item.id)));
     }
-    /**
-   * Helper method to handle errors with proper logging and type safety
-   */ handleError(error, operation) {
-        ErrorHandler.logError(this.logger, error, operation, {
-            entity: this.entityName
+    handleError(error, _operation) {
+        if (error instanceof Error) {
+            throw error;
+        }
+        throw new InternalServerErrorException({
+            message: typeof error === 'string' ? error : 'Unknown error',
+            messageKey: ERROR_MESSAGES.INTERNAL
         });
-        ErrorHandler.rethrowError(error);
     }
-    // Hooks (override in child classes)
-    async ensureRepositoryInitialized() {}
+    ensureArray(value) {
+        return Array.isArray(value) ? value : [
+            value
+        ];
+    }
+    async executeInTransaction(operation, fn) {
+        await this.ensureDataSourceRepository();
+        const qr = this.repository.manager.connection.createQueryRunner();
+        await qr.connect();
+        await qr.startTransaction();
+        try {
+            const { saved, returnFirst } = await fn(qr);
+            await qr.commitTransaction();
+            const savedArray = this.ensureArray(saved);
+            if (this.isCacheable) {
+                await Promise.all([
+                    this.clearCacheForAll(),
+                    this.clearCacheForId(savedArray)
+                ]);
+            }
+            if (returnFirst) {
+                return this.convertEntityToResponseDto(savedArray[0], false);
+            }
+            return savedArray.map((e)=>this.convertEntityToResponseDto(e, false));
+        } catch (error) {
+            await qr.rollbackTransaction();
+            this.handleError(error, operation);
+        } finally{
+            await qr.release();
+        }
+    }
     async beforeInsertOperation(_dto, _user, _queryRunner) {}
-    async afterInsertOperation(_entity, _user, _queryRunner) {}
+    async afterInsertOperation(_entity, _dto, _user, _queryRunner) {}
     async beforeUpdateOperation(_dto, _user, _queryRunner) {}
-    async afterUpdateOperation(_entity, _user, _queryRunner) {}
+    async afterUpdateOperation(_entity, _dto, _user, _queryRunner) {}
     async beforeDeleteOperation(_dto, _user, _queryRunner) {}
-    async afterDeleteOperation(_entity, _user, _queryRunner) {}
+    async afterDeleteOperation(_entity, _dto, _user, _queryRunner) {}
     async getFilterQuery(query, filter, _user) {
         Object.entries(filter).forEach(([key, value])=>{
             query.andWhere(`${this.entityName}.${key} = :value`, {
@@ -394,7 +427,6 @@ import { In } from 'typeorm';
             isRaw: false
         };
     }
-    // DTO conversion
     async convertRequestDtoToEntity(dto, user) {
         return Array.isArray(dto) ? await this.convertArrayDtoToEntities(dto, user) : [
             await this.convertSingleDtoToEntity(dto, user)
@@ -408,7 +440,10 @@ import { In } from 'typeorm';
                     id: d.id
                 }
             });
-            if (!existing) throw new NotFoundException('No such entity data found for update! Please, Try Again.');
+            if (!existing) throw new NotFoundException({
+                message: 'No such entity data found for update! Please, Try Again.',
+                messageKey: ERROR_MESSAGES.NOT_FOUND
+            });
             return Object.assign(existing, d);
         }
         delete d.id;
@@ -421,26 +456,113 @@ import { In } from 'typeorm';
         return Object.assign({}, entity);
     }
     convertEntityListToResponseListDto(entities, _isRaw) {
-        return entities.map((entity)=>Object.assign({}, entity));
+        return entities.map((entity)=>this.convertEntityToResponseDto(entity, _isRaw));
     }
     async getEntityClass() {
-        return await this.repository.create();
+        return this.repository.create();
     }
-    constructor(entityName, repository, cacheManager, utilsService, loggerName, isCacheable = false){
+    constructor(entityName, cacheManager, utilsService, _loggerName, isCacheable = false, moduleName, entity, dataSourceProvider){
         _define_property(this, "entityName", void 0);
-        _define_property(this, "repository", void 0);
         _define_property(this, "cacheManager", void 0);
         _define_property(this, "utilsService", void 0);
-        _define_property(this, "loggerName", void 0);
+        _define_property(this, "_loggerName", void 0);
         _define_property(this, "isCacheable", void 0);
-        _define_property(this, "logger", void 0);
+        _define_property(this, "moduleName", void 0);
+        _define_property(this, "repository", void 0);
+        _define_property(this, "repositoryInitialized", void 0);
+        _define_property(this, "_entity", void 0);
+        _define_property(this, "_dataSourceProvider", void 0);
         this.entityName = entityName;
-        this.repository = repository;
         this.cacheManager = cacheManager;
         this.utilsService = utilsService;
-        this.loggerName = loggerName;
+        this._loggerName = _loggerName;
         this.isCacheable = isCacheable;
-        this.logger = new Logger('ApiService');
-        this.logger = new Logger(loggerName);
+        this.moduleName = moduleName;
+        this.repositoryInitialized = false;
+        this._entity = entity;
+        this._dataSourceProvider = dataSourceProvider;
     }
 }
+_ts_decorate([
+    LogAction({
+        action: 'create'
+    }),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof CreateDtoT === "undefined" ? Object : CreateDtoT,
+        Object
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], ApiService.prototype, "insert", null);
+_ts_decorate([
+    LogAction({
+        action: 'createMany'
+    }),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof Array === "undefined" ? Object : Array,
+        Object
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], ApiService.prototype, "insertMany", null);
+_ts_decorate([
+    LogAction({
+        action: 'update'
+    }),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof UpdateDtoT === "undefined" ? Object : UpdateDtoT,
+        Object
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], ApiService.prototype, "update", null);
+_ts_decorate([
+    LogAction({
+        action: 'updateMany'
+    }),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        Array,
+        Object
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], ApiService.prototype, "updateMany", null);
+_ts_decorate([
+    LogAction({
+        action: 'bulkUpsert'
+    }),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        Array,
+        Array,
+        Object
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], ApiService.prototype, "bulkUpsert", null);
+_ts_decorate([
+    LogAction({
+        action: 'delete'
+    }),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof DeleteDto === "undefined" ? Object : DeleteDto,
+        Object
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], ApiService.prototype, "delete", null);
+ApiService = _ts_decorate([
+    Injectable({
+        scope: Scope.REQUEST
+    }),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        String,
+        typeof HybridCache === "undefined" ? Object : HybridCache,
+        typeof UtilsService === "undefined" ? Object : UtilsService,
+        String,
+        Boolean,
+        String,
+        typeof EntityTarget === "undefined" ? Object : EntityTarget,
+        typeof IDataSourceProvider === "undefined" ? Object : IDataSourceProvider
+    ])
+], ApiService);

package/fesm/classes/handle-custome-db.js

@@ -0,0 +1,19 @@
+import { envConfig } from '@flusys/nestjs-core';
+export function getJsonColumnType() {
+    const driver = envConfig.getTypeOrmConfig().type;
+    if (driver === 'postgres') return 'jsonb';
+    if (driver === 'mysql') return 'json';
+    return 'simple-json';
+}
+export function getCastIntType() {
+    const driver = envConfig.getTypeOrmConfig().type;
+    return driver === 'postgres' ? 'INTEGER' : 'UNSIGNED';
+}
+/**
+ * Converts MySQL-style `?` placeholders to PostgreSQL `$1, $2, ...` placeholders.
+ * No-op for MySQL/MariaDB.
+ */ export function buildQuery(sql, dbType) {
+    if (dbType !== 'postgres') return sql;
+    let index = 0;
+    return sql.replace(/\?/g, ()=>`$${++index}`);
+}

package/fesm/classes/index.js

@@ -1,6 +1,7 @@
 export * from './api-controller.class';
 export * from './api-service.class';
-export * from './request-scoped-api.service';
+export * from './handle-custome-db';
 export * from './hybrid-cache.class';
-export * from './winston-logger-adapter.class';
 export * from './winston.logger.class';
+// Re-export permission constants for convenience
+export * from '../constants/permissions';