@intranefr/superbackend 1.5.1 → 1.5.3

package/src/helpers/mongooseHelper.js

@@ -0,0 +1,258 @@
+const mongoose = require('mongoose');
+
+/**
+ * Mongoose connection state management
+ * Provides centralized connection handling with reference counting and automatic cleanup
+ */
+class MongooseHelper {
+  constructor() {
+    this.connectionPromise = null;
+    this.isConnected = false;
+    this.connectionCount = 0;
+    this.connectionOptions = null;
+  }
+
+  /**
+   * Get MongoDB URI from environment with fallbacks
+   * @returns {string} MongoDB connection URI
+   */
+  getMongoUri() {
+    const uri = process.env.MONGODB_URI || process.env.MONGO_URI || 'mongodb://localhost:27017/myappdb';
+    if (!uri) {
+      throw new Error('Missing MONGODB_URI or MONGO_URI environment variable');
+    }
+    return uri;
+  }
+
+  /**
+   * Get mongoose connection options
+   * @returns {Object} Connection options
+   */
+  getConnectionOptions() {
+    if (this.connectionOptions) {
+      return this.connectionOptions;
+    }
+
+    this.connectionOptions = {
+      serverSelectionTimeoutMS: 5000,
+      maxPoolSize: 2, // Conservative for scripts
+      bufferCommands: false,
+      // Add retry settings for reliability
+      retryWrites: true,
+      retryReads: true,
+      // Add socket settings for scripts
+      socketTimeoutMS: 30000,
+      connectTimeoutMS: 10000,
+    };
+
+    return this.connectionOptions;
+  }
+
+  /**
+   * Connect to MongoDB (singleton pattern)
+   * @returns {Promise<mongoose.Connection>} Mongoose connection
+   */
+  async connect() {
+    // Return existing connection if already connected
+    if (this.isConnected && mongoose.connection.readyState === 1) {
+      this.connectionCount++;
+      return mongoose.connection;
+    }
+
+    // Return existing promise if connection is in progress
+    if (this.connectionPromise) {
+      await this.connectionPromise;
+      this.connectionCount++;
+      return mongoose.connection;
+    }
+
+    // Create new connection promise
+    this.connectionPromise = this._createConnection();
+    await this.connectionPromise;
+    this.connectionCount++;
+    return mongoose.connection;
+  }
+
+  /**
+   * Internal connection creation
+   * @private
+   * @returns {Promise<mongoose.Connection>}
+   */
+  async _createConnection() {
+    try {
+      const uri = this.getMongoUri();
+      const options = this.getConnectionOptions();
+      
+      if (!process.env.TUI_MODE) console.log(`[MongooseHelper] Connecting to MongoDB...`);
+      
+      // Clear any existing connection
+      if (mongoose.connection.readyState !== 0) {
+        await mongoose.disconnect();
+      }
+      
+      await mongoose.connect(uri, options);
+      
+      this.isConnected = true;
+      
+      if (!process.env.TUI_MODE) console.log(`[MongooseHelper] ✅ Connected to MongoDB`);
+      
+      // Setup connection error handling
+      mongoose.connection.on('error', (error) => {
+        console.error('[MongooseHelper] Connection error:', error);
+        this.isConnected = false;
+        this.connectionPromise = null;
+      });
+
+      mongoose.connection.on('disconnected', () => {
+        if (!process.env.TUI_MODE) console.log('[MongooseHelper] Disconnected from MongoDB');
+        this.isConnected = false;
+        this.connectionPromise = null;
+      });
+
+      mongoose.connection.on('reconnected', () => {
+        if (!process.env.TUI_MODE) console.log('[MongooseHelper] Reconnected to MongoDB');
+        this.isConnected = true;
+      });
+
+      return mongoose.connection;
+    } catch (error) {
+      this.connectionPromise = null;
+      throw error;
+    }
+  }
+
+  /**
+   * Disconnect from MongoDB (reference counting)
+   * @returns {Promise<void>}
+   */
+  async disconnect() {
+    if (!this.isConnected) {
+      return;
+    }
+
+    this.connectionCount--;
+    
+    // Only disconnect if no more references
+    if (this.connectionCount <= 0) {
+      try {
+        await mongoose.disconnect();
+        if (!process.env.TUI_MODE) console.log('[MongooseHelper] ✅ Disconnected from MongoDB');
+      } catch (error) {
+        console.error('[MongooseHelper] Disconnect error:', error);
+      } finally {
+        this.isConnected = false;
+        this.connectionPromise = null;
+        this.connectionCount = 0;
+      }
+    }
+  }
+
+  /**
+   * Force disconnect regardless of reference count
+   * @returns {Promise<void>}
+   */
+  async forceDisconnect() {
+    try {
+      if (mongoose.connection.readyState !== 0) {
+        await mongoose.disconnect();
+        if (!process.env.TUI_MODE) console.log('[MongooseHelper] ✅ Force disconnected from MongoDB');
+      }
+    } catch (error) {
+      console.error('[MongooseHelper] Force disconnect error:', error);
+    } finally {
+      this.isConnected = false;
+      this.connectionPromise = null;
+      this.connectionCount = 0;
+    }
+  }
+
+  /**
+   * Get connection status
+   * @returns {Object} Connection status info
+   */
+  getStatus() {
+    const readyStateMap = {
+      0: 'disconnected',
+      1: 'connected',
+      2: 'connecting',
+      3: 'disconnecting'
+    };
+
+    return {
+      isConnected: this.isConnected,
+      readyState: mongoose.connection.readyState,
+      readyStateText: readyStateMap[mongoose.connection.readyState] || 'unknown',
+      connectionCount: this.connectionCount,
+      host: mongoose.connection.host,
+      port: mongoose.connection.port,
+      name: mongoose.connection.name,
+      hasActiveConnection: mongoose.connection.readyState === 1
+    };
+  }
+
+  /**
+   * Execute function with automatic connection management
+   * @param {Function} fn - Async function to execute
+   * @param {Object} options - Options
+   * @returns {Promise<any>} Function result
+   */
+  async withConnection(fn, options = {}) {
+    await this.connect();
+    
+    try {
+      const result = await fn(mongoose);
+      return result;
+    } finally {
+      if (options.autoDisconnect !== false) {
+        await this.disconnect();
+      }
+    }
+  }
+
+  /**
+   * Wait for connection to be ready
+   * @param {number} timeout - Timeout in milliseconds
+   * @returns {Promise<void>}
+   */
+  async waitForConnection(timeout = 10000) {
+    const startTime = Date.now();
+    
+    while (mongoose.connection.readyState !== 1) {
+      if (Date.now() - startTime > timeout) {
+        throw new Error(`Connection timeout after ${timeout}ms`);
+      }
+      
+      if (mongoose.connection.readyState === 0) {
+        throw new Error('Connection is disconnected');
+      }
+      
+      await new Promise(resolve => setTimeout(resolve, 100));
+    }
+  }
+
+  /**
+   * Reset the helper state (useful for testing)
+   */
+  reset() {
+    this.connectionPromise = null;
+    this.isConnected = false;
+    this.connectionCount = 0;
+    this.connectionOptions = null;
+  }
+}
+
+// Singleton instance
+const mongooseHelper = new MongooseHelper();
+
+module.exports = {
+  MongooseHelper,
+  mongooseHelper,
+  connect: () => mongooseHelper.connect(),
+  disconnect: () => mongooseHelper.disconnect(),
+  forceDisconnect: () => mongooseHelper.forceDisconnect(),
+  withConnection: (fn, options) => mongooseHelper.withConnection(fn, options),
+  getStatus: () => mongooseHelper.getStatus(),
+  getMongoUri: () => mongooseHelper.getMongoUri(),
+  waitForConnection: (timeout) => mongooseHelper.waitForConnection(timeout),
+  reset: () => mongooseHelper.reset()
+};

package/src/helpers/scriptBase.js

@@ -0,0 +1,230 @@
+const { mongooseHelper } = require('./mongooseHelper');
+
+/**
+ * Base class for scripts with database connectivity
+ * Provides automatic connection management and error handling
+ */
+class ScriptBase {
+  constructor(options = {}) {
+    this.name = options.name || this.constructor.name;
+    this.autoDisconnect = options.autoDisconnect !== false;
+    this.timeout = options.timeout || 300000; // 5 minutes default
+    this.startTime = null;
+    this.context = null;
+  }
+
+  /**
+   * Main script execution method (to be implemented by subclasses)
+   * @param {Object} context - Execution context with mongoose instance
+   * @returns {Promise<any>} Script result
+   */
+  async execute(context) {
+    throw new Error('execute method must be implemented by subclass');
+  }
+
+  /**
+   * Setup method called before execution (optional override)
+   * @param {Object} context - Execution context
+   * @returns {Promise<void>}
+   */
+  async setup(context) {
+    // Override in subclasses if needed
+  }
+
+  /**
+   * Cleanup method called after execution (optional override)
+   * @param {Object} context - Execution context
+   * @returns {Promise<void>}
+   */
+  async cleanup(context) {
+    // Override in subclasses if needed
+  }
+
+  /**
+   * Run the script with automatic database connection management
+   * @returns {Promise<any>} Script result
+   */
+  async run() {
+    this.startTime = Date.now();
+    
+    // Set up timeout handling
+    const timeoutPromise = new Promise((_, reject) => {
+      setTimeout(() => {
+        reject(new Error(`Script ${this.name} timed out after ${this.timeout}ms`));
+      }, this.timeout);
+    });
+
+    try {
+      if (!process.env.TUI_MODE) console.log(`[${this.name}] Starting script execution...`);
+      
+      const executionPromise = this._executeWithConnection();
+      const result = await Promise.race([executionPromise, timeoutPromise]);
+
+      const duration = Date.now() - this.startTime;
+      if (!process.env.TUI_MODE) console.log(`[${this.name}] ✅ Completed in ${duration}ms`);
+      
+      return result;
+    } catch (error) {
+      const duration = Date.now() - this.startTime;
+      console.error(`[${this.name}] ❌ Failed after ${duration}ms:`, error.message);
+      
+      // Ensure cleanup on error
+      await this._handleError(error);
+      throw error;
+    }
+  }
+
+  /**
+   * Internal execution method with connection management
+   * @private
+   * @returns {Promise<any>}
+   */
+  async _executeWithConnection() {
+    return await mongooseHelper.withConnection(
+      async (mongoose) => {
+        // Create execution context
+        this.context = {
+          mongoose,
+          models: mongoose.models,
+          connection: mongoose.connection,
+          db: mongoose.connection.db,
+          script: {
+            name: this.name,
+            startTime: this.startTime,
+            timeout: this.timeout
+          }
+        };
+
+        // Call setup
+        await this.setup(this.context);
+
+        try {
+          // Execute main logic
+          const result = await this.execute(this.context);
+          return result;
+        } finally {
+          // Call cleanup
+          await this.cleanup(this.context);
+        }
+      },
+      { autoDisconnect: this.autoDisconnect }
+    );
+  }
+
+  /**
+   * Handle script errors and cleanup
+   * @private
+   * @param {Error} error - The error that occurred
+   */
+  async _handleError(error) {
+    try {
+      // Call cleanup with error context if available
+      if (this.context) {
+        await this.cleanup(this.context);
+      }
+    } catch (cleanupError) {
+      console.error(`[${this.name}] Cleanup error:`, cleanupError.message);
+    }
+
+    // Force disconnect on error
+    await mongooseHelper.forceDisconnect();
+  }
+
+  /**
+   * Get script execution status
+   * @returns {Object} Status information
+   */
+  getStatus() {
+    return {
+      name: this.name,
+      isRunning: this.startTime !== null,
+      startTime: this.startTime,
+      duration: this.startTime ? Date.now() - this.startTime : null,
+      timeout: this.timeout,
+      autoDisconnect: this.autoDisconnect,
+      connectionStatus: mongooseHelper.getStatus()
+    };
+  }
+
+  /**
+   * Validate script configuration
+   * @returns {Object} Validation result
+   */
+  validate() {
+    const errors = [];
+    const warnings = [];
+
+    // Check if execute method is implemented
+    if (this.execute === ScriptBase.prototype.execute) {
+      errors.push('execute method must be implemented');
+    }
+
+    // Check timeout value
+    if (this.timeout <= 0) {
+      errors.push('timeout must be greater than 0');
+    }
+
+    if (this.timeout > 3600000) { // 1 hour
+      warnings.push('timeout is very long (> 1 hour)');
+    }
+
+    // Check environment
+    if (!process.env.MONGODB_URI && !process.env.MONGO_URI) {
+      warnings.push('No MongoDB URI environment variable set, will use localhost');
+    }
+
+    return {
+      valid: errors.length === 0,
+      errors,
+      warnings
+    };
+  }
+
+  /**
+   * Create a child script with inherited configuration
+   * @param {Function} ChildScriptClass - Child script class
+   * @param {Object} options - Additional options for child
+   * @returns {ScriptBase} Child script instance
+   */
+  createChild(ChildScriptClass, options = {}) {
+    const childOptions = {
+      timeout: this.timeout,
+      autoDisconnect: this.autoDisconnect,
+      ...options
+    };
+
+    return new ChildScriptClass(childOptions);
+  }
+
+  /**
+   * Log script message with consistent formatting
+   * @param {string} level - Log level (info, warn, error, debug)
+   * @param {string} message - Message to log
+   * @param {any} data - Additional data to log
+   */
+  log(level, message, data = null) {
+    const timestamp = new Date().toISOString();
+    const prefix = `[${timestamp}][${this.name}]`;
+    
+    switch (level) {
+      case 'info':
+        console.log(`${prefix} ${message}`, data || '');
+        break;
+      case 'warn':
+        console.warn(`${prefix} ⚠️  ${message}`, data || '');
+        break;
+      case 'error':
+        console.error(`${prefix} ❌ ${message}`, data || '');
+        break;
+      case 'debug':
+        if (process.env.DEBUG || process.env.NODE_ENV === 'development') {
+          console.debug(`${prefix} 🔍 ${message}`, data || '');
+        }
+        break;
+      default:
+        console.log(`${prefix} ${message}`, data || '');
+    }
+  }
+}
+
+module.exports = { ScriptBase };