@fluentcommerce/fc-connect-sdk 0.1.54 → 0.1.56

package/docs/04-REFERENCE/resolver-signature/examples/async-resolvers.ts

@@ -1,496 +1,496 @@
-/**
- * Async Resolver Examples
- *
- * Async resolvers that perform API calls, enrichment, and async operations.
- * Demonstrates error handling, retries, and performance patterns.
- */
-
-import type { FieldResolverFunction } from '@fluentcommerce/fc-connect-sdk';
-
-/**
- * Collection of async resolvers with API calls and error handling
- */
-export const asyncResolvers: Record<string, FieldResolverFunction> = {
-  // ===== BASIC ASYNC ENRICHMENT =====
-
-  /**
-   * Enrich product data from Fluent Commerce API
-   *
-   * Config options:
-   * - enableEnrichment: Whether to perform enrichment
-   */
-  'custom.enrichWithProduct': async (sku, sourceData, config, helpers) => {
-    if (!helpers.fluentClient) {
-      helpers.log.warn('FluentClient not available, skipping enrichment');
-      return { sku };
-    }
-
-    if (!config?.enableEnrichment) {
-      return { sku };
-    }
-
-    try {
-      const result = await helpers.fluentClient.graphql({
-        query: `
-          query GetProduct($ref: String!) {
-            product(ref: $ref) {
-              id
-              ref
-              name
-              gtin
-              status
-              attributes {
-                name
-                value
-              }
-            }
-          }
-        `,
-        variables: { ref: sku }
-      });
-
-      if (!result.data?.product) {
-        helpers.log.warn(`Product not found: ${sku}`);
-        return { sku, found: false };
-      }
-
-      return {
-        sku,
-        found: true,
-        ...result.data.product
-      };
-
-    } catch (error) {
-      helpers.log.error(`Failed to fetch product ${sku}`, error);
-      return { sku, error: (error as Error).message };
-    }
-  },
-
-  /**
-   * Enrich customer data from Fluent Commerce API
-   */
-  'custom.enrichWithCustomer': async (customerId, sourceData, config, helpers) => {
-    if (!helpers.fluentClient) {
-      helpers.log.warn('FluentClient not available');
-      return customerId;
-    }
-
-    try {
-      const result = await helpers.fluentClient.graphql({
-        query: `
-          query GetCustomer($id: ID!) {
-            customer(id: $id) {
-              id
-              firstName
-              lastName
-              email
-              tier
-              status
-            }
-          }
-        `,
-        variables: { id: customerId }
-      });
-
-      return result.data?.customer || { id: customerId, found: false };
-
-    } catch (error) {
-      helpers.log.error(`Customer lookup failed: ${customerId}`, error);
-      return { id: customerId, error: (error as Error).message };
-    }
-  },
-
-  // ===== ASYNC WITH RETRY PATTERN =====
-
-  /**
-   * Fetch data with automatic retry on failure
-   *
-   * Config options:
-   * - maxRetries: Maximum retry attempts (default: 3)
-   * - retryDelay: Delay between retries in ms (default: 1000)
-   */
-  'custom.fetchWithRetry': async (id, sourceData, config, helpers) => {
-    if (!helpers.fluentClient) {
-      return null;
-    }
-
-    const maxRetries = config?.maxRetries || 3;
-    const retryDelay = config?.retryDelay || 1000;
-
-    const fetchData = async () => {
-      const result = await helpers.fluentClient.graphql({
-        query: `query { data(id: "${id}") { value } }`
-      });
-
-      if (!result.data) {
-        throw new Error('No data returned');
-      }
-
-      return result.data;
-    };
-
-    try {
-      return await helpers.retry(fetchData, {
-        maxAttempts: maxRetries,
-        delayMs: retryDelay,
-        backoffMultiplier: 2
-      });
-    } catch (error) {
-      helpers.log.error(`Failed after ${maxRetries} retries`, error);
-      return null;
-    }
-  },
-
-  // ===== MEMOIZED ASYNC OPERATIONS =====
-
-  /**
-   * Lookup customer with memoization (cached results)
-   */
-  'custom.lookupCustomer': async (customerId, sourceData, config, helpers) => {
-    // Create memoized version of the lookup function
-    const memoizedLookup = helpers.memoize(
-      async (id: string) => {
-        if (!helpers.fluentClient) {
-          return null;
-        }
-
-        try {
-          const result = await helpers.fluentClient.graphql({
-            query: `
-              query GetCustomer($id: ID!) {
-                customer(id: $id) {
-                  id
-                  firstName
-                  lastName
-                  email
-                  tier
-                }
-              }
-            `,
-            variables: { id }
-          });
-
-          return result.data?.customer;
-        } catch (error) {
-          helpers.log.error(`Customer lookup failed: ${id}`, error);
-          return null;
-        }
-      },
-      (id) => id // Memoization key function
-    );
-
-    return await memoizedLookup(customerId);
-  },
-
-  // ===== BATCH PROCESSING =====
-
-  /**
-   * Enrich multiple items in batches
-   *
-   * Config options:
-   * - batchSize: Number of items to process per batch (default: 10)
-   */
-  'custom.batchEnrichItems': async (items, sourceData, config, helpers) => {
-    if (!helpers.fluentClient) {
-      return items;
-    }
-
-    const arr = helpers.ensureArray(items);
-    const batchSize = config?.batchSize || 10;
-
-    try {
-      const results = await helpers.batchProcess(
-        arr,
-        async (batch) => {
-          const promises = batch.map(item =>
-            helpers.fluentClient.graphql({
-              query: `
-                query GetProduct($ref: String!) {
-                  product(ref: $ref) {
-                    id
-                    name
-                    gtin
-                  }
-                }
-              `,
-              variables: { ref: item.sku }
-            })
-          );
-
-          return await Promise.all(promises);
-        },
-        batchSize
-      );
-
-      return results.flat().map(r => r.data?.product);
-
-    } catch (error) {
-      helpers.log.error('Batch enrichment failed', error);
-      return items;
-    }
-  },
-
-  // ===== ERROR HANDLING PATTERNS =====
-
-  /**
-   * Fetch with graceful degradation
-   */
-  'custom.fetchWithFallback': async (id, sourceData, config, helpers) => {
-    if (!helpers.fluentClient) {
-      return config?.fallbackValue || { id };
-    }
-
-    try {
-      const result = await helpers.fluentClient.graphql({
-        query: `query { data(id: "${id}") { id name value } }`
-      });
-
-      if (!result.data || !result.data.data) {
-        throw new Error('No data returned');
-      }
-
-      return result.data.data;
-
-    } catch (error) {
-      helpers.log.error(`Fetch failed, using fallback`, error);
-      return config?.fallbackValue || { id, error: 'Fetch failed' };
-    }
-  },
-
-  /**
-   * Validate data before async operation
-   */
-  'custom.validateAndFetch': async (id, sourceData, config, helpers) => {
-    // Pre-flight validation
-    if (!id || String(id).trim() === '') {
-      helpers.log.error('Invalid ID for fetch');
-      return null;
-    }
-
-    if (!helpers.fluentClient) {
-      helpers.log.error('FluentClient not configured');
-      return null;
-    }
-
-    // Perform fetch
-    try {
-      const result = await helpers.fluentClient.graphql({
-        query: `query { data(id: "${id}") { value } }`
-      });
-
-      // Post-fetch validation
-      if (!result.data || !result.data.data) {
-        helpers.log.warn(`No data found for ID: ${id}`);
-        return null;
-      }
-
-      return result.data.data;
-
-    } catch (error) {
-      helpers.log.error(`Fetch failed for ID: ${id}`, error);
-      return null;
-    }
-  },
-
-  // ===== PARALLEL ASYNC OPERATIONS =====
-
-  /**
-   * Enrich with data from multiple sources in parallel
-   */
-  'custom.enrichWithMultipleSources': async (id, sourceData, config, helpers) => {
-    if (!helpers.fluentClient) {
-      return { id };
-    }
-
-    try {
-      // Fetch from multiple sources in parallel
-      const [product, inventory, pricing] = await Promise.all([
-        helpers.fluentClient.graphql({
-          query: `query { product(id: "${id}") { name gtin } }`
-        }),
-        helpers.fluentClient.graphql({
-          query: `query { inventoryPosition(id: "${id}") { qty status } }`
-        }),
-        helpers.fluentClient.graphql({
-          query: `query { price(productId: "${id}") { value currency } }`
-        })
-      ]);
-
-      return {
-        id,
-        product: product.data?.product,
-        inventory: inventory.data?.inventoryPosition,
-        pricing: pricing.data?.price
-      };
-
-    } catch (error) {
-      helpers.log.error('Multi-source enrichment failed', error);
-      return { id, error: (error as Error).message };
-    }
-  },
-
-  // ===== CONDITIONAL ASYNC OPERATIONS =====
-
-  /**
-   * Conditionally enrich based on sourceData and config
-   *
-   * Config options:
-   * - enrichmentRules: Rules for when to enrich
-   */
-  'custom.conditionalEnrich': async (value, sourceData, config, helpers) => {
-    // Check if enrichment should be performed
-    const rules = config?.enrichmentRules || {};
-
-    const shouldEnrich =
-      rules.always ||
-      (rules.ifHighValue && helpers.get(sourceData, 'totalValue', 0) > 1000) ||
-      (rules.ifPremiumTier && helpers.get(sourceData, 'customer.tier') === 'platinum');
-
-    if (!shouldEnrich) {
-      helpers.log.debug('Skipping enrichment based on rules');
-      return value;
-    }
-
-    if (!helpers.fluentClient) {
-      return value;
-    }
-
-    try {
-      const result = await helpers.fluentClient.graphql({
-        query: `query { enrichData(value: "${value}") { enriched } }`
-      });
-
-      return result.data?.enrichData || value;
-
-    } catch (error) {
-      helpers.log.error('Conditional enrichment failed', error);
-      return value;
-    }
-  },
-
-  // ===== TIMEOUT HANDLING =====
-
-  /**
-   * Fetch with timeout
-   *
-   * Config options:
-   * - timeout: Timeout in milliseconds (default: 5000)
-   */
-  'custom.fetchWithTimeout': async (id, sourceData, config, helpers) => {
-    if (!helpers.fluentClient) {
-      return null;
-    }
-
-    const timeout = config?.timeout || 5000;
-
-    const fetchPromise = helpers.fluentClient.graphql({
-      query: `query { data(id: "${id}") { value } }`
-    });
-
-    const timeoutPromise = new Promise((_, reject) =>
-      setTimeout(() => reject(new Error('Timeout')), timeout)
-    );
-
-    try {
-      const result = await Promise.race([fetchPromise, timeoutPromise]);
-      return (result as any).data?.data;
-
-    } catch (error) {
-      if ((error as Error).message === 'Timeout') {
-        helpers.log.error(`Fetch timed out after ${timeout}ms`);
-      } else {
-        helpers.log.error('Fetch failed', error);
-      }
-      return null;
-    }
-  },
-
-  // ===== PROGRESSIVE ENHANCEMENT =====
-
-  /**
-   * Try enrichment but don't fail if it doesn't work
-   */
-  'custom.tryEnrich': async (value, sourceData, config, helpers) => {
-    const baseResult = { value, enriched: false };
-
-    if (!helpers.fluentClient || !config?.tryEnrichment) {
-      return baseResult;
-    }
-
-    try {
-      const result = await helpers.fluentClient.graphql({
-        query: `query { enrich(value: "${value}") { data } }`
-      });
-
-      if (result.data?.enrich) {
-        return {
-          ...baseResult,
-          ...result.data.enrich,
-          enriched: true
-        };
-      }
-
-      return baseResult;
-
-    } catch (error) {
-      // Don't log errors for optional enrichment
-      helpers.log.debug('Enrichment failed but continuing', error);
-      return baseResult;
-    }
-  }
-};
-
-/**
- * Example usage:
- *
- * ```typescript
- * import { UniversalMapper, createClient } from '@fluentcommerce/fc-connect-sdk';
- * import { asyncResolvers } from './async-resolvers';
- *
- * const fluentClient = await createClient({
- *   config: {
- *     baseUrl: 'https://api.fluentcommerce.com',
- *     clientId: process.env.FLUENT_CLIENT_ID,
- *     clientSecret: process.env.FLUENT_CLIENT_SECRET,
- *     retailerId: process.env.FLUENT_RETAILER_ID
- *   }
- * });
- *
- * const mapper = new UniversalMapper(
- *   {
- *     fields: {
- *       enrichedProduct: {
- *         source: 'sku',
- *         resolver: 'custom.enrichWithProduct'
- *       },
- *       enrichedCustomer: {
- *         source: 'customerId',
- *         resolver: 'custom.enrichWithCustomer'
- *       }
- *     }
- *   },
- *   {
- *     customResolvers: asyncResolvers,
- *     context: {
- *       enableEnrichment: true,
- *       maxRetries: 3,
- *       retryDelay: 1000,
- *       batchSize: 10
- *     },
- *     fluentClient,
- *     logger: console
- *   }
- * );
- *
- * const result = await mapper.map({
- *   sku: 'SKU-001',
- *   customerId: 'CUST-123'
- * });
- *
- * console.log(result.data);
- * // {
- * //   enrichedProduct: { sku: 'SKU-001', name: 'Widget', ... },
- * //   enrichedCustomer: { id: 'CUST-123', firstName: 'John', ... }
- * // }
- * ```
- */
+/**
+ * Async Resolver Examples
+ *
+ * Async resolvers that perform API calls, enrichment, and async operations.
+ * Demonstrates error handling, retries, and performance patterns.
+ */
+
+import type { FieldResolverFunction } from '@fluentcommerce/fc-connect-sdk';
+
+/**
+ * Collection of async resolvers with API calls and error handling
+ */
+export const asyncResolvers: Record<string, FieldResolverFunction> = {
+  // ===== BASIC ASYNC ENRICHMENT =====
+
+  /**
+   * Enrich product data from Fluent Commerce API
+   *
+   * Config options:
+   * - enableEnrichment: Whether to perform enrichment
+   */
+  'custom.enrichWithProduct': async (sku, sourceData, config, helpers) => {
+    if (!helpers.fluentClient) {
+      helpers.log.warn('FluentClient not available, skipping enrichment');
+      return { sku };
+    }
+
+    if (!config?.enableEnrichment) {
+      return { sku };
+    }
+
+    try {
+      const result = await helpers.fluentClient.graphql({
+        query: `
+          query GetProduct($ref: String!) {
+            product(ref: $ref) {
+              id
+              ref
+              name
+              gtin
+              status
+              attributes {
+                name
+                value
+              }
+            }
+          }
+        `,
+        variables: { ref: sku }
+      });
+
+      if (!result.data?.product) {
+        helpers.log.warn(`Product not found: ${sku}`);
+        return { sku, found: false };
+      }
+
+      return {
+        sku,
+        found: true,
+        ...result.data.product
+      };
+
+    } catch (error) {
+      helpers.log.error(`Failed to fetch product ${sku}`, error);
+      return { sku, error: (error as Error).message };
+    }
+  },
+
+  /**
+   * Enrich customer data from Fluent Commerce API
+   */
+  'custom.enrichWithCustomer': async (customerId, sourceData, config, helpers) => {
+    if (!helpers.fluentClient) {
+      helpers.log.warn('FluentClient not available');
+      return customerId;
+    }
+
+    try {
+      const result = await helpers.fluentClient.graphql({
+        query: `
+          query GetCustomer($id: ID!) {
+            customer(id: $id) {
+              id
+              firstName
+              lastName
+              email
+              tier
+              status
+            }
+          }
+        `,
+        variables: { id: customerId }
+      });
+
+      return result.data?.customer || { id: customerId, found: false };
+
+    } catch (error) {
+      helpers.log.error(`Customer lookup failed: ${customerId}`, error);
+      return { id: customerId, error: (error as Error).message };
+    }
+  },
+
+  // ===== ASYNC WITH RETRY PATTERN =====
+
+  /**
+   * Fetch data with automatic retry on failure
+   *
+   * Config options:
+   * - maxRetries: Maximum retry attempts (default: 3)
+   * - retryDelay: Delay between retries in ms (default: 1000)
+   */
+  'custom.fetchWithRetry': async (id, sourceData, config, helpers) => {
+    if (!helpers.fluentClient) {
+      return null;
+    }
+
+    const maxRetries = config?.maxRetries || 3;
+    const retryDelay = config?.retryDelay || 1000;
+
+    const fetchData = async () => {
+      const result = await helpers.fluentClient.graphql({
+        query: `query { data(id: "${id}") { value } }`
+      });
+
+      if (!result.data) {
+        throw new Error('No data returned');
+      }
+
+      return result.data;
+    };
+
+    try {
+      return await helpers.retry(fetchData, {
+        maxAttempts: maxRetries,
+        delayMs: retryDelay,
+        backoffMultiplier: 2
+      });
+    } catch (error) {
+      helpers.log.error(`Failed after ${maxRetries} retries`, error);
+      return null;
+    }
+  },
+
+  // ===== MEMOIZED ASYNC OPERATIONS =====
+
+  /**
+   * Lookup customer with memoization (cached results)
+   */
+  'custom.lookupCustomer': async (customerId, sourceData, config, helpers) => {
+    // Create memoized version of the lookup function
+    const memoizedLookup = helpers.memoize(
+      async (id: string) => {
+        if (!helpers.fluentClient) {
+          return null;
+        }
+
+        try {
+          const result = await helpers.fluentClient.graphql({
+            query: `
+              query GetCustomer($id: ID!) {
+                customer(id: $id) {
+                  id
+                  firstName
+                  lastName
+                  email
+                  tier
+                }
+              }
+            `,
+            variables: { id }
+          });
+
+          return result.data?.customer;
+        } catch (error) {
+          helpers.log.error(`Customer lookup failed: ${id}`, error);
+          return null;
+        }
+      },
+      (id) => id // Memoization key function
+    );
+
+    return await memoizedLookup(customerId);
+  },
+
+  // ===== BATCH PROCESSING =====
+
+  /**
+   * Enrich multiple items in batches
+   *
+   * Config options:
+   * - batchSize: Number of items to process per batch (default: 10)
+   */
+  'custom.batchEnrichItems': async (items, sourceData, config, helpers) => {
+    if (!helpers.fluentClient) {
+      return items;
+    }
+
+    const arr = helpers.ensureArray(items);
+    const batchSize = config?.batchSize || 10;
+
+    try {
+      const results = await helpers.batchProcess(
+        arr,
+        async (batch) => {
+          const promises = batch.map(item =>
+            helpers.fluentClient.graphql({
+              query: `
+                query GetProduct($ref: String!) {
+                  product(ref: $ref) {
+                    id
+                    name
+                    gtin
+                  }
+                }
+              `,
+              variables: { ref: item.sku }
+            })
+          );
+
+          return await Promise.all(promises);
+        },
+        batchSize
+      );
+
+      return results.flat().map(r => r.data?.product);
+
+    } catch (error) {
+      helpers.log.error('Batch enrichment failed', error);
+      return items;
+    }
+  },
+
+  // ===== ERROR HANDLING PATTERNS =====
+
+  /**
+   * Fetch with graceful degradation
+   */
+  'custom.fetchWithFallback': async (id, sourceData, config, helpers) => {
+    if (!helpers.fluentClient) {
+      return config?.fallbackValue || { id };
+    }
+
+    try {
+      const result = await helpers.fluentClient.graphql({
+        query: `query { data(id: "${id}") { id name value } }`
+      });
+
+      if (!result.data || !result.data.data) {
+        throw new Error('No data returned');
+      }
+
+      return result.data.data;
+
+    } catch (error) {
+      helpers.log.error(`Fetch failed, using fallback`, error);
+      return config?.fallbackValue || { id, error: 'Fetch failed' };
+    }
+  },
+
+  /**
+   * Validate data before async operation
+   */
+  'custom.validateAndFetch': async (id, sourceData, config, helpers) => {
+    // Pre-flight validation
+    if (!id || String(id).trim() === '') {
+      helpers.log.error('Invalid ID for fetch');
+      return null;
+    }
+
+    if (!helpers.fluentClient) {
+      helpers.log.error('FluentClient not configured');
+      return null;
+    }
+
+    // Perform fetch
+    try {
+      const result = await helpers.fluentClient.graphql({
+        query: `query { data(id: "${id}") { value } }`
+      });
+
+      // Post-fetch validation
+      if (!result.data || !result.data.data) {
+        helpers.log.warn(`No data found for ID: ${id}`);
+        return null;
+      }
+
+      return result.data.data;
+
+    } catch (error) {
+      helpers.log.error(`Fetch failed for ID: ${id}`, error);
+      return null;
+    }
+  },
+
+  // ===== PARALLEL ASYNC OPERATIONS =====
+
+  /**
+   * Enrich with data from multiple sources in parallel
+   */
+  'custom.enrichWithMultipleSources': async (id, sourceData, config, helpers) => {
+    if (!helpers.fluentClient) {
+      return { id };
+    }
+
+    try {
+      // Fetch from multiple sources in parallel
+      const [product, inventory, pricing] = await Promise.all([
+        helpers.fluentClient.graphql({
+          query: `query { product(id: "${id}") { name gtin } }`
+        }),
+        helpers.fluentClient.graphql({
+          query: `query { inventoryPosition(id: "${id}") { qty status } }`
+        }),
+        helpers.fluentClient.graphql({
+          query: `query { price(productId: "${id}") { value currency } }`
+        })
+      ]);
+
+      return {
+        id,
+        product: product.data?.product,
+        inventory: inventory.data?.inventoryPosition,
+        pricing: pricing.data?.price
+      };
+
+    } catch (error) {
+      helpers.log.error('Multi-source enrichment failed', error);
+      return { id, error: (error as Error).message };
+    }
+  },
+
+  // ===== CONDITIONAL ASYNC OPERATIONS =====
+
+  /**
+   * Conditionally enrich based on sourceData and config
+   *
+   * Config options:
+   * - enrichmentRules: Rules for when to enrich
+   */
+  'custom.conditionalEnrich': async (value, sourceData, config, helpers) => {
+    // Check if enrichment should be performed
+    const rules = config?.enrichmentRules || {};
+
+    const shouldEnrich =
+      rules.always ||
+      (rules.ifHighValue && helpers.get(sourceData, 'totalValue', 0) > 1000) ||
+      (rules.ifPremiumTier && helpers.get(sourceData, 'customer.tier') === 'platinum');
+
+    if (!shouldEnrich) {
+      helpers.log.debug('Skipping enrichment based on rules');
+      return value;
+    }
+
+    if (!helpers.fluentClient) {
+      return value;
+    }
+
+    try {
+      const result = await helpers.fluentClient.graphql({
+        query: `query { enrichData(value: "${value}") { enriched } }`
+      });
+
+      return result.data?.enrichData || value;
+
+    } catch (error) {
+      helpers.log.error('Conditional enrichment failed', error);
+      return value;
+    }
+  },
+
+  // ===== TIMEOUT HANDLING =====
+
+  /**
+   * Fetch with timeout
+   *
+   * Config options:
+   * - timeout: Timeout in milliseconds (default: 5000)
+   */
+  'custom.fetchWithTimeout': async (id, sourceData, config, helpers) => {
+    if (!helpers.fluentClient) {
+      return null;
+    }
+
+    const timeout = config?.timeout || 5000;
+
+    const fetchPromise = helpers.fluentClient.graphql({
+      query: `query { data(id: "${id}") { value } }`
+    });
+
+    const timeoutPromise = new Promise((_, reject) =>
+      setTimeout(() => reject(new Error('Timeout')), timeout)
+    );
+
+    try {
+      const result = await Promise.race([fetchPromise, timeoutPromise]);
+      return (result as any).data?.data;
+
+    } catch (error) {
+      if ((error as Error).message === 'Timeout') {
+        helpers.log.error(`Fetch timed out after ${timeout}ms`);
+      } else {
+        helpers.log.error('Fetch failed', error);
+      }
+      return null;
+    }
+  },
+
+  // ===== PROGRESSIVE ENHANCEMENT =====
+
+  /**
+   * Try enrichment but don't fail if it doesn't work
+   */
+  'custom.tryEnrich': async (value, sourceData, config, helpers) => {
+    const baseResult = { value, enriched: false };
+
+    if (!helpers.fluentClient || !config?.tryEnrichment) {
+      return baseResult;
+    }
+
+    try {
+      const result = await helpers.fluentClient.graphql({
+        query: `query { enrich(value: "${value}") { data } }`
+      });
+
+      if (result.data?.enrich) {
+        return {
+          ...baseResult,
+          ...result.data.enrich,
+          enriched: true
+        };
+      }
+
+      return baseResult;
+
+    } catch (error) {
+      // Don't log errors for optional enrichment
+      helpers.log.debug('Enrichment failed but continuing', error);
+      return baseResult;
+    }
+  }
+};
+
+/**
+ * Example usage:
+ *
+ * ```typescript
+ * import { UniversalMapper, createClient } from '@fluentcommerce/fc-connect-sdk';
+ * import { asyncResolvers } from './async-resolvers';
+ *
+ * const fluentClient = await createClient({
+ *   config: {
+ *     baseUrl: 'https://api.fluentcommerce.com',
+ *     clientId: process.env.FLUENT_CLIENT_ID,
+ *     clientSecret: process.env.FLUENT_CLIENT_SECRET,
+ *     retailerId: process.env.FLUENT_RETAILER_ID
+ *   }
+ * });
+ *
+ * const mapper = new UniversalMapper(
+ *   {
+ *     fields: {
+ *       enrichedProduct: {
+ *         source: 'sku',
+ *         resolver: 'custom.enrichWithProduct'
+ *       },
+ *       enrichedCustomer: {
+ *         source: 'customerId',
+ *         resolver: 'custom.enrichWithCustomer'
+ *       }
+ *     }
+ *   },
+ *   {
+ *     customResolvers: asyncResolvers,
+ *     context: {
+ *       enableEnrichment: true,
+ *       maxRetries: 3,
+ *       retryDelay: 1000,
+ *       batchSize: 10
+ *     },
+ *     fluentClient,
+ *     logger: console
+ *   }
+ * );
+ *
+ * const result = await mapper.map({
+ *   sku: 'SKU-001',
+ *   customerId: 'CUST-123'
+ * });
+ *
+ * console.log(result.data);
+ * // {
+ * //   enrichedProduct: { sku: 'SKU-001', name: 'Widget', ... },
+ * //   enrichedCustomer: { id: 'CUST-123', firstName: 'John', ... }
+ * // }
+ * ```
+ */