@flusys/nestjs-shared 3.0.1 → 4.0.0-lts

package/README.md

@@ -134,7 +134,6 @@ nestjs-shared/
 │   │       └── utils.service.ts           # Cache helpers, string utilities
 │   │
 │   └── utils/                # Utility functions
-│       ├── error-handler.util.ts          # ErrorHandler class
 │       ├── html-sanitizer.util.ts         # escapeHtml, escapeHtmlVariables
 │       ├── query-helpers.util.ts          # applyCompanyFilter, validateCompanyOwnership
 │       ├── request.util.ts                # isBrowserRequest, buildCookieOptions, parseDurationToMs
@@ -582,6 +581,45 @@ export class CreateCommentDto {
 }
 ```
 
+### @LogAction
+
+Method-level logging decorator with automatic correlation context and error handling:
+
+```typescript
+import { LogAction } from '@flusys/nestjs-shared';
+
+@Injectable()
+export class UserService {
+  // Module name for routing logs to module-specific files (production)
+  protected readonly moduleName = 'auth';
+
+  // Basic usage - logs start, success (with duration), and errors
+  @LogAction({ action: 'user.create' })
+  async createUser(dto: CreateUserDto): Promise<User> {
+    return this.repository.save(dto);
+  }
+
+  // With all options
+  @LogAction({
+    action: 'user.update',       // Action name (default: ClassName.methodName)
+    module: 'auth',              // Override module routing
+    includeParams: true,         // Log method parameters (sensitive data redacted)
+    includeResult: true,         // Log result preview
+    logLevel: 'info'             // 'debug' | 'info' | 'warn' (default: 'debug')
+  })
+  async updateUser(dto: UpdateUserDto): Promise<User> {
+    return this.repository.save(dto);
+  }
+}
+```
+
+**Features:**
+- Automatic start/end logging with duration
+- Error logging with stack trace (then re-throws)
+- Sensitive data redaction (password, secret, token, apiKey, authorization)
+- Request context (requestId, userId, tenantId, companyId)
+- Module-specific log routing (production mode)
+
 ### @ApiResponseDto
 
 Generates Swagger schema for response:
@@ -872,20 +910,6 @@ Removes empty/null `id` fields from request body (single objects and arrays).
 // Output: [{ name: 'A' }, { id: '123', name: 'B' }]
 ```
 
-### QueryPerformanceInterceptor
-
-Monitors endpoint execution time and logs warnings for slow requests.
-
-```typescript
-import { QueryPerformanceInterceptor } from '@flusys/nestjs-shared';
-
-// Default threshold: 1000ms
-app.useGlobalInterceptors(new QueryPerformanceInterceptor());
-
-// Custom threshold: 500ms
-app.useGlobalInterceptors(new QueryPerformanceInterceptor(500));
-```
-
 ### Slug Interceptor
 
 Auto-generates `slug` from `name` field if not provided.
@@ -1202,66 +1226,92 @@ const safeVars = escapeHtmlVariables({
 
 ## Error Handling
 
-### ErrorHandler Class
+### BaseAppException
 
-Centralized error handling with automatic sensitive data redaction.
+Structured exceptions with i18n support and validation errors:
 
 ```typescript
-import { ErrorHandler, IErrorContext } from '@flusys/nestjs-shared';
-import { Logger } from '@nestjs/common';
+import {
+  BaseAppException,
+  NotFoundException,
+  ValidationException,
+  UnauthorizedException,
+  ForbiddenException,
+  ConflictException,
+  InternalServerException,
+  ServiceUnavailableException,
+  IValidationError,
+} from '@flusys/nestjs-shared';
 
-const logger = new Logger('MyService');
+// Custom exception with all options
+throw new BaseAppException({
+  message: 'User registration failed',
+  code: 'REGISTRATION_FAILED',
+  messageKey: 'error.registration.failed',  // For i18n
+  status: HttpStatus.BAD_REQUEST,
+  errors: [
+    { field: 'email', message: 'Email already exists', code: 'DUPLICATE_EMAIL' }
+  ],
+  metadata: { attemptedEmail: email },
+});
 
-// Error context interface
-interface IErrorContext {
-  operation?: string;
-  entity?: string;
-  userId?: string;
-  id?: string;
-  companyId?: string;
-  branchId?: string;
-  sectionId?: string;
-  data?: Record<string, unknown>;
-}
+// Pre-built exceptions
+throw new NotFoundException('User', userId);
+// → { message: "User with id 'abc' not found", code: "NOT_FOUND", messageKey: "error.notFound" }
 
-// Safe error message extraction from unknown error
-const message = ErrorHandler.getErrorMessage(error);
-// Returns: 'Error message' | 'Unknown error occurred'
+throw new ValidationException([
+  { field: 'email', message: 'Invalid format' },
+  { field: 'password', message: 'Too short' },
+]);
 
-// Log error with sensitive key redaction
-// Automatically redacts: password, secret, token, apiKey, credential, authorization
-ErrorHandler.logError(logger, error, 'createUser', {
-  entity: 'User',
-  userId: user.id,
-  data: { email: 'test@example.com', password: 'secret123' }, // password will be [REDACTED]
-});
+throw new UnauthorizedException('Invalid credentials');
+throw new ForbiddenException('Admin access required');
+throw new ConflictException('User', 'email');
+throw new InternalServerException('Database connection failed');
+throw new ServiceUnavailableException('Email Service');
+```
 
-// Type-safe rethrow (preserves Error instances, wraps others)
-ErrorHandler.rethrowError(error);  // throws: never
+### GlobalExceptionFilter
 
-// Combined log + rethrow (common pattern)
-ErrorHandler.logAndRethrow(logger, error, 'updateUser', { entity: 'User', id: userId });
+Unified exception handling with structured responses and logging:
 
-// Typical usage in service
-async createUser(dto: CreateUserDto): Promise<User> {
-  try {
-    return await this.repository.save(dto);
-  } catch (error) {
-    ErrorHandler.logAndRethrow(this.logger, error, 'createUser', {
-      entity: 'User',
-      data: dto,
-    });
+```typescript
+import { GlobalExceptionFilter } from '@flusys/nestjs-shared';
+
+// Register in main.ts
+app.useGlobalFilters(new GlobalExceptionFilter());
+
+// Or in app.module.ts
+@Module({
+  providers: [
+    { provide: APP_FILTER, useClass: GlobalExceptionFilter },
+  ],
+})
+export class AppModule {}
+```
+
+**Response format (all errors):**
+```json
+{
+  "success": false,
+  "message": "User with id 'abc' not found",
+  "code": "NOT_FOUND",
+  "messageKey": "error.notFound",
+  "errors": [...],
+  "_meta": {
+    "requestId": "uuid",
+    "timestamp": "2024-01-15T10:30:00.000Z",
+    "responseTime": 45
   }
 }
 ```
 
-**Sensitive Keys (automatically redacted in logs):**
-- `password`
-- `secret`
-- `token`
-- `apiKey`
-- `credential`
-- `authorization`
+**Features:**
+- Consistent error response format
+- Request correlation (requestId, userId, tenantId)
+- Log level by status (500+ → error, 400+ → warn)
+- Handles BaseAppException, HttpException, and generic errors
+- class-validator error transformation
 
 ---
 
@@ -1376,11 +1426,34 @@ type PermissionCode = 'user.create' | 'user.read' | ... ; // Union of all permis
 Production-ready logging with tenant-aware routing and daily rotation.
 
 **Configuration via environment:**
-- `LOG_DIR` - Directory for log files (default: `logs/`)
-- `LOG_LEVEL` - Minimum log level (default: `info`)
-- `LOG_MAX_SIZE` - Max file size before rotation
-- `LOG_MAX_FILES` - Max number of log files to keep
-- `USE_TENANT_MODE` - Enable tenant-aware log routing
+| Variable | Description | Default |
+|----------|-------------|---------|
+| `LOG_DIR` | Directory for log files | `logs/` |
+| `LOG_LEVEL` | Minimum log level | `info` (prod), `debug` (dev) |
+| `LOG_MAX_SIZE` | Max file size before rotation | `20m` |
+| `LOG_MAX_FILES` | Max number of log files to keep | `14d` |
+| `USE_TENANT_MODE` | Enable tenant-aware log routing | `false` |
+| `DISABLE_HTTP_LOGGING` | Disable HTTP request/response logs | `false` |
+
+**Disable HTTP Logging:**
+```bash
+# .env - Disable middleware HTTP logs (keep service-level @LogAction logs)
+DISABLE_HTTP_LOGGING=true
+```
+
+When disabled, LoggerMiddleware skips request/response logging but preserves:
+- `@LogAction` decorator logs
+- Manual `logger.log()` calls
+- Error logs from GlobalExceptionFilter
+
+**Log Format (Production):**
+```
+────────────────────────────────────────────────────────────────────────────────
+2024-01-15 10:30:45.123 | Information | [request-uuid]
+Context: HTTP | Endpoint: POST /api/users | Status: 200 | Duration: 45ms
+Request finished "HTTP/1.1" "POST" "/api/users" - 200 534 "application/json" 45.00ms
+Metadata: {"userId":"user-123","tenantId":"tenant-1"}
+```
 
 **Logger Modes:**
 
@@ -1464,6 +1537,8 @@ import {
   SanitizeAndTrim,
   ApiResponseDto,
   ArrayResponseType,
+  LogAction,
+  ILogActionOptions,
 
   // Guards
   JwtAuthGuard,
@@ -1477,7 +1552,6 @@ import {
   SetDeletedByOnBody,
   createSetUserFieldInterceptor,  // Factory function
   DeleteEmptyIdFromBodyInterceptor,
-  QueryPerformanceInterceptor,
   Slug,
 
   // Modules
@@ -1532,7 +1606,20 @@ import {
   getUserId,
   getCompanyId,
 
+  // Filters
+  GlobalExceptionFilter,
+
   // Exceptions
+  BaseAppException,
+  IBaseAppExceptionOptions,
+  IValidationError,
+  NotFoundException,
+  ValidationException,
+  UnauthorizedException,
+  ForbiddenException,
+  ConflictException,
+  InternalServerException,
+  ServiceUnavailableException,
   InsufficientPermissionsException,
   NoPermissionsFoundException,
   PermissionSystemUnavailableException,
@@ -1569,8 +1656,6 @@ import {
   FORM_RESULT_PERMISSIONS,
 
   // Utilities
-  ErrorHandler,
-  IErrorContext,
   escapeHtml,
   escapeHtmlVariables,
   applyCompanyFilter,
@@ -1758,18 +1843,13 @@ validateCompanyOwnership(entity, user, this.config.isCompanyFeatureEnabled(), 'P
 ### 7. Error Handling Pattern
 
 ```typescript
-import { ErrorHandler } from '@flusys/nestjs-shared';
+import { LogAction } from '@flusys/nestjs-shared';
 
-// Use ErrorHandler for consistent logging with sensitive data redaction
+// Use @LogAction for consistent logging with sensitive data redaction
+@LogAction({ action: 'user.create', includeParams: false })
 async createUser(dto: CreateUserDto): Promise<User> {
-  try {
-    return await this.repository.save(dto);
-  } catch (error) {
-    ErrorHandler.logAndRethrow(this.logger, error, 'createUser', {
-      entity: 'User',
-      data: dto,  // Sensitive fields auto-redacted
-    });
-  }
+  return this.repository.save(dto);
+  // Errors automatically logged with stack trace, then re-thrown
 }
 ```
 

package/cjs/classes/api-controller.class.js

@@ -88,6 +88,8 @@ function _ts_param(paramIndex, decorator) {
     return (0, _common.applyDecorators)(...decorators);
 }
 function createApiController(createDtoClass, updateDtoClass, responseDtoClass, options = {}) {
+    // Entity name for message keys (defaults to 'item')
+    const entityName = options.entityName ?? 'item';
     // Determine if security is global (applies to all) or per-endpoint
     const securityConfig = options.security;
     const endpointKeys = [
@@ -124,7 +126,8 @@ function createApiController(createDtoClass, updateDtoClass, responseDtoClass, o
             const data = (0, _classtransformer.plainToInstance)(responseDtoClass, entity);
             return {
                 success: true,
-                message: 'Item created successfully',
+                message: `${entityName.charAt(0).toUpperCase() + entityName.slice(1)} created successfully`,
+                messageKey: `${entityName}.create.success`,
                 data
             };
         }
@@ -133,7 +136,11 @@ function createApiController(createDtoClass, updateDtoClass, responseDtoClass, o
             const data = entities.map((item)=>(0, _classtransformer.plainToInstance)(responseDtoClass, item));
             return {
                 success: true,
-                message: `${data.length} items created successfully`,
+                message: `${data.length} ${entityName}s created successfully`,
+                messageKey: `${entityName}.create.many.success`,
+                messageVariables: {
+                    count: data.length
+                },
                 data,
                 meta: {
                     count: data.length,
@@ -147,7 +154,8 @@ function createApiController(createDtoClass, updateDtoClass, responseDtoClass, o
             const data = (0, _classtransformer.plainToInstance)(responseDtoClass, entity);
             return {
                 success: true,
-                message: 'Item retrieved successfully',
+                message: `${entityName.charAt(0).toUpperCase() + entityName.slice(1)} retrieved successfully`,
+                messageKey: `${entityName}.get.success`,
                 data
             };
         }
@@ -156,7 +164,8 @@ function createApiController(createDtoClass, updateDtoClass, responseDtoClass, o
             const data = (0, _classtransformer.plainToInstance)(responseDtoClass, entity);
             return {
                 success: true,
-                message: 'Item updated successfully',
+                message: `${entityName.charAt(0).toUpperCase() + entityName.slice(1)} updated successfully`,
+                messageKey: `${entityName}.update.success`,
                 data
             };
         }
@@ -165,7 +174,11 @@ function createApiController(createDtoClass, updateDtoClass, responseDtoClass, o
             const data = (0, _classtransformer.plainToInstance)(responseDtoClass, entities);
             return {
                 success: true,
-                message: `${data.length} items updated successfully`,
+                message: `${data.length} ${entityName}s updated successfully`,
+                messageKey: `${entityName}.update.many.success`,
+                messageVariables: {
+                    count: data.length
+                },
                 data,
                 meta: {
                     count: data.length,
@@ -182,7 +195,8 @@ function createApiController(createDtoClass, updateDtoClass, responseDtoClass, o
             const totalPages = pageSize > 0 ? Math.ceil(result.total / pageSize) : 1;
             return {
                 success: true,
-                message: 'Data retrieved successfully',
+                message: `${entityName.charAt(0).toUpperCase() + entityName.slice(1)}s retrieved successfully`,
+                messageKey: `${entityName}.get.all.success`,
                 data,
                 meta: {
                     total: result.total,
@@ -197,10 +211,14 @@ function createApiController(createDtoClass, updateDtoClass, responseDtoClass, o
         async delete(deleteDto, user) {
             await this.service.delete(deleteDto, user);
             const count = Array.isArray(deleteDto.id) ? deleteDto.id.length : 1;
-            const action = deleteDto.type === 'restore' ? 'restored' : 'deleted';
+            const action = deleteDto.type === 'restore' ? 'restore' : 'delete';
             return {
                 success: true,
-                message: `${count} item${count > 1 ? 's' : ''} ${action} successfully`
+                message: `${count} ${entityName}${count > 1 ? 's' : ''} ${action}d successfully`,
+                messageKey: `${entityName}.${action}.success`,
+                messageVariables: {
+                    count
+                }
             };
         }
         constructor(service){

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

@@ -8,9 +8,11 @@ Object.defineProperty(exports, "ApiService", {
         return ApiService;
     }
 });
-const _errorhandlerutil = require("../utils/error-handler.util");
+const _dtos = require("../dtos");
 const _common = require("@nestjs/common");
+const _constants = require("../constants");
 const _typeorm = require("typeorm");
+const _logactiondecorator = require("../decorators/log-action.decorator");
 function _define_property(obj, key, value) {
     if (key in obj) {
         Object.defineProperty(obj, key, {
@@ -24,6 +26,15 @@ function _define_property(obj, key, value) {
     }
     return obj;
 }
+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);
+}
 let ApiService = class ApiService {
     async insert(dto, user) {
         return this.executeInTransaction('insert', async (qr)=>{
@@ -88,7 +99,10 @@ let ApiService = class ApiService {
                 output = await finalQuery.getMany();
             }
             const result = this.convertEntityListToResponseListDto(output, isRaw);
-            if (!result || !result.length) throw new _common.NotFoundException('No Data Found');
+            if (!result || !result.length) throw new _common.NotFoundException({
+                message: 'No Data Found',
+                messageKey: _constants.SYSTEM_MESSAGES.NOT_FOUND
+            });
             return result;
         } catch (error) {
             if (error instanceof _common.NotFoundException) {
@@ -119,7 +133,10 @@ let ApiService = class ApiService {
                     if (convertResult.length) result = convertResult[0];
                 } else {
                     output = await finalQuery.getOne();
-                    if (!output) throw new _common.NotFoundException('No Data Found');
+                    if (!output) throw new _common.NotFoundException({
+                        message: 'No Data Found',
+                        messageKey: _constants.SYSTEM_MESSAGES.NOT_FOUND
+                    });
                     result = this.convertEntityToResponseDto(output, false);
                 }
                 if (this.isCacheable) {
@@ -209,7 +226,15 @@ let ApiService = class ApiService {
                 const parameters = rawSubQuery.getParameters();
                 const orderedValues = [];
                 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 _common.InternalServerErrorException({
+                            message: `Missing parameter value for: ${key}`,
+                            messageKey: _constants.SYSTEM_MESSAGES.MISSING_PARAMETER,
+                            messageParams: {
+                                key
+                            }
+                        });
+                    }
                     orderedValues.push(parameters[key]);
                     return '?';
                 });
@@ -282,13 +307,14 @@ let ApiService = class ApiService {
     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) {
-        _errorhandlerutil.ErrorHandler.logError(this.logger, error, operation, {
-            entity: this.entityName
+    handleError(error, _operation) {
+        if (error instanceof Error) {
+            throw error;
+        }
+        throw new _common.InternalServerErrorException({
+            message: typeof error === 'string' ? error : 'Unknown error',
+            messageKey: _constants.SYSTEM_MESSAGES.INTERNAL_ERROR
         });
-        _errorhandlerutil.ErrorHandler.rethrowError(error);
     }
     /** Ensures value is always an array */ ensureArray(value) {
         return Array.isArray(value) ? value : [
@@ -385,7 +411,10 @@ let ApiService = class ApiService {
                     id: d.id
                 }
             });
-            if (!existing) throw new _common.NotFoundException('No such entity data found for update! Please, Try Again.');
+            if (!existing) throw new _common.NotFoundException({
+                message: 'No such entity data found for update! Please, Try Again.',
+                messageKey: _constants.SYSTEM_MESSAGES.NOT_FOUND
+            });
             return Object.assign(existing, d);
         }
         delete d.id;
@@ -403,21 +432,75 @@ let ApiService = class ApiService {
     async getEntityClass() {
         return await this.repository.create();
     }
-    constructor(entityName, repository, cacheManager, utilsService, loggerName, isCacheable = false){
+    constructor(entityName, repository, cacheManager, utilsService, _loggerName, isCacheable = false, moduleName){
         _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);
         this.entityName = entityName;
         this.repository = repository;
         this.cacheManager = cacheManager;
         this.utilsService = utilsService;
-        this.loggerName = loggerName;
+        this._loggerName = _loggerName;
         this.isCacheable = isCacheable;
-        this.logger = new _common.Logger('ApiService');
-        this.logger = new _common.Logger(loggerName);
+        this.moduleName = moduleName;
     }
 };
+_ts_decorate([
+    (0, _logactiondecorator.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([
+    (0, _logactiondecorator.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([
+    (0, _logactiondecorator.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([
+    (0, _logactiondecorator.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([
+    (0, _logactiondecorator.LogAction)({
+        action: 'delete'
+    }),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof _dtos.DeleteDto === "undefined" ? Object : _dtos.DeleteDto,
+        Object
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], ApiService.prototype, "delete", null);

package/cjs/classes/winston-logger-adapter.class.js

@@ -31,20 +31,13 @@ function _define_property(obj, key, value) {
     }
     return obj;
 }
-/**
- * Get correlation context for logging
- * Automatically includes requestId, userId, tenantId, companyId if available
- */ function getCorrelationMeta() {
-    const meta = {};
-    const requestId = (0, _loggermiddleware.getRequestId)();
-    const userId = (0, _loggermiddleware.getUserId)();
-    const tenantId = (0, _loggermiddleware.getTenantId)();
-    const companyId = (0, _loggermiddleware.getCompanyId)();
-    if (requestId) meta.requestId = requestId;
-    if (userId) meta.userId = userId;
-    if (tenantId) meta.tenantId = tenantId;
-    if (companyId) meta.companyId = companyId;
-    return meta;
+function getCorrelationMeta() {
+    return Object.fromEntries(Object.entries({
+        requestId: (0, _loggermiddleware.getRequestId)(),
+        userId: (0, _loggermiddleware.getUserId)(),
+        tenantId: (0, _loggermiddleware.getTenantId)(),
+        companyId: (0, _loggermiddleware.getCompanyId)()
+    }).filter(([, v])=>v != null));
 }
 let WinstonLoggerAdapter = class WinstonLoggerAdapter {
     buildLogMeta(context, args, extra) {
@@ -57,25 +50,27 @@ let WinstonLoggerAdapter = class WinstonLoggerAdapter {
         };
     }
     log(message, context, ...args) {
-        _winstonloggerclass.instance.info(message, this.buildLogMeta(context, args));
+        this.logger.info(message, this.buildLogMeta(context, args));
     }
     error(message, trace, context, ...args) {
-        _winstonloggerclass.instance.error(message, this.buildLogMeta(context, args, {
+        this.logger.error(message, this.buildLogMeta(context, args, {
             stack: trace
         }));
     }
     warn(message, context, ...args) {
-        _winstonloggerclass.instance.warn(message, this.buildLogMeta(context, args));
+        this.logger.warn(message, this.buildLogMeta(context, args));
     }
     debug(message, context, ...args) {
-        _winstonloggerclass.instance.debug(message, this.buildLogMeta(context, args));
+        this.logger.debug(message, this.buildLogMeta(context, args));
     }
     verbose(message, context, ...args) {
-        _winstonloggerclass.instance.verbose(message, this.buildLogMeta(context, args));
+        this.logger.verbose(message, this.buildLogMeta(context, args));
     }
-    constructor(context){
+    constructor(context, moduleName){
         _define_property(this, "context", void 0);
+        _define_property(this, "logger", void 0);
         this.context = context;
+        this.logger = moduleName ? (0, _winstonloggerclass.createModuleLogger)(moduleName) : _winstonloggerclass.instance;
     }
 };
 let NestLoggerAdapter = class NestLoggerAdapter {