@liiift-studio/sales-portal 1.2.1

package/api/utils/processors/paymentProcessor.js

@@ -0,0 +1,462 @@
+/**
+ * Processor for Stripe payment intent data
+ */
+
+import { calculateFees, formatRefunds } from '../feeCalculator';
+
+const debuggingAccounts = ["colby@liiift.studio", "quinn@liiift.studio", "qkeave@gmail.com", "quinn@quitetype.com"];
+
+/**
+ * Finds a matching product based on price and creation time
+ * @param {Object} payment - Payment intent
+ * @param {Object} item - Payment item
+ * @param {Array} sanitySales - Sanity orders to search
+ * @returns {string} Product description or null
+ */
+function findMatchingProduct(payment, item, sanitySales) {
+    if (!payment?.amount || !item?.amount || item.amount <= 0) return null;
+
+    // Look for orders with similar price and creation time
+    const matchingOrders = sanitySales.filter(order => {
+        if (!order?._createdAt) return false;
+
+        const orderTime = new Date(order._createdAt).getTime() / 1000;
+        const paymentTime = payment.created;
+        const timeDiff = Math.abs(orderTime - paymentTime);
+        const dayInSeconds = 24 * 60 * 60;
+
+        // Match if:
+        // 1. Price matches exactly
+        // 2. Created within 2 days of each other
+        return Math.abs(order.cost * 100 - item.amount) < 1 && // Compare in cents with 1 cent tolerance
+               timeDiff < (2 * dayInSeconds); // Within 2 days
+    });
+
+    if (matchingOrders.length > 0) {
+        // Get the order closest in time
+        const closestOrder = matchingOrders.reduce((closest, current) => {
+            const closestTime = new Date(closest._createdAt).getTime() / 1000;
+            const currentTime = new Date(current._createdAt).getTime() / 1000;
+            const closestDiff = Math.abs(closestTime - payment.created);
+            const currentDiff = Math.abs(currentTime - payment.created);
+            return currentDiff < closestDiff ? current : closest;
+        });
+
+        // Generate description from typefaces
+        if (closestOrder?.typefaces?.length) {
+            return closestOrder.typefaces.map(typeface => 
+                `${typeface?.typeface?.title?.toUpperCase()} (${(typeface?.fonts?.length || 0) + 1} styles)`
+            ).join(', ');
+        }
+    }
+
+    return null;
+}
+
+/**
+ * Creates a new order object from payment intent data
+ * @param {Object} payment - Payment intent
+ * @param {Object} item - Payment item
+ * @returns {Object} Created order object
+ */
+function createOrderFromPayment(payment, item) {
+    const email = payment.customer?.email || payment.latest_charge?.billing_details?.email || '';
+    const orderNumber = payment.metadata?.orderNumber || payment.id || '';
+    
+    // Create empty address structure
+    const emptyAddress = {
+        city: "",
+        postalCode: "",
+        email: "",
+        address: "",
+        phone: "",
+        state: "",
+        country: "",
+        name: "",
+        address2: ""
+    };
+
+    // Get billing address from payment
+    const billingAddress = {
+        ...emptyAddress,
+        address: payment.latest_charge?.billing_details?.address?.line1 || "",
+        address2: payment.latest_charge?.billing_details?.address?.line2 || "",
+        postalCode: payment.latest_charge?.billing_details?.address?.postal_code || "",
+        email: email,
+        name: payment.latest_charge?.billing_details?.name || "",
+        country: payment.latest_charge?.billing_details?.address?.country || "",
+        city: payment.latest_charge?.billing_details?.address?.city || "",
+        phone: payment.latest_charge?.billing_details?.phone || "",
+        state: payment.latest_charge?.billing_details?.address?.state || ""
+    };
+
+    // Create order object with minimal required fields
+    return {
+        _type: "order",
+        _id: orderNumber,
+        title: email,
+        orderNumber,
+        cost: payment.amount / 100,
+        _createdAt: new Date(payment.created * 1000).toISOString(),
+        _updatedAt: new Date(payment.created * 1000).toISOString(),
+        orderSuccess: true,
+        billingAddress,
+        orderStatus: {
+            status: "verified",
+            paymentIntentId: payment.id,
+            orderNumber: orderNumber
+        },
+        typefaces: [{
+            typeface: {
+                title: item.description || "Unknown Typeface"
+            }
+        }],
+        slug: {
+            current: `${email}-${orderNumber}`,
+            _type: "slug"
+        }
+    };
+}
+
+/**
+ * Finds matching order and typeface for a payment item
+ * @param {Object} params - Search parameters
+ * @param {Object} params.payment - Payment to match
+ * @param {Object} [params.item] - Payment item (optional)
+ * @param {Array} params.sanitySales - Sanity orders to search
+ * @returns {Object} Matching order and typeface
+ */
+function findMatches({ payment, item = {}, sanitySales = [] }) {
+    if (!payment || !Array.isArray(sanitySales)) {
+        return { associatedOrder: null, associatedTypeface: null };
+    }
+
+    // Find matching order
+    let associatedOrder = sanitySales.find(order => {
+        if (!order?.orderStatus) return false;
+        
+        const isPaymentMatch = order.orderStatus.paymentIntentId === payment.id;
+        const isTimeMatch = payment?.customer?.email && 
+            order._createdAt && 
+            Math.abs(new Date(order._createdAt) - new Date(payment.created * 1000)) < (1000 * 60 * 60);
+        
+        return isPaymentMatch || isTimeMatch;
+    });
+
+    // If no order found, create one from payment data
+    if (!associatedOrder && item) {
+        associatedOrder = createOrderFromPayment(payment, item);
+    }
+
+    // Fix description for unknown items before finding typeface
+    if (item?.description === 'Unknown item' && associatedOrder?.typefaces?.length) {
+        item.description = associatedOrder.typefaces.map(typeface => 
+            `${typeface?.typeface?.title} ${typeface?.fonts?.length ? `(${(typeface?.fonts?.length) + 1} styles)` : ``}`
+        ).join(', ');
+    }
+
+    // Find matching typeface
+    let associatedTypeface = null;
+    if (associatedOrder?.typefaces?.length) {
+        try {
+            const sortedTypefaces = [...associatedOrder.typefaces]
+                .filter(t => t?.typeface?.title)
+                .sort((a, b) => b.typeface.title.length - a.typeface.title.length);
+
+            if (item?.description) {
+                const matchingTypeface = sortedTypefaces.find(typeface => 
+                    item.description.toLowerCase().includes(typeface.typeface.title.toLowerCase())
+                );
+                associatedTypeface = matchingTypeface?.typeface || null;
+            }
+        } catch (error) {
+            console.warn('Error finding matching typeface:', error);
+        }
+    }
+
+    return { associatedOrder, associatedTypeface };
+}
+
+/**
+ * Processes a single item from a payment intent
+ * @param {Object} params - Processing parameters
+ * @param {Object} params.item - Payment item
+ * @param {Object} params.payment - Parent payment intent
+ * @param {Object} params.associatedOrder - Matching Sanity order if found
+ * @param {Object} params.associatedTypeface - Matching typeface if found
+ * @param {number} params.itemIndex - Index of item in payment
+ * @param {number} params.totalItems - Total number of items in payment
+ * @param {boolean} params.isPrimaryItem - Whether this is the first/primary item that gets transaction fees
+ * @param {number} [params.totalFee] - Total transaction fee for the payment (for non-primary items)
+ * @returns {Object} Processed payment item data
+ */
+function processPaymentItem({ item = {}, payment, associatedOrder, associatedTypeface, itemIndex, totalItems, sanitySales, isPrimaryItem = false, totalFee = null }) {
+    // Check if this is a refund - we'll consider it a refund if it has a negative amount
+    // or if the payment status indicates it's a refund
+    const isRefund = (item.amount || 0) < 0 || payment.status === 'refunded';
+    
+    // Calculate proper amounts that account for discounts
+    const discountAmount = payment.metadata?.discount ? Number(payment.metadata.discount) * 100 : 0; // Convert to cents
+    const itemDiscountPortion = discountAmount * ((item.amount || 0) / payment.amount);
+    const itemAmountAdjusted = (item.amount || 0) - itemDiscountPortion;
+    const paymentTotalAdjusted = payment.amount - discountAmount;
+    
+    // Calculate fees and dispute amounts using discount-adjusted values
+    const result = calculateFees({
+        charge: payment.latest_charge,
+        amount: itemAmountAdjusted, // Use discount-adjusted amount
+        total: paymentTotalAdjusted, // Use discount-adjusted total
+        isPrimaryItem,
+        isRefund,
+        totalFee
+    });
+    
+    const { disputed, disputeAmount, totalFees, disputeDetails, totalTransactionFee } = result;
+
+    const itemTaxAmount = (associatedOrder?.tax || 0) / totalItems;
+    const itemTotal = (item.amount || 0) - itemTaxAmount - disputeAmount;
+    const itemTotalWithTax = (item.amount || 0) - disputeAmount;
+
+    // Try to find matching product if no description
+    let description = item.description;
+    if (!description && payment.saleType === "paymentIntent" && item.amount > 0) {
+        description = findMatchingProduct(payment, item, sanitySales);
+    }
+    console.log("description", description);
+    console.log("payment", payment);
+    return {
+        totalWithTax: itemTotalWithTax,
+        total: itemTotal,
+        invoiceTotal: payment.amount,
+        invoiceTotalWithTax: payment.amount,
+        discountAmounts: [],
+        stripeFees: totalFees,
+        disputed,
+        disputeDetails,
+        taxAmounts: [{
+            amount: itemTaxAmount,
+            inclusive: true,
+            tax_rate: null,
+            taxability_reason: null,
+            taxable_amount: item.amount
+        }],
+        refunds: formatRefunds(
+            payment.latest_charge?.refunds?.data,
+            item.amount || 0,
+            payment.amount
+        ),
+        description: description || payment.metadata?.product_description || 'Unknown item',
+        discounts: payment.metadata?.discount ? [{
+            amount: payment.metadata.discount,
+            description: 'Discount applied'
+        }] : [],
+        lineId: `${payment.id}-${itemIndex}`,
+        created: payment.created,
+        id: payment.id,
+        invoicePdf: payment?.latest_charge?.receipt_url || null,
+        number: payment?.latest_charge?.receipt_number || null,
+        customer: payment.customer,
+        testSale: debuggingAccounts.includes(payment?.customer?.email) ||
+            debuggingAccounts.includes(payment?.shipping?.address?.email) ||
+            debuggingAccounts.includes(payment?.latest_charge?.billing_details?.email) ||
+            debuggingAccounts.includes(associatedOrder?.billingAddress?.email) ||
+            debuggingAccounts.includes(associatedOrder?.shippingAddress?.email) ||
+            debuggingAccounts.includes(associatedOrder?.licenseeAddress?.email),
+        customerAddress: payment.shipping?.address || payment.latest_charge?.billing_details?.address || null,
+        // Payment method data
+        paymentMethod: {
+            type: payment?.payment_method?.type,
+            card: payment?.payment_method?.card,
+            origin: payment?.payment_method?.card?.country ? {
+                country: payment?.payment_method?.card?.country
+            } : null
+        },
+        order: associatedOrder || null,
+        orderNumber: associatedOrder?.orderNumber || null,
+        author: associatedTypeface?.author || null,
+        typeface: associatedTypeface || null,
+        saleType: "paymentIntent"
+    };
+}
+
+/**
+ * Processes shipping costs from a payment intent
+ * @param {Object} params - Processing parameters
+ * @param {Object} params.payment - Parent payment intent
+ * @param {Object} params.associatedOrder - Matching Sanity order if found
+ * @param {number} [params.totalFee] - Total transaction fee for the payment (for proportional distribution)
+ * @returns {Object} Processed shipping data
+ */
+function processShippingCost({ payment, associatedOrder, totalFee = null }) {
+    if (!payment?.shipping_cost) {
+        return null;
+    }
+
+    // Check if this is a refund shipping cost
+    const isRefund = payment.shipping_cost < 0 || payment.status === 'refunded';
+    
+    // Shipping should get proportional fee allocation
+    const { disputed, disputeAmount, totalFees, disputeDetails } = calculateFees({
+        charge: payment.latest_charge,
+        amount: payment.shipping_cost,
+        total: payment.amount,
+        isPrimaryItem: false, // Shipping never gets the primary transaction fee
+        isRefund,
+        totalFee // Use the total fee for proportional distribution
+    });
+
+    return {
+        totalWithTax: payment.shipping_cost - disputeAmount,
+        total: payment.shipping_cost - disputeAmount,
+        invoiceTotal: payment.amount,
+        invoiceTotalWithTax: payment.amount,
+        discountAmounts: [],
+        stripeFees: totalFees,
+        disputed,
+        disputeDetails,
+        taxAmounts: [],
+        refunds: formatRefunds(
+            payment.latest_charge?.refunds?.data,
+            payment.shipping_cost,
+            payment.amount
+        ),
+        shippingProvision: true,
+        description: `Shipping for ${associatedOrder?.orderNumber || "?"} : ${payment.id}`,
+        discounts: [],
+        lineId: `${payment.id}-shipping`,
+        created: payment.created,
+        id: payment.id,
+        invoicePdf: null,
+        number: null,
+        customer: payment.customer,
+        testSale: debuggingAccounts.includes(payment?.customer?.email) ||
+            debuggingAccounts.includes(payment?.shipping?.address?.email) ||
+            debuggingAccounts.includes(payment?.latest_charge?.billing_details?.email) ||
+            debuggingAccounts.includes(associatedOrder?.billingAddress?.email) ||
+            debuggingAccounts.includes(associatedOrder?.shippingAddress?.email) ||
+            debuggingAccounts.includes(associatedOrder?.licenseeAddress?.email),
+        customerAddress: payment.shipping?.address || payment.latest_charge?.billing_details?.address || null,
+        // Payment method data
+        paymentMethod: {
+            type: payment?.payment_method?.type,
+            card: payment?.payment_method?.card,
+            origin: payment?.payment_method?.card?.country ? {
+                country: payment?.payment_method?.card?.country
+            } : null
+        },
+        order: associatedOrder || null,
+        orderNumber: associatedOrder?.orderNumber || null,
+        author: null,
+        typeface: null,
+        saleType: "paymentIntent"
+    };
+}
+
+/**
+ * Processes a payment intent and its items
+ * @param {Object} params - Processing parameters
+ * @param {Object} params.payment - Payment intent to process
+ * @param {Array} params.sanitySales - Sanity orders to match against
+ * @returns {Array} Processed sales data
+ */
+export function processPaymentIntent({ payment, sanitySales = [] }) {
+    if (!payment?.amount) {
+        console.warn('Invalid payment intent received:', payment);
+        return [];
+    }
+    
+		// Make sure we're using the payment's ID consistently and extract payment method data
+		let paymentMethodData = null;
+		
+		if (payment.id && typeof payment.id === 'object' && payment.id.id) {
+			console.log(`Payment intent ID is an object, extracting ID: ${payment.id.id}`);
+			payment.id = payment.id.id;
+		}
+		
+		// Extract and store payment method data
+		if (payment.payment_method) {
+			paymentMethodData = payment.payment_method;
+			console.log(`Payment intent ${payment.id} payment method data:`, 
+				JSON.stringify({
+					type: paymentMethodData.type,
+					card_country: paymentMethodData.card?.country
+				}));
+		}
+		
+		console.log(`Processing payment intent: ${payment.id}`);
+
+    const sales = [];
+    let totalStripeFee = null;
+
+    // Parse items from metadata or create default item
+    let items;
+    try {
+        items = payment.metadata?.items ? JSON.parse(payment.metadata.items) : null;
+    } catch (error) {
+        console.warn(`Failed to parse payment items for ${payment.id}:`, error);
+        items = null;
+    }
+
+    // Validate parsed items
+    if (!Array.isArray(items) || items.length === 0 || !items.every(item => item && typeof item === 'object')) {
+        items = [{
+            description: payment.description || 'Unknown item',
+            amount: payment.amount
+        }];
+    }
+
+    // Process each item
+    items.forEach((item, index) => {
+        try {
+            const { associatedOrder, associatedTypeface } = findMatches({ payment, item, sanitySales });
+            // Check if this is a refund item
+            const isRefund = (item.amount || 0) < 0 || payment.status === 'refunded';
+            
+            // Calculate parameters for fee calculation
+            const itemParams = {
+                item, 
+                payment, 
+                associatedOrder, 
+                associatedTypeface,
+                itemIndex: index,
+                totalItems: items.length,
+                sanitySales,
+                isPrimaryItem: index === 0, // First item calculates the total fee
+                isRefund
+            };
+            
+            // For the first non-refund item, calculate the total fee
+            if (index === 0 && !isRefund) {
+                const processedItem = processPaymentItem(itemParams);
+                // Store the total transaction fee for distribution
+                totalStripeFee = processedItem.totalTransactionFee || processedItem.stripeFees;
+                sales.push(processedItem);
+            } else {
+                // For subsequent items, pass the total fee for proportional distribution
+                const processedItem = processPaymentItem({
+                    ...itemParams,
+                    totalFee: totalStripeFee
+                });
+                sales.push(processedItem);
+            }
+        } catch (error) {
+            console.error(`Error processing payment item ${index} for payment ${payment.id}:`, error);
+        }
+    });
+
+    // Process shipping if present
+    try {
+        const shippingCost = processShippingCost({ 
+            payment, 
+            associatedOrder: findMatches({ payment, sanitySales }).associatedOrder,
+            totalFee: totalStripeFee // Pass the total fee for proportional distribution
+        });
+        if (shippingCost) {
+            sales.push(shippingCost);
+        }
+    } catch (error) {
+        console.error(`Error processing shipping cost for payment ${payment.id}:`, error);
+    }
+
+    return sales;
+}