@arela/uploader 1.0.3 → 1.0.5

package/src/commands/ScanCommand.js

@@ -10,6 +10,7 @@ import appConfig from '../config/config.js';
 import ErrorHandler from '../errors/ErrorHandler.js';
 import { ConfigurationError } from '../errors/ErrorTypes.js';
 import FileOperations from '../utils/FileOperations.js';
+import PathNormalizer from '../utils/PathNormalizer.js';
 
 /**
  * Scan Command Handler
@@ -40,13 +41,13 @@ export class ScanCommand {
       this.scanApiService = new ScanApiService();
 
       const scanConfig = appConfig.getScanConfig();
-      const basePath = appConfig.getBasePath();
+      // Ensure basePath is absolute for scan operations
+      const basePath = PathNormalizer.toAbsolutePath(appConfig.getBasePath());
 
       logger.info('🔍 Starting arela scan command');
       logger.info(`📦 Company: ${scanConfig.companySlug}`);
       logger.info(`🖥️  Server: ${scanConfig.serverId}`);
       logger.info(`📂 Base Path: ${basePath}`);
-      logger.info(`🏷️  Label: ${scanConfig.basePathLabel}`);
       logger.info(`📊 Directory Level: ${scanConfig.directoryLevel}`);
 
       // Step 1: Discover directories at specified level
@@ -63,15 +64,14 @@ export class ScanCommand {
       logger.info('\n📝 Registering scan instances...');
       const registrations = [];
       for (const dir of directories) {
-        const dirLabel = dir.label
-          ? `${scanConfig.basePathLabel}_${dir.label.replace(/[^a-zA-Z0-9_-]/g, '_')}`
-          : scanConfig.basePathLabel;
+        // dir.path is already absolute from #discoverDirectories
+        // Use the absolute path as basePathLabel (simplifies everything!)
+        const absolutePath = dir.path;
 
         const registration = await this.scanApiService.registerInstance({
           companySlug: scanConfig.companySlug,
           serverId: scanConfig.serverId,
-          basePathLabel: dirLabel,
-          basePathFull: dir.path,
+          basePathFull: absolutePath,
         });
 
         registrations.push({ ...registration, directory: dir });
@@ -181,8 +181,8 @@ export class ScanCommand {
       return sources.map((source) => {
         const sourcePath =
           source === '.' ? basePath : path.resolve(basePath, source);
-        const label =
-          source === '.' ? '' : source.replace(/[^a-zA-Z0-9_-]/g, '_');
+        // Label is relative path for display purposes only
+        const label = source === '.' ? '' : source;
         return { path: sourcePath, label };
       });
     }
@@ -204,20 +204,20 @@ export class ScanCommand {
             // Source is current directory, use discovered path as-is
             directories.push(levelDir);
           } else {
-            // Append source to both path and label
+            // Append source to path
             const combinedPath = path.resolve(levelDir.path, source);
-            const sourceLabel = source.replace(/[^a-zA-Z0-9_-]/g, '_');
-            const combinedLabel = levelDir.label
-              ? `${levelDir.label}_${sourceLabel}`
-              : sourceLabel;
 
             // Only add if the combined path actually exists
             try {
               const stats = await fs.stat(combinedPath);
               if (stats.isDirectory()) {
+                // Label for display
+                const label = levelDir.label
+                  ? `${levelDir.label}/${source}`
+                  : source;
                 directories.push({
                   path: combinedPath,
-                  label: combinedLabel,
+                  label,
                 });
               } else {
                 logger.debug(`⏭️ Skipping ${combinedPath} (not a directory)`);
@@ -249,8 +249,9 @@ export class ScanCommand {
     const fullPath = path.join(basePath, currentPath);
 
     if (currentLevel === targetLevel) {
-      const label = currentPath.replace(/\\/g, '/').replace(/^\//g, '');
-      return [{ path: fullPath, label: label || 'root' }];
+      // Label is the relative path for display
+      const label = currentPath || '';
+      return [{ path: fullPath, label }];
     }
 
     const directories = [];
@@ -418,20 +419,26 @@ export class ScanCommand {
 
   /**
    * Normalize file record for database insertion
+   * Stores paths with forward slashes for consistency but keeps them absolute
    * @private
    */
   #normalizeFileRecord(filePath, fileStats, basePath, scanTimestamp) {
     const fileName = path.basename(filePath);
     const fileExtension = path.extname(filePath).toLowerCase().replace('.', '');
-    const directoryPath = path.dirname(filePath);
-    const relativePath = path.relative(basePath, filePath);
+
+    // Normalize separators to forward slashes for consistency
+    const directoryPath = PathNormalizer.normalizeSeparators(
+      path.dirname(filePath),
+    );
+    const relativePath = PathNormalizer.getRelativePath(filePath, basePath);
+    const absolutePath = PathNormalizer.normalizeSeparators(filePath);
 
     return {
       fileName,
       fileExtension,
       directoryPath,
       relativePath,
-      absolutePath: filePath,
+      absolutePath,
       sizeBytes: Number(fileStats.size),
       modifiedAt: fileStats.mtime.toISOString(),
       scanTimestamp,

package/src/config/config.js

@@ -3,6 +3,8 @@ import fs from 'fs';
 import path from 'path';
 import { fileURLToPath } from 'url';
 
+import PathNormalizer from '../utils/PathNormalizer.js';
+
 config();
 
 /**
@@ -32,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.3';
+      return packageJson.version || '1.0.5';
     } catch (error) {
       console.warn('⚠️ Could not read package.json version, using fallback');
-      return '1.0.3';
+      return '1.0.5';
     }
   }
 
@@ -251,13 +253,18 @@ class Config {
     let basePathLabel = process.env.ARELA_BASE_PATH_LABEL;
 
     // Auto-derive basePathLabel from UPLOAD_BASE_PATH if not set
+    // IMPORTANT: Always resolve to absolute path for uniqueness
     if (!basePathLabel && process.env.UPLOAD_BASE_PATH) {
       const basePath = process.env.UPLOAD_BASE_PATH;
-      // Get the last segment of the path
-      const segments = basePath.split(path.sep).filter(Boolean);
-      basePathLabel = segments[segments.length - 1] || 'root';
-      // Sanitize the label
-      basePathLabel = basePathLabel.replace(/[^a-zA-Z0-9_-]/g, '_');
+      // 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
+    // Use PathNormalizer.isAbsolutePath for cross-platform Windows path detection
+    if (basePathLabel && !PathNormalizer.isAbsolutePath(basePathLabel)) {
+      basePathLabel = PathNormalizer.toAbsolutePath(basePathLabel);
     }
 
     // Parse exclude patterns
@@ -271,16 +278,21 @@ class Config {
       .filter(Boolean);
 
     // Generate table name if all components are available
+    // Note: This is just for reference; actual table names are generated dynamically
+    // in ScanCommand based on discovered directories and levels
     let tableName = null;
     if (companySlug && serverId && basePathLabel) {
-      const rawName = `${companySlug}_${serverId}_${basePathLabel}`;
-      tableName = this.#sanitizeTableName(rawName);
+      tableName = PathNormalizer.generateTableName({
+        companySlug,
+        serverId,
+        basePathLabel,
+      });
     }
 
     return {
       companySlug,
       serverId,
-      basePathLabel,
+      basePathFull: basePathLabel, // Renamed for consistency
       tableName,
       excludePatterns,
       batchSize: parseInt(process.env.SCAN_BATCH_SIZE) || 2000,
@@ -311,38 +323,6 @@ class Config {
     };
   }
 
-  /**
-   * Sanitize and generate table name
-   * @private
-   */
-  #sanitizeTableName(rawName) {
-    // Sanitize: lowercase, replace special chars with underscore
-    let sanitized = rawName
-      .toLowerCase()
-      .replace(/[^a-z0-9_]/g, '_')
-      .replace(/_+/g, '_')
-      .replace(/^_|_$/g, '');
-
-    const prefix = 'scan_';
-    let tableName = prefix + sanitized;
-
-    // PostgreSQL table name limit is 63 characters
-    if (tableName.length > 63) {
-      // Simple hash without crypto module
-      let hash = 0;
-      for (let i = 0; i < rawName.length; i++) {
-        const char = rawName.charCodeAt(i);
-        hash = (hash << 5) - hash + char;
-        hash = hash & hash; // Convert to 32bit integer
-      }
-      const hashStr = Math.abs(hash).toString(36).substring(0, 8);
-      const maxBaseLength = 63 - hashStr.length - 1;
-      tableName = tableName.substring(0, maxBaseLength) + '_' + hashStr;
-    }
-
-    return tableName;
-  }
-
   /**
    * Validate scan configuration
    * @throws {Error} If required scan configuration is missing
@@ -376,9 +356,9 @@ class Config {
       );
     }
 
-    if (!this.scan.basePathLabel) {
+    if (!this.scan.basePathFull) {
       errors.push(
-        'Could not determine base path label. Set ARELA_BASE_PATH_LABEL or UPLOAD_BASE_PATH',
+        'Could not determine base path. Set ARELA_BASE_PATH_LABEL or UPLOAD_BASE_PATH',
       );
     }
 
@@ -394,10 +374,8 @@ class Config {
    * @returns {Object} Scan configuration
    */
   getScanConfig() {
-    return {
-      ...this.scan,
-      basePathFull: this.upload.basePath,
-    };
+    // Return scan config with basePathFull already resolved to absolute path
+    return this.scan;
   }
 
   /**
@@ -549,6 +527,7 @@ class Config {
 
   /**
    * Get base path with validation
+   * Returns the path as configured (may be relative for legacy compatibility)
    * @returns {string} Base path for uploads
    * @throws {Error} If base path is not configured
    */

package/src/services/ScanApiService.js

@@ -249,7 +249,6 @@ export class ScanApiService {
     const result = await this.#request('/api/uploader/scan/register', 'POST', {
       companySlug: config.companySlug,
       serverId: config.serverId,
-      basePathLabel: config.basePathLabel,
       basePathFull: config.basePathFull,
     });
 
@@ -327,15 +326,15 @@ export class ScanApiService {
    * Get all tables for a specific instance
    * @param {string} companySlug - Company slug
    * @param {string} serverId - Server ID
-   * @param {string} basePathLabel - Base path label
+   * @param {string} basePathFull - Base path (absolute)
    * @returns {Promise<Array>} List of tables for the instance
    */
-  async getInstanceTables(companySlug, serverId, basePathLabel) {
+  async getInstanceTables(companySlug, serverId, basePathFull) {
     logger.debug(
-      `Fetching instance tables for ${companySlug}/${serverId}/${basePathLabel}...`,
+      `Fetching instance tables for ${companySlug}/${serverId}/${basePathFull}...`,
     );
     return await this.#request(
-      `/api/uploader/scan/instance-tables?companySlug=${encodeURIComponent(companySlug)}&serverId=${encodeURIComponent(serverId)}&basePathLabel=${encodeURIComponent(basePathLabel)}`,
+      `/api/uploader/scan/instance-tables?companySlug=${encodeURIComponent(companySlug)}&serverId=${encodeURIComponent(serverId)}&basePathFull=${encodeURIComponent(basePathFull)}`,
       'GET',
     );
   }

package/src/utils/PathNormalizer.js

@@ -0,0 +1,272 @@
+import crypto from 'crypto';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+/**
+ * PathNormalizer - Absolute path resolution and table name generation
+ *
+ * Strategy:
+ * 1. Always resolve paths to absolute paths first (resolves ../sample vs ./sample)
+ * 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 (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 (native format for Unix, preserved for Windows)
+   */
+  static toAbsolutePath(inputPath, basePath = null) {
+    if (!inputPath) return '';
+
+    // 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 against base
+    const base = basePath || process.cwd();
+    return path.resolve(base, inputPath);
+  }
+
+  /**
+   * Normalize path separators to forward slashes for consistency
+   * Does NOT remove drive letters or convert to POSIX - just normalizes separators
+   *
+   * @param {string} inputPath - Path to normalize
+   * @returns {string} Path with forward slashes
+   */
+  static normalizeSeparators(inputPath) {
+    if (!inputPath) return '';
+    return inputPath.replace(/\\/g, '/');
+  }
+
+  /**
+   * Get relative path from base with normalized separators
+   *
+   * @param {string} fullPath - Full absolute path
+   * @param {string} basePath - Base absolute path to subtract
+   * @returns {string} Relative path with forward slashes
+   */
+  static getRelativePath(fullPath, basePath) {
+    const relativePath = path.relative(basePath, fullPath);
+    return this.normalizeSeparators(relativePath);
+  }
+
+  /**
+   * Sanitize an absolute path for use in database table names
+   * Converts path separators and special characters to underscores
+   * Preserves the path structure for uniqueness
+   *
+   * Examples:
+   * - /data/2023 -> data_2023
+   * - C:\Users\Documents -> c_users_documents
+   * - /home/user/project/sample -> home_user_project_sample
+   *
+   * @param {string} absolutePath - Absolute path to sanitize
+   * @returns {string} Sanitized string safe for table names
+   */
+  static sanitizeForTableName(absolutePath) {
+    if (!absolutePath) return '';
+
+    return absolutePath
+      .toLowerCase()
+      .replace(/^[a-z]:/i, '') // Remove Windows drive letter (C:, D:, etc.)
+      .replace(/[^a-z0-9]/g, '_') // Replace all non-alphanumeric with underscore
+      .replace(/_+/g, '_') // Replace multiple underscores with single
+      .replace(/^_|_$/g, ''); // Remove leading/trailing underscores
+  }
+
+  /**
+   * Generate a PostgreSQL-compatible table name from scan configuration
+   * Format: scan_<company>_<server>_<sanitized_absolute_path>
+   *
+   * Uses the absolute path to ensure uniqueness:
+   * - ../sample -> /data/sample
+   * - ./sample -> /data/project/sample
+   * These create different table names!
+   *
+   * Handles the 63-character PostgreSQL limit by:
+   * 1. Trying the full name first
+   * 2. If too long, truncating and adding an 8-character hash for uniqueness
+   *
+   * @param {Object} config - Scan configuration
+   * @param {string} config.companySlug - Company identifier
+   * @param {string} config.serverId - Server identifier
+   * @param {string} config.basePathLabel - Absolute base path
+   * @returns {string} PostgreSQL-compatible table name
+   */
+  static generateTableName(config) {
+    const { companySlug, serverId, basePathLabel } = config;
+
+    // Sanitize each component (basePathLabel should already be absolute)
+    const sanitizedCompany = companySlug
+      .toLowerCase()
+      .replace(/[^a-z0-9]/g, '_');
+    const sanitizedServer = serverId.toLowerCase().replace(/[^a-z0-9]/g, '_');
+    const sanitizedPath = this.sanitizeForTableName(basePathLabel);
+
+    // Build raw name for hashing (preserve original for uniqueness)
+    const rawName = `${companySlug}_${serverId}_${basePathLabel}`;
+
+    // Build sanitized table name
+    let tableName = `scan_${sanitizedCompany}_${sanitizedServer}`;
+
+    if (sanitizedPath) {
+      tableName += `_${sanitizedPath}`;
+    }
+
+    // PostgreSQL table name limit is 63 characters
+    if (tableName.length > 63) {
+      // Generate a hash for uniqueness
+      const hash = crypto
+        .createHash('md5')
+        .update(rawName)
+        .digest('hex')
+        .substring(0, 8);
+
+      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
+        const maxCompanyServerLength = 63 - basePrefix.length - hash.length - 2; // -2 for underscores
+        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}`;
+        } else if (sanitizedPath.length <= availableSpace) {
+          // Path fits in available space, use it all
+          tableName = `${prefix}${sanitizedPath}_${hash}`;
+        } else {
+          // Need to split: preserve start and end
+          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);
+          
+          // Build table name with start, hash, and end
+          tableName = `${prefix}${pathStart}_${hash}_${pathEnd}`;
+        }
+      }
+    }
+
+    return tableName;
+  }
+
+  /**
+   * Build an absolute path from base and relative component
+   *
+   * @param {string} basePath - Absolute base path
+   * @param {string} relativePath - Relative path from base (can be empty)
+   * @returns {string} Absolute path
+   */
+  static buildAbsolutePath(basePath, relativePath = '') {
+    if (!relativePath || relativePath === '.') {
+      return basePath;
+    }
+    return path.resolve(basePath, relativePath);
+  }
+
+  /**
+   * Validate that a path can be used for table name generation
+   *
+   * @param {string} pathStr - Path to validate
+   * @returns {Object} Validation result { valid: boolean, error?: string }
+   */
+  static validatePath(pathStr) {
+    if (!pathStr || typeof pathStr !== 'string') {
+      return { valid: false, error: 'Path is required and must be a string' };
+    }
+
+    if (pathStr.trim() === '') {
+      return { valid: false, error: 'Path cannot be empty' };
+    }
+
+    // Check for null bytes (security)
+    if (pathStr.includes('\0')) {
+      return { valid: false, error: 'Path cannot contain null bytes' };
+    }
+
+    return { valid: true };
+  }
+}
+
+export default PathNormalizer;