AppHighway for E-Commerce: Top 10 API Automations to Boost Sales

// Shopify Product Description Generator
const generateDescription = async (product) => {
  const response = await fetch('https://apphighway.com/api/v1/structify', {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer YOUR_API_KEY',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      text: `Product: ${product.title}\nSpecs: ${JSON.stringify(product.specs)}\nCategory: ${product.category}`,
      schema: {
        description: 'string (150-300 words, SEO-optimized)',
        keyFeatures: 'array of 5-7 bullet points',
        targetKeywords: 'array of relevant SEO keywords'
      },
      instructions: 'Write engaging, conversion-focused copy in friendly tone. Emphasize benefits over features.'
    })
  });
  
  const data = await response.json();
  
  // Update Shopify product
  await shopify.product.update(product.id, {
    body_html: data.description,
    metafields: [
      { key: 'key_features', value: JSON.stringify(data.keyFeatures) },
      { key: 'seo_keywords', value: data.targetKeywords.join(', ') }
    ]
  });
};

// Bulk process all products
const products = await shopify.product.list({ limit: 250 });
for (const product of products) {
  if (!product.body_html) {
    await generateDescription(product);
    await sleep(1000); // Rate limiting
  }
}

// WooCommerce Review Analysis
const analyzeReviews = async (productId) => {
  // Fetch all reviews for product
  const reviews = await wc.get(`products/${productId}/reviews`);
  const reviewTexts = reviews.map(r => r.review).join('\n\n---\n\n');
  
  // Sentiment analysis
  const sentimentResponse = await fetch('https://apphighway.com/api/v1/sentiment-summarizer', {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer YOUR_API_KEY',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      text: reviewTexts,
      options: {
        extractKeyPhrases: true,
        categorizeTopics: true,
        identifyIssues: true
      }
    })
  });
  
  const sentiment = await sentimentResponse.json();
  
  // Extract Q&A from reviews
  const qaResponse = await fetch('https://apphighway.com/api/v1/qa-extractor', {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer YOUR_API_KEY',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      text: reviewTexts,
      extractQuestions: true
    })
  });
  
  const qa = await qaResponse.json();
  
  // Store insights
  await db.productInsights.create({
    productId,
    sentimentScore: sentiment.score,
    positiveCount: sentiment.positive,
    negativeCount: sentiment.negative,
    keyPhrases: sentiment.keyPhrases,
    commonIssues: sentiment.issues,
    frequentQuestions: qa.questions,
    analyzedAt: new Date()
  });
  
  // Alert if negative sentiment spike
  if (sentiment.score < -0.3 && sentiment.negative > 10) {
    await sendAlert({
      type: 'NEGATIVE_REVIEWS',
      product: productId,
      message: `Product has ${sentiment.negative} negative reviews. Common issues: ${sentiment.issues.join(', ')}`
    });
  }
  
  return { sentiment, qa };
};

// Automated review responses
const generateResponse = async (review) => {
  const response = await fetch('https://apphighway.com/api/v1/chatbot-completion', {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer YOUR_API_KEY',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      message: review.review,
      context: `You are a customer service representative for our e-commerce store. Generate a professional, empathetic response to this ${review.rating}-star review.`,
      tone: review.rating >= 4 ? 'grateful' : 'apologetic-helpful'
    })
  });
  
  return await response.json();
};

// Shopify Multi-Currency Implementation
const convertPrices = async (prices, fromCurrency, toCurrency) => {
  const response = await fetch('https://apphighway.com/api/v1/currency-converter', {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer YOUR_API_KEY',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      from: fromCurrency,
      to: toCurrency,
      amounts: prices
    })
  });
  
  const { convertedAmounts, rate } = await response.json();
  return convertedAmounts;
};

// Frontend price display
const displayLocalizedPrices = async () => {
  // Detect customer location
  const location = await fetch('https://ipapi.co/json/').then(r => r.json());
  const currency = location.currency || 'USD';
  
  // Get all product prices
  const products = document.querySelectorAll('[data-product-price]');
  const prices = Array.from(products).map(p => parseFloat(p.dataset.basePrice));
  
  // Convert all at once (1 API call)
  const convertedPrices = await convertPrices(prices, 'USD', currency);
  
  // Update display
  products.forEach((product, index) => {
    const localPrice = convertedPrices[index];
    const formatted = new Intl.NumberFormat(location.country_code, {
      style: 'currency',
      currency: currency
    }).format(localPrice);
    
    product.textContent = formatted;
  });
  
  // Store currency preference
  localStorage.setItem('preferredCurrency', currency);
};

// WooCommerce integration
add_filter('woocommerce_product_get_price', function($price, $product) {
  $customer_currency = WC()->session->get('customer_currency', 'USD');
  
  if ($customer_currency !== 'USD') {
    $cache_key = 'exchange_rate_' . $customer_currency;
    $rate = get_transient($cache_key);
    
    if (!$rate) {
      // Fetch from AppHighway Currency API
      $response = wp_remote_post('https://apphighway.com/api/v1/currency-converter', [
        'headers' => ['Authorization' => 'Bearer ' . APPHIGHWAY_API_KEY],
        'body' => json_encode([
          'from' => 'USD',
          'to' => $customer_currency,
          'amounts' => [1]
        ])
      ]);
      
      $data = json_decode(wp_remote_retrieve_body($response));
      $rate = $data->convertedAmounts[0];
      
      // Cache for 1 hour
      set_transient($cache_key, $rate, HOUR_IN_SECONDS);
    }
    
    return $price * $rate;
  }
  
  return $price;
}, 10, 2);

// Shopify Markets Translation
const translateProduct = async (product, targetLanguage) => {
  const response = await fetch('https://apphighway.com/api/v1/translate', {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer YOUR_API_KEY',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      text: `Title: ${product.title}\n\nDescription: ${product.description}\n\nFeatures: ${product.features.join(', ')}`,
      targetLanguage: targetLanguage,
      context: {
        industry: 'e-commerce',
        productCategory: product.category,
        tone: 'professional-friendly',
        preserveFormatting: true,
        optimizeForSEO: true
      }
    })
  });
  
  const translation = await response.json();
  
  // Parse translated sections
  const sections = translation.translatedText.split('\n\n');
  const translatedTitle = sections[0].replace('Title: ', '');
  const translatedDesc = sections[1].replace('Description: ', '');
  const translatedFeatures = sections[2].replace('Features: ', '').split(', ');
  
  return {
    title: translatedTitle,
    description: translatedDesc,
    features: translatedFeatures
  };
};

// Bulk translate entire catalog
const translateCatalog = async (targetLanguages) => {
  const products = await shopify.product.list({ limit: 250 });
  
  for (const product of products) {
    for (const lang of targetLanguages) {
      const translated = await translateProduct(product, lang);
      
      // Create/update translation in Shopify
      await shopify.translation.upsert({
        resourceId: product.id,
        locale: lang,
        key: 'title',
        value: translated.title
      });
      
      await shopify.translation.upsert({
        resourceId: product.id,
        locale: lang,
        key: 'body_html',
        value: translated.description
      });
      
      // Store features in metafields
      await shopify.metafield.create({
        ownerId: product.id,
        namespace: 'translations',
        key: `features_${lang}`,
        value: JSON.stringify(translated.features),
        type: 'json'
      });
      
      await sleep(500); // Rate limiting
    }
    
    console.log(`Translated product ${product.id} to ${targetLanguages.length} languages`);
  }
};

// WooCommerce WPML Integration
function auto_translate_product($post_id, $language) {
  $product = wc_get_product($post_id);
  
  $response = wp_remote_post('https://apphighway.com/api/v1/translate', [
    'headers' => [
      'Authorization' => 'Bearer ' . APPHIGHWAY_API_KEY,
      'Content-Type' => 'application/json'
    ],
    'body' => json_encode([
      'text' => $product->get_name() . '\n\n' . $product->get_description(),
      'targetLanguage' => $language,
      'context' => [
        'industry' => 'e-commerce',
        'productCategory' => $product->get_category_ids()[0],
        'optimizeForSEO' => true
      ]
    ])
  ]);
  
  $translation = json_decode(wp_remote_retrieve_body($response));
  
  // Create WPML translation
  $translated_post_id = wpml_create_translation([
    'post_id' => $post_id,
    'language' => $language,
    'title' => $translation->title,
    'content' => $translation->description
  ]);
  
  return $translated_post_id;
}

// Shopify Feature Extraction
const extractFeatures = async (product) => {
  const response = await fetch('https://apphighway.com/api/v1/feature-generator', {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer YOUR_API_KEY',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      text: product.body_html,
      productCategory: product.product_type,
      options: {
        featureCount: 7,
        categorizeFeatures: true,
        extractSpecifications: true,
        prioritizeSellingPoints: true
      }
    })
  });
  
  const { features, specifications, categories } = await response.json();
  
  // Update product metafields
  await shopify.metafield.create({
    ownerId: product.id,
    namespace: 'product',
    key: 'key_features',
    value: JSON.stringify(features),
    type: 'json'
  });
  
  await shopify.metafield.create({
    ownerId: product.id,
    namespace: 'product',
    key: 'specifications',
    value: JSON.stringify(specifications),
    type: 'json'
  });
  
  return { features, specifications, categories };
};

// Generate comparison table for variants
const generateComparisonTable = async (products) => {
  const allFeatures = [];
  
  for (const product of products) {
    const { features } = await extractFeatures(product);
    allFeatures.push({
      productId: product.id,
      title: product.title,
      features: features
    });
  }
  
  // Find common feature categories
  const categories = [...new Set(
    allFeatures.flatMap(p => p.features.map(f => f.category))
  )];
  
  // Build comparison table HTML
  let tableHTML = '<table class="comparison-table"><thead><tr><th>Feature</th>';
  allFeatures.forEach(p => {
    tableHTML += `<th>${p.title}</th>`;
  });
  tableHTML += '</tr></thead><tbody>';
  
  categories.forEach(category => {
    tableHTML += `<tr class="category-row"><td colspan="${products.length + 1}">${category}</td></tr>`;
    
    // Get all features in this category
    const categoryFeatures = new Set();
    allFeatures.forEach(p => {
      p.features
        .filter(f => f.category === category)
        .forEach(f => categoryFeatures.add(f.name));
    });
    
    categoryFeatures.forEach(featureName => {
      tableHTML += `<tr><td>${featureName}</td>`;
      allFeatures.forEach(p => {
        const hasFeature = p.features.some(f => f.name === featureName);
        tableHTML += `<td>${hasFeature ? '✓' : '—'}</td>`;
      });
      tableHTML += '</tr>';
    });
  });
  
  tableHTML += '</tbody></table>';
  return tableHTML;
};

// Shopify Inventory Demand Prediction
const analyzeInventoryDemand = async () => {
  // Export 12 months of sales data
  const orders = await shopify.order.list({
    created_at_min: new Date(Date.now() - 365*24*60*60*1000),
    status: 'any',
    limit: 250
  });
  
  // Convert to CSV format
  const csv = convertToCSV(orders);
  
  // Convert CSV to structured JSON
  const csvResponse = await fetch('https://apphighway.com/api/v1/csv-to-json', {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer YOUR_API_KEY',
      'Content-Type': 'text/csv'
    },
    body: csv
  });
  
  const salesData = await csvResponse.json();
  
  // Analyze with Structify for demand patterns
  const analysisResponse = await fetch('https://apphighway.com/api/v1/structify', {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer YOUR_API_KEY',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      text: JSON.stringify(salesData),
      schema: {
        productId: 'string',
        averageMonthlySales: 'number',
        seasonalityFactor: 'number (1.0 = no seasonality)',
        trendDirection: 'string (increasing/stable/decreasing)',
        predictedNextMonthSales: 'number',
        recommendedReorderPoint: 'number',
        recommendedOrderQuantity: 'number',
        stockoutRisk: 'string (low/medium/high)',
        daysUntilStockout: 'number'
      },
      instructions: 'Analyze sales velocity, identify seasonal patterns, calculate optimal reorder points based on lead time of 14 days and desired service level of 95%.'
    })
  });
  
  const predictions = await analysisResponse.json();
  
  // Generate reorder alerts
  const reorderNeeded = predictions.filter(p => 
    p.stockoutRisk === 'high' || p.daysUntilStockout < 21
  );
  
  // Create purchase orders
  for (const product of reorderNeeded) {
    await createPurchaseOrder({
      productId: product.productId,
      quantity: product.recommendedOrderQuantity,
      reason: `Predicted stockout in ${product.daysUntilStockout} days`,
      urgency: product.stockoutRisk
    });
  }
  
  return {
    totalProducts: predictions.length,
    reorderNeeded: reorderNeeded.length,
    predictions: predictions
  };
};

// Slow-moving stock identification
const identifySlowMovers = async () => {
  const inventory = await shopify.inventoryLevel.list();
  const products = await shopify.product.list();
  
  const analysis = [];
  
  for (const item of inventory) {
    const product = products.find(p => p.id === item.product_id);
    const salesLast90Days = await getSalesCount(product.id, 90);
    const inventoryValue = item.available * product.variants[0].price;
    
    const turnoverRate = salesLast90Days / (item.available || 1);
    const daysOfStock = item.available / (salesLast90Days / 90 || 1);
    
    if (daysOfStock > 180 || turnoverRate < 0.1) {
      analysis.push({
        productId: product.id,
        title: product.title,
        available: item.available,
        salesLast90Days,
        daysOfStock: Math.round(daysOfStock),
        inventoryValue: inventoryValue.toFixed(2),
        recommendation: daysOfStock > 365 ? 'Clearance sale' : 'Promotional campaign'
      });
    }
  }
  
  return analysis.sort((a, b) => b.daysOfStock - a.daysOfStock);
};

// Zendesk AI Chatbot Integration
const handleCustomerInquiry = async (ticket) => {
  // Extract customer message and context
  const message = ticket.description;
  const customerEmail = ticket.requester.email;
  
  // Get customer order history
  const orders = await shopify.order.list({
    email: customerEmail,
    limit: 5
  });
  
  // Build context for AI
  const context = `
Customer: ${ticket.requester.name}
Email: ${customerEmail}
Recent orders: ${orders.map(o => `Order #${o.order_number} (${o.created_at}, ${o.financial_status})`).join(', ')}
Return policy: 30 days, free returns
Shipping: 3-5 business days standard, 1-2 days express
`;
  
  // Generate AI response
  const response = await fetch('https://apphighway.com/api/v1/chatbot-completion', {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer YOUR_API_KEY',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      message: message,
      context: context,
      instructions: 'You are a helpful customer service representative. Provide accurate, friendly responses. If you cannot answer definitively, offer to escalate to a human agent.',
      tone: 'professional-friendly',
      maxLength: 300
    })
  });
  
  const aiResponse = await response.json();
  
  // Check if escalation is needed
  const needsEscalation = 
    aiResponse.confidence < 0.7 ||
    message.toLowerCase().includes('speak to a human') ||
    message.toLowerCase().includes('refund');
  
  if (needsEscalation) {
    // Tag for human agent
    await zendesk.ticket.update(ticket.id, {
      comment: {
        body: aiResponse.response + '\n\n[AI: Suggested escalation - low confidence or complex issue]',
        public: false
      },
      tags: ['ai_escalation', 'needs_human_review'],
      status: 'open'
    });
  } else {
    // Send AI response directly
    await zendesk.ticket.update(ticket.id, {
      comment: {
        body: aiResponse.response,
        public: true
      },
      status: 'solved',
      tags: ['ai_resolved']
    });
  }
  
  return { resolved: !needsEscalation, response: aiResponse };
};

// Live chat widget implementation
const initChatbot = () => {
  window.chatWidget = {
    conversationHistory: [],
    
    async sendMessage(userMessage) {
      this.conversationHistory.push({
        role: 'user',
        message: userMessage,
        timestamp: new Date()
      });
      
      // Show typing indicator
      this.showTypingIndicator();
      
      // Get AI response
      const response = await fetch('https://apphighway.com/api/v1/chatbot-completion', {
        method: 'POST',
        headers: {
          'Authorization': 'Bearer YOUR_API_KEY',
          'Content-Type': 'application/json'
        },
        body: JSON.stringify({
          message: userMessage,
          conversationHistory: this.conversationHistory.slice(-5), // Last 5 messages for context
          context: `E-commerce support bot. Website: ${window.location.hostname}`,
          tone: 'friendly-helpful'
        })
      });
      
      const aiResponse = await response.json();
      
      this.conversationHistory.push({
        role: 'assistant',
        message: aiResponse.response,
        timestamp: new Date()
      });
      
      // Display response
      this.hideTypingIndicator();
      this.displayMessage(aiResponse.response, 'bot');
      
      // Track analytics
      this.trackInteraction({
        intent: aiResponse.intent,
        confidence: aiResponse.confidence,
        resolved: aiResponse.confidence > 0.8
      });
    }
  };
};

// Shopify Checkout Email Validation
const validateEmail = async (email) => {
  const response = await fetch('https://apphighway.com/api/v1/email-validator', {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer YOUR_API_KEY',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({ email })
  });
  
  const result = await response.json();
  
  return {
    isValid: result.valid,
    riskScore: result.riskScore, // 0-100, higher = riskier
    emailType: result.type, // personal, business, disposable, role-based
    suggestions: result.suggestions, // Typo corrections (gmail.com vs gmial.com)
    domain: result.domain,
    disposable: result.disposable,
    acceptAll: result.acceptAll // Catch-all domain
  };
};

// WooCommerce checkout validation
add_action('woocommerce_after_checkout_validation', function($data, $errors) {
  $email = $data['billing_email'];
  
  // Validate email
  $response = wp_remote_post('https://apphighway.com/api/v1/email-validator', [
    'headers' => [
      'Authorization' => 'Bearer ' . APPHIGHWAY_API_KEY,
      'Content-Type' => 'application/json'
    ],
    'body' => json_encode(['email' => $email])
  ]);
  
  $result = json_decode(wp_remote_retrieve_body($response));
  
  // Reject invalid or high-risk emails
  if (!$result->valid) {
    $errors->add('email_invalid', 'Please enter a valid email address.');
    
    if (!empty($result->suggestions)) {
      $errors->add('email_suggestion', 'Did you mean: ' . $result->suggestions[0] . '?');
    }
  }
  
  if ($result->disposable) {
    $errors->add('email_disposable', 'Temporary email addresses are not allowed. Please use a permanent email.');
  }
  
  if ($result->riskScore > 70) {
    // Flag for manual review instead of blocking
    update_post_meta($order_id, '_high_risk_email', true);
    update_post_meta($order_id, '_email_risk_score', $result->riskScore);
    
    // Optionally: Require additional verification (phone, address, etc.)
    $errors->add('email_verification', 'For your security, please verify your phone number to complete this order.');
  }
}, 10, 2);

// Frontend real-time validation
const emailInput = document.querySelector('#email');
let validationTimeout;

emailInput.addEventListener('input', (e) => {
  clearTimeout(validationTimeout);
  
  validationTimeout = setTimeout(async () => {
    const email = e.target.value;
    
    if (email.includes('@')) {
      const validation = await validateEmail(email);
      
      if (!validation.isValid) {
        showError('Please enter a valid email address');
        
        if (validation.suggestions.length > 0) {
          showSuggestion(`Did you mean: ${validation.suggestions[0]}?`);
        }
      } else if (validation.disposable) {
        showWarning('Temporary emails are not allowed');
      } else {
        clearErrors();
        showSuccess('Email validated');
      }
    }
  }, 500); // Debounce
});

// Shopify QR Code Generation for Products
const generateProductQR = async (product) => {
  // Create tracking URL with UTM parameters
  const trackingUrl = `https://yourstore.com/products/${product.handle}?utm_source=qr&utm_medium=packaging&utm_campaign=product_${product.id}`;
  
  const response = await fetch('https://apphighway.com/api/v1/qr-generator', {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer YOUR_API_KEY',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      data: trackingUrl,
      size: 1000, // 1000x1000px for print quality
      format: 'png',
      errorCorrection: 'H', // High (30% damage tolerance)
      options: {
        color: '#000000',
        backgroundColor: '#FFFFFF',
        margin: 4,
        includeText: false
      }
    })
  });
  
  const qrData = await response.json();
  
  // Save QR code to Shopify files
  await shopify.file.create({
    filename: `qr_${product.handle}.png`,
    contentType: 'image/png',
    data: qrData.image // Base64 encoded
  });
  
  // Store QR URL in product metafield
  await shopify.metafield.create({
    ownerId: product.id,
    namespace: 'marketing',
    key: 'qr_code_url',
    value: qrData.url,
    type: 'url'
  });
  
  return qrData;
};

// Bulk generate for entire catalog
const generateCatalogQRCodes = async () => {
  const products = await shopify.product.list({ limit: 250 });
  const qrCodes = [];
  
  for (const product of products) {
    const qr = await generateProductQR(product);
    qrCodes.push({
      productId: product.id,
      title: product.title,
      qrUrl: qr.url
    });
    
    await sleep(100); // Rate limiting
  }
  
  // Generate CSV for print vendor
  const csv = convertToCSV(qrCodes);
  await fs.writeFile('product_qr_codes.csv', csv);
  
  return qrCodes;
};

// Warranty registration QR code
const generateWarrantyQR = async (order) => {
  const warrantyUrl = `https://yourstore.com/warranty-register?order=${order.id}&email=${order.email}`;
  
  const response = await fetch('https://apphighway.com/api/v1/qr-generator', {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer YOUR_API_KEY',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      data: warrantyUrl,
      size: 500,
      format: 'png'
    })
  });
  
  const qrData = await response.json();
  
  // Include in order confirmation email
  await sendOrderEmail(order, {
    subject: 'Order Confirmation + Warranty Registration',
    qrCode: qrData.image,
    message: 'Scan this QR code to register your product warranty'
  });
};

// Track QR code scans
app.get('/products/:handle', (req, res) => {
  const { utm_source, utm_medium, utm_campaign } = req.query;
  
  if (utm_source === 'qr') {
    // Log QR scan
    analytics.track({
      event: 'QR Code Scan',
      properties: {
        productHandle: req.params.handle,
        medium: utm_medium,
        campaign: utm_campaign,
        timestamp: new Date(),
        userAgent: req.headers['user-agent']
      }
    });
  }
  
  // Render product page
  res.render('product', { handle: req.params.handle });
});

// Competitor Price Monitoring System
const monitorCompetitorPrices = async () => {
  // Load competitor URLs from database
  const competitorProducts = await db.competitorProducts.findMany();
  
  for (const comp of competitorProducts) {
    try {
      // Fetch page metadata
      const metadataResponse = await fetch('https://apphighway.com/api/v1/url-metadata', {
        method: 'POST',
        headers: {
          'Authorization': 'Bearer YOUR_API_KEY',
          'Content-Type': 'application/json'
        },
        body: JSON.stringify({ url: comp.url })
      });
      
      const metadata = await metadataResponse.json();
      
      // Extract price with Structify
      const priceResponse = await fetch('https://apphighway.com/api/v1/structify', {
        method: 'POST',
        headers: {
          'Authorization': 'Bearer YOUR_API_KEY',
          'Content-Type': 'application/json'
        },
        body: JSON.stringify({
          text: metadata.content,
          schema: {
            price: 'number',
            currency: 'string (3-letter code)',
            inStock: 'boolean',
            shippingCost: 'number or null',
            discount: 'number or null (percentage)',
            originalPrice: 'number or null'
          },
          instructions: 'Extract current product price, stock status, and any discounts. Look for sale prices, strikethrough prices, and shipping information.'
        })
      });
      
      const priceData = await priceResponse.json();
      
      // Store historical data
      await db.priceHistory.create({
        competitorProductId: comp.id,
        price: priceData.price,
        currency: priceData.currency,
        inStock: priceData.inStock,
        discount: priceData.discount,
        scrapedAt: new Date()
      });
      
      // Check for significant price changes
      const previousPrice = await db.priceHistory.findFirst({
        where: { competitorProductId: comp.id },
        orderBy: { scrapedAt: 'desc' },
        skip: 1 // Previous entry
      });
      
      if (previousPrice && previousPrice.price) {
        const priceChange = ((priceData.price - previousPrice.price) / previousPrice.price) * 100;
        
        // Alert on >5% price change
        if (Math.abs(priceChange) > 5) {
          await sendAlert({
            type: 'COMPETITOR_PRICE_CHANGE',
            product: comp.name,
            competitor: comp.competitorName,
            oldPrice: previousPrice.price,
            newPrice: priceData.price,
            changePercent: priceChange.toFixed(2),
            url: comp.url
          });
        }
        
        // Dynamic pricing logic
        if (comp.autoPriceMatch && priceData.inStock) {
          await adjustOwnPrice(comp.ownProductId, priceData.price, comp.pricingStrategy);
        }
      }
      
      await sleep(2000); // Rate limiting
      
    } catch (error) {
      console.error(`Error monitoring ${comp.url}:`, error);
      await db.monitoringErrors.create({
        competitorProductId: comp.id,
        error: error.message,
        timestamp: new Date()
      });
    }
  }
};

// Dynamic pricing strategy
const adjustOwnPrice = async (productId, competitorPrice, strategy) => {
  const product = await shopify.product.get(productId);
  const currentPrice = parseFloat(product.variants[0].price);
  let newPrice;
  
  switch (strategy) {
    case 'MATCH':
      newPrice = competitorPrice;
      break;
    case 'UNDERCUT_5':
      newPrice = competitorPrice * 0.95;
      break;
    case 'MATCH_IF_LOWER':
      newPrice = Math.min(currentPrice, competitorPrice);
      break;
    case 'STAY_WITHIN_10':
      const diff = ((competitorPrice - currentPrice) / currentPrice) * 100;
      if (Math.abs(diff) > 10) {
        newPrice = diff > 0 ? currentPrice * 1.10 : currentPrice * 0.90;
      }
      break;
  }
  
  if (newPrice && newPrice !== currentPrice) {
    // Apply floor price (don't go below cost)
    const floorPrice = product.metafields?.find(m => m.key === 'floor_price')?.value;
    if (floorPrice && newPrice < parseFloat(floorPrice)) {
      console.log(`Price ${newPrice} below floor ${floorPrice}, skipping`);
      return;
    }
    
    // Update Shopify price
    await shopify.variant.update(product.variants[0].id, {
      price: newPrice.toFixed(2)
    });
    
    // Log price change
    await db.priceChanges.create({
      productId,
      oldPrice: currentPrice,
      newPrice: newPrice,
      reason: `Competitor price: ${competitorPrice} (${strategy})`,
      timestamp: new Date()
    });
  }
};