@arela/uploader 0.2.4 → 0.2.6

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;

package/src/utils/FileSanitizer.js

@@ -0,0 +1,99 @@
+import path from 'path';
+
+/**
+ * File Sanitization Utility
+ * Handles filename sanitization with caching for performance
+ */
+export class FileSanitizer {
+  constructor() {
+    this.cache = new Map();
+    this.patterns = [
+      [/[áàâäãåāăą]/gi, 'a'],
+      [/[éèêëēĕėę]/gi, 'e'],
+      [/[íìîïīĭį]/gi, 'i'],
+      [/[óòôöõōŏő]/gi, 'o'],
+      [/[úùûüūŭů]/gi, 'u'],
+      [/[ñň]/gi, 'n'],
+      [/[ç]/gi, 'c'],
+      [/[ý]/gi, 'y'],
+      [/[멕]/g, 'meok'],
+      [/[시]/g, 'si'],
+      [/[코]/g, 'ko'],
+      [/[용]/g, 'yong'],
+      [/[가-힣]/g, 'kr'],
+      [/[\u0300-\u036f]/g, ''],
+      [/[\\?%*:|"<>[\]~`^]/g, '-'],
+      [/[{}]/g, '-'],
+      [/[&]/g, 'and'],
+      [/[()]/g, ''],
+      [/\s+/g, '-'],
+      [/-+/g, '-'],
+      [/^-+|-+$/g, ''],
+      [/^\.+/, ''],
+      [/[^\w.-]/g, ''],
+    ];
+  }
+
+  /**
+   * Sanitize a filename for safe storage
+   * @param {string} fileName - Original filename
+   * @returns {string} Sanitized filename
+   */
+  sanitizeFileName(fileName) {
+    if (this.cache.has(fileName)) {
+      return this.cache.get(fileName);
+    }
+
+    const ext = path.extname(fileName);
+    const nameWithoutExt = path.basename(fileName, ext);
+
+    // If already clean, return as-is
+    if (/^[a-zA-Z0-9._-]+$/.test(nameWithoutExt)) {
+      const result = fileName;
+      this.cache.set(fileName, result);
+      return result;
+    }
+
+    let sanitized = nameWithoutExt.normalize('NFD');
+
+    // Apply all sanitization patterns
+    for (const [pattern, replacement] of this.patterns) {
+      sanitized = sanitized.replace(pattern, replacement);
+    }
+
+    // Additional cleanup
+    sanitized = sanitized
+      .replace(/~/g, '-')
+      .replace(/\s+/g, '-')
+      .replace(/\.+/g, '-')
+      .replace(/-+/g, '-')
+      .replace(/^-+|-+$/g, '');
+
+    if (!sanitized) {
+      sanitized = 'unnamed_file';
+    }
+
+    const result = sanitized + ext;
+    this.cache.set(fileName, result);
+    return result;
+  }
+
+  /**
+   * Clear the sanitization cache
+   */
+  clearCache() {
+    this.cache.clear();
+  }
+
+  /**
+   * Get cache size for monitoring
+   * @returns {number} Number of cached entries
+   */
+  getCacheSize() {
+    return this.cache.size;
+  }
+}
+
+// Export singleton instance
+export const fileSanitizer = new FileSanitizer();
+export default fileSanitizer;

package/src/utils/PathDetector.js

@@ -0,0 +1,198 @@
+import path from 'path';
+
+/**
+ * Path Detection Utility
+ * Extracts year and pedimento information from file paths with caching
+ */
+export class PathDetector {
+  constructor() {
+    this.cache = new Map();
+  }
+
+  /**
+   * Extract year and pedimento number from file path with caching
+   * @param {string} filePath - Full file path
+   * @param {string} basePath - Base path to make relative
+   * @returns {Object} Detection result with year, pedimento, and detected flag
+   */
+  extractYearAndPedimentoFromPath(filePath, basePath) {
+    const cacheKey = `${filePath}|${basePath}`;
+
+    if (this.cache.has(cacheKey)) {
+      return this.cache.get(cacheKey);
+    }
+
+    const detection = this.#performDetection(filePath, basePath);
+    this.cache.set(cacheKey, detection);
+
+    return detection;
+  }
+
+  /**
+   * Perform the actual path detection
+   * @private
+   * @param {string} filePath - Full file path
+   * @param {string} basePath - Base path to make relative
+   * @returns {Object} Detection result
+   */
+  #performDetection(filePath, basePath) {
+    try {
+      const relativePath = path.relative(basePath, filePath);
+      const pathParts = relativePath.split(path.sep);
+
+      let year = null;
+      let pedimento = null;
+
+      // Pattern 1: Direct year/pedimento structure (2024/4023260)
+      year = this.#detectDirectPattern(pathParts);
+      pedimento = year ? this.#findPedimentoForYear(pathParts, year) : null;
+
+      // Pattern 2: Named patterns (año2024, ped4023260)
+      if (!year || !pedimento) {
+        const namedDetection = this.#detectNamedPatterns(pathParts);
+        year = year || namedDetection.year;
+        pedimento = pedimento || namedDetection.pedimento;
+      }
+
+      // Pattern 3: Loose year detection
+      if (!year) {
+        year = this.#detectLooseYear(pathParts);
+      }
+
+      // Pattern 4: Loose pedimento detection
+      if (!pedimento) {
+        pedimento = this.#detectLoosePedimento(pathParts);
+      }
+
+      return {
+        year,
+        pedimento,
+        detected: !!(year && pedimento),
+      };
+    } catch (error) {
+      return {
+        year: null,
+        pedimento: null,
+        detected: false,
+        error: error.message,
+      };
+    }
+  }
+
+  /**
+   * Detect direct year/pedimento pattern
+   * @private
+   * @param {string[]} pathParts - Path components
+   * @returns {string|null} Detected year
+   */
+  #detectDirectPattern(pathParts) {
+    for (let i = 0; i < pathParts.length - 1; i++) {
+      const yearMatch = pathParts[i].match(/^(202[0-9])$/);
+      if (yearMatch) {
+        return yearMatch[1];
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Find pedimento for a detected year
+   * @private
+   * @param {string[]} pathParts - Path components
+   * @param {string} year - Detected year
+   * @returns {string|null} Detected pedimento
+   */
+  #findPedimentoForYear(pathParts, year) {
+    const yearIndex = pathParts.findIndex((part) => part === year);
+    if (yearIndex >= 0 && yearIndex < pathParts.length - 1) {
+      const nextPart = pathParts[yearIndex + 1];
+      const pedimentoMatch = nextPart.match(/^(\d{4,8})$/);
+      if (pedimentoMatch) {
+        return pedimentoMatch[1];
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Detect named patterns (año2024, ped4023260)
+   * @private
+   * @param {string[]} pathParts - Path components
+   * @returns {Object} Detection result with year and pedimento
+   */
+  #detectNamedPatterns(pathParts) {
+    let year = null;
+    let pedimento = null;
+
+    for (const part of pathParts) {
+      if (!year) {
+        const namedYearMatch = part.match(/(?:año|year|anio)(\d{4})/i);
+        if (namedYearMatch) {
+          year = namedYearMatch[1];
+        }
+      }
+
+      if (!pedimento) {
+        const namedPedimentoMatch = part.match(
+          /(?:ped|pedimento|pedi)(\d{4,8})/i,
+        );
+        if (namedPedimentoMatch) {
+          pedimento = namedPedimentoMatch[1];
+        }
+      }
+    }
+
+    return { year, pedimento };
+  }
+
+  /**
+   * Detect loose year pattern
+   * @private
+   * @param {string[]} pathParts - Path components
+   * @returns {string|null} Detected year
+   */
+  #detectLooseYear(pathParts) {
+    for (const part of pathParts) {
+      const yearMatch = part.match(/(202[0-9])/);
+      if (yearMatch) {
+        return yearMatch[1];
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Detect loose pedimento pattern
+   * @private
+   * @param {string[]} pathParts - Path components
+   * @returns {string|null} Detected pedimento
+   */
+  #detectLoosePedimento(pathParts) {
+    for (const part of pathParts) {
+      const pedimentoMatch = part.match(/(\d{4,8})/);
+      if (pedimentoMatch && pedimentoMatch[1].length >= 4) {
+        return pedimentoMatch[1];
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Clear the detection cache
+   */
+  clearCache() {
+    this.cache.clear();
+  }
+
+  /**
+   * Get cache size for monitoring
+   * @returns {number} Number of cached entries
+   */
+  getCacheSize() {
+    return this.cache.size;
+  }
+}
+
+// Export singleton instance
+export const pathDetector = new PathDetector();
+export default pathDetector;