@intranefr/superbackend 1.5.0 → 1.5.2

package/src/controllers/metrics.controller.js

@@ -55,14 +55,35 @@ async function tryAttachUser(req) {
 
 exports.track = async (req, res) => {
   try {
+    // Validate request size to prevent abuse
+    const contentLength = req.headers['content-length'];
+    if (contentLength && parseInt(contentLength) > 1024 * 10) { // 10KB limit
+      return res.status(413).json({ error: 'Request too large' });
+    }
+
     await tryAttachUser(req);
 
     const action = String(req.body?.action || '').trim();
     const meta = req.body?.meta ?? null;
 
+    // Validate action field
     if (!action) {
       return res.status(400).json({ error: 'action is required' });
     }
+    
+    if (action.length > 100) {
+      return res.status(400).json({ error: 'action too long (max 100 characters)' });
+    }
+    
+    // Validate action format (allow only alphanumeric, underscores, hyphens, dots)
+    if (!/^[a-zA-Z0-9._-]+$/.test(action)) {
+      return res.status(400).json({ error: 'invalid action format' });
+    }
+
+    // Validate meta size
+    if (meta && JSON.stringify(meta).length > 1024 * 5) { // 5KB limit
+      return res.status(400).json({ error: 'meta data too large' });
+    }
 
     let actorType = 'anonymous';
     let actorId = getAnonId(req);
@@ -98,12 +119,48 @@ exports.track = async (req, res) => {
 
 exports.getImpact = async (req, res) => {
   try {
-    const { start, end } = getMonthRange(new Date());
+    // Validate query parameters
+    const { start, end } = req.query;
+    
+    // Allow custom time ranges but restrict to reasonable limits
+    let startTime, endTime;
+    
+    if (start || end) {
+      // Parse custom range if provided
+      startTime = start ? new Date(start) : null;
+      endTime = end ? new Date(end) : null;
+      
+      // Validate dates
+      if ((start && isNaN(startTime.getTime())) || (end && isNaN(endTime.getTime()))) {
+        return res.status(400).json({ error: 'Invalid date format' });
+      }
+      
+      // Restrict range to maximum 1 year
+      if (startTime && endTime) {
+        const rangeMs = endTime.getTime() - startTime.getTime();
+        const maxRangeMs = 365 * 24 * 60 * 60 * 1000; // 1 year
+        if (rangeMs > maxRangeMs) {
+          return res.status(400).json({ error: 'Time range too large (max 1 year)' });
+        }
+      }
+      
+      // Default to current month if range is incomplete
+      if (!startTime || !endTime) {
+        const currentMonth = getMonthRange(new Date());
+        startTime = startTime || currentMonth.start;
+        endTime = endTime || currentMonth.end;
+      }
+    } else {
+      // Default to current month
+      const currentMonth = getMonthRange(new Date());
+      startTime = currentMonth.start;
+      endTime = currentMonth.end;
+    }
 
     const activeActorsAgg = await ActionEvent.aggregate([
       {
         $match: {
-          createdAt: { $gte: start, $lt: end },
+          createdAt: { $gte: startTime, $lt: endTime },
           actorType: { $in: ['user', 'anonymous'] },
         },
       },
@@ -122,7 +179,7 @@ exports.getImpact = async (req, res) => {
 
     const servicesConsulted = await ActionEvent.countDocuments({
       action: 'service_view',
-      createdAt: { $gte: start, $lt: end },
+      createdAt: { $gte: startTime, $lt: endTime },
     });
 
     const newsletterSetting = await GlobalSetting.findOne({ key: 'newsletter_list' }).lean();
@@ -136,8 +193,11 @@ exports.getImpact = async (req, res) => {
       }
     }
 
+    // Add cache headers for better performance
+    res.set('Cache-Control', 'public, max-age=300'); // 5 minutes cache
+
     return res.json({
-      range: { start: start.toISOString(), end: end.toISOString() },
+      range: { start: startTime.toISOString(), end: endTime.toISOString() },
       activeUsers,
       servicesConsulted,
       newsletterSubscribers,

package/src/controllers/orgAdmin.controller.js

@@ -270,6 +270,86 @@ exports.removeMember = async (req, res) => {
   }
 };
 
+exports.addMember = async (req, res) => {
+  try {
+    const { orgId } = req.params;
+    const { userId, role } = req.body;
+
+    if (!orgId || !mongoose.Types.ObjectId.isValid(String(orgId))) {
+      return res.status(400).json({ error: 'Invalid organization ID' });
+    }
+
+    if (!userId || !mongoose.Types.ObjectId.isValid(String(userId))) {
+      return res.status(400).json({ error: 'Invalid user ID' });
+    }
+
+    // Validate role
+    const defaultRole = await getDefaultOrgRole();
+    const memberRole = role || defaultRole;
+    if (!(await isValidOrgRole(memberRole))) {
+      const allowed = await getAllowedOrgRoles();
+      return res.status(400).json({ error: 'Invalid role', allowedRoles: allowed });
+    }
+
+    // Check if organization exists
+    const org = await Organization.findById(orgId);
+    if (!org) {
+      return res.status(404).json({ error: 'Organization not found' });
+    }
+
+    // Check if user exists
+    const user = await User.findById(userId);
+    if (!user) {
+      return res.status(404).json({ error: 'User not found' });
+    }
+
+    // Check if user is already a member
+    const existingMember = await OrganizationMember.findOne({
+      orgId,
+      userId,
+      status: { $in: ['active', 'removed'] }
+    });
+
+    if (existingMember) {
+      if (existingMember.status === 'active') {
+        return res.status(409).json({ error: 'User is already a member of this organization' });
+      } else {
+        // Reactivate removed member
+        existingMember.status = 'active';
+        existingMember.role = memberRole;
+        existingMember.addedByUserId = req.user?.id || org.ownerUserId;
+        await existingMember.save();
+        return res.json({
+          message: 'Member reactivated successfully',
+          member: existingMember.toObject()
+        });
+      }
+    }
+
+    // Create new member
+    const member = await OrganizationMember.create({
+      orgId,
+      userId,
+      role: memberRole,
+      status: 'active',
+      addedByUserId: req.user?.id || org.ownerUserId,
+    });
+
+    // Populate user data for response
+    const populatedMember = await OrganizationMember.findById(member._id)
+      .populate('userId', 'email name')
+      .lean();
+
+    return res.status(201).json({
+      message: 'Member added successfully',
+      member: populatedMember
+    });
+  } catch (error) {
+    console.error('Admin org member add error:', error);
+    return res.status(500).json({ error: 'Failed to add member' });
+  }
+};
+
 exports.listInvites = async (req, res) => {
   try {
     const { orgId } = req.params;

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();
+      
+      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;
+      
+      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', () => {
+        console.log('[MongooseHelper] Disconnected from MongoDB');
+        this.isConnected = false;
+        this.connectionPromise = null;
+      });
+
+      mongoose.connection.on('reconnected', () => {
+        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();
+        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();
+        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 {
+      console.log(`[${this.name}] Starting script execution...`);
+      
+      const executionPromise = this._executeWithConnection();
+      const result = await Promise.race([executionPromise, timeoutPromise]);
+
+      const duration = Date.now() - this.startTime;
+      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 };