jtcsv 2.2.7 → 3.0.0

package/plugins/nextjs-api/route.ts

@@ -0,0 +1,370 @@
+/**
+ * Next.js API Route для JTCSV
+ * Готовый API endpoint для конвертации CSV/JSON в Next.js приложениях
+ * 
+ * @version 1.0.0
+ * @date 2026-01-23
+ * 
+ * @usage
+ * 1. Скопируйте этот файл в pages/api/convert.js
+ * 2. Или импортируйте функции в существующие API routes
+ */
+
+import { csvToJson, jsonToCsv } from 'jtcsv';
+
+/**
+ * Конфигурация Next.js API route
+ */
+export const config = {
+  api: {
+    bodyParser: {
+      sizeLimit: '50mb',  // Максимальный размер тела запроса
+      
+      // Кастомный парсер для определения формата
+      parse: (req) => {
+        const contentType = req.headers['content-type'] || '';
+        
+        if (contentType.includes('application/json')) {
+          return JSON.parse(req.body);
+        } else if (contentType.includes('text/csv') || contentType.includes('text/plain')) {
+          return req.body;
+        }
+        
+        // Пытаемся определить автоматически
+        try {
+          return JSON.parse(req.body);
+        } catch {
+          return req.body;
+        }
+      }
+    }
+  }
+};
+
+/**
+ * Основной обработчик API route
+ * 
+ * @param {import('next').NextApiRequest} req - Next.js request object
+ * @param {import('next').NextApiResponse} res - Next.js response object
+ * 
+ * @example
+ * // Пример запроса:
+ * // POST /api/convert
+ * // Content-Type: application/json
+ * // Body: [{ "name": "John", "age": 30 }]
+ * 
+ * @example
+ * // Пример запроса:
+ * // POST /api/convert?format=csv
+ * // Content-Type: text/csv
+ * // Body: name,age\nJohn,30\nJane,25
+ */
+export default async function handler(req, res) {
+  // Поддерживаем только POST запросы
+  if (req.method !== 'POST') {
+    return res.status(405).json({
+      success: false,
+      error: 'Method not allowed',
+      allowed: ['POST']
+    });
+  }
+
+  const startTime = Date.now();
+  const contentType = req.headers['content-type'] || '';
+  const acceptHeader = req.headers['accept'] || 'application/json';
+  
+  try {
+    const { 
+      format, 
+      delimiter = ',',
+      includeHeaders = 'true',
+      parseNumbers = 'true',
+      parseBooleans = 'true',
+      useFastPath = 'true',
+      preventCsvInjection = 'true'
+    } = req.query;
+
+    // Определяем желаемый формат вывода
+    const outputFormat = format || (acceptHeader.includes('text/csv') ? 'csv' : 'json');
+    
+    // Определяем формат входных данных
+    let inputFormat = 'unknown';
+    
+    if (contentType.includes('application/json') || Array.isArray(req.body)) {
+      inputFormat = 'json';
+    } else if (contentType.includes('text/csv') || 
+              contentType.includes('text/plain') ||
+              (typeof req.body === 'string' && req.body.includes(','))) {
+      inputFormat = 'csv';
+    }
+
+    if (inputFormat === 'unknown') {
+      return res.status(400).json({
+        success: false,
+        error: 'Unable to determine input format',
+        code: 'UNKNOWN_FORMAT',
+        suggestions: [
+          'Set Content-Type header to application/json or text/csv',
+          'Or send JSON array/object or CSV string'
+        ]
+      });
+    }
+
+    // Опции конвертации
+    const options = {
+      delimiter,
+      includeHeaders: includeHeaders === 'true',
+      parseNumbers: parseNumbers === 'true',
+      parseBooleans: parseBooleans === 'true',
+      useFastPath: useFastPath === 'true',
+      preventCsvInjection: preventCsvInjection === 'true',
+      rfc4180Compliant: true
+    };
+
+    let result;
+    const stats = {
+      inputSize: 0,
+      outputSize: 0,
+      processingTime: 0,
+      conversion: `${inputFormat}→${outputFormat}`
+    };
+
+    // Выполняем конвертацию
+    if (inputFormat === 'json' && outputFormat === 'csv') {
+      const jsonData = Array.isArray(req.body) ? req.body : [req.body];
+      stats.inputSize = Buffer.byteLength(JSON.stringify(jsonData));
+      
+      result = await jsonToCsv(jsonData, options);
+      stats.outputSize = Buffer.byteLength(result);
+      
+      res.setHeader('Content-Type', 'text/csv; charset=utf-8');
+      res.setHeader('Content-Disposition', 'attachment; filename="data.csv"');
+      
+    } else if (inputFormat === 'csv' && outputFormat === 'json') {
+      const csvData = typeof req.body === 'string' ? req.body : String(req.body);
+      stats.inputSize = Buffer.byteLength(csvData);
+      
+      result = await csvToJson(csvData, options);
+      stats.outputSize = Buffer.byteLength(JSON.stringify(result));
+      
+      res.setHeader('Content-Type', 'application/json; charset=utf-8');
+      
+    } else {
+      // Нет необходимости в конвертации
+      result = req.body;
+      stats.conversion = 'none';
+      stats.inputSize = Buffer.byteLength(JSON.stringify(result));
+      stats.outputSize = stats.inputSize;
+    }
+
+    stats.processingTime = Date.now() - startTime;
+
+    // Формируем ответ
+    const response = {
+      success: true,
+      data: result,
+      format: outputFormat,
+      inputFormat,
+      stats,
+      options: {
+        ...options,
+        delimiter
+      }
+    };
+
+    // Если запрашивали CSV, отправляем как plain text
+    if (outputFormat === 'csv') {
+      return res.status(200).send(result);
+    }
+
+    return res.status(200).json(response);
+
+  } catch (error) {
+    console.error('Conversion error:', error);
+    
+    const errorResponse = {
+      success: false,
+      error: error.message,
+      code: error.code || 'CONVERSION_ERROR',
+      timestamp: new Date().toISOString()
+    };
+
+    // Добавляем дополнительную информацию для отладки в development
+    if (process.env.NODE_ENV === 'development') {
+      errorResponse.stack = error.stack;
+      errorResponse.details = {
+        contentType: req.headers['content-type'],
+        contentLength: req.headers['content-length'],
+        method: req.method,
+        url: req.url,
+        query: req.query
+      };
+    }
+
+    return res.status(400).json(errorResponse);
+  }
+}
+
+/**
+ * Специализированный обработчик для CSV → JSON
+ */
+export async function csvToJsonHandler(req, res) {
+  if (req.method !== 'POST') {
+    return res.status(405).json({
+      success: false,
+      error: 'Method not allowed',
+      allowed: ['POST']
+    });
+  }
+
+  const startTime = Date.now();
+  
+  try {
+    const csvData = req.body;
+    
+    if (!csvData || (typeof csvData !== 'string' && !Buffer.isBuffer(csvData))) {
+      return res.status(400).json({
+        success: false,
+        error: 'CSV data is required'
+      });
+    }
+
+    const {
+      delimiter = ',',
+      parseNumbers = 'true',
+      parseBooleans = 'true',
+      useFastPath = 'true'
+    } = req.query;
+
+    const result = await csvToJson(csvData, {
+      delimiter,
+      parseNumbers: parseNumbers === 'true',
+      parseBooleans: parseBooleans === 'true',
+      useFastPath: useFastPath === 'true',
+      preventCsvInjection: true,
+      rfc4180Compliant: true
+    });
+
+    return res.status(200).json({
+      success: true,
+      data: result,
+      stats: {
+        rows: result.length,
+        processingTime: Date.now() - startTime
+      }
+    });
+
+  } catch (error) {
+    return res.status(400).json({
+      success: false,
+      error: error.message
+    });
+  }
+}
+
+/**
+ * Специализированный обработчик для JSON → CSV
+ */
+export async function jsonToCsvHandler(req, res) {
+  if (req.method !== 'POST') {
+    return res.status(405).json({
+      success: false,
+      error: 'Method not allowed',
+      allowed: ['POST']
+    });
+  }
+
+  const startTime = Date.now();
+  
+  try {
+    const jsonData = req.body;
+    
+    if (!jsonData || (typeof jsonData !== 'object' && typeof jsonData !== 'string')) {
+      return res.status(400).json({
+        success: false,
+        error: 'JSON data is required'
+      });
+    }
+
+    const {
+      delimiter = ',',
+      includeHeaders = 'true',
+      useFastPath = 'true'
+    } = req.query;
+
+    const data = typeof jsonData === 'string' ? JSON.parse(jsonData) : jsonData;
+    const result = await jsonToCsv(data, {
+      delimiter,
+      includeHeaders: includeHeaders === 'true',
+      useFastPath: useFastPath === 'true',
+      preventCsvInjection: true,
+      rfc4180Compliant: true
+    });
+
+    res.setHeader('Content-Type', 'text/csv; charset=utf-8');
+    res.setHeader('Content-Disposition', 'attachment; filename="data.csv"');
+    
+    return res.status(200).send(result);
+
+  } catch (error) {
+    return res.status(400).json({
+      success: false,
+      error: error.message
+    });
+  }
+}
+
+/**
+ * Health check endpoint
+ */
+export async function healthCheckHandler(req, res) {
+  if (req.method !== 'GET') {
+    return res.status(405).json({
+      success: false,
+      error: 'Method not allowed',
+      allowed: ['GET']
+    });
+  }
+
+  return res.status(200).json({
+    service: 'jtcsv-nextjs-api',
+    status: 'healthy',
+    version: '1.0.0',
+    timestamp: new Date().toISOString(),
+    features: {
+      csvToJson: true,
+      jsonToCsv: true,
+      fastPathEngine: true,
+      csvInjectionProtection: true,
+      streaming: true,
+      ndjson: true
+    }
+  });
+}
+
+/**
+ * Утилита для создания кастомных API endpoints
+ */
+export function createJtcsvApiEndpoint(options = {}) {
+  const {
+    route = '/api/convert',
+    allowedMethods = ['POST'],
+    defaultFormat = 'json',
+    ...defaultOptions
+  } = options;
+
+  return async function customHandler(req, res) {
+    // Проверяем разрешенные методы
+    if (!allowedMethods.includes(req.method)) {
+      return res.status(405).json({
+        success: false,
+        error: `Method ${req.method} not allowed`,
+        allowed: allowedMethods
+      });
+    }
+
+    // Здесь можно добавить кастомную логику
+    // Пока просто используем основной handler
+    return handler(req, res);
+  };
+}

package/plugins/nuxt/index.ts

@@ -0,0 +1,94 @@
+/**
+ * Nuxt plugin for jtcsv
+ * Provides jtcsv integration for Nuxt applications
+ * @module plugins/nuxt
+ */
+
+import type { CsvToJsonOptions, JsonToCsvOptions } from '../../src/types';
+
+/**
+ * Nuxt plugin options
+ */
+export interface NuxtPluginOptions {
+  /** Whether to enable async functions (default: true) */
+  async?: boolean;
+  /** Whether to enable worker support (default: false) */
+  workers?: boolean;
+}
+
+/**
+ * Nuxt plugin implementation
+ * This is a simplified version that works with Nuxt 3
+ */
+export default defineNuxtPlugin((nuxtApp: any, options: NuxtPluginOptions = {}) => {
+  const { async = true, workers = false } = options;
+  
+  // Import jtcsv functions
+  const jtcsv = {
+    // Core functions
+    csvToJson: (csv: string, opts?: CsvToJsonOptions) => {
+      // This would be replaced with actual import in runtime
+      return require('jtcsv').csvToJson(csv, opts);
+    },
+    jsonToCsv: (data: any, opts?: JsonToCsvOptions) => {
+      return require('jtcsv').jsonToCsv(data, opts);
+    },
+    
+    // Async versions if enabled
+    ...(async ? {
+      csvToJsonAsync: async (csv: string, opts?: CsvToJsonOptions) => {
+        const { csvToJson } = require('jtcsv');
+        return csvToJson(csv, opts);
+      },
+      jsonToCsvAsync: async (data: any, opts?: JsonToCsvOptions) => {
+        const { jsonToCsv } = require('jtcsv');
+        return jsonToCsv(data, opts);
+      }
+    } : {}),
+    
+    // Worker support if enabled
+    ...(workers ? {
+      createWorkerPool: (size?: number) => {
+        const { WorkerPool } = require('../../src/workers/worker-pool');
+        return new WorkerPool(size);
+      }
+    } : {})
+  };
+
+  // Provide jtcsv to Nuxt app
+  nuxtApp.provide('jtcsv', jtcsv);
+  nuxtApp.provide('useJtcsv', () => jtcsv);
+});
+
+/**
+ * Nuxt composable for using jtcsv
+ */
+export function useJtcsv() {
+  const nuxtApp = useNuxtApp();
+  return nuxtApp.$jtcsv;
+}
+
+/**
+ * Nuxt composable for async jtcsv operations
+ */
+export function useJtcsvAsync() {
+  const nuxtApp = useNuxtApp();
+  const jtcsv = nuxtApp.$jtcsv as any;
+  
+  return {
+    ...jtcsv,
+    // Ensure async methods are available
+    csvToJson: (jtcsv.csvToJsonAsync || jtcsv.csvToJson) as (csv: string, opts?: CsvToJsonOptions) => any,
+    jsonToCsv: (jtcsv.jsonToCsvAsync || jtcsv.jsonToCsv) as (data: any, opts?: JsonToCsvOptions) => string,
+  };
+}
+
+// Helper functions for Nuxt module compatibility
+function defineNuxtPlugin(fn: any) {
+  return fn;
+}
+
+function useNuxtApp() {
+  // This would be provided by Nuxt runtime
+  return { $jtcsv: {} as any };
+}

package/plugins/nuxt/runtime/composables/useJtcsv.ts

@@ -0,0 +1,100 @@
+/**
+ * Nuxt composable for jtcsv
+ * Provides reactive access to jtcsv functions
+ */
+
+import type { CsvToJsonOptions, JsonToCsvOptions } from '../../../../src/types';
+
+/**
+ * Jtcsv composable interface
+ */
+export interface UseJtcsvReturn {
+  // Core functions
+  csvToJson: (csv: string, options?: CsvToJsonOptions) => any[];
+  jsonToCsv: (data: any, options?: JsonToCsvOptions) => string;
+  
+  // Async versions
+  csvToJsonAsync: (csv: string, options?: CsvToJsonOptions) => Promise<any[]>;
+  jsonToCsvAsync: (data: any, options?: JsonToCsvOptions) => Promise<string>;
+  
+  // Utility functions
+  saveAsCsv: (data: any, filename: string, options?: JsonToCsvOptions) => void;
+  saveAsCsvAsync: (data: any, filename: string, options?: JsonToCsvOptions) => Promise<void>;
+  
+  // Worker support
+  createWorkerPool?: (size?: number) => any;
+}
+
+/**
+ * Use jtcsv composable
+ * This is a simplified version that works without Nuxt dependencies
+ */
+export function useJtcsv(): UseJtcsvReturn {
+  // In a real Nuxt app, this would get jtcsv from the Nuxt context
+  // For now, we'll create a mock implementation
+  
+  const mockJtcsv = {
+    csvToJson: (csv: string, options?: CsvToJsonOptions) => {
+      console.log('csvToJson called with:', { csv: csv.substring(0, 50) + '...', options });
+      return [];
+    },
+    
+    jsonToCsv: (data: any, options?: JsonToCsvOptions) => {
+      console.log('jsonToCsv called with:', { data, options });
+      return '';
+    },
+    
+    csvToJsonAsync: async (csv: string, options?: CsvToJsonOptions) => {
+      console.log('csvToJsonAsync called with:', { csv: csv.substring(0, 50) + '...', options });
+      return [];
+    },
+    
+    jsonToCsvAsync: async (data: any, options?: JsonToCsvOptions) => {
+      console.log('jsonToCsvAsync called with:', { data, options });
+      return '';
+    },
+    
+    saveAsCsv: (data: any, filename: string, options?: JsonToCsvOptions) => {
+      console.log('saveAsCsv called with:', { data, filename, options });
+    },
+    
+    saveAsCsvAsync: async (data: any, filename: string, options?: JsonToCsvOptions) => {
+      console.log('saveAsCsvAsync called with:', { data, filename, options });
+    },
+    
+    createWorkerPool: (size?: number) => {
+      console.log('createWorkerPool called with size:', size);
+      return {
+        size: size || 4,
+        process: async (data: any) => data
+      };
+    }
+  };
+  
+  return mockJtcsv;
+}
+
+/**
+ * Async version of useJtcsv with better error handling
+ */
+export function useJtcsvAsync(): Omit<UseJtcsvReturn, 'csvToJson' | 'jsonToCsv' | 'saveAsCsv'> & {
+  csvToJson: (csv: string, options?: CsvToJsonOptions) => Promise<any[]>;
+  jsonToCsv: (data: any, options?: JsonToCsvOptions) => Promise<string>;
+  saveAsCsv: (data: any, filename: string, options?: JsonToCsvOptions) => Promise<void>;
+} {
+  const jtcsv = useJtcsv();
+  
+  return {
+    ...jtcsv,
+    // Ensure all methods are async
+    csvToJson: async (csv: string, options?: CsvToJsonOptions) => {
+      return await jtcsv.csvToJsonAsync(csv, options);
+    },
+    jsonToCsv: async (data: any, options?: JsonToCsvOptions) => {
+      return await jtcsv.jsonToCsvAsync(data, options);
+    },
+    saveAsCsv: async (data: any, filename: string, options?: JsonToCsvOptions) => {
+      await jtcsv.saveAsCsvAsync(data, filename, options);
+    }
+  } as any;
+}

package/plugins/nuxt/runtime/plugin.ts

@@ -0,0 +1,71 @@
+/**
+ * Nuxt runtime plugin for jtcsv
+ * Provides jtcsv integration at runtime
+ */
+
+import { defineNuxtPlugin } from '#app';
+import * as jtcsv from 'jtcsv';
+import type { CsvToJsonOptions, JsonToCsvOptions } from '../../../src/types';
+
+/**
+ * Nuxt plugin options
+ */
+interface PluginOptions {
+  async?: boolean;
+  workers?: boolean;
+}
+
+/**
+ * Enhanced jtcsv with async support
+ */
+function enhanceJtcsv(baseJtcsv: typeof jtcsv, options: PluginOptions = {}) {
+  const { async = true, workers = false } = options;
+  
+  const enhanced = {
+    ...baseJtcsv,
+    
+    // Async versions
+    ...(async ? {
+      csvToJsonAsync: async (csv: string, options?: CsvToJsonOptions) => {
+        return baseJtcsv.csvToJson(csv, options);
+      },
+      jsonToCsvAsync: async (data: any, options?: JsonToCsvOptions) => {
+        return baseJtcsv.jsonToCsv(data, options);
+      },
+      saveAsCsvAsync: async (data: any, filepath: string, options?: JsonToCsvOptions) => {
+        return baseJtcsv.saveAsCsv(data, filepath, options);
+      },
+      saveAsJsonAsync: async (data: any, filepath: string, options?: any) => {
+        return baseJtcsv.saveAsJson(data, filepath, options);
+      }
+    } : {}),
+    
+    // Worker support
+    ...(workers ? {
+      createWorkerPool: (size?: number) => {
+        // This would import from the worker pool module
+        // For now, return a mock
+        return {
+          size,
+          process: async (data: any) => data
+        };
+      }
+    } : {})
+  };
+  
+  return enhanced;
+}
+
+export default defineNuxtPlugin((nuxtApp, inject) => {
+  // Get plugin options from runtime config
+  const config = nuxtApp.$config?.public?.jtcsv || {};
+  
+  // Enhance jtcsv with async support based on config
+  const enhancedJtcsv = enhanceJtcsv(jtcsv, config);
+  
+  // Provide to Nuxt app
+  nuxtApp.provide('jtcsv', enhancedJtcsv);
+  
+  // Also inject for backward compatibility
+  inject('jtcsv', enhancedJtcsv);
+});

package/plugins/remix/index.js

@@ -13,7 +13,7 @@ async function extractCsvText(formData, fieldName) {
     if (value && typeof value.text === 'function') {
       return await value.text();
     }
-    if (value != null) {
+    if (value !== null) {
       return String(value);
     }
   }