@arela/uploader 1.0.5 → 1.0.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arela/uploader",
-  "version": "1.0.5",
+  "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.5';
+      return packageJson.version || '1.0.6';
     } catch (error) {
       console.warn('⚠️ Could not read package.json version, using fallback');
-      return '1.0.5';
+      return '1.0.6';
     }
   }
 

package/src/utils/PathNormalizer.js

@@ -189,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
@@ -197,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}`;
@@ -217,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}`;
         }