@fluentcommerce/fc-connect-sdk 0.1.54 → 0.1.55

package/docs/03-PATTERN-GUIDES/multiple-connections/multiple-connections-readme.md

@@ -1,270 +1,270 @@
-# GraphQL Multi-Connection Pagination Guide
-
-> **Complete guide to handling multiple paginated GraphQL connections in the Fluent Connect SDK**
-> Progressive learning modules with real schema examples and production-ready patterns
-
-> **⚠️ Note:** This guide is about **GraphQL pagination** with multiple paginated fields in a single query (e.g., fetching both `products` and `locations`). It is **NOT** about multi-tenant connections, credential management, or managing multiple API connections. If you're looking for multi-tenant or credential management, see the [Authentication Guide](../../02-CORE-GUIDES/api-reference/modules/api-reference-03-authentication.md).
-
-**Key Concept:** When your GraphQL query requests multiple paginated fields (connections), the SDK can only auto-paginate ONE at a time. This guide shows you how to handle this limitation.
-
-## 📚 What You'll Learn
-
-This guide teaches you how to handle queries with **multiple paginated GraphQL connections** using the SDK's auto-pagination feature. By the end, you'll understand:
-
-- ✅ How to target specific connections with `connectionPath`
-- ✅ When and how to use parallel queries for multiple connections
-- ✅ How to work with nested connections using dot notation
-- ✅ Best practices for multi-connection scenarios
-- ✅ How to monitor and optimize performance for complex queries
-
-## 🎯 Learning Path Overview
-
-This guide is organized into **6 progressive modules**. Follow them in order for the best learning experience:
-
-| Module | Topic | Level |
-|--------|-------|-------|
-| [Module 1](./modules/multiple-connections-01-foundations.md) | **Foundations** - Understanding multiple connections | Beginner |
-| [Module 2](./modules/multiple-connections-02-quick-start.md) | **Quick Start** - Your first multi-connection query | Beginner |
-| [Module 3](./modules/multiple-connections-03-targeting-connections.md) | **Targeting Connections** - Using connectionPath | Intermediate |
-| [Module 4](./modules/multiple-connections-04-parallel-queries.md) | **Parallel Queries** - Simultaneous pagination workaround | Advanced |
-| [Module 5](./modules/multiple-connections-05-best-practices.md) | **Best Practices** - Production patterns and optimization | Advanced |
-| [Module 6](./modules/multiple-connections-06-api-reference.md) | **API Reference** - Complete interface documentation | Reference |
-
-## 🚀 Quick Navigation
-
-### By Use Case
-
-- **First time with multiple connections?** → Start with [Module 1: Foundations](./modules/multiple-connections-01-foundations.md)
-- **Need a working example now?** → Jump to [Module 2: Quick Start](./modules/multiple-connections-02-quick-start.md)
-- **Want to paginate all connections?** → See [Module 4: Parallel Queries](./modules/multiple-connections-04-parallel-queries.md)
-- **Need specific config option?** → Check [Module 6: API Reference](./modules/multiple-connections-06-api-reference.md)
-- **Want code examples?** → Browse [Examples Directory](./examples/)
-
-### By Scenario Type
-
-Different multi-connection scenarios require different approaches:
-
-| Scenario | Complexity | Approach | Example |
-|----------|------------|----------|---------|
-| Single connection targeted | Simple | Use `connectionPath` | [Example](./examples/common-patterns.ts) |
-| Multiple root connections | Medium | Parallel queries | [Example](./examples/parallel-root-connections.ts) |
-| Nested connections | Medium | Dot notation path | [Example](./examples/common-patterns.ts) |
-| Bulk export (3+ connections) | Complex | Promise.all pattern | [Example](./examples/parallel-root-connections.ts) |
-
-## 📖 Quick Reference
-
-For quick lookups, see:
-- [Quick Reference Cheat Sheet](../../02-CORE-GUIDES/advanced-services/advanced-services-quick-reference.md) - All patterns on one page
-- [Common Patterns](./examples/common-patterns.ts) - Copy-paste ready snippets
-- [Troubleshooting Guide](./modules/multiple-connections-05-best-practices.md#troubleshooting) - Error messages and fixes
-
-## 🎓 Prerequisites
-
-Before starting this guide, you should:
-
-1. ✅ Have the SDK installed: `npm install @fluentcommerce/fc-connect-sdk@latest`
-2. ✅ Have Fluent API credentials (clientId, clientSecret, retailerId)
-3. ✅ Understand basic auto-pagination concepts
-4. ✅ Be familiar with GraphQL connection patterns
-
-**SDK Version:** Version 0.1.23+ - `npm install @fluentcommerce/fc-connect-sdk@latest`
-
-**New to auto-pagination?** Start with the [Auto-Pagination Guide](../../02-CORE-GUIDES/auto-pagination/auto-pagination-readme.md) first.
-
-## 🔍 Key Concepts at a Glance
-
-### Quick Answer: Can I paginate multiple connections?
-
-**Partially YES!**
-
-```typescript
-// ✅ One connection per query - Use connectionPath
-const result = await client.graphql({
-  query: multiConnectionQuery,
-  variables: { productsFirst: 50, locationsFirst: 10 },
-  pagination: {
-    connectionPath: 'products',  // ← Only products paginated
-    maxPages: 5
-  }
-});
-// Result: products (250 records), locations (10 records - first page only)
-
-// ✅ Multiple connections - Use parallel queries
-const [products, locations] = await Promise.all([
-  client.graphql({
-    query: productsQuery,
-    pagination: { maxPages: 10 }
-  }),
-  client.graphql({
-    query: locationsQuery,
-    pagination: { maxPages: 5 }
-  })
-]);
-// Result: Both fully paginated independently
-
-// ❌ Multiple connections simultaneously - Not supported
-pagination: {
-  connectionPath: ['products', 'locations']  // ← Not supported (yet)
-}
-```
-
-### Current Behavior Summary
-
-| Scenario | Supported | How |
-|----------|-----------|-----|
-| Single connection | ✅ YES | Auto-detected or use `connectionPath` |
-| Multiple connections (one paginated) | ✅ YES | Use `connectionPath` to target one |
-| Multiple connections (all paginated) | ❌ NO | Use parallel queries with `Promise.all()` |
-| Nested connections | ✅ YES | Use dot notation: `"order.items"` |
-
-### Why This Design?
-
-Auto-pagination targets **ONE connection per query** because:
-- **Cursor independence** - Different connections may complete at different pages
-- **Complexity** - Parallel pagination requires complex state management
-- **Clarity** - Single-target design is predictable and debuggable
-- **Workaround exists** - Parallel queries provide full control
-
-## 🛠️ Complete Example
-
-Here's a real-world multi-connection scenario:
-
-```typescript
-import { createClient } from '@fluentcommerce/fc-connect-sdk';
-
-// Standalone Node.js/Deno
-const client = await createClient({
-  config: {
-    baseUrl: process.env.FLUENT_BASE_URL!,
-    clientId: process.env.FLUENT_CLIENT_ID!,
-    clientSecret: process.env.FLUENT_CLIENT_SECRET!,
-    username: process.env.FLUENT_USERNAME!,
-    password: process.env.FLUENT_PASSWORD!,
-    retailerId: process.env.FLUENT_RETAILER_ID!
-  }
-});
-
-// OR Versori Platform (auto-detected)
-const client = await createClient(ctx); // Auto-detects Versori context
-
-// ✅ OPTION 1: Target one connection (products only)
-const singleTargetResult = await client.graphql({
-  query: `
-    query GetMultiple($productsFirst: Int!, $productsAfter: String, $locationsFirst: Int!) {
-      products(first: $productsFirst, after: $productsAfter) {
-        edges {
-          node { id ref type }
-          cursor
-        }
-        pageInfo { hasNextPage }
-      }
-      locations(first: $locationsFirst) {
-        edges {
-          node { id name }
-          cursor
-        }
-        pageInfo { hasNextPage }
-      }
-    }
-  `,
-  variables: { productsFirst: 50, locationsFirst: 10 },
-  pagination: {
-    connectionPath: 'products',  // Only products paginated
-    maxPages: 5
-  }
-});
-
-console.log(`Products: ${singleTargetResult.data.products.edges.length} (paginated)`);
-console.log(`Locations: ${singleTargetResult.data.locations.edges.length} (first page only)`);
-
-// ✅ OPTION 2: Parallel queries (both fully paginated)
-const [productsResult, locationsResult] = await Promise.all([
-  client.graphql({
-    query: `
-      query GetProducts($first: Int!, $after: String) {
-        products(first: $first, after: $after) {
-          edges {
-            node { id ref type }
-            cursor
-          }
-          pageInfo { hasNextPage }
-        }
-      }
-    `,
-    variables: { first: 100 },
-    pagination: { maxPages: 10 }
-  }),
-  client.graphql({
-    query: `
-      query GetLocations($first: Int!, $after: String) {
-        locations(first: $first, after: $after) {
-          edges {
-            node { id name }
-            cursor
-          }
-          pageInfo { hasNextPage }
-        }
-      }
-    `,
-    variables: { first: 50 },
-    pagination: { maxPages: 5 }
-  })
-]);
-
-console.log(`Products: ${productsResult.extensions.autoPagination.totalRecords} (fully paginated)`);
-console.log(`Locations: ${locationsResult.extensions.autoPagination.totalRecords} (fully paginated)`);
-```
-
-## 📂 Repository Structure
-
-```
-docs/guides/multiple-connections/
-├── readme.md                          # This file - main index
-├── quick-reference.md                 # Cheat sheet for quick lookups
-│
-├── modules/                           # Learning modules
-│   ├── 01-foundations.md              # Understanding multiple connections
-│   ├── 02-quick-start.md              # First working example
-│   ├── 03-targeting-connections.md    # Using connectionPath
-│   ├── 04-parallel-queries.md         # Promise.all patterns
-│   ├── 05-best-practices.md           # Production patterns
-│   └── 06-api-reference.md            # Complete API docs
-│
-└── examples/                          # Verified code examples
-    ├── readme.md                      # Examples index
-    ├── common-patterns.ts             # Copy-paste ready patterns
-    ├── single-connection-targeted.ts  # Using connectionPath
-    ├── auto-detection.ts              # Without connectionPath
-    ├── nested-connection-path.ts      # Dot notation for nested
-    ├── parallel-root-connections.ts   # Promise.all basic
-    ├── bulk-export-parallel.ts        # 3+ connections
-    ├── sequential-processing.ts       # Sequential approach
-    └── real-world-scenarios.ts        # Production examples
-```
-
-## 🔗 Related Documentation
-
-- [Auto-Pagination Guide](../../02-CORE-GUIDES/auto-pagination/auto-pagination-readme.md) - Core pagination concepts
-- [SDK Architecture](../../04-REFERENCE/architecture/) - Understanding SDK design
-- [Getting Started](../../00-START-HERE/getting-started.md) - SDK setup and installation
-- [Fluent API Documentation](https://docs.fluentcommerce.com/) - Official API docs
-
-## 💡 Tips for Best Results
-
-1. **Always use `connectionPath`** - Be explicit when multiple connections exist
-2. **Prefer parallel queries** - When all connections need full pagination
-3. **Use dot notation** - For nested connections like `"order.items"`
-4. **Monitor each connection** - Use separate `onProgress` callbacks
-5. **Test limits first** - Start with small `maxPages` to verify behavior
-
-## 🚦 Getting Started
-
-Ready to begin? Start with [Module 1: Foundations →](./modules/multiple-connections-01-foundations.md)
-
----
-
-**Need Help?**
-- 📖 Browse [Examples](./examples/)
-- 🔍 Check [Best Practices](./modules/multiple-connections-05-best-practices.md)
-- 📧 Contact support@fluentcommerce.com
-- 🐛 Report issues at [GitHub](https://github.com/fluentcommerce/fc-connect-sdk/issues)
+# GraphQL Multi-Connection Pagination Guide
+
+> **Complete guide to handling multiple paginated GraphQL connections in the Fluent Connect SDK**
+> Progressive learning modules with real schema examples and production-ready patterns
+
+> **⚠️ Note:** This guide is about **GraphQL pagination** with multiple paginated fields in a single query (e.g., fetching both `products` and `locations`). It is **NOT** about multi-tenant connections, credential management, or managing multiple API connections. If you're looking for multi-tenant or credential management, see the [Authentication Guide](../../02-CORE-GUIDES/api-reference/modules/api-reference-03-authentication.md).
+
+**Key Concept:** When your GraphQL query requests multiple paginated fields (connections), the SDK can only auto-paginate ONE at a time. This guide shows you how to handle this limitation.
+
+## 📚 What You'll Learn
+
+This guide teaches you how to handle queries with **multiple paginated GraphQL connections** using the SDK's auto-pagination feature. By the end, you'll understand:
+
+- ✅ How to target specific connections with `connectionPath`
+- ✅ When and how to use parallel queries for multiple connections
+- ✅ How to work with nested connections using dot notation
+- ✅ Best practices for multi-connection scenarios
+- ✅ How to monitor and optimize performance for complex queries
+
+## 🎯 Learning Path Overview
+
+This guide is organized into **6 progressive modules**. Follow them in order for the best learning experience:
+
+| Module | Topic | Level |
+|--------|-------|-------|
+| [Module 1](./modules/multiple-connections-01-foundations.md) | **Foundations** - Understanding multiple connections | Beginner |
+| [Module 2](./modules/multiple-connections-02-quick-start.md) | **Quick Start** - Your first multi-connection query | Beginner |
+| [Module 3](./modules/multiple-connections-03-targeting-connections.md) | **Targeting Connections** - Using connectionPath | Intermediate |
+| [Module 4](./modules/multiple-connections-04-parallel-queries.md) | **Parallel Queries** - Simultaneous pagination workaround | Advanced |
+| [Module 5](./modules/multiple-connections-05-best-practices.md) | **Best Practices** - Production patterns and optimization | Advanced |
+| [Module 6](./modules/multiple-connections-06-api-reference.md) | **API Reference** - Complete interface documentation | Reference |
+
+## 🚀 Quick Navigation
+
+### By Use Case
+
+- **First time with multiple connections?** → Start with [Module 1: Foundations](./modules/multiple-connections-01-foundations.md)
+- **Need a working example now?** → Jump to [Module 2: Quick Start](./modules/multiple-connections-02-quick-start.md)
+- **Want to paginate all connections?** → See [Module 4: Parallel Queries](./modules/multiple-connections-04-parallel-queries.md)
+- **Need specific config option?** → Check [Module 6: API Reference](./modules/multiple-connections-06-api-reference.md)
+- **Want code examples?** → Browse [Examples Directory](./examples/)
+
+### By Scenario Type
+
+Different multi-connection scenarios require different approaches:
+
+| Scenario | Complexity | Approach | Example |
+|----------|------------|----------|---------|
+| Single connection targeted | Simple | Use `connectionPath` | [Example](./examples/common-patterns.ts) |
+| Multiple root connections | Medium | Parallel queries | [Example](./examples/parallel-root-connections.ts) |
+| Nested connections | Medium | Dot notation path | [Example](./examples/common-patterns.ts) |
+| Bulk export (3+ connections) | Complex | Promise.all pattern | [Example](./examples/parallel-root-connections.ts) |
+
+## 📖 Quick Reference
+
+For quick lookups, see:
+- [Quick Reference Cheat Sheet](../../02-CORE-GUIDES/advanced-services/advanced-services-quick-reference.md) - All patterns on one page
+- [Common Patterns](./examples/common-patterns.ts) - Copy-paste ready snippets
+- [Troubleshooting Guide](./modules/multiple-connections-05-best-practices.md#troubleshooting) - Error messages and fixes
+
+## 🎓 Prerequisites
+
+Before starting this guide, you should:
+
+1. ✅ Have the SDK installed: `npm install @fluentcommerce/fc-connect-sdk@latest`
+2. ✅ Have Fluent API credentials (clientId, clientSecret, retailerId)
+3. ✅ Understand basic auto-pagination concepts
+4. ✅ Be familiar with GraphQL connection patterns
+
+**SDK Version:** Version 0.1.23+ - `npm install @fluentcommerce/fc-connect-sdk@latest`
+
+**New to auto-pagination?** Start with the [Auto-Pagination Guide](../../02-CORE-GUIDES/auto-pagination/auto-pagination-readme.md) first.
+
+## 🔍 Key Concepts at a Glance
+
+### Quick Answer: Can I paginate multiple connections?
+
+**Partially YES!**
+
+```typescript
+// ✅ One connection per query - Use connectionPath
+const result = await client.graphql({
+  query: multiConnectionQuery,
+  variables: { productsFirst: 50, locationsFirst: 10 },
+  pagination: {
+    connectionPath: 'products',  // ← Only products paginated
+    maxPages: 5
+  }
+});
+// Result: products (250 records), locations (10 records - first page only)
+
+// ✅ Multiple connections - Use parallel queries
+const [products, locations] = await Promise.all([
+  client.graphql({
+    query: productsQuery,
+    pagination: { maxPages: 10 }
+  }),
+  client.graphql({
+    query: locationsQuery,
+    pagination: { maxPages: 5 }
+  })
+]);
+// Result: Both fully paginated independently
+
+// ❌ Multiple connections simultaneously - Not supported
+pagination: {
+  connectionPath: ['products', 'locations']  // ← Not supported (yet)
+}
+```
+
+### Current Behavior Summary
+
+| Scenario | Supported | How |
+|----------|-----------|-----|
+| Single connection | ✅ YES | Auto-detected or use `connectionPath` |
+| Multiple connections (one paginated) | ✅ YES | Use `connectionPath` to target one |
+| Multiple connections (all paginated) | ❌ NO | Use parallel queries with `Promise.all()` |
+| Nested connections | ✅ YES | Use dot notation: `"order.items"` |
+
+### Why This Design?
+
+Auto-pagination targets **ONE connection per query** because:
+- **Cursor independence** - Different connections may complete at different pages
+- **Complexity** - Parallel pagination requires complex state management
+- **Clarity** - Single-target design is predictable and debuggable
+- **Workaround exists** - Parallel queries provide full control
+
+## 🛠️ Complete Example
+
+Here's a real-world multi-connection scenario:
+
+```typescript
+import { createClient } from '@fluentcommerce/fc-connect-sdk';
+
+// Standalone Node.js/Deno
+const client = await createClient({
+  config: {
+    baseUrl: process.env.FLUENT_BASE_URL!,
+    clientId: process.env.FLUENT_CLIENT_ID!,
+    clientSecret: process.env.FLUENT_CLIENT_SECRET!,
+    username: process.env.FLUENT_USERNAME!,
+    password: process.env.FLUENT_PASSWORD!,
+    retailerId: process.env.FLUENT_RETAILER_ID!
+  }
+});
+
+// OR Versori Platform (auto-detected)
+const client = await createClient(ctx); // Auto-detects Versori context
+
+// ✅ OPTION 1: Target one connection (products only)
+const singleTargetResult = await client.graphql({
+  query: `
+    query GetMultiple($productsFirst: Int!, $productsAfter: String, $locationsFirst: Int!) {
+      products(first: $productsFirst, after: $productsAfter) {
+        edges {
+          node { id ref type }
+          cursor
+        }
+        pageInfo { hasNextPage }
+      }
+      locations(first: $locationsFirst) {
+        edges {
+          node { id name }
+          cursor
+        }
+        pageInfo { hasNextPage }
+      }
+    }
+  `,
+  variables: { productsFirst: 50, locationsFirst: 10 },
+  pagination: {
+    connectionPath: 'products',  // Only products paginated
+    maxPages: 5
+  }
+});
+
+console.log(`Products: ${singleTargetResult.data.products.edges.length} (paginated)`);
+console.log(`Locations: ${singleTargetResult.data.locations.edges.length} (first page only)`);
+
+// ✅ OPTION 2: Parallel queries (both fully paginated)
+const [productsResult, locationsResult] = await Promise.all([
+  client.graphql({
+    query: `
+      query GetProducts($first: Int!, $after: String) {
+        products(first: $first, after: $after) {
+          edges {
+            node { id ref type }
+            cursor
+          }
+          pageInfo { hasNextPage }
+        }
+      }
+    `,
+    variables: { first: 100 },
+    pagination: { maxPages: 10 }
+  }),
+  client.graphql({
+    query: `
+      query GetLocations($first: Int!, $after: String) {
+        locations(first: $first, after: $after) {
+          edges {
+            node { id name }
+            cursor
+          }
+          pageInfo { hasNextPage }
+        }
+      }
+    `,
+    variables: { first: 50 },
+    pagination: { maxPages: 5 }
+  })
+]);
+
+console.log(`Products: ${productsResult.extensions.autoPagination.totalRecords} (fully paginated)`);
+console.log(`Locations: ${locationsResult.extensions.autoPagination.totalRecords} (fully paginated)`);
+```
+
+## 📂 Repository Structure
+
+```
+docs/guides/multiple-connections/
+├── readme.md                          # This file - main index
+├── quick-reference.md                 # Cheat sheet for quick lookups
+│
+├── modules/                           # Learning modules
+│   ├── 01-foundations.md              # Understanding multiple connections
+│   ├── 02-quick-start.md              # First working example
+│   ├── 03-targeting-connections.md    # Using connectionPath
+│   ├── 04-parallel-queries.md         # Promise.all patterns
+│   ├── 05-best-practices.md           # Production patterns
+│   └── 06-api-reference.md            # Complete API docs
+│
+└── examples/                          # Verified code examples
+    ├── readme.md                      # Examples index
+    ├── common-patterns.ts             # Copy-paste ready patterns
+    ├── single-connection-targeted.ts  # Using connectionPath
+    ├── auto-detection.ts              # Without connectionPath
+    ├── nested-connection-path.ts      # Dot notation for nested
+    ├── parallel-root-connections.ts   # Promise.all basic
+    ├── bulk-export-parallel.ts        # 3+ connections
+    ├── sequential-processing.ts       # Sequential approach
+    └── real-world-scenarios.ts        # Production examples
+```
+
+## 🔗 Related Documentation
+
+- [Auto-Pagination Guide](../../02-CORE-GUIDES/auto-pagination/auto-pagination-readme.md) - Core pagination concepts
+- [SDK Architecture](../../04-REFERENCE/architecture/) - Understanding SDK design
+- [Getting Started](../../00-START-HERE/getting-started.md) - SDK setup and installation
+- [Fluent API Documentation](https://docs.fluentcommerce.com/) - Official API docs
+
+## 💡 Tips for Best Results
+
+1. **Always use `connectionPath`** - Be explicit when multiple connections exist
+2. **Prefer parallel queries** - When all connections need full pagination
+3. **Use dot notation** - For nested connections like `"order.items"`
+4. **Monitor each connection** - Use separate `onProgress` callbacks
+5. **Test limits first** - Start with small `maxPages` to verify behavior
+
+## 🚦 Getting Started
+
+Ready to begin? Start with [Module 1: Foundations →](./modules/multiple-connections-01-foundations.md)
+
+---
+
+**Need Help?**
+- 📖 Browse [Examples](./examples/)
+- 🔍 Check [Best Practices](./modules/multiple-connections-05-best-practices.md)
+- 📧 Contact support@fluentcommerce.com
+- 🐛 Report issues at [GitHub](https://github.com/fluentcommerce/fc-connect-sdk/issues)

package/docs/03-PATTERN-GUIDES/multiple-connections/readme.md

@@ -1,30 +1,30 @@
-# Multiple Connections Guide
-
-> **Manage multiple Fluent Commerce connections**
-> Multi-retailer and multi-environment patterns
-
-For complete documentation, see [multiple-connections-readme.md](./multiple-connections-readme.md)
-
-## Overview
-
-This guide covers patterns for managing multiple Fluent Commerce connections, including multi-retailer integrations, multi-environment deployments, and parallel queries.
-
-## Navigation
-
-- [Complete Documentation](./multiple-connections-readme.md) - Full guide
-- [Quick Reference](./multiple-connections-quick-reference.md) - Cheat sheet
-- [Modules](./modules/) - Progressive learning modules
-- [Examples](./examples/) - Code examples
-
-## Learning Path
-
-| Module | Topic | Level |
-|--------|-------|-------|
-| [Module 1](./modules/multiple-connections-01-foundations.md) | Foundations | Beginner |
-| [Module 2](./modules/multiple-connections-02-quick-start.md) | Quick Start | Beginner |
-| [Module 3](./modules/multiple-connections-03-targeting-connections.md) | Targeting Connections | Intermediate |
-| [Module 4](./modules/multiple-connections-04-parallel-queries.md) | Parallel Queries | Advanced |
-| [Module 5](./modules/multiple-connections-05-best-practices.md) | Best Practices | Intermediate |
-| [Module 6](./modules/multiple-connections-06-api-reference.md) | API Reference | Reference |
-
-See [multiple-connections-readme.md](./multiple-connections-readme.md) for complete details.
+# Multiple Connections Guide
+
+> **Manage multiple Fluent Commerce connections**
+> Multi-retailer and multi-environment patterns
+
+For complete documentation, see [multiple-connections-readme.md](./multiple-connections-readme.md)
+
+## Overview
+
+This guide covers patterns for managing multiple Fluent Commerce connections, including multi-retailer integrations, multi-environment deployments, and parallel queries.
+
+## Navigation
+
+- [Complete Documentation](./multiple-connections-readme.md) - Full guide
+- [Quick Reference](./multiple-connections-quick-reference.md) - Cheat sheet
+- [Modules](./modules/) - Progressive learning modules
+- [Examples](./examples/) - Code examples
+
+## Learning Path
+
+| Module | Topic | Level |
+|--------|-------|-------|
+| [Module 1](./modules/multiple-connections-01-foundations.md) | Foundations | Beginner |
+| [Module 2](./modules/multiple-connections-02-quick-start.md) | Quick Start | Beginner |
+| [Module 3](./modules/multiple-connections-03-targeting-connections.md) | Targeting Connections | Intermediate |
+| [Module 4](./modules/multiple-connections-04-parallel-queries.md) | Parallel Queries | Advanced |
+| [Module 5](./modules/multiple-connections-05-best-practices.md) | Best Practices | Intermediate |
+| [Module 6](./modules/multiple-connections-06-api-reference.md) | API Reference | Reference |
+
+See [multiple-connections-readme.md](./multiple-connections-readme.md) for complete details.

package/docs/03-PATTERN-GUIDES/pagination/pagination-readme.md

@@ -1,14 +1,14 @@
-# Pagination Patterns
-
-Pagination documentation has been moved to:
-
-**📍 [Auto-Pagination Guide](../../02-CORE-GUIDES/auto-pagination/auto-pagination-readme.md)**
-
-This comprehensive guide covers:
-- Forward pagination (`first`/`after`)
-- Backward pagination (`last`/`before`)
-- Cursor selection logic
-- Query requirements
-- Complete examples
-
-For pattern-specific examples, see the auto-pagination modules directory.
+# Pagination Patterns
+
+Pagination documentation has been moved to:
+
+**📍 [Auto-Pagination Guide](../../02-CORE-GUIDES/auto-pagination/auto-pagination-readme.md)**
+
+This comprehensive guide covers:
+- Forward pagination (`first`/`after`)
+- Backward pagination (`last`/`before`)
+- Cursor selection logic
+- Query requirements
+- Complete examples
+
+For pattern-specific examples, see the auto-pagination modules directory.