@arela/uploader 1.0.4 → 1.0.6

package/docs/CROSS_PLATFORM_PATH_HANDLING.md

@@ -37,7 +37,7 @@ C:\Users\Docs → C:/Users/Docs (stored) → scan_palco_local_c_users_docs
 ### cli_registry Table
 - `company_slug`: Company identifier
 - `server_id`: Server identifier  
-- `base_path_full`: Absolute path with forward slashes (`C:/Users/Documents/2023`)
+- `base_path_full`: Absolute path (preserves original format for Windows paths like `O:\expediente\archivos`)
 - `table_name`: Sanitized version (`scan_palco_local_c_users_documents_2023`)
 - **Removed**: `base_path_label` (was redundant - same as base_path_full)
 
@@ -46,18 +46,22 @@ C:\Users\Docs → C:/Users/Docs (stored) → scan_palco_local_c_users_docs
 - `relative_path`: Relative to base with forward slashes  
 - `absolute_path`: Absolute path with forward slashes
 
-**Note**: All paths stored with forward slashes for consistency, but work on all platforms.
+**Note**: Paths are stored consistently. Windows absolute paths (with drive letters) are preserved when the CLI runs on the same Windows machine or a different OS (macOS/Linux).
 
 ## Key Features
 
-### 1. Cross-Platform Path Normalization
+### 1. Cross-Platform Path Detection
 
-All paths are normalized to POSIX format (forward slashes) for consistency:
+The CLI correctly identifies Windows absolute paths even when running on macOS/Linux:
 
-- **Windows paths**: `C:\Users\Documents` → `/Users/Documents`
-- **Unix paths**: `/home/user/docs` → `/home/user/docs`
-- **Relative paths**: `../parent/folder` → `../parent/folder`
-- **Network drives**: `O:/data/files` → `/data/files`
+- **Windows paths on any OS**: `O:\expediente\archivos` → recognized as absolute, preserved as-is
+- **Unix paths**: `/home/user/docs` → recognized as absolute, normalized
+- **Relative paths**: `./sample` → resolved against cwd
+
+This allows:
+- Running `arela scan` on Windows server → creates table with Windows path in `base_path_full`
+- Running `arela identify` on macOS (for testing) → correctly uses the same Windows path
+- Both resolve to the same table lookup
 
 ### 2. Full Path in Table Names
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arela/uploader",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "description": "CLI to upload files/directories to Arela",
   "bin": {
     "arela": "./src/index.js"

package/src/commands/PushCommand.js

@@ -272,18 +272,17 @@ export class PushCommand {
         break;
       }
 
-      // Upload files in smaller batches
+      // Upload files in smaller batches using new CLI upload endpoint
       for (let i = 0; i < files.length; i += uploadBatchSize) {
         const uploadBatch = files.slice(i, i + uploadBatchSize);
-        const batchResults = await this.#uploadBatch(
+        const batchResults = await this.#uploadBatchViaCli(
+          tableName,
           uploadBatch,
           uploadApiConfig,
         );
 
-        // Update results in database
-        await this.scanApiService.batchUpdateUpload(tableName, batchResults);
-
-        // Update counters
+        // Update counters from API response
+        // Note: The CLI endpoint now handles updating the scan table directly
         batchResults.forEach((result) => {
           results.processed++;
           if (result.uploaded) {
@@ -317,8 +316,160 @@ export class PushCommand {
   }
 
   /**
-   * Upload a batch of files
+   * Upload a batch of files using the new CLI upload endpoint
+   * The endpoint updates the CLI scan table directly
+   * @private
+   */
+  async #uploadBatchViaCli(tableName, files, uploadApiConfig) {
+    const pushConfig = appConfig.getPushConfig();
+    const results = [];
+
+    // Process files one by one (simpler for now, can optimize to true batch later)
+    for (const file of files) {
+      const result = await this.#uploadFileViaCli(
+        tableName,
+        file,
+        uploadApiConfig,
+        pushConfig,
+      );
+      results.push(result);
+    }
+
+    return results;
+  }
+
+  /**
+   * Upload a single file using the CLI upload endpoint
+   * @private
+   */
+  async #uploadFileViaCli(tableName, file, uploadApiConfig, pushConfig) {
+    const result = {
+      id: file.id,
+      uploaded: false,
+      uploadError: null,
+      uploadPath: null,
+      uploadedToStorageId: null,
+    };
+
+    try {
+      // Check if file exists
+      if (!fs.existsSync(file.absolute_path)) {
+        result.uploadError =
+          'FILE_NOT_FOUND: File does not exist on filesystem';
+        // Update the scan table with the error
+        await this.scanApiService.batchUpdateUpload(tableName, [result]);
+        return result;
+      }
+
+      // Get file stats
+      const stats = fs.statSync(file.absolute_path);
+      if (!stats.isFile()) {
+        result.uploadError = 'NOT_A_FILE: Path is not a regular file';
+        await this.scanApiService.batchUpdateUpload(tableName, [result]);
+        return result;
+      }
+
+      // Construct upload path using arela_path
+      // arela_path format: RFC/Year/Patente/Aduana/Pedimento/
+      const uploadPath = `${file.arela_path}${file.file_name}`;
+      result.uploadPath = uploadPath;
+
+      // Create form data for CLI upload endpoint
+      const form = new FormData();
+
+      // Encode fileId and folderStructure in the filename
+      // Format: [fileId][folderStructure]filename
+      const folderStructure = file.arela_path.endsWith('/')
+        ? file.arela_path.slice(0, -1)
+        : file.arela_path;
+
+      const encodedFilename = `[${file.id}][${folderStructure}]${file.file_name}`;
+
+      // Create a read stream with the encoded filename
+      const fileStream = fs.createReadStream(file.absolute_path);
+      form.append('files', fileStream, {
+        filename: encodedFilename,
+        contentType: this.#getMimeType(file.file_extension),
+      });
+
+      // Add required fields for CLI upload
+      form.append('tableName', tableName);
+      form.append('rfc', file.rfc);
+      form.append('bucket', pushConfig.bucket);
+      form.append('autoDetect', 'true');
+      form.append('autoOrganize', 'false');
+      form.append('batchSize', '1');
+      form.append('clientVersion', appConfig.packageVersion);
+
+      // Upload file using new CLI upload endpoint
+      const response = await fetch(
+        `${uploadApiConfig.baseUrl}/api/storage/cli-upload`,
+        {
+          method: 'POST',
+          headers: {
+            'x-api-key': uploadApiConfig.token,
+            ...form.getHeaders(),
+          },
+          body: form,
+        },
+      );
+
+      if (!response.ok) {
+        const errorText = await response.text();
+        result.uploadError = `HTTP ${response.status}: ${errorText}`;
+        logger.error(`✗ Failed: ${file.file_name} - ${result.uploadError}`);
+        return result;
+      }
+
+      const apiResult = await response.json();
+
+      // Check response from CLI upload endpoint
+      if (apiResult.uploaded && apiResult.uploaded.length > 0) {
+        const uploadedFile = apiResult.uploaded[0];
+        result.uploaded = true;
+        result.uploadedToStorageId = uploadedFile.storageId;
+        logger.info(`✓ Uploaded: ${file.file_name} → ${uploadPath}`);
+      } else if (apiResult.errors && apiResult.errors.length > 0) {
+        const error = apiResult.errors[0];
+        result.uploadError = `UPLOAD_FAILED: ${error.error || 'Upload failed'}`;
+        logger.error(`✗ Failed: ${file.file_name} - ${result.uploadError}`);
+      } else {
+        result.uploadError = 'Unknown upload error - no files uploaded';
+        logger.error(`✗ Failed: ${file.file_name} - ${result.uploadError}`);
+      }
+    } catch (error) {
+      result.uploadError = `UPLOAD_ERROR: ${error.message}`;
+      logger.error(`✗ Error uploading ${file.file_name}:`, error.message);
+    }
+
+    return result;
+  }
+
+  /**
+   * Get MIME type from file extension
+   * @private
+   */
+  #getMimeType(extension) {
+    const mimeTypes = {
+      pdf: 'application/pdf',
+      doc: 'application/msword',
+      docx: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+      xls: 'application/vnd.ms-excel',
+      xlsx: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+      txt: 'text/plain',
+      jpg: 'image/jpeg',
+      jpeg: 'image/jpeg',
+      png: 'image/png',
+      gif: 'image/gif',
+      xml: 'application/xml',
+    };
+    return mimeTypes[extension?.toLowerCase()] || 'application/octet-stream';
+  }
+
+  /**
+   * Upload a batch of files (legacy - kept for compatibility)
    * @private
+   * @deprecated Use #uploadBatchViaCli instead
    */
   async #uploadBatch(files, uploadApiConfig) {
     const uploadPromises = files.map((file) =>

package/src/config/config.js

@@ -34,10 +34,10 @@ class Config {
       const __dirname = path.dirname(__filename);
       const packageJsonPath = path.resolve(__dirname, '../../package.json');
       const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
-      return packageJson.version || '1.0.4';
+      return packageJson.version || '1.0.6';
     } catch (error) {
       console.warn('⚠️ Could not read package.json version, using fallback');
-      return '1.0.4';
+      return '1.0.6';
     }
   }
 
@@ -257,11 +257,13 @@ class Config {
     if (!basePathLabel && process.env.UPLOAD_BASE_PATH) {
       const basePath = process.env.UPLOAD_BASE_PATH;
       // Resolve to absolute path (handles ../sample vs ./sample correctly)
+      // Note: toAbsolutePath handles Windows paths (O:\...) even on macOS/Linux
       basePathLabel = PathNormalizer.toAbsolutePath(basePath);
     }
 
     // If basePathLabel is provided, ensure it's absolute
-    if (basePathLabel && !path.isAbsolute(basePathLabel)) {
+    // Use PathNormalizer.isAbsolutePath for cross-platform Windows path detection
+    if (basePathLabel && !PathNormalizer.isAbsolutePath(basePathLabel)) {
       basePathLabel = PathNormalizer.toAbsolutePath(basePathLabel);
     }
 

package/src/utils/PathNormalizer.js

@@ -10,31 +10,83 @@ import { fileURLToPath } from 'url';
  * 2. Store absolute paths in base_path_full
  * 3. Normalize ONLY for table name generation (sanitize special chars)
  * 4. Keep full path structure in table names (hash if too long)
+ *
+ * Cross-platform support:
+ * - Recognizes Windows paths (C:\, D:\, etc.) even when running on macOS/Linux
+ * - Preserves Windows paths as-is when detected (for remote server scenarios)
+ * - This allows CLI running on macOS to work with paths stored from Windows servers
  */
 export class PathNormalizer {
+  /**
+   * Check if a path is a Windows-style absolute path (has drive letter)
+   * This works on any OS, not just Windows
+   *
+   * Examples:
+   * - C:\Users\Documents -> true
+   * - O:\expediente\archivos -> true
+   * - /home/user/docs -> false
+   * - ./relative/path -> false
+   *
+   * @param {string} inputPath - Path to check
+   * @returns {boolean} True if path has a Windows drive letter
+   */
+  static isWindowsAbsolutePath(inputPath) {
+    if (!inputPath || typeof inputPath !== 'string') return false;
+    // Match drive letter followed by colon and backslash or forward slash
+    // e.g., C:\, D:/, O:\
+    return /^[A-Za-z]:[/\\]/.test(inputPath);
+  }
+
+  /**
+   * Check if a path is absolute (works cross-platform)
+   * Recognizes both Unix and Windows absolute paths regardless of current OS
+   *
+   * @param {string} inputPath - Path to check
+   * @returns {boolean} True if path is absolute (Unix or Windows style)
+   */
+  static isAbsolutePath(inputPath) {
+    if (!inputPath) return false;
+    // Check native absolute path first, then Windows-style
+    return path.isAbsolute(inputPath) || this.isWindowsAbsolutePath(inputPath);
+  }
+
   /**
    * Resolve a path to an absolute path
    * This ensures ../sample and ./sample are treated as different paths
    *
+   * Cross-platform behavior:
+   * - Windows paths (C:\, O:\, etc.) are preserved as-is, even on macOS/Linux
+   * - Unix paths are normalized using native path.resolve
+   * - Relative paths are resolved against basePath or cwd
+   *
    * Examples:
    * - ../sample (from /data/project) -> /data/sample
    * - ./sample (from /data/project) -> /data/project/sample
-   * - C:\Users\Documents -> C:\Users\Documents (on Windows)
+   * - C:\Users\Documents -> C:\Users\Documents (preserved on any OS)
+   * - O:\expediente\archivos -> O:\expediente\archivos (preserved on any OS)
    * - /home/user/docs -> /home/user/docs (on Unix)
    *
    * @param {string} inputPath - Path to resolve
    * @param {string} basePath - Base path for resolving relative paths (defaults to cwd)
-   * @returns {string} Absolute path in native OS format
+   * @returns {string} Absolute path (native format for Unix, preserved for Windows)
    */
   static toAbsolutePath(inputPath, basePath = null) {
     if (!inputPath) return '';
 
-    // If already absolute, return as-is
+    // Check for Windows absolute path first (works on any OS)
+    // This prevents macOS from treating "O:\path" as relative
+    if (this.isWindowsAbsolutePath(inputPath)) {
+      // Normalize Windows path but preserve the format
+      // Replace forward slashes with backslashes for consistency
+      return inputPath.replace(/\//g, '\\');
+    }
+
+    // If native absolute path, return normalized
     if (path.isAbsolute(inputPath)) {
       return path.normalize(inputPath);
     }
 
-    // Resolve relative path
+    // Resolve relative path against base
     const base = basePath || process.cwd();
     return path.resolve(base, inputPath);
   }
@@ -137,7 +189,7 @@ export class PathNormalizer {
 
       const basePrefix = 'scan_';
       const prefix = `${basePrefix}${sanitizedCompany}_${sanitizedServer}_`;
-      
+
       // Check if even prefix + hash exceeds limit
       if (prefix.length + hash.length > 63) {
         // Company/server names are too long, need to truncate them too
@@ -145,15 +197,15 @@ export class PathNormalizer {
         const halfLength = Math.floor(maxCompanyServerLength / 2);
         const companyLength = halfLength;
         const serverLength = maxCompanyServerLength - companyLength;
-        
+
         const truncatedCompany = sanitizedCompany.substring(0, companyLength);
         const truncatedServer = sanitizedServer.substring(0, serverLength);
-        
+
         tableName = `${basePrefix}${truncatedCompany}_${truncatedServer}_${hash}`;
       } else {
         // Preserve start and end of path, put hash in middle
         const availableSpace = 63 - prefix.length - hash.length - 2; // -2 for underscores around hash
-        
+
         if (availableSpace <= 0 || !sanitizedPath) {
           // If no space for path or path is empty, just use hash
           tableName = `${prefix}${hash}`;
@@ -165,11 +217,13 @@ export class PathNormalizer {
           const halfSpace = Math.floor(availableSpace / 2);
           const startLength = halfSpace;
           const endLength = availableSpace - startLength;
-          
+
           // Extract start and end portions of the sanitized path
           const pathStart = sanitizedPath.substring(0, startLength);
-          const pathEnd = sanitizedPath.substring(sanitizedPath.length - endLength);
-          
+          const pathEnd = sanitizedPath.substring(
+            sanitizedPath.length - endLength,
+          );
+
           // Build table name with start, hash, and end
           tableName = `${prefix}${pathStart}_${hash}_${pathEnd}`;
         }