@arela/uploader 0.2.4 → 0.2.5

package/src/services/LoggingService.js

@@ -0,0 +1,194 @@
+import fs from 'fs';
+import path from 'path';
+
+import appConfig from '../config/config.js';
+import FileOperations from '../utils/FileOperations.js';
+
+/**
+ * Logging Service
+ * Handles application logging with buffering, file output, and console output
+ */
+export class LoggingService {
+  constructor() {
+    this.logFilePath = appConfig.logging.logFilePath;
+    this.isVerbose = appConfig.logging.verbose;
+    this.buffer = [];
+    this.bufferSize = appConfig.performance.logBufferSize;
+    this.flushInterval = appConfig.performance.logFlushInterval;
+    this.lastFlushTime = Date.now();
+    
+    this.#setupProcessHandlers();
+  }
+
+  /**
+   * Setup process handlers for graceful shutdown
+   * @private
+   */
+  #setupProcessHandlers() {
+    const flushAndExit = (exitCode = 0) => {
+      this.flush();
+      process.exit(exitCode);
+    };
+
+    process.on('exit', () => this.flush());
+    process.on('SIGINT', () => flushAndExit(0));
+    process.on('SIGTERM', () => flushAndExit(0));
+    process.on('uncaughtException', (error) => {
+      this.error(`Uncaught Exception: ${error.message}`);
+      flushAndExit(1);
+    });
+    process.on('unhandledRejection', (reason, promise) => {
+      this.error(`Unhandled Rejection at: ${promise}, reason: ${reason}`);
+      flushAndExit(1);
+    });
+  }
+
+  /**
+   * Write a log message
+   * @param {string} message - Log message
+   * @param {string} level - Log level (info, warn, error, debug)
+   */
+  writeLog(message, level = 'info') {
+    try {
+      const timestamp = new Date().toISOString();
+      const logEntry = `[${timestamp}] [${level.toUpperCase()}] ${message}`;
+      
+      this.buffer.push(logEntry);
+
+      // Flush if buffer is full or enough time has passed
+      const now = Date.now();
+      if (
+        this.buffer.length >= this.bufferSize ||
+        now - this.lastFlushTime >= this.flushInterval
+      ) {
+        this.flush();
+      }
+    } catch (error) {
+      console.error(`❌ Error buffering log message: ${error.message}`);
+    }
+  }
+
+  /**
+   * Log info message
+   * @param {string} message - Message to log
+   */
+  info(message) {
+    this.writeLog(message, 'info');
+  }
+
+  /**
+   * Log warning message
+   * @param {string} message - Message to log
+   */
+  warn(message) {
+    this.writeLog(message, 'warn');
+    if (this.isVerbose) {
+      console.warn(`⚠️ ${message}`);
+    }
+  }
+
+  /**
+   * Log error message
+   * @param {string} message - Message to log
+   */
+  error(message) {
+    this.writeLog(message, 'error');
+    console.error(`❌ ${message}`);
+  }
+
+  /**
+   * Log debug message (only if verbose mode is enabled)
+   * @param {string} message - Message to log
+   */
+  debug(message) {
+    if (this.isVerbose) {
+      this.writeLog(message, 'debug');
+      console.log(`🔍 ${message}`);
+    }
+  }
+
+  /**
+   * Log verbose message (only if verbose mode is enabled)
+   * @param {string} message - Message to log
+   */
+  verbose(message) {
+    if (this.isVerbose) {
+      this.writeLog(message, 'verbose');
+      console.log(message);
+    }
+  }
+
+  /**
+   * Log success message
+   * @param {string} message - Message to log
+   */
+  success(message) {
+    this.writeLog(message, 'success');
+    console.log(`✅ ${message}`);
+  }
+
+  /**
+   * Flush log buffer to file
+   */
+  flush() {
+    if (this.buffer.length === 0) return;
+
+    try {
+      const logContent = this.buffer.join('\n') + '\n';
+      FileOperations.appendToFile(this.logFilePath, logContent);
+      this.buffer = [];
+      this.lastFlushTime = Date.now();
+    } catch (error) {
+      console.error(`❌ Error writing to log file: ${error.message}`);
+    }
+  }
+
+  /**
+   * Clear the log file
+   */
+  clearLogFile() {
+    try {
+      if (FileOperations.fileExists(this.logFilePath)) {
+        fs.unlinkSync(this.logFilePath);
+      }
+    } catch (error) {
+      console.error(`❌ Error clearing log file: ${error.message}`);
+    }
+  }
+
+  /**
+   * Get log file path
+   * @returns {string} Path to log file
+   */
+  getLogFilePath() {
+    return this.logFilePath;
+  }
+
+  /**
+   * Check if verbose logging is enabled
+   * @returns {boolean} True if verbose logging is enabled
+   */
+  isVerboseEnabled() {
+    return this.isVerbose;
+  }
+
+  /**
+   * Set verbose mode
+   * @param {boolean} verbose - Enable/disable verbose mode
+   */
+  setVerbose(verbose) {
+    this.isVerbose = verbose;
+  }
+
+  /**
+   * Get current buffer size
+   * @returns {number} Number of buffered log entries
+   */
+  getBufferSize() {
+    return this.buffer.length;
+  }
+}
+
+// Export singleton instance
+export const logger = new LoggingService();
+export default logger;

package/src/services/upload/ApiUploadService.js

@@ -0,0 +1,147 @@
+import fs from 'fs';
+import fetch from 'node-fetch';
+import path from 'path';
+import { FormData } from 'formdata-node';
+import { Blob } from 'buffer';
+
+import appConfig from '../../config/config.js';
+import { BaseUploadService } from './BaseUploadService.js';
+
+/**
+ * API Upload Service
+ * Handles uploads to the Arela API with automatic processing
+ */
+export class ApiUploadService extends BaseUploadService {
+  constructor() {
+    super();
+    this.baseUrl = appConfig.api.baseUrl;
+    this.token = appConfig.api.token;
+  }
+
+  /**
+   * Upload files to Arela API with automatic detection and organization
+   * @param {Array} files - Array of file objects
+   * @param {Object} options - Upload options
+   * @returns {Promise<Object>} API response
+   */
+  async upload(files, options) {
+    const formData = new FormData();
+
+    // Add files to form data
+    files.forEach((file) => {
+      const fileBuffer = fs.readFileSync(file.path);
+      const blob = new Blob([fileBuffer], { type: file.contentType });
+      formData.append('files', blob, file.name);
+    });
+
+    // Add configuration parameters
+    if (appConfig.supabase.bucket) {
+      formData.append('bucket', appConfig.supabase.bucket);
+    }
+    
+    if (options.prefix) {
+      formData.append('prefix', options.prefix);
+    }
+
+    // Handle folder structure configuration
+    const folderStructure = this.#buildFolderStructure(files, options);
+    if (folderStructure) {
+      formData.append('folderStructure', folderStructure);
+    }
+
+    // Add client path if specified
+    if (options.clientPath) {
+      formData.append('clientPath', options.clientPath);
+    }
+
+    // Add processing options
+    formData.append('autoDetect', String(options.autoDetect ?? true));
+    formData.append('autoOrganize', String(options.autoOrganize ?? false));
+    formData.append('batchSize', String(options.batchSize || 10));
+    formData.append('clientVersion', appConfig.packageVersion);
+
+    try {
+      const response = await fetch(
+        `${this.baseUrl}/api/storage/batch-upload-and-process`,
+        {
+          method: 'POST',
+          headers: {
+            'x-api-key': this.token,
+          },
+          body: formData,
+        }
+      );
+
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(
+          `API request failed: ${response.status} ${response.statusText} - ${errorText}`
+        );
+      }
+
+      const result = await response.json();
+      
+      // Normalize response format to match DatabaseService expectations
+      return { success: true, data: result };
+    } catch (fetchError) {
+      // Return normalized error format
+      return { success: false, error: fetchError.message };
+    }
+  }
+
+  /**
+   * Check if API service is available
+   * @returns {Promise<boolean>} True if available
+   */
+  async isAvailable() {
+    if (!this.baseUrl || !this.token) {
+      return false;
+    }
+
+    try {
+      const response = await fetch(`${this.baseUrl}/api/health`, {
+        headers: {
+          'x-api-key': this.token,
+        },
+      });
+      
+      return response.ok;
+    } catch (error) {
+      return false;
+    }
+  }
+
+  /**
+   * Get service name
+   * @returns {string} Service name
+   */
+  getServiceName() {
+    return 'Arela API';
+  }
+
+  /**
+   * Build folder structure from options and auto-detection
+   * @private
+   * @param {Array} files - Files being uploaded
+   * @param {Object} options - Upload options
+   * @returns {string|null} Folder structure or null
+   */
+  #buildFolderStructure(files, options) {
+    let combinedStructure = null;
+
+    if (options.folderStructure && options.autoDetectStructure && files.length > 0) {
+      // This would require the path detection utility - we'll implement this after creating that module
+      console.log(`📁 Custom folder structure: ${options.folderStructure}`);
+      return options.folderStructure;
+    } else if (options.folderStructure) {
+      console.log(`📁 Using custom folder structure: ${options.folderStructure}`);
+      return options.folderStructure;
+    } else if (options.autoDetectStructure && files.length > 0) {
+      // Auto-detection logic would go here
+      console.log('📁 Auto-detection requested but not yet implemented');
+      return null;
+    }
+
+    return null;
+  }
+}

package/src/services/upload/BaseUploadService.js

@@ -0,0 +1,36 @@
+import FormData from 'form-data';
+import fs from 'fs';
+import fetch from 'node-fetch';
+
+/**
+ * Base upload service interface
+ * Defines the contract for upload implementations
+ */
+export class BaseUploadService {
+  /**
+   * Upload files using the specific implementation
+   * @param {Array} files - Array of file objects with path, name, and contentType
+   * @param {Object} options - Upload options
+   * @returns {Promise<Object>} Upload result
+   * @throws {Error} If upload fails
+   */
+  async upload(files, options) {
+    throw new Error('upload() method must be implemented by subclass');
+  }
+
+  /**
+   * Check if the service is available and properly configured
+   * @returns {Promise<boolean>} True if service is available
+   */
+  async isAvailable() {
+    throw new Error('isAvailable() method must be implemented by subclass');
+  }
+
+  /**
+   * Get the service name for logging purposes
+   * @returns {string} Service name
+   */
+  getServiceName() {
+    throw new Error('getServiceName() method must be implemented by subclass');
+  }
+}

package/src/services/upload/SupabaseUploadService.js

@@ -0,0 +1,107 @@
+import { createClient } from '@supabase/supabase-js';
+import fs from 'fs';
+import mime from 'mime-types';
+
+import appConfig from '../../config/config.js';
+import { BaseUploadService } from './BaseUploadService.js';
+
+/**
+ * Supabase Upload Service
+ * Handles direct uploads to Supabase Storage
+ */
+export class SupabaseUploadService extends BaseUploadService {
+  constructor() {
+    super();
+    this.client = null;
+    this.bucket = appConfig.supabase.bucket;
+  }
+
+  /**
+   * Initialize Supabase client if not already initialized
+   * @private
+   */
+  async #initializeClient() {
+    if (this.client) {
+      return;
+    }
+
+    if (!appConfig.supabase.url || !appConfig.supabase.key || !this.bucket) {
+      throw new Error('Missing Supabase configuration');
+    }
+
+    this.client = createClient(appConfig.supabase.url, appConfig.supabase.key);
+
+    // Test connection
+    const { error } = await this.client.storage.from(this.bucket).list('');
+    if (error) {
+      throw new Error(`Error connecting to Supabase: ${error.message}`);
+    }
+  }
+
+  /**
+   * Upload file directly to Supabase
+   * @param {Array} files - Array with single file object
+   * @param {Object} options - Upload options with uploadPath
+   * @returns {Promise<Object>} Upload result
+   */
+  async upload(files, options) {
+    await this.#initializeClient();
+
+    if (files.length !== 1) {
+      throw new Error('SupabaseUploadService only supports single file uploads');
+    }
+
+    const file = files[0];
+    const uploadPath = options.uploadPath;
+
+    if (!uploadPath) {
+      throw new Error('uploadPath is required for Supabase uploads');
+    }
+
+    const content = fs.readFileSync(file.path);
+    const contentType = mime.lookup(file.path) || 'application/octet-stream';
+
+    const { data, error } = await this.client.storage
+      .from(this.bucket)
+      .upload(uploadPath.replace(/\\/g, '/'), content, {
+        upsert: true,
+        contentType,
+      });
+
+    if (error) {
+      throw new Error(error.message);
+    }
+
+    return data;
+  }
+
+  /**
+   * Check if Supabase service is available
+   * @returns {Promise<boolean>} True if available
+   */
+  async isAvailable() {
+    try {
+      await this.#initializeClient();
+      return true;
+    } catch (error) {
+      return false;
+    }
+  }
+
+  /**
+   * Get service name
+   * @returns {string} Service name
+   */
+  getServiceName() {
+    return 'Supabase';
+  }
+
+  /**
+   * Get Supabase client for database operations
+   * @returns {Object} Supabase client
+   */
+  async getClient() {
+    await this.#initializeClient();
+    return this.client;
+  }
+}

package/src/services/upload/UploadServiceFactory.js

@@ -0,0 +1,68 @@
+import { ApiUploadService } from './ApiUploadService.js';
+import { SupabaseUploadService } from './SupabaseUploadService.js';
+
+/**
+ * Upload Service Factory
+ * Manages upload service selection and initialization
+ */
+export class UploadServiceFactory {
+  constructor() {
+    this.apiService = new ApiUploadService();
+    this.supabaseService = new SupabaseUploadService();
+  }
+
+  /**
+   * Get the appropriate upload service based on availability and preferences
+   * @param {boolean} forceSupabase - Force Supabase mode
+   * @returns {Promise<BaseUploadService>} Upload service instance
+   * @throws {Error} If no service is available
+   */
+  async getUploadService(forceSupabase = false) {
+    if (forceSupabase) {
+      console.log('🔧 Force Supabase mode enabled - skipping API');
+      
+      if (await this.supabaseService.isAvailable()) {
+        console.log(`✅ Connected to ${this.supabaseService.getServiceName()} (direct mode)`);
+        return this.supabaseService;
+      } else {
+        throw new Error('Supabase service is not available');
+      }
+    }
+
+    // Try API service first
+    if (await this.apiService.isAvailable()) {
+      console.log('🌐 API mode enabled - files will be uploaded to Arela API with automatic processing');
+      console.log(`✅ Connected to ${this.apiService.getServiceName()}`);
+      return this.apiService;
+    }
+
+    // Fallback to Supabase
+    if (await this.supabaseService.isAvailable()) {
+      console.warn('⚠️ API connection failed, falling back to direct Supabase upload');
+      console.log(`✅ Connected to ${this.supabaseService.getServiceName()} (direct mode)`);
+      return this.supabaseService;
+    }
+
+    throw new Error('No upload service is available');
+  }
+
+  /**
+   * Check if API mode is currently active
+   * @returns {Promise<boolean>} True if API service is available
+   */
+  async isApiModeAvailable() {
+    return await this.apiService.isAvailable();
+  }
+
+  /**
+   * Get Supabase service for database operations
+   * @returns {SupabaseUploadService} Supabase service instance
+   */
+  getSupabaseService() {
+    return this.supabaseService;
+  }
+}
+
+// Export singleton instance
+export const uploadServiceFactory = new UploadServiceFactory();
+export default uploadServiceFactory;

package/src/utils/FileOperations.js

@@ -0,0 +1,148 @@
+import fs from 'fs';
+import path from 'path';
+
+/**
+ * File Operations Utility
+ * Provides optimized file system operations with batching
+ */
+export class FileOperations {
+  /**
+   * Batch read file stats for multiple files
+   * @param {string[]} filePaths - Array of file paths
+   * @returns {Array} Array of results with path, stats, and error
+   */
+  static batchReadFileStats(filePaths) {
+    const results = [];
+
+    for (const filePath of filePaths) {
+      try {
+        const stats = fs.statSync(filePath);
+        results.push({ path: filePath, stats, error: null });
+      } catch (error) {
+        results.push({ path: filePath, stats: null, error: error.message });
+      }
+    }
+
+    return results;
+  }
+
+  /**
+   * Check if file exists synchronously
+   * @param {string} filePath - Path to file
+   * @returns {boolean} True if file exists
+   */
+  static fileExists(filePath) {
+    try {
+      return fs.existsSync(filePath);
+    } catch (error) {
+      return false;
+    }
+  }
+
+  /**
+   * Get file size safely
+   * @param {string} filePath - Path to file
+   * @returns {number|null} File size in bytes or null if error
+   */
+  static getFileSize(filePath) {
+    try {
+      const stats = fs.statSync(filePath);
+      return stats.size;
+    } catch (error) {
+      return null;
+    }
+  }
+
+  /**
+   * Get file modification time
+   * @param {string} filePath - Path to file
+   * @returns {Date|null} Modification time or null if error
+   */
+  static getFileModTime(filePath) {
+    try {
+      const stats = fs.statSync(filePath);
+      return stats.mtime;
+    } catch (error) {
+      return null;
+    }
+  }
+
+  /**
+   * Get file stats
+   * @param {string} filePath - Path to file
+   * @returns {Object|null} File stats or null if error
+   */
+  static getFileStats(filePath) {
+    try {
+      return fs.statSync(filePath);
+    } catch (error) {
+      return null;
+    }
+  }
+
+  /**
+   * Create directory recursively if it doesn't exist
+   * @param {string} dirPath - Directory path
+   * @returns {boolean} True if successful
+   */
+  static ensureDirectory(dirPath) {
+    try {
+      if (!fs.existsSync(dirPath)) {
+        fs.mkdirSync(dirPath, { recursive: true });
+      }
+      return true;
+    } catch (error) {
+      return false;
+    }
+  }
+
+  /**
+   * Read file with error handling
+   * @param {string} filePath - Path to file
+   * @param {string} encoding - File encoding (default: 'utf-8')
+   * @returns {string|null} File content or null if error
+   */
+  static readFileContent(filePath, encoding = 'utf-8') {
+    try {
+      return fs.readFileSync(filePath, encoding);
+    } catch (error) {
+      return null;
+    }
+  }
+
+  /**
+   * Write file with error handling and directory creation
+   * @param {string} filePath - Path to file
+   * @param {string} content - Content to write
+   * @param {string} encoding - File encoding (default: 'utf-8')
+   * @returns {boolean} True if successful
+   */
+  static writeFileContent(filePath, content, encoding = 'utf-8') {
+    try {
+      const dir = path.dirname(filePath);
+      this.ensureDirectory(dir);
+      fs.writeFileSync(filePath, content, encoding);
+      return true;
+    } catch (error) {
+      return false;
+    }
+  }
+
+  /**
+   * Append to file with error handling
+   * @param {string} filePath - Path to file
+   * @param {string} content - Content to append
+   * @param {string} encoding - File encoding (default: 'utf-8')
+   * @returns {boolean} True if successful
+   */
+  static appendToFile(filePath, content, encoding = 'utf-8') {
+    try {
+      fs.appendFileSync(filePath, content, encoding);
+      return true;
+    } catch (error) {
+      return false;
+    }
+  }
+}
+
+export default FileOperations;