@flusys/nestjs-shared 3.0.1 → 4.0.0-lts

package/exceptions/base-app.exception.d.ts

@@ -0,0 +1,41 @@
+import { HttpException, HttpStatus } from '@nestjs/common';
+export interface IValidationError {
+    field: string;
+    message: string;
+}
+export interface IBaseAppExceptionOptions {
+    message: string;
+    messageKey?: string;
+    messageParams?: Record<string, unknown>;
+    status?: HttpStatus;
+    errors?: IValidationError[];
+    metadata?: Record<string, unknown>;
+}
+export declare class BaseAppException extends HttpException {
+    readonly messageKey: string;
+    readonly messageParams?: Record<string, unknown>;
+    readonly errors?: IValidationError[];
+    readonly metadata?: Record<string, unknown>;
+    constructor(options: IBaseAppExceptionOptions);
+}
+export declare class NotFoundException extends BaseAppException {
+    constructor(entity: string, id?: string);
+}
+export declare class ValidationException extends BaseAppException {
+    constructor(errors: IValidationError[]);
+}
+export declare class UnauthorizedException extends BaseAppException {
+    constructor(message?: string);
+}
+export declare class ForbiddenException extends BaseAppException {
+    constructor(message?: string);
+}
+export declare class ConflictException extends BaseAppException {
+    constructor(entity: string, field?: string);
+}
+export declare class InternalServerException extends BaseAppException {
+    constructor(message?: string);
+}
+export declare class ServiceUnavailableException extends BaseAppException {
+    constructor(service: string);
+}

package/exceptions/index.d.ts

@@ -1 +1,2 @@
+export * from './base-app.exception';
 export * from './permission.exception';

package/exceptions/permission.exception.d.ts

@@ -1,6 +1,6 @@
 import { ForbiddenException, InternalServerErrorException } from '@nestjs/common';
 export declare class PermissionSystemUnavailableException extends InternalServerErrorException {
-    constructor(message?: string);
+    constructor();
 }
 export declare class InsufficientPermissionsException extends ForbiddenException {
     constructor(missingPermissions: string[], operator?: 'AND' | 'OR');

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

@@ -78,6 +78,8 @@ import { ApiResponseDto } from '../decorators/api-response.decorator';
     return applyDecorators(...decorators);
 }
 /** Creates an API Controller with standardized CRUD endpoints (POST-only RPC pattern) */ export 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 = [
@@ -114,7 +116,8 @@ import { ApiResponseDto } from '../decorators/api-response.decorator';
             const data = 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
             };
         }
@@ -123,7 +126,11 @@ import { ApiResponseDto } from '../decorators/api-response.decorator';
             const data = entities.map((item)=>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,
@@ -137,7 +144,8 @@ import { ApiResponseDto } from '../decorators/api-response.decorator';
             const data = 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
             };
         }
@@ -146,7 +154,8 @@ import { ApiResponseDto } from '../decorators/api-response.decorator';
             const data = 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
             };
         }
@@ -155,7 +164,11 @@ import { ApiResponseDto } from '../decorators/api-response.decorator';
             const data = 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,
@@ -172,7 +185,8 @@ import { ApiResponseDto } from '../decorators/api-response.decorator';
             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,
@@ -187,10 +201,14 @@ import { ApiResponseDto } from '../decorators/api-response.decorator';
         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/fesm/classes/api-service.class.js

@@ -11,9 +11,20 @@ function _define_property(obj, key, value) {
     }
     return obj;
 }
-import { ErrorHandler } from '../utils/error-handler.util';
-import { Logger, NotFoundException } from '@nestjs/common';
+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 { DeleteDto } from '../dtos';
+import { InternalServerErrorException, NotFoundException } from '@nestjs/common';
+import { SYSTEM_MESSAGES } from '../constants';
 import { In } from 'typeorm';
+import { LogAction } from '../decorators/log-action.decorator';
 /** Generic API service with CRUD operations and caching support */ export class ApiService {
     async insert(dto, user) {
         return this.executeInTransaction('insert', async (qr)=>{
@@ -78,7 +89,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: SYSTEM_MESSAGES.NOT_FOUND
+            });
             return result;
         } catch (error) {
             if (error instanceof NotFoundException) {
@@ -109,7 +123,10 @@ import { In } from 'typeorm';
                     if (convertResult.length) result = convertResult[0];
                 } else {
                     output = await finalQuery.getOne();
-                    if (!output) throw new NotFoundException('No Data Found');
+                    if (!output) throw new NotFoundException({
+                        message: 'No Data Found',
+                        messageKey: SYSTEM_MESSAGES.NOT_FOUND
+                    });
                     result = this.convertEntityToResponseDto(output, false);
                 }
                 if (this.isCacheable) {
@@ -199,7 +216,15 @@ import { In } from 'typeorm';
                 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 InternalServerErrorException({
+                            message: `Missing parameter value for: ${key}`,
+                            messageKey: SYSTEM_MESSAGES.MISSING_PARAMETER,
+                            messageParams: {
+                                key
+                            }
+                        });
+                    }
                     orderedValues.push(parameters[key]);
                     return '?';
                 });
@@ -272,13 +297,14 @@ import { In } from 'typeorm';
     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: SYSTEM_MESSAGES.INTERNAL_ERROR
         });
-        ErrorHandler.rethrowError(error);
     }
     /** Ensures value is always an array */ ensureArray(value) {
         return Array.isArray(value) ? value : [
@@ -375,7 +401,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: SYSTEM_MESSAGES.NOT_FOUND
+            });
             return Object.assign(existing, d);
         }
         delete d.id;
@@ -393,21 +422,75 @@ import { In } from 'typeorm';
     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 Logger('ApiService');
-        this.logger = new Logger(loggerName);
+        this.moduleName = moduleName;
     }
 }
+_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: '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);

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

@@ -11,39 +11,17 @@ function _define_property(obj, key, value) {
     }
     return obj;
 }
-import { instance as winstonLogger } from './winston.logger.class';
+import { instance as winstonLogger, createModuleLogger } from './winston.logger.class';
 import { getRequestId, getUserId, getTenantId, getCompanyId } from '../middlewares/logger.middleware';
-/**
- * Get correlation context for logging
- * Automatically includes requestId, userId, tenantId, companyId if available
- */ function getCorrelationMeta() {
-    const meta = {};
-    const requestId = getRequestId();
-    const userId = getUserId();
-    const tenantId = getTenantId();
-    const companyId = 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: getRequestId(),
+        userId: getUserId(),
+        tenantId: getTenantId(),
+        companyId: getCompanyId()
+    }).filter(([, v])=>v != null));
 }
-/**
- * Winston Logger Adapter
- * Adapts Winston logger to ILogger interface for dependency injection
- *
- * Features:
- * - Automatic correlation ID injection
- * - User ID tracking
- * - Structured metadata logging
- *
- * Usage:
- * ```typescript
- * const logger = new WinstonLoggerAdapter('MyService');
- * logger.log('Operation completed', undefined, { orderId: '123' });
- * // Output: { requestId: 'uuid', userId: 'user-id', context: 'MyService', message: 'Operation completed', orderId: '123' }
- * ```
- */ export class WinstonLoggerAdapter {
+export class WinstonLoggerAdapter {
     buildLogMeta(context, args, extra) {
         const meta = args?.length && typeof args[0] === 'object' ? args[0] : {};
         return {
@@ -54,34 +32,30 @@ import { getRequestId, getUserId, getTenantId, getCompanyId } from '../middlewar
         };
     }
     log(message, context, ...args) {
-        winstonLogger.info(message, this.buildLogMeta(context, args));
+        this.logger.info(message, this.buildLogMeta(context, args));
     }
     error(message, trace, context, ...args) {
-        winstonLogger.error(message, this.buildLogMeta(context, args, {
+        this.logger.error(message, this.buildLogMeta(context, args, {
             stack: trace
         }));
     }
     warn(message, context, ...args) {
-        winstonLogger.warn(message, this.buildLogMeta(context, args));
+        this.logger.warn(message, this.buildLogMeta(context, args));
     }
     debug(message, context, ...args) {
-        winstonLogger.debug(message, this.buildLogMeta(context, args));
+        this.logger.debug(message, this.buildLogMeta(context, args));
     }
     verbose(message, context, ...args) {
-        winstonLogger.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 ? createModuleLogger(moduleName) : winstonLogger;
     }
 }
-/**
- * NestJS Logger Adapter
- * Adapts NestJS Logger to ILogger interface
- *
- * Use this when you need to use NestJS's built-in logger
- * instead of Winston (e.g., for testing)
- */ export class NestLoggerAdapter {
+export class NestLoggerAdapter {
     formatMessage(message, args) {
         return args?.length ? `${message} ${JSON.stringify(args)}` : message;
     }

package/fesm/classes/winston.logger.class.js

@@ -16,9 +16,9 @@ import { existsSync, mkdirSync } from 'fs';
 import { join } from 'path';
 import { createLogger, format, transports } from 'winston';
 // Handle both webpack (no default export) and esbuild (default export)
+import * as DailyRotateFileModule from 'winston-daily-rotate-file';
 import * as TransportModule from 'winston-transport';
 const Transport = TransportModule.default || TransportModule;
-import * as DailyRotateFileModule from 'winston-daily-rotate-file';
 const DailyRotateFile = DailyRotateFileModule.default || DailyRotateFileModule;
 // Configuration
 const logConfig = envConfig.getLogConfig();
@@ -35,33 +35,48 @@ if (!existsSync(LOG_DIR)) {
 }
 // Custom Formats
 /**
- * Custom format for structured logging
- * Includes: timestamp, level, context, requestId, userId, message, metadata
- */ const structuredFormat = format.printf(({ timestamp, level, message, context, requestId, userId, stack, ...metadata })=>{
-    const logEntry = {
-        timestamp,
-        level: level.toUpperCase(),
-        context: context || 'App',
-        message
-    };
-    if (requestId) logEntry.requestId = requestId;
-    if (userId) logEntry.userId = userId;
-    if (Object.keys(metadata).length > 0) logEntry.metadata = metadata;
-    if (stack) logEntry.stack = stack;
-    return JSON.stringify(logEntry);
-});
-/**
- * Custom format for development console output
- * Human-readable format with colors
- */ const devConsoleFormat = format.printf(({ timestamp, level, message, context, requestId, userId, method, url, path, statusCode, duration, stack })=>{
-    const ctx = context || 'App';
-    const reqId = requestId ? ` [${requestId}]` : '';
-    const user = userId ? ` (user:${userId})` : '';
-    const endpoint = method && (path || url) ? ` [${method} ${path || url}]` : '';
-    const status = statusCode ? ` [${statusCode}]` : '';
-    const time = duration ? ` (${duration})` : '';
-    const stackTrace = stack ? `\n${stack}` : '';
-    return `${timestamp} [${level.toUpperCase().padEnd(7)}] [${ctx}]${endpoint}${status}${time}${reqId}${user} ${message}${stackTrace}`;
+ * Custom format for structured logging (production)
+ * Multi-line format:
+ * - Line 1: Timestamp
+ * - Line 2: Log Level
+ * - Line 3: [RequestId]
+ * - Line 4: Empty
+ * - Line 5+: Message with context
+ */ const LEVEL_MAP = {
+    error: 'Error',
+    warn: 'Warning',
+    info: 'Information',
+    debug: 'Debug',
+    verbose: 'Verbose'
+};
+const LOG_SEPARATOR = '─'.repeat(80);
+const structuredFormat = format.printf(({ timestamp, level, message, context, requestId, userId, tenantId, companyId, method, url, path, statusCode, duration, stack, ...metadata })=>{
+    const reqId = requestId || 'no-request-id';
+    const levelFormatted = LEVEL_MAP[level] || level.charAt(0).toUpperCase() + level.slice(1);
+    const contextParts = [];
+    if (context) contextParts.push(`Context: ${context}`);
+    if (method && (path || url)) contextParts.push(`Endpoint: ${method} ${path || url}`);
+    if (statusCode) contextParts.push(`Status: ${statusCode}`);
+    if (duration) contextParts.push(`Duration: ${duration}`);
+    if (userId) contextParts.push(`UserId: ${userId}`);
+    if (tenantId) contextParts.push(`TenantId: ${tenantId}`);
+    if (companyId) contextParts.push(`CompanyId: ${companyId}`);
+    let content = message;
+    if (contextParts.length > 0) {
+        content = `${contextParts.join(' | ')}\n${message}`;
+    }
+    const metaKeys = Object.keys(metadata).filter((k)=>k !== 'splat');
+    if (metaKeys.length > 0) {
+        const metaStr = JSON.stringify(metaKeys.reduce((acc, k)=>({
+                ...acc,
+                [k]: metadata[k]
+            }), {}));
+        content += `\nMetadata: ${metaStr}`;
+    }
+    if (stack) {
+        content += `\nStack: ${stack}`;
+    }
+    return `${LOG_SEPARATOR}\n${timestamp} | ${levelFormatted} | [${reqId}]\n${content}`;
 });
 // Transports
 /**
@@ -84,63 +99,44 @@ if (!existsSync(LOG_DIR)) {
     maxFiles: LOG_MAX_FILES,
     level: 'error'
 });
-// Tenant-Aware Transport
-/**
- * Cache for tenant-specific transports
- * Avoids creating new transport instances for each log entry
- */ const tenantTransportCache = new Map();
-/**
- * Get or create a tenant-specific transport
- * Creates logs in: logs/{tenantId}/combined-YYYY-MM-DD.log
- */ function getTenantTransport(tenantId) {
-    if (tenantTransportCache.has(tenantId)) {
-        return tenantTransportCache.get(tenantId);
-    }
-    const tenantLogDir = join(LOG_DIR, tenantId);
-    if (!existsSync(tenantLogDir)) {
-        mkdirSync(tenantLogDir, {
+// Transport Caches
+const moduleTransportCache = new Map();
+const tenantTransportCache = new Map();
+function getCachedTransport(cache, name) {
+    const cached = cache.get(name);
+    if (cached) return cached;
+    const logDir = join(LOG_DIR, name);
+    if (!existsSync(logDir)) {
+        mkdirSync(logDir, {
             recursive: true
         });
     }
     const transport = new DailyRotateFile({
-        filename: `${tenantLogDir}/combined-%DATE%.log`,
+        filename: `${logDir}/combined-%DATE%.log`,
         datePattern: 'YYYY-MM-DD',
         zippedArchive: true,
         maxSize: LOG_MAX_SIZE,
         maxFiles: LOG_MAX_FILES,
         level: LOG_LEVEL
     });
-    tenantTransportCache.set(tenantId, transport);
+    cache.set(name, transport);
     return transport;
 }
-/**
- * Tenant-aware transport wrapper
- * Routes logs to tenant-specific folders when tenantId is present
- */ let TenantAwareTransport = class TenantAwareTransport extends Transport {
+const getModuleTransport = (name)=>getCachedTransport(moduleTransportCache, name);
+const getTenantTransport = (name)=>getCachedTransport(tenantTransportCache, name);
+let TenantAwareTransport = class TenantAwareTransport extends Transport {
     log(info, callback) {
         setImmediate(()=>this.emit('logged', info));
         const tenantId = info.tenantId || info.metadata?.tenantId;
-        if (USE_TENANT_MODE && tenantId) {
-            // Write to tenant-specific folder
-            const tenantTransport = getTenantTransport(tenantId);
-            tenantTransport.log(info, callback);
-        } else {
-            // Write to default log folder
-            this.defaultTransport.log(info, callback);
-        }
+        const transport = USE_TENANT_MODE && tenantId ? getTenantTransport(tenantId) : this.defaultTransport;
+        transport.log(info, callback);
     }
     constructor(defaultTransport){
-        super(), _define_property(this, "defaultTransport", void 0);
-        this.defaultTransport = defaultTransport;
+        super(), _define_property(this, "defaultTransport", void 0), this.defaultTransport = defaultTransport;
     }
 };
-/**
- * Tenant-aware combined transport
- * When USE_TENANT_MODE=true, routes to tenant folders (like database mode)
- */ const tenantAwareCombinedTransport = new TenantAwareTransport(combinedRotateTransport);
-/**
- * Console transport for development
- */ const consoleTransport = new transports.Console({
+const tenantAwareCombinedTransport = new TenantAwareTransport(combinedRotateTransport);
+const consoleTransport = new transports.Console({
     level: LOG_LEVEL,
     format: format.combine(format.colorize({
         all: true
@@ -148,7 +144,7 @@ if (!existsSync(LOG_DIR)) {
         format: 'YYYY-MM-DD HH:mm:ss'
     }), format.errors({
         stack: true
-    }), devConsoleFormat)
+    }), structuredFormat)
 });
 // Logger Instances
 /**
@@ -190,7 +186,43 @@ if (!existsSync(LOG_DIR)) {
 });
 // Exports
 /**
- * Winston logger instance
+ * Winston logger instance (global)
  * - DEV: Console output with colors
  * - PROD: File-based with daily rotation, tenant-aware routing
  */ export const instance = envConfig.isProduction() ? prodLogger : devLogger;
+/**
+ * Module logger cache to avoid creating multiple loggers for the same module
+ */ const moduleLoggerCache = new Map();
+/**
+ * Create a module-specific logger instance
+ * - DEV: Console output (same as global)
+ * - PROD: File-based with module-specific folder + shared error log
+ *
+ * @param moduleName - The module name (e.g., 'auth', 'iam', 'storage')
+ * @returns Logger instance for the module
+ */ export function createModuleLogger(moduleName) {
+    // In dev mode, use global console logger
+    if (!envConfig.isProduction()) {
+        return devLogger;
+    }
+    // Check cache first
+    if (moduleLoggerCache.has(moduleName)) {
+        return moduleLoggerCache.get(moduleName);
+    }
+    // Create module-specific logger for production
+    const moduleLogger = createLogger({
+        level: LOG_LEVEL,
+        format: format.combine(format.timestamp({
+            format: 'YYYY-MM-DD HH:mm:ss.SSS'
+        }), format.errors({
+            stack: true
+        }), structuredFormat),
+        transports: [
+            getModuleTransport(moduleName),
+            errorRotateTransport
+        ],
+        exitOnError: false
+    });
+    moduleLoggerCache.set(moduleName, moduleLogger);
+    return moduleLogger;
+}

package/fesm/constants/index.js

@@ -14,3 +14,5 @@ export const PERMISSIONS_CACHE_PREFIX = 'permissions';
 export const IDEMPOTENCY_CACHE_PREFIX = 'idempotency';
 // Permission codes
 export * from './permissions';
+// Message keys for localization
+export * from './message-keys';