@flusys/nestjs-shared 7.0.2 → 8.0.0-beta.1

package/fesm/classes/hybrid-event-bus.class.js

@@ -1,237 +0,0 @@
-function _define_property(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
-import { envConfig } from '@flusys/nestjs-core/config';
-import { Logger } from '@nestjs/common';
-import { matchEventPattern } from '../utils/event-pattern.util';
-import { EventTransportRegistry } from './event-transports/event-transport.registry';
-import { MemoryTransport } from './event-transports/memory-transport';
-const DEFAULT_DEDUPE_SIZE = 5000;
-/**
- * Event counterpart of HybridCache: one wrapper, transport chosen by configuration.
- *
- * - `memory`   in-process only, no broker required (default)
- * - `rabbitmq` topic exchange, cross-service
- * - `kafka`    single topic, cross-service
- * - `hybrid`   both, with duplicate delivery suppressed by event id
- */ export class HybridEventBus {
-    getTransportLabel() {
-        return this.label;
-    }
-    getActiveTransports() {
-        return this.transports.map((transport)=>transport.name);
-    }
-    async connect() {
-        if (this.connected) return;
-        if (!this.connecting) {
-            this.connecting = this.buildTransports().catch((error)=>{
-                // A cached rejection would leave the bus dead for the process lifetime
-                this.connecting = undefined;
-                throw error;
-            });
-        }
-        await this.connecting;
-        this.connected = true;
-    }
-    async publish(event) {
-        if (!await this.ensureConnected()) return;
-        await Promise.all(this.transports.map((transport)=>transport.publish(event).catch((error)=>{
-                this.logger.warn(`Publish failed on ${transport.name}: ${error.message}`);
-            })));
-    }
-    async subscribe(pattern, handler) {
-        this.subscriptions.push({
-            pattern,
-            handler: handler
-        });
-        if (!await this.ensureConnected()) return;
-        await this.bindSubscriptions();
-    }
-    async close() {
-        await Promise.allSettled(this.transports.map((transport)=>transport.close()));
-        this.transports.length = 0;
-        this.subscriptions.length = 0;
-        this.boundPatterns.clear();
-        this.seenIds.clear();
-        this.seenOrder.length = 0;
-        this.memory = undefined;
-        this.connecting = undefined;
-        this.connected = false;
-    }
-    // ─── Private Helpers ────────────────────────────────────────────────────────
-    /**
-   * Connecting must never throw at the call site - a bus that cannot start is
-   * a degraded system, not a failed request. The next call retries.
-   */ async ensureConnected() {
-        try {
-            await this.connect();
-            return true;
-        } catch (error) {
-            const message = error instanceof Error ? error.message : 'Unknown error';
-            this.logger.error(`Event bus is not available: ${message}`);
-            return false;
-        }
-    }
-    resolveLabelFromEnv() {
-        const value = envConfig.tryGetValue('USE_EVENT_LABEL', false) || 'memory';
-        return value;
-    }
-    async buildTransports() {
-        // Fresh transports know nothing of what was bound on the ones they replace
-        this.boundPatterns.clear();
-        if (this.label === 'memory' || this.label === 'hybrid') {
-            this.memory = new MemoryTransport();
-            await this.memory.connect();
-            this.registerTransport(this.memory);
-        }
-        if (this.label !== 'memory') {
-            const broker = await this.createBrokerTransport(this.label);
-            if (broker) {
-                this.registerTransport(broker);
-            } else {
-                this.logger.error(`Event transport '${this.label}' was requested but is unavailable - delivering ` + `in-process only, so no event will reach another service. Check the broker URL ` + `and that its driver is installed.`);
-                if (!this.memory) {
-                    this.memory = new MemoryTransport();
-                    await this.memory.connect();
-                    this.registerTransport(this.memory);
-                }
-            }
-        }
-        await this.bindSubscriptions();
-    }
-    /**
-   * Binds every pattern the bus knows about, skipping the ones already bound.
-   *
-   * Called once the transports are built, not only from `subscribe`: a
-   * subscription taken while the bus was down returns before any transport
-   * exists, so nothing would ever bind its routing key on the broker that
-   * finally comes up, leaving the process publishing but never consuming.
-   */ async bindSubscriptions() {
-        for (const { pattern } of this.subscriptions){
-            if (this.boundPatterns.has(pattern)) continue;
-            this.boundPatterns.add(pattern);
-            await Promise.all(this.transports.map((transport)=>transport.bind(pattern).catch((error)=>{
-                    this.logger.warn(`Bind failed on ${transport.name}: ${error.message}`);
-                })));
-        }
-    }
-    async createBrokerTransport(label) {
-        const name = label === 'hybrid' ? this.resolveHybridBrokerName() : label;
-        try {
-            await this.loadOptionalTransport(name);
-            const factory = EventTransportRegistry.get(name);
-            if (!factory) {
-                this.logger.error(`Event transport '${name}' is not registered. Available: ${EventTransportRegistry.getAll().join(', ')}`);
-                return undefined;
-            }
-            const transport = factory(this.getTransportConfig(name));
-            await transport.connect();
-            return transport;
-        } catch (error) {
-            const message = error instanceof Error ? error.message : 'Unknown error';
-            this.logger.error(`Failed to start the '${name}' event transport: ${message}`);
-            return undefined;
-        }
-    }
-    resolveHybridBrokerName() {
-        return envConfig.tryGetValue('EVENT_BROKER', false) || 'rabbitmq';
-    }
-    /**
-   * Registers explicitly rather than relying on the transport file's own
-   * side effect, which a tree shaking bundler is free to drop.
-   */ async loadOptionalTransport(name) {
-        if (EventTransportRegistry.has(name)) return;
-        if (name === 'rabbitmq') {
-            const { RabbitMqTransport } = await import('./event-transports/rabbitmq-transport.optional');
-            EventTransportRegistry.register('rabbitmq', (config)=>new RabbitMqTransport(config));
-            return;
-        }
-        if (name === 'kafka') {
-            const { KafkaTransport } = await import('./event-transports/kafka-transport.optional');
-            EventTransportRegistry.register('kafka', (config)=>new KafkaTransport(config));
-        }
-    }
-    getTransportConfig(name) {
-        if (name === 'rabbitmq') {
-            return {
-                url: envConfig.tryGetValue('RABBITMQ_URL', false) || undefined,
-                queue: this.options.serviceName ? `${this.options.serviceName}.events` : undefined,
-                ...this.options.rabbitmq ?? {}
-            };
-        }
-        if (name === 'kafka') {
-            return {
-                brokers: this.parseBrokers(envConfig.tryGetValue('KAFKA_BROKERS', false)),
-                clientId: this.options.serviceName,
-                groupId: this.options.serviceName ? `${this.options.serviceName}-events` : undefined,
-                ...this.options.kafka ?? {}
-            };
-        }
-        return {};
-    }
-    parseBrokers(value) {
-        if (!value) return undefined;
-        return value.split(',').map((broker)=>broker.trim()).filter(Boolean);
-    }
-    registerTransport(transport) {
-        transport.onMessage((event)=>this.dispatch(event));
-        this.transports.push(transport);
-    }
-    async dispatch(event) {
-        if (this.isDuplicate(event.id)) return;
-        const matched = this.subscriptions.filter((subscription)=>matchEventPattern(subscription.pattern, event.name));
-        await Promise.all(matched.map(async (subscription)=>{
-            try {
-                await subscription.handler(event);
-            } catch (error) {
-                const message = error instanceof Error ? error.message : 'Unknown error';
-                this.logger.error(`Handler for '${subscription.pattern}' failed: ${message}`);
-            }
-        }));
-    }
-    isDuplicate(eventId) {
-        if (!eventId) return false;
-        if (this.seenIds.has(eventId)) return true;
-        this.seenIds.add(eventId);
-        this.seenOrder.push(eventId);
-        if (this.seenOrder.length > this.dedupeSize) {
-            const evicted = this.seenOrder.shift();
-            if (evicted) this.seenIds.delete(evicted);
-        }
-        return false;
-    }
-    constructor(options = {}){
-        _define_property(this, "options", void 0);
-        _define_property(this, "logger", void 0);
-        _define_property(this, "subscriptions", void 0);
-        _define_property(this, "transports", void 0);
-        _define_property(this, "boundPatterns", void 0);
-        _define_property(this, "seenIds", void 0);
-        _define_property(this, "seenOrder", void 0);
-        _define_property(this, "label", void 0);
-        _define_property(this, "dedupeSize", void 0);
-        _define_property(this, "memory", void 0);
-        _define_property(this, "connecting", void 0);
-        _define_property(this, "connected", void 0);
-        this.options = options;
-        this.logger = new Logger(HybridEventBus.name);
-        this.subscriptions = [];
-        this.transports = [];
-        this.boundPatterns = new Set();
-        this.seenIds = new Set();
-        this.seenOrder = [];
-        this.connected = false;
-        this.label = options.transport ?? this.resolveLabelFromEnv();
-        this.dedupeSize = options.dedupeSize ?? DEFAULT_DEDUPE_SIZE;
-    }
-}

package/fesm/classes/hybrid-event-bus.class.spec.js

@@ -1,214 +0,0 @@
-import { EventTransportRegistry } from './event-transports/event-transport.registry';
-import { MemoryTransport } from './event-transports/memory-transport';
-import { HybridEventBus } from './hybrid-event-bus.class';
-function buildEvent(name = 'storage.folder.created', id = 'event-1') {
-    return {
-        id,
-        name,
-        module: 'storage',
-        entity: 'folder',
-        action: 'created',
-        payload: {
-            ids: [
-                '1'
-            ]
-        },
-        actor: {},
-        occurredAt: new Date().toISOString(),
-        version: 1
-    };
-}
-function createFakeTransport(name) {
-    const handlers = [];
-    const transport = {
-        name,
-        connect: jest.fn().mockResolvedValue(undefined),
-        publish: jest.fn().mockResolvedValue(undefined),
-        bind: jest.fn().mockResolvedValue(undefined),
-        onMessage: (handler)=>handlers.push(handler),
-        close: jest.fn().mockResolvedValue(undefined),
-        isReady: ()=>true,
-        emit: (event)=>handlers.forEach((handler)=>handler(event))
-    };
-    return transport;
-}
-describe('HybridEventBus', ()=>{
-    const originalLabel = process.env.USE_EVENT_LABEL;
-    afterEach(async ()=>{
-        EventTransportRegistry.clear();
-        if (originalLabel === undefined) delete process.env.USE_EVENT_LABEL;
-        else process.env.USE_EVENT_LABEL = originalLabel;
-    });
-    it('should default to the memory transport', async ()=>{
-        const bus = new HybridEventBus();
-        await bus.connect();
-        expect(bus.getTransportLabel()).toBe('memory');
-        expect(bus.getActiveTransports()).toEqual([
-            'memory'
-        ]);
-        await bus.close();
-    });
-    it('should read the transport label from USE_EVENT_LABEL when not given explicitly', ()=>{
-        process.env.USE_EVENT_LABEL = 'kafka';
-        expect(new HybridEventBus().getTransportLabel()).toBe('kafka');
-    });
-    it('should prefer an explicit transport option over the env value', ()=>{
-        process.env.USE_EVENT_LABEL = 'kafka';
-        expect(new HybridEventBus({
-            transport: 'memory'
-        }).getTransportLabel()).toBe('memory');
-    });
-    it('should deliver a published event to a matching subscriber', async ()=>{
-        const bus = new HybridEventBus({
-            transport: 'memory'
-        });
-        const handler = jest.fn();
-        await bus.subscribe('storage.*.created', handler);
-        await bus.publish(buildEvent());
-        expect(handler).toHaveBeenCalledWith(expect.objectContaining({
-            name: 'storage.folder.created'
-        }));
-        await bus.close();
-    });
-    it('should not deliver an event to a non matching subscriber', async ()=>{
-        const bus = new HybridEventBus({
-            transport: 'memory'
-        });
-        const handler = jest.fn();
-        await bus.subscribe('auth.#', handler);
-        await bus.publish(buildEvent());
-        expect(handler).not.toHaveBeenCalled();
-        await bus.close();
-    });
-    it('should keep publishing when a handler throws', async ()=>{
-        const bus = new HybridEventBus({
-            transport: 'memory'
-        });
-        const failing = jest.fn().mockRejectedValue(new Error('boom'));
-        const healthy = jest.fn();
-        await bus.subscribe('**', failing);
-        await bus.subscribe('**', healthy);
-        await expect(bus.publish(buildEvent())).resolves.toBeUndefined();
-        expect(healthy).toHaveBeenCalled();
-        await bus.close();
-    });
-    it('should publish to both layers in hybrid mode and deliver each event once', async ()=>{
-        const broker = createFakeTransport('rabbitmq');
-        EventTransportRegistry.register('rabbitmq', ()=>broker);
-        const bus = new HybridEventBus({
-            transport: 'hybrid'
-        });
-        const handler = jest.fn();
-        await bus.subscribe('**', handler);
-        expect(bus.getActiveTransports()).toEqual([
-            'memory',
-            'rabbitmq'
-        ]);
-        const event = buildEvent();
-        await bus.publish(event);
-        // the broker loops the same event back to this process
-        broker.emit(event);
-        expect(broker.publish).toHaveBeenCalledWith(event);
-        expect(handler).toHaveBeenCalledTimes(1);
-        await bus.close();
-    });
-    it('should fall back to memory when the broker cannot start', async ()=>{
-        EventTransportRegistry.register('kafka', ()=>{
-            throw new Error('kafkajs not installed');
-        });
-        const bus = new HybridEventBus({
-            transport: 'kafka'
-        });
-        await bus.connect();
-        expect(bus.getActiveTransports()).toEqual([
-            'memory'
-        ]);
-        await bus.close();
-    });
-    it('should survive a transport that fails to publish', async ()=>{
-        const broker = createFakeTransport('rabbitmq');
-        broker.publish.mockRejectedValue(new Error('channel closed'));
-        EventTransportRegistry.register('rabbitmq', ()=>broker);
-        const bus = new HybridEventBus({
-            transport: 'rabbitmq'
-        });
-        await expect(bus.publish(buildEvent())).resolves.toBeUndefined();
-        await bus.close();
-    });
-    it('should not publish or throw while it has no working transport', async ()=>{
-        const connectSpy = jest.spyOn(MemoryTransport.prototype, 'connect').mockRejectedValueOnce(new Error('boot failure'));
-        const bus = new HybridEventBus({
-            transport: 'memory'
-        });
-        await expect(bus.publish(buildEvent())).resolves.toBeUndefined();
-        expect(bus.getActiveTransports()).toEqual([]);
-        connectSpy.mockRestore();
-        await bus.close();
-    });
-    it('should retry connecting after a failed attempt instead of staying dead', async ()=>{
-        const connectSpy = jest.spyOn(MemoryTransport.prototype, 'connect').mockRejectedValueOnce(new Error('boot failure'));
-        const bus = new HybridEventBus({
-            transport: 'memory'
-        });
-        const handler = jest.fn();
-        await bus.publish(buildEvent());
-        connectSpy.mockRestore();
-        await bus.subscribe('**', handler);
-        await bus.publish(buildEvent('storage.folder.created', 'event-2'));
-        expect(bus.getActiveTransports()).toEqual([
-            'memory'
-        ]);
-        expect(handler).toHaveBeenCalledTimes(1);
-        await bus.close();
-    });
-    it('should keep a subscription made while disconnected so a later connect binds it', async ()=>{
-        const connectSpy = jest.spyOn(MemoryTransport.prototype, 'connect').mockRejectedValueOnce(new Error('boot failure'));
-        const bus = new HybridEventBus({
-            transport: 'memory'
-        });
-        const handler = jest.fn();
-        await expect(bus.subscribe('**', handler)).resolves.toBeUndefined();
-        connectSpy.mockRestore();
-        await bus.publish(buildEvent());
-        expect(handler).toHaveBeenCalledTimes(1);
-        await bus.close();
-    });
-    it('should bind a subscription taken while disconnected on the broker that comes up later', async ()=>{
-        const broker = createFakeTransport('rabbitmq');
-        EventTransportRegistry.register('rabbitmq', ()=>broker);
-        const connectSpy = jest.spyOn(MemoryTransport.prototype, 'connect').mockRejectedValueOnce(new Error('boot failure'));
-        const bus = new HybridEventBus({
-            transport: 'hybrid'
-        });
-        await bus.subscribe('storage.#', jest.fn());
-        expect(broker.bind).not.toHaveBeenCalled();
-        connectSpy.mockRestore();
-        // Anything that reconnects must bind what is already subscribed, or the
-        // queue stays unbound and this process publishes without ever consuming
-        await bus.publish(buildEvent());
-        expect(broker.bind).toHaveBeenCalledWith('storage.#');
-        await bus.close();
-    });
-    it('should bind each pattern once, not again on every later subscribe', async ()=>{
-        const broker = createFakeTransport('rabbitmq');
-        EventTransportRegistry.register('rabbitmq', ()=>broker);
-        const bus = new HybridEventBus({
-            transport: 'rabbitmq'
-        });
-        await bus.subscribe('storage.#', jest.fn());
-        await bus.subscribe('auth.#', jest.fn());
-        expect(broker.bind.mock.calls.map(([pattern])=>pattern)).toEqual([
-            'storage.#',
-            'auth.#'
-        ]);
-        await bus.close();
-    });
-    it('should forget its transports after close', async ()=>{
-        const bus = new HybridEventBus({
-            transport: 'memory'
-        });
-        await bus.connect();
-        await bus.close();
-        expect(bus.getActiveTransports()).toEqual([]);
-    });
-});

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

@@ -1,228 +0,0 @@
-function _define_property(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
-import { envConfig } from '@flusys/nestjs-core/config';
-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;
-const DailyRotateFile = DailyRotateFileModule.default || DailyRotateFileModule;
-// Configuration
-const logConfig = envConfig.getLogConfig();
-const LOG_DIR = logConfig.dir;
-const LOG_LEVEL = logConfig.level;
-const LOG_MAX_SIZE = logConfig.maxSize;
-const LOG_MAX_FILES = logConfig.maxFiles;
-const USE_TENANT_MODE = envConfig.useTenantMode();
-// Ensure logs directory exists
-if (!existsSync(LOG_DIR)) {
-    mkdirSync(LOG_DIR, {
-        recursive: true
-    });
-}
-// Custom Formats
-/**
- * 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
-/**
- * Daily rotating file transport for all logs
- */ const combinedRotateTransport = new DailyRotateFile({
-    filename: `${LOG_DIR}/combined-%DATE%.log`,
-    datePattern: 'YYYY-MM-DD',
-    zippedArchive: true,
-    maxSize: LOG_MAX_SIZE,
-    maxFiles: LOG_MAX_FILES,
-    level: LOG_LEVEL
-});
-/**
- * Daily rotating file transport for error logs only
- */ const errorRotateTransport = new DailyRotateFile({
-    filename: `${LOG_DIR}/error-%DATE%.log`,
-    datePattern: 'YYYY-MM-DD',
-    zippedArchive: true,
-    maxSize: LOG_MAX_SIZE,
-    maxFiles: LOG_MAX_FILES,
-    level: 'error'
-});
-// 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: `${logDir}/combined-%DATE%.log`,
-        datePattern: 'YYYY-MM-DD',
-        zippedArchive: true,
-        maxSize: LOG_MAX_SIZE,
-        maxFiles: LOG_MAX_FILES,
-        level: LOG_LEVEL
-    });
-    cache.set(name, transport);
-    return 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;
-        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;
-    }
-};
-const tenantAwareCombinedTransport = new TenantAwareTransport(combinedRotateTransport);
-const consoleTransport = new transports.Console({
-    level: LOG_LEVEL,
-    format: format.combine(format.colorize({
-        all: true
-    }), format.timestamp({
-        format: 'YYYY-MM-DD HH:mm:ss'
-    }), format.errors({
-        stack: true
-    }), structuredFormat)
-});
-// Logger Instances
-/**
- * Development logger configuration
- * - Console output with colors
- * - Human-readable format
- * - Debug level by default
- */ const devLogger = createLogger({
-    level: LOG_LEVEL,
-    format: format.combine(format.timestamp({
-        format: 'YYYY-MM-DD HH:mm:ss'
-    }), format.errors({
-        stack: true
-    })),
-    transports: [
-        consoleTransport
-    ],
-    exitOnError: false
-});
-/**
- * Production logger configuration
- * - File-based logging with rotation
- * - JSON structured format
- * - Separate error log file
- * - Compressed old logs
- * - Tenant-aware routing (when USE_TENANT_MODE=true)
- */ const prodLogger = createLogger({
-    level: LOG_LEVEL,
-    format: format.combine(format.timestamp({
-        format: 'YYYY-MM-DD HH:mm:ss.SSS'
-    }), format.errors({
-        stack: true
-    }), structuredFormat),
-    transports: [
-        tenantAwareCombinedTransport,
-        errorRotateTransport
-    ],
-    exitOnError: false
-});
-// Exports
-/**
- * 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;
-}