@liiift-studio/sales-portal 1.2.1

package/api/utils/salesDataProcessor.js

@@ -0,0 +1,224 @@
+/**
+ * Main processor for sales data, coordinating Stripe and Sanity data processing
+ */
+
+import { createClient } from '@sanity/client';
+import { createDateRange, createStripeTimeRange, isInDateRange } from './dateUtils';
+import { fetchStripeData } from './stripeFetcher';
+import { processInvoice } from './processors/invoiceProcessor';
+import { processPaymentIntent } from './processors/paymentProcessor';
+
+// Initialize Sanity client
+const client = createClient({
+	projectId: process.env.SANITY_STUDIO_PROJECT_ID,
+	dataset: process.env.SANITY_STUDIO_DATASET,
+	apiVersion: '2022-04-01',
+	token: process.env.SANITY_STUDIO_TOKEN,
+	useCdn: true,
+});
+
+/**
+ * Authenticates a designer using Sanity credentials
+ * @param {string} email - Designer's email
+ * @param {string} password - Designer's password
+ * @returns {Promise<Object>} Authenticated designer data
+ */
+export async function authenticateDesigner(email, password) {
+	try {
+		const designer = await client.fetch(
+			`*[_type == "account" && email == $email && password == $password && isDesigner][0]`,
+			{ email, password }
+		);
+		return designer || null;
+	} catch (error) {
+		console.error('Authentication error:', error);
+		throw new Error('Failed to authenticate designer');
+	}
+}
+
+/**
+ * Fetches Sanity orders for a date range
+ * @param {Date} startDate - Range start date
+ * @param {Date} endDate - Range end date
+ * @returns {Promise<Array>} Array of Sanity orders
+ */
+async function fetchSanityOrders(startDate, endDate) {
+	try {
+		return await client.fetch(
+			`*[_type == "order" && _createdAt >= $startOfMonth && _createdAt <= $endOfMonth]{
+				...,
+				discount->,
+				typefaces[]{
+					...,
+					typeface->{
+						_id,
+						title,
+						author->{
+							_id,
+							firstName,
+							lastName,
+							email
+						},
+					}
+				}
+			}`,
+			{ 
+				startOfMonth: startDate.toISOString(), 
+				endOfMonth: endDate.toISOString() 
+			}
+		);
+	} catch (error) {
+		console.error('Error fetching Sanity orders:', error);
+		throw new Error('Failed to fetch Sanity orders');
+	}
+}
+
+/**
+ * Processes all sales data for a given date range and designer
+ * @param {Object} params - Processing parameters
+ * @param {string} params.date - Single date for month range
+ * @param {Object} [params.dateRange] - Specific date range
+ * @param {Object} params.designer - Authenticated designer data
+ * @param {boolean} [params.admin] - Whether to include all sales (admin only)
+ * @returns {Promise<Array>} Processed sales data
+ */
+export async function processSalesData({ date, dateRange, designer, admin = false }) {
+	try {
+		// Create date ranges
+		const { startDate, endDate } = createDateRange({ date, dateRange });
+		const stripeTimeRange = createStripeTimeRange(startDate, endDate);
+
+		// Fetch data from both sources
+		const [sanitySales, stripeData] = await Promise.all([
+			fetchSanityOrders(startDate, endDate),
+			fetchStripeData(stripeTimeRange, {
+				filterByDesigner: !designer.isAdmin || !admin,
+				designerId: designer._id
+			})
+		]);
+
+		// Process all sales data
+		const processedPaymentIntents = new Set();
+		const allSales = [];
+
+		// Process invoices
+		console.log("Processing invoices...");
+		stripeData.invoices.forEach(invoice => {
+			if (
+				(!designer.isAdmin || !admin) && 
+				!invoice?.metadata?.authors?.includes(designer._id)
+			) {
+				return;
+			}
+
+			// Log payment intent before processing
+			if (invoice.payment_intent) {
+				console.log(`Invoice ${invoice.id} has payment_intent: ${typeof invoice.payment_intent === 'string' ? invoice.payment_intent : 'Object'}`);
+				
+				// Check if it's an object or string
+				if (typeof invoice.payment_intent !== 'string') {
+					console.log(`Payment intent is an object: ${JSON.stringify(invoice.payment_intent)}`);
+					// If it's an object, ensure we're using the ID for tracking
+					if (invoice.payment_intent.id) {
+						invoice.payment_method = invoice.payment_intent.payment_method;
+						invoice.payment_intent = invoice.payment_intent.id;
+						console.log(`Updated to use payment intent ID: ${invoice.payment_intent}`);
+					}
+				}
+			}
+
+			const sales = processInvoice({
+				invoice,
+				sanitySales,
+				processedPaymentIntents
+			});
+			allSales.push(...sales);
+		});
+
+		console.log(`After processing invoices, tracked payment intents: ${Array.from(processedPaymentIntents).join(', ')}`);
+
+		// Process payment intents that don't have associated invoices
+		console.log("Processing payment intents...");
+		stripeData.payments.forEach(payment => {
+			console.log(`Checking payment intent: ${payment.id}`);
+			
+			if (processedPaymentIntents.has(payment.id)) {
+				console.log(`Skipping payment intent ${payment.id} - already processed via invoice`);
+				return; // Skip if already processed via invoice
+			}
+
+			if (
+				(!designer.isAdmin || !admin) && 
+				!payment?.metadata?.authors?.includes(designer._id)
+			) {
+				return;
+			}
+
+			const sales = processPaymentIntent({
+				payment,
+				sanitySales
+			});
+			allSales.push(...sales);
+		});
+
+		// Filter by exact date range
+		const filteredByDate = allSales.filter(sale => 
+			isInDateRange(sale.created, startDate, endDate)
+		);
+
+		// Filter out duplicate transactions with the same Stripe data within an hour
+		const seen = new Map(); // Map<key, Array<timestamp>>
+		const filteredSales = filteredByDate.filter(sale => {
+			// Always keep sales over $0, refunds and shipping provisions
+			if ((sale.refunds && sale.refunds.length > 0) || sale.shippingProvision || sale.total > 0) {
+				return true;
+			}
+
+			// Create a comprehensive key from the sale data
+			const key = JSON.stringify({
+				customerEmail: sale.customer?.email,
+				description: sale.description,
+				total: sale.total,
+				orderNumber: sale.orderNumber,
+				// Include more fields for better duplicate detection
+				taxAmount: sale.taxAmounts?.reduce((sum, tax) => sum + (tax.amount || 0), 0),
+				discountAmount: sale.discountAmounts?.reduce((sum, discount) => sum + (discount.amount || 0), 0),
+				// Additional deduplication for payment methods
+				saleType: sale.saleType,  // 'invoice' or 'paymentIntent'
+				id: sale.id // The Stripe ID (either invoice ID or payment intent ID)
+			});
+
+			// Get the current timestamp
+			const timestamp = sale.created;
+			
+			// Check if we've seen this key before
+			if (seen.has(key)) {
+
+				const timestamps = seen.get(key);
+				
+				// Use a time window (24 hours)
+				const timeWindowInSeconds = 24 * 60 * 60;
+				const isDuplicate = timestamps.some(ts => 
+					Math.abs(ts - timestamp) < timeWindowInSeconds
+				);
+				
+				if (isDuplicate) return false; // Skip this duplicate
+				
+				// Not a duplicate within an hour, add this timestamp to the array
+				timestamps.push(timestamp);
+			} else {
+				// First time seeing this key, initialize with this timestamp
+				seen.set(key, [timestamp]);
+			}
+			
+			return true;
+		});
+
+		// Sort by creation date (newest first)
+		return filteredSales.sort((a, b) => b.created - a.created);
+
+	} catch (error) {
+		console.error('Error processing sales data:', error);
+		throw new Error(`Failed to process sales data: ${error.message}`);
+	}
+}

package/api/utils/stripeFetcher.js

@@ -0,0 +1,248 @@
+/**
+ * Utility functions for fetching data from Stripe API
+ */
+
+const stripe = require('stripe')(process.env.STRIPE_SECRET_KEY);
+
+/**
+ * Fetches dispute details including all balance transactions
+ * @param {Object} dispute - Stripe dispute object
+ * @returns {Promise<Object>} Enhanced dispute object with all transactions
+ */
+async function fetchDisputeDetails(dispute) {
+	if (!dispute) return null;
+
+	// Get dispute with balance transactions
+	const fullDispute = await stripe.disputes.retrieve(dispute.id, {
+		expand: ['balance_transactions']
+	});
+
+	// If there's a dispute charge, get its balance transaction
+	if (fullDispute.charge) {
+		const disputeCharge = await stripe.charges.retrieve(fullDispute.charge, {
+			expand: ['balance_transaction']
+		});
+
+		// Get all balance transactions for this dispute
+		const balanceTransactions = await stripe.balanceTransactions.list({
+			type: 'dispute_fee',
+			source: disputeCharge.id
+		});
+
+		// Add balance transactions to the dispute object
+		fullDispute.charge = disputeCharge;
+		fullDispute.balance_transactions = [
+			...(fullDispute.balance_transactions || []),
+			...balanceTransactions.data
+		];
+	}
+
+	return fullDispute;
+}
+
+/**
+ * Fetches all pages of Stripe invoices for a given date range
+ * @param {Object} timeRange - Stripe-compatible date range
+ * @param {Object} options - Additional fetch options
+ * @param {boolean} [options.filterByDesigner] - Whether to filter by designer
+ * @param {string} [options.designerId] - Designer ID to filter by
+ * @returns {Promise<Array>} Array of all fetched invoices
+ */
+export async function fetchAllInvoices(timeRange, options = {}) {
+	const fetchOptions = {
+		created: timeRange,
+		status: 'paid',
+		limit: 100,
+		expand: [
+			'data.charge',
+			'data.charge.refunds',
+			'data.charge.balance_transaction',
+			'data.charge.dispute',
+			'data.customer',
+			'data.payment_intent',
+			'data.payment_intent.payment_method'
+		]
+	};
+
+	let allInvoices = [];
+	let hasMore = true;
+	let lastId = null;
+	let pageCount = 0;
+
+	while (hasMore) {
+		try {
+			const fetchParams = { ...fetchOptions };
+			if (lastId) {
+				fetchParams.starting_after = lastId;
+			}
+
+			console.log(`Fetching invoice page ${pageCount + 1}...`);
+			const response = await stripe.invoices.list(fetchParams);
+
+			if (response.data.length > 0) {
+				// Filter by designer if needed
+				const invoices = options.filterByDesigner && options.designerId
+					? response.data.filter(invoice => invoice?.metadata?.authors?.includes(options.designerId))
+					: response.data;
+
+				// Log the expansion of payment_intent for debugging
+				if (response.data.length > 0) {
+					const sampleInvoice = response.data[0];
+					console.log('Sample invoice payment_intent type:', typeof sampleInvoice.payment_intent);
+					console.log('Sample invoice payment_intent:', sampleInvoice.payment_intent );
+				}
+
+				// For each invoice with a dispute, fetch additional details
+				const processedInvoices = await Promise.all(invoices.map(async invoice => {
+					if (invoice.charge?.disputed) {
+						invoice.charge.dispute = await fetchDisputeDetails(invoice.charge.dispute);
+					}
+
+					// For each refund, fetch its balance transaction
+					if (invoice.charge?.refunds?.data?.length) {
+						const refundsWithTransactions = await Promise.all(
+							invoice.charge.refunds.data.map(async refund => {
+								const fullRefund = await stripe.refunds.retrieve(refund.id, {
+									expand: ['balance_transaction']
+								});
+								return fullRefund;
+							})
+						);
+						invoice.charge.refunds.data = refundsWithTransactions;
+					}
+
+					// If payment_intent is a string, try to fetch the full object
+					if (invoice.payment_intent && typeof invoice.payment_intent === 'string') {
+						try {
+							const paymentIntent = await stripe.paymentIntents.retrieve(invoice.payment_intent, {
+								expand: ['payment_method']
+							});
+							invoice.payment_intent = paymentIntent;
+							console.log(`Expanded payment intent ${paymentIntent.id} for invoice ${invoice.id}`);
+						} catch (error) {
+							console.warn(`Could not expand payment intent for invoice ${invoice.id}:`, error.message);
+						}
+					}
+
+					return invoice;
+				}));
+
+				allInvoices = allInvoices.concat(processedInvoices);
+				lastId = response.data[response.data.length - 1].id;
+				hasMore = response.has_more;
+				pageCount++;
+
+			} else {
+				hasMore = false;
+			}
+		} catch (error) {
+			console.error('Error fetching invoice page:', error);
+			throw new Error(`Failed to fetch invoice page ${pageCount + 1}: ${error.message}`);
+		}
+	}
+
+	return allInvoices;
+}
+
+/**
+ * Fetches all pages of Stripe payment intents for a given date range
+ * @param {Object} timeRange - Stripe-compatible date range
+ * @param {Object} options - Additional fetch options
+ * @param {boolean} [options.filterByDesigner] - Whether to filter by designer
+ * @param {string} [options.designerId] - Designer ID to filter by
+ * @returns {Promise<Array>} Array of all fetched payment intents
+ */
+export async function fetchAllPaymentIntents(timeRange, options = {}) {
+	const fetchOptions = {
+		created: timeRange,
+		limit: 100,
+		expand: [
+			'data.latest_charge',
+			'data.latest_charge.balance_transaction',
+			'data.latest_charge.dispute',
+			'data.latest_charge.refunds',
+			'data.customer',
+			'data.payment_method'
+		]
+	};
+
+	let allPayments = [];
+	let hasMore = true;
+	let lastId = null;
+	let pageCount = 0;
+
+	while (hasMore) {
+		try {
+			const fetchParams = { ...fetchOptions };
+			if (lastId) {
+				fetchParams.starting_after = lastId;
+			}
+
+			console.log(`Fetching payment intent page ${pageCount + 1}...`);
+			const response = await stripe.paymentIntents.list(fetchParams);
+
+			if (response.data.length > 0) {
+				// Filter succeeded payments and by designer if needed
+				const payments = response.data
+					.filter(pi => pi.status === 'succeeded')
+					.filter(pi => !options.filterByDesigner || !options.designerId || 
+						pi?.metadata?.authors?.includes(options.designerId));
+
+				// For each payment with a dispute, fetch additional details
+				const processedPayments = await Promise.all(payments.map(async payment => {
+					if (payment.latest_charge?.disputed) {
+						payment.latest_charge.dispute = await fetchDisputeDetails(payment.latest_charge.dispute);
+					}
+
+					// For each refund, fetch its balance transaction
+					if (payment.latest_charge?.refunds?.data?.length) {
+						const refundsWithTransactions = await Promise.all(
+							payment.latest_charge.refunds.data.map(async refund => {
+								const fullRefund = await stripe.refunds.retrieve(refund.id, {
+									expand: ['balance_transaction']
+								});
+								return fullRefund;
+							})
+						);
+						payment.latest_charge.refunds.data = refundsWithTransactions;
+					}
+
+					return payment;
+				}));
+
+				allPayments = allPayments.concat(processedPayments);
+				lastId = response.data[response.data.length - 1].id;
+				hasMore = response.has_more;
+				pageCount++;
+
+			} else {
+				hasMore = false;
+			}
+		} catch (error) {
+			console.error('Error fetching payment intent page:', error);
+			throw new Error(`Failed to fetch payment intent page ${pageCount + 1}: ${error.message}`);
+		}
+	}
+
+	return allPayments;
+}
+
+/**
+ * Fetches both invoices and payment intents for a date range
+ * @param {Object} timeRange - Stripe-compatible date range
+ * @param {Object} options - Additional fetch options
+ * @returns {Promise<Object>} Object containing both invoices and payment intents
+ */
+export async function fetchStripeData(timeRange, options = {}) {
+	try {
+		const [invoices, payments] = await Promise.all([
+			fetchAllInvoices(timeRange, options),
+			fetchAllPaymentIntents(timeRange, options)
+		]);
+
+		return { invoices, payments };
+	} catch (error) {
+		console.error('Error fetching Stripe data:', error);
+		throw new Error(`Failed to fetch Stripe data: ${error.message}`);
+	}
+}