@arela/uploader 0.2.13 → 1.0.0

package/src/services/AdvancedFilterService.js

@@ -0,0 +1,505 @@
+/**
+ * AdvancedFilterService.js
+ * Phase 7 - Task 1: Advanced Filtering & Validation
+ *
+ * Provides advanced filtering options for files including:
+ * - File type filtering
+ * - File size filtering
+ * - Date range filtering
+ * - Custom validation rules
+ * - Complex filter combinations
+ */
+import fs from 'fs/promises';
+import path from 'path';
+
+class AdvancedFilterService {
+  constructor(logger) {
+    this.logger = logger;
+
+    // Filter presets
+    this.filterPresets = {
+      pdfOnly: {
+        name: 'PDF Files Only',
+        filters: [{ type: 'extension', value: '.pdf', operator: 'equals' }],
+      },
+      largeFiles: {
+        name: 'Large Files (>10MB)',
+        filters: [
+          { type: 'size', value: 10 * 1024 * 1024, operator: 'greaterThan' },
+        ],
+      },
+      recentFiles: {
+        name: 'Recent Files (Last 7 days)',
+        filters: [{ type: 'dateModified', value: 7, operator: 'daysAgo' }],
+      },
+      documentsOnly: {
+        name: 'Documents',
+        filters: [
+          {
+            type: 'extension',
+            value: ['.pdf', '.doc', '.docx', '.xls', '.xlsx'],
+            operator: 'in',
+          },
+        ],
+      },
+    };
+
+    // Validation rules
+    this.validationRules = {
+      pdfs: {
+        extension: '.pdf',
+        minSize: 0,
+        maxSize: 500 * 1024 * 1024, // 500MB
+        allowedFormats: ['pdf'],
+      },
+      documents: {
+        extension: ['.pdf', '.doc', '.docx', '.xls', '.xlsx'],
+        minSize: 0,
+        maxSize: 100 * 1024 * 1024,
+        allowedFormats: ['pdf', 'doc', 'docx', 'xls', 'xlsx'],
+      },
+      images: {
+        extension: ['.jpg', '.jpeg', '.png', '.gif', '.bmp'],
+        minSize: 0,
+        maxSize: 50 * 1024 * 1024,
+        allowedFormats: ['jpg', 'jpeg', 'png', 'gif', 'bmp'],
+      },
+    };
+
+    // Statistics
+    this.stats = {
+      filesFiltered: 0,
+      filesMatched: 0,
+      filesRejected: 0,
+      filterApplications: 0,
+    };
+  }
+
+  /**
+   * Apply multiple filters to a file list
+   */
+  async filterFiles(files, filterConfig) {
+    const startTime = Date.now();
+    this.stats.filterApplications++;
+
+    let filtered = [...files];
+    const filterResults = {
+      original: files.length,
+      stages: [],
+      final: 0,
+      duration: 0,
+      rejectedFiles: [],
+    };
+
+    if (!filterConfig || Object.keys(filterConfig).length === 0) {
+      return {
+        files: filtered,
+        results: filterResults,
+      };
+    }
+
+    // Apply each filter in sequence
+    const filterEntries = Object.entries(filterConfig);
+    for (const [filterType, filterValue] of filterEntries) {
+      const beforeCount = filtered.length;
+
+      switch (filterType) {
+        case 'extension':
+          filtered = await this._filterByExtension(filtered, filterValue);
+          break;
+        case 'size':
+          filtered = await this._filterBySize(filtered, filterValue);
+          break;
+        case 'dateModified':
+          filtered = await this._filterByDateModified(filtered, filterValue);
+          break;
+        case 'dateCreated':
+          filtered = await this._filterByDateCreated(filtered, filterValue);
+          break;
+        case 'custom':
+          filtered = await this._filterByCustomRule(filtered, filterValue);
+          break;
+        case 'validation':
+          filtered = await this._filterByValidation(filtered, filterValue);
+          break;
+      }
+
+      const afterCount = filtered.length;
+      filterResults.stages.push({
+        filterType,
+        before: beforeCount,
+        after: afterCount,
+        removed: beforeCount - afterCount,
+      });
+    }
+
+    filterResults.final = filtered.length;
+    filterResults.duration = Date.now() - startTime;
+
+    this.stats.filesFiltered += files.length;
+    this.stats.filesMatched += filtered.length;
+    this.stats.filesRejected += files.length - filtered.length;
+
+    this.logger.debug(
+      `Filtered ${files.length} files to ${filtered.length} (${filterResults.duration}ms)`,
+    );
+
+    return {
+      files: filtered,
+      results: filterResults,
+    };
+  }
+
+  /**
+   * Filter by file extension
+   */
+  async _filterByExtension(files, extensions) {
+    const extensionList = Array.isArray(extensions) ? extensions : [extensions];
+    const normalized = extensionList.map((ext) => ext.toLowerCase());
+
+    return files.filter((file) => {
+      const fileExt = path.extname(file).toLowerCase();
+      return normalized.includes(fileExt);
+    });
+  }
+
+  /**
+   * Filter by file size
+   */
+  async _filterBySize(files, sizeConfig) {
+    const filtered = [];
+
+    for (const file of files) {
+      try {
+        const stats = await fs.stat(file);
+
+        if (sizeConfig.min && stats.size < sizeConfig.min) continue;
+        if (sizeConfig.max && stats.size > sizeConfig.max) continue;
+
+        filtered.push(file);
+      } catch (error) {
+        this.logger.warn(`Failed to stat file: ${file}`, error.message);
+      }
+    }
+
+    return filtered;
+  }
+
+  /**
+   * Filter by date modified
+   */
+  async _filterByDateModified(files, dateConfig) {
+    const filtered = [];
+    const now = Date.now();
+
+    for (const file of files) {
+      try {
+        const stats = await fs.stat(file);
+        const fileTime = stats.mtime.getTime();
+
+        if (dateConfig.daysAgo !== undefined) {
+          const daysInMs = dateConfig.daysAgo * 24 * 60 * 60 * 1000;
+          if (now - fileTime > daysInMs) continue;
+        }
+
+        if (
+          dateConfig.before &&
+          fileTime > new Date(dateConfig.before).getTime()
+        )
+          continue;
+        if (dateConfig.after && fileTime < new Date(dateConfig.after).getTime())
+          continue;
+
+        filtered.push(file);
+      } catch (error) {
+        this.logger.warn(`Failed to stat file: ${file}`, error.message);
+      }
+    }
+
+    return filtered;
+  }
+
+  /**
+   * Filter by date created
+   */
+  async _filterByDateCreated(files, dateConfig) {
+    const filtered = [];
+
+    for (const file of files) {
+      try {
+        const stats = await fs.stat(file);
+        const birthTime = stats.birthtime.getTime();
+        const now = Date.now();
+
+        if (dateConfig.daysAgo !== undefined) {
+          const daysInMs = dateConfig.daysAgo * 24 * 60 * 60 * 1000;
+          if (now - birthTime > daysInMs) continue;
+        }
+
+        filtered.push(file);
+      } catch (error) {
+        this.logger.warn(`Failed to stat file: ${file}`, error.message);
+      }
+    }
+
+    return filtered;
+  }
+
+  /**
+   * Filter by custom validation rule
+   */
+  async _filterByCustomRule(files, ruleFunction) {
+    const filtered = [];
+
+    for (const file of files) {
+      try {
+        const stats = await fs.stat(file);
+        const shouldInclude = await ruleFunction({
+          path: file,
+          name: path.basename(file),
+          size: stats.size,
+          modified: stats.mtime,
+          created: stats.birthtime,
+          isDirectory: stats.isDirectory(),
+        });
+
+        if (shouldInclude) {
+          filtered.push(file);
+        }
+      } catch (error) {
+        this.logger.warn(`Custom filter error for ${file}:`, error.message);
+      }
+    }
+
+    return filtered;
+  }
+
+  /**
+   * Filter by validation rule preset
+   */
+  async _filterByValidation(files, validationRule) {
+    const rule =
+      typeof validationRule === 'string'
+        ? this.validationRules[validationRule]
+        : validationRule;
+
+    if (!rule) {
+      this.logger.warn(`Unknown validation rule: ${validationRule}`);
+      return files;
+    }
+
+    const filtered = [];
+
+    for (const file of files) {
+      try {
+        const ext = path.extname(file).toLowerCase();
+        const stats = await fs.stat(file);
+
+        // Check extension
+        const allowedExts = Array.isArray(rule.extension)
+          ? rule.extension
+          : [rule.extension];
+        if (!allowedExts.includes(ext)) continue;
+
+        // Check size
+        if (stats.size < rule.minSize) continue;
+        if (stats.size > rule.maxSize) continue;
+
+        filtered.push(file);
+      } catch (error) {
+        this.logger.warn(`Validation error for ${file}:`, error.message);
+      }
+    }
+
+    return filtered;
+  }
+
+  /**
+   * Create a complex filter query
+   */
+  createFilterQuery(config) {
+    const query = {
+      filters: [],
+      logic: config.logic || 'AND',
+      description: config.description || 'Custom filter query',
+    };
+
+    if (config.extensions) {
+      query.filters.push({
+        type: 'extension',
+        operator: 'in',
+        values: Array.isArray(config.extensions)
+          ? config.extensions
+          : [config.extensions],
+      });
+    }
+
+    if (config.minSize !== undefined) {
+      query.filters.push({
+        type: 'size',
+        operator: 'greaterThan',
+        value: config.minSize,
+      });
+    }
+
+    if (config.maxSize !== undefined) {
+      query.filters.push({
+        type: 'size',
+        operator: 'lessThan',
+        value: config.maxSize,
+      });
+    }
+
+    if (config.modifiedInDays !== undefined) {
+      query.filters.push({
+        type: 'dateModified',
+        operator: 'daysAgo',
+        value: config.modifiedInDays,
+      });
+    }
+
+    return query;
+  }
+
+  /**
+   * Apply a filter preset
+   */
+  async applyPreset(files, presetName) {
+    const preset = this.filterPresets[presetName];
+
+    if (!preset) {
+      this.logger.error(`Unknown preset: ${presetName}`);
+      return { files, results: { error: `Unknown preset: ${presetName}` } };
+    }
+
+    const filterConfig = {};
+
+    for (const filter of preset.filters) {
+      if (filter.type === 'extension') {
+        filterConfig.extension = filter.value;
+      } else if (filter.type === 'size') {
+        filterConfig.size = {
+          [filter.operator === 'greaterThan' ? 'min' : 'max']: filter.value,
+        };
+      } else if (filter.type === 'dateModified') {
+        filterConfig.dateModified = { daysAgo: filter.value };
+      }
+    }
+
+    return this.filterFiles(files, filterConfig);
+  }
+
+  /**
+   * Get available filter presets
+   */
+  getFilterPresets() {
+    return Object.entries(this.filterPresets).map(([key, preset]) => ({
+      key,
+      name: preset.name,
+      description: `Filter: ${preset.filters.map((f) => f.type).join(', ')}`,
+    }));
+  }
+
+  /**
+   * Get available validation rules
+   */
+  getValidationRules() {
+    return Object.entries(this.validationRules).map(([key, rule]) => ({
+      key,
+      extensions: Array.isArray(rule.extension)
+        ? rule.extension
+        : [rule.extension],
+      minSize: rule.minSize,
+      maxSize: rule.maxSize,
+    }));
+  }
+
+  /**
+   * Validate a single file against rule
+   */
+  async validateFile(filePath, ruleName) {
+    const rule = this.validationRules[ruleName];
+
+    if (!rule) {
+      return { valid: false, error: `Unknown rule: ${ruleName}` };
+    }
+
+    try {
+      const stats = await fs.stat(filePath);
+      const ext = path.extname(filePath).toLowerCase();
+      const allowedExts = Array.isArray(rule.extension)
+        ? rule.extension
+        : [rule.extension];
+
+      const validation = {
+        filePath,
+        ruleName,
+        valid: true,
+        checks: [],
+      };
+
+      // Check extension
+      const extCheck = {
+        check: 'extension',
+        allowed: allowedExts,
+        actual: ext,
+        passed: allowedExts.includes(ext),
+      };
+      validation.checks.push(extCheck);
+      if (!extCheck.passed) validation.valid = false;
+
+      // Check size
+      const sizeCheck = {
+        check: 'size',
+        min: rule.minSize,
+        max: rule.maxSize,
+        actual: stats.size,
+        passed: stats.size >= rule.minSize && stats.size <= rule.maxSize,
+      };
+      validation.checks.push(sizeCheck);
+      if (!sizeCheck.passed) validation.valid = false;
+
+      return validation;
+    } catch (error) {
+      return {
+        valid: false,
+        error: error.message,
+        filePath,
+      };
+    }
+  }
+
+  /**
+   * Get filter statistics
+   */
+  getStatistics() {
+    return {
+      ...this.stats,
+      averageFilesPerFilter:
+        this.stats.filterApplications > 0
+          ? Math.round(this.stats.filesFiltered / this.stats.filterApplications)
+          : 0,
+      matchRate:
+        this.stats.filesFiltered > 0
+          ? (
+              (this.stats.filesMatched / this.stats.filesFiltered) *
+              100
+            ).toFixed(2) + '%'
+          : 'N/A',
+    };
+  }
+
+  /**
+   * Reset statistics
+   */
+  resetStatistics() {
+    this.stats = {
+      filesFiltered: 0,
+      filesMatched: 0,
+      filesRejected: 0,
+      filterApplications: 0,
+    };
+  }
+}
+
+export default AdvancedFilterService;