@fluentcommerce/fc-connect-sdk 0.1.54 → 0.1.56

package/docs/03-PATTERN-GUIDES/file-operations/modules/file-operations-01-foundations.md

@@ -1,430 +1,430 @@
-# Module 1: Foundations
-
-**Level:** Beginner
-**Estimated Time:** 15 minutes
-
-## Overview
-
-This module introduces the fundamental concepts of file operations in the Fluent Connect SDK. You'll learn about data source abstractions, when to use different storage systems, and the unified interface pattern that makes working with files consistent across S3, SFTP, and other storage backends.
-
-## Learning Objectives
-
-By the end of this module, you will:
-
-- ✅ Understand the data source abstraction pattern
-- ✅ Know when to use S3 vs SFTP vs local files
-- ✅ Understand the unified interface benefits
-- ✅ Learn the common file operation patterns
-
-## What Are Data Sources?
-
-In the SDK, a **data source** is an abstraction layer that provides a consistent interface for file operations across different storage systems. Instead of learning separate APIs for S3, SFTP, FTP, local files, etc., you use the same methods regardless of where files are stored.
-
-### The Problem Without Abstraction
-
-```typescript
-// ❌ WITHOUT SDK: Every storage system has different API
-import { S3Client, GetObjectCommand, PutObjectCommand } from '@aws-sdk/client-s3';
-import * as SftpClient from 'ssh2-sftp-client';
-import * as fs from 'fs/promises';
-
-// S3 - complex AWS SDK
-const s3 = new S3Client({ region: 'us-east-1' });
-const s3Result = await s3.send(
-  new GetObjectCommand({
-    Bucket: 'my-bucket',
-    Key: 'file.csv',
-  })
-);
-const s3Body = await s3Result.Body?.transformToString();
-
-// SFTP - SDK SftpDataSource
-const sftp = new SftpDataSource(
-  {
-    type: 'SFTP_CSV',
-    connectionId: 'my-sftp',
-    name: 'My SFTP',
-    settings: {
-      host: 'example.com',
-      username: 'user',
-      password: 'pass',
-    },
-  },
-  logger
-);
-// No connect needed - handled internally
-const sftpResult = await sftp.downloadFile('/remote/file.csv');
-
-// Local files - yet another API
-const localResult = await fs.readFile('/local/file.csv', 'utf-8');
-
-// Three completely different APIs for the same operation!
-```
-
-### The Solution: Unified Interface
-
-```typescript
-// ✅ WITH SDK: Same interface for all storage systems
-import {
-  S3DataSource,
-  SftpDataSource,
-  createConsoleLogger,
-  toStructuredLogger
-} from '@fluentcommerce/fc-connect-sdk';
-
-const logger = createConsoleLogger();
-
-// S3 data source
-const s3Source = new S3DataSource(
-  {
-    type: 'S3_CSV',
-    connectionId: 'my-s3',
-    name: 'My S3 Bucket',
-    s3Config: {
-      region: 'us-east-1',
-      bucket: 'my-bucket',
-      accessKeyId: process.env.AWS_ACCESS_KEY_ID!,
-      secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY!,
-    },
-  },
-  logger
-);
-
-// SFTP data source
-const sftpSource = new SftpDataSource(
-  {
-    type: 'SFTP_CSV',
-    connectionId: 'my-sftp',
-    name: 'My SFTP Server',
-    settings: {
-      host: 'example.com',
-      username: 'user',
-      password: 'pass',
-    },
-  },
-  logger
-);
-
-// Same method signature for both!
-const s3File = await s3Source.downloadFile('file.csv');
-const sftpFile = await sftpSource.downloadFile('file.csv');
-
-// ✅ Consistent, predictable, easy to swap
-```
-
-## When to Use Each Storage System
-
-### S3 (AWS Simple Storage Service)
-
-**Best For:**
-
-- Cloud-native applications
-- Serverless workflows (Lambda, Versori)
-- Large datasets and data lakes
-- High availability requirements
-- Scalable storage needs
-- Public or presigned URL access
-
-**Advantages:**
-
-- ✅ Unlimited scalability
-- ✅ High durability (99.999999999%)
-- ✅ Low cost for large datasets
-- ✅ Presigned URLs for temporary access
-- ✅ Event notifications (S3 → Lambda)
-- ✅ No connection pooling needed
-
-**Disadvantages:**
-
-- ❌ Requires AWS account
-- ❌ Internet dependency
-- ❌ Per-request pricing model
-- ❌ No native "move" operation (copy + delete)
-
-**Use Case Examples:**
-
-```typescript
-// Data lake ingestion
-await s3.uploadFile('data-lake/orders/2025-01-15.parquet', parquetData);
-
-// Serverless processing
-const csvFiles = await s3.listFiles({ prefix: 'incoming/', maxKeys: 1000 });
-// Filter CSV files after listing (pattern matching not supported in S3 listFiles)
-const csvOnly = csvFiles.filter(f => f.name.endsWith('.csv'));
-
-// Presigned URL generation
-const url = await s3PresignService.generatePresignedDownloadUrl('report.pdf', 3600);
-```
-
-### SFTP (SSH File Transfer Protocol)
-
-**Best For:**
-
-- B2B integrations with partners
-- EDI system integrations
-- Secure file transfers
-- Compliance requirements (HIPAA, PCI-DSS)
-- Systems with existing SFTP infrastructure
-
-**Advantages:**
-
-- ✅ Industry standard for B2B
-- ✅ Strong encryption (SSH)
-- ✅ Widely supported
-- ✅ Native move/rename operations
-- ✅ Directory structure support
-- ✅ Username/password or key-based auth
-
-**Disadvantages:**
-
-- ❌ Connection management overhead
-- ❌ Requires server maintenance
-- ❌ Connection pooling complexity
-- ❌ Network latency sensitivity
-- ❌ Manual scaling
-
-**Use Case Examples:**
-
-```typescript
-// Partner file drop
-const partnerFiles = await sftp.listFiles(); // Pattern from config
-for (const file of partnerFiles) {
-  const content = await sftp.downloadFile(file.path);
-  await processPartnerData(content);
-  await sftp.moveFile(file.path, `/archive/${file.name}`);
-}
-
-// Compliance-required audit trail
-await sftp.uploadFile('/outgoing/audit-report.txt', reportData);
-```
-
-### Local Files
-
-**Best For:**
-
-- Development and testing
-- Single-machine scripts
-- Small datasets
-- Quick prototypes
-
-**Advantages:**
-
-- ✅ No external dependencies
-- ✅ Fast access
-- ✅ Simple setup
-
-**Disadvantages:**
-
-- ❌ Not scalable
-- ❌ No high availability
-- ❌ Single point of failure
-
-## Data Source Comparison
-
-| Feature                | S3            | SFTP               | Local Files         |
-| ---------------------- | ------------- | ------------------ | ------------------- |
-| **Scalability**        | Unlimited     | Limited by server  | Limited by disk     |
-| **Availability**       | 99.99% SLA    | Depends on server  | Single machine      |
-| **Cost**               | Pay per use   | Server + bandwidth | Infrastructure only |
-| **Setup Complexity**   | Medium        | High               | Low                 |
-| **B2B Integration**    | Rare          | Common             | N/A                 |
-| **Cloud-Native**       | Yes           | No                 | No                  |
-| **Connection Pooling** | N/A           | Required           | N/A                 |
-| **Move Operation**     | Copy + Delete | Native             | Native              |
-| **Presigned URLs**     | Yes           | No                 | No                  |
-
-## Unified Interface Pattern
-
-All data sources in the SDK implement a common interface with these core operations:
-
-### Core File Operations
-
-```typescript
-interface DataSource {
-  // List files matching criteria
-  listFiles(options?: ListOptions): Promise<FileInfo[]>;
-
-  // Read file content
-  downloadFile(path: string): Promise<string>;
-
-  // Write file content
-  uploadFile(path: string, content: string | Buffer): Promise<void>;
-
-  // Move file (rename or relocate)
-  moveFile(source: string, dest: string, createDirs?: boolean): Promise<void>;
-
-  // Copy file
-  copyFile(source: string, dest: string): Promise<void>;
-
-  // Delete file
-  deleteFile(path: string): Promise<void>;
-
-  // Check file existence
-  fileExists(path: string): Promise<boolean>;
-
-  // Clean up resources
-  dispose(): Promise<void>;
-}
-```
-
-### Benefits of Unified Interface
-
-1. **Portability**: Swap S3 for SFTP without code changes
-2. **Testability**: Mock data sources easily
-3. **Consistency**: Same method names, same error handling
-4. **Composability**: Build higher-level abstractions
-5. **Documentation**: Learn once, use everywhere
-
-## Common File Operation Patterns
-
-### Pattern 1: Read-Process-Archive
-
-The most common workflow in data integration:
-
-```typescript
-// 1. List files to process
-const files = await dataSource.listFiles();
-
-// 2. Process each file
-for (const file of files) {
-  // 2a. Read file
-  const content = await dataSource.downloadFile(file.path);
-
-  // 2b. Process data
-  await processData(content);
-
-  // 2c. Archive to prevent reprocessing
-  const archivePath = `/archive/${file.name}`;
-  await dataSource.moveFile(file.path, archivePath, true);
-}
-```
-
-### Pattern 2: Transform-and-Upload
-
-Process data and write to storage:
-
-```typescript
-// 1. Transform data
-const jsonData = await transformToJSON(sourceData);
-
-// 2. Upload result
-const outputPath = `output/${new Date().toISOString()}.json`;
-await dataSource.uploadFile(outputPath, JSON.stringify(jsonData));
-```
-
-### Pattern 3: Multi-Folder Processing
-
-Process files from multiple logical folders:
-
-```typescript
-const folders = ['orders', 'inventory', 'customers'];
-
-for (const folder of folders) {
-  const files = await dataSource.listFiles({ prefix: folder });
-
-  for (const file of files) {
-    const content = await dataSource.downloadFile(file.name);
-    await processByType(folder, content);
-  }
-}
-```
-
-### Pattern 4: Conditional Processing
-
-Only process files meeting certain criteria:
-
-```typescript
-const allFiles = await dataSource.listFiles();
-
-// Filter by file extension after listing
-const csvFiles = allFiles.filter(f => f.name.endsWith('.csv'));
-
-for (const file of csvFiles) {
-  // Only process files from today
-  if (file.name.includes(new Date().toISOString().split('T')[0])) {
-    const content = await dataSource.downloadFile(file.name);
-    await processData(content);
-  }
-}
-```
-
-## Key Concepts Summary
-
-### Data Source Abstraction
-
-- Provides unified interface across storage systems
-- Same methods work on S3, SFTP, local files
-- Eliminates vendor lock-in
-
-### Storage System Selection
-
-- **S3**: Cloud-native, scalable, serverless workflows
-- **SFTP**: B2B integrations, enterprise systems, compliance
-- **Local**: Development, testing, simple scripts
-
-### Common Operations
-
-- **List**: Find files to process
-- **Download**: Read file content
-- **Upload**: Write file content
-- **Move**: Archive or reorganize
-- **Copy**: Backup or duplicate
-- **Delete**: Clean up temporary files
-
-### Common Patterns
-
-- Read-Process-Archive (most common)
-- Transform-and-Upload
-- Multi-Folder Processing
-- Conditional Processing
-
-## Practice Exercise
-
-Try identifying which storage system to use:
-
-**Scenario 1**: You need to integrate with a retail partner who sends daily order files via their existing file transfer system.
-
-<details>
-<summary>Answer</summary>
-
-**SFTP** - B2B integrations typically use SFTP as the industry standard.
-
-</details>
-
-**Scenario 2**: You're building a serverless data pipeline on AWS Lambda that processes inventory updates from an S3 bucket.
-
-<details>
-<summary>Answer</summary>
-
-**S3** - Cloud-native, serverless workflows work best with S3.
-
-</details>
-
-**Scenario 3**: You're writing a one-time migration script to convert 100 CSV files on your laptop to JSON.
-
-<details>
-<summary>Answer</summary>
-
-**Local Files** - Simple, single-machine tasks don't need cloud storage.
-
-</details>
-
-## Key Takeaways
-
-- 🎯 Data sources provide a unified interface for file operations across storage systems
-- 🎯 Choose S3 for cloud-native scalability, SFTP for B2B integrations, local files for development
-- 🎯 The same methods work on all data sources: `downloadFile()`, `uploadFile()`, `moveFile()`, etc.
-- 🎯 Common patterns: Read-Process-Archive, Transform-and-Upload, Multi-Folder Processing
-- 🎯 Unified interface enables portability, testability, and consistency
-
-## Next Steps
-
-Continue to [Module 2: Quick Start](./file-operations-02-quick-start.md) to see working examples with S3 and SFTP.
-
----
-
-**Related Resources:**
-
-- [Quick Reference](../../../02-CORE-GUIDES/advanced-services/advanced-services-quick-reference.md) - All operations cheat sheet
-- [S3 Operations](./file-operations-03-s3-operations.md) - Complete S3 guide
-- [SFTP Operations](./file-operations-04-sftp-operations.md) - Complete SFTP guide
+# Module 1: Foundations
+
+**Level:** Beginner
+**Estimated Time:** 15 minutes
+
+## Overview
+
+This module introduces the fundamental concepts of file operations in the Fluent Connect SDK. You'll learn about data source abstractions, when to use different storage systems, and the unified interface pattern that makes working with files consistent across S3, SFTP, and other storage backends.
+
+## Learning Objectives
+
+By the end of this module, you will:
+
+- ✅ Understand the data source abstraction pattern
+- ✅ Know when to use S3 vs SFTP vs local files
+- ✅ Understand the unified interface benefits
+- ✅ Learn the common file operation patterns
+
+## What Are Data Sources?
+
+In the SDK, a **data source** is an abstraction layer that provides a consistent interface for file operations across different storage systems. Instead of learning separate APIs for S3, SFTP, FTP, local files, etc., you use the same methods regardless of where files are stored.
+
+### The Problem Without Abstraction
+
+```typescript
+// ❌ WITHOUT SDK: Every storage system has different API
+import { S3Client, GetObjectCommand, PutObjectCommand } from '@aws-sdk/client-s3';
+import * as SftpClient from 'ssh2-sftp-client';
+import * as fs from 'fs/promises';
+
+// S3 - complex AWS SDK
+const s3 = new S3Client({ region: 'us-east-1' });
+const s3Result = await s3.send(
+  new GetObjectCommand({
+    Bucket: 'my-bucket',
+    Key: 'file.csv',
+  })
+);
+const s3Body = await s3Result.Body?.transformToString();
+
+// SFTP - SDK SftpDataSource
+const sftp = new SftpDataSource(
+  {
+    type: 'SFTP_CSV',
+    connectionId: 'my-sftp',
+    name: 'My SFTP',
+    settings: {
+      host: 'example.com',
+      username: 'user',
+      password: 'pass',
+    },
+  },
+  logger
+);
+// No connect needed - handled internally
+const sftpResult = await sftp.downloadFile('/remote/file.csv');
+
+// Local files - yet another API
+const localResult = await fs.readFile('/local/file.csv', 'utf-8');
+
+// Three completely different APIs for the same operation!
+```
+
+### The Solution: Unified Interface
+
+```typescript
+// ✅ WITH SDK: Same interface for all storage systems
+import {
+  S3DataSource,
+  SftpDataSource,
+  createConsoleLogger,
+  toStructuredLogger
+} from '@fluentcommerce/fc-connect-sdk';
+
+const logger = createConsoleLogger();
+
+// S3 data source
+const s3Source = new S3DataSource(
+  {
+    type: 'S3_CSV',
+    connectionId: 'my-s3',
+    name: 'My S3 Bucket',
+    s3Config: {
+      region: 'us-east-1',
+      bucket: 'my-bucket',
+      accessKeyId: process.env.AWS_ACCESS_KEY_ID!,
+      secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY!,
+    },
+  },
+  logger
+);
+
+// SFTP data source
+const sftpSource = new SftpDataSource(
+  {
+    type: 'SFTP_CSV',
+    connectionId: 'my-sftp',
+    name: 'My SFTP Server',
+    settings: {
+      host: 'example.com',
+      username: 'user',
+      password: 'pass',
+    },
+  },
+  logger
+);
+
+// Same method signature for both!
+const s3File = await s3Source.downloadFile('file.csv');
+const sftpFile = await sftpSource.downloadFile('file.csv');
+
+// ✅ Consistent, predictable, easy to swap
+```
+
+## When to Use Each Storage System
+
+### S3 (AWS Simple Storage Service)
+
+**Best For:**
+
+- Cloud-native applications
+- Serverless workflows (Lambda, Versori)
+- Large datasets and data lakes
+- High availability requirements
+- Scalable storage needs
+- Public or presigned URL access
+
+**Advantages:**
+
+- ✅ Unlimited scalability
+- ✅ High durability (99.999999999%)
+- ✅ Low cost for large datasets
+- ✅ Presigned URLs for temporary access
+- ✅ Event notifications (S3 → Lambda)
+- ✅ No connection pooling needed
+
+**Disadvantages:**
+
+- ❌ Requires AWS account
+- ❌ Internet dependency
+- ❌ Per-request pricing model
+- ❌ No native "move" operation (copy + delete)
+
+**Use Case Examples:**
+
+```typescript
+// Data lake ingestion
+await s3.uploadFile('data-lake/orders/2025-01-15.parquet', parquetData);
+
+// Serverless processing
+const csvFiles = await s3.listFiles({ prefix: 'incoming/', maxKeys: 1000 });
+// Filter CSV files after listing (pattern matching not supported in S3 listFiles)
+const csvOnly = csvFiles.filter(f => f.name.endsWith('.csv'));
+
+// Presigned URL generation
+const url = await s3PresignService.generatePresignedDownloadUrl('report.pdf', 3600);
+```
+
+### SFTP (SSH File Transfer Protocol)
+
+**Best For:**
+
+- B2B integrations with partners
+- EDI system integrations
+- Secure file transfers
+- Compliance requirements (HIPAA, PCI-DSS)
+- Systems with existing SFTP infrastructure
+
+**Advantages:**
+
+- ✅ Industry standard for B2B
+- ✅ Strong encryption (SSH)
+- ✅ Widely supported
+- ✅ Native move/rename operations
+- ✅ Directory structure support
+- ✅ Username/password or key-based auth
+
+**Disadvantages:**
+
+- ❌ Connection management overhead
+- ❌ Requires server maintenance
+- ❌ Connection pooling complexity
+- ❌ Network latency sensitivity
+- ❌ Manual scaling
+
+**Use Case Examples:**
+
+```typescript
+// Partner file drop
+const partnerFiles = await sftp.listFiles(); // Pattern from config
+for (const file of partnerFiles) {
+  const content = await sftp.downloadFile(file.path);
+  await processPartnerData(content);
+  await sftp.moveFile(file.path, `/archive/${file.name}`);
+}
+
+// Compliance-required audit trail
+await sftp.uploadFile('/outgoing/audit-report.txt', reportData);
+```
+
+### Local Files
+
+**Best For:**
+
+- Development and testing
+- Single-machine scripts
+- Small datasets
+- Quick prototypes
+
+**Advantages:**
+
+- ✅ No external dependencies
+- ✅ Fast access
+- ✅ Simple setup
+
+**Disadvantages:**
+
+- ❌ Not scalable
+- ❌ No high availability
+- ❌ Single point of failure
+
+## Data Source Comparison
+
+| Feature                | S3            | SFTP               | Local Files         |
+| ---------------------- | ------------- | ------------------ | ------------------- |
+| **Scalability**        | Unlimited     | Limited by server  | Limited by disk     |
+| **Availability**       | 99.99% SLA    | Depends on server  | Single machine      |
+| **Cost**               | Pay per use   | Server + bandwidth | Infrastructure only |
+| **Setup Complexity**   | Medium        | High               | Low                 |
+| **B2B Integration**    | Rare          | Common             | N/A                 |
+| **Cloud-Native**       | Yes           | No                 | No                  |
+| **Connection Pooling** | N/A           | Required           | N/A                 |
+| **Move Operation**     | Copy + Delete | Native             | Native              |
+| **Presigned URLs**     | Yes           | No                 | No                  |
+
+## Unified Interface Pattern
+
+All data sources in the SDK implement a common interface with these core operations:
+
+### Core File Operations
+
+```typescript
+interface DataSource {
+  // List files matching criteria
+  listFiles(options?: ListOptions): Promise<FileInfo[]>;
+
+  // Read file content
+  downloadFile(path: string): Promise<string>;
+
+  // Write file content
+  uploadFile(path: string, content: string | Buffer): Promise<void>;
+
+  // Move file (rename or relocate)
+  moveFile(source: string, dest: string, createDirs?: boolean): Promise<void>;
+
+  // Copy file
+  copyFile(source: string, dest: string): Promise<void>;
+
+  // Delete file
+  deleteFile(path: string): Promise<void>;
+
+  // Check file existence
+  fileExists(path: string): Promise<boolean>;
+
+  // Clean up resources
+  dispose(): Promise<void>;
+}
+```
+
+### Benefits of Unified Interface
+
+1. **Portability**: Swap S3 for SFTP without code changes
+2. **Testability**: Mock data sources easily
+3. **Consistency**: Same method names, same error handling
+4. **Composability**: Build higher-level abstractions
+5. **Documentation**: Learn once, use everywhere
+
+## Common File Operation Patterns
+
+### Pattern 1: Read-Process-Archive
+
+The most common workflow in data integration:
+
+```typescript
+// 1. List files to process
+const files = await dataSource.listFiles();
+
+// 2. Process each file
+for (const file of files) {
+  // 2a. Read file
+  const content = await dataSource.downloadFile(file.path);
+
+  // 2b. Process data
+  await processData(content);
+
+  // 2c. Archive to prevent reprocessing
+  const archivePath = `/archive/${file.name}`;
+  await dataSource.moveFile(file.path, archivePath, true);
+}
+```
+
+### Pattern 2: Transform-and-Upload
+
+Process data and write to storage:
+
+```typescript
+// 1. Transform data
+const jsonData = await transformToJSON(sourceData);
+
+// 2. Upload result
+const outputPath = `output/${new Date().toISOString()}.json`;
+await dataSource.uploadFile(outputPath, JSON.stringify(jsonData));
+```
+
+### Pattern 3: Multi-Folder Processing
+
+Process files from multiple logical folders:
+
+```typescript
+const folders = ['orders', 'inventory', 'customers'];
+
+for (const folder of folders) {
+  const files = await dataSource.listFiles({ prefix: folder });
+
+  for (const file of files) {
+    const content = await dataSource.downloadFile(file.name);
+    await processByType(folder, content);
+  }
+}
+```
+
+### Pattern 4: Conditional Processing
+
+Only process files meeting certain criteria:
+
+```typescript
+const allFiles = await dataSource.listFiles();
+
+// Filter by file extension after listing
+const csvFiles = allFiles.filter(f => f.name.endsWith('.csv'));
+
+for (const file of csvFiles) {
+  // Only process files from today
+  if (file.name.includes(new Date().toISOString().split('T')[0])) {
+    const content = await dataSource.downloadFile(file.name);
+    await processData(content);
+  }
+}
+```
+
+## Key Concepts Summary
+
+### Data Source Abstraction
+
+- Provides unified interface across storage systems
+- Same methods work on S3, SFTP, local files
+- Eliminates vendor lock-in
+
+### Storage System Selection
+
+- **S3**: Cloud-native, scalable, serverless workflows
+- **SFTP**: B2B integrations, enterprise systems, compliance
+- **Local**: Development, testing, simple scripts
+
+### Common Operations
+
+- **List**: Find files to process
+- **Download**: Read file content
+- **Upload**: Write file content
+- **Move**: Archive or reorganize
+- **Copy**: Backup or duplicate
+- **Delete**: Clean up temporary files
+
+### Common Patterns
+
+- Read-Process-Archive (most common)
+- Transform-and-Upload
+- Multi-Folder Processing
+- Conditional Processing
+
+## Practice Exercise
+
+Try identifying which storage system to use:
+
+**Scenario 1**: You need to integrate with a retail partner who sends daily order files via their existing file transfer system.
+
+<details>
+<summary>Answer</summary>
+
+**SFTP** - B2B integrations typically use SFTP as the industry standard.
+
+</details>
+
+**Scenario 2**: You're building a serverless data pipeline on AWS Lambda that processes inventory updates from an S3 bucket.
+
+<details>
+<summary>Answer</summary>
+
+**S3** - Cloud-native, serverless workflows work best with S3.
+
+</details>
+
+**Scenario 3**: You're writing a one-time migration script to convert 100 CSV files on your laptop to JSON.
+
+<details>
+<summary>Answer</summary>
+
+**Local Files** - Simple, single-machine tasks don't need cloud storage.
+
+</details>
+
+## Key Takeaways
+
+- 🎯 Data sources provide a unified interface for file operations across storage systems
+- 🎯 Choose S3 for cloud-native scalability, SFTP for B2B integrations, local files for development
+- 🎯 The same methods work on all data sources: `downloadFile()`, `uploadFile()`, `moveFile()`, etc.
+- 🎯 Common patterns: Read-Process-Archive, Transform-and-Upload, Multi-Folder Processing
+- 🎯 Unified interface enables portability, testability, and consistency
+
+## Next Steps
+
+Continue to [Module 2: Quick Start](./file-operations-02-quick-start.md) to see working examples with S3 and SFTP.
+
+---
+
+**Related Resources:**
+
+- [Quick Reference](../../../02-CORE-GUIDES/advanced-services/advanced-services-quick-reference.md) - All operations cheat sheet
+- [S3 Operations](./file-operations-03-s3-operations.md) - Complete S3 guide
+- [SFTP Operations](./file-operations-04-sftp-operations.md) - Complete SFTP guide