@flusys/nestjs-shared 1.0.0-beta → 1.0.0

package/fesm/guards/permission.guard.js

@@ -35,106 +35,81 @@ import { ILogger } from '../interfaces/logger.interface';
 import { PermissionGuardConfig } from '../interfaces/permission.interface';
 export class PermissionGuard {
     async canActivate(context) {
-        // Check if route is marked as public
         const isPublic = this.reflector.getAllAndOverride(IS_PUBLIC_KEY, [
             context.getHandler(),
             context.getClass()
         ]);
         if (isPublic) return true;
-        // Get required permissions from decorator
         const permissionConfig = this.reflector.getAllAndOverride(PERMISSIONS_KEY, [
             context.getHandler(),
             context.getClass()
         ]);
-        // If no permissions required, allow access
-        if (!permissionConfig) {
-            return true;
-        }
-        // Normalize permission config (support old format: string[])
+        if (!permissionConfig) return true;
         const { permissions: requiredPermissions, operator } = this.normalizePermissionConfig(permissionConfig);
-        // If no permissions required, allow access
-        if (!requiredPermissions || requiredPermissions.length === 0) {
-            return true;
-        }
+        if (!requiredPermissions || requiredPermissions.length === 0) return true;
         const request = context.switchToHttp().getRequest();
         const user = request.user;
-        // User must be authenticated
-        if (!user) {
-            throw new UnauthorizedException('Authentication required');
-        }
-        // Cache is required for permission checks - fail securely if unavailable
+        if (!user) throw new UnauthorizedException('Authentication required');
         if (!this.cache) {
-            // Log error (in production, this should be monitored)
-            this.logger.error(`Cache not available - permission system unavailable (userId: ${user.id})`, undefined, 'PermissionGuard');
-            // Fail securely - deny access rather than allowing without permission check
+            this.logger.error(`Cache not available (userId: ${user.id})`, undefined, 'PermissionGuard');
             throw new PermissionSystemUnavailableException();
         }
-        // Get user's permissions from cache
         const userPermissions = await this.getUserPermissions(user);
-        // If no permissions found in cache, deny access
         if (!userPermissions || userPermissions.length === 0) {
-            this.logger.warn(`No permissions found for user (userId: ${user.id})`, 'PermissionGuard');
+            this.logger.warn(`No permissions found (userId: ${user.id})`, 'PermissionGuard');
             throw new NoPermissionsFoundException();
         }
-        // Check if this is a nested condition or simple permission list
         if (this.isNestedCondition(permissionConfig)) {
-            // Complex nested permission check
             const result = this.evaluateCondition(permissionConfig, userPermissions);
             if (!result.passed) {
-                this.logger.warn(`Permission check failed (userId: ${user.id}, missing: ${result.missingPermissions.join(', ')})`, 'PermissionGuard');
+                this.logger.warn(`Permission denied (userId: ${user.id})`, 'PermissionGuard');
                 throw new InsufficientPermissionsException(result.missingPermissions, result.operator);
             }
         } else {
-            // Simple permission check (backward compatible)
-            let hasRequiredPermissions;
-            if (operator === 'or') {
-                // OR: User must have at least ONE permission
-                hasRequiredPermissions = requiredPermissions.some((permission)=>this.hasPermission(userPermissions, permission));
-                if (!hasRequiredPermissions) {
-                    throw new InsufficientPermissionsException(requiredPermissions, 'or');
-                }
-            } else {
-                // AND (default): User must have ALL permissions
-                hasRequiredPermissions = requiredPermissions.every((permission)=>this.hasPermission(userPermissions, permission));
-                if (!hasRequiredPermissions) {
-                    const missing = requiredPermissions.filter((permission)=>!this.hasPermission(userPermissions, permission));
-                    throw new InsufficientPermissionsException(missing, 'and');
-                }
-            }
+            this.validateSimplePermissions(requiredPermissions, userPermissions, operator);
         }
         return true;
     }
-    /**
-   * Normalize permission config to handle both old and new formats
-   */ normalizePermissionConfig(config) {
-        // Old format: string[]
-        if (Array.isArray(config)) {
-            return {
-                permissions: config,
-                operator: 'and'
-            };
-        }
-        // New format: PermissionConfig
+    normalizePermissionConfig(config) {
+        if (Array.isArray(config)) return {
+            permissions: config,
+            operator: 'and'
+        };
         return {
             permissions: config.permissions || [],
             operator: config.operator || 'and'
         };
     }
-    /**
-   * Check if config is a nested condition (has children)
-   */ isNestedCondition(config) {
+    validateSimplePermissions(requiredPermissions, userPermissions, operator) {
+        if (operator === 'or') {
+            const hasAny = requiredPermissions.some((p)=>this.hasPermission(userPermissions, p));
+            if (!hasAny) throw new InsufficientPermissionsException(requiredPermissions, 'or');
+        } else {
+            const hasAll = requiredPermissions.every((p)=>this.hasPermission(userPermissions, p));
+            if (!hasAll) {
+                const missing = requiredPermissions.filter((p)=>!this.hasPermission(userPermissions, p));
+                throw new InsufficientPermissionsException(missing, 'and');
+            }
+        }
+    }
+    isNestedCondition(config) {
         if (Array.isArray(config)) return false;
         return 'children' in config && Array.isArray(config.children) && config.children.length > 0;
     }
-    /**
-   * Evaluate a nested permission condition recursively
-   */ evaluateCondition(condition, userPermissions) {
+    evaluateCondition(condition, userPermissions) {
         const { permissions = [], operator, children = [] } = condition;
-        // Results for this level
+        // SECURITY: Fail-closed - deny access when no permissions configured (empty condition)
+        if (permissions.length === 0 && children.length === 0) {
+            return {
+                passed: false,
+                message: 'No permissions configured - access denied by default',
+                missingPermissions: [],
+                operator
+            };
+        }
         const results = [];
         const failureDetails = [];
         const missingPermissions = [];
-        // Check permissions at this level
         if (permissions.length > 0) {
             if (operator === 'or') {
                 const hasAny = permissions.some((p)=>this.hasPermission(userPermissions, p));
@@ -153,7 +128,6 @@ export class PermissionGuard {
                 }
             }
         }
-        // Evaluate children recursively
         for (const child of children){
             const childResult = this.evaluateCondition(child, userPermissions);
             results.push(childResult.passed);
@@ -162,14 +136,9 @@ export class PermissionGuard {
                 missingPermissions.push(...childResult.missingPermissions);
             }
         }
-        // Combine results based on operator
-        let passed;
-        if (operator === 'or') {
-            passed = results.length === 0 || results.some((r)=>r);
-        } else {
-            passed = results.length === 0 || results.every((r)=>r);
-        }
-        const message = passed ? 'Permission granted' : `Permission denied: ${failureDetails.join(` ${operator.toUpperCase()} `)}`;
+        // Evaluate based on operator - empty results already handled above
+        const passed = operator === 'or' ? results.some((r)=>r) : results.every((r)=>r);
+        const message = passed ? 'OK' : `Denied: ${failureDetails.join(` ${operator.toUpperCase()} `)}`;
         return {
             passed,
             message,
@@ -177,48 +146,27 @@ export class PermissionGuard {
             operator
         };
     }
-    /**
-   * Get user's permissions from cache
-   */ async getUserPermissions(user) {
-        if (!this.cache) {
-            throw new PermissionSystemUnavailableException();
-        }
-        let cacheKey;
+    async getUserPermissions(user) {
+        if (!this.cache) throw new PermissionSystemUnavailableException();
+        const cacheKey = this.buildPermissionCacheKey(user);
+        return await this.cache.get(cacheKey) || [];
+    }
+    buildPermissionCacheKey(user) {
         if (this.config.enableCompanyFeature && user.companyId) {
-            // Company-based permissions (includes branchId for branch-scoped DIRECT permissions)
-            const format = this.config.companyPermissionKeyFormat || `${PERMISSIONS_CACHE_PREFIX}:company:{companyId}:branch:{branchId}:user:{userId}`;
-            cacheKey = format.replace('{userId}', user.id).replace('{companyId}', user.companyId).replace('{branchId}', user.branchId || 'null');
-        } else {
-            // User-based permissions
-            const format = this.config.userPermissionKeyFormat || `${PERMISSIONS_CACHE_PREFIX}:user:{userId}`;
-            cacheKey = format.replace('{userId}', user.id);
+            return (this.config.companyPermissionKeyFormat || `${PERMISSIONS_CACHE_PREFIX}:company:{companyId}:branch:{branchId}:user:{userId}`).replace('{userId}', user.id).replace('{companyId}', user.companyId).replace('{branchId}', user.branchId || 'null');
         }
-        const permissions = await this.cache.get(cacheKey);
-        return permissions || [];
+        return (this.config.userPermissionKeyFormat || `${PERMISSIONS_CACHE_PREFIX}:user:{userId}`).replace('{userId}', user.id);
     }
-    /**
-   * Check if user has a specific permission
-   * Supports wildcard matching (e.g., 'admin.*' matches 'admin.users.read')
-   */ hasPermission(userPermissions, requiredPermission) {
-        // Direct match
-        if (userPermissions.includes(requiredPermission)) {
-            return true;
-        }
-        // Wildcard match (e.g., '*' or 'admin.*')
+    hasPermission(userPermissions, requiredPermission) {
+        if (userPermissions.includes(requiredPermission)) return true;
         for (const permission of userPermissions){
-            if (permission === '*') {
-                return true; // Super admin
-            }
-            if (permission.endsWith('.*')) {
-                const prefix = permission.slice(0, -1); // Remove '*'
-                if (requiredPermission.startsWith(prefix)) {
-                    return true;
-                }
+            if (permission === '*') return true;
+            if (permission.endsWith('.*') && requiredPermission.startsWith(permission.slice(0, -1))) {
+                return true;
             }
         }
         return false;
     }
-    // NOTE: @Inject(Reflector) required for bundled code - external classes need explicit injection
     constructor(reflector, cache, config, logger){
         _define_property(this, "reflector", void 0);
         _define_property(this, "cache", void 0);
@@ -228,12 +176,10 @@ export class PermissionGuard {
         this.cache = cache;
         this.config = {
             enableCompanyFeature: false,
-            cacheKeyPrefix: PERMISSIONS_CACHE_PREFIX,
             userPermissionKeyFormat: `${PERMISSIONS_CACHE_PREFIX}:user:{userId}`,
             companyPermissionKeyFormat: `${PERMISSIONS_CACHE_PREFIX}:company:{companyId}:branch:{branchId}:user:{userId}`,
             ...config
         };
-        // Use provided logger or fallback to NestJS Logger wrapped in adapter
         this.logger = logger || new NestLoggerAdapter(new Logger(PermissionGuard.name));
     }
 }

package/fesm/interceptors/index.js

@@ -2,7 +2,5 @@ export * from './delete-empty-id-from-body.interceptor';
 export * from './idempotency.interceptor';
 export * from './query-performance.interceptor';
 export * from './response-meta.interceptor';
-export * from './set-create-by-on-body.interceptor';
-export * from './set-delete-by-on-body.interceptor';
-export * from './set-update-by-on-body.interceptor';
+export * from './set-user-field-on-body.interceptor';
 export * from './slug.interceptor';

package/fesm/interceptors/set-user-field-on-body.interceptor.js

@@ -0,0 +1,39 @@
+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;
+}
+import { Injectable } from '@nestjs/common';
+/**
+ * Factory function to create interceptors that set user ID fields on request body
+ * @param fieldName - The field name to set (e.g., 'createdById', 'updatedById', 'deletedById')
+ */ export function createSetUserFieldInterceptor(fieldName) {
+    let SetUserFieldOnBody = class SetUserFieldOnBody {
+        intercept(context, next) {
+            const request = context.switchToHttp().getRequest();
+            const user = request?.user;
+            if (user) {
+                if (Array.isArray(request.body)) {
+                    request.body = request.body.map((item)=>({
+                            ...item,
+                            [fieldName]: user.id
+                        }));
+                } else if (typeof request.body === 'object' && request.body !== null) {
+                    request.body = {
+                        ...request.body,
+                        [fieldName]: user.id
+                    };
+                }
+            }
+            return next.handle();
+        }
+    };
+    SetUserFieldOnBody = _ts_decorate([
+        Injectable()
+    ], SetUserFieldOnBody);
+    return SetUserFieldOnBody;
+}
+/** Sets createdById field on request body from authenticated user */ export const SetCreatedByOnBody = createSetUserFieldInterceptor('createdById');
+/** Sets updatedById field on request body from authenticated user */ export const SetUpdateByOnBody = createSetUserFieldInterceptor('updatedById');
+/** Sets deletedById field on request body from authenticated user */ export const SetDeletedByOnBody = createSetUserFieldInterceptor('deletedById');

package/fesm/interceptors/slug.interceptor.js

@@ -17,28 +17,49 @@ function _ts_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;
 }
-import { Injectable } from '@nestjs/common';
+function _ts_metadata(k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+function _ts_param(paramIndex, decorator) {
+    return function(target, key) {
+        decorator(target, key, paramIndex);
+    };
+}
+import { Inject, Injectable } from '@nestjs/common';
 import { UtilsService } from '../modules/utils/utils.service';
 export class Slug {
     intercept(context, next) {
         const request = context.switchToHttp().getRequest();
         if (Array.isArray(request.body)) {
-            request.body = request.body.map((item)=>({
-                    ...item,
-                    slug: item.slug || (item?.name ? this.utilsService.transformToSlug(item.name) : null)
-                }));
-        } else if (!request.body.slug) {
+            request.body = request.body.map((item)=>{
+                // Only generate slug if not provided and name exists
+                if (!item.slug && item?.name) {
+                    return {
+                        ...item,
+                        slug: this.utilsService.transformToSlug(item.name)
+                    };
+                }
+                return item;
+            });
+        } else if (!request.body?.slug && request.body?.name) {
+            // Only generate slug if not provided and name exists
             request.body = {
                 ...request.body,
-                slug: request.body?.name ? this.utilsService.transformToSlug(request.body?.name) : null
+                slug: this.utilsService.transformToSlug(request.body.name)
             };
         }
         return next.handle();
     }
-    constructor(){
-        _define_property(this, "utilsService", new UtilsService());
+    constructor(utilsService){
+        _define_property(this, "utilsService", void 0);
+        this.utilsService = utilsService;
     }
 }
 Slug = _ts_decorate([
-    Injectable()
+    Injectable(),
+    _ts_param(0, Inject(UtilsService)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof UtilsService === "undefined" ? Object : UtilsService
+    ])
 ], Slug);

package/fesm/interfaces/datasource.interface.js

@@ -0,0 +1,20 @@
+/**
+ * Interface for DataSource providers used by RequestScopedApiService.
+ * Implement this interface in each module's DataSourceProvider to ensure type safety.
+ *
+ * @example
+ * ```typescript
+ * @Injectable()
+ * export class IAMDataSourceProvider implements IDataSourceProvider {
+ *   constructor(private readonly dataSource: DataSource) {}
+ *
+ *   async getRepository<T extends ObjectLiteral>(entity: EntityTarget<T>): Promise<Repository<T>> {
+ *     return this.dataSource.getRepository(entity);
+ *   }
+ *
+ *   async getDataSource(): Promise<DataSource> {
+ *     return this.dataSource;
+ *   }
+ * }
+ * ```
+ */ export { };

package/fesm/interfaces/index.js

@@ -1,6 +1,7 @@
 export * from './api.interface';
-export * from './base-query.interface';
+export * from './datasource.interface';
 export * from './identity.interface';
 export * from './logged-user-info.interface';
 export * from './logger.interface';
+export * from './module-config.interface';
 export * from './permission.interface';

package/fesm/interfaces/module-config.interface.js

@@ -0,0 +1,5 @@
+/**
+ * Common interface for module configuration services.
+ * All feature module config services should implement this interface
+ * to ensure consistent access to bootstrap configuration.
+ */ export { };

package/fesm/middlewares/logger.middleware.js

@@ -43,14 +43,6 @@ export const getRequestId = ()=>requestContext.getStore()?.requestId;
 export const getTenantId = ()=>requestContext.getStore()?.tenantId;
 export const getUserId = ()=>requestContext.getStore()?.userId;
 export const getCompanyId = ()=>requestContext.getStore()?.companyId;
-export const setUserId = (userId)=>{
-    const store = requestContext.getStore();
-    if (store) store.userId = userId;
-};
-export const setCompanyId = (companyId)=>{
-    const store = requestContext.getStore();
-    if (store) store.companyId = companyId;
-};
 // Helper Functions
 function sanitizeHeaders(headers) {
     const sanitized = {};
@@ -72,84 +64,62 @@ export class LoggerMiddleware {
         const requestId = req.headers[REQUEST_ID_HEADER] || uuidv4();
         const tenantId = req.headers[TENANT_ID_HEADER];
         const startTime = Date.now();
-        // Set response header
         res.setHeader(REQUEST_ID_HEADER, requestId);
-        // Create context
         const context = {
             requestId,
             tenantId,
             startTime
         };
-        // Run in AsyncLocalStorage context
         requestContext.run(context, ()=>{
-            // Check if we should skip logging
             const shouldSkipLogging = EXCLUDED_PATHS.some((path)=>req.originalUrl.startsWith(path));
             if (!shouldSkipLogging) {
                 this.logRequest(req, requestId, tenantId);
-                // Track if response was already logged
-                let responseLogged = false;
-                // Capture response using multiple hooks to ensure we catch it
-                const originalSend = res.send;
-                const originalJson = res.json;
-                const originalEnd = res.end;
-                // Store reference to this for use in callbacks
-                const self = this;
-                // Override res.send
-                res.send = function(body) {
-                    if (!responseLogged) {
-                        responseLogged = true;
-                        self.logResponse(req, res, startTime, body, requestId, tenantId);
-                    }
-                    return originalSend.call(this, body);
-                };
-                // Override res.json
-                res.json = function(body) {
-                    if (!responseLogged) {
-                        responseLogged = true;
-                        self.logResponse(req, res, startTime, body, requestId, tenantId);
-                    }
-                    return originalJson.call(this, body);
-                };
-                // Override res.end as fallback
-                res.end = function(...args) {
-                    if (!responseLogged) {
-                        responseLogged = true;
-                        self.logResponse(req, res, startTime, args[0], requestId, tenantId);
-                    }
-                    return originalEnd.apply(this, args);
-                };
-                // Handle errors
-                res.on('error', (error)=>{
-                    this.logger.error('Response error', {
-                        context: 'HTTP',
-                        requestId,
-                        tenantId,
-                        method: req.method,
-                        url: req.originalUrl,
-                        path: req.path,
-                        error: error.message,
-                        stack: error.stack
-                    });
-                });
+                this.setupResponseLogging(req, res, startTime, requestId, tenantId);
             }
             next();
         });
     }
+    setupResponseLogging(req, res, startTime, requestId, tenantId) {
+        let responseLogged = false;
+        const originalSend = res.send;
+        const originalJson = res.json;
+        const originalEnd = res.end;
+        const self = this;
+        const logOnce = (body)=>{
+            if (!responseLogged) {
+                responseLogged = true;
+                self.logResponse(req, res, startTime, body, requestId, tenantId);
+            }
+        };
+        res.send = function(body) {
+            logOnce(body);
+            return originalSend.call(this, body);
+        };
+        res.json = function(body) {
+            logOnce(body);
+            return originalJson.call(this, body);
+        };
+        res.end = function(...args) {
+            logOnce(args[0]);
+            return originalEnd.apply(this, args);
+        };
+        res.on('error', (error)=>{
+            this.logger.error('Response error', {
+                ...this.buildBaseLogData(req, requestId, tenantId),
+                error: error.message,
+                stack: error.stack
+            });
+        });
+    }
     logRequest(req, requestId, tenantId) {
         const logData = {
-            context: 'HTTP',
-            requestId,
-            tenantId,
-            method: req.method,
-            url: req.originalUrl,
-            path: req.path,
+            ...this.buildBaseLogData(req, requestId, tenantId),
             query: Object.keys(req.query).length > 0 ? req.query : undefined,
             ip: getClientIp(req),
             userAgent: req.headers['user-agent'],
             contentType: req.headers['content-type'],
             contentLength: req.headers['content-length']
         };
-        // Add debug details if enabled
         if (IS_DEBUG) {
             logData.headers = sanitizeHeaders(req.headers);
             logData.body = truncateBody(req.body);
@@ -161,13 +131,12 @@ export class LoggerMiddleware {
         const duration = Date.now() - startTime;
         const statusCode = res.statusCode;
         const level = statusCode >= 500 ? 'error' : statusCode >= 400 ? 'warn' : 'info';
+        const userId = getUserId();
+        const companyId = getCompanyId();
         const logData = {
-            context: 'HTTP',
-            requestId,
-            tenantId,
-            method: req.method,
-            url: req.originalUrl,
-            path: req.path,
+            ...this.buildBaseLogData(req, requestId, tenantId),
+            userId,
+            companyId,
             statusCode,
             statusMessage: res.statusMessage,
             duration: `${duration}ms`,
@@ -175,33 +144,31 @@ export class LoggerMiddleware {
             contentType: res.getHeader('content-type'),
             contentLength: res.getHeader('content-length')
         };
-        // Add user context if available
-        const userId = getUserId();
-        const companyId = getCompanyId();
-        if (userId) logData.userId = userId;
-        if (companyId) logData.companyId = companyId;
-        // Add response body for errors or debug mode
         if (statusCode >= 400 || IS_DEBUG) {
             logData.responseBody = truncateBody(body);
         }
         this.logger.log(level, `Response [${statusCode}]`, logData);
-        // Log slow requests separately
         if (duration > 3000 && statusCode < 400) {
             this.logger.warn('Slow request detected', {
-                context: 'HTTP',
-                requestId,
-                tenantId,
+                ...this.buildBaseLogData(req, requestId, tenantId),
                 userId,
                 companyId,
-                method: req.method,
-                url: req.originalUrl,
-                path: req.path,
                 duration: `${duration}ms`,
                 durationMs: duration,
                 threshold: '3000ms'
             });
         }
     }
+    buildBaseLogData(req, requestId, tenantId) {
+        return {
+            context: 'HTTP',
+            requestId,
+            tenantId,
+            method: req.method,
+            url: req.originalUrl,
+            path: req.path
+        };
+    }
     constructor(){
         _define_property(this, "logger", winstonLogger);
     }

package/fesm/modules/cache/cache.module.js

@@ -4,8 +4,8 @@ function _ts_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;
 }
-import { HybridCache } from '@flusys/nestjs-shared/classes';
-import { CACHE_INSTANCE } from '@flusys/nestjs-shared/constants';
+import { HybridCache } from '../../classes/hybrid-cache.class';
+import { CACHE_INSTANCE } from '../../constants';
 import { Module } from '@nestjs/common';
 export class CacheModule {
     static forRoot(isGlobal = true, memoryTtl = 60_000, memorySize = 5000) {

package/fesm/modules/datasource/datasource.module.js

@@ -77,24 +77,12 @@ export class DataSourceModule {
                     provide: options.useClass,
                     useClass: options.useClass
                 },
-                {
-                    provide: MODULE_OPTIONS,
-                    useFactory: async (factory)=>factory.createOptions(),
-                    inject: [
-                        options.useClass
-                    ]
-                }
+                this.createFactoryProvider(options.useClass)
             ];
         }
         if (options.useExisting) {
             return [
-                {
-                    provide: MODULE_OPTIONS,
-                    useFactory: async (factory)=>factory.createOptions(),
-                    inject: [
-                        options.useExisting
-                    ]
-                }
+                this.createFactoryProvider(options.useExisting)
             ];
         }
         return [
@@ -104,6 +92,15 @@ export class DataSourceModule {
             }
         ];
     }
+    static createFactoryProvider(factoryClass) {
+        return {
+            provide: MODULE_OPTIONS,
+            useFactory: async (factory)=>factory.createOptions(),
+            inject: [
+                factoryClass
+            ]
+        };
+    }
 }
 DataSourceModule = _ts_decorate([
     Module({})