feat: Enhance order and payment transaction handling

- Updated OrderDTO to include payment_transactions as an array of PaymentTransactionDTO.
- Introduced PaymentTransactionDTO and related types for better payment transaction management.
- Modified Order interface to accommodate paymentTransactions.
- Updated payment.ts to define PaymentTransaction interface and related types.
- Enhanced admin order management UI to display payment transactions history.
- Added functionality for capturing, refunding, and canceling payments with improved error handling.
- Implemented Mark as Shipped action for orders.
- Cleaned up console logs in product management routes.

Author: gustaavik

src/lib/server/api/commercify.ts

@@ -179,9 +179,9 @@ export interface OrderDTO {
 	currency: string;
 	shipping_address: AddressDTO;
 	billing_address: AddressDTO;
-	payment_details?: PaymentDetails;
 	shipping_details: ShippingOptionDTO;
 	discount_details?: AppliedDiscountDTO;
+	payment_transactions?: PaymentTransactionDTO[];
 	customer: CustomerDetailsDTO;
 	action_required: boolean; // Indicates if action is needed (e.g., payment)
 	action_url?: string; // URL for payment or order actions
@@ -262,6 +262,36 @@ export const PaymentStatusCaptured: PaymentStatus = 'captured';
 export const PaymentStatusRefunded: PaymentStatus = 'refunded';
 export const PaymentStatusCancelled: PaymentStatus = 'cancelled';
 export const PaymentStatusFailed: PaymentStatus = 'failed';
+/**
+ * PaymentTransactionDTO represents a payment transaction
+ */
+export interface PaymentTransactionDTO {
+	id: number /* uint */;
+	transaction_id: string;
+	external_id?: string;
+	type: TransactionType;
+	status: TransactionStatus;
+	amount: number /* float64 */;
+	currency: string;
+	provider: string;
+	created_at: string;
+	updated_at: string;
+}
+/**
+ * TransactionType represents the type of payment transaction
+ */
+export type TransactionType = string;
+export const TransactionTypeAuthorize: TransactionType = 'authorize';
+export const TransactionTypeCapture: TransactionType = 'capture';
+export const TransactionTypeRefund: TransactionType = 'refund';
+export const TransactionTypeCancel: TransactionType = 'cancel';
+/**
+ * TransactionStatus represents the status of a payment transaction
+ */
+export type TransactionStatus = string;
+export const TransactionStatusSuccessful: TransactionStatus = 'successful';
+export const TransactionStatusFailed: TransactionStatus = 'failed';
+export const TransactionStatusPending: TransactionStatus = 'pending';
 
 //////////
 // source: product.go

src/lib/server/api/dtos.ts

@@ -1,6 +1,6 @@
 import type { Checkout, CheckoutItem } from './checkout';
 import type { Price } from './common';
-import type { PaymentDetails, PaymentStatus } from './payment';
+import type { PaymentDetails, PaymentStatus, PaymentTransaction } from './payment';
 
 export interface OrderItem extends CheckoutItem {}
 
@@ -10,6 +10,7 @@ export interface Order extends Checkout {
 	checkoutId: string; // Reference to the original checkout session
 	status: OrderStatus;
 	paymentDetails?: PaymentDetails;
+	paymentTransactions?: PaymentTransaction[];
 	createdAt: string; // ISO date string
 }
 

src/lib/types/order.ts

@@ -10,6 +10,8 @@ export type PaymentStatus =
 	| 'failed';
 export type PaymentProvider = 'stripe' | 'mobilepay';
 
+export type TransactionStatus = 'pending' | 'successful' | 'failed';
+
 export interface PaymentDetails {
 	paymentId: string; // Optional payment ID if available
 	method: PaymentMethod; // e.g., 'credit_card', 'wallet'
@@ -26,3 +28,34 @@ export interface PaymentDetails {
 	createdAt: string; // ISO date string for when the payment was created
 	updatedAt?: string; // Optional ISO date string for when the payment was last updated
 }
+
+export interface PaymentTransaction {
+	id: string;
+	transactionId: string;
+	externalId?: string;
+	type: 'authorize' | 'capture' | 'refund' | 'cancel';
+	status: TransactionStatus;
+	amount: number;
+	currency: string;
+	provider: string;
+	createdAt: string;
+	updatedAt: string;
+}
+
+export interface PaymentTransactionDTO {
+	id: number /* uint */;
+	transaction_id: string;
+	external_id?: string;
+	type: PaymentStatus;
+	status: TransactionStatus;
+	amount: number /* float64 */;
+	currency: string;
+	provider: string;
+	created_at: string;
+	updated_at: string;
+}
+
+export interface PaymentEventInput {
+	amount?: number;
+	isFull: boolean;
+}

src/lib/types/payment.ts

@@ -133,16 +133,16 @@
 														View Details
 													</a>
 												</DropdownMenu.Item>
-												<DropdownMenu.Item>
+												<!-- <DropdownMenu.Item>
 													<Package class="mr-2 h-4 w-4" />
 													Ship Order
-												</DropdownMenu.Item>
-												<DropdownMenu.Item>
+												</DropdownMenu.Item> -->
+												<!-- <DropdownMenu.Item>
 													<CreditCard class="mr-2 h-4 w-4" />
 													Process Payment
 												</DropdownMenu.Item>
 												<DropdownMenu.Separator />
-												<DropdownMenu.Item class="text-red-600">Cancel Order</DropdownMenu.Item>
+												<DropdownMenu.Item class="text-red-600">Cancel Order</DropdownMenu.Item> -->
 											</DropdownMenu.Content>
 										</DropdownMenu.Root>
 									</Table.Cell>

src/routes/admin/orders/+page.svelte

@@ -12,113 +12,113 @@ export const load: PageServerLoad = async ({ params, locals, depends }) => {
 		return fail(404, { error: 'Order ID is required' });
 	}
 
-	try {
-		const orderResult = await commercify.getOrderById(orderId);
+	const orderResult = await commercify.getOrderById(orderId);
 
-		if (!orderResult.success || !orderResult.data) {
-			console.error('Error fetching order:', orderResult.error);
-			return fail(404, {
-				error: orderResult.error || 'Order not found'
+	if (!orderResult.success || !orderResult.data) {
+		console.error('Error fetching order:', orderResult.error);
+		return fail(404, {
+			error: orderResult.error || 'Order not found'
+		});
+	}
+
+	return {
+		order: orderResult.data,
+		orderId
+	};
+};
+
+export const actions: Actions = {
+	capture: async ({ request, locals }) => {
+		const { commercify } = locals;
+		const data = await request.formData();
+		const paymentId = data.get('paymentId') as string;
+
+		if (!paymentId) {
+			return fail(400, { error: 'Payment ID is required' });
+		}
+
+		// Note: The API captures payment by orderId, but we validate paymentId from the form
+		const result = await commercify.captureOrderPayment(paymentId, {
+			isFull: true
+		});
+
+		if (!result.success) {
+			return fail(400, {
+				error: result.error || 'Failed to capture payment'
 			});
 		}
 
 		return {
-			order: orderResult.data,
-			orderId
+			success: true,
+			message: 'Payment captured successfully'
 		};
-	} catch (error) {
-		console.error('Error loading order:', error);
-		return fail(500, {
-			error: 'Failed to load order. Please try again later.'
-		});
-	}
-};
+	},
 
-export const actions: Actions = {
-	capture: async ({ params, locals }) => {
+	refund: async ({ locals, request }) => {
 		const { commercify } = locals;
-		const orderId = params.id;
+		const data = await request.formData();
+		const paymentId = data.get('paymentId') as string;
 
-		if (!orderId) {
+		if (!paymentId) {
 			return fail(400, { error: 'Order ID is required' });
 		}
 
-		try {
-			const result = await commercify.captureOrderPayment(orderId);
-
-			if (!result.success) {
-				return fail(400, {
-					error: result.error || 'Failed to capture payment'
-				});
-			}
-
-			return {
-				success: true,
-				message: 'Payment captured successfully'
-			};
-		} catch (error) {
-			console.error('Error capturing payment:', error);
-			return fail(500, {
-				error: 'Failed to capture payment'
+		const result = await commercify.refundOrderPayment(paymentId, { isFull: true });
+
+		if (!result.success) {
+			return fail(400, {
+				error: result.error || 'Failed to refund payment'
 			});
 		}
+
+		return {
+			success: true,
+			message: 'Payment refunded successfully'
+		};
 	},
 
-	refund: async ({ params, locals }) => {
+	cancel: async ({ request, locals }) => {
 		const { commercify } = locals;
-		const orderId = params.id;
+		const data = await request.formData();
+		const paymentId = data.get('paymentId') as string;
 
-		if (!orderId) {
+		if (!paymentId) {
 			return fail(400, { error: 'Order ID is required' });
 		}
 
-		try {
-			const result = await commercify.refundOrderPayment(orderId);
-
-			if (!result.success) {
-				return fail(400, {
-					error: result.error || 'Failed to refund payment'
-				});
-			}
-
-			return {
-				success: true,
-				message: 'Payment refunded successfully'
-			};
-		} catch (error) {
-			console.error('Error refunding payment:', error);
-			return fail(500, {
-				error: 'Failed to refund payment'
+		const result = await commercify.cancelOrderPayment(paymentId);
+
+		if (!result.success) {
+			return fail(400, {
+				error: result.error || 'Failed to cancel payment'
 			});
 		}
+
+		return {
+			success: true,
+			message: 'Payment cancelled successfully'
+		};
 	},
 
-	cancel: async ({ params, locals }) => {
+	ship: async ({ params, locals }) => {
 		const { commercify } = locals;
 		const orderId = params.id;
 
 		if (!orderId) {
 			return fail(400, { error: 'Order ID is required' });
 		}
 
-		try {
-			const result = await commercify.cancelOrder(orderId);
-
-			if (!result.success) {
-				return fail(400, {
-					error: result.error || 'Failed to cancel order'
-				});
-			}
-
-			return {
-				success: true,
-				message: 'Order cancelled successfully'
-			};
-		} catch (error) {
-			console.error('Error cancelling order:', error);
-			return fail(500, {
-				error: 'Failed to cancel order'
+		const result = await commercify.updateOrderStatus(orderId, 'shipped');
+
+		if (!result.success) {
+			return fail(400, {
+				error: result.error || 'Failed to mark order as shipped'
 			});
 		}
+
+		return {
+			success: true,
+			message: 'Order marked as shipped successfully'
+		};
 	}
 };