Partner API Documentation

// Helper function to make authenticated requests
async function makeAuthenticatedRequest(endpoint, method = 'GET', body = null) {
  const url = `https://us-central1-sp3nddotshop-prod.cloudfunctions.net/\${endpoint}`;
  
  const options = {
    method,
    headers: {
      'Content-Type': 'application/json',
      'X-API-Key': API_KEY,
      'X-API-Secret': API_SECRET,
    },
  };
  
  if (body) {
    options.body = JSON.stringify(body);
  }
  
  const response = await fetch(url, options);
  return await response.json();
}

// Create a cart (simple format - just URL and quantity)
async function createCart(productUrl, quantity = 1) {
  return await makeAuthenticatedRequest('createPartnerCart', 'POST', {
    items: [{ product_url: productUrl, quantity }]
  });
}

// Or create cart with full product details
async function createCartWithDetails(items) {
  return await makeAuthenticatedRequest('createPartnerCart', 'POST', { items });
}

// Add item to cart (auto-scrapes product details)
async function addItemToCart(cartId, productUrl, quantity = 1) {
  return await makeAuthenticatedRequest(`addItemToPartnerCart/\${cartId}`, 'POST', {
    product_url: productUrl,
    quantity
  });
}

// Update cart shipping address (calculates tax automatically)
async function updateCartShippingAddress(cartId, shippingAddress) {
  return await makeAuthenticatedRequest(`updateCartShippingAddress/\${cartId}`, 'PATCH', {
    shipping_address: shippingAddress
  });
}

// Create an order
async function createOrder(cartId, shippingAddress, customerEmail, isTest = false) {
  return await makeAuthenticatedRequest('createPartnerOrder', 'POST', {
    cart_id: cartId,
    shipping_address: shippingAddress,
    customer_email: customerEmail,
    test: isTest, // Set to true for test orders
  });
}

// Create payment transaction
async function createPayment(orderId, orderNumber, amount, recipientAddress, customerWallet) {
  return await makeAuthenticatedRequest('createPartnerTransaction', 'POST', {
    order_id: orderId,
    order_number: orderNumber,
    amount: amount,
    currency: 'USD',
    memo: `SP3ND Order: \${orderNumber}`,
    recipient_address: recipientAddress, // from the createPartnerOrder response
    sender_address: customerWallet,
  });
}

// Get orders (with optional filters)
async function getOrders(limit = 50, status = null, userWallet = null, customerEmail = null) {
  const params = new URLSearchParams({ limit: limit.toString() });
  if (status) params.append('status', status);
  if (userWallet) params.append('user_wallet', userWallet);
  if (customerEmail) params.append('customer_email', customerEmail);
  
  return await makeAuthenticatedRequest(`getPartnerOrders?\${params}`);
}

// Get single order by order_id or order_number
async function getOrder(orderIdOrNumber) {
  return await makeAuthenticatedRequest(`getPartnerOrder/\${orderIdOrNumber}`, 'GET');
}

async function processOrder(productUrls, shippingAddress, customerEmail, customerWallet, isTest = false) {
  try {
    // 1. Create cart (start with first item)
    const cartResult = await createCart(productUrls[0], 1);
    const cartId = cartResult.cart.cart_id;
    
    // 2. Add additional items one by one
    for (let i = 1; i < productUrls.length; i++) {
      await addItemToCart(cartId, productUrls[i], 1);
    }
    
    // 3. Update shipping address (calculates tax automatically)
    await updateCartShippingAddress(cartId, shippingAddress);
    
    // 4. Create order
    const orderResult = await createOrder(cartId, shippingAddress, customerEmail, isTest);
    const orderId = orderResult.order.order_id;
    const orderNumber = orderResult.order.order_number;
    const totalAmount = orderResult.order.total_amount;
    
    // 5. Create payment transaction
    const paymentResult = await createPayment(
      orderId,
      orderNumber,
      totalAmount,
      orderResult.order.recipient_address,
      customerWallet
    );
    
    // 6. Return order details to customer
    return {
      orderId,
      orderNumber,
      totalAmount,
      memo: paymentResult.memo,
      recipientAddress: paymentResult.recipient_address,
    };
  } catch (error) {
    console.error('Error processing order:', error);
    throw error;
  }
}