jtcsv 2.2.8 → 3.1.0

package/src/core/transform-hooks.js

@@ -1,350 +0,0 @@
-/**
- * Transform Hooks System
- * Система хуков для трансформации данных перед/после конвертации
- * 
- * @version 1.0.0
- * @date 2026-01-23
- */
-
-const { ValidationError } = require('../../errors');
-
-class TransformHooks {
-  constructor() {
-    this.hooks = {
-      beforeConvert: [],
-      afterConvert: [],
-      perRow: []
-    };
-  }
-
-  /**
-   * Регистрирует хук beforeConvert
-   * @param {Function} hook - Функция хука
-   * @returns {TransformHooks} this для цепочки вызовов
-   */
-  beforeConvert(hook) {
-    if (typeof hook !== 'function') {
-      throw new ValidationError('beforeConvert hook must be a function');
-    }
-    this.hooks.beforeConvert.push(hook);
-    return this;
-  }
-
-  /**
-   * Регистрирует хук afterConvert
-   * @param {Function} hook - Функция хука
-   * @returns {TransformHooks} this для цепочки вызовов
-   */
-  afterConvert(hook) {
-    if (typeof hook !== 'function') {
-      throw new ValidationError('afterConvert hook must be a function');
-    }
-    this.hooks.afterConvert.push(hook);
-    return this;
-  }
-
-  /**
-   * Регистрирует per-row хук
-   * @param {Function} hook - Функция хука
-   * @returns {TransformHooks} this для цепочки вызовов
-   */
-  perRow(hook) {
-    if (typeof hook !== 'function') {
-      throw new ValidationError('perRow hook must be a function');
-    }
-    this.hooks.perRow.push(hook);
-    return this;
-  }
-
-  /**
-   * Применяет beforeConvert хуки
-   * @param {any} data - Входные данные
-   * @param {Object} context - Контекст выполнения
-   * @returns {any} Трансформированные данные
-   */
-  applyBeforeConvert(data, context = {}) {
-    let result = data;
-    for (const hook of this.hooks.beforeConvert) {
-      result = hook(result, context);
-    }
-    return result;
-  }
-
-  /**
-   * Применяет afterConvert хуки
-   * @param {any} data - Выходные данные
-   * @param {Object} context - Контекст выполнения
-   * @returns {any} Трансформированные данные
-   */
-  applyAfterConvert(data, context = {}) {
-    let result = data;
-    for (const hook of this.hooks.afterConvert) {
-      result = hook(result, context);
-    }
-    return result;
-  }
-
-  /**
-   * Применяет per-row хуки
-   * @param {any} row - Строка данных
-   * @param {number} index - Индекс строки
-   * @param {Object} context - Контекст выполнения
-   * @returns {any} Трансформированная строка
-   */
-  applyPerRow(row, index, context = {}) {
-    let result = row;
-    for (const hook of this.hooks.perRow) {
-      result = hook(result, index, context);
-    }
-    return result;
-  }
-
-  /**
-   * Применяет все хуки к массиву данных
-   * @param {Array} data - Массив данных
-   * @param {Object} context - Контекст выполнения
-   * @returns {Array} Трансформированный массив
-   */
-  applyAll(data, context = {}) {
-    if (!Array.isArray(data)) {
-      throw new ValidationError('Data must be an array for applyAll');
-    }
-
-    // Применяем beforeConvert хуки
-    let processedData = this.applyBeforeConvert(data, context);
-
-    // Применяем per-row хуки к каждой строке
-    if (this.hooks.perRow.length > 0) {
-      processedData = processedData.map((row, index) => 
-        this.applyPerRow(row, index, context)
-      );
-    }
-
-    // Применяем afterConvert хуки
-    return this.applyAfterConvert(processedData, context);
-  }
-
-  /**
-   * Создает копию системы хуков
-   * @returns {TransformHooks} Новая копия
-   */
-  clone() {
-    const cloned = new TransformHooks();
-    cloned.hooks = {
-      beforeConvert: [...this.hooks.beforeConvert],
-      afterConvert: [...this.hooks.afterConvert],
-      perRow: [...this.hooks.perRow]
-    };
-    return cloned;
-  }
-
-  /**
-   * Очищает все хуки
-   */
-  clear() {
-    this.hooks = {
-      beforeConvert: [],
-      afterConvert: [],
-      perRow: []
-    };
-  }
-
-  /**
-   * Возвращает статистику по хукам
-   * @returns {Object} Статистика
-   */
-  getStats() {
-    return {
-      beforeConvert: this.hooks.beforeConvert.length,
-      afterConvert: this.hooks.afterConvert.length,
-      perRow: this.hooks.perRow.length,
-      total: this.hooks.beforeConvert.length + 
-             this.hooks.afterConvert.length + 
-             this.hooks.perRow.length
-    };
-  }
-}
-
-/**
- * Предопределенные хуки
- */
-const predefinedHooks = {
-  /**
-   * Хук для фильтрации данных
-   * @param {Function} predicate - Функция-предикат
-   * @returns {Function} Хук фильтрации
-   */
-  filter(predicate) {
-    return (data) => {
-      if (Array.isArray(data)) {
-        return data.filter(predicate);
-      }
-      return data;
-    };
-  },
-
-  /**
-   * Хук для маппинга данных
-   * @param {Function} mapper - Функция-маппер
-   * @returns {Function} Хук маппинга
-   */
-  map(mapper) {
-    return (data) => {
-      if (Array.isArray(data)) {
-        return data.map(mapper);
-      }
-      return data;
-    };
-  },
-
-  /**
-   * Хук для сортировки данных
-   * @param {Function} compareFn - Функция сравнения
-   * @returns {Function} Хук сортировки
-   */
-  sort(compareFn) {
-    return (data) => {
-      if (Array.isArray(data)) {
-        return [...data].sort(compareFn);
-      }
-      return data;
-    };
-  },
-
-  /**
-   * Хук для ограничения количества записей
-   * @param {number} limit - Максимальное количество записей
-   * @returns {Function} Хук ограничения
-   */
-  limit(limit) {
-    return (data) => {
-      if (Array.isArray(data)) {
-        return data.slice(0, limit);
-      }
-      return data;
-    };
-  },
-
-  /**
-   * Хук для добавления метаданных
-   * @param {Object} metadata - Метаданные для добавления
-   * @returns {Function} Хук добавления метаданных
-   */
-  addMetadata(metadata) {
-    return (data, context) => {
-      if (Array.isArray(data)) {
-        return data.map(item => ({
-          ...item,
-          _metadata: {
-            ...metadata,
-            timestamp: new Date().toISOString(),
-            context
-          }
-        }));
-      }
-      return data;
-    };
-  },
-
-  /**
-   * Хук для преобразования ключей
-   * @param {Function} keyTransformer - Функция преобразования ключей
-   * @returns {Function} Хук преобразования ключей
-   */
-  transformKeys(keyTransformer) {
-    return (data) => {
-      if (Array.isArray(data)) {
-        return data.map(item => {
-          const transformed = {};
-          for (const [key, value] of Object.entries(item)) {
-            transformed[keyTransformer(key)] = value;
-          }
-          return transformed;
-        });
-      }
-      return data;
-    };
-  },
-
-  /**
-   * Хук для преобразования значений
-   * @param {Function} valueTransformer - Функция преобразования значений
-   * @returns {Function} Хук преобразования значений
-   */
-  transformValues(valueTransformer) {
-    return (data) => {
-      if (Array.isArray(data)) {
-        return data.map(item => {
-          const transformed = {};
-          for (const [key, value] of Object.entries(item)) {
-            transformed[key] = valueTransformer(value, key);
-          }
-          return transformed;
-        });
-      }
-      return data;
-    };
-  },
-
-  /**
-   * Хук для валидации данных
-   * @param {Function} validator - Функция валидации
-   * @param {Function} onError - Обработчик ошибки
-   * @returns {Function} Хук валидации
-   */
-  validate(validator, onError = console.error) {
-    return (data) => {
-      if (Array.isArray(data)) {
-        const validData = [];
-        const errors = [];
-
-        data.forEach((item, index) => {
-          try {
-            const isValid = validator(item, index);
-            if (isValid) {
-              validData.push(item);
-            } else {
-              errors.push({ index, item, reason: 'Validation failed' });
-            }
-          } catch (error) {
-            errors.push({ index, item, error: error.message });
-          }
-        });
-
-        if (errors.length > 0) {
-          onError('Validation errors:', errors);
-        }
-
-        return validData;
-      }
-      return data;
-    };
-  },
-
-  /**
-   * Хук для дедупликации данных
-   * @param {Function} keySelector - Функция выбора ключа
-   * @returns {Function} Хук дедупликации
-   */
-  deduplicate(keySelector = JSON.stringify) {
-    return (data) => {
-      if (Array.isArray(data)) {
-        const seen = new Set();
-        return data.filter(item => {
-          const key = keySelector(item);
-          if (seen.has(key)) {
-            return false;
-          }
-          seen.add(key);
-          return true;
-        });
-      }
-      return data;
-    };
-  }
-};
-
-module.exports = {
-  TransformHooks,
-  predefinedHooks
-};

package/src/errors.js

@@ -1,26 +0,0 @@
-class ValidationError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = 'ValidationError';
-  }
-}
-
-class SecurityError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = 'SecurityError';
-  }
-}
-
-class ConfigurationError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = 'ConfigurationError';
-  }
-}
-
-module.exports = {
-  ValidationError,
-  SecurityError,
-  ConfigurationError
-};

package/src/utils/transform-loader.js

@@ -1,205 +0,0 @@
-/**
- * Transform Loader Utility
- * 
- * Utility for loading and applying transform functions from JavaScript files
- */
-
-const fs = require('fs');
-const path = require('path');
-const vm = require('vm');
-
-const {
-  ValidationError,
-  SecurityError,
-  ConfigurationError
-} = require('../errors');
-
-/**
- * Validates transform function
- * @private
- */
-function validateTransformFunction(fn) {
-  if (typeof fn !== 'function') {
-    throw new ValidationError('Transform must export a function');
-  }
-  
-  // Check function arity (should accept 1-2 parameters)
-  const functionString = fn.toString();
-  const paramMatch = functionString.match(/\(([^)]*)\)/);
-  if (paramMatch) {
-    const params = paramMatch[1].split(',').map(p => p.trim()).filter(p => p);
-    if (params.length === 0 || params.length > 2) {
-      throw new ValidationError('Transform function should accept 1-2 parameters: (row, index)');
-    }
-  }
-  
-  return true;
-}
-
-/**
- * Loads transform function from a JavaScript file
- * 
- * @param {string} transformPath - Path to JavaScript file with transform function
- * @returns {Function} Transform function
- * 
- * @example
- * // transform.js
- * module.exports = function(row, index) {
- *   return { ...row, processed: true, index };
- * };
- * 
- * // Usage
- * const transform = loadTransform('./transform.js');
- * const result = transform({ id: 1, name: 'John' }, 0);
- */
-function loadTransform(transformPath) {
-  if (!transformPath || typeof transformPath !== 'string') {
-    throw new ValidationError('Transform path must be a string');
-  }
-  
-  // Validate file path
-  const safePath = path.resolve(transformPath);
-  
-  // Prevent directory traversal
-  const normalizedPath = path.normalize(transformPath);
-  if (normalizedPath.includes('..') || 
-      /\\\.\.\\|\/\.\.\//.test(transformPath) ||
-      transformPath.startsWith('..') ||
-      transformPath.includes('/..')) {
-    throw new SecurityError('Directory traversal detected in transform file path');
-  }
-  
-  // Check file exists and has .js extension
-  if (!fs.existsSync(safePath)) {
-    throw new ValidationError(`Transform file not found: ${transformPath}`);
-  }
-  
-  if (!safePath.toLowerCase().endsWith('.js')) {
-    throw new ValidationError('Transform file must have .js extension');
-  }
-  
-  try {
-    // Read and evaluate the transform file in a safe context
-    const transformCode = fs.readFileSync(safePath, 'utf8');
-    
-    // Create a safe context with limited access
-    const sandbox = {
-      console,
-      require,
-      module: { exports: {} },
-      exports: {},
-      __filename: safePath,
-      __dirname: path.dirname(safePath),
-      Buffer,
-      process: {
-        env: process.env,
-        cwd: process.cwd,
-        platform: process.platform
-      }
-    };
-    
-    // Create a context and run the code
-    const context = vm.createContext(sandbox);
-    const script = new vm.Script(transformCode, { filename: safePath });
-    script.runInContext(context);
-    
-    // Get the exported function
-    const transformFn = context.module.exports || context.exports;
-    
-    // Handle default export for ES6 modules
-    const finalTransform = transformFn.default || transformFn;
-    
-    // Validate the transform function
-    validateTransformFunction(finalTransform);
-    
-    return finalTransform;
-  } catch (error) {
-    if (error instanceof ValidationError || error instanceof SecurityError) {
-      throw error;
-    }
-    
-    if (error.code === 'EACCES') {
-      throw new SecurityError(`Permission denied reading transform file: ${transformPath}`);
-    }
-    
-    throw new ValidationError(`Failed to load transform function: ${error.message}`);
-  }
-}
-
-/**
- * Creates a transform hook for use with csvToJson/jsonToCsv hooks system
- * 
- * @param {string|Function} transform - Transform function or path to transform file
- * @returns {Function} Transform hook function
- */
-function createTransformHook(transform) {
-  let transformFn;
-  
-  if (typeof transform === 'string') {
-    // Load transform from file
-    transformFn = loadTransform(transform);
-  } else if (typeof transform === 'function') {
-    // Use provided function
-    validateTransformFunction(transform);
-    transformFn = transform;
-  } else {
-    throw new ValidationError('Transform must be a function or a path to a JavaScript file');
-  }
-  
-  // Return a hook function compatible with hooks.perRow
-  return function(row, index, context) {
-    try {
-      return transformFn(row, index);
-    } catch (error) {
-      // Log error but don't crash - return original row
-      console.error(`Transform error at row ${index}: ${error.message}`);
-      if (process.env.NODE_ENV === 'development') {
-        console.error(error.stack);
-      }
-      return row;
-    }
-  };
-}
-
-/**
- * Applies transform to data array
- * 
- * @param {Array} data - Array of data to transform
- * @param {string|Function} transform - Transform function or path to transform file
- * @returns {Array} Transformed data
- */
-function applyTransform(data, transform) {
-  if (!Array.isArray(data)) {
-    throw new ValidationError('Data must be an array');
-  }
-  
-  const transformHook = createTransformHook(transform);
-  
-  return data.map((row, index) => {
-    return transformHook(row, index, { operation: 'applyTransform' });
-  });
-}
-
-/**
- * Creates a TransformHooks instance with transform function
- * 
- * @param {string|Function} transform - Transform function or path to transform file
- * @returns {TransformHooks} TransformHooks instance
- */
-function createTransformHooksWithTransform(transform) {
-  const { TransformHooks } = require('../core/transform-hooks');
-  const hooks = new TransformHooks();
-  
-  const transformHook = createTransformHook(transform);
-  hooks.perRow(transformHook);
-  
-  return hooks;
-}
-
-module.exports = {
-  loadTransform,
-  createTransformHook,
-  applyTransform,
-  createTransformHooksWithTransform,
-  validateTransformFunction
-};