@liiift-studio/sales-portal 1.2.1

package/api/getDesigners.js

@@ -0,0 +1,63 @@
+// API endpoint to fetch designer accounts from Sanity CMS
+
+const { createClient } = require('@sanity/client');
+
+/**
+ * Configure Next.js API route to allow for longer execution time
+ * @constant {Object} config
+ */
+export const config = { maxDuration: 300 };
+
+/**
+ * Sanity client configuration
+ * @constant {Object} 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,
+});
+
+/**
+ * GET handler to fetch designer accounts
+ * @param {Object} req - Next.js API request object
+ * @param {Object} res - Next.js API response object
+ * @returns {Promise<void>}
+ * @response {Object} success - Indicates if the request was successful
+ * @response {boolean} admin - Always true for this endpoint
+ * @response {Array<Object>} data - Array of designer objects with firstName, lastName, and _id
+ */
+export default async function handler(req, res) {
+	const { method } = req;
+
+	if (method === 'GET') {
+		const designers = await client.fetch(`*[_type == "account" && isDesigner]`);
+		
+		if (designers) {
+			let designerData = designers
+				.map(designer => ({
+					firstName: designer?.firstName || (designer?.name || 'Nameless'),
+					lastName: designer?.lastName || '',
+					_id: designer?._id,
+				}))
+				.sort((a, b) => 
+					a?.firstName 
+						? a.firstName.localeCompare(b.firstName) 
+						: a.name.localeCompare(b.name)
+				);
+
+			res.status(200).json({
+				success: true,
+				admin: true,
+				data: designerData,
+			});
+		} else {
+			res.status(200).json({ 
+				success: false, 
+				message: 'No designers... thats weird.' 
+			});
+		}
+	}
+}

package/api/getPreviousSales.d.ts

@@ -0,0 +1,23 @@
+// Type definitions for getPreviousSales API handler
+import { NextApiRequest, NextApiResponse } from 'next';
+import { SalesAPIResponse } from './getSales';
+
+export interface GetPreviousSalesRequest extends NextApiRequest {
+	query: {
+		month: string;
+		year: string;
+		user?: string;
+		password?: string;
+	};
+}
+
+export const config: {
+	maxDuration: number;
+};
+
+declare function handler(
+	req: GetPreviousSalesRequest,
+	res: NextApiResponse<SalesAPIResponse>
+): Promise<void>;
+
+export default handler;

package/api/getPreviousSales.js

@@ -0,0 +1,82 @@
+// API route for fetching sales data from a previous period
+import { authMiddleware } from './utils/authMiddleware';
+
+/**
+ * API handler for fetching sales data from a previous period
+ * @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 using middleware
+		const { authorized, designer, error } = await authMiddleware(req);
+		
+		if (!authorized) {
+			return res.status(401).json({ success: false, message: error || 'Unauthorized' });
+		}
+
+		// Extract request parameters
+		const { date, comparisonType = 'MoM', admin } = req.body;
+		
+		if (!date) {
+			return res.status(400).json({ success: false, message: 'Date is required' });
+		}
+
+		// Calculate previous period date based on comparison type
+		const currentDate = new Date(date);
+		let previousDate = new Date(currentDate);
+		
+		if (comparisonType === 'MoM') {
+			// Month over Month - go back 1 month
+			previousDate.setUTCMonth(previousDate.getUTCMonth() - 1);
+		} else if (comparisonType === 'YoY') {
+			// Year over Year - go back 1 year
+			previousDate.setUTCFullYear(previousDate.getUTCFullYear() - 1);
+		} else {
+			return res.status(400).json({ success: false, message: 'Invalid comparison type' });
+		}
+
+		// Use the existing getSales logic to fetch sales data for the previous period
+		// This would typically involve database queries or API calls to your sales data source
+		
+		// Call your existing sales data retrieval function
+		// Example: 
+		const salesData = await fetchSalesData(previousDate, designer, admin);
+		
+		// Return the sales data
+		return res.status(200).json({ 
+			success: true, 
+			data: salesData,
+			metadata: {
+				currentPeriod: currentDate.toISOString(),
+				previousPeriod: previousDate.toISOString(),
+				comparisonType
+			}
+		});
+		
+	} catch (error) {
+		console.error('Error fetching previous sales data:', error);
+		return res.status(500).json({ success: false, message: 'Internal server error' });
+	}
+}
+
+/**
+ * Fetch sales data from the database for a given period
+ * @param {Date} date - Date to fetch sales for
+ * @param {Object} designer - Designer information
+ * @param {boolean} admin - Whether the user is an admin
+ * @returns {Promise<Array>} Sales data
+ */
+async function fetchSalesData(date, designer, admin) {
+	// Implement your sales data retrieval logic here
+	// This would typically involve database queries
+	
+	// For now, import and use the same logic from the getSales API endpoint
+	const { getSalesData } = require('./getSales');
+	return await getSalesData(date, designer, admin);
+}

package/api/getSales.d.ts

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

package/api/getSales.js

@@ -0,0 +1,50 @@
+/**
+ * API endpoint for retrieving sales data from Sanity and Stripe for authenticated designers
+ * Combines order data from both platforms and handles refunds, shipping, and tax calculations
+ */
+
+import { authenticateDesigner, processSalesData } from './utils/salesDataProcessor';
+
+// API config for extended processing time
+export const config = { maxDuration: 300 };
+
+/**
+ * API route handler for sales data retrieval
+ * @param {Object} req - Next.js API request object
+ * @param {Object} res - Next.js API response object
+ */
+export default async function handler(req, res) {
+	if (req.method !== 'POST') {
+		return res.status(405).json({ success: false, message: 'Method not allowed' });
+	}
+
+	try {
+		// Extract request parameters
+		const { user, password, date, dateRange, admin } = req.body;
+
+		// Authenticate designer
+		const designer = await authenticateDesigner(user, password);
+		if (!designer) {
+			return res.status(200).json({ 
+				success: false, 
+				message: 'Looks like there was an issue finding the account.' 
+			});
+		}
+
+		// Process sales data
+		const sales = await processSalesData({ date, dateRange, designer, admin });
+
+		// Return processed data
+		res.status(200).json({
+			success: true,
+			data: sales,
+		});
+
+	} catch (error) {
+		console.error('Error in sales data API:', error);
+		res.status(500).json({ 
+			success: false, 
+			message: 'An error occurred while processing sales data.' 
+		});
+	}
+}

package/api/getSalesRange.d.ts

@@ -0,0 +1,23 @@
+// Type definitions for getSalesRange API handler
+import { NextApiRequest, NextApiResponse } from 'next';
+import { SalesAPIResponse } from './getSales';
+
+export interface GetSalesRangeRequest extends NextApiRequest {
+	query: {
+		startDate: string;
+		endDate: string;
+		user?: string;
+		password?: string;
+	};
+}
+
+export const config: {
+	maxDuration: number;
+};
+
+declare function handler(
+	req: GetSalesRangeRequest,
+	res: NextApiResponse<SalesAPIResponse>
+): Promise<void>;
+
+export default handler;

package/api/getSalesRange.js

@@ -0,0 +1,58 @@
+// API endpoint for retrieving sales data within a specified date range
+// File summary: Handles POST requests to retrieve sales data within a specified date range
+import { createClient } from '@sanity/client';
+
+// 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,
+});
+
+export default async function handler(req, res) {
+	if (req.method !== 'POST') {
+		return res.status(405).json({ success: false, message: 'Method not allowed' });
+	}
+
+	const { user, password, startDate, endDate, admin } = req.body;
+
+	if (!user || !password || !startDate || !endDate) {
+		return res.status(400).json({ success: false, message: 'Missing required fields' });
+	}
+
+	try {
+		// Verify user credentials
+		const designer = await client.fetch(
+			`*[_type == "designer" && _id == $user && password == $password][0]{
+				_id,
+				firstName,
+				lastName,
+				admin,
+				password
+			}`,
+			{ user, password }
+		);
+
+		if (!designer) {
+			return res.status(401).json({ success: false, message: 'Invalid credentials' });
+		}
+
+		// Fetch sales data within date range
+		const query = admin ? 
+			`*[_type == "sale" && dateTime >= $startDate && dateTime <= $endDate] | order(dateTime asc)` :
+			`*[_type == "sale" && dateTime >= $startDate && dateTime <= $endDate && references($user)] | order(dateTime asc)`;
+
+		const sales = await client.fetch(query, {
+			user,
+			startDate: new Date(startDate).toISOString(),
+			endDate: new Date(endDate).toISOString()
+		});
+
+		return res.status(200).json({ success: true, data: sales });
+	} catch (error) {
+		console.error('Error fetching sales range:', error);
+		return res.status(500).json({ success: false, message: 'Internal server error' });
+	}
+}

package/api/utils/authMiddleware.js

@@ -0,0 +1,84 @@
+/**
+ * Authentication middleware for sales portal API endpoints
+ * Verifies user credentials against Sanity database and returns designer information
+ */
+
+import { createClient } from '@sanity/client';
+
+// 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,
+});
+
+/**
+ * Middleware to authenticate API requests
+ * Validates credentials and returns designer data
+ * @param {Object} req - HTTP request object with user credentials
+ * @returns {Object} Authentication result with authorized flag, designer data, and error message
+ */
+export async function authMiddleware(req) {
+	// Check if sales portal is enabled via environment variable
+	if (process.env.SALES_PORTAL_ENABLED === 'false') {
+		return {
+			authorized: false,
+			designer: null,
+			error: 'Sales portal is currently disabled'
+		};
+	}
+
+	// Extract credentials from request body
+	const { user, password, admin = false } = req.body;
+
+	// Check if credentials are provided
+	if (!user || !password) {
+		return {
+			authorized: false,
+			designer: null,
+			error: 'Email and password are required'
+		};
+	}
+
+	try {
+		// Query Sanity for designer account
+		const designer = await client.fetch(
+			`*[_type == "account" && email == $email && password == $password && isDesigner][0]`,
+			{ email: user, password }
+		);
+
+		// Verify designer account exists
+		if (!designer) {
+			return {
+				authorized: false,
+				designer: null,
+				error: 'Invalid credentials'
+			};
+		}
+
+		// Verify admin access if requested
+		if (admin && !designer.isAdmin) {
+			return {
+				authorized: false,
+				designer: null,
+				error: 'Admin privileges required'
+			};
+		}
+
+		// Authentication successful
+		return {
+			authorized: true,
+			designer,
+			error: null
+		};
+	} catch (error) {
+		console.error('Authentication error:', error);
+		return {
+			authorized: false,
+			designer: null,
+			error: 'Authentication service error'
+		};
+	}
+}

package/api/utils/dateUtils.js

@@ -0,0 +1,69 @@
+/**
+ * Utility functions for handling dates and time operations in sales data processing
+ */
+
+/**
+ * Adjusts a date to UTC, handling timezone offsets
+ * @param {Date} date - The date to adjust
+ * @returns {Date} UTC-adjusted date
+ */
+export function adjustToUTC(date) {
+	const newDate = new Date(date);
+	newDate.setMinutes(newDate.getMinutes() - newDate.getTimezoneOffset());
+	return newDate;
+}
+
+/**
+ * Creates a date range for a given month or specific range
+ * @param {Object} params - Date parameters
+ * @param {string|Date} params.date - Single date for month range
+ * @param {Object} [params.dateRange] - Specific date range
+ * @param {string|Date} params.dateRange.start - Start date
+ * @param {string|Date} params.dateRange.end - End date
+ * @returns {Object} Start and end dates
+ */
+export function createDateRange({ date, dateRange }) {
+	let startDate, endDate;
+
+	if (dateRange) {
+		startDate = adjustToUTC(new Date(dateRange.start));
+		endDate = adjustToUTC(new Date(dateRange.end));
+	} else {
+		const dateObject = new Date(date);
+		startDate = new Date(dateObject.getUTCFullYear(), dateObject.getUTCMonth(), 1);
+		// Get the last day of the current month by finding the last day that still belongs to this month
+		const lastDay = new Date(dateObject.getUTCFullYear(), dateObject.getUTCMonth() + 1, 0).getUTCDate();
+		endDate = new Date(dateObject.getUTCFullYear(), dateObject.getUTCMonth(), lastDay);
+	}
+
+	// Set precise start/end times
+	startDate.setUTCHours(0, 0, 0, 0);
+	endDate.setUTCHours(23, 59, 59, 999);
+
+	return { startDate, endDate };
+}
+
+/**
+ * Creates a date range suitable for Stripe API queries
+ * @param {Date} startDate - Range start date
+ * @param {Date} endDate - Range end date
+ * @returns {Object} Stripe-compatible date range
+ */
+export function createStripeTimeRange(startDate, endDate) {
+	return {
+		gte: Math.floor(new Date(startDate.getTime() - 24 * 60 * 60 * 1000).getTime() / 1000),
+		lte: Math.floor(new Date(endDate.getTime() + 24 * 60 * 60 * 1000).getTime() / 1000)
+	};
+}
+
+/**
+ * Checks if a timestamp falls within a date range
+ * @param {number} timestamp - Unix timestamp to check
+ * @param {Date} startDate - Range start date
+ * @param {Date} endDate - Range end date
+ * @returns {boolean} Whether timestamp is in range
+ */
+export function isInDateRange(timestamp, startDate, endDate) {
+	const date = timestamp * 1000; // Convert to milliseconds
+	return date >= startDate.getTime() && date <= endDate.getTime();
+}

package/api/utils/feeCalculator.js

@@ -0,0 +1,148 @@
+/**
+ * Shared utilities for fee calculations
+ * Fixed to handle transaction fees correctly for multiple line items
+ */
+
+/**
+ * Calculates total transaction fees for a charge (first pass)
+ * @param {Object} charge - Stripe charge object
+ * @param {boolean} isRefund - Whether this is a refund transaction
+ * @returns {number} Total transaction fees
+ */
+function calculateTotalTransactionFees(charge, isRefund) {
+	// Don't calculate transaction fees for refunds
+	if (isRefund) return 0;
+	
+	// Calculate regular Stripe fees
+	let stripeFees = 0;
+	if (charge?.balance_transaction?.fee_details) {
+		stripeFees = charge.balance_transaction.fee_details.reduce((total, fee) => {
+			if (fee.type === 'stripe_fee') {
+				return total + fee.amount;
+			}
+			return total;
+		}, 0);
+	}
+	
+	return stripeFees;
+}
+
+/**
+ * Calculates all fees for a charge
+ * @param {Object} params - Calculation parameters
+ * @param {Object} params.charge - Stripe charge object
+ * @param {number} params.amount - Amount for this item
+ * @param {number} params.total - Total amount of the charge
+ * @param {boolean} params.isPrimaryItem - Whether this is the primary/first item that should calculate the total fee
+ * @param {boolean} params.isRefund - Whether this item is a refund
+ * @param {number} [params.totalFee] - Pre-calculated total fee (provided for non-primary items)
+ * @returns {Object} Calculated fees and amounts
+ */
+export function calculateFees({ charge, amount, total, isPrimaryItem = false, isRefund = false, totalFee = null }) {
+	// For invoice items, amount often includes the raw amount without considering discounts
+	// Additionally, the total might not account for all discounts applied
+	// This is especially problematic for refunded items where the ratio calculation is critical
+	
+	// Calculate the effective amount and total that properly accounts for discounts
+	// For refunded items, we need to ensure we're using the pre-discount values for consistent ratio calculation
+	const effectiveAmount = amount;
+	const effectiveTotal = total;
+	const ratio = effectiveTotal !== 0 ? effectiveAmount / effectiveTotal : 0;
+	const dispute = charge?.dispute;
+
+	// Calculate dispute amounts
+	const disputeAmount = (dispute?.amount || 0) * ratio;
+	
+	// Get dispute fees from balance transactions
+	let disputeFees = 0;
+
+	// Get fees from dispute balance transactions - only if there's an actual dispute
+	if (dispute?.balance_transactions?.length) {
+		// For disputes, we still calculate the full fee amount
+		// because these are charged per-dispute, not per-transaction
+		disputeFees = dispute.balance_transactions.reduce((total, transaction) => {
+			// The dispute fee is directly in the fee field
+			return total + (transaction.fee || 0);
+		}, 0);
+	}
+
+	// Calculate or retrieve transaction fees
+	let stripeFees = 0;
+	
+	if (isRefund) {
+		// No transaction fees for refunds
+		stripeFees = 0;
+	} else if (isPrimaryItem) {
+		// For primary item, calculate the total fee but only assign its proportional part
+		const totalStripeFee = calculateTotalTransactionFees(charge, isRefund);
+		// Apply only this item's proportion of the fee
+		stripeFees = Math.round(totalStripeFee * ratio);
+		// Return the full fee as well for distribution to other items
+		return {
+			disputed: !!charge?.disputed,
+			disputeAmount,
+			disputeFees,
+			stripeFees,  // This item's portion
+			totalFees: stripeFees,  // This item's portion of fees
+			totalTransactionFee: totalStripeFee,  // The full transaction fee to distribute
+			disputeDetails: dispute ? {
+				amount: disputeAmount,
+				fees: disputeFees,
+				status: dispute.status,
+				reason: dispute.reason,
+				evidence: dispute.evidence,
+				created: dispute.created,
+				balanceTransactions: dispute.balance_transactions,
+				charge: dispute.charge
+			} : null
+		};
+	} else if (totalFee !== null) {
+		// For non-primary items, distribute the fee proportionally
+		stripeFees = Math.round(totalFee * ratio);
+	}
+
+	// For disputed charges, add dispute fees only
+	// Regular transaction fees are distributed proportionally for non-refund items
+	const totalFees = dispute ? disputeFees : stripeFees;
+
+	return {
+		disputed: !!charge?.disputed,
+		disputeAmount,
+		disputeFees,
+		stripeFees,
+		totalFees,
+		disputeDetails: dispute ? {
+			amount: disputeAmount,
+			fees: disputeFees,
+			status: dispute.status,
+			reason: dispute.reason,
+			evidence: dispute.evidence,
+			created: dispute.created,
+			balanceTransactions: dispute.balance_transactions,
+			charge: dispute.charge
+		} : null
+	};
+}
+
+/**
+ * Maps refund data to a consistent format
+ * @param {Array} refunds - Array of Stripe refund objects
+ * @param {number} amount - Amount for this item
+ * @param {number} total - Total amount
+ * @returns {Array} Formatted refund data
+ */
+export function formatRefunds(refunds, amount, total) {
+	if (!refunds?.length) return [];
+
+	const ratio = amount / total;
+	return refunds.map(refund => ({
+		total: refund.amount,
+		created: refund.created,
+		id: refund.id,
+		description: refund.reason,
+		status: refund.status,
+		percentOf_total: ratio,
+		adjustedTotal: refund.amount * ratio,
+		balance_transaction: refund.balance_transaction
+	}));
+}