nx-mongo 3.8.5 → 3.8.7

package/src/simpleMongoHelper.ts

@@ -1,182 +1,6 @@
 import { MongoClient, Db, Collection, Filter, UpdateFilter, OptionalUnlessRequiredId, Document, WithId, ClientSession, Sort, IndexSpecification, CreateIndexesOptions } from 'mongodb';
 import { createHash } from 'crypto';
-import { getEnvVariables, autoLoadConfig } from 'nx-config2';
-
-/**
- * Log levels ordered from lowest to highest severity
- */
-type LogLevel = 'verbose' | 'debug' | 'info' | 'warn' | 'error';
-
-/**
- * Log level numeric values for comparison (lower = more verbose)
- */
-const LOG_LEVEL_VALUES: Record<LogLevel, number> = {
-  verbose: 0,
-  debug: 1,
-  info: 2,
-  warn: 3,
-  error: 4,
-};
-
-/**
- * Console logger with environment-based level control
- */
-class ConsoleLogger {
-  private globalMinLevel: LogLevel;
-  private debugNamespaces: Set<string> = new Set();
-  private debugPatterns: string[] = [];
-
-  constructor() {
-    // Auto-load config from .env files
-    autoLoadConfig();
-    
-    // Get ENV_PREFIX from environment or use default
-    const envPrefix = process.env.ENV_PREFIX || '';
-    
-    // Read LOGS_LEVEL from environment
-    // Priority: {ENV_PREFIX}_LOG_LEVEL > LOGS_LEVEL > default 'info'
-    const logLevelEnv = (envPrefix ? process.env[`${envPrefix}_LOG_LEVEL`] : null) || 
-                        process.env.LOGS_LEVEL || 
-                        'info';
-    
-    // Validate and set global minimum level
-    if (this.isValidLogLevel(logLevelEnv)) {
-      this.globalMinLevel = logLevelEnv as LogLevel;
-    } else {
-      this.globalMinLevel = 'info';
-    }
-
-    // Parse DEBUG environment variable for namespace matching
-    const debugEnv = process.env.DEBUG || '';
-    if (debugEnv) {
-      const patterns = debugEnv.split(',').map(p => p.trim());
-      for (const pattern of patterns) {
-        if (pattern === '*') {
-          // Wildcard matches everything
-          this.debugPatterns.push('*');
-        } else {
-          // Store pattern for matching
-          this.debugPatterns.push(pattern);
-        }
-      }
-    }
-  }
-
-  /**
-   * Checks if a string is a valid log level
-   */
-  private isValidLogLevel(level: string): level is LogLevel {
-    return ['verbose', 'debug', 'info', 'warn', 'error'].includes(level);
-  }
-
-  /**
-   * Checks if a namespace matches any DEBUG pattern
-   */
-  private matchesDebugPattern(namespace: string): boolean {
-    if (this.debugPatterns.length === 0) {
-      return false;
-    }
-
-    for (const pattern of this.debugPatterns) {
-      if (pattern === '*') {
-        return true;
-      }
-      
-      // Simple wildcard matching: "my-pkg*" matches "my-pkg", "my-pkg:sub", etc.
-      if (pattern.endsWith('*')) {
-        const prefix = pattern.slice(0, -1);
-        if (namespace.startsWith(prefix)) {
-          return true;
-        }
-      } else if (pattern === namespace) {
-        return true;
-      }
-    }
-
-    return false;
-  }
-
-  /**
-   * Determines if a log entry should be printed to console
-   */
-  private shouldPrint(level: LogLevel, namespace?: string): boolean {
-    const levelValue = LOG_LEVEL_VALUES[level];
-    const minLevelValue = LOG_LEVEL_VALUES[this.globalMinLevel];
-
-    // Rule 1: Print if level >= global minimum level
-    if (levelValue >= minLevelValue) {
-      return true;
-    }
-
-    // Rule 2: Print verbose/debug if namespace matches DEBUG pattern
-    if ((level === 'verbose' || level === 'debug') && namespace) {
-      if (this.matchesDebugPattern(namespace)) {
-        return true;
-      }
-    }
-
-    return false;
-  }
-
-  /**
-   * Logs a message to console
-   */
-  log(level: LogLevel, message: string, namespace?: string, throwError: boolean = false): void {
-    if (!this.shouldPrint(level, namespace)) {
-      return;
-    }
-
-    // Format message with namespace if provided
-    const formattedMessage = namespace ? `[${namespace}] ${message}` : message;
-
-    // Use appropriate console method
-    switch (level) {
-      case 'verbose':
-      case 'debug':
-        console.debug(formattedMessage);
-        break;
-      case 'info':
-        console.info(formattedMessage);
-        break;
-      case 'warn':
-        console.warn(formattedMessage);
-        break;
-      case 'error':
-        console.error(formattedMessage);
-        // Errors throw by default unless explicitly disabled
-        if (throwError !== false) {
-          throw new Error(formattedMessage);
-        }
-        break;
-    }
-  }
-
-  /**
-   * Convenience methods for each log level
-   */
-  verbose(message: string, namespace?: string): void {
-    this.log('verbose', message, namespace, false);
-  }
-
-  debug(message: string, namespace?: string): void {
-    this.log('debug', message, namespace, false);
-  }
-
-  info(message: string, namespace?: string): void {
-    this.log('info', message, namespace, false);
-  }
-
-  warn(message: string, namespace?: string): void {
-    this.log('warn', message, namespace, false);
-  }
-
-  error(message: string, namespace?: string, throwError: boolean = true): void {
-    this.log('error', message, namespace, throwError);
-  }
-}
-
-// Singleton logger instance
-const logger = new ConsoleLogger();
+import { Logger } from 'micro-logs';
 
 export interface PaginationOptions {
   page?: number;
@@ -916,7 +740,7 @@ export class SimpleMongoHelper {
   public readonly progress: ProgressAPI;
   private cleanupRegistered: boolean = false;
   private isDisconnecting: boolean = false;
-  private namespace: string = 'nx-mongo';
+  private logger: Logger;
 
   constructor(connectionString: string, retryOptions?: RetryOptions, config?: HelperConfig) {
     // Store original connection string for database name extraction
@@ -931,6 +755,12 @@ export class SimpleMongoHelper {
     this.config = config || null;
     this.progress = new ProgressAPIImpl(this, config?.progress);
     
+    // Initialize logger with micro-logs
+    this.logger = new Logger({
+      packageName: 'nx-mongo',
+      debugNamespace: 'nx-mongo'
+    });
+    
     // Register automatic cleanup on process exit
     this.registerCleanup();
   }
@@ -942,7 +772,7 @@ export class SimpleMongoHelper {
    */
   useConfig(config: HelperConfig): this {
     this.config = config;
-    logger.debug('Configuration updated', this.namespace);
+    this.logger.debug('Configuration updated');
     return this;
   }
 
@@ -952,31 +782,35 @@ export class SimpleMongoHelper {
    * @returns This instance for method chaining
    */
   setNamespace(namespace: string): this {
-    this.namespace = namespace;
+    // Update logger with new namespace
+    this.logger = new Logger({
+      packageName: 'nx-mongo',
+      debugNamespace: namespace
+    });
     return this;
   }
 
   /**
-   * Logging methods - delegates to console logger
+   * Logging methods - delegates to micro-logs Logger
    */
-  logVerbose(message: string): void {
-    logger.verbose(message, this.namespace);
+  logVerbose(message: string, data?: any): void {
+    this.logger.verbose(message, data);
   }
 
-  logDebug(message: string): void {
-    logger.debug(message, this.namespace);
+  logDebug(message: string, data?: any): void {
+    this.logger.debug(message, data);
   }
 
-  logInfo(message: string): void {
-    logger.info(message, this.namespace);
+  logInfo(message: string, data?: any): void {
+    this.logger.info(message, data);
   }
 
-  logWarn(message: string): void {
-    logger.warn(message, this.namespace);
+  logWarn(message: string, data?: any): void {
+    this.logger.warn(message, data);
   }
 
-  logError(message: string, throwError: boolean = true): void {
-    logger.error(message, this.namespace, throwError);
+  logError(message: string, data?: any): void {
+    this.logger.error(message, data);
   }
 
   /**
@@ -1240,10 +1074,12 @@ export class SimpleMongoHelper {
    */
   async initialize(options?: { connectionString?: string; databaseName?: string }): Promise<void> {
     if (this.isInitialized) {
-      this.logError('SimpleMongoHelper is already initialized');
+      const errorMsg = 'SimpleMongoHelper is already initialized';
+      this.logError(errorMsg);
+      throw new Error(errorMsg);
     }
 
-    logger.debug('Initializing MongoDB connection', this.namespace);
+    this.logger.debug('Initializing MongoDB connection');
     
     // Use provided connection string or original (not stripped) connection string
     const connectionString = options?.connectionString || this.originalConnectionString;
@@ -1260,14 +1096,18 @@ export class SimpleMongoHelper {
     
     // ✅ Validate database name
     if (dbName && !isValidDatabaseName(dbName)) {
-      this.logError(`Invalid database name: '${dbName}'. Database names cannot contain: / ? & =`);
+      const errorMsg = `Invalid database name: '${dbName}'. Database names cannot contain: / ? & =`;
+      this.logError(errorMsg);
+      throw new Error(errorMsg);
     }
     
     if (!dbName) {
-      this.logError('Database name is required. Provide databaseName parameter or include it in connection string path.');
+      const errorMsg = 'Database name is required. Provide databaseName parameter or include it in connection string path.';
+      this.logError(errorMsg);
+      throw new Error(errorMsg);
     }
     
-    logger.debug(`Using database: ${dbName}`, this.namespace);
+    this.logger.debug(`Using database: ${dbName}`);
     
     // ✅ Clean connection string if databaseName was provided separately
     // (to avoid using database name from URI path when we have explicit databaseName)
@@ -1278,32 +1118,34 @@ export class SimpleMongoHelper {
     let lastError: Error | null = null;
     for (let attempt = 0; attempt <= this.retryOptions.maxRetries!; attempt++) {
       try {
-        logger.verbose(`Connection attempt ${attempt + 1}/${this.retryOptions.maxRetries! + 1}`, this.namespace);
+        this.logger.verbose(`Connection attempt ${attempt + 1}/${this.retryOptions.maxRetries! + 1}`);
         this.client = new MongoClient(cleanUri);
         await this.client.connect();
         // Use the resolved database name
         this.db = this.client.db(dbName);
         this.isInitialized = true;
-        logger.info(`Successfully connected to MongoDB database: ${dbName}`, this.namespace);
+        this.logger.info(`Successfully connected to MongoDB database: ${dbName}`);
         return;
       } catch (error) {
         lastError = error instanceof Error ? error : new Error(String(error));
         this.client = null;
         this.db = null;
         
-        logger.warn(`Connection attempt ${attempt + 1} failed: ${lastError.message}`, this.namespace);
+        this.logger.warn(`Connection attempt ${attempt + 1} failed: ${lastError.message}`);
         
         if (attempt < this.retryOptions.maxRetries!) {
           const delay = this.retryOptions.exponentialBackoff
             ? this.retryOptions.retryDelay! * Math.pow(2, attempt)
             : this.retryOptions.retryDelay!;
-          logger.debug(`Retrying in ${delay}ms...`, this.namespace);
+          this.logger.debug(`Retrying in ${delay}ms...`);
           await new Promise(resolve => setTimeout(resolve, delay));
         }
       }
     }
     
-    this.logError(`Failed to initialize MongoDB connection after ${this.retryOptions.maxRetries! + 1} attempts: ${lastError?.message}`);
+    const errorMsg = `Failed to initialize MongoDB connection after ${this.retryOptions.maxRetries! + 1} attempts: ${lastError?.message}`;
+    this.logError(errorMsg);
+    throw new Error(errorMsg);
   }
 
   /**