nx-mongo 3.8.1 → 3.8.3

package/src/simpleMongoHelper.ts

@@ -1,5 +1,182 @@
 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();
 
 export interface PaginationOptions {
   page?: number;
@@ -351,6 +528,94 @@ export function computeSignature(
   return hash.digest('hex');
 }
 
+/**
+ * Extracts database name from MongoDB connection string URI.
+ * Only extracts from pathname, NOT from query parameters.
+ * @param uri - MongoDB connection string
+ * @returns Database name or null if not found
+ */
+function extractDatabaseNameFromUri(uri: string): string | null {
+  try {
+    const url = new URL(uri);
+    // Only extract from pathname, NOT from query parameters
+    const dbName = url.pathname ? url.pathname.slice(1) : null; // Remove leading /
+    
+    // Validate: database name should not contain query parameter values
+    if (dbName && (dbName.includes('?') || dbName.includes('&') || dbName.includes('='))) {
+      // This means we're incorrectly parsing query params
+      return null; // Don't use invalid database name
+    }
+    
+    return dbName || null;
+  } catch (error) {
+    // Fallback: regex approach
+    // Match: mongodb://.../databaseName?query
+    // Don't match: mongodb://...?authSource=admin (no path)
+    const pathMatch = uri.match(/mongodb:\/\/[^\/]+\/([^\/\?]+)(\?|$)/);
+    if (pathMatch && pathMatch[1]) {
+      return pathMatch[1];
+    }
+    return null;
+  }
+}
+
+/**
+ * Validates a MongoDB database name according to MongoDB rules.
+ * @param dbName - Database name to validate
+ * @returns true if valid, false otherwise
+ */
+function isValidDatabaseName(dbName: string): boolean {
+  if (!dbName || typeof dbName !== 'string') {
+    return false;
+  }
+  
+  // Database names cannot contain: / ? & = 
+  // These are URL/query parameter characters
+  if (dbName.includes('/') || dbName.includes('?') || dbName.includes('&') || dbName.includes('=')) {
+    return false;
+  }
+  
+  // Database names cannot be empty or just whitespace
+  if (dbName.trim().length === 0) {
+    return false;
+  }
+  
+  // MongoDB database name rules
+  // Cannot contain: / \ . " $ * < > : | ?
+  const invalidChars = /[\/\\\.\"\$*<>:|?]/;
+  if (invalidChars.test(dbName)) {
+    return false;
+  }
+  
+  // Cannot start or end with space or dot
+  if (dbName.trim() !== dbName || dbName.startsWith('.') || dbName.endsWith('.')) {
+    return false;
+  }
+  
+  return true;
+}
+
+/**
+ * Cleans a connection string by removing database name from URI path.
+ * Preserves query parameters (authSource, etc.).
+ * @param uri - MongoDB connection string
+ * @returns Cleaned connection string without database name in path
+ */
+function cleanConnectionString(uri: string): string {
+  // Remove database name from URI path
+  // Preserve query parameters (authSource, etc.)
+  try {
+    const url = new URL(uri);
+    url.pathname = ''; // Remove database name from path
+    return url.toString().replace(/\/\?/g, '?').replace(/\/$/, '');
+  } catch (error) {
+    // Fallback: regex approach
+    return uri.replace(/\/[^\/\?]+(\?|$)/, (match, query) => {
+      return query === '?' ? '?' : '';
+    }).replace(/\/$/, '');
+  }
+}
+
 /**
  * Internal class that implements the ProgressAPI interface for stage tracking.
  */
@@ -642,6 +907,7 @@ class ProgressAPIImpl implements ProgressAPI {
 
 export class SimpleMongoHelper {
   private connectionString: string;
+  private originalConnectionString: string; // Store original for database name extraction
   private client: MongoClient | null = null;
   protected db: Db | null = null;
   private isInitialized: boolean = false;
@@ -650,9 +916,12 @@ export class SimpleMongoHelper {
   public readonly progress: ProgressAPI;
   private cleanupRegistered: boolean = false;
   private isDisconnecting: boolean = false;
+  private namespace: string = 'nx-mongo';
 
   constructor(connectionString: string, retryOptions?: RetryOptions, config?: HelperConfig) {
-    // Strip database name from connection string if present
+    // Store original connection string for database name extraction
+    this.originalConnectionString = connectionString;
+    // Strip database name from connection string if present (for backward compatibility)
     this.connectionString = this.stripDatabaseFromConnectionString(connectionString);
     this.retryOptions = {
       maxRetries: retryOptions?.maxRetries ?? 3,
@@ -673,9 +942,43 @@ export class SimpleMongoHelper {
    */
   useConfig(config: HelperConfig): this {
     this.config = config;
+    logger.debug('Configuration updated', this.namespace);
+    return this;
+  }
+
+  /**
+   * Sets the logging namespace for this instance
+   * @param namespace - Namespace string for logging
+   * @returns This instance for method chaining
+   */
+  setNamespace(namespace: string): this {
+    this.namespace = namespace;
     return this;
   }
 
+  /**
+   * Logging methods - delegates to console logger
+   */
+  logVerbose(message: string): void {
+    logger.verbose(message, this.namespace);
+  }
+
+  logDebug(message: string): void {
+    logger.debug(message, this.namespace);
+  }
+
+  logInfo(message: string): void {
+    logger.info(message, this.namespace);
+  }
+
+  logWarn(message: string): void {
+    logger.warn(message, this.namespace);
+  }
+
+  logError(message: string, throwError: boolean = true): void {
+    logger.error(message, this.namespace, throwError);
+  }
+
   /**
    * Tests the MongoDB connection and returns detailed error information if it fails.
    * This method does not establish a persistent connection - use initialize() for that.
@@ -930,37 +1233,77 @@ export class SimpleMongoHelper {
   /**
    * Establishes MongoDB connection internally with retry logic.
    * Must be called before using other methods.
+   * @param options - Optional initialization options
+   * @param options.connectionString - Connection string (overrides constructor value if provided)
+   * @param options.databaseName - Database name (takes priority over URI extraction)
    * @throws Error if connection fails or if already initialized
    */
-  async initialize(): Promise<void> {
+  async initialize(options?: { connectionString?: string; databaseName?: string }): Promise<void> {
     if (this.isInitialized) {
-      throw new Error('SimpleMongoHelper is already initialized');
+      this.logError('SimpleMongoHelper is already initialized');
     }
 
+    logger.debug('Initializing MongoDB connection', this.namespace);
+    
+    // Use provided connection string or original (not stripped) connection string
+    const connectionString = options?.connectionString || this.originalConnectionString;
+    
+    // ✅ Priority 1: Use provided databaseName parameter
+    let dbName: string | undefined = options?.databaseName;
+    const dbNameProvided = !!dbName;
+    
+    // ✅ Priority 2: Only extract from URI if databaseName not provided
+    if (!dbName) {
+      const extractedDbName = extractDatabaseNameFromUri(connectionString);
+      dbName = extractedDbName || undefined;
+    }
+    
+    // ✅ Validate database name
+    if (dbName && !isValidDatabaseName(dbName)) {
+      this.logError(`Invalid database name: '${dbName}'. Database names cannot contain: / ? & =`);
+    }
+    
+    if (!dbName) {
+      this.logError('Database name is required. Provide databaseName parameter or include it in connection string path.');
+    }
+    
+    logger.debug(`Using database: ${dbName}`, this.namespace);
+    
+    // ✅ Clean connection string if databaseName was provided separately
+    // (to avoid using database name from URI path when we have explicit databaseName)
+    const cleanUri = dbNameProvided ? 
+                     cleanConnectionString(connectionString) : 
+                     connectionString;
+
     let lastError: Error | null = null;
     for (let attempt = 0; attempt <= this.retryOptions.maxRetries!; attempt++) {
       try {
-        this.client = new MongoClient(this.connectionString);
+        logger.verbose(`Connection attempt ${attempt + 1}/${this.retryOptions.maxRetries! + 1}`, this.namespace);
+        this.client = new MongoClient(cleanUri);
         await this.client.connect();
-        // Default to 'admin' database for initial connection (not used for operations)
-        this.db = this.client.db('admin');
+        // Use the resolved database name
+        this.db = this.client.db(dbName);
         this.isInitialized = true;
+        logger.info(`Successfully connected to MongoDB database: ${dbName}`, this.namespace);
         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);
+        
         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);
           await new Promise(resolve => setTimeout(resolve, delay));
         }
       }
     }
     
-    throw new Error(`Failed to initialize MongoDB connection after ${this.retryOptions.maxRetries! + 1} attempts: ${lastError?.message}`);
+    this.logError(`Failed to initialize MongoDB connection after ${this.retryOptions.maxRetries! + 1} attempts: ${lastError?.message}`);
   }
 
   /**
@@ -1020,7 +1363,9 @@ export class SimpleMongoHelper {
       const results = await cursor.toArray();
       return results;
     } catch (error) {
-      throw new Error(`Failed to load collection '${collectionName}': ${error instanceof Error ? error.message : String(error)}`);
+      const errorMsg = `Failed to load collection '${collectionName}': ${error instanceof Error ? error.message : String(error)}`;
+      this.logError(errorMsg);
+      throw new Error(errorMsg); // TypeScript control flow
     }
   }
 
@@ -1057,7 +1402,9 @@ export class SimpleMongoHelper {
       const result = await collection.findOne(query, findOptions);
       return result;
     } catch (error) {
-      throw new Error(`Failed to find document in collection '${collectionName}': ${error instanceof Error ? error.message : String(error)}`);
+      const errorMsg = `Failed to find document in collection '${collectionName}': ${error instanceof Error ? error.message : String(error)}`;
+      this.logError(errorMsg);
+      throw new Error(errorMsg); // TypeScript control flow
     }
   }
 
@@ -1092,7 +1439,9 @@ export class SimpleMongoHelper {
         return result;
       }
     } catch (error) {
-      throw new Error(`Failed to insert into collection '${collectionName}': ${error instanceof Error ? error.message : String(error)}`);
+      const errorMsg = `Failed to insert into collection '${collectionName}': ${error instanceof Error ? error.message : String(error)}`;
+      this.logError(errorMsg);
+      throw new Error(errorMsg); // TypeScript control flow
     }
   }
 
@@ -1131,7 +1480,9 @@ export class SimpleMongoHelper {
         return result;
       }
     } catch (error) {
-      throw new Error(`Failed to update collection '${collectionName}': ${error instanceof Error ? error.message : String(error)}`);
+      const errorMsg = `Failed to update collection '${collectionName}': ${error instanceof Error ? error.message : String(error)}`;
+      this.logError(errorMsg);
+      throw new Error(errorMsg); // TypeScript control flow
     }
   }
 
@@ -1165,7 +1516,9 @@ export class SimpleMongoHelper {
         return result;
       }
     } catch (error) {
-      throw new Error(`Failed to delete from collection '${collectionName}': ${error instanceof Error ? error.message : String(error)}`);
+      const errorMsg = `Failed to delete from collection '${collectionName}': ${error instanceof Error ? error.message : String(error)}`;
+      this.logError(errorMsg);
+      throw new Error(errorMsg); // TypeScript control flow
     }
   }
 

package/test-connection.ts

@@ -1,47 +0,0 @@
-import { SimpleMongoHelper } from './src/simpleMongoHelper';
-
-async function testConnection() {
-  // Test with the connection string from the blocker report
-  const connectionString = 'mongodb://localhost:27017/';
-  const helper = new SimpleMongoHelper(connectionString);
-
-  console.log('Testing MongoDB connection...');
-  console.log(`Connection String: ${connectionString}`);
-  console.log(`Database: server`);
-  console.log('');
-
-  const result = await helper.testConnection();
-
-  if (result.success) {
-    console.log('✅ Connection test passed!');
-    console.log('You can now call helper.initialize() to establish a persistent connection.');
-  } else {
-    console.error('❌ Connection test failed!');
-    console.error('');
-    console.error('Error Type:', result.error?.type);
-    console.error('Error Message:', result.error?.message);
-    console.error('Error Details:', result.error?.details);
-    console.error('');
-    
-    // Show full error object for debugging
-    console.error('Full error object:');
-    console.error(JSON.stringify(result.error, null, 2));
-    
-    // Provide troubleshooting tips
-    console.error('');
-    console.error('Troubleshooting tips:');
-    if (result.error?.type === 'connection_failed') {
-      console.error('  - Try using 127.0.0.1 instead of localhost');
-      console.error('  - Verify MongoDB is running: mongosh --eval "db.version()"');
-      console.error('  - Check if MongoDB is listening on port 27017');
-      console.error('  - Check Windows Firewall settings');
-    }
-  }
-}
-
-// Run the test
-testConnection().catch((error) => {
-  console.error('Unexpected error:', error);
-  process.exit(1);
-});
-