@arela/uploader 0.2.12 → 0.3.0

package/src/services/upload/ApiUploadService.js

@@ -7,6 +7,7 @@ import fetch from 'node-fetch';
 import path from 'path';
 
 import appConfig from '../../config/config.js';
+import logger from '../LoggingService.js';
 import { BaseUploadService } from './BaseUploadService.js';
 
 /**
@@ -57,22 +58,47 @@ export class ApiUploadService extends BaseUploadService {
    * @returns {Promise<Object>} API response
    */
   async upload(files, options) {
+    // Validate files parameter
+    if (!files || !Array.isArray(files)) {
+      logger.warn(`Invalid files parameter: ${typeof files}`);
+      throw new Error('Files must be an array');
+    }
+
     const formData = new FormData();
 
+    // Filter out system files (macOS, Windows, etc.)
+    const systemFilePattern = /^\.|__pycache__|\.pyc|\.swp|\.swo|Thumbs\.db|desktop\.ini|DS_Store|\$RECYCLE\.BIN|System Volume Information|~\$|\.tmp/i;
+    const filteredFiles = files.filter(file => {
+      const fileName = file.name || path.basename(file.path);
+      if (systemFilePattern.test(fileName)) {
+        logger.warn(`Skipping system file from upload: ${fileName}`);
+        return false;
+      }
+      return true;
+    });
+
+    if (filteredFiles.length === 0) {
+      throw new Error('No valid files to upload after filtering system files');
+    }
+
     // Add files to form data asynchronously
-    for (const file of files) {
+    for (const file of filteredFiles) {
       try {
         // Check file size for streaming vs buffer approach
-        const stats = await fs.promises.stat(file.path);
+        let size = file.size;
+        if (size === undefined || size === null) {
+          const stats = await fs.promises.stat(file.path);
+          size = stats.size;
+        }
         const fileSizeThreshold = 10 * 1024 * 1024; // 10MB threshold
 
-        if (stats.size > fileSizeThreshold) {
+        if (size > fileSizeThreshold) {
           // Use streaming for large files
           const fileStream = fs.createReadStream(file.path);
           formData.append('files', fileStream, {
             filename: file.name,
             contentType: file.contentType,
-            knownLength: stats.size,
+            knownLength: size,
           });
         } else {
           // Use buffer for smaller files

package/src/services/upload/SupabaseUploadService.js

@@ -26,9 +26,16 @@ export class SupabaseUploadService extends BaseUploadService {
     }
 
     if (!appConfig.supabase.url || !appConfig.supabase.key || !this.bucket) {
-      throw new Error('Missing Supabase configuration');
+      const missing = [];
+      if (!appConfig.supabase.url) missing.push('SUPABASE_URL');
+      if (!appConfig.supabase.key) missing.push('SUPABASE_KEY');
+      if (!this.bucket) missing.push('SUPABASE_BUCKET');
+      throw new Error(`Missing Supabase configuration: ${missing.join(', ')}`);
     }
 
+    console.log(`🔌 Connecting to Supabase: ${appConfig.supabase.url}`);
+    console.log(`📦 Using bucket: ${this.bucket}`);
+
     this.client = createClient(appConfig.supabase.url, appConfig.supabase.key, {
       db: {
         schema: 'public',
@@ -48,11 +55,19 @@ export class SupabaseUploadService extends BaseUploadService {
       },
     });
 
-    // Test connection
-    const { error } = await this.client.storage.from(this.bucket).list('');
+    // Test connection and bucket access
+    console.log(`🧪 Testing bucket access...`);
+    const { error } = await this.client.storage
+      .from(this.bucket)
+      .list('', { limit: 1 });
     if (error) {
-      throw new Error(`Error connecting to Supabase: ${error.message}`);
+      console.error(`❌ Bucket access test failed:`, error.message);
+      throw new Error(
+        `Error connecting to Supabase bucket '${this.bucket}': ${error.message}`,
+      );
     }
+
+    console.log(`✅ Successfully connected to Supabase bucket: ${this.bucket}`);
   }
 
   /**
@@ -80,18 +95,25 @@ export class SupabaseUploadService extends BaseUploadService {
     const content = fs.readFileSync(file.path);
     const contentType = mime.lookup(file.path) || 'application/octet-stream';
 
+    const normalizedPath = uploadPath.replace(/\\/g, '/');
+
     const { data, error } = await this.client.storage
       .from(this.bucket)
-      .upload(uploadPath.replace(/\\/g, '/'), content, {
+      .upload(normalizedPath, content, {
         upsert: true,
         contentType,
       });
 
     if (error) {
+      console.error(
+        `❌ Supabase upload failed for ${normalizedPath}:`,
+        error.message,
+      );
       return { success: false, error: error.message };
     }
 
-    return { success: true, data };
+    console.log(`✅ Supabase upload successful: ${normalizedPath}`);
+    return { success: true, data, uploadPath: normalizedPath };
   }
 
   /**

package/src/utils/CleanupManager.js

@@ -0,0 +1,262 @@
+import logger from '../services/LoggingService.js';
+
+/**
+ * Cleanup Manager
+ * Centralizes and coordinates cleanup of resources during graceful shutdown
+ * Ensures resources are cleaned up in reverse order of registration (LIFO)
+ */
+export class CleanupManager {
+  constructor() {
+    /**
+     * Array of registered resources
+     * @type {Array<{name: string, resource: any, cleanupFn: Function}>}
+     */
+    this.resources = [];
+
+    /**
+     * Flag to prevent concurrent cleanup
+     * @type {boolean}
+     */
+    this.cleanupInProgress = false;
+
+    /**
+     * Timestamp when cleanup started
+     * @type {number|null}
+     */
+    this.cleanupStartTime = null;
+
+    /**
+     * Cleanup timeout duration (30 seconds)
+     * @type {number}
+     */
+    this.cleanupTimeout = 30000;
+
+    /**
+     * Results of cleanup operations
+     * @type {Array<{name: string, success: boolean, duration: number, error: string|null}>}
+     */
+    this.cleanupResults = [];
+  }
+
+  /**
+   * Register a resource to be cleaned up during shutdown
+   * Resources are cleaned up in reverse order (LIFO)
+   * @param {string} name - Name of the resource
+   * @param {any} resource - The resource object
+   * @param {Function} cleanupFn - Async function to clean up the resource
+   * @returns {void}
+   */
+  registerResource(name, resource, cleanupFn) {
+    if (!name || typeof name !== 'string') {
+      logger.warn('CleanupManager: Resource name must be a non-empty string');
+      return;
+    }
+
+    if (typeof cleanupFn !== 'function') {
+      logger.warn(
+        `CleanupManager: Cleanup function for "${name}" is not a function`,
+      );
+      return;
+    }
+
+    this.resources.push({
+      name,
+      resource,
+      cleanupFn,
+    });
+
+    logger.debug(`CleanupManager: Registered resource "${name}"`);
+  }
+
+  /**
+   * Perform cleanup of all registered resources in reverse order
+   * @param {string} reason - Reason for cleanup (e.g., 'SIGINT', 'SIGTERM')
+   * @returns {Promise<Object>} Cleanup results
+   */
+  async performCleanup(reason = 'unknown') {
+    // Prevent concurrent cleanup operations
+    if (this.cleanupInProgress) {
+      logger.warn(
+        `CleanupManager: Cleanup already in progress, skipping new cleanup request`,
+      );
+      return {
+        success: false,
+        reason: 'Cleanup already in progress',
+        results: this.cleanupResults,
+      };
+    }
+
+    this.cleanupInProgress = true;
+    this.cleanupStartTime = Date.now();
+    this.cleanupResults = [];
+
+    logger.info(
+      `CleanupManager: Starting cleanup sequence (reason: ${reason})`,
+    );
+
+    // Set timeout for cleanup
+    const cleanupTimeoutId = setTimeout(() => {
+      logger.error('CleanupManager: Cleanup timeout reached, forcing exit');
+    }, this.cleanupTimeout);
+
+    // Clean up resources in reverse order (LIFO)
+    for (let i = this.resources.length - 1; i >= 0; i--) {
+      const { name, cleanupFn } = this.resources[i];
+      const startTime = Date.now();
+
+      try {
+        logger.debug(`CleanupManager: Cleaning up resource "${name}"...`);
+
+        // Execute cleanup function
+        const result = cleanupFn();
+
+        // Handle both sync and async cleanup functions
+        if (result && typeof result.catch === 'function') {
+          await result;
+        }
+
+        const duration = Date.now() - startTime;
+        this.cleanupResults.push({
+          name,
+          success: true,
+          duration,
+          error: null,
+        });
+
+        logger.info(
+          `CleanupManager: Successfully cleaned up "${name}" (${duration}ms)`,
+        );
+      } catch (error) {
+        const duration = Date.now() - startTime;
+        this.cleanupResults.push({
+          name,
+          success: false,
+          duration,
+          error: error.message,
+        });
+
+        logger.error(
+          `CleanupManager: Error cleaning up "${name}": ${error.message}`,
+        );
+      }
+    }
+
+    // Clear timeout
+    clearTimeout(cleanupTimeoutId);
+
+    const totalDuration = Date.now() - this.cleanupStartTime;
+    const successCount = this.cleanupResults.filter((r) => r.success).length;
+    const failureCount = this.cleanupResults.filter((r) => !r.success).length;
+
+    logger.info(
+      `CleanupManager: Cleanup complete (${totalDuration}ms, ${successCount} successful, ${failureCount} failed)`,
+    );
+
+    return {
+      success: failureCount === 0,
+      reason,
+      totalDuration,
+      successCount,
+      failureCount,
+      results: this.cleanupResults,
+    };
+  }
+
+  /**
+   * Clear all registered resources without cleaning them up
+   * Use this for resetting the cleanup manager
+   * @returns {void}
+   */
+  clearResources() {
+    const count = this.resources.length;
+    this.resources = [];
+    logger.debug(`CleanupManager: Cleared ${count} registered resources`);
+  }
+
+  /**
+   * Get the number of registered resources
+   * @returns {number} Number of registered resources
+   */
+  getResourceCount() {
+    return this.resources.length;
+  }
+
+  /**
+   * Get details of all registered resources
+   * @returns {Array<string>} Array of resource names
+   */
+  getResourceNames() {
+    return this.resources.map((r) => r.name);
+  }
+
+  /**
+   * Check if cleanup is in progress
+   * @returns {boolean} True if cleanup is currently running
+   */
+  isCleanupInProgress() {
+    return this.cleanupInProgress;
+  }
+
+  /**
+   * Get cleanup results from last operation
+   * @returns {Array<Object>} Array of cleanup results
+   */
+  getCleanupResults() {
+    return [...this.cleanupResults];
+  }
+
+  /**
+   * Generate a formatted report of the cleanup operation
+   * @returns {string} Formatted cleanup report
+   */
+  generateCleanupReport() {
+    if (this.cleanupResults.length === 0) {
+      return 'No cleanup operations recorded';
+    }
+
+    const totalDuration = this.cleanupStartTime
+      ? Date.now() - this.cleanupStartTime
+      : 0;
+
+    let report =
+      '\n═══════════════════════════════════════════════════════════\n';
+    report += 'CLEANUP OPERATION REPORT\n';
+    report += '═══════════════════════════════════════════════════════════\n\n';
+
+    for (const result of this.cleanupResults) {
+      const status = result.success ? '✅' : '❌';
+      report += `${status} ${result.name}\n`;
+      report += `   Duration: ${result.duration}ms\n`;
+      if (result.error) {
+        report += `   Error: ${result.error}\n`;
+      }
+      report += '\n';
+    }
+
+    const successCount = this.cleanupResults.filter((r) => r.success).length;
+    const failureCount = this.cleanupResults.filter((r) => !r.success).length;
+
+    report += '─────────────────────────────────────────────────────────────\n';
+    report += `Total Duration: ${totalDuration}ms\n`;
+    report += `Successful: ${successCount}\n`;
+    report += `Failed: ${failureCount}\n`;
+    report += '═══════════════════════════════════════════════════════════\n';
+
+    return report;
+  }
+
+  /**
+   * Reset cleanup state (useful for testing)
+   * @returns {void}
+   */
+  reset() {
+    this.cleanupInProgress = false;
+    this.cleanupStartTime = null;
+    this.cleanupResults = [];
+    logger.debug('CleanupManager: Reset to initial state');
+  }
+}
+
+// Export singleton instance
+export const cleanupManager = new CleanupManager();
+export default cleanupManager;

package/src/utils/FileOperations.js

@@ -143,6 +143,47 @@ export class FileOperations {
       return false;
     }
   }
+
+  /**
+   * List all files in a directory (non-recursive)
+   * @param {string} dirPath - Directory path
+   * @param {Object} options - Options { excludePattern, onlyPdf }
+   * @returns {Array} Array of file paths
+   */
+  static listFilesInDirectory(dirPath, options = {}) {
+    try {
+      const { excludePattern = /(^|[\/\\])\.|node_modules|\.git/, onlyPdf = false } = options;
+      
+      if (!fs.existsSync(dirPath)) {
+        return [];
+      }
+
+      const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+      const files = [];
+
+      for (const entry of entries) {
+        const fullPath = path.join(dirPath, entry.name);
+        
+        // Skip excluded patterns
+        if (excludePattern && excludePattern.test(fullPath)) {
+          continue;
+        }
+
+        // Only include files, not directories
+        if (entry.isFile()) {
+          // If onlyPdf is true, filter for PDF files
+          if (onlyPdf && !entry.name.toLowerCase().endsWith('.pdf')) {
+            continue;
+          }
+          files.push(fullPath);
+        }
+      }
+
+      return files;
+    } catch (error) {
+      return [];
+    }
+  }
 }
 
 export default FileOperations;