backend-bulk-import
/backend-bulk-import
Projektuje import plików CSV i Excel z walidacją wierszy, raportem błędów, podglądem, przetwarzaniem wsadowym i wycofywaniem.
- Autor
- j4flmao ↗
- Repozytorium
- agent-skills ↗
- Licencja
- MIT
- Ostatnia zmiana repozytorium
- 10.11.2026
Ocena i bezpieczeństwo
- Pliki w paczce
- 9
- Skrypty
- 0
- Komentarze HTML
- 0
- Adresy URL w SKILL.md
- 0
Brak sygnałów. Repozytorium zmienione 10.11.2026, bez odwołań do wycofanych modeli i API.
MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.
Co robi i kiedy
Projektuje import plików CSV i Excel z walidacją wierszy, raportem błędów, podglądem, przetwarzaniem wsadowym i wycofywaniem.
Wyzwalacze z opisu
Oryginalny opis (EN)
Use this skill when the user says 'bulk import', 'CSV upload', 'Excel import', 'import pipeline', 'import validation', 'upsert from file', 'import progress', 'import error report'. Designs file-based bulk import: upload handling, streaming CSV/Excel parsing, row validation with error reports, preview/confirm flow, batched background processing with progress, deduplication and rollback. Do NOT use for: real-time or streaming ingestion (backend-data-streaming), warehouse ETL (data etl skills), report/export generation (backend-report-generation).
Jak działa
- Purpose
- Architecture Decision Trees
- Agent Protocol
- Workflow
- Implementation Patterns
- Production Considerations
- Anti-Patterns
- Security Considerations
- Testing Strategies
- Rules
Podgląd SKILL.md
---
name: backend-bulk-import
description: >
Use this skill when the user says 'bulk import', 'CSV upload', 'Excel import', 'import pipeline', 'import validation', 'upsert from file', 'import progress', 'import error report'. Designs file-based bulk import: upload handling, streaming CSV/Excel parsing, row validation with error reports, preview/confirm flow, batched background processing with progress, deduplication and rollback. Do NOT use for: real-time or streaming ingestion (backend-data-streaming), warehouse ETL (data etl skills), report/export generation (backend-report-generation).
version: "1.1.0"
author: "j4flmao"
license: "MIT"
compatibility:
claude-code: true
cursor: true
codex: true
windsurf: true
tags: [backend, data, phase-10]
---
# Bulk Import Skill
## Purpose
Design robust bulk import systems that handle large CSV/Excel files with validation, progress tracking, error recovery, and audit trails.
## Architecture Decision Trees
### Import Mode Selection
| Criterion | Insert | Upsert | Replace |
|-----------|--------|--------|---------|
| Duplicate handling | Fails on conflict | Updates existing | Truncate all first |
| Performance | Fastest | Moderate (check per row) | Fast (truncate + insert) |
| Idempotent | No | Yes (by dedup field) | No (destructive) |
| Risk level | Low | Low | High (data loss) |
| Audit trail | All inserts | Updates logged | Lost on truncate |
| Rollback complexity | Simple (transaction) | Moderate | Complex (needs backup) |
| Use case | New data ingestion | Sync with external system | Full reimport/replace |
Decision: Upsert for production syncs. Insert for immutable audit data. Replace only with pre-import backup.
### Parsing Strategy
| Criterion | Streaming (CSV) | Full load (Excel) | Hybrid (chunked) |
|-----------|----------------|-------------------|------------------|
| Memory | O(1) rows in memory | Full file in memory | O(batch size) |
| Max file size | Unlimited | ~100MB practical | ~500MB |
| Row validation | Per-batch | All before processing | Per-batch |
| Error collection | Per-batch | Full before process | Per-batch |
| Progress tracking | Yes (real-time) | No (must parse first) | Yes (per chunk) |
| Random access | No | Yes | No |
Decision: Streaming for CSV. Chunked for Excel > 10MB. Full load for Excel < 10MB.
### Deduplication Strategy
| Approach | Precision | Performance | Implementation |
|----------|-----------|-------------|----------------|
| DB unique constraint | Exact | Fast (index) | Schema definition |
| Pre-check with SELECT | Exact | Slow on large tables | Query existing values |
| Row content hash (SHA-256 of normalized row, stored in a unique column) | Exact on normalized content | Fast (index) | Hash + unique index |
| External dedup (Redis set) | Exact within the set's lifetime | Very fast | `SADD` returns 0 for duplicates |
| Bloom filter (RedisBloom `BF.ADD`) | Probabilistic: false positives possible | Very fast, small memory | Only where wrongly skipping a few unique rows is acceptable |
Decision: DB unique constraint (with `ON CONFLICT`) for exact dedup. Bloom filters only as a pre-filter, never as the final decision for business data.
## Agent Protocol
### Trigger
User mentions bulk import, CSV upload, Excel import, data ingestion, batch processing, data migration, import pipeline, file upload processing, import validation, or ETL pipeline.
### Input Context
- Source file format (CSV, Excel, JSON)
- Expected file size and row count
- Data schema and validation rules
- Import mode (insert, upsert, replace)
- Deduplication strategy
- Error handling requirements
- Background processing needs
- Target system and database
### Output Artifact
SKILL.md adherence document plus implemented import pipeline, validation logic, progress tracking, error handling, and rollback mechanisms.
### Response Format
No preamble. No postamble. No explanations. No filler/hedging/transitions. Compress output — why use many token when few do trick.
### Completion Criteria
- [ ] File upload endpoint with size/type validation implemented
- [ ] CSV/Excel parser configured with header mapping and encoding detection
- [ ] Validation pipeline with row-level error collection operational
- [ ] Preview step (show sample + errors before confirm) implemented
- [ ] Batch processing with progress tracking and throttling
- [ ] Import template with downloadable sample file ready
- [ ] Deduplication logic implemented (configurable per field)
- [ ] Rollback mechanism for partial failures
- [ ] Import history and audit log stored
- [ ] Webhook notification on import completion
- [ ] Rate limiting on import endpoints
### Max Response Length
4096 tokens
## Workflow
1. **File Upload & Validation**: Accept upload with strict type/size checks.
```typescript
import multer from 'multer';
import { randomUUID } from 'node:crypto';
const ALLOWED_MIME = [
'text/csv',
'application/vnd.ms-excel',
'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
];
const MAX_SIZE = 50 * 1024 * 1024; // 50MB
// Disk (or object storage) instead of memory: the worker streams the file later.
const upload = multer({
storage: multer.diskStorage({
destination: process.env.IMPORT_DIR ?? '/var/app/imports',
filename: (_req, _file, cb) => cb(null, randomUUID()), // never trust client file names
}),
limits: { fileSize: MAX_SIZE },
fileFilter: (_req, file, cb) => {
// mimetype is client-supplied: treat as a hint and re-validate content when parsing.
if (!ALLOWED_MIME.includes(file.mimetype)) {
cb(new Error('Unsupported file type. Only CSV and Excel files are allowed.'));
return;
}
cb(null, true);
},
});
app.post('/api/imports/upload', upload.single('file'), async (req, res) => {
const importJob = await ImportJob.create({
userId: req.user.id,
fileName: req.file.originalname,
fileSize: req.file.size,
mimeType: req.file.mimetype,
filePath: req.file.path,
status: 'uploaded',
});
// Preview reads only the first rows; full validation runs in a background job.
const preview = await readPreview(req.file.path, req.file.mimetype, 5);
importJob.columnCount = preview.headers.length;
importJob.preview = preview.rows;
await importJob.save();
await validationQueue.add('validate', { importId: importJob.id });
res.status(202).json({ jobId: importJob.id, preview: importJob.preview });
});
```
2. **CSV Parsing with Streaming**: Handle large files without memory overflow.
```typescript
import { parse } from 'csv-parse';
import { createReadStream } from 'fs';
async function* streamCsvRows(filePath: string, batchSize = 500): AsyncGenerator<Record<string, string>[]> {
const parser = createReadStream(filePath).pipe(parse({
columns: true,
skip_empty_lines: true,
trim: true,
relax_column_count: true,
encoding: 'utf-8',
bom: true,
}));
let batch: Record<string, string>[] = [];
for await (const record of parser) {
batch.push(record);
if (batch.length >= batchSize) {
yield batch;
batch = [];
}
}
if (batch.length > 0) yield batch;
}
```
3. **Validation Pipeline**: Row-level validation with comprehensive error collection.
```typescript
class ImportValidator {
private validators: Map<string, FieldValidator[]> = new Map();
register(field: string, ...validators: FieldValidator[]): void {
this.validators.set(field, [...(this.validators.get(field) || []), ...validators]);
}
async validate(rows: Record<string, unknown>[]): Promise<ValidationResult> {
const errors: ValidationError[] = [];
const validRows: Record<string, unknown>[] = [];
for (let i = 0; i < rows.length; i++) {
const row = rows[i];
const rowErrors: ValidationError[] = [];
for (const [field, fieldValidators] of this.validators.entries()) {
const value = row[field];
for (const validator of fieldValidators) {
const error = await validator.validate(field, value, row);
if (error) rowErrors.push({ ...error, row: i + 1 });
}
}
if (rowErrors.length > 0) {
errors.push(...rowErrors);
} else {
validRows.push(row);
}
}
return { validRows, errors, totalRows: rows.length, validCount: validRows.length, errorCount: errors.length };
}
}
// Usage
const validator = new ImportValidator();
validator.register('email', { validate: async (field, value) => {
if (!value || typeof value !== 'string') return { field, message: 'Email is required' };
if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value)) return { field, message: 'Invalid email format' };
return null;
}});
validator.register('age', { validate: async (field, value) => {
const num = Number(value);
if (isNaN(num) || num < 0 || num > 150) return { field, message: 'Age must be between 0 and 150' };
return null;
}});
```
4. **Import Pipeline Lifecycle**: Upload → Validate → Preview → Confirm → Process.
```typescript
interface ImportJob {
id: string;
userId: string;
fileName: string;
fileSize: number;
rowCount: number;
status: ImportStatus;
importMode: 'insert' | 'upsert' | 'replace';
dedupField?: string;
validationErrors?: ValidationError[];
processingProgress?: { processed: number; total: number; failed: number };
createdAt: Date;
completedAt?: Date;
}
type ImportStatus =
| 'uploaded'
| 'validating'
| 'validation_complete'
| 'preview'
| 'confirmed'
| 'processing'
| 'completed'
| 'partial'
| 'failed';
app.post('/api/imports/:id/confirm', async (req, res) => {
const job = await ImportJob.findById(req.params.id);
if (job.status !== 'validation_complete') {
return res.status(400).json({ error: 'Import must complete validation first' });
}
job.status = 'confirmed';
await job.save();
await importQueue.add('process', {
importId: job.id,
batchSize: req.body.batchSize || 500,
importMode: job.importMode,
dedupField: job.dedupField,
});
res.json({ status: 'processing', jobId: job.id });
});
```
5. **Batch Processing with Progress**: Process in batches with transaction support.
```typescript
import { Queue, Worker } from 'bullmq';
const connection = { host: process.env.REDIS_HOST, port: Number(process.env.REDIS_PORT ?? 6379) };
export const importQueue = new Queue('import-processing', { connection });
new Worker('import-processing', async (job) => {
const { importId, batchSize, importMode, dedupField } = job.data;
const importJob = await ImportJob.findById(importId);
importJob.status = 'processing';
await importJob.save();
// Replace mode: clear once, up front (or load into a staging table and swap).
if (importMode === 'replace') {
await backupTargetTable(importId);
await db('target_table').delete();
}
const fileStream = createReadStream(importJob.filePath);
const parser = fileStream.pipe(parse({ columns: true, skip_empty_lines: true }));
let batch: Record<string, unknown>[] = [];
let processed = 0;
let failed = 0;
const errors: ProcessingError[] = [];
for await (const record of parser) {
batch.push(record);
if (batch.length >= batchSize) {
const result = await processBatch(batch, importMode, dedupField);
processed += result.processed;
failed += result.failed;
errors.push(...result.errors);
importJob.processingProgress = { processed, total: importJob.rowCount, failed };
await importJob.save();
await job.updateProgress({ processed, total: importJob.rowCount, failed });
batch = [];
}
}
if (batch.length > 0) {
const result = await processBatch(batch, importMode, dedupField);
processed += result.processed;
failed += result.failed;
errors.push(...result.errors);
}
importJob.status = failed > 0 && processed > 0 ? 'partial' : 'completed';
importJob.completedAt = new Date();
importJob.processingProgress = { processed, total: importJob.rowCount, failed };
await importJob.save();
await notifyWebhook(importJob);
return { processed, failed, errors: errors.slice(0, 100) };
}, { connection, concurrency: 2 });
async function processBatch(
rows: Record<string, unknown>[],
mode: string,
dedupField?: string
): Promise<{ processed: number; failed: number; errors: ProcessingError[] }> {
const errors: ProcessingError[] = [];
if (dedupField) {
const existingValues = await getExistingValues(rows, dedupField);
rows = filterDuplicates(rows, dedupField, existingValues);
}
const trx = await db.transaction(); // knex
try {
switch (mode) {
case 'insert':
case 'replace': // table already cleared once before the first batch
await trx('target_table').insert(rows);
break;
case 'upsert':
await trx('target_table').insert(rows).onConflict(dedupField || 'id').merge();
break;
}
await trx.commit();
return { processed: rows.length, failed: 0, errors: [] };
} catch (error) {
await trx.rollback();
errors.push({ message: (error as Error).message, rows: rows.length });
return { processed: 0, failed: rows.length, errors };
}
}
```
6. **Import Templates**: Generate downloadable sample files.
```typescript
function generateImportTemplate(headers: ImportColumn[]): string {
const headerRow = headers.map(h => h.label).join(',');
const sampleRow = headers.map(h => h.example || '').join(',');
return `${headerRow}\n${sampleRow}\n`;
}
app.get('/api/imports/templates/:type', (req, res) => {
const template = getImportTemplateConfig(req.params.type);
const csv = generateImportTemplate(template.columns);
res.setHeader('Content-Type', 'text/csv');
res.setHeader('Content-Disposition', `attachment; filename="${template.name}-template.csv"`);
res.send(csv);
});
```
## Implementation Patterns
### Pattern: Column Header Mapping
```typescript
interface ColumnMapping {
displayName: string; // From CSV header
fieldName: string; // Internal field name
required: boolean;
defaultValue?: unknown;
transform?: (value: string) => unknown;
}
class HeaderMapper {
async detectHeaders(file: Buffer, mimeType: string): Promise<ColumnMapping[]> {
const headers = await this.parseHeaders(file, mimeType);
const mapping = this.fuzzyMatch(headers, this.expectedColumns);
const unmatched = headers.filter(h => !mapping.find(m => m.displayName === h));
if (unmatched.length > 0) {
throw new ImportError(`Unrecognized columns: ${unmatched.join(', ')}`);
}
return mapping;
}
private fuzzyMatch(actual: string[], expected: ColumnMapping[]): ColumnMapping[] {
return actual.map(header => {
const match = expected.find(e =>
e.displayName.toLowerCase() === header.toLowerCase() ||
e.fieldName.toLowerCase() === header.toLowerCase()
);
if (!match) return null;
return { ...match, displayName: header };
}).filter(Boolean) as ColumnMapping[];
}
}
```
### Pattern: Error Report Generation
```typescript
interface ImportError {
row: number;
column: string;
value: string;
message: string;
code: string;
}
async function generateErrorReport(errors: ImportError[], format: 'csv' | 'xlsx'): Promise<Buffer> {
if (format === 'csv') {
const header = 'Row,Column,Value,Error,Code\n';
const rows = errors.map(e =>
`"${e.row}","${e.column}","${e.value.replace(/"/g, '""')}","${e.message.replace(/"/g, '""')}","${e.code}"`
).join('\n');
return Buffer.from(header + rows, 'utf-8');
}
const workbook = new ExcelJS.Workbook();
const sheet = workbook.addWorksheet('Import Errors');
sheet.columns = [
{ header: 'Row', key: 'row', width: 10 },
{ header: 'Column', key: 'column', width: 20 },
{ header: 'Value', key: 'value', width: 30 },
{ header: 'Error', key: 'message', width: 50 },
{ header: 'Code', key: 'code', width: 15 },
];
errors.forEach(e => sheet.addRow(e));
sheet.getRow(1).font = { bold: true };
return await workbook.xlsx.writeBuffer() as Buffer;
}
```
### Pattern: Import Webhook Notifications
```typescript
interface ImportNotification {
importId: string;
status: 'completed' | 'partial' | 'failed';
summary: { total: number; processed: number; failed: number; skipped: number };
downloadUrl?: string;
errorReportUrl?: string;
}
async function notifyImportComplete(job: ImportJob): Promise<void> {
const notification: ImportNotification = {
importId: job.id,
status: job.status,
summary: {
total: job.rowCount,
processed: job.processingProgress?.processed || 0,
failed: job.processingProgress?.failed || 0,
skipped: job.rowCount - (job.processingProgress?.processed || 0) - (job.processingProgress?.failed || 0),
},
};
if (job.webhookUrl) {
await fetch(job.webhookUrl, {
method: 'POST',
headers: { 'content-type': 'application/json' },
body: JSON.stringify(notification),
});
}
if (job.notifyUserId) {
await notificationService.send(job.notifyUserId, {
type: 'import_complete',
title: `Import ${job.status}: ${job.fileName}`,
...notification,
});
}
}
```
## Production Considerations
### Scalability
- Queue workers: scale horizontally by import type; dedicated worker pools for large imports
- DB connections: batch processing uses pooled connections; release between batches
- Memory: streaming parsers for files > 50MB; never load entire file into memory
- Storage: upload files to S3/Blob storage; process from stream without local temp file
### Monitoring
- Metrics: import duration, rows/second, error rate by type, queue depth, failure rate
- Alerts: error rate > 5%, queue backlog > 100 jobs, same file re-upload > 3 times
- Logging: structured logs per import job (importId, userId, status, rowCount, duration)
### Error Recovery
- Partial success: import valid rows, report errors, allow retry of failed rows only
- Rollback: transaction per batch; failed batch rolls back without affecting previous batches
- Retry: exponential backoff for transient DB errors; manual retry for data errors after fix
- Cancellation: set cancel flag; worker checks flag between batches and stops gracefully
## Anti-Patterns
| Anti-Pattern | Why | Fix |
|-------------|-----|-----|
| Direct INSERT without validation | Bad data corrupts database | Validation pipeline before any insert |
| Single transaction for entire file | Failure loses all progress; locks table | Batch per transaction (500-1000 rows) |
| Processing on main thread | Blocks HTTP response; no retry | Background queue always |
| Ignoring BOM/encoding | Corrupted strings for special chars | Auto-detect encoding with `chardet` or `iconv-lite` |
| Overwriting data without backup | Replace mode can't be undone | Auto-backup before replace; transaction rollback |
| No header validation | Wrong column mapping = wrong data | Validate headers before processing any rows |
| Synchronous progress tracking | Users refresh waiting; no feedback | WebSocket push or poll endpoint for progress |
| Storing full file content in DB | DB bloat; file storage is cheaper | Object storage with metadata reference in DB |
| Too-large batch size (10K+) | Long transaction; deadlock risk | Optimal batch size: 500-1000 rows |
| No dedup before import | Duplicate records; manual cleanup | Dedup check per batch; fail or skip duplicates |
## Security Considerations
- File validation: do not trust extension or client MIME type. XLSX is a ZIP container (check the `PK` signature and parse it with a hardened library); CSV has no signature, so validate it by parsing (encoding, column count) and reject on failure. Cap rows, columns and cell length to stop zip bombs and memory exhaustion
- Upload path traversal: sanitize filename; use UUID-based storage keys, never user-provided names
- CSV injection: don't open generated CSV in Excel directly (formulas starting with =, +, -, @ can execute)
- Mitigation: prefix dangerous-starting values with tab or single quote in CSV output
- Rate limiting: per-user, per-hour import limits (e.g., 5 imports/hour, 500MB/hour total)
- PII: mask sensitive fields in preview; enforce field-level access control
- Audit: log every import action (upload, validate, confirm, cancel) with userId, timestamp, row count
- File retention: auto-delete uploaded files after 30 days; allow user-triggered immediate deletion
## Testing Strategies
```typescript
import { describe, it, expect } from 'vitest';
import { parse } from 'csv-parse';
describe('Bulk Import', () => {
it('parses CSV with headers', async () => {
const csv = 'name,email,age\nAlice,alice@test.com,30\nBob,bob@test.com,25';
const records: Record<string, string>[] = [];
const parser = parse(csv, { columns: true, skip_empty_lines: true });
for await (const record of parser) records.push(record);
expect(records).toHaveLength(2);
expect(records[0].name).toBe('Alice');
});
it('validates required fields', async () => {
const validator = new ImportValidator();
validator.register('email', { validate: async (f, v) => !v ? { field: f, message: 'Required' } : null });
const result = await validator.validate([{ email: '' }, { email: 'test@test.com' }]);
expect(result.errorCount).toBe(1);
expect(result.validCount).toBe(1);
});
it('detects encoding', async () => {
const buf = Buffer.from('name,email\nJalapeño,test@test.com', 'utf-8');
const encoding = await detectEncoding(buf);
expect(encoding).toBe('UTF-8');
});
it('rejects oversized files', () => {
const file = { size: 100 * 1024 * 1024, mimetype: 'text/csv' };
expect(validateFile(file, { maxSize: 50 * 1024 * 1024 })).toBe(false);
});
it('processes batch with transaction rollback on error', async () => {
// db is a mocked knex instance whose insert rejects (name NOT NULL)
const result = await processBatch(
[{ id: 1, name: 'Valid' }, { id: 2, name: null }],
'insert',
);
expect(result.processed).toBe(0);
expect(result.failed).toBe(2);
});
it('generates downloadable error report', async () => {
const errors = [{ row: 1, column: 'email', value: 'bad', message: 'Invalid format', code: 'INVALID_EMAIL' }];
const report = await generateErrorReport(errors, 'csv');
expect(report.toString()).toContain('Row,Column,Value,Error,Code');
expect(report.toString()).toContain('"1","email","bad","Invalid format","INVALID_EMAIL"');
});
});
```
- Test with real CSV/Excel files containing edge cases: BOM, UTF-16, emoji, null bytes, quote-escaped fields
- Load test with a realistic large file (e.g. 500K rows) and record rows/second as a regression baseline
- Test cancel: start import, cancel mid-way, verify no partial data committed
- Test replace mode: verify old data is backed up before truncate, can be restored
## Rules
- Never parse a whole large file in the HTTP request; upload, then process in a background job.
- Validate headers before rows; collect row errors instead of failing on the first.
- One transaction per batch (hundreds to a few thousand rows); never one transaction for a huge file unless using a staging table.
- Database constraints are the final authority for uniqueness and integrity.
- Replace mode only with a backup or staging-table swap.
## References
- references/bulk-export.md — Bulk Export
- references/bulk-import-advanced.md — Bulk Import Advanced Topics
- references/bulk-import-fundamentals.md — Bulk Import Fundamentals
- references/csv-parsing.md — CSV Parsing
- references/import-monitoring.md — Import Monitoring
- references/import-workflow.md — Import Workflow
- references/rollback-recovery.md — Rollback and Recovery
- references/validation-pipeline.md — Validation Pipeline
## Handoff
- `backend/report-generation` — Export/import round-trip patterns
- `skills/data/etl-pipeline` — ETL pipeline integration for bulk imports
- `skills/backend/universal/background-jobs` — Queue management for import jobs
Pliki w paczce (9)
- SKILL.md 24 KB
- references/bulk-export.md 10 KB
- references/bulk-import-advanced.md 7 KB
- references/bulk-import-fundamentals.md 7 KB
- references/csv-parsing.md 16 KB
- references/import-monitoring.md 11 KB
- references/import-workflow.md 13 KB
- references/rollback-recovery.md 17 KB
- references/validation-pipeline.md 19 KB
Wersje
W bazie nie ma innych skilli o nazwie backend-bulk-import.
Migawka bazy z 13.11.2026 · wersja paczki 36efa0ae8f17 (skrót SHA-256 całej paczki)
Pobrania w ostatnich 30 dniach: 0 · ranking
Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.
Podobne skille
- 95file-handling
Opisuje obsługę plików: przechowywanie w S3, R2 i Vercel Blob, generowanie PDF, import i eksport CSV i Excel, streaming, presigned URL i multipart upload. - 100imports
Wprowadza dane zewnętrzne do aplikacji: import z CSV i arkuszy, kreatory wklejania listy, przesyłanie dużych plików i asynchroniczne zadania. - 100csv-xlsx-import-export-stinger
Wdraża import i eksport arkuszy w React: parsowanie CSV i XLSX, mapowanie kolumn, walidacja wierszy, strumieniowanie i ochrona przed CSV injection. - 100dataverse-data
Zapisuje rekordy w tabelach Microsoft Dataverse przez Python SDK, CLI lub MCP: tworzenie, aktualizacja, usuwanie, upsert z kluczami alternatywnymi, import zbiorczy, import CSV i zapis zwrotny DataFrame. - 100rails-csv-io
Statycznie, bez LLM, wykrywa trzy pułapki importu CSV w Rails: wczytywanie całego pliku do pamięci, brak obsługi kodowania i BOM oraz zapisy w pętli bez transakcji. - 100apache-poi
Obsługuje pliki Excel w aplikacjach Java z Apache POI: generowanie i import XLSX, skoroszyty i arkusze.