jtcsv 2.1.1 → 2.1.5

package/plugins/express-middleware/README.md

@@ -1,306 +1,64 @@
 # @jtcsv/express-middleware
 
-Express middleware для автоматической конвертации CSV/JSON в HTTP запросах.
-
-## 📦 Установка
+Express middleware that converts CSV/JSON payloads and exposes the converted data on `req.converted`.
 
+## Install
 ```bash
 npm install @jtcsv/express-middleware express jtcsv
 ```
 
-## 🚀 Быстрый старт
-
+## Quick start
 ```javascript
 const express = require('express');
-const bodyParser = require('body-parser');
 const { middleware } = require('@jtcsv/express-middleware');
 
 const app = express();
-
-// Middleware для парсинга JSON и CSV
-app.use(bodyParser.json());
-app.use(bodyParser.text({ type: 'text/csv' }));
-
-// JTCSV middleware для автоматической конвертации
+app.use(express.json());
+app.use(express.text({ type: 'text/csv' }));
 app.use(middleware());
 
-// Роут, использующий автоматическую конвертацию
 app.post('/api/convert', (req, res) => {
-  // Конвертированные данные доступны в req.converted
-  res.json({
-    success: true,
-    data: req.converted.data,
-    format: req.converted.format,
-    stats: req.converted.stats
-  });
-});
-
-app.listen(3000, () => {
-  console.log('Server started on port 3000');
+  res.json(req.converted);
 });
 ```
 
-## 📖 Документация
-
-### Основное middleware
+## Options
+The middleware detects input/output format based on `Content-Type`, `Accept`, and `?format=csv`.
 
 ```javascript
 app.use(middleware({
-  maxSize: '50mb',           // Максимальный размер тела запроса
-  autoDetect: true,          // Автоматическое определение формата
-  delimiter: ',',            // Разделитель CSV
-  enableFastPath: true,      // Включить Fast-Path Engine
-  preventCsvInjection: true, // Защита от CSV инъекций
-  rfc4180Compliant: true     // Соответствие RFC 4180
-}));
-```
-
-### Специфичные роуты
-
-```javascript
-const { 
-  csvToJsonRoute, 
-  jsonToCsvRoute, 
-  uploadCsvRoute, 
-  healthCheck 
-} = require('@jtcsv/express-middleware');
-
-// Конвертация CSV в JSON
-app.post('/api/csv-to-json', csvToJsonRoute({
+  autoDetect: true,
   delimiter: ',',
-  parseNumbers: true,
-  parseBooleans: true
-}));
-
-// Конвертация JSON в CSV
-app.post('/api/json-to-csv', jsonToCsvRoute({
-  delimiter: ',',
-  includeHeaders: true,
-  preventCsvInjection: true
+  enableFastPath: true,
+  preventCsvInjection: true,
+  rfc4180Compliant: true,
+  conversionOptions: {
+    parseNumbers: true,
+    parseBooleans: true
+  }
 }));
-
-// Загрузка CSV файла (требуется multer)
-const multer = require('multer');
-const upload = multer({ dest: 'uploads/' });
-app.post('/api/upload-csv', upload.single('file'), uploadCsvRoute());
-
-// Health check
-app.get('/api/health', healthCheck());
-```
-
-## 🔧 Конфигурация
-
-### Опции middleware
-
-| Опция | Тип | По умолчанию | Описание |
-|-------|-----|--------------|----------|
-| `maxSize` | `string` | `'10mb'` | Максимальный размер тела запроса |
-| `autoDetect` | `boolean` | `true` | Автоматическое определение формата |
-| `delimiter` | `string` | `','` | Разделитель CSV |
-| `enableFastPath` | `boolean` | `true` | Включить Fast-Path Engine |
-| `preventCsvInjection` | `boolean` | `true` | Защита от CSV инъекций |
-| `rfc4180Compliant` | `boolean` | `true` | Соответствие RFC 4180 |
-| `conversionOptions` | `object` | `{}` | Дополнительные опции конвертации |
-
-### Формат ответа
-
-После обработки middleware, в объекте `req` появляется свойство `converted`:
-
-```javascript
-{
-  data: any,                    // Конвертированные данные
-  format: 'json' | 'csv',       // Формат выходных данных
-  inputFormat: 'json' | 'csv' | 'unknown', // Формат входных данных
-  outputFormat: 'json' | 'csv', // Формат выходных данных
-  stats: {                      // Статистика конвертации
-    inputSize: number,          // Размер входных данных (байты)
-    outputSize: number,         // Размер выходных данных (байты)
-    processingTime: number,     // Время обработки (мс)
-    conversion: string          // Тип конвертации (например: "json→csv")
-  },
-  options: object               // Использованные опции
-}
-```
-
-## 🌐 Примеры запросов
-
-### Конвертация JSON в CSV
-
-```bash
-curl -X POST http://localhost:3000/api/convert \
-  -H "Content-Type: application/json" \
-  -d '[{"name":"John","age":30},{"name":"Jane","age":25}]'
-```
-
-**Ответ:**
-```csv
-name,age
-John,30
-Jane,25
-```
-
-### Конвертация CSV в JSON
-
-```bash
-curl -X POST http://localhost:3000/api/convert \
-  -H "Content-Type: text/csv" \
-  -d 'name,age\nJohn,30\nJane,25'
-```
-
-**Ответ:**
-```json
-[
-  {"name":"John","age":30},
-  {"name":"Jane","age":25}
-]
-```
-
-### Специфичный формат вывода
-
-```bash
-# Запросить CSV даже если отправляем JSON
-curl -X POST http://localhost:3000/api/convert \
-  -H "Content-Type: application/json" \
-  -H "Accept: text/csv" \
-  -d '[{"name":"John","age":30}]'
-
-# Или через query параметр
-curl -X POST "http://localhost:3000/api/convert?format=csv" \
-  -H "Content-Type: application/json" \
-  -d '[{"name":"John","age":30}]'
-```
-
-## 🛡️ Безопасность
-
-### CSV Injection Protection
-
-Middleware автоматически защищает от CSV инъекций:
-
-```javascript
-// Входные данные с потенциальной инъекцией
-const dangerousData = [
-  { formula: '=1+1', command: '@echo hello' }
-];
-
-// Безопасный CSV
-const safeCsv = jsonToCsv(dangerousData, { 
-  preventCsvInjection: true 
-});
-// Результат: "'=1+1','@echo hello"
 ```
 
-### Валидация размера
+Note: body size limits are controlled by your body parser (for example `express.json({ limit: '10mb' })`).
 
+## Helpers
 ```javascript
-app.use(middleware({
-  maxSize: '10mb' // Ограничение размера запроса
-}));
-```
-
-## 📊 Мониторинг
-
-### Health Check
-
-```bash
-curl http://localhost:3000/api/health
-```
-
-**Ответ:**
-```json
-{
-  "service": "jtcsv-express-middleware",
-  "status": "healthy",
-  "version": "1.0.0",
-  "timestamp": "2026-01-23T10:30:00.000Z",
-  "features": {
-    "csvToJson": true,
-    "jsonToCsv": true,
-    "fastPathEngine": true,
-    "csvInjectionProtection": true,
-    "streaming": true
-  }
-}
+const {
+  csvToJsonRoute,
+  jsonToCsvRoute,
+  uploadCsvRoute,
+  healthCheck
+} = require('@jtcsv/express-middleware');
 ```
 
-### Статистика
-
-Каждый запрос включает статистику конвертации:
-
+## req.converted shape
 ```json
 {
-  "stats": {
-    "inputSize": 45,
-    "outputSize": 28,
-    "processingTime": 12,
-    "conversion": "json→csv"
-  }
+  "data": "...",
+  "format": "json",
+  "inputFormat": "csv",
+  "outputFormat": "json",
+  "stats": { "inputSize": 0, "outputSize": 0, "processingTime": 0, "conversion": "csv->json" },
+  "options": {}
 }
-```
-
-## 🔌 Интеграция
-
-### С TypeScript
-
-```typescript
-import { Request, Response } from 'express';
-import { middleware, ConvertedData } from '@jtcsv/express-middleware';
-
-app.use(middleware());
-
-app.post('/api/convert', (req: Request, res: Response) => {
-  const converted = req.converted as ConvertedData;
-  // TypeScript знает тип converted
-});
-```
-
-### С другими middleware
-
-```javascript
-const express = require('express');
-const cors = require('cors');
-const helmet = require('helmet');
-const rateLimit = require('express-rate-limit');
-const { middleware } = require('@jtcsv/express-middleware');
-
-const app = express();
-
-app.use(cors());
-app.use(helmet());
-app.use(rateLimit({ windowMs: 15 * 60 * 1000, max: 100 }));
-app.use(express.json());
-app.use(express.text({ type: 'text/csv' }));
-app.use(middleware());
-```
-
-## 🧪 Тестирование
-
-```bash
-# Запуск примера
-cd plugins/express-middleware
-node example.js
-
-# Тестовые запросы
-curl -X POST http://localhost:3000/api/convert \
-  -H "Content-Type: application/json" \
-  -d '[{"test":"data"}]'
-```
-
-## 📄 Лицензия
-
-MIT
-
-## 🤝 Вклад в развитие
-
-1. Форкните репозиторий
-2. Создайте ветку для вашей функции (`git checkout -b feature/amazing-feature`)
-3. Закоммитьте изменения (`git commit -m 'Add amazing feature'`)
-4. Запушьте в ветку (`git push origin feature/amazing-feature`)
-5. Откройте Pull Request
-
-## 📞 Поддержка
-
-- [Issues](https://github.com/Linol-Hamelton/jtcsv/issues)
-- [Discussions](https://github.com/Linol-Hamelton/jtcsv/discussions)
-- [Documentation](https://github.com/Linol-Hamelton/jtcsv#readme)
-
-
+```

package/plugins/hono/README.md

@@ -0,0 +1,28 @@
+# @jtcsv/hono
+
+Minimal helpers for Hono routes.
+
+## Install
+```bash
+npm install @jtcsv/hono jtcsv
+```
+
+## Usage
+```javascript
+import { Hono } from 'hono';
+import { csvMiddleware, createCsvResponse } from '@jtcsv/hono';
+
+const app = new Hono();
+
+app.use('/upload', csvMiddleware());
+app.post('/upload', (c) => c.json({ rows: c.get('csv') }));
+
+app.get('/export', (c) => {
+  const { csv, headers } = createCsvResponse([{ id: 1 }], 'export.csv');
+  return c.text(csv, 200, headers);
+});
+```
+
+## Exports
+- csvMiddleware
+- createCsvResponse

package/plugins/hono/index.d.ts

@@ -0,0 +1,12 @@
+import type { CsvToJsonOptions, JsonToCsvOptions } from 'jtcsv';
+import type { Context } from 'hono';
+
+export function csvMiddleware(
+  options?: CsvToJsonOptions
+): (c: Context, next: () => Promise<void>) => Promise<void>;
+
+export function createCsvResponse(
+  data: unknown[] | Record<string, unknown>,
+  filename?: string,
+  options?: JsonToCsvOptions
+): { csv: string; headers: Record<string, string> };

package/plugins/hono/index.js

@@ -0,0 +1,36 @@
+const jtcsv = require('jtcsv');
+
+function normalizeFilename(filename) {
+  if (!filename || typeof filename !== 'string') {
+    return 'export.csv';
+  }
+  return filename.includes('.') ? filename : `${filename}.csv`;
+}
+
+function csvMiddleware(options = {}) {
+  return async (c, next) => {
+    const csvText = await c.req.text();
+    const rows = jtcsv.csvToJson(csvText, options);
+    c.set('csv', rows);
+    await next();
+  };
+}
+
+function createCsvResponse(data, filename = 'export.csv', options = {}) {
+  const safeName = normalizeFilename(filename);
+  const rows = Array.isArray(data) ? data : [data];
+  const csv = jtcsv.jsonToCsv(rows, options);
+
+  return {
+    csv,
+    headers: {
+      'Content-Type': 'text/csv; charset=utf-8',
+      'Content-Disposition': `attachment; filename="${safeName}"`
+    }
+  };
+}
+
+module.exports = {
+  csvMiddleware,
+  createCsvResponse
+};

package/plugins/hono/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@jtcsv/hono",
+  "version": "1.0.0",
+  "description": "Hono middleware for JTCSV",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "keywords": [
+    "hono",
+    "csv",
+    "json",
+    "converter",
+    "jtcsv",
+    "middleware"
+  ],
+  "author": "Ruslan Fomenko",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Linol-Hamelton/jtcsv.git",
+    "directory": "plugins/hono"
+  },
+  "bugs": {
+    "url": "https://github.com/Linol-Hamelton/jtcsv/issues"
+  },
+  "homepage": "https://github.com/Linol-Hamelton/jtcsv/tree/main/plugins/hono#readme",
+  "peerDependencies": {
+    "hono": "^4.0.0",
+    "jtcsv": "^2.1.3"
+  },
+  "files": [
+    "index.js",
+    "index.d.ts",
+    "README.md"
+  ]
+}

package/plugins/nestjs/README.md

@@ -0,0 +1,35 @@
+# @jtcsv/nestjs
+
+NestJS interceptors for parsing CSV payloads and returning CSV responses.
+
+## Install
+```bash
+npm install @jtcsv/nestjs jtcsv
+```
+
+## Usage
+```typescript
+import { Controller, Post, Body, UseInterceptors } from '@nestjs/common';
+import { CsvParserInterceptor, CsvDownloadDecorator } from '@jtcsv/nestjs';
+
+@Controller('data')
+export class DataController {
+  @Post('upload')
+  @CsvParserInterceptor({ delimiter: ',' })
+  upload(@Body() body: any[]) {
+    return { rows: body };
+  }
+
+  @Post('export')
+  @CsvDownloadDecorator({ filename: 'export.csv' })
+  exportCsv() {
+    return [{ id: 1, name: 'Jane' }];
+  }
+}
+```
+
+## Exports
+- CsvParserInterceptor
+- CsvDownloadDecorator
+- createCsvParserInterceptor
+- createCsvDownloadInterceptor

package/plugins/nestjs/index.d.ts

@@ -0,0 +1,25 @@
+import type { Type } from '@nestjs/common';
+import type { NestInterceptor } from '@nestjs/common';
+import type { CsvToJsonOptions, JsonToCsvOptions } from 'jtcsv';
+
+export interface CsvParserOptions extends CsvToJsonOptions {}
+
+export interface CsvDownloadOptions extends JsonToCsvOptions {
+  filename?: string;
+}
+
+export function createCsvParserInterceptor(
+  options?: CsvParserOptions
+): Type<NestInterceptor>;
+
+export function createCsvDownloadInterceptor(
+  options?: CsvDownloadOptions
+): Type<NestInterceptor>;
+
+export function CsvParserInterceptor(
+  options?: CsvParserOptions
+): MethodDecorator & ClassDecorator;
+
+export function CsvDownloadDecorator(
+  options?: CsvDownloadOptions
+): MethodDecorator & ClassDecorator;

package/plugins/nestjs/index.js

@@ -0,0 +1,77 @@
+const { Injectable, UseInterceptors } = require('@nestjs/common');
+const { map } = require('rxjs/operators');
+const jtcsv = require('jtcsv');
+
+function normalizeFilename(filename) {
+  if (!filename || typeof filename !== 'string') {
+    return 'export.csv';
+  }
+  return filename.includes('.') ? filename : `${filename}.csv`;
+}
+
+function createCsvParserInterceptor(options = {}) {
+  class CsvParserInterceptorImpl {
+    intercept(context, next) {
+      const req = context.switchToHttp().getRequest();
+      const body = req && req.body;
+
+      if (typeof body === 'string' || Buffer.isBuffer(body)) {
+        const csv = Buffer.isBuffer(body) ? body.toString('utf8') : body;
+        req.body = jtcsv.csvToJson(csv, options);
+      }
+
+      return next.handle();
+    }
+  }
+
+  Injectable()(CsvParserInterceptorImpl);
+  return CsvParserInterceptorImpl;
+}
+
+function createCsvDownloadInterceptor(options = {}) {
+  class CsvDownloadInterceptorImpl {
+    intercept(context, next) {
+      const res = context.switchToHttp().getResponse();
+      const filename = normalizeFilename(options.filename);
+      const csvOptions = { ...options };
+      delete csvOptions.filename;
+
+      return next.handle().pipe(
+        map(data => {
+          const rows = Array.isArray(data) ? data : [data];
+          const csv = jtcsv.jsonToCsv(rows, csvOptions);
+
+          if (res && typeof res.setHeader === 'function') {
+            res.setHeader('Content-Type', 'text/csv; charset=utf-8');
+            res.setHeader(
+              'Content-Disposition',
+              `attachment; filename="${filename}"`
+            );
+          }
+
+          return csv;
+        })
+      );
+    }
+  }
+
+  Injectable()(CsvDownloadInterceptorImpl);
+  return CsvDownloadInterceptorImpl;
+}
+
+function CsvParserInterceptor(options = {}) {
+  const Interceptor = createCsvParserInterceptor(options);
+  return UseInterceptors(new Interceptor());
+}
+
+function CsvDownloadDecorator(options = {}) {
+  const Interceptor = createCsvDownloadInterceptor(options);
+  return UseInterceptors(new Interceptor());
+}
+
+module.exports = {
+  CsvParserInterceptor,
+  CsvDownloadDecorator,
+  createCsvParserInterceptor,
+  createCsvDownloadInterceptor
+};

package/plugins/nestjs/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@jtcsv/nestjs",
+  "version": "1.0.0",
+  "description": "NestJS interceptors and decorators for JTCSV",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "keywords": [
+    "nestjs",
+    "csv",
+    "json",
+    "converter",
+    "jtcsv",
+    "interceptor",
+    "decorator"
+  ],
+  "author": "Ruslan Fomenko",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Linol-Hamelton/jtcsv.git",
+    "directory": "plugins/nestjs"
+  },
+  "bugs": {
+    "url": "https://github.com/Linol-Hamelton/jtcsv/issues"
+  },
+  "homepage": "https://github.com/Linol-Hamelton/jtcsv/tree/main/plugins/nestjs#readme",
+  "peerDependencies": {
+    "@nestjs/common": "^9.0.0 || ^10.0.0",
+    "jtcsv": "^2.1.3",
+    "rxjs": "^7.0.0"
+  },
+  "files": [
+    "index.js",
+    "index.d.ts",
+    "README.md"
+  ]
+}