@liiift-studio/sales-portal 1.3.1 → 1.7.0

package/api/getBalanceTransactions.js

@@ -1,66 +1,29 @@
 // API endpoint to fetch Stripe balance transactions for reconciliation
-const stripe = require('stripe')(process.env.STRIPE_SECRET_KEY, {
-	maxNetworkRetries: 3,
-});
+import { stripe } from './utils/clients';
+import { createDateRange, createStripeTimeRange } from './utils/dateUtils';
+import { sendError, requirePost } from './utils/apiResponse';
+
+export const config = { maxDuration: 300 };
 
-/**
- * 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' });
-	}
+	if (!requirePost(req, res)) return;
 
 	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' });
+
+		if (!date && !dateRange) {
+			return sendError(res, 400, 'Either date or dateRange is required');
 		}
 
-		// Fetch all balance transactions for the month
+		// Reuse the same date range logic as getSales for consistent boundaries
+		const { startDate, endDate } = createDateRange({ date, dateRange });
+		const timeRange = createStripeTimeRange(startDate, endDate);
+
+		// Fetch all balance transactions for the period
 		const balanceTransactions = await fetchAllBalanceTransactions(timeRange);
-		
-		// Calculate total balance change for the month (ignoring payouts and pending transactions)
+
+		// Calculate total balance change (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;
 			}
@@ -75,53 +38,36 @@ export default async function handler(req, res) {
 			}
 		});
 	} 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
-		});
+		return sendError(res, 500, 'Failed to fetch balance transactions', error);
 	}
 }
 
 /**
  * Fetches all pages of Stripe balance transactions for a given date range
- * @param {Object} timeRange - Stripe-compatible date range
+ * @param {Object} timeRange - Stripe-compatible date range (Unix seconds)
  * @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;
-			}
+		const fetchParams = { created: timeRange, limit: 100 };
+		if (lastId) fetchParams.starting_after = lastId;
 
-			console.log(`Fetching balance transaction page ${pageCount + 1}...`);
-			const response = await stripe.balanceTransactions.list(fetchParams);
+		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}`);
+		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;
 		}
 	}
+
 	return allTransactions;
 }

package/api/getDesignerInfo.js

@@ -1,36 +1,10 @@
 // API endpoint for retrieving designer information and authentication
+import { sanityClient } from './utils/clients';
+import { sendError, requirePost } from './utils/apiResponse';
 
-// 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, {
-	maxNetworkRetries: 3,
-});
-
-/**
- * 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 || '2022-04-01',
-	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,
@@ -39,63 +13,59 @@ export default async function handler(req, res) {
 		});
 	}
 
-	// Only handle POST requests
-	if (method === 'POST') {
-		const { user, password } = req.body;
+	if (!requirePost(req, res)) return;
+
+	const { user, password } = req.body;
 
-		// Authenticate designer using Sanity
-		const designer = await client.fetch(
+	if (!user || !password) {
+		return sendError(res, 400, 'Email and password are required');
+	}
+
+	try {
+		const designer = await sanityClient.fetch(
 			`*[_type == "account" && email == $user && password == $password && isDesigner][0]`,
 			{ user, password }
 		);
 
-		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
-				}],
-			});
+		if (!designer) {
+			return sendError(res, 401, 'Incorrect email or password.');
+		}
+
+		// Admin user — return all designers
+		if (designer.isAdmin) {
+			const designers = await sanityClient.fetch(`*[_type == "account" && isDesigner]`);
+
+			if (!designers) {
+				return sendError(res, 500, 'Failed to fetch designer accounts');
 			}
-		} else {
-			// Handle authentication failure
-			res.status(200).json({ 
-				success: false, 
-				message: 'Incorrect email or password.' 
+
+			return res.status(200).json({
+				success: true,
+				admin: true,
+				data: designers.map(d => ({
+					_id: d._id,
+					firstName: d?.firstName || (d?.name || 'Nameless'),
+					lastName: d?.lastName || '',
+					user: d.email,
+					password: d.password,
+				})).sort((a, b) =>
+					(a?.firstName || '').localeCompare(b?.firstName || '')
+				),
 			});
 		}
+
+		// Regular designer
+		return 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
+			}],
+		});
+	} catch (error) {
+		return sendError(res, 500, 'Authentication service error', error);
 	}
 }

package/api/getDesigners.js

@@ -1,63 +1,31 @@
 // API endpoint to fetch designer accounts from Sanity CMS
+import { sanityCdnClient } from './utils/clients';
+import { sendSuccess, sendError } from './utils/apiResponse';
 
-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 (req.method !== 'GET') {
+		return sendError(res, 405, 'Method not allowed');
+	}
 
-	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)
-				);
+	try {
+		const designers = await sanityCdnClient.fetch(`*[_type == "account" && isDesigner]`);
 
-			res.status(200).json({
-				success: true,
-				admin: true,
-				data: designerData,
-			});
-		} else {
-			res.status(200).json({ 
-				success: false, 
-				message: 'No designers... thats weird.' 
-			});
+		if (!designers) {
+			return sendError(res, 500, 'No designers found');
 		}
+
+		return sendSuccess(res,
+			designers.map(designer => ({
+				firstName: designer?.firstName || (designer?.name || 'Nameless'),
+				lastName: designer?.lastName || '',
+				_id: designer?._id,
+			})).sort((a, b) =>
+				(a?.firstName || '').localeCompare(b?.firstName || '')
+			)
+		);
+	} catch (error) {
+		return sendError(res, 500, 'Failed to fetch designers', error);
 	}
 }

package/api/getSales.js

@@ -1,50 +1,27 @@
-/**
- * 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
- */
-
+// API endpoint for retrieving sales data from Sanity and Stripe
 import { authenticateDesigner, processSalesData } from './utils/salesDataProcessor';
+import { sendError, requirePost } from './utils/apiResponse';
 
-// 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' });
-	}
+	if (!requirePost(req, res)) return;
 
 	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.' 
-			});
+			return sendError(res, 401, '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.' 
-		});
+		return sendError(res, 500, 'An error occurred while processing sales data.', error);
 	}
 }

package/api/utils/apiResponse.js

@@ -0,0 +1,41 @@
+// Standardized API response helpers for consistent error reporting
+
+/**
+ * Send a success response
+ * @param {Object} res - Next.js response object
+ * @param {*} data - Response data
+ * @param {Object} [meta] - Optional metadata
+ */
+export function sendSuccess(res, data, meta = null) {
+	const body = { success: true, data };
+	if (meta) body.metadata = meta;
+	return res.status(200).json(body);
+}
+
+/**
+ * Send an error response with consistent formatting
+ * @param {Object} res - Next.js response object
+ * @param {number} status - HTTP status code
+ * @param {string} message - User-facing error message
+ * @param {Error} [error] - Original error for server-side logging
+ */
+export function sendError(res, status, message, error = null) {
+	if (error) {
+		console.error(`[${status}] ${message}:`, error.message || error);
+	}
+	return res.status(status).json({ success: false, message });
+}
+
+/**
+ * Require POST method or send 405
+ * @param {Object} req - Next.js request object
+ * @param {Object} res - Next.js response object
+ * @returns {boolean} true if method is POST
+ */
+export function requirePost(req, res) {
+	if (req.method !== 'POST') {
+		sendError(res, 405, 'Method not allowed');
+		return false;
+	}
+	return true;
+}

package/api/utils/authMiddleware.js

@@ -1,27 +1,12 @@
-/**
- * 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,
-});
+// Authentication middleware for sales portal API endpoints
+import { sanityClient } from './clients';
 
 /**
  * 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,
@@ -30,10 +15,8 @@ export async function authMiddleware(req) {
 		};
 	}
 
-	// Extract credentials from request body
 	const { user, password, admin = false } = req.body;
 
-	// Check if credentials are provided
 	if (!user || !password) {
 		return {
 			authorized: false,
@@ -43,13 +26,11 @@ export async function authMiddleware(req) {
 	}
 
 	try {
-		// Query Sanity for designer account
-		const designer = await client.fetch(
+		const designer = await sanityClient.fetch(
 			`*[_type == "account" && email == $email && password == $password && isDesigner][0]`,
 			{ email: user, password }
 		);
 
-		// Verify designer account exists
 		if (!designer) {
 			return {
 				authorized: false,
@@ -58,7 +39,6 @@ export async function authMiddleware(req) {
 			};
 		}
 
-		// Verify admin access if requested
 		if (admin && !designer.isAdmin) {
 			return {
 				authorized: false,
@@ -67,7 +47,6 @@ export async function authMiddleware(req) {
 			};
 		}
 
-		// Authentication successful
 		return {
 			authorized: true,
 			designer,

package/api/utils/clients.js

@@ -0,0 +1,44 @@
+// Shared client instances for Sanity CMS and Stripe API
+import { createClient } from '@sanity/client';
+
+const API_VERSION = '2022-04-01';
+
+// Sanity client for fresh data (auth, writes)
+export const sanityClient = createClient({
+	projectId: process.env.SANITY_STUDIO_PROJECT_ID,
+	dataset: process.env.SANITY_STUDIO_DATASET,
+	apiVersion: process.env.SANITY_STUDIO_API_VERSION || API_VERSION,
+	token: process.env.SANITY_STUDIO_TOKEN,
+	useCdn: false,
+});
+
+// Sanity client with CDN for read-heavy queries
+export const sanityCdnClient = createClient({
+	projectId: process.env.SANITY_STUDIO_PROJECT_ID,
+	dataset: process.env.SANITY_STUDIO_DATASET,
+	apiVersion: API_VERSION,
+	token: process.env.SANITY_STUDIO_TOKEN,
+	useCdn: true,
+});
+
+// Stripe client with automatic retries for rate limiting
+export const stripe = require('stripe')(process.env.STRIPE_SECRET_KEY, {
+	maxNetworkRetries: 3,
+});
+
+// Test accounts excluded from production sales data
+export const TEST_ACCOUNTS = [
+	"colby@liiift.studio",
+	"quinn@liiift.studio",
+	"qkeave@gmail.com",
+	"quinn@quitetype.com"
+];
+
+/**
+ * Checks if a sale involves a test account
+ * @param {Object} params - Objects to check for test email addresses
+ * @returns {boolean} Whether any email matches a test account
+ */
+export function isTestSale(...emailSources) {
+	return emailSources.some(email => email && TEST_ACCOUNTS.includes(email));
+}

package/api/utils/dateUtils.js

@@ -1,42 +1,33 @@
 /**
  * Utility functions for handling dates and time operations in sales data processing
+ * All date operations use UTC to ensure consistent behavior regardless of server timezone
  */
 
-/**
- * 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
+ * @param {number|string|Date} params.dateRange.start - Start date (ms timestamp, ISO string, or Date)
+ * @param {number|string|Date} params.dateRange.end - End date (ms timestamp, ISO string, or Date)
+ * @returns {Object} Start and end dates in UTC
  */
 export function createDateRange({ date, dateRange }) {
 	let startDate, endDate;
 
 	if (dateRange) {
-		startDate = adjustToUTC(new Date(dateRange.start));
-		endDate = adjustToUTC(new Date(dateRange.end));
+		startDate = new Date(dateRange.start);
+		endDate = 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);
+		const year = dateObject.getUTCFullYear();
+		const month = dateObject.getUTCMonth();
+		startDate = new Date(Date.UTC(year, month, 1));
+		const lastDay = new Date(Date.UTC(year, month + 1, 0)).getUTCDate();
+		endDate = new Date(Date.UTC(year, month, lastDay));
 	}
 
-	// Set precise start/end times
+	// Set precise start/end times in UTC
 	startDate.setUTCHours(0, 0, 0, 0);
 	endDate.setUTCHours(23, 59, 59, 999);
 
@@ -47,18 +38,18 @@ export function createDateRange({ date, dateRange }) {
  * 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
+ * @returns {Object} Stripe-compatible date range (Unix seconds)
  */
 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)
+		gte: Math.floor(startDate.getTime() / 1000),
+		lte: Math.floor(endDate.getTime() / 1000)
 	};
 }
 
 /**
- * Checks if a timestamp falls within a date range
- * @param {number} timestamp - Unix timestamp to check
+ * Checks if a Unix timestamp falls within a date range
+ * @param {number} timestamp - Unix timestamp in seconds
  * @param {Date} startDate - Range start date
  * @param {Date} endDate - Range end date
  * @returns {boolean} Whether timestamp is in range