@liiift-studio/sales-portal 1.2.1

package/api/getAnalytics.d.ts

@@ -0,0 +1,38 @@
+// Type definitions for getAnalytics API handler
+import { NextApiRequest, NextApiResponse } from 'next';
+
+export interface GetAnalyticsRequest extends NextApiRequest {
+	query: {
+		month: string;
+		year: string;
+		user?: string;
+		password?: string;
+	};
+}
+
+export interface AnalyticsData {
+	totalRevenue: number;
+	orderCount: number;
+	averageOrderValue: number;
+	topTypefaces?: any[];
+	topLicenseTypes?: any[];
+	geographicDistribution?: any[];
+}
+
+export interface AnalyticsResponse {
+	success: boolean;
+	data?: AnalyticsData;
+	error?: string;
+	message?: string;
+}
+
+export const config: {
+	maxDuration: number;
+};
+
+declare function handler(
+	req: GetAnalyticsRequest,
+	res: NextApiResponse<AnalyticsResponse>
+): Promise<void>;
+
+export default handler;

package/api/getAnalytics.js

@@ -0,0 +1,346 @@
+// API endpoint for fetching sales analytics data 
+import { authMiddleware } from './utils/authMiddleware';
+
+/**
+ * API handler for generating analytics from sales data
+ * @param {Object} req - HTTP request object
+ * @param {Object} res - HTTP response object
+ */
+export default async function handler(req, res) {
+	// Only allow POST requests
+	if (req.method !== 'POST') {
+		return res.status(405).json({ success: false, message: 'Method not allowed' });
+	}
+
+	try {
+		// Authenticate request
+		const { authorized, designer, error } = await authMiddleware(req);
+		
+		if (!authorized) {
+			return res.status(401).json({ success: false, message: error || 'Unauthorized' });
+		}
+
+		// Extract request parameters
+		const { 
+			date, 
+			compareWith = 'previous_month', // 'previous_month', 'previous_year', 'custom'
+			customStartDate, 
+			customEndDate,
+			admin = false
+		} = req.body;
+		
+		if (!date) {
+			return res.status(400).json({ success: false, message: 'Date is required' });
+		}
+
+		// Generate analytics based on current sales data
+		try {
+			// Call your existing sales data retrieval function to get current period data
+			const { getSalesData } = require('./getSales');
+			const currentPeriodSales = await getSalesData(date, designer, admin);
+			
+			// Get comparison period data
+			let comparisonPeriodDate;
+			let comparisonLabel;
+			
+			if (compareWith === 'previous_month') {
+				comparisonPeriodDate = new Date(date);
+				comparisonPeriodDate.setUTCMonth(comparisonPeriodDate.getUTCMonth() - 1);
+				comparisonLabel = 'Previous Month';
+			} else if (compareWith === 'previous_year') {
+				comparisonPeriodDate = new Date(date);
+				comparisonPeriodDate.setUTCFullYear(comparisonPeriodDate.getUTCFullYear() - 1);
+				comparisonLabel = 'Previous Year';
+			} else if (compareWith === 'custom' && customStartDate && customEndDate) {
+				// Handle custom date range
+				comparisonPeriodDate = {
+					start: new Date(customStartDate),
+					end: new Date(customEndDate)
+				};
+				comparisonLabel = 'Custom Range';
+			} else {
+				// Default to previous month
+				comparisonPeriodDate = new Date(date);
+				comparisonPeriodDate.setUTCMonth(comparisonPeriodDate.getUTCMonth() - 1);
+				comparisonLabel = 'Previous Month';
+			}
+			
+			// Fetch comparison period data
+			const comparisonPeriodSales = await getSalesData(comparisonPeriodDate, designer, admin);
+			
+			// Calculate analytics
+			const analytics = generateAnalytics(currentPeriodSales, comparisonPeriodSales);
+			
+			// Return the analytics data
+			return res.status(200).json({ 
+				success: true, 
+				data: analytics,
+				metadata: {
+					currentPeriod: new Date(date).toISOString(),
+					comparisonPeriod: comparisonPeriodDate instanceof Date 
+						? comparisonPeriodDate.toISOString() 
+						: { 
+							start: comparisonPeriodDate.start.toISOString(), 
+							end: comparisonPeriodDate.end.toISOString() 
+						},
+					comparisonLabel
+				}
+			});
+		} catch (error) {
+			console.error('Error generating analytics:', error);
+			return res.status(500).json({ success: false, message: 'Failed to generate analytics' });
+		}
+	} catch (error) {
+		console.error('Error in getAnalytics API:', error);
+		return res.status(500).json({ success: false, message: 'Internal server error' });
+	}
+}
+
+/**
+ * Generate analytics from sales data
+ * @param {Array} currentSales - Current period sales data
+ * @param {Array} comparisonSales - Comparison period sales data
+ * @returns {Object} Analytics data
+ */
+function generateAnalytics(currentSales, comparisonSales) {
+	// Initialize analytics object with proper documentation
+	/**
+	 * Analytics data structure
+	 * Note: All currency values are stored in dollars (not cents)
+	 */
+	const analytics = {
+		summary: {
+			totalRevenue: 0,
+			totalOrders: 0,
+			averageOrderValue: 0,
+			totalTax: 0,
+			totalShipping: 0,
+			totalDiscounts: 0,
+			totalRefunds: 0
+		},
+		comparison: {
+			revenueChange: 0,
+			revenueChangePercent: 0,
+			orderChange: 0,
+			orderChangePercent: 0,
+			aovChange: 0,
+			aovChangePercent: 0
+		},
+		typefaces: [],
+		bestSellingTypefaces: [],
+		worstSellingTypefaces: [],
+		designers: [],
+		topDesigners: [],
+		salesByDay: {},
+		salesByWeekday: {
+			"Sunday": 0,
+			"Monday": 0,
+			"Tuesday": 0,
+			"Wednesday": 0,
+			"Thursday": 0,
+			"Friday": 0,
+			"Saturday": 0
+		}
+	};
+	
+	// Skip processing if no sales data
+	if (!currentSales || currentSales.length === 0) {
+		return analytics;
+	}
+	
+	// Process current period sales data
+	let totalRevenue = 0;
+	let totalTax = 0;
+	let totalShipping = 0;
+	let totalDiscounts = 0;
+	let totalRefunds = 0;
+	
+	// Typeface and designer tracking
+	const typefaceMap = new Map();
+	const designerMap = new Map();
+	const dailySalesMap = new Map();
+	const weekdaySalesMap = new Map();
+	
+	// Initialize weekday totals
+	for (let i = 0; i < 7; i++) {
+		weekdaySalesMap.set(i, 0);
+	}
+	
+	// Process each sale
+	currentSales.forEach(sale => {
+		// Skip shipping provisions
+		if (sale.shippingProvision) {
+			totalShipping += sale.total || 0;
+			return;
+		}
+		
+		// Basic metrics
+		totalRevenue += sale.total || 0;
+		
+		// Tax totals
+		if (sale.taxAmounts && sale.taxAmounts.length) {
+			sale.taxAmounts.forEach(tax => {
+				totalTax += tax.amount || 0;
+			});
+		}
+		
+		// Discount totals
+		if (sale.discountAmounts && sale.discountAmounts.length) {
+			sale.discountAmounts.forEach(discount => {
+				totalDiscounts += discount.amount || 0;
+			});
+		}
+		
+		// Refund totals
+		if (sale.refunds && sale.refunds.length) {
+			sale.refunds.forEach(refund => {
+				totalRefunds += refund.adjustedTotal || 0;
+			});
+		}
+		
+		// Process by typeface
+		const typefaceTitle = getTypefaceTitle(sale);
+		if (typefaceTitle) {
+			const current = typefaceMap.get(typefaceTitle) || { revenue: 0, orders: 0, author: sale.author };
+			current.revenue += sale.total || 0;
+			current.orders += 1;
+			typefaceMap.set(typefaceTitle, current);
+		}
+		
+		// Process by designer
+		if (sale.author) {
+			const designerId = sale.author._id || sale.author;
+			const designerName = sale.author.firstName && sale.author.lastName 
+				? `${sale.author.firstName} ${sale.author.lastName}`
+				: 'Unknown Designer';
+				
+			const current = designerMap.get(designerId) || { id: designerId, name: designerName, revenue: 0, orders: 0 };
+			current.revenue += sale.total || 0;
+			current.orders += 1;
+			designerMap.set(designerId, current);
+		}
+		
+		// Process by day
+		const saleDate = new Date(sale.date || sale.created * 1000);
+		const dayKey = saleDate.toISOString().split('T')[0];
+		const weekdayIndex = saleDate.getUTCDay(); // 0 = Sunday, 6 = Saturday
+		
+		const dailyTotal = dailySalesMap.get(dayKey) || 0;
+		dailySalesMap.set(dayKey, dailyTotal + (sale.total || 0));
+		
+		const weekdayTotal = weekdaySalesMap.get(weekdayIndex) || 0;
+		weekdaySalesMap.set(weekdayIndex, weekdayTotal + (sale.total || 0));
+	});
+	
+	// Process comparison data if available
+	let comparisonRevenue = 0;
+	let comparisonOrders = 0;
+	
+	if (comparisonSales && comparisonSales.length > 0) {
+		comparisonSales.forEach(sale => {
+			if (!sale.shippingProvision) {
+				comparisonRevenue += sale.total || 0;
+				comparisonOrders += 1;
+			}
+		});
+	}
+	
+	// Set summary data
+	analytics.summary.totalRevenue = totalRevenue;
+	analytics.summary.totalOrders = currentSales.filter(sale => !sale.shippingProvision).length;
+	analytics.summary.averageOrderValue = analytics.summary.totalOrders > 0 
+		? totalRevenue / analytics.summary.totalOrders 
+		: 0;
+	analytics.summary.totalTax = totalTax;
+	analytics.summary.totalShipping = totalShipping;
+	analytics.summary.totalDiscounts = totalDiscounts;
+	analytics.summary.totalRefunds = totalRefunds;
+	
+	// Set comparison data
+	analytics.comparison.revenueChange = totalRevenue - comparisonRevenue;
+	analytics.comparison.revenueChangePercent = comparisonRevenue > 0 
+		? (totalRevenue - comparisonRevenue) / comparisonRevenue * 100 
+		: 0;
+	analytics.comparison.orderChange = analytics.summary.totalOrders - comparisonOrders;
+	analytics.comparison.orderChangePercent = comparisonOrders > 0 
+		? (analytics.summary.totalOrders - comparisonOrders) / comparisonOrders * 100 
+		: 0;
+	
+	const comparisonAOV = comparisonOrders > 0 ? comparisonRevenue / comparisonOrders : 0;
+	analytics.comparison.aovChange = analytics.summary.averageOrderValue - comparisonAOV;
+	analytics.comparison.aovChangePercent = comparisonAOV > 0 
+		? (analytics.summary.averageOrderValue - comparisonAOV) / comparisonAOV * 100 
+		: 0;
+	
+	// Set typeface data
+	analytics.typefaces = Array.from(typefaceMap.entries()).map(([title, data]) => ({
+		title,
+		revenue: data.revenue,
+		orders: data.orders,
+		author: data.author
+	}));
+	
+	// Best and worst selling typefaces
+	analytics.bestSellingTypefaces = [...analytics.typefaces]
+		.sort((a, b) => b.revenue - a.revenue)
+		.slice(0, 5);
+		
+	analytics.worstSellingTypefaces = [...analytics.typefaces]
+		.sort((a, b) => a.revenue - b.revenue)
+		.slice(0, 5);
+	
+	// Set designer data
+	analytics.designers = Array.from(designerMap.values());
+	
+	// Top designers
+	analytics.topDesigners = [...analytics.designers]
+		.sort((a, b) => b.revenue - a.revenue)
+		.slice(0, 5);
+	
+	// Sales by day
+	analytics.salesByDay = Object.fromEntries(dailySalesMap);
+	
+	// Sales by weekday
+	analytics.salesByWeekday = {
+		"Sunday": weekdaySalesMap.get(0) || 0,
+		"Monday": weekdaySalesMap.get(1) || 0,
+		"Tuesday": weekdaySalesMap.get(2) || 0,
+		"Wednesday": weekdaySalesMap.get(3) || 0,
+		"Thursday": weekdaySalesMap.get(4) || 0,
+		"Friday": weekdaySalesMap.get(5) || 0,
+		"Saturday": weekdaySalesMap.get(6) || 0
+	};
+	
+	return analytics;
+}
+
+/**
+ * Extract typeface title from sale description
+ * @param {Object} sale - Sale data object
+ * @returns {string} Typeface title
+ */
+function getTypefaceTitle(sale) {
+	if (!sale || !sale.description) return 'Unknown Typeface';
+	
+	let title = sale.description;
+	
+	// Extract title before parentheses
+	const parenIndex = title.indexOf(' (');
+	if (parenIndex !== -1) {
+		title = title.substring(0, parenIndex);
+	}
+	
+	// Extract title before em dash
+	const dashIndex = title.indexOf(' —');
+	if (dashIndex !== -1) {
+		title = title.substring(0, dashIndex);
+	}
+	
+	// Extract title before period
+	const periodIndex = title.indexOf('.');
+	if (periodIndex !== -1) {
+		title = title.substring(0, periodIndex);
+	}
+	
+	return title.trim() || 'Unknown Typeface';
+}

package/api/getBalanceTransactions.d.ts

@@ -0,0 +1,29 @@
+// Type definitions for getBalanceTransactions API handler
+import { NextApiRequest, NextApiResponse } from 'next';
+
+export interface GetBalanceTransactionsRequest extends NextApiRequest {
+	query: {
+		month: string;
+		year: string;
+		user?: string;
+		password?: string;
+	};
+}
+
+export interface BalanceTransactionsResponse {
+	success: boolean;
+	data?: any[];
+	error?: string;
+	message?: string;
+}
+
+export const config: {
+	maxDuration: number;
+};
+
+declare function handler(
+	req: GetBalanceTransactionsRequest,
+	res: NextApiResponse<BalanceTransactionsResponse>
+): Promise<void>;
+
+export default handler;

package/api/getBalanceTransactions.js

@@ -0,0 +1,125 @@
+// API endpoint to fetch Stripe balance transactions for reconciliation
+const stripe = require('stripe')(process.env.STRIPE_SECRET_KEY);
+
+/**
+ * Fetches Stripe balance transactions for a specific month
+ * @param {Object} req - HTTP request object
+ * @param {Object} res - HTTP response object
+ */
+export default async function handler(req, res) {
+	// Only allow POST requests
+	if (req.method !== 'POST') {
+		return res.status(405).json({ success: false, message: 'Method not allowed' });
+	}
+
+	try {
+		// Get date or dateRange from request body
+		const { date, dateRange, admin } = req.body;
+		
+		let timeRange;
+		
+		if (dateRange) {
+			// If dateRange is provided, use it directly
+			if (!dateRange.start || !dateRange.end) {
+				return res.status(400).json({ success: false, message: 'dateRange must include start and end timestamps' });
+			}
+			
+			// Convert millisecond timestamps to seconds for Stripe API
+			timeRange = {
+				gte: Math.floor(dateRange.start / 1000),
+				lte: Math.floor(dateRange.end / 1000)
+			};
+			
+			console.log('Using date range:', {
+				start: new Date(dateRange.start).toISOString(),
+				end: new Date(dateRange.end).toISOString()
+			});
+		} else if (date) {
+			// If only date is provided, create a month range
+			const targetDate = new Date(date);
+			const startOfMonth = new Date(Date.UTC(targetDate.getUTCFullYear(), targetDate.getUTCMonth(), 1, 0, 0, 0));
+			const endOfMonth = new Date(Date.UTC(targetDate.getUTCFullYear(), targetDate.getUTCMonth() + 1, 0, 23, 59, 59));
+			
+			timeRange = {
+				gte: Math.floor(startOfMonth.getTime() / 1000),
+				lte: Math.floor(endOfMonth.getTime() / 1000)
+			};
+			
+			console.log('Using month range:', {
+				start: startOfMonth.toISOString(),
+				end: endOfMonth.toISOString()
+			});
+		} else {
+			return res.status(400).json({ success: false, message: 'Either date or dateRange is required' });
+		}
+
+		// Fetch all balance transactions for the month
+		const balanceTransactions = await fetchAllBalanceTransactions(timeRange);
+		
+		// Calculate total balance change for the month (ignoring payouts and pending transactions)
+		const totalBalanceChange = balanceTransactions.reduce((total, transaction) => {
+			// Skip payout, stripe_fee and pending transactions
+			if (transaction.type === 'payout' || transaction.type === 'stripe_fee' || transaction.status === 'pending') {
+				return total;
+			}
+			return total + transaction.amount;
+		}, 0);
+
+		return res.status(200).json({
+			success: true,
+			data: {
+				totalBalanceChange,
+				transactions: balanceTransactions
+			}
+		});
+	} catch (error) {
+		console.error('Error fetching balance transactions:', error);
+		return res.status(500).json({
+			success: false,
+			message: 'Failed to fetch balance transactions',
+			error: error.message
+		});
+	}
+}
+
+/**
+ * Fetches all pages of Stripe balance transactions for a given date range
+ * @param {Object} timeRange - Stripe-compatible date range
+ * @returns {Promise<Array>} Array of all fetched balance transactions
+ */
+async function fetchAllBalanceTransactions(timeRange) {
+	const fetchOptions = {
+		created: timeRange,
+		limit: 100,
+	};
+
+	let allTransactions = [];
+	let hasMore = true;
+	let lastId = null;
+	let pageCount = 0;
+
+	while (hasMore) {
+		try {
+			const fetchParams = { ...fetchOptions };
+			if (lastId) {
+				fetchParams.starting_after = lastId;
+			}
+
+			console.log(`Fetching balance transaction page ${pageCount + 1}...`);
+			const response = await stripe.balanceTransactions.list(fetchParams);
+
+			if (response.data.length > 0) {
+				allTransactions = allTransactions.concat(response.data);
+				lastId = response.data[response.data.length - 1].id;
+				hasMore = response.has_more;
+				pageCount++;
+			} else {
+				hasMore = false;
+			}
+		} catch (error) {
+			console.error('Error fetching balance transaction page:', error);
+			throw new Error(`Failed to fetch balance transaction page ${pageCount + 1}: ${error.message}`);
+		}
+	}
+	return allTransactions;
+}

package/api/getDesignerInfo.d.ts

@@ -0,0 +1,37 @@
+// Type definitions for getDesignerInfo API handler
+import { NextApiRequest, NextApiResponse } from 'next';
+
+export interface Designer {
+	_id: string;
+	firstName: string;
+	lastName: string;
+	user: string;
+	password?: string;
+}
+
+export interface GetDesignerInfoRequest extends NextApiRequest {
+	body: {
+		user: string;
+		password: string;
+	};
+}
+
+export interface DesignerInfoResponse {
+	success: boolean;
+	designer?: Designer;
+	designers?: Designer[];
+	admin?: boolean;
+	error?: string;
+	message?: string;
+}
+
+export const config: {
+	maxDuration: number;
+};
+
+declare function handler(
+	req: GetDesignerInfoRequest,
+	res: NextApiResponse<DesignerInfoResponse>
+): Promise<void>;
+
+export default handler;

package/api/getDesignerInfo.js

@@ -0,0 +1,98 @@
+// API endpoint for retrieving designer information and authentication
+
+// Configure extended timeout for Vercel serverless function
+export const config = { maxDuration: 300 };
+
+// Import required dependencies
+const { createClient } = require('@sanity/client');
+const stripe = require('stripe')(process.env.STRIPE_SECRET_KEY);
+
+/**
+ * Sanity client configuration for CMS interactions
+ * Uses environment variables for secure configuration
+ */
+const client = createClient({
+	projectId: process.env.SANITY_STUDIO_PROJECT_ID,
+	dataset: process.env.SANITY_STUDIO_DATASET,
+	apiVersion: process.env.SANITY_STUDIO_API_VERSION,
+	token: process.env.SANITY_STUDIO_TOKEN,
+	useCdn: false, // Ensures fresh data by bypassing CDN
+});
+
+/**
+ * API route handler for designer information
+ * Handles authentication and retrieval of designer data
+ * @param {Object} req - HTTP request object containing user credentials
+ * @param {Object} res - HTTP response object
+ */
+export default async function handler(req, res) {
+	const { method } = req;
+
+	// Check if sales portal is enabled
+	if (process.env.SALES_PORTAL_ENABLED === 'false') {
+		return res.status(503).json({
+			success: false,
+			message: 'Sales portal is currently disabled',
+			disabled: true
+		});
+	}
+
+	// Only handle POST requests
+	if (method === 'POST') {
+		const { user, password } = req.body;
+
+		// Authenticate designer using Sanity
+		const designer = await client.fetch(
+			`*[_type == "account" && email == '${user}' && password == '${password}' && isDesigner][0]`
+		);
+
+		if (designer) {
+			// Handle admin user case
+			if (designer.isAdmin) {
+				// Fetch all designers for admin view
+				const designers = await client.fetch(`*[_type == "account" && isDesigner]`);
+				
+				if (designers) {
+				res.status(200).json({
+					success: true,
+					admin: true,
+					data: designers.map(designer => ({
+						_id: designer._id,
+						firstName: designer?.firstName || (designer?.name || 'Nameless'),
+						lastName: designer?.lastName || '',
+						user: designer.email,
+						password: designer.password,
+					})).sort((a, b) => 
+						a?.firstName 
+							? a.firstName.localeCompare(b.firstName) 
+							: a.name.localeCompare(b.name)
+					),
+				});
+				} else {
+					res.status(200).json({ 
+						success: false, 
+						message: 'No designers... thats weird.' 
+					});
+				}
+			} else {
+			// Handle regular designer case
+			res.status(200).json({
+				success: true,
+				data: [{
+					_id: designer._id,
+					firstName: designer?.firstName || (designer?.name || 'Nameless'),
+					lastName: designer?.lastName || '',
+					user: designer.email,
+					password: designer.password
+				}],
+			});
+			}
+		} else {
+			// Handle authentication failure
+			res.status(200).json({ 
+				success: false, 
+				message: 'Incorrect email or password.' 
+			});
+		}
+	}
+}

package/api/getDesigners.d.ts

@@ -0,0 +1,28 @@
+// Type definitions for getDesigners API handler
+import { NextApiRequest, NextApiResponse } from 'next';
+import { Designer } from './getDesignerInfo';
+
+export interface GetDesignersRequest extends NextApiRequest {
+	body: {
+		user: string;
+		password: string;
+	};
+}
+
+export interface DesignersResponse {
+	success: boolean;
+	designers?: Designer[];
+	error?: string;
+	message?: string;
+}
+
+export const config: {
+	maxDuration: number;
+};
+
+declare function handler(
+	req: GetDesignersRequest,
+	res: NextApiResponse<DesignersResponse>
+): Promise<void>;
+
+export default handler;