jtcsv 1.2.0 → 2.1.1

package/src/formats/tsv-parser.js

@@ -0,0 +1,336 @@
+/**
+ * TSV (Tab-Separated Values) парсер
+ * Специализированная поддержка TSV формата
+ * 
+ * @version 1.0.0
+ * @date 2026-01-23
+ */
+
+const { csvToJson } = require('../../csv-to-json');
+const { jsonToCsv } = require('../../json-to-csv');
+const { ValidationError, SecurityError, FileSystemError } = require('../../errors');
+const path = require('path');
+
+function validateTsvFilePath(filePath) {
+  if (typeof filePath !== 'string' || filePath.trim() === '') {
+    throw new ValidationError('File path must be a non-empty string');
+  }
+
+  if (!filePath.toLowerCase().endsWith('.tsv')) {
+    throw new ValidationError('File must have .tsv extension');
+  }
+
+  const normalizedPath = path.normalize(filePath);
+  if (normalizedPath.includes('..') ||
+      /\\\.\.\\|\/\.\.\//.test(filePath) ||
+      filePath.startsWith('..') ||
+      filePath.includes('/..')) {
+    throw new SecurityError('Directory traversal detected in file path');
+  }
+
+  return path.resolve(filePath);
+}
+
+class TsvParser {
+  /**
+   * Конвертирует массив объектов в TSV строку
+   * @param {Array} data - Массив объектов
+   * @param {Object} options - Опции форматирования
+   * @returns {string} TSV строка
+   * 
+   * @example
+   * const data = [{ id: 1, name: 'John' }, { id: 2, name: 'Jane' }];
+   * const tsv = TsvParser.jsonToTsv(data);
+   * // Результат: "id\tname\n1\tJohn\n2\tJane"
+   */
+  static jsonToTsv(data, options = {}) {
+    const defaultOptions = {
+      delimiter: '\t',
+      includeHeaders: true,
+      ...options
+    };
+    
+    return jsonToCsv(data, defaultOptions);
+  }
+
+  /**
+   * Конвертирует TSV строку в массив объектов
+   * @param {string} tsvString - TSV строка
+   * @param {Object} options - Опции парсинга
+   * @returns {Array} Массив объектов
+   * 
+   * @example
+   * const tsv = "id\tname\n1\tJohn\n2\tJane";
+   * const data = TsvParser.tsvToJson(tsv);
+   * // Результат: [{ id: 1, name: 'John' }, { id: 2, name: 'Jane' }]
+   */
+  static tsvToJson(tsvString, options = {}) {
+    const defaultOptions = {
+      delimiter: '\t',
+      autoDetect: false,
+      hasHeaders: true,
+      ...options
+    };
+    
+    return csvToJson(tsvString, defaultOptions);
+  }
+
+  /**
+   * Автоматически определяет является ли строка TSV
+   * @param {string} sample - Образец данных
+   * @returns {boolean} True если это TSV
+   */
+  static isTsv(sample) {
+    if (!sample || typeof sample !== 'string') {
+      return false;
+    }
+
+    const lines = sample.split('\n').slice(0, 10);
+    let tabCount = 0;
+    let commaCount = 0;
+    let semicolonCount = 0;
+
+    for (const line of lines) {
+      if (line.trim() === '') {
+        continue;
+      }
+      
+      // Считаем разделители
+      tabCount += (line.match(/\t/g) || []).length;
+      commaCount += (line.match(/,/g) || []).length;
+      semicolonCount += (line.match(/;/g) || []).length;
+    }
+
+    // Если табуляций больше чем других разделителей, считаем это TSV
+    return tabCount > commaCount && tabCount > semicolonCount;
+  }
+
+  /**
+   * Создает TransformStream для конвертации JSON в TSV
+   * @param {Object} options - Опции конвертации
+   * @returns {TransformStream} Transform stream
+   */
+  static createJsonToTsvStream(options = {}) {
+    const { createJsonToCsvStream } = require('../../stream-json-to-csv');
+    
+    return createJsonToCsvStream({
+      delimiter: '\t',
+      ...options
+    });
+  }
+
+  /**
+   * Создает TransformStream для конвертации TSV в JSON
+   * @param {Object} options - Опции конвертации
+   * @returns {TransformStream} Transform stream
+   */
+  static createTsvToJsonStream(options = {}) {
+    const { createCsvToJsonStream } = require('../../stream-csv-to-json');
+    
+    return createCsvToJsonStream({
+      delimiter: '\t',
+      autoDetect: false,
+      ...options
+    });
+  }
+
+  /**
+   * Читает TSV файл и конвертирует в JSON
+   * @param {string} filePath - Путь к TSV файлу
+   * @param {Object} options - Опции парсинга
+   * @returns {Promise<Array>} Promise с массивом объектов
+   */
+  static async readTsvAsJson(filePath, options = {}) {
+    const fs = require('fs').promises;
+    const safePath = validateTsvFilePath(filePath);
+
+    try {
+      const tsvContent = await fs.readFile(safePath, 'utf8');
+      return csvToJson(tsvContent, {
+        delimiter: '\t',
+        autoDetect: false,
+        ...options
+      });
+    } catch (error) {
+      if (error instanceof ValidationError || error instanceof SecurityError) {
+        throw error;
+      }
+      if (error.code === 'ENOENT') {
+        throw new FileSystemError(`File not found: ${safePath}`, error);
+      }
+      if (error.code === 'EACCES') {
+        throw new FileSystemError(`Permission denied: ${safePath}`, error);
+      }
+      if (error.code === 'EISDIR') {
+        throw new FileSystemError(`Path is a directory: ${safePath}`, error);
+      }
+      throw new FileSystemError(`Failed to read TSV file: ${error.message}`, error);
+    }
+  }
+
+  /**
+   * Синхронно читает TSV файл и конвертирует в JSON
+   * @param {string} filePath - Путь к TSV файлу
+   * @param {Object} options - Опции парсинга
+   * @returns {Array} Массив объектов
+   */
+  static readTsvAsJsonSync(filePath, options = {}) {
+    const fs = require('fs');
+    const safePath = validateTsvFilePath(filePath);
+
+    try {
+      const tsvContent = fs.readFileSync(safePath, 'utf8');
+      return csvToJson(tsvContent, {
+        delimiter: '\t',
+        autoDetect: false,
+        ...options
+      });
+    } catch (error) {
+      if (error instanceof ValidationError || error instanceof SecurityError) {
+        throw error;
+      }
+      if (error.code === 'ENOENT') {
+        throw new FileSystemError(`File not found: ${safePath}`, error);
+      }
+      if (error.code === 'EACCES') {
+        throw new FileSystemError(`Permission denied: ${safePath}`, error);
+      }
+      if (error.code === 'EISDIR') {
+        throw new FileSystemError(`Path is a directory: ${safePath}`, error);
+      }
+      throw new FileSystemError(`Failed to read TSV file: ${error.message}`, error);
+    }
+  }
+
+  /**
+   * Сохраняет массив объектов как TSV файл
+   * @param {Array} data - Массив объектов
+   * @param {string} filePath - Путь для сохранения
+   * @param {Object} options - Опции сохранения
+   * @returns {Promise<void>}
+   */
+  static async saveAsTsv(data, filePath, options = {}) {
+    const fs = require('fs').promises;
+    const safePath = validateTsvFilePath(filePath);
+    const tsvContent = this.jsonToTsv(data, options);
+    const dir = path.dirname(safePath);
+
+    try {
+      await fs.mkdir(dir, { recursive: true });
+      await fs.writeFile(safePath, tsvContent, 'utf8');
+      return safePath;
+    } catch (error) {
+      if (error.code === 'ENOENT') {
+        throw new FileSystemError(`Directory does not exist: ${dir}`, error);
+      }
+      if (error.code === 'EACCES') {
+        throw new FileSystemError(`Permission denied: ${safePath}`, error);
+      }
+      if (error.code === 'ENOSPC') {
+        throw new FileSystemError(`No space left on device: ${safePath}`, error);
+      }
+      throw new FileSystemError(`Failed to save TSV file: ${error.message}`, error);
+    }
+  }
+
+  /**
+   * Синхронно сохраняет массив объектов как TSV файл
+   * @param {Array} data - Массив объектов
+   * @param {string} filePath - Путь для сохранения
+   * @param {Object} options - Опции сохранения
+   */
+  static saveAsTsvSync(data, filePath, options = {}) {
+    const fs = require('fs');
+    const safePath = validateTsvFilePath(filePath);
+    const tsvContent = this.jsonToTsv(data, options);
+
+    fs.mkdirSync(path.dirname(safePath), { recursive: true });
+    fs.writeFileSync(safePath, tsvContent, 'utf8');
+  }
+
+  /**
+   * Валидирует TSV строку
+   * @param {string} tsvString - TSV строка для валидации
+   * @param {Object} options - Опции валидации
+   * @returns {Object} Результат валидации
+   */
+  static validateTsv(tsvString, options = {}) {
+    const { requireConsistentColumns = true } = options;
+    
+    if (!tsvString || typeof tsvString !== 'string') {
+      return {
+        valid: false,
+        error: 'Input must be a non-empty string',
+        details: { inputType: typeof tsvString }
+      };
+    }
+
+    const lines = tsvString.split('\n').filter(line => line.trim() !== '');
+    
+    if (lines.length === 0) {
+      return {
+        valid: false,
+        error: 'No data found in TSV',
+        details: { lineCount: 0 }
+      };
+    }
+
+    const columnCounts = [];
+    const errors = [];
+
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const columns = line.split('\t');
+      columnCounts.push(columns.length);
+
+      // Проверяем наличие пустых полей (если требуется)
+      if (options.disallowEmptyFields) {
+        const emptyFields = columns.filter(field => field.trim() === '');
+        if (emptyFields.length > 0) {
+          errors.push({
+            line: i + 1,
+            error: `Found ${emptyFields.length} empty field(s)`,
+            fields: emptyFields.map((_, idx) => idx + 1)
+          });
+        }
+      }
+    }
+
+    // Проверяем консистентность колонки
+    if (requireConsistentColumns && columnCounts.length > 1) {
+      const firstCount = columnCounts[0];
+      const inconsistentLines = [];
+      
+      for (let i = 1; i < columnCounts.length; i++) {
+        if (columnCounts[i] !== firstCount) {
+          inconsistentLines.push({
+            line: i + 1,
+            expected: firstCount,
+            actual: columnCounts[i]
+          });
+        }
+      }
+
+      if (inconsistentLines.length > 0) {
+        errors.push({
+          error: 'Inconsistent column count',
+          details: inconsistentLines
+        });
+      }
+    }
+
+    return {
+      valid: errors.length === 0,
+      stats: {
+        totalLines: lines.length,
+        totalColumns: columnCounts[0] || 0,
+        minColumns: Math.min(...columnCounts),
+        maxColumns: Math.max(...columnCounts),
+        consistentColumns: new Set(columnCounts).size === 1
+      },
+      errors: errors.length > 0 ? errors : undefined
+    };
+  }
+}
+
+module.exports = TsvParser;

package/src/index-with-plugins.js

@@ -0,0 +1,371 @@
+/**
+ * JTCSV с поддержкой плагинов
+ * Расширяемая версия основного API с plugin system
+ * 
+ * @version 1.0.0
+ * @date 2026-01-22
+ */
+
+const PluginManager = require('./core/plugin-system');
+const FastPathEngine = require('./engines/fast-path-engine');
+const NdjsonParser = require('./formats/ndjson-parser');
+
+// Импортируем основные функции
+const coreJsonToCsv = require('../json-to-csv').jsonToCsv;
+const coreCsvToJson = require('../csv-to-json').csvToJson;
+const coreCsvToJsonIterator = require('../csv-to-json').csvToJsonIterator;
+const coreSaveAsCsv = require('../json-to-csv').saveAsCsv;
+const coreReadCsvAsJson = require('../csv-to-json').readCsvAsJson;
+
+class JtcsvWithPlugins {
+  constructor(options = {}) {
+    this.pluginManager = new PluginManager();
+    this.fastPathEngine = new FastPathEngine();
+    this.options = {
+      enableFastPath: true,
+      enablePlugins: true,
+      ...options
+    };
+
+    // Регистрируем встроенные плагины
+    this._registerBuiltinPlugins();
+  }
+
+  /**
+   * Регистрирует встроенные плагины
+   */
+  _registerBuiltinPlugins() {
+    // Fast Path Engine плагин
+    this.pluginManager.use('fast-path-engine', {
+      name: 'Fast Path Engine',
+      version: '1.0.0',
+      description: 'Оптимизированный парсер CSV с автоматическим выбором стратегии',
+      hooks: {
+        'before:csvToJson': (csv, context) => {
+          if (this.options.enableFastPath && context.options?.useFastPath !== false) {
+            // Используем fast path engine для анализа
+            const sample = csv.substring(0, Math.min(1000, csv.length));
+            const structure = this.fastPathEngine.analyzeStructure(sample, context.options);
+            
+            context.metadata.fastPathStructure = structure;
+            console.log(`🚀 Используется ${structure.recommendedEngine} парсер`);
+          }
+          return csv;
+        },
+        'after:csvToJson': (result, context) => {
+          if (context.metadata?.fastPathStructure) {
+            context.metadata.fastPathStats = this.fastPathEngine.getStats();
+          }
+          return result;
+        }
+      }
+    });
+
+    // NDJSON плагин
+    this.pluginManager.use('ndjson-support', {
+      name: 'NDJSON Support',
+      version: '1.0.0',
+      description: 'Поддержка Newline Delimited JSON формата',
+      hooks: {
+        'before:parse': (input, context) => {
+          if (context.options?.format === 'ndjson') {
+            // Парсим NDJSON
+            return NdjsonParser.fromNdjson(input, context.options);
+          }
+          return input;
+        },
+        'after:serialize': (output, context) => {
+          if (context.options?.format === 'ndjson') {
+            // Сериализуем в NDJSON
+            return NdjsonParser.toNdjson(output, context.options);
+          }
+          return output;
+        }
+      }
+    });
+
+    // Валидация данных плагин
+    this.pluginManager.use('data-validation', {
+      name: 'Data Validation',
+      version: '1.0.0',
+      description: 'Валидация входных и выходных данных',
+      hooks: {
+        'validation': (data, context) => {
+          if (!data) {
+            throw new Error('Данные не могут быть пустыми');
+          }
+          
+          if (context.operation === 'jsonToCsv' && !Array.isArray(data)) {
+            throw new Error('Для конвертации в CSV данные должны быть массивом');
+          }
+          
+          return data;
+        }
+      },
+      middlewares: [
+        async (ctx, next) => {
+          // Валидация перед выполнением
+          await this.pluginManager.executeHooks('validation', ctx.input, ctx);
+          await next();
+          // Валидация после выполнения
+          await this.pluginManager.executeHooks('validation', ctx.result, ctx);
+        }
+      ]
+    });
+
+    // Логирование плагин
+    this.pluginManager.use('logging', {
+      name: 'Logging',
+      version: '1.0.0',
+      description: 'Логирование операций',
+      hooks: {
+        'before:csvToJson': (csv, context) => {
+          console.log(`📥 Начало csvToJson, размер: ${csv.length} байт`);
+          return csv;
+        },
+        'after:csvToJson': (result, context) => {
+          console.log(`📤 Завершение csvToJson, результат: ${result.length} записей`);
+          return result;
+        },
+        'before:jsonToCsv': (json, context) => {
+          console.log(`📥 Начало jsonToCsv, записей: ${json.length}`);
+          return json;
+        },
+        'after:jsonToCsv': (csv, context) => {
+          console.log(`📤 Завершение jsonToCsv, размер: ${csv.length} байт`);
+          return csv;
+        }
+      }
+    });
+  }
+
+  /**
+   * Конвертирует CSV в JSON с поддержкой плагинов
+   * @param {string} csv - CSV данные
+   * @param {Object} options - Опции парсинга
+   * @returns {Promise<Array>} JSON данные
+   */
+  async csvToJson(csv, options = {}) {
+    if (!this.options.enablePlugins) {
+      return coreCsvToJson(csv, options);
+    }
+
+    return this.pluginManager.executeWithPlugins(
+      'csvToJson',
+      csv,
+      options,
+      (input, opts) => {
+        if (this.options.enableFastPath && opts?.useFastPath !== false) {
+          return coreCsvToJson(input, { ...opts, useFastPath: true });
+        }
+
+        return coreCsvToJson(input, opts);
+      }
+    );
+  }
+
+  /**
+   * Convert CSV to JSON rows as async iterator with plugin hooks.
+   * @param {string} csv - CSV input
+   * @param {Object} options - Conversion options
+   * @returns {AsyncGenerator} Async iterator of rows
+   */
+  async *csvToJsonIterator(csv, options = {}) {
+    if (!this.options.enablePlugins) {
+      for await (const row of coreCsvToJsonIterator(csv, options)) {
+        yield row;
+      }
+      return;
+    }
+
+    const iterator = await this.pluginManager.executeWithPlugins(
+      'csvToJson',
+      csv,
+      options,
+      (input, opts) => {
+        if (this.options.enableFastPath && opts?.useFastPath !== false) {
+          return coreCsvToJsonIterator(input, { ...opts, useFastPath: true });
+        }
+
+        return coreCsvToJsonIterator(input, opts);
+      }
+    );
+
+    for await (const row of iterator) {
+      yield row;
+    }
+  }
+
+  /**
+   * Конвертирует JSON в CSV с поддержкой плагинов
+   * @param {Array} json - JSON данные
+   * @param {Object} options - Опции сериализации
+   * @returns {Promise<string>} CSV данные
+   */
+  async jsonToCsv(json, options = {}) {
+    if (!this.options.enablePlugins) {
+      return coreJsonToCsv(json, options);
+    }
+
+    return this.pluginManager.executeWithPlugins(
+      'jsonToCsv',
+      json,
+      options,
+      coreJsonToCsv
+    );
+  }
+
+  /**
+   * Сохраняет JSON как CSV файл
+   * @param {Array} data - JSON данные
+   * @param {string} filePath - Путь к файлу
+   * @param {Object} options - Опции
+   * @returns {Promise<void>}
+   */
+  async saveAsCsv(data, filePath, options = {}) {
+    if (!this.options.enablePlugins) {
+      return coreSaveAsCsv(data, filePath, options);
+    }
+
+    const csv = await this.jsonToCsv(data, options);
+    
+    // Используем плагины для сохранения
+    return this.pluginManager.executeWithPlugins(
+      'saveAsCsv',
+      { data: csv, filePath },
+      options,
+      async (input) => {
+        const fs = require('fs').promises;
+        await fs.writeFile(input.filePath, input.data, 'utf8');
+        return input.filePath;
+      }
+    );
+  }
+
+  /**
+   * Читает CSV файл и конвертирует в JSON
+   * @param {string} filePath - Путь к файлу
+   * @param {Object} options - Опции
+   * @returns {Promise<Array>} JSON данные
+   */
+  async readCsvAsJson(filePath, options = {}) {
+    if (!this.options.enablePlugins) {
+      return coreReadCsvAsJson(filePath, options);
+    }
+
+    // Читаем файл
+    const fs = require('fs').promises;
+    const csv = await fs.readFile(filePath, 'utf8');
+    
+    // Конвертируем с использованием плагинов
+    return this.csvToJson(csv, options);
+  }
+
+  /**
+   * Парсит NDJSON данные
+   * @param {string|ReadableStream} input - NDJSON данные
+   * @param {Object} options - Опции
+   * @returns {Promise<Array>} JSON данные
+   */
+  async parseNdjson(input, options = {}) {
+    if (typeof input === 'string') {
+      return NdjsonParser.fromNdjson(input, options);
+    }
+    
+    // Для потоков
+    const result = [];
+    for await (const obj of NdjsonParser.parseStream(input, options)) {
+      result.push(obj);
+    }
+    return result;
+  }
+
+  /**
+   * Конвертирует JSON в NDJSON
+   * @param {Array} data - JSON данные
+   * @param {Object} options - Опции
+   * @returns {string} NDJSON строка
+   */
+  toNdjson(data, options = {}) {
+    return NdjsonParser.toNdjson(data, options);
+  }
+
+  /**
+   * Регистрирует плагин
+   * @param {string} name - Имя плагина
+   * @param {Object} plugin - Конфигурация плагина
+   * @returns {JtcsvWithPlugins} this для chaining
+   */
+  use(name, plugin) {
+    this.pluginManager.use(name, plugin);
+    return this;
+  }
+
+  /**
+   * Возвращает менеджер плагинов
+   * @returns {PluginManager}
+   */
+  getPluginManager() {
+    return this.pluginManager;
+  }
+
+  /**
+   * Возвращает fast path engine
+   * @returns {FastPathEngine}
+   */
+  getFastPathEngine() {
+    return this.fastPathEngine;
+  }
+
+  /**
+   * Возвращает список плагинов
+   * @returns {Array}
+   */
+  listPlugins() {
+    return this.pluginManager.listPlugins();
+  }
+
+  /**
+   * Возвращает статистику
+   * @returns {Object}
+   */
+  getStats() {
+    return {
+      plugins: this.pluginManager.getStats(),
+      fastPath: this.fastPathEngine.getStats(),
+      options: this.options
+    };
+  }
+
+  /**
+   * Настраивает опции
+   * @param {Object} newOptions - Новые опции
+   */
+  configure(newOptions) {
+    this.options = { ...this.options, ...newOptions };
+    return this;
+  }
+
+  /**
+   * Создает экземпляр с настройками по умолчанию
+   * @param {Object} options - Опции
+   * @returns {JtcsvWithPlugins}
+   */
+  static create(options = {}) {
+    return new JtcsvWithPlugins(options);
+  }
+}
+
+// Экспортируем основной класс
+module.exports = JtcsvWithPlugins;
+
+// Экспортируем утилиты
+module.exports.PluginManager = PluginManager;
+module.exports.FastPathEngine = FastPathEngine;
+module.exports.NdjsonParser = NdjsonParser;
+
+// Экспортируем фабричный метод
+module.exports.create = JtcsvWithPlugins.create;
+
+
+

package/stream-csv-to-json.js

@@ -610,4 +610,4 @@ module.exports = {
 // For ES6 module compatibility
 if (typeof module !== 'undefined' && module.exports) {
   module.exports.default = createCsvToJsonStream;
-}
+}