@fluentcommerce/fc-connect-sdk 0.1.53 → 0.1.55

package/docs/02-CORE-GUIDES/extraction/modules/02-core-guides-extraction-06-export-formats.md

@@ -1,458 +1,458 @@
-# Module 6: Export Formats
-
-**Level:** Advanced
-**Estimated Time:** 20 minutes
-
-## Overview
-
-This module covers exporting extracted and transformed data to various formats including JSON, JSONL, CSV, XML, and Parquet, with integration to S3 and SFTP.
-
-## Learning Objectives
-
-By the end of this module, you will:
-- ✅ Export data to JSON and JSONL formats
-- ✅ Generate CSV files with proper headers
-- ✅ Create XML output for enterprise systems
-- ✅ Write Parquet files for data lakes
-- ✅ Upload exports to S3 and SFTP
-- ✅ Handle large files with streaming
-
-## JSON Export
-
-### Basic JSON Export
-
-```typescript
-import { S3DataSource } from '@fluentcommerce/fc-connect-sdk';
-
-const s3 = new S3DataSource(s3Config);
-
-// Pretty-printed JSON
-await s3.putObject(
-  'output-bucket',
-  'inventory.json',
-  JSON.stringify(data, null, 2)
-);
-
-// Compact JSON
-await s3.putObject(
-  'output-bucket',
-  'inventory.min.json',
-  JSON.stringify(data)
-);
-```
-
-### JSONL (JSON Lines) Export
-
-For streaming and big data tools:
-
-```typescript
-// Each record on separate line
-const jsonl = data.map(record => JSON.stringify(record)).join('\n');
-
-await s3.putObject('output-bucket', 'inventory.jsonl', jsonl);
-```
-
-### Streaming JSONL to S3
-
-For very large datasets:
-
-```typescript
-async function streamToJsonl(records: AsyncIterable<any>, outputKey: string) {
-  const s3 = new S3DataSource(s3Config);
-  const chunks: string[] = [];
-  let chunkSize = 0;
-  const maxChunkSize = 5 * 1024 * 1024; // 5MB
-
-  for await (const batch of records) {
-    for (const record of batch) {
-      const line = JSON.stringify(record) + '\n';
-
-      if (chunkSize + line.length > maxChunkSize && chunks.length > 0) {
-        // Write chunk to S3
-        await s3.putObject('output-bucket', outputKey, chunks.join(''));
-        chunks.length = 0;
-        chunkSize = 0;
-      }
-
-      chunks.push(line);
-      chunkSize += line.length;
-    }
-  }
-
-  // Write final chunk
-  if (chunks.length > 0) {
-    await s3.putObject('output-bucket', outputKey, chunks.join(''));
-  }
-}
-```
-
-## CSV Export
-
-### Using csv-stringify
-
-```typescript
-import { stringify } from 'csv-stringify/sync';
-import { S3DataSource } from '@fluentcommerce/fc-connect-sdk';
-
-function exportToCsv(data: any[], outputKey: string) {
-  const csv = stringify(data, {
-    header: true,
-    columns: [
-      { key: 'sku', header: 'SKU' },
-      { key: 'warehouse', header: 'Warehouse' },
-      { key: 'quantity', header: 'Quantity' },
-      { key: 'status', header: 'Status' }
-    ],
-    cast: {
-      boolean: (value) => value ? 'Yes' : 'No',
-      date: (value) => value.toISOString().split('T')[0]
-    }
-  });
-
-  const s3 = new S3DataSource(s3Config);
-  await s3.putObject('output-bucket', outputKey, csv);
-}
-```
-
-### Custom CSV Builder
-
-```typescript
-class CsvBuilder {
-  private headers: string[];
-  private rows: string[][] = [];
-
-  constructor(headers: string[]) {
-    this.headers = headers;
-  }
-
-  addRow(row: Record<string, any>): void {
-    const values = this.headers.map(header => {
-      const value = row[header];
-      return this.escapeCsvValue(value);
-    });
-    this.rows.push(values);
-  }
-
-  private escapeCsvValue(value: any): string {
-    if (value === null || value === undefined) return '';
-
-    const str = String(value);
-
-    // Escape quotes and wrap in quotes if contains special chars
-    if (str.includes(',') || str.includes('"') || str.includes('\n')) {
-      return `"${str.replace(/"/g, '""')}"`;
-    }
-
-    return str;
-  }
-
-  toString(): string {
-    const headerRow = this.headers.map(h => this.escapeCsvValue(h)).join(',');
-    const dataRows = this.rows.map(row => row.join(',')).join('\n');
-    return `${headerRow}\n${dataRows}`;
-  }
-}
-
-// Usage
-const csv = new CsvBuilder(['SKU', 'Warehouse', 'Quantity', 'Status']);
-
-for (const record of data) {
-  csv.addRow(record);
-}
-
-await s3.putObject('output-bucket', 'inventory.csv', csv.toString());
-```
-
-## XML Export
-
-### Basic XML Generation
-
-```typescript
-import { create } from 'xmlbuilder2';
-
-function exportToXml(data: any[], outputKey: string) {
-  const root = create({ version: '1.0', encoding: 'UTF-8' })
-    .ele('InventoryExport')
-    .att('timestamp', new Date().toISOString());
-
-  for (const record of data) {
-    root.ele('Item')
-      .ele('SKU').txt(record.sku).up()
-      .ele('Warehouse').txt(record.warehouse).up()
-      .ele('Quantity').txt(String(record.quantity)).up()
-      .ele('Status').txt(record.status).up()
-      .up();
-  }
-
-  const xml = root.end({ prettyPrint: true });
-
-  const s3 = new S3DataSource(s3Config);
-  await s3.putObject('output-bucket', outputKey, xml);
-}
-```
-
-### XML with Nested Structures
-
-```typescript
-function exportOrdersToXml(orders: any[]) {
-  const root = create({ version: '1.0' })
-    .ele('Orders');
-
-  for (const order of orders) {
-    const orderEl = root.ele('Order')
-      .att('ref', order.ref)
-      .att('status', order.status);
-
-    orderEl.ele('TotalPrice').txt(String(order.totalPrice)).up();
-    orderEl.ele('Currency').txt(order.currency).up();
-
-    const customerEl = orderEl.ele('Customer');
-    customerEl.ele('Email').txt(order.customer.email).up();
-    customerEl.ele('Name').txt(`${order.customer.firstName} ${order.customer.lastName}`).up();
-    customerEl.up();
-
-    const itemsEl = orderEl.ele('Items');
-    for (const item of order.items || []) {
-      itemsEl.ele('Item')
-        .att('ref', item.ref)
-        .ele('ProductRef').txt(item.productRef).up()
-        .ele('Quantity').txt(String(item.quantity)).up()
-        .ele('Price').txt(String(item.price)).up()
-        .up();
-    }
-  }
-
-  return root.end({ prettyPrint: true });
-}
-```
-
-## Parquet Export
-
-### Writing Parquet Files
-
-```typescript
-import { ParquetWriter, ParquetSchema } from 'parquetjs';
-
-async function exportToParquet(data: any[], outputPath: string) {
-  // Define schema
-  const schema = new ParquetSchema({
-    sku: { type: 'UTF8' },
-    warehouse: { type: 'UTF8' },
-    quantity: { type: 'INT32' },
-    status: { type: 'UTF8' },
-    lastUpdated: { type: 'UTF8' }
-  });
-
-  // Create writer
-  const writer = await ParquetWriter.openFile(schema, outputPath);
-
-  // Write records
-  for (const record of data) {
-    await writer.appendRow({
-      sku: record.sku,
-      warehouse: record.warehouse,
-      quantity: parseInt(record.quantity) || 0,
-      status: record.status,
-      lastUpdated: record.lastUpdated || new Date().toISOString()
-    });
-  }
-
-  // Close file
-  await writer.close();
-
-  console.log(`Wrote ${data.length} records to ${outputPath}`);
-}
-```
-
-### Parquet with Compression
-
-```typescript
-async function exportToCompressedParquet(data: any[]) {
-  const schema = new ParquetSchema({
-    sku: { type: 'UTF8', compression: 'SNAPPY' },
-    warehouse: { type: 'UTF8', compression: 'SNAPPY' },
-    quantity: { type: 'INT32' },
-    status: { type: 'UTF8' }
-  });
-
-  const writer = await ParquetWriter.openFile(schema, 'output.parquet', {
-    compression: 'SNAPPY'
-  });
-
-  for (const record of data) {
-    await writer.appendRow(record);
-  }
-
-  await writer.close();
-}
-```
-
-## S3 Integration
-
-### Upload with Metadata
-
-```typescript
-import { PutObjectCommand, S3Client } from '@aws-sdk/client-s3';
-
-async function uploadWithMetadata(data: any[], bucket: string, key: string) {
-  const s3Client = new S3Client({
-    region: process.env.AWS_REGION!,
-    credentials: {
-      accessKeyId: process.env.AWS_ACCESS_KEY_ID!,
-      secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY!
-    }
-  });
-
-  const content = JSON.stringify(data, null, 2);
-
-  await s3Client.send(new PutObjectCommand({
-    Bucket: bucket,
-    Key: key,
-    Body: content,
-    ContentType: 'application/json',
-    Metadata: {
-      'record-count': String(data.length),
-      'export-timestamp': new Date().toISOString(),
-      'source-system': 'fluent-commerce'
-    }
-  }));
-}
-```
-
-### Multipart Upload for Large Files
-
-```typescript
-import { S3DataSource } from '@fluentcommerce/fc-connect-sdk';
-
-async function uploadLargeFile(filePath: string, bucket: string, key: string) {
-  const s3 = new S3DataSource(s3Config);
-  const fs = require('fs');
-
-  // For files > 5GB, use multipart upload
-  const stats = fs.statSync(filePath);
-
-  if (stats.size > 5 * 1024 * 1024 * 1024) {
-    console.log('Using multipart upload for large file');
-    // SDK handles multipart automatically for large files
-  }
-
-  const content = fs.readFileSync(filePath);
-  await s3.putObject(bucket, key, content);
-}
-```
-
-## SFTP Integration
-
-### Upload to SFTP Server
-
-```typescript
-import { SftpDataSource, createConsoleLogger } from '@fluentcommerce/fc-connect-sdk';
-
-async function exportToSftp(data: any[], remotePath: string) {
-  const logger = createConsoleLogger();
-  const sftp = new SftpDataSource(
-    {
-      type: 'SFTP_JSON',
-      sftpConfig: {
-        settings: {
-          host: process.env.SFTP_HOST!,
-          port: parseInt(process.env.SFTP_PORT || '22'),
-          username: process.env.SFTP_USERNAME!,
-          password: process.env.SFTP_PASSWORD!,
-        },
-      },
-      connectionId: 'sftp-export',
-    },
-    logger
-  );
-
-  const content = JSON.stringify(data, null, 2);
-
-  try {
-    await sftp.uploadFile(remotePath, content);
-    console.log(`Uploaded to ${remotePath}`);
-  } finally {
-    // Connection pooling handles cleanup automatically
-  }
-}
-```
-
-## Complete Export Workflow
-
-```typescript
-import {
-  createClient,
-  UniversalMapper,
-  S3DataSource,
-  createConsoleLogger,
-  toStructuredLogger
-} from '@fluentcommerce/fc-connect-sdk';
-import { stringify } from 'csv-stringify/sync';
-
-async function fullExportWorkflow() {
-  const logger = toStructuredLogger(createConsoleLogger(), { logLevel: 'info' });
-  const client = await createClient({ config });
-  const s3 = new S3DataSource(s3Config);
-
-  // Extract
-  const result = await client.graphql({
-    query: extractionQuery,
-    variables: { first: 100 },
-    pagination: { maxRecords: 50000 }
-  });
-
-  const records = result.data.inventoryPositions.edges.map(e => e.node);
-  logger.info(`Extracted ${records.length} records`);
-
-  // Transform
-  const mapper = new UniversalMapper(mappingConfig);
-  const mappingResult = await mapper.map(records);
-
-  if (!mappingResult.success) {
-    throw new Error('Transformation failed');
-  }
-
-  const transformed = mappingResult.data;
-  const timestamp = new Date().toISOString();
-
-  // Export to multiple formats
-  await Promise.all([
-    // JSON
-    s3.putObject(
-      'output-bucket',
-      `exports/inventory_${timestamp}.json`,
-      JSON.stringify(transformed, null, 2)
-    ),
-
-    // JSONL
-    s3.putObject(
-      'output-bucket',
-      `exports/inventory_${timestamp}.jsonl`,
-      transformed.map(r => JSON.stringify(r)).join('\n')
-    ),
-
-    // CSV
-    s3.putObject(
-      'output-bucket',
-      `exports/inventory_${timestamp}.csv`,
-      stringify(transformed, { header: true })
-    )
-  ]);
-
-  logger.info('Export complete');
-}
-```
-
-## Key Takeaways
-
-- 🎯 Choose format based on use case (JSON for APIs, CSV for BI, Parquet for data lakes)
-- 🎯 Use JSONL for streaming and large datasets
-- 🎯 Properly escape CSV values to avoid parsing issues
-- 🎯 Add metadata to S3 uploads for traceability
-- 🎯 Use compression for Parquet files
-- 🎯 Stream large files to avoid memory issues
-- 🎯 Test exports with sample data first
-
-## Next Steps
-
-Continue to [Module 7: Optimization](./02-core-guides-extraction-07-optimization.md) to learn performance optimization, caching, monitoring, and best practices.
+# Module 6: Export Formats
+
+**Level:** Advanced
+**Estimated Time:** 20 minutes
+
+## Overview
+
+This module covers exporting extracted and transformed data to various formats including JSON, JSONL, CSV, XML, and Parquet, with integration to S3 and SFTP.
+
+## Learning Objectives
+
+By the end of this module, you will:
+- ✅ Export data to JSON and JSONL formats
+- ✅ Generate CSV files with proper headers
+- ✅ Create XML output for enterprise systems
+- ✅ Write Parquet files for data lakes
+- ✅ Upload exports to S3 and SFTP
+- ✅ Handle large files with streaming
+
+## JSON Export
+
+### Basic JSON Export
+
+```typescript
+import { S3DataSource } from '@fluentcommerce/fc-connect-sdk';
+
+const s3 = new S3DataSource(s3Config);
+
+// Pretty-printed JSON
+await s3.putObject(
+  'output-bucket',
+  'inventory.json',
+  JSON.stringify(data, null, 2)
+);
+
+// Compact JSON
+await s3.putObject(
+  'output-bucket',
+  'inventory.min.json',
+  JSON.stringify(data)
+);
+```
+
+### JSONL (JSON Lines) Export
+
+For streaming and big data tools:
+
+```typescript
+// Each record on separate line
+const jsonl = data.map(record => JSON.stringify(record)).join('\n');
+
+await s3.putObject('output-bucket', 'inventory.jsonl', jsonl);
+```
+
+### Streaming JSONL to S3
+
+For very large datasets:
+
+```typescript
+async function streamToJsonl(records: AsyncIterable<any>, outputKey: string) {
+  const s3 = new S3DataSource(s3Config);
+  const chunks: string[] = [];
+  let chunkSize = 0;
+  const maxChunkSize = 5 * 1024 * 1024; // 5MB
+
+  for await (const batch of records) {
+    for (const record of batch) {
+      const line = JSON.stringify(record) + '\n';
+
+      if (chunkSize + line.length > maxChunkSize && chunks.length > 0) {
+        // Write chunk to S3
+        await s3.putObject('output-bucket', outputKey, chunks.join(''));
+        chunks.length = 0;
+        chunkSize = 0;
+      }
+
+      chunks.push(line);
+      chunkSize += line.length;
+    }
+  }
+
+  // Write final chunk
+  if (chunks.length > 0) {
+    await s3.putObject('output-bucket', outputKey, chunks.join(''));
+  }
+}
+```
+
+## CSV Export
+
+### Using csv-stringify
+
+```typescript
+import { stringify } from 'csv-stringify/sync';
+import { S3DataSource } from '@fluentcommerce/fc-connect-sdk';
+
+function exportToCsv(data: any[], outputKey: string) {
+  const csv = stringify(data, {
+    header: true,
+    columns: [
+      { key: 'sku', header: 'SKU' },
+      { key: 'warehouse', header: 'Warehouse' },
+      { key: 'quantity', header: 'Quantity' },
+      { key: 'status', header: 'Status' }
+    ],
+    cast: {
+      boolean: (value) => value ? 'Yes' : 'No',
+      date: (value) => value.toISOString().split('T')[0]
+    }
+  });
+
+  const s3 = new S3DataSource(s3Config);
+  await s3.putObject('output-bucket', outputKey, csv);
+}
+```
+
+### Custom CSV Builder
+
+```typescript
+class CsvBuilder {
+  private headers: string[];
+  private rows: string[][] = [];
+
+  constructor(headers: string[]) {
+    this.headers = headers;
+  }
+
+  addRow(row: Record<string, any>): void {
+    const values = this.headers.map(header => {
+      const value = row[header];
+      return this.escapeCsvValue(value);
+    });
+    this.rows.push(values);
+  }
+
+  private escapeCsvValue(value: any): string {
+    if (value === null || value === undefined) return '';
+
+    const str = String(value);
+
+    // Escape quotes and wrap in quotes if contains special chars
+    if (str.includes(',') || str.includes('"') || str.includes('\n')) {
+      return `"${str.replace(/"/g, '""')}"`;
+    }
+
+    return str;
+  }
+
+  toString(): string {
+    const headerRow = this.headers.map(h => this.escapeCsvValue(h)).join(',');
+    const dataRows = this.rows.map(row => row.join(',')).join('\n');
+    return `${headerRow}\n${dataRows}`;
+  }
+}
+
+// Usage
+const csv = new CsvBuilder(['SKU', 'Warehouse', 'Quantity', 'Status']);
+
+for (const record of data) {
+  csv.addRow(record);
+}
+
+await s3.putObject('output-bucket', 'inventory.csv', csv.toString());
+```
+
+## XML Export
+
+### Basic XML Generation
+
+```typescript
+import { create } from 'xmlbuilder2';
+
+function exportToXml(data: any[], outputKey: string) {
+  const root = create({ version: '1.0', encoding: 'UTF-8' })
+    .ele('InventoryExport')
+    .att('timestamp', new Date().toISOString());
+
+  for (const record of data) {
+    root.ele('Item')
+      .ele('SKU').txt(record.sku).up()
+      .ele('Warehouse').txt(record.warehouse).up()
+      .ele('Quantity').txt(String(record.quantity)).up()
+      .ele('Status').txt(record.status).up()
+      .up();
+  }
+
+  const xml = root.end({ prettyPrint: true });
+
+  const s3 = new S3DataSource(s3Config);
+  await s3.putObject('output-bucket', outputKey, xml);
+}
+```
+
+### XML with Nested Structures
+
+```typescript
+function exportOrdersToXml(orders: any[]) {
+  const root = create({ version: '1.0' })
+    .ele('Orders');
+
+  for (const order of orders) {
+    const orderEl = root.ele('Order')
+      .att('ref', order.ref)
+      .att('status', order.status);
+
+    orderEl.ele('TotalPrice').txt(String(order.totalPrice)).up();
+    orderEl.ele('Currency').txt(order.currency).up();
+
+    const customerEl = orderEl.ele('Customer');
+    customerEl.ele('Email').txt(order.customer.email).up();
+    customerEl.ele('Name').txt(`${order.customer.firstName} ${order.customer.lastName}`).up();
+    customerEl.up();
+
+    const itemsEl = orderEl.ele('Items');
+    for (const item of order.items || []) {
+      itemsEl.ele('Item')
+        .att('ref', item.ref)
+        .ele('ProductRef').txt(item.productRef).up()
+        .ele('Quantity').txt(String(item.quantity)).up()
+        .ele('Price').txt(String(item.price)).up()
+        .up();
+    }
+  }
+
+  return root.end({ prettyPrint: true });
+}
+```
+
+## Parquet Export
+
+### Writing Parquet Files
+
+```typescript
+import { ParquetWriter, ParquetSchema } from 'parquetjs';
+
+async function exportToParquet(data: any[], outputPath: string) {
+  // Define schema
+  const schema = new ParquetSchema({
+    sku: { type: 'UTF8' },
+    warehouse: { type: 'UTF8' },
+    quantity: { type: 'INT32' },
+    status: { type: 'UTF8' },
+    lastUpdated: { type: 'UTF8' }
+  });
+
+  // Create writer
+  const writer = await ParquetWriter.openFile(schema, outputPath);
+
+  // Write records
+  for (const record of data) {
+    await writer.appendRow({
+      sku: record.sku,
+      warehouse: record.warehouse,
+      quantity: parseInt(record.quantity) || 0,
+      status: record.status,
+      lastUpdated: record.lastUpdated || new Date().toISOString()
+    });
+  }
+
+  // Close file
+  await writer.close();
+
+  console.log(`Wrote ${data.length} records to ${outputPath}`);
+}
+```
+
+### Parquet with Compression
+
+```typescript
+async function exportToCompressedParquet(data: any[]) {
+  const schema = new ParquetSchema({
+    sku: { type: 'UTF8', compression: 'SNAPPY' },
+    warehouse: { type: 'UTF8', compression: 'SNAPPY' },
+    quantity: { type: 'INT32' },
+    status: { type: 'UTF8' }
+  });
+
+  const writer = await ParquetWriter.openFile(schema, 'output.parquet', {
+    compression: 'SNAPPY'
+  });
+
+  for (const record of data) {
+    await writer.appendRow(record);
+  }
+
+  await writer.close();
+}
+```
+
+## S3 Integration
+
+### Upload with Metadata
+
+```typescript
+import { PutObjectCommand, S3Client } from '@aws-sdk/client-s3';
+
+async function uploadWithMetadata(data: any[], bucket: string, key: string) {
+  const s3Client = new S3Client({
+    region: process.env.AWS_REGION!,
+    credentials: {
+      accessKeyId: process.env.AWS_ACCESS_KEY_ID!,
+      secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY!
+    }
+  });
+
+  const content = JSON.stringify(data, null, 2);
+
+  await s3Client.send(new PutObjectCommand({
+    Bucket: bucket,
+    Key: key,
+    Body: content,
+    ContentType: 'application/json',
+    Metadata: {
+      'record-count': String(data.length),
+      'export-timestamp': new Date().toISOString(),
+      'source-system': 'fluent-commerce'
+    }
+  }));
+}
+```
+
+### Multipart Upload for Large Files
+
+```typescript
+import { S3DataSource } from '@fluentcommerce/fc-connect-sdk';
+
+async function uploadLargeFile(filePath: string, bucket: string, key: string) {
+  const s3 = new S3DataSource(s3Config);
+  const fs = require('fs');
+
+  // For files > 5GB, use multipart upload
+  const stats = fs.statSync(filePath);
+
+  if (stats.size > 5 * 1024 * 1024 * 1024) {
+    console.log('Using multipart upload for large file');
+    // SDK handles multipart automatically for large files
+  }
+
+  const content = fs.readFileSync(filePath);
+  await s3.putObject(bucket, key, content);
+}
+```
+
+## SFTP Integration
+
+### Upload to SFTP Server
+
+```typescript
+import { SftpDataSource, createConsoleLogger } from '@fluentcommerce/fc-connect-sdk';
+
+async function exportToSftp(data: any[], remotePath: string) {
+  const logger = createConsoleLogger();
+  const sftp = new SftpDataSource(
+    {
+      type: 'SFTP_JSON',
+      sftpConfig: {
+        settings: {
+          host: process.env.SFTP_HOST!,
+          port: parseInt(process.env.SFTP_PORT || '22'),
+          username: process.env.SFTP_USERNAME!,
+          password: process.env.SFTP_PASSWORD!,
+        },
+      },
+      connectionId: 'sftp-export',
+    },
+    logger
+  );
+
+  const content = JSON.stringify(data, null, 2);
+
+  try {
+    await sftp.uploadFile(remotePath, content);
+    console.log(`Uploaded to ${remotePath}`);
+  } finally {
+    // Connection pooling handles cleanup automatically
+  }
+}
+```
+
+## Complete Export Workflow
+
+```typescript
+import {
+  createClient,
+  UniversalMapper,
+  S3DataSource,
+  createConsoleLogger,
+  toStructuredLogger
+} from '@fluentcommerce/fc-connect-sdk';
+import { stringify } from 'csv-stringify/sync';
+
+async function fullExportWorkflow() {
+  const logger = toStructuredLogger(createConsoleLogger(), { logLevel: 'info' });
+  const client = await createClient({ config });
+  const s3 = new S3DataSource(s3Config);
+
+  // Extract
+  const result = await client.graphql({
+    query: extractionQuery,
+    variables: { first: 100 },
+    pagination: { maxRecords: 50000 }
+  });
+
+  const records = result.data.inventoryPositions.edges.map(e => e.node);
+  logger.info(`Extracted ${records.length} records`);
+
+  // Transform
+  const mapper = new UniversalMapper(mappingConfig);
+  const mappingResult = await mapper.map(records);
+
+  if (!mappingResult.success) {
+    throw new Error('Transformation failed');
+  }
+
+  const transformed = mappingResult.data;
+  const timestamp = new Date().toISOString();
+
+  // Export to multiple formats
+  await Promise.all([
+    // JSON
+    s3.putObject(
+      'output-bucket',
+      `exports/inventory_${timestamp}.json`,
+      JSON.stringify(transformed, null, 2)
+    ),
+
+    // JSONL
+    s3.putObject(
+      'output-bucket',
+      `exports/inventory_${timestamp}.jsonl`,
+      transformed.map(r => JSON.stringify(r)).join('\n')
+    ),
+
+    // CSV
+    s3.putObject(
+      'output-bucket',
+      `exports/inventory_${timestamp}.csv`,
+      stringify(transformed, { header: true })
+    )
+  ]);
+
+  logger.info('Export complete');
+}
+```
+
+## Key Takeaways
+
+- 🎯 Choose format based on use case (JSON for APIs, CSV for BI, Parquet for data lakes)
+- 🎯 Use JSONL for streaming and large datasets
+- 🎯 Properly escape CSV values to avoid parsing issues
+- 🎯 Add metadata to S3 uploads for traceability
+- 🎯 Use compression for Parquet files
+- 🎯 Stream large files to avoid memory issues
+- 🎯 Test exports with sample data first
+
+## Next Steps
+
+Continue to [Module 7: Optimization](./02-core-guides-extraction-07-optimization.md) to learn performance optimization, caching, monitoring, and best practices.