@arela/uploader 1.0.2 → 1.0.4

package/src/utils/PathNormalizer.js

@@ -0,0 +1,220 @@
+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)
+ */
+export class PathNormalizer {
+  /**
+   * Resolve a path to an absolute path
+   * This ensures ../sample and ./sample are treated as different paths
+   *
+   * Examples:
+   * - ../sample (from /data/project) -> /data/sample
+   * - ./sample (from /data/project) -> /data/project/sample
+   * - C:\Users\Documents -> C:\Users\Documents (on Windows)
+   * - /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
+   */
+  static toAbsolutePath(inputPath, basePath = null) {
+    if (!inputPath) return '';
+
+    // If already absolute, return as-is
+    if (path.isAbsolute(inputPath)) {
+      return path.normalize(inputPath);
+    }
+
+    // Resolve relative path
+    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;