async function captureOrder(orderData) {
    try {
      let order;
      switch(orderData.type) {
        case 'standard':
          // See https://docs.stateset.io/stateset-commerce-api-reference/orders/create for details on the create order endpoint
          order = await client.order.create({
            source: orderData.channel,
            channel_order_id: orderData.channelOrderId,
           customer: orderData.customer,
            line_items: orderData.lineItems,
            total_price: orderData.totalPrice,
             currency: orderData.currency,
           shipping_address: orderData.shippingAddress,
           status: 'received'
         });
         break;
       case 'pre-order':
          order = await createPreOrder(orderData);
          break;
        case 'backorder':
          order = await createBackOrder(orderData);
          break;
        case 'subscription':
           order = await createSubscriptionOrder(orderData);
         break;
        default:
          throw new Error('Unsupported order type');
      }
     console.log("Order Created:", order)
      return order;
    } catch (error) {
      console.error("Error capturing order:", error);
      throw error;
    }
}

const order = await captureOrder({
  type: 'standard',
  channel: 'web',
  channelOrderId: 'WEB-001',
  customer: { id: 'cust_001' },
   lineItems: [
    { product_id: 'prod_001', quantity: 2, price: 20, weight: 1, length: 5, width: 5, height: 5 },
    { product_id: 'prod_002', quantity: 1, price: 30, weight: 2, length: 10, width: 10, height: 10 }
    ],
  totalPrice: 70,
  currency: 'USD',
  shippingAddress: {
    street: '123 Main St',
    city: 'Anytown',
    state: 'CA',
    zip: '12345'
    }
})

async function routeOrder(orderId) {
    try {
      // See https://docs.stateset.io/stateset-commerce-api-reference/orders/get for details
      const order = await client.order.get(orderId);
    const fulfillmentLocations = await client.location.list({ type: 'fulfillment' });

        if (!order || !fulfillmentLocations.length) {
           throw new Error('Invalid order or no fulfillment locations available');
        }

        // Placeholder: This is where you would use a machine learning algorithm to predict the best fulfillment location
       const mlPrediction = {
         confidence: 0.95,
         locationScores: fulfillmentLocations.reduce((acc, location) => {
         acc[location.id] = Math.random();
         return acc;
        }, {})
       }

        const inventoryLevels = await getInventoryLevels(order.line_items.map(item => item.product_id));
       const shippingRates = await getShippingRates(order);

      const optimalLocation = determineOptimalLocation(order, fulfillmentLocations, mlPrediction, shippingRates, inventoryLevels);

      if (!optimalLocation) {
       throw new Error('Unable to determine optimal fulfillment location');
    }
     // See https://docs.stateset.io/stateset-commerce-api-reference/orders/update for details
     const updatedOrder = await client.order.update(orderId, {
       assigned_location: optimalLocation.id,
        status: 'routed',
        routing_metadata: {
            prediction_confidence: mlPrediction.confidence,
            selected_shipping_rate: optimalLocation.selectedRate
          }
       });

    await logRoutingDecision(orderId, optimalLocation, mlPrediction);
    console.log("Order Routed:", updatedOrder);
    return {
      optimalLocation,
      updatedOrder
   };
  } catch (error) {
      console.error(`Error routing order ${orderId}:`, error);
    await client.order.update(orderId, { status: 'routing_failed' });
      throw error;
    }
}

function determineOptimalLocation(order, locations, mlPrediction, shippingRates, inventoryLevels) {
  const scoredLocations = locations.map(location => {
     const inventoryScore = calculateInventoryScore(location, order, inventoryLevels);
     const shippingScore = calculateShippingScore(location, shippingRates);
    const mlScore = mlPrediction.locationScores[location.id] || 0;
       const fulfillmentCost = estimateFulfillmentCost(location, order);

    const totalScore = (inventoryScore * 0.4) + (shippingScore * 0.3) + (mlScore * 0.2) - (fulfillmentCost * 0.1);

     return {
       ...location,
     score: totalScore,
        selectedRate: shippingRates[location.id].cheapestRate
      };
   });

   return scoredLocations.reduce((best, current) =>
      current.score > best.score ? current : best
    , scoredLocations[0]);
}

function calculateInventoryScore(location, order, inventoryLevels) {
    return order.line_items.reduce((score, item) => {
      const availability = inventoryLevels[location.id]?.[item.product_id] || 0;
      return score + (availability >= item.quantity ? 1 : 0);
   }, 0) / order.line_items.length;
}

function calculateShippingScore(location, shippingRates) {
  const locationRates = shippingRates[location.id];
   const cheapestRate = locationRates.cheapestRate;
  const fastestRate = locationRates.fastestRate;
   return 1 - (cheapestRate.price / fastestRate.price);
}

function estimateFulfillmentCost(location, order) {
    // Simplified cost estimation
  const baseCost = location.fulfillmentCostFactor || 1;
    return baseCost * order.line_items.reduce((total, item) => total + item.quantity, 0);
}

async function getShippingRates(order) {
  try {
      const carriers = await client.carrier.list();
    const fulfillmentLocations = await client.location.list({ type: 'fulfillment' });

     const rates = {};
    for (const location of fulfillmentLocations) {
     const locationRates = await Promise.all(carriers.map(carrier =>
        carrier.getRates({
            origin: location.address,
          destination: order.shipping_address,
          packages: convertOrderToPackages(order)
        })
      ));

      const flatRates = locationRates.flatMap(rate => rate);
     rates[location.id] = {
        allRates: flatRates,
        cheapestRate: flatRates.reduce((min, rate) => rate.price < min.price ? rate : min),
        fastestRate: flatRates.reduce((fastest, rate) => rate.deliveryDays < fastest.deliveryDays ? rate : fastest)
       };
      }

      return rates;
    } catch (error) {
     console.error("Error fetching shipping rates:", error);
        throw error
  }
}

function convertOrderToPackages(order) {
   // Simplified conversion - in reality, this would involve a more complex packing algorithm
   return [{
      weight: order.line_items.reduce((total, item) => total + (item.weight * item.quantity), 0),
     dimensions: {
       length: Math.max(...order.line_items.map(item => item.length)),
       width: Math.max(...order.line_items.map(item => item.width)),
        height: Math.max(...order.line_items.map(item => item.height))
     }
   }];
}

async function getInventoryLevels(productIds) {
    const inventoryRecords = await client.inventory.list({ product_id: { in: productIds } });
   return inventoryRecords.reduce((acc, record) => {
      acc[record.location_id] = acc[record.location_id] || {};
       acc[record.location_id][record.product_id] = record.available_quantity;
        return acc;
     }, {});
}

async function logRoutingDecision(orderId, optimalLocation, mlPrediction) {
  await client.log.create({
     type: 'order_routing',
      order_id: orderId,
    selected_location: optimalLocation.id,
    ml_confidence: mlPrediction.confidence,
     routing_score: optimalLocation.score
   });
}

// Example usage
const routedOrder = await routeOrder(order.id);
console.log("Routed Order:", routedOrder)

async function getGlobalInventory(productId) {
  try {
    const inventoryList = await client.inventory.list({ product_id: productId });
      const globalInventory = inventoryList.reduce((acc, inv) => {
      acc[inv.location_id] = {
        quantity: inv.quantity,
          type: inv.inventory_type, // 'owned', 'dropship', or 'jit'
        safetyStock: inv.safety_stock_level
      };
        return acc;
     }, {});
      console.log("Global Inventory:", globalInventory)
    return globalInventory;
  } catch (error) {
      console.error("Error fetching global inventory:", error);
      throw error;
  }
}

//Example of use
const globalInventory = await getGlobalInventory('prod_001')

async function allocateInventory(orderId) {
   let allocatedItems = [];
  try {
   const order = await client.order.get(orderId);
   const allocationResults = await Promise.all(order.line_items.map(async (item) => {
     const allocation = await determineOptimalAllocation(item, order.assigned_location);
      return { item, allocation };
    }));

      for (const { item, allocation } of allocationResults) {
        for (const alloc of allocation) {
        if (alloc.quantity > 0) {
          await client.inventory.allocate({
           product_id: item.product_id,
           location_id: alloc.location_id,
           quantity: alloc.quantity,
            allocation_type: alloc.type,
            order_id: orderId,
            item_id: item.id
           });
        allocatedItems.push({
            item_id: item.id,
            product_id: item.product_id,
           allocated_quantity: alloc.quantity,
          location_id: alloc.location_id,
           allocation_type: alloc.type
           });
        }
       }
      }

    const fullyAllocated = allocatedItems.every(ai =>
        ai.allocated_quantity === order.line_items.find(li => li.id === ai.item_id).quantity
     );
    await client.order.update(orderId, {
        status: fullyAllocated ? 'fully_allocated' : 'partially_allocated',
      inventory_allocations: allocatedItems
     });

      await logAllocationResult(orderId, allocatedItems, fullyAllocated);
      console.log("Allocation Results:", { orderId, allocatedItems, fullyAllocated });
      return { orderId, allocatedItems, fullyAllocated };
  } catch (error) {
     console.error(`Error allocating inventory for order ${orderId}:`, error);
    await client.order.update(orderId, {
       status: 'allocation_failed',
        allocation_error: error.message
     });
    throw error;
  }
}

async function determineOptimalAllocation(item, preferredLocation) {
  const inventory = await getInventoryLevels(item.product_id);
  const reservations = await getActiveReservations(item.product_id);
  const safetyStockLevels = await getSafetyStockLevels(item.product_id);

  let remainingQuantity = item.quantity;
    let allocations = [];

   // Try to allocate from the preferred location first
    if (inventory[preferredLocation]) {
     const preferredAllocation = allocateFromLocation(
       preferredLocation,
     remainingQuantity,
      inventory[preferredLocation],
       reservations[preferredLocation],
       safetyStockLevels[preferredLocation]
   );
      if (preferredAllocation.quantity > 0) {
        allocations.push(preferredAllocation);
          remainingQuantity -= preferredAllocation.quantity;
    }
    }

    // If we couldn't fully allocate from the preferred location, try others
   if (remainingQuantity > 0) {
     for (const [locationId, quantity] of Object.entries(inventory)) {
     if (locationId === preferredLocation) continue;

       const allocation = allocateFromLocation(
          locationId,
          remainingQuantity,
          quantity,
           reservations[locationId],
         safetyStockLevels[locationId]
     );

    if (allocation.quantity > 0) {
       allocations.push(allocation);
     remainingQuantity -= allocation.quantity;
      if (remainingQuantity === 0) break;
       }
     }
  }

    // If we still couldn't allocate everything, create a backorder
   if (remainingQuantity > 0) {
      allocations.push({
        location_id: 'backorder',
          quantity: remainingQuantity,
          type: 'backorder'
       });
     }
  return allocations;
}

function allocateFromLocation(locationId, requiredQuantity, availableQuantity, reservations, safetyStock) {
  const effectiveQuantity = Math.max(availableQuantity - reservations - safetyStock, 0);
  const allocatedQuantity = Math.min(requiredQuantity, effectiveQuantity);

  return {
     location_id: locationId,
      quantity: allocatedQuantity,
      type: allocatedQuantity > 0 ? 'standard' : 'none'
   };
}

async function getActiveReservations(productId) {
    const reservations = await client.reservation.list({ product_id: productId, status: 'active' });
    return reservations.reduce((acc, reservation) => {
      acc[reservation.location_id] = (acc[reservation.location_id] || 0) + reservation.quantity;
      return acc;
    }, {});
}

async function getSafetyStockLevels(productId) {
  const safetyStockRecords = await client.safetyStock.list({ product_id: productId });
    return safetyStockRecords.reduce((acc, record) => {
      acc[record.location_id] = record.quantity;
       return acc;
   }, {});
}

async function logAllocationResult(orderId, allocatedItems, fullyAllocated) {
    await client.log.create({
      type: 'inventory_allocation',
      order_id: orderId,
       allocated_items: allocatedItems,
      fully_allocated: fullyAllocated,
      timestamp: new Date().toISOString()
     });
}

//Example of use
const allocatedOrder = await allocateInventory(order.id)
console.log("Allocated order:", allocatedOrder)

async function rebalanceInventory() {
  const rebalancingLog = [];
  try {
    const inventory = await client.inventory.list();
    const locations = await client.location.list();
    const salesVelocity = await getSalesVelocityByLocation();
    const seasonalTrends = await getSeasonalTrends();
    const shippingCosts = await getShippingCostMatrix();
    const storageCapacity = await getStorageCapacityByLocation();

      const rebalancingPlan = generateRebalancingPlan(
          inventory,
        locations,
       salesVelocity,
        seasonalTrends,
          shippingCosts,
           storageCapacity
      );
    for (const transfer of rebalancingPlan) {
      try {
        await client.inventory.transfer(transfer);
          rebalancingLog.push({
              status: 'success',
            transfer: transfer
        });
       } catch (transferError) {
         console.error(`Error executing transfer:`, transferError);
           rebalancingLog.push({
            status: 'failed',
              transfer: transfer,
           error: transferError.message
        });
       }
      }
    const successfulTransfers = rebalancingLog.filter(log => log.status === 'success').length;
      console.log(`Inventory rebalancing completed. ${successfulTransfers}/${rebalancingPlan.length} transfers successful.`);

    await logRebalancingResult(rebalancingLog);

   return {
     totalTransfers: rebalancingPlan.length,
       successfulTransfers: successfulTransfers,
      rebalancingLog: rebalancingLog
    };
 } catch (error) {
      console.error("Error in inventory rebalancing process:", error);
    await logRebalancingError(error);
        throw error;
   }
}

function generateRebalancingPlan(inventory, locations, salesVelocity, seasonalTrends, shippingCosts, storageCapacity) {
    const rebalancingPlan = [];

   // Group inventory by product
   const productInventory = groupInventoryByProduct(inventory);

  for (const [productId, productLocations] of Object.entries(productInventory)) {
      const totalInventory = sum(Object.values(productLocations));
    const totalSalesVelocity = sum(Object.values(salesVelocity[productId] || {}));

    if (totalSalesVelocity === 0) continue; // Skip products with no sales

   const idealDistribution = calculateIdealDistribution(
        productId,
        totalInventory,
       locations,
      salesVelocity,
       seasonalTrends,
      storageCapacity
     );

      for (const [fromLocation, fromQuantity] of Object.entries(productLocations)) {
        const idealQuantity = idealDistribution[fromLocation] || 0;
        const difference = fromQuantity - idealQuantity;

      if (difference > 0) { // This location has excess inventory
        for (const [toLocation, toIdealQuantity] of Object.entries(idealDistribution)) {
         if (productLocations[toLocation] < toIdealQuantity) {
              const transferQuantity = Math.min(difference, toIdealQuantity - productLocations[toLocation]);
           if (transferQuantity > 0 && isTransferCostEffective(productId, fromLocation, toLocation, transferQuantity, shippingCosts)) {
           rebalancingPlan.push({
               product_id: productId,
                from_location: fromLocation,
                  to_location: toLocation,
                 quantity: transferQuantity
              });
           productLocations[fromLocation] -= transferQuantity;
            productLocations[toLocation] = (productLocations[toLocation] || 0) + transferQuantity;
            }
          }
         }
        }
     }
   }

  return rebalancingPlan;
}

function calculateIdealDistribution(productId, totalInventory, locations, salesVelocity, seasonalTrends, storageCapacity) {
  const distribution = {};
    const totalSalesVelocity = sum(Object.values(salesVelocity[productId] || {}));

  for (const location of locations) {
   const locationSalesVelocity = salesVelocity[productId]?.[location.id] || 0;
  const seasonalFactor = seasonalTrends[productId]?.[location.id] || 1;
    const adjustedSalesVelocity = locationSalesVelocity * seasonalFactor;

        let idealQuantity = Math.round((adjustedSalesVelocity / totalSalesVelocity) * totalInventory);
      idealQuantity = Math.min(idealQuantity, storageCapacity[location.id]); // Respect storage capacity

        distribution[location.id] = idealQuantity;
  }

  return distribution;
}

function isTransferCostEffective(productId, fromLocation, toLocation, quantity, shippingCosts) {
    const transferCost = shippingCosts[fromLocation]?.[toLocation] * quantity;
    const productValue = getProductValue(productId);
    const transferValueRatio = transferCost / (productValue * quantity);

   // Consider transfer cost-effective if it's less than 10% of the inventory value
    return transferValueRatio < 0.1;
}

function groupInventoryByProduct(inventory) {
    return inventory.reduce((acc, item) => {
       acc[item.product_id] = acc[item.product_id] || {};
     acc[item.product_id][item.location_id] = item.quantity;
        return acc;
   }, {});
}

async function getSalesVelocityByLocation() {
    // Placeholder: In a real implementation you'd use a caching layer
   const cacheKey = 'sales_velocity';
     // let salesVelocity = cache.get(cacheKey);

     //if (salesVelocity) {
   //   return salesVelocity;
     //}

    try {
     // Assume we're fetching data for the last 90 days
      const endDate = new Date();
        const startDate = new Date(endDate.getTime() - (90 * 24 * 60 * 60 * 1000));

     const salesData = await client.analytics.getSales({
          start_date: startDate.toISOString(),
           end_date: endDate.toISOString(),
          group_by: ['product_id', 'location_id']
       });

   let salesVelocity = salesData.reduce((acc, sale) => {
        acc[sale.product_id] = acc[sale.product_id] || {};
       acc[sale.product_id][sale.location_id] = sale.quantity / 90; // Daily sales velocity
            return acc;
   }, {});

     // cache.set(cacheKey, salesVelocity);
     return salesVelocity;
    } catch (error) {
       console.error('Error fetching sales velocity:', error);
      throw new Error('Failed to fetch sales velocity data');
   }
}

async function getSeasonalTrends() {
   // Placeholder: In a real implementation you'd use a caching layer
     const cacheKey = 'seasonal_trends';
     // let seasonalTrends = cache.get(cacheKey);

    //  if (seasonalTrends) {
       //   return seasonalTrends;
     //  }

    try {
        // Assume we're fetching seasonal data for the next 90 days
     const startDate = new Date();
        const endDate = new Date(startDate.getTime() + (90 * 24 * 60 * 60 * 1000));

        const trendsData = await client.analytics.getSeasonalTrends({
          start_date: startDate.toISOString(),
        end_date: endDate.toISOString(),
        group_by: ['product_id', 'location_id']
       });

        let seasonalTrends = trendsData.reduce((acc, trend) => {
         acc[trend.product_id] = acc[trend.product_id] || {};
         acc[trend.product_id][trend.location_id] = trend.seasonal_factor;
            return acc;
       }, {});

      // cache.set(cacheKey, seasonalTrends);
      return seasonalTrends;
    } catch (error) {
     console.error('Error fetching seasonal trends:', error);
        throw new Error('Failed to fetch seasonal trend data');
    }
}

async function getShippingCostMatrix() {
  // Placeholder: In a real implementation you'd use a caching layer
    const cacheKey = 'shipping_cost_matrix';
    // let shippingCostMatrix = cache.get(cacheKey);

   // if (shippingCostMatrix) {
       // return shippingCostMatrix;
    // }

    try {
    const locations = await client.location.list();
        let shippingCostMatrix = {};

     for (const fromLocation of locations) {
       shippingCostMatrix[fromLocation.id] = {};
            for (const toLocation of locations) {
                if (fromLocation.id !== toLocation.id) {
                  const shippingRate = await client.shipping.getRate({
                       from: fromLocation.id,
                        to: toLocation.id,
                        weight: 1, // Assume 1 kg as a base weight
                        volume: 1 // Assume 1 cubic meter as a base volume
                    });
                   shippingCostMatrix[fromLocation.id][toLocation.id] = shippingRate.cost;
           }
           }
      }

        //  cache.set(cacheKey, shippingCostMatrix);
    return shippingCostMatrix;
    } catch (error) {
     console.error('Error fetching shipping cost matrix:', error);
       throw new Error('Failed to fetch shipping cost data');
   }
}

async function getStorageCapacityByLocation() {
    // Placeholder: In a real implementation you'd use a caching layer
    const cacheKey = 'storage_capacity';
    //  let storageCapacity = cache.get(cacheKey);

    // if (storageCapacity) {
      //  return storageCapacity;
     //}

  try {
        const locations = await client.location.list();
      let storageCapacity = {};

        for (const location of locations) {
          const capacityData = await client.warehouse.getCapacity(location.id);
        storageCapacity[location.id] = capacityData.available_capacity;
       }
    // cache.set(cacheKey, storageCapacity);
    return storageCapacity;
    } catch (error) {
        console.error('Error fetching storage capacity:', error);
       throw new Error('Failed to fetch storage capacity data');
    }
}

function getProductValue(productId) {
    return new Promise((resolve, reject) => {
       // Placeholder: In a real implementation you'd use a caching layer
       const cacheKey = `product_value_${productId}`;
     // const cachedValue = cache.get(cacheKey);

        //if (cachedValue) {
          //  resolve(cachedValue);
      //  } else {
            client.product.get(productId)
            .then(product => {
                const value = product.cost || product.price || 0;
         //     cache.set(cacheKey, value);
                resolve(value);
        })
            .catch(error => {
               console.error(`Error fetching product value for ${productId}:`, error);
               reject(new Error(`Failed to fetch product value for ${productId}`));
      });
      //  }
  });
}

function sum(numbers) {
   return numbers.reduce((a, b) => a + b, 0);
}

async function logRebalancingResult(rebalancingLog) {
    await client.log.create({
     type: 'inventory_rebalancing',
      result: rebalancingLog,
       timestamp: new Date().toISOString()
    });
}

async function logRebalancingError(error) {
   await client.log.create({
       type: 'inventory_rebalancing_error',
     error: error.message,
        stack: error.stack,
       timestamp: new Date().toISOString()
    });
}
// Example of use
const rebalancedInventory = await rebalanceInventory();
console.log("Rebalanced Inventory:", rebalancedInventory)

## Support Resources

If you encounter issues or have questions, here are some resources that can help you:

*   **Stateset Documentation:** [https://docs.stateset.io](https://docs.stateset.io)
*   **Community Forum:** [https://community.stateset.io](https://community.stateset.io)
*   **Email Support:** [support@stateset.com](mailto:support@stateset.com)

## Complete Order Lifecycle Implementation

Here's a production-ready implementation that ties everything together:

```javascript
import { StateSetClient } from 'stateset-node';
import { EventEmitter } from 'events';

class OrderLifecycleManager extends EventEmitter {
  constructor(apiKey) {
    super();
    this.client = new StateSetClient({ apiKey });
    this.setupEventHandlers();
  }
  
  /**
   * Process a complete order from creation to delivery
   */
  async processOrder(orderData) {
    const orderLog = {
      orderId: null,
      steps: [],
      errors: [],
      startTime: Date.now()
    };
    
    try {
      // Step 1: Validate and create order
      this.emit('step:start', 'order_creation');
      const order = await this.createOrderWithValidation(orderData);
      orderLog.orderId = order.id;
      orderLog.steps.push({ step: 'created', timestamp: Date.now() });
      
      // Step 2: Check inventory and allocate
      this.emit('step:start', 'inventory_check');
      const allocation = await this.allocateInventoryWithFallback(order);
      orderLog.steps.push({ step: 'allocated', timestamp: Date.now() });
      
      // Step 3: Route to optimal fulfillment center
      this.emit('step:start', 'routing');
      const routing = await this.routeOrderIntelligently(order, allocation);
      orderLog.steps.push({ step: 'routed', timestamp: Date.now() });
      
      // Step 4: Create fulfillment order
      this.emit('step:start', 'fulfillment');
      const fulfillment = await this.createFulfillmentWithRetry(order, routing);
      orderLog.steps.push({ step: 'fulfillment_created', timestamp: Date.now() });
      
      // Step 5: Generate shipping label
      this.emit('step:start', 'shipping');
      const shipping = await this.generateShippingLabel(fulfillment);
      orderLog.steps.push({ step: 'shipped', timestamp: Date.now() });
      
      // Step 6: Notify customer
      this.emit('step:start', 'notification');
      await this.sendCustomerNotifications(order, shipping);
      orderLog.steps.push({ step: 'customer_notified', timestamp: Date.now() });
      
      // Success!
      orderLog.completionTime = Date.now();
      orderLog.duration = orderLog.completionTime - orderLog.startTime;
      
      this.emit('order:complete', orderLog);
      return {
        success: true,
        order,
        fulfillment,
        shipping,
        log: orderLog
      };
      
    } catch (error) {
      orderLog.errors.push({
        step: this.currentStep,
        error: error.message,
        timestamp: Date.now()
      });
      
      // Attempt recovery
      await this.handleOrderError(orderLog, error);
      
      this.emit('order:failed', orderLog);
      throw error;
    }
  }
  
  async createOrderWithValidation(orderData) {
    // Validate order data
    const validation = this.validateOrderData(orderData);
    if (!validation.valid) {
      throw new Error(`Order validation failed: ${validation.errors.join(', ')}`);
    }
    
    // Check for duplicate orders
    const isDuplicate = await this.checkDuplicateOrder(orderData);
    if (isDuplicate) {
      throw new Error('Duplicate order detected');
    }
    
    // Create order with idempotency key
    const order = await this.client.orders.create({
      ...orderData,
      idempotency_key: this.generateIdempotencyKey(orderData)
    });
    
    return order;
  }
  
  async allocateInventoryWithFallback(order) {
    try {
      // Try primary allocation
      return await this.client.inventory.allocate({
        order_id: order.id,
        items: order.items
      });
    } catch (error) {
      if (error.code === 'INSUFFICIENT_INVENTORY') {
        // Try split fulfillment
        return await this.attemptSplitFulfillment(order);
      }
      throw error;
    }
  }
  
  async routeOrderIntelligently(order, allocation) {
    // Get all potential fulfillment locations
    const locations = await this.client.locations.list({
      type: 'fulfillment',
      active: true
    });
    
    // Score each location
    const scoredLocations = await Promise.all(
      locations.map(async (location) => {
        const score = await this.scoreLocation(location, order, allocation);
        return { location, score };
      })
    );
    
    // Select optimal location
    const optimal = scoredLocations.reduce((best, current) => 
      current.score > best.score ? current : best
    );
    
    // Update order with routing
    await this.client.orders.update(order.id, {
      fulfillment_location: optimal.location.id,
      routing_score: optimal.score
    });
    
    return optimal;
  }
  
  async createFulfillmentWithRetry(order, routing) {
    let attempts = 0;
    const maxAttempts = 3;
    
    while (attempts < maxAttempts) {
      try {
        return await this.client.fulfillment.create({
          order_id: order.id,
          location_id: routing.location.id,
          priority: this.calculatePriority(order)
        });
      } catch (error) {
        attempts++;
        if (attempts >= maxAttempts) throw error;
        
        // Wait with exponential backoff
        await this.sleep(Math.pow(2, attempts) * 1000);
      }
    }
  }
  
  async generateShippingLabel(fulfillment) {
    // Select best carrier
    const carrier = await this.selectOptimalCarrier(fulfillment);
    
    // Generate label
    const label = await this.client.shipping.createLabel({
      fulfillment_id: fulfillment.id,
      carrier: carrier.id,
      service: carrier.recommended_service,
      insurance: fulfillment.total_value > 100
    });
    
    return label;
  }
  
  async sendCustomerNotifications(order, shipping) {
    const notifications = [];
    
    // Email notification
    notifications.push(
      this.client.notifications.send({
        type: 'email',
        to: order.customer_email,
        template: 'order_shipped',
        data: {
          order_number: order.number,
          tracking_number: shipping.tracking_number,
          tracking_url: shipping.tracking_url,
          estimated_delivery: shipping.estimated_delivery
        }
      })
    );
    
    // SMS if opted in
    if (order.customer_phone && order.sms_opt_in) {
      notifications.push(
        this.client.notifications.send({
          type: 'sms',
          to: order.customer_phone,
          message: `Your order ${order.number} has shipped! Track: ${shipping.tracking_url}`
        })
      );
    }
    
    await Promise.all(notifications);
  }
  
  setupEventHandlers() {
    this.on('step:start', (step) => {
      this.currentStep = step;
      console.log(`📋 Starting: ${step}`);
    });
    
    this.on('order:complete', (log) => {
      console.log(`✅ Order ${log.orderId} completed in ${log.duration}ms`);
    });
    
    this.on('order:failed', (log) => {
      console.error(`❌ Order ${log.orderId} failed:`, log.errors);
    });
  }
  
  // Helper methods
  validateOrderData(data) {
    const errors = [];
    
    if (!data.customer_email) errors.push('Missing customer email');
    if (!data.items || data.items.length === 0) errors.push('No items in order');
    if (!data.shipping_address) errors.push('Missing shipping address');
    
    // Validate each item
    data.items?.forEach((item, index) => {
      if (!item.sku) errors.push(`Item ${index}: missing SKU`);
      if (!item.quantity || item.quantity < 1) errors.push(`Item ${index}: invalid quantity`);
      if (!item.price || item.price < 0) errors.push(`Item ${index}: invalid price`);
    });
    
    return {
      valid: errors.length === 0,
      errors
    };
  }
  
  generateIdempotencyKey(orderData) {
    return `${orderData.source}-${orderData.external_id}-${Date.now()}`;
  }
  
  async checkDuplicateOrder(orderData) {
    if (!orderData.external_id) return false;
    
    const existing = await this.client.orders.list({
      external_id: orderData.external_id,
      created_after: new Date(Date.now() - 24 * 60 * 60 * 1000) // Last 24 hours
    });
    
    return existing.length > 0;
  }
  
  calculatePriority(order) {
    // Priority based on shipping method, customer tier, etc.
    if (order.shipping_method === 'express') return 'high';
    if (order.customer_tier === 'vip') return 'high';
    if (order.total_value > 500) return 'medium';
    return 'normal';
  }
  
  sleep(ms) {
    return new Promise(resolve => setTimeout(resolve, ms));
  }
}

// Usage example
const orderManager = new OrderLifecycleManager(process.env.STATESET_API_KEY);

// Process an order
const result = await orderManager.processOrder({
  source: 'website',
  external_id: 'WEB-12345',
  customer_email: 'customer@example.com',
  customer_phone: '+1234567890',
  sms_opt_in: true,
  shipping_method: 'standard',
  items: [
    {
      sku: 'WIDGET-001',
      quantity: 2,
      price: 29.99,
      name: 'Premium Widget'
    }
  ],
  shipping_address: {
    name: 'John Doe',
    street1: '123 Main St',
    city: 'San Francisco',
    state: 'CA',
    zip: '94105',
    country: 'US'
  },
  billing_address: {
    // Same as shipping or different
  }
});

console.log('Order processed:', result);

import express from 'express';
import crypto from 'crypto';

const app = express();
app.use(express.json());

// Webhook endpoint
app.post('/webhooks/stateset', async (req, res) => {
  try {
    // Verify webhook signature
    const signature = req.headers['x-stateset-signature'];
    const payload = JSON.stringify(req.body);
    const expectedSignature = crypto
      .createHmac('sha256', process.env.WEBHOOK_SECRET)
      .update(payload)
      .digest('hex');
    
    if (signature !== expectedSignature) {
      return res.status(401).json({ error: 'Invalid signature' });
    }
    
    // Process webhook event
    const { event, data } = req.body;
    
    switch (event) {
      case 'order.created':
        await handleOrderCreated(data);
        break;
        
      case 'order.fulfilled':
        await handleOrderFulfilled(data);
        break;
        
      case 'inventory.low':
        await handleLowInventory(data);
        break;
        
      case 'order.delivered':
        await handleOrderDelivered(data);
        break;
        
      default:
        console.log(`Unhandled event: ${event}`);
    }
    
    res.status(200).json({ received: true });
    
  } catch (error) {
    console.error('Webhook error:', error);
    res.status(500).json({ error: 'Webhook processing failed' });
  }
});

// Event handlers
async function handleOrderCreated(order) {
  console.log('New order created:', order.id);
  
  // Send order confirmation
  await sendOrderConfirmation(order);
  
  // Update external systems
  await updateCRM(order);
  
  // Start fulfillment process
  await initiateFulfillment(order);
}

async function handleOrderFulfilled(data) {
  console.log('Order fulfilled:', data.order_id);
  
  // Update inventory counts
  await updateInventoryCounts(data.items);
  
  // Trigger shipping workflow
  await createShippingLabel(data);
  
  // Notify customer
  await sendShippingNotification(data);
}

async function handleLowInventory(data) {
  console.log('Low inventory alert:', data);
  
  // Check if reorder needed
  if (data.available < data.reorder_point) {
    await createPurchaseOrder(data.product_id, data.reorder_quantity);
  }
  
  // Alert operations team
  await notifyOperationsTeam(data);
}

async function handleOrderDelivered(data) {
  console.log('Order delivered:', data.order_id);
  
  // Request customer feedback
  await sendFeedbackRequest(data);
  
  // Update customer lifetime value
  await updateCustomerMetrics(data);
}

app.listen(3000, () => {
  console.log('Webhook server running on port 3000');
});

class OrderErrorRecovery {
  constructor(client) {
    this.client = client;
    this.retryQueue = [];
  }
  
  async handleOrderError(order, error) {
    const errorHandlers = {
      'INSUFFICIENT_INVENTORY': this.handleInsufficientInventory,
      'PAYMENT_FAILED': this.handlePaymentFailure,
      'INVALID_ADDRESS': this.handleInvalidAddress,
      'CARRIER_ERROR': this.handleCarrierError,
      'SYSTEM_ERROR': this.handleSystemError
    };
    
    const handler = errorHandlers[error.code] || this.handleGenericError;
    return await handler.call(this, order, error);
  }
  
  async handleInsufficientInventory(order, error) {
    console.log('Handling insufficient inventory for order:', order.id);
    
    // Option 1: Try to allocate from multiple locations
    const multiLocationAllocation = await this.attemptMultiLocationFulfillment(order);
    if (multiLocationAllocation.success) {
      return multiLocationAllocation;
    }
    
    // Option 2: Create backorder
    const backorder = await this.createBackorder(order, error.items);
    
    // Notify customer of delay
    await this.notifyCustomerOfDelay(order, backorder.estimated_restock_date);
    
    return { success: true, type: 'backorder', backorder };
  }
  
  async handlePaymentFailure(order, error) {
    console.log('Handling payment failure for order:', order.id);
    
    // Retry payment with fallback method
    const retryResult = await this.retryPayment(order);
    if (retryResult.success) {
      return retryResult;
    }
    
    // Put order on hold
    await this.client.orders.update(order.id, {
      status: 'payment_pending',
      payment_retry_count: (order.payment_retry_count || 0) + 1
    });
    
    // Send payment failure notification
    await this.sendPaymentFailureNotification(order);
    
    // Schedule retry
    this.schedulePaymentRetry(order);
    
    return { success: false, type: 'payment_pending' };
  }
  
  async handleInvalidAddress(order, error) {
    console.log('Handling invalid address for order:', order.id);
    
    // Try to validate/correct address
    const correctedAddress = await this.validateAndCorrectAddress(order.shipping_address);
    
    if (correctedAddress.valid) {
      // Update order with corrected address
      await this.client.orders.update(order.id, {
        shipping_address: correctedAddress.address
      });
      
      return { success: true, type: 'address_corrected' };
    }
    
    // Request address update from customer
    await this.requestAddressUpdate(order);
    
    return { success: false, type: 'awaiting_address_update' };
  }
  
  async attemptMultiLocationFulfillment(order) {
    const locations = await this.client.locations.list({ type: 'fulfillment' });
    const allocations = [];
    
    for (const item of order.items) {
      const itemAllocations = await this.findInventoryAcrossLocations(item, locations);
      if (itemAllocations.length === 0) {
        return { success: false, missing_item: item };
      }
      allocations.push(...itemAllocations);
    }
    
    // Create split fulfillment orders
    const fulfillmentOrders = await this.createSplitFulfillmentOrders(order, allocations);
    
    return { success: true, fulfillment_orders: fulfillmentOrders };
  }
  
  schedulePaymentRetry(order) {
    // Add to retry queue
    this.retryQueue.push({
      order_id: order.id,
      retry_at: new Date(Date.now() + 2 * 60 * 60 * 1000), // 2 hours
      attempt: order.payment_retry_count || 1
    });
  }
}

class OrderPerformanceMonitor {
  constructor(client) {
    this.client = client;
    this.metrics = new Map();
  }
  
  async trackOrderMetrics(order, stage, data = {}) {
    const metric = {
      order_id: order.id,
      stage,
      timestamp: Date.now(),
      ...data
    };
    
    // Store in memory (in production, use a proper metrics service)
    const key = `${order.id}-${stage}`;
    this.metrics.set(key, metric);
    
    // Send to analytics
    await this.client.analytics.track({
      event: `order.${stage}`,
      properties: metric
    });
  }
  
  async generatePerformanceReport(startDate, endDate) {
    const report = {
      period: { start: startDate, end: endDate },
      summary: {},
      bottlenecks: [],
      recommendations: []
    };
    
    // Get all orders in period
    const orders = await this.client.orders.list({
      created_after: startDate,
      created_before: endDate
    });
    
    // Calculate key metrics
    report.summary = {
      total_orders: orders.length,
      average_fulfillment_time: this.calculateAverageFulfillmentTime(orders),
      on_time_delivery_rate: this.calculateOnTimeDeliveryRate(orders),
      order_accuracy_rate: this.calculateOrderAccuracyRate(orders),
      inventory_turnover: await this.calculateInventoryTurnover(startDate, endDate)
    };
    
    // Identify bottlenecks
    report.bottlenecks = await this.identifyBottlenecks(orders);
    
    // Generate recommendations
    report.recommendations = this.generateRecommendations(report);
    
    return report;
  }
  
  calculateAverageFulfillmentTime(orders) {
    const fulfilledOrders = orders.filter(o => o.fulfilled_at);
    if (fulfilledOrders.length === 0) return 0;
    
    const totalTime = fulfilledOrders.reduce((sum, order) => {
      const created = new Date(order.created_at);
      const fulfilled = new Date(order.fulfilled_at);
      return sum + (fulfilled - created);
    }, 0);
    
    return totalTime / fulfilledOrders.length / (1000 * 60 * 60); // Hours
  }
  
  async identifyBottlenecks(orders) {
    const bottlenecks = [];
    
    // Check for slow fulfillment locations
    const locationPerformance = await this.analyzeLocationPerformance(orders);
    locationPerformance.forEach((perf, location) => {
      if (perf.avg_fulfillment_time > 48) { // 48 hours
        bottlenecks.push({
          type: 'slow_fulfillment',
          location,
          avg_time: perf.avg_fulfillment_time,
          impact: 'high'
        });
      }
    });
    
    // Check for inventory issues
    const inventoryIssues = await this.analyzeInventoryIssues(orders);
    if (inventoryIssues.stockout_rate > 0.05) { // 5%
      bottlenecks.push({
        type: 'inventory_stockouts',
        rate: inventoryIssues.stockout_rate,
        affected_skus: inventoryIssues.affected_skus,
        impact: 'critical'
      });
    }
    
    return bottlenecks;
  }
  
  generateRecommendations(report) {
    const recommendations = [];
    
    // Based on bottlenecks
    report.bottlenecks.forEach(bottleneck => {
      if (bottleneck.type === 'slow_fulfillment') {
        recommendations.push({
          priority: 'high',
          action: 'Optimize fulfillment center operations',
          location: bottleneck.location,
          expected_impact: '20-30% reduction in fulfillment time'
        });
      }
      
      if (bottleneck.type === 'inventory_stockouts') {
        recommendations.push({
          priority: 'critical',
          action: 'Adjust reorder points and safety stock levels',
          affected_skus: bottleneck.affected_skus,
          expected_impact: '90% reduction in stockouts'
        });
      }
    });
    
    // Based on general metrics
    if (report.summary.on_time_delivery_rate < 0.95) {
      recommendations.push({
        priority: 'medium',
        action: 'Review carrier performance and consider alternatives',
        current_rate: report.summary.on_time_delivery_rate,
        target_rate: 0.98
      });
    }
    
    return recommendations;
  }
}

// Usage
const monitor = new OrderPerformanceMonitor(client);
const report = await monitor.generatePerformanceReport(
  new Date('2024-01-01'),
  new Date('2024-01-31')
);

console.log('Performance Report:', report);