fix: Remove COD transaction creation to fix checkout errors

The transaction creation was failing due to HANDLE_PAYMENTS permission issues.
Removed the code to get checkout working again. Will implement via
order metadata or core-extensions webhook instead.

ONE-PAGE-CHECKOUT-PLAN.md

@@ -0,0 +1,367 @@
+# One-Page Checkout Implementation Plan
+
+**Branch:** `feature/one-page-checkout`  
+**Status:** In Development  
+**Priority:** High  
+**Phone Requirement:** Required (not optional)
+
+---
+
+## Overview
+
+Convert the current two-phase checkout into a streamlined one-page checkout experience where customers can see all fields at once and complete their order in a single action.
+
+### Current State
+- **Phase 1:** Collect email, shipping address → fetch shipping methods
+- **Phase 2:** Select shipping method, billing address → complete order
+- **Total API calls:** 6-7 sequential requests across 2 user interactions
+
+### Target State
+- **Single Page:** All fields visible simultaneously
+- **Dynamic updates:** Shipping methods fetch automatically when address changes
+- **Single submit:** One "Complete Order" button
+- **Optimized API:** 3-4 sequential steps (parallel where possible)
+
+---
+
+## Requirements
+
+### Must-Have
+- [ ] All checkout fields visible on single page
+- [ ] Phone number is **required** (strict validation)
+- [ ] Shipping methods fetch automatically (debounced) when address changes
+- [ ] Real-time total calculation (updates when shipping method selected)
+- [ ] Single "Complete Order" submit button
+- [ ] Section-based validation with inline errors
+- [ ] Auto-scroll to first error on validation failure
+- [ ] Preserve form data on error
+
+### UX Requirements
+- [ ] Clear visual hierarchy (Contact → Shipping → Billing → Shipping Method → Payment)
+- [ ] Collapsible sections (optional - all expanded by default)
+- [ ] Loading states for shipping method fetching
+- [ ] Disabled submit button until all required fields valid
+- [ ] Success confirmation page (existing)
+
+### Technical Requirements
+- [ ] Debounced shipping method API calls (500ms)
+- [ ] Optimistic UI updates where possible
+- [ ] Proper error handling per section
+- [ ] Analytics events for checkout steps
+- [ ] Mobile-responsive layout
+
+---
+
+## UI Layout
+
+### Left Column (Form - 60% width on desktop)
+
+```
+┌─────────────────────────────────────┐
+│  1. Contact Information             │
+│  ├─ Email * [________________]      │
+│  └─ Phone * [________________]      │
+│     [+381... format hint]           │
+├─────────────────────────────────────┤
+│  2. Shipping Address                │
+│  ├─ First Name * [____________]     │
+│  ├─ Last Name * [_____________]     │
+│  ├─ Country * [▼ Serbia ▼]          │
+│  ├─ Street Address * [________]     │
+│  ├─ Apt/Suite [______________]      │
+│  ├─ City * [_________________]      │
+│  └─ Postal Code * [__________]      │
+├─────────────────────────────────────┤
+│  3. Billing Address                 │
+│  [✓] Same as shipping address       │
+│  (Fields hidden when checked)       │
+├─────────────────────────────────────┤
+│  4. Shipping Method                 │
+│  (Loading... / Select to see        │
+│   available options)                │
+│  ○ Standard (2-3 days)     400 RSD  │
+│  ○ Express (1-2 days)      800 RSD  │
+├─────────────────────────────────────┤
+│  5. Payment Method                  │
+│  ● Cash on Delivery                 │
+│  (Additional payment methods TBD)   │
+├─────────────────────────────────────┤
+│  [ Complete Order - 3,600 RSD ]     │
+│  Loading spinner when processing    │
+└─────────────────────────────────────┘
+```
+
+### Right Column (Order Summary - 40% width on desktop)
+
+```
+┌─────────────────────────────────────┐
+│  Order Summary                      │
+├─────────────────────────────────────┤
+│  Product Image  Serum x1    3,200   │
+│                                 RSD │
+├─────────────────────────────────────┤
+│  Subtotal                 3,200 RSD │
+│  Shipping                   400 RSD │
+│  ─────────────────────────────────  │
+│  Total                    3,600 RSD │
+└─────────────────────────────────────┘
+```
+
+### Mobile Layout
+Single column, stacked sections with sticky order summary at bottom.
+
+---
+
+## Technical Implementation
+
+### State Management
+
+```typescript
+// Form state (existing)
+const [shippingAddress, setShippingAddress] = useState<AddressForm>({...});
+const [billingAddress, setBillingAddress] = useState<AddressForm>({...});
+const [sameAsShipping, setSameAsShipping] = useState(true);
+
+// New state
+const [paymentMethod, setPaymentMethod] = useState<string>("cod");
+const [errors, setErrors] = useState<ValidationErrors>({
+  contact: null,
+  shipping: null,
+  billing: null,
+  shippingMethod: null,
+  general: null,
+});
+```
+
+### Debounced Shipping Method Fetching
+
+```typescript
+useEffect(() => {
+  if (!isAddressComplete(shippingAddress)) return;
+  
+  const timer = setTimeout(() => {
+    fetchShippingMethods();
+  }, 500); // 500ms debounce
+  
+  return () => clearTimeout(timer);
+}, [shippingAddress]);
+```
+
+### Validation Schema
+
+```typescript
+const validationRules = {
+  email: (value) => /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value),
+  phone: (value) => {
+    // Country-specific validation
+    // Serbia: +381 XX XXX XXXX
+    // Bosnia: +387 XX XXX XXX
+    // etc.
+  },
+  required: (value) => value.trim().length > 0,
+  postalCode: (value, country) => {
+    // Country-specific postal code validation
+  },
+};
+```
+
+### API Call Sequence
+
+**Optimized Flow (parallel + sequential):**
+
+```
+Step 1: Validation (client-side)
+  ├─ Validate all fields
+  └─ Show inline errors
+
+Step 2: Parallel Independent Calls
+  ├─ Update Email
+  └─ Update Shipping Address
+  (Both can run simultaneously)
+
+Step 3: Conditional Call
+  └─ Update Billing Address (if different from shipping)
+
+Step 4: Sequential Dependent Calls
+  ├─ Update Shipping Method
+  ├─ Update Metadata (phone, language, payment method)
+  └─ Complete Checkout
+
+Total: 4 sequential steps vs current 7+
+```
+
+### Error Handling Strategy
+
+**Field-level:**
+- Real-time validation on blur
+- Visual indicators (red border, error message)
+- Prevent submit if validation fails
+
+**Section-level:**
+- Group errors by section
+- Show section header in red if has errors
+- Expand section if collapsed and has errors
+
+**Form-level:**
+- On submit: validate all fields
+- If errors: scroll to first error, show summary
+- If API error: show in relevant section, preserve data
+
+**API-level:**
+- Map Saleor errors to form fields when possible
+- Generic error: show at top of form
+- Network error: show retry button
+
+---
+
+## Files to Modify
+
+### Primary Files
+
+1. **`/src/app/[locale]/checkout/page.tsx`**
+   - Major refactor of checkout flow
+   - Combine Phase 1 & Phase 2 into single component
+   - Add debounced shipping method fetching
+   - Implement section-based validation
+   - Optimize API call sequence
+
+2. **`/src/lib/saleor/mutations/Checkout.ts`**
+   - Ensure all mutations available
+   - Add metadata update mutation if needed
+
+3. **`/src/lib/saleor/queries/Checkout.ts`**
+   - Ensure checkout query returns shipping methods
+
+### Translation Files
+
+4. **`/messages/sr.json`** (and other language files)
+   - Add new translation keys for one-page checkout
+   - Section headers
+   - Validation messages
+   - Button labels
+
+### Styling
+
+5. **`/src/app/globals.css`** (or Tailwind config)
+   - Ensure consistent form styling
+   - Add validation state styles
+   - Loading spinner styles
+
+---
+
+## Implementation Phases
+
+### Phase 1: Core Structure (Day 1-2)
+- [ ] Refactor checkout page layout
+- [ ] Display all sections simultaneously
+- [ ] Keep existing form logic working
+- [ ] Test existing flow still works
+
+### Phase 2: Dynamic Shipping Methods (Day 3)
+- [ ] Implement debounced fetching
+- [ ] Add loading states
+- [ ] Display shipping methods inline
+- [ ] Update total when method selected
+
+### Phase 3: Validation & Error Handling (Day 4)
+- [ ] Implement field-level validation
+- [ ] Add section-based error display
+- [ ] Auto-scroll to errors
+- [ ] Test all validation scenarios
+
+### Phase 4: Optimization (Day 5)
+- [ ] Optimize API call sequence
+- [ ] Add parallel mutation execution
+- [ ] Improve loading states
+- [ ] Add optimistic updates
+
+### Phase 5: Polish (Day 6)
+- [ ] Mobile responsiveness
+- [ ] Analytics events
+- [ ] Accessibility improvements
+- [ ] Final testing
+
+---
+
+## Testing Checklist
+
+### Functionality Tests
+- [ ] Fill all fields, submit successfully
+- [ ] Verify order created in Saleor
+- [ ] Verify emails sent
+- [ ] Change shipping method, verify total updates
+- [ ] Change address, verify shipping methods refetch
+
+### Validation Tests
+- [ ] Submit with empty email → email error
+- [ ] Submit with empty phone → phone error
+- [ ] Submit with invalid email format → format error
+- [ ] Submit with invalid phone → format error
+- [ ] Submit with empty required fields → field errors
+- [ ] Submit without selecting shipping method → shipping error
+
+### Edge Cases
+- [ ] Slow network (test debouncing)
+- [ ] No shipping methods available
+- [ ] API failure during submission
+- [ ] Partial API failure (some mutations succeed)
+- [ ] Browser refresh (preserve data?)
+
+### Mobile Tests
+- [ ] Layout works on iPhone SE
+- [ ] Layout works on iPhone 14 Pro Max
+- [ ] Touch targets large enough
+- [ ] Scroll behavior smooth
+
+### Accessibility Tests
+- [ ] Tab navigation works
+- [ ] Screen reader friendly
+- [ ] Error announcements
+- [ ] Focus management
+
+---
+
+## Rollout Strategy
+
+1. **Development:** Complete on feature branch
+2. **Testing:** Local testing with all scenarios
+3. **Staging:** Deploy to dev.manoonoils.com
+4. **Monitoring:** Check for errors, conversion rates
+5. **Production:** Merge to master and deploy
+
+---
+
+## Success Metrics
+
+- **Conversion Rate:** Should increase (fewer steps = less drop-off)
+- **Time to Complete:** Should decrease (single page vs two phases)
+- **Error Rate:** Should decrease (better validation)
+- **Mobile Completion:** Should improve (optimized for mobile)
+
+---
+
+## Future Enhancements (Out of Scope)
+
+- [ ] Save addresses for logged-in users
+- [ ] Address autocomplete (Google Maps)
+- [ ] Multiple payment methods (Stripe, etc.)
+- [ ] Guest checkout improvements
+- [ ] Order notes/comments field
+- [ ] Gift wrapping options
+- [ ] Promo code input
+
+---
+
+## Notes
+
+- Phone number is **strictly required** - validate format per country
+- Keep existing checkout success page
+- Maintain multi-language support
+- Ensure analytics tracking works
+- Don't break existing cart functionality
+
+---
+
+**Created:** March 28, 2026  
+**Branch:** feature/one-page-checkout  
+**Next Step:** Start Phase 1 - Core Structure

docs/CHECKOUT_ARCHITECTURE_ANALYSIS.md

@@ -0,0 +1,317 @@
+# Checkout Architecture Analysis
+
+## What Broke: Root Cause Analysis
+
+### The Incident
+Yesterday, checkout confirmation emails were working correctly in the customer's selected language. Today, they started arriving in English regardless of the customer's language preference.
+
+### Root Cause
+**Implicit Dependency on Step Ordering**
+
+The checkout flow had a critical implicit requirement: the `languageCode` field MUST be set on the checkout object BEFORE calling `checkoutComplete`. This was discovered through trial and error, not through explicit architecture.
+
+### Why Small Changes Broke It
+
+The checkout flow was implemented as a **procedural monolith** in `page.tsx`:
+
+```typescript
+// ❌ BEFORE: Monolithic function (440+ lines)
+const handleSubmit = async () => {
+  // Step 1: Email
+  await updateEmail()
+  
+  // Step 2: Language ← This was added today
+  await updateLanguage()  // <- Without this, emails are in wrong language!
+  
+  // Step 3: Addresses
+  await updateBillingAddress()
+  
+  // Step 4: Shipping
+  await updateShippingMethod()
+  
+  // Step 5: Metadata
+  await updateMetadata()
+  
+  // Step 6: Complete
+  await checkoutComplete()
+}
+```
+
+**Problems with this approach:**
+
+1. **No explicit contracts**: Nothing says "language must be set before complete"
+2. **Ordering is fragile**: Moving steps around breaks functionality
+3. **No isolation**: Can't test individual steps
+4. **Tight coupling**: UI, validation, API calls, and business logic all mixed
+5. **No failure boundaries**: One failure stops everything, but unclear where
+
+## The Fix: Proper Abstraction
+
+### New Architecture
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                    UI Layer (Page Component)                  │
+│  - Form handling                                             │
+│  - Display logic                                              │
+│  - Error display                                              │
+└───────────────────────┬─────────────────────────────────────┘
+                        │
+                        ▼
+┌─────────────────────────────────────────────────────────────┐
+│                 Checkout Service Layer                        │
+│  - executeCheckoutPipeline()                                 │
+│  - Enforces step ordering                                    │
+│  - Validates inputs                                          │
+│  - Handles failures                                          │
+└───────────────────────┬─────────────────────────────────────┘
+                        │
+                        ▼
+┌─────────────────────────────────────────────────────────────┐
+│                 Individual Steps (Composable)                 │
+│  - updateCheckoutEmail()                                     │
+│  - updateCheckoutLanguage()  ← CRITICAL: Before complete!     │
+│  - updateShippingAddress()                                   │
+│  - updateBillingAddress()                                    │
+│  - updateShippingMethod()                                    │
+│  - updateCheckoutMetadata()                                  │
+│  - completeCheckout()                                        │
+└───────────────────────┬─────────────────────────────────────┘
+                        │
+                        ▼
+┌─────────────────────────────────────────────────────────────┐
+│                    Saleor API Client                          │
+└─────────────────────────────────────────────────────────────┘
+```
+
+### Key Improvements
+
+#### 1. **Explicit Pipeline**
+```typescript
+// ✅ AFTER: Explicit pipeline with enforced ordering
+export async function executeCheckoutPipeline(input: CheckoutInput) {
+  // Step 1: Email
+  const emailResult = await updateCheckoutEmail(checkoutId, email);
+  if (!emailResult.success) return { success: false, error: emailResult.error };
+
+  // Step 2: Language (CRITICAL for email language)
+  const languageResult = await updateCheckoutLanguage(checkoutId, languageCode);
+  if (!languageResult.success) return { success: false, error: languageResult.error };
+  // ^^^ This MUST happen before complete - enforced by structure!
+
+  // Step 3: Addresses
+  // ...
+  
+  // Step 7: Complete
+  return completeCheckout(checkoutId);
+}
+```
+
+**Benefits:**
+- Order is enforced by code structure, not comments
+- Each step validates its result before continuing
+- Clear failure points
+
+#### 2. **Composable Steps**
+Each step is an independent, testable function:
+
+```typescript
+// Can be tested in isolation
+export async function updateCheckoutLanguage(
+  checkoutId: string,
+  languageCode: string
+): Promise<CheckoutStepResult> {
+  const { data } = await saleorClient.mutate({
+    mutation: CHECKOUT_LANGUAGE_CODE_UPDATE,
+    variables: { checkoutId, languageCode },
+  });
+
+  if (data?.checkoutLanguageCodeUpdate?.errors?.length) {
+    return { success: false, error: data.checkoutLanguageCodeUpdate.errors[0].message };
+  }
+
+  return { success: true };
+}
+```
+
+**Benefits:**
+- Unit testable
+- Can be reused in other flows
+- Can be mocked for testing
+- Clear input/output contracts
+
+#### 3. **Validation Separation**
+```typescript
+// Pure validation functions
+export function validateAddress(address: Partial<Address>): string | null {
+  if (!address.firstName?.trim()) return "First name is required";
+  if (!address.phone?.trim() || address.phone.length < 8) return "Valid phone is required";
+  return null;
+}
+```
+
+**Benefits:**
+- Validation is deterministic and testable
+- No UI dependencies
+- Can be reused
+
+#### 4. **Service Class for Complex Use Cases**
+```typescript
+// For cases that need step-by-step control
+const checkoutService = createCheckoutService(checkoutId);
+await checkoutService.updateEmail(email);
+await checkoutService.updateLanguage(locale); // Explicitly called
+// ... custom logic ...
+await checkoutService.complete();
+```
+
+## Comparison: Before vs After
+
+| Aspect | Before (Monolithic) | After (Service Layer) |
+|--------|--------------------|----------------------|
+| **Lines of code** | 440+ in one function | ~50 in UI, 300 in service |
+| **Testability** | ❌ Can't unit test | ✅ Each step testable |
+| **Step ordering** | ❌ Implicit/fragile | ✅ Enforced by structure |
+| **Failure handling** | ❌ Try/catch spaghetti | ✅ Result-based, explicit |
+| **Reusability** | ❌ Copy-paste only | ✅ Import and compose |
+| **Type safety** | ⚠️ Inline types | ✅ Full TypeScript |
+| **Documentation** | ❌ Comments only | ✅ Code is self-documenting |
+
+## Critical Business Rules Now Explicit
+
+```typescript
+// These rules are now ENFORCED by code, not comments:
+
+// Rule 1: Language must be set before checkout completion
+const languageResult = await updateCheckoutLanguage(checkoutId, languageCode);
+if (!languageResult.success) {
+  return { success: false, error: languageResult.error }; // Pipeline stops!
+}
+// Only after success do we proceed to complete...
+
+// Rule 2: Any step failure stops the pipeline
+const emailResult = await updateCheckoutEmail(checkoutId, email);
+if (!emailResult.success) {
+  return { success: false, error: emailResult.error }; // Early return!
+}
+
+// Rule 3: Validation happens before any API calls
+const validationError = validateCheckoutInput(input);
+if (validationError) {
+  return { success: false, error: validationError }; // Fail fast!
+}
+```
+
+## Why This Won't Break Again
+
+### 1. **Enforced Ordering**
+The pipeline function physically cannot complete checkout without first setting the language. It's not a comment—it's code structure.
+
+### 2. **Fail Fast**
+Validation happens before any API calls. Invalid data never reaches Saleor.
+
+### 3. **Explicit Error Handling**
+Each step returns a `CheckoutStepResult` with `success` boolean. No exceptions for flow control.
+
+### 4. **Composable Design**
+If we need to add a new step (e.g., "apply coupon"), we insert it into the pipeline:
+```typescript
+const couponResult = await applyCoupon(checkoutId, couponCode);
+if (!couponResult.success) return { success: false, error: couponResult.error };
+```
+The location in the pipeline shows its dependency order.
+
+### 5. **Type Safety**
+TypeScript enforces that all required fields are present before the pipeline runs.
+
+## Migration Path
+
+### Phase 1: Keep Both (Current)
+- Old code in `page.tsx` continues to work
+- New service available for new features
+- Gradual migration
+
+### Phase 2: Migrate UI
+Replace the monolithic `handleSubmit` with service call:
+```typescript
+// In page.tsx
+import { createCheckoutService } from '@/lib/services/checkoutService';
+
+const handleSubmit = async () => {
+  const checkoutService = createCheckoutService(checkout.id);
+  
+  const result = await checkoutService.execute({
+    email: shippingAddress.email,
+    shippingAddress: transformToServiceAddress(shippingAddress),
+    billingAddress: transformToServiceAddress(billingAddress),
+    shippingMethodId: selectedShippingMethod,
+    languageCode: locale,
+    metadata: { phone: shippingAddress.phone, userLanguage: locale },
+  });
+  
+  if (result.success) {
+    setOrderNumber(result.order!.number);
+    clearCheckout();
+  } else {
+    setError(result.error);
+  }
+};
+```
+
+### Phase 3: Remove Old Code
+Once confirmed working, remove the inline mutations from `page.tsx`.
+
+## Testing Strategy
+
+With the new architecture, we can test each component:
+
+```typescript
+// Test individual steps
+import { updateCheckoutLanguage, validateAddress } from './checkoutService';
+
+describe('updateCheckoutLanguage', () => {
+  it('should fail if checkout does not exist', async () => {
+    const result = await updateCheckoutLanguage('invalid-id', 'EN');
+    expect(result.success).toBe(false);
+  });
+});
+
+describe('validateAddress', () => {
+  it('should require phone number', () => {
+    const error = validateAddress({ ...validAddress, phone: '' });
+    expect(error).toContain('phone');
+  });
+});
+
+// Test full pipeline
+import { executeCheckoutPipeline } from './checkoutService';
+
+describe('executeCheckoutPipeline', () => {
+  it('should stop if language update fails', async () => {
+    // Mock language failure
+    jest.spyOn(checkoutService, 'updateCheckoutLanguage').mockResolvedValue({
+      success: false, error: 'Language not supported'
+    });
+    
+    const result = await executeCheckoutPipeline(validInput);
+    expect(result.success).toBe(false);
+    expect(result.error).toBe('Language not supported');
+  });
+});
+```
+
+## Conclusion
+
+The previous architecture was **accidentally fragile** because:
+1. Business rules were implicit (language must be set before complete)
+2. Step ordering was by convention, not enforcement
+3. Everything was tightly coupled in one function
+4. No clear boundaries between concerns
+
+The new architecture is **intentionally robust** because:
+1. Business rules are enforced by code structure
+2. Step ordering is physically enforced by the pipeline
+3. Each component has a single, clear responsibility
+4. Strong TypeScript contracts prevent misuse
+
+**Small changes will no longer break critical functionality** because the architecture makes dependencies explicit and enforces them at compile time and runtime.

docs/COD-IMPLEMENTATION-PLAN.md

@@ -0,0 +1,320 @@
+# Cash on Delivery (COD) Implementation Plan
+
+**Branch:** `feature/cash-on-delivery`  
+**Status:** In Development  
+**Created:** March 29, 2026  
+
+---
+
+## 1. ARCHITECTURE DECISIONS
+
+### Payment Method Type: Simple Transaction
+- Uses Saleor's native `Transaction` objects
+- No Payment App required (COD is manual payment)
+- Creates transaction with status `NOT_CHARGED`
+- Staff marks as paid via Dashboard when cash collected
+
+### Why This Approach:
+- ✅ Native Saleor data structures
+- ✅ Appears in Dashboard automatically
+- ✅ No metadata hacks
+- ✅ Extensible to other simple payments (Bank Transfer)
+- ✅ Compatible with Payment Apps later (Stripe, etc.)
+
+---
+
+## 2. FILE STRUCTURE
+
+```
+src/
+├── lib/
+│   ├── config/
+│   │   └── paymentMethods.ts          # Payment methods configuration
+│   └── saleor/
+│       └── payments/
+│           ├── types.ts                # Payment type definitions
+│           ├── cod.ts                  # COD-specific logic
+│           └── createTransaction.ts    # Generic transaction creator
+│
+├── components/
+│   └── payment/
+│       ├── PaymentMethodSelector.tsx   # Payment method selection UI
+│       ├── PaymentMethodCard.tsx       # Individual payment card
+│       └── CODInstructions.tsx         # COD-specific instructions
+│
+├── app/[locale]/checkout/
+│   ├── page.tsx                        # Updated checkout page
+│   └── components/
+│       └── PaymentSection.tsx          # Checkout payment section wrapper
+│
+└── i18n/messages/
+    ├── en.json                         # Payment translations
+    ├── sr.json                         # Payment translations
+    ├── de.json                         # Payment translations
+    └── fr.json                         # Payment translations
+```
+
+---
+
+## 3. DATA MODELS
+
+### PaymentMethod Interface
+```typescript
+interface PaymentMethod {
+  id: string;
+  name: string;
+  description: string;
+  type: 'simple' | 'app';
+  fee: number;
+  available: boolean;
+  availableInChannels: string[];
+  icon?: string;
+}
+```
+
+### COD Transaction Structure
+```typescript
+const codTransaction = {
+  name: "Cash on Delivery",
+  pspReference: `COD-${orderNumber}-${timestamp}`,
+  availableActions: ["CHARGE"],
+  amountAuthorized: { amount: 0, currency: "RSD" },
+  amountCharged: { amount: 0, currency: "RSD" }
+};
+```
+
+---
+
+## 4. IMPLEMENTATION PHASES
+
+### Phase 1: Configuration & Types (Files 1-3)
+**Files:**
+1. `lib/config/paymentMethods.ts` - Payment methods config
+2. `lib/saleor/payments/types.ts` - Type definitions
+3. `lib/saleor/payments/cod.ts` - COD transaction logic
+
+**Deliverables:**
+- [ ] Payment methods configuration
+- [ ] TypeScript interfaces
+- [ ] COD transaction creation function
+
+### Phase 2: UI Components (Files 4-6)
+**Files:**
+4. `components/payment/PaymentMethodCard.tsx`
+5. `components/payment/PaymentMethodSelector.tsx`
+6. `components/payment/CODInstructions.tsx`
+
+**Deliverables:**
+- [ ] Payment method selection UI
+- [ ] COD instructions component
+- [ ] Responsive design
+
+### Phase 3: Checkout Integration (Files 7-8)
+**Files:**
+7. `app/[locale]/checkout/components/PaymentSection.tsx`
+8. `app/[locale]/checkout/page.tsx` (updated)
+
+**Deliverables:**
+- [ ] Payment section in checkout
+- [ ] Integration with checkout flow
+- [ ] Transaction creation on complete
+
+### Phase 4: Translations (Files 9-12)
+**Files:**
+9-12. Update `i18n/messages/{en,sr,de,fr}.json`
+
+**Deliverables:**
+- [ ] All translation keys
+- [ ] Serbian, English, German, French
+
+### Phase 5: Testing
+**Tasks:**
+- [ ] Test COD flow end-to-end
+- [ ] Verify transaction created in Saleor
+- [ ] Test mobile responsiveness
+- [ ] Test locale switching
+
+---
+
+## 5. CHECKOUT FLOW
+
+```
+1. User adds items to cart
+   ↓
+2. User proceeds to checkout
+   ↓
+3. Checkout page loads with:
+   - Contact form (email, phone)
+   - Shipping address form
+   - Billing address form (same as shipping default)
+   - Shipping method selector
+   - PAYMENT METHOD SELECTOR (NEW)
+     └─ COD selected by default
+   - Order summary
+   - Complete Order button
+   ↓
+4. User fills all required fields
+   ↓
+5. User clicks "Complete Order"
+   ↓
+6. System:
+   a. Validates all fields
+   b. Creates order via checkoutComplete
+   c. Creates COD Transaction on order
+   d. Redirects to order confirmation
+   ↓
+7. Order Confirmation page shows:
+   - Order number
+   - Total amount
+   - Payment method: "Cash on Delivery"
+   - Instructions: "Please prepare cash for delivery"
+   ↓
+8. Staff sees order in Dashboard:
+   - Status: UNFULFILLED
+   - Payment Status: NOT_CHARGED
+   - Transaction: "Cash on Delivery (COD-123)"
+   ↓
+9. On delivery:
+   - Delivery person collects cash
+   - Staff marks order as FULFILLED in Dashboard
+   - (Optional: Create CHARGE_SUCCESS transaction event)
+```
+
+---
+
+## 6. SALESOR DASHBOARD VIEW
+
+### Order Details:
+```
+Order #1234
+├─ Status: UNFULFILLED
+├─ Payment Status: NOT_CHARGED
+├─ Transactions:
+│  └─ Cash on Delivery (COD-1234-1743214567890)
+│     ├─ Status: NOT_CHARGED
+│     ├─ Amount: 3,200 RSD
+│     └─ Available Actions: [CHARGE]
+└─ Actions: [Fulfill] [Cancel]
+```
+
+### When Cash Collected:
+```
+Staff clicks [Fulfill]
+  ↓
+Order Status: FULFILLED
+Payment Status: (still NOT_CHARGED, but order is complete)
+```
+
+---
+
+## 7. TRANSLATION KEYS
+
+### English (en.json):
+```json
+{
+  "Payment": {
+    "title": "Payment Method",
+    "cod": {
+      "name": "Cash on Delivery",
+      "description": "Pay when you receive your order",
+      "instructions": {
+        "title": "Payment Instructions",
+        "prepareCash": "Please prepare the exact amount in cash",
+        "inspectOrder": "You can inspect your order before paying",
+        "noFee": "No additional fee for cash on delivery"
+      }
+    },
+    "card": {
+      "name": "Credit Card",
+      "description": "Secure online payment",
+      "comingSoon": "Coming soon"
+    },
+    "selectMethod": "Select payment method",
+    "securePayment": "Secure payment processing"
+  }
+}
+```
+
+### Serbian (sr.json):
+```json
+{
+  "Payment": {
+    "title": "Način Plaćanja",
+    "cod": {
+      "name": "Plaćanje Pouzećem",
+      "description": "Platite kada primite porudžbinu",
+      "instructions": {
+        "title": "Uputstva za Plaćanje",
+        "prepareCash": "Pripremite tačan iznos u gotovini",
+        "inspectOrder": "Možete pregledati porudžbinu pre plaćanja",
+        "noFee": "Bez dodatne naknade za plaćanje pouzećem"
+      }
+    }
+  }
+}
+```
+
+---
+
+## 8. TESTING CHECKLIST
+
+### Functional Tests:
+- [ ] COD radio button selected by default
+- [ ] Payment section visible in checkout
+- [ ] Order completes with COD selected
+- [ ] Transaction created with correct details
+- [ ] Transaction visible in Saleor Dashboard
+- [ ] Order confirmation shows COD
+- [ ] Translations work in all locales
+
+### Edge Cases:
+- [ ] Checkout validation fails - payment method preserved
+- [ ] Network error during transaction creation
+- [ ] User switches payment methods (when multiple available)
+- [ ] Mobile viewport - payment section responsive
+
+### Integration Tests:
+- [ ] End-to-end COD flow
+- [ ] Order appears in Dashboard
+- [ ] Staff can fulfill COD order
+- [ ] Multiple payment methods display correctly
+
+---
+
+## 9. FUTURE ENHANCEMENTS
+
+### Phase 2 (Post-MVP):
+- [ ] Add Bank Transfer payment method
+- [ ] Payment method icons
+- [ ] Save payment preference for logged-in users
+
+### Phase 3 (Advanced):
+- [ ] Bitcoin (manual) payment method
+- [ ] Bitcoin (automated) via custom handler
+- [ ] Payment Apps integration (Stripe, etc.)
+
+---
+
+## 10. NOTES
+
+### Why No Metadata:
+- Saleor has native Transaction objects
+- Transactions are typed and validated
+- Appear in Dashboard automatically
+- Support proper lifecycle (NOT_CHARGED → CHARGED)
+
+### Why Simple Type (Not App):
+- COD doesn't need async processing
+- No external API to integrate
+- No PCI compliance requirements
+- Manual verification by staff
+
+### Compatibility:
+- Current architecture supports Payment Apps later
+- Can add Stripe/PayPal as `type: 'app'` without breaking COD
+- Bitcoin can be added as `type: 'async'` when ready
+
+---
+
+**Last Updated:** March 29, 2026  
+**Next Review:** After Phase 1 completion

docs/roadmap/FEATURE_ROADMAP.md

@@ -0,0 +1,666 @@
+# Storefront Feature Roadmap
+
+> Strategic roadmap for increasing profitability, conversion rates, and SEO traffic.
+
+## Quick Stats
+- **Total Features:** 20
+- **Estimated Timeline:** 12-16 weeks
+- **Priority Categories:** Foundation → Quick Wins → Revenue → Growth
+
+---
+
+## Phase 1: Foundation (Weeks 1-3)
+*These features must be completed first as they enable other features*
+
+### 1. Enhanced Product Reviews System
+**Impact:** High | **Effort:** Medium | **Revenue Impact:** +15-30% conversion
+
+**Description:**
+- Allow customers to submit reviews with photos
+- Star ratings display on product cards
+- "Verified Purchase" badges
+- Review moderation dashboard
+- Review request email automation
+
+**Why First:**
+- Required for Rich Snippets (SEO feature #9)
+- Social proof enables all conversion optimizations
+- Reviews feed into email sequences
+
+**Technical Requirements:**
+- Database schema for reviews
+- Image upload/storage (S3/MinIO)
+- Moderation workflow
+- Saleor integration or standalone system
+
+**Dependencies:** None (foundation feature)
+
+---
+
+### 2. Structured Data / Rich Snippets (JSON-LD)
+**Impact:** High | **Effort:** Low | **Revenue Impact:** +10-20% CTR
+
+**Description:**
+- Product Schema (price, availability, ratings)
+- Review Schema (star ratings in Google)
+- Organization Schema (brand info)
+- BreadcrumbList Schema (navigation in SERPs)
+- FAQ Schema for product pages
+
+**Why First:**
+- Needs reviews system (#1) for review schema
+- Immediate SEO benefit
+- No dependencies after reviews
+
+**Technical Requirements:**
+- next/head component for JSON-LD injection
+- Dynamic schema generation per page
+- Testing with Google's Rich Results Test
+
+**Dependencies:** 
+- ✅ Product Reviews System (#1) - for review ratings
+- ⏳ Product catalog (already exists)
+
+---
+
+### 3. Open Graph & Twitter Card Meta Tags
+**Impact:** Medium | **Effort:** Low | **Revenue Impact:** Social sharing boost
+
+**Description:**
+- og:title, og:description, og:image for all pages
+- Twitter Card meta tags
+- Dynamic meta tags for product pages
+- Social share preview optimization
+
+**Why First:**
+- Quick win, low effort
+- Improves social media traffic quality
+
+**Technical Requirements:**
+- Extend existing metadata.ts
+- Generate dynamic OG images (optional)
+
+**Dependencies:** None (parallel with #2)
+
+---
+
+## Phase 2: Quick Wins (Weeks 4-5)
+*High impact, low effort features that show immediate results*
+
+### 4. Free Shipping Progress Bar
+**Impact:** High | **Effort:** Low | **Revenue Impact:** +15-25% AOV
+
+**Description:**
+- Visual progress bar in cart drawer
+- "Add X RSD more for free shipping" messaging
+- Animated progress indicator
+- Threshold: 5,000 RSD (already configured)
+
+**Why Now:**
+- Increases average order value immediately
+- Simple cart component modification
+- No backend dependencies
+
+**Technical Requirements:**
+- Cart drawer component update
+- Real-time calculation based on cart total
+- Confetti animation when threshold reached (optional)
+
+**Dependencies:** None
+
+---
+
+### 5. Sticky "Add to Cart" Button (Mobile)
+**Impact:** High | **Effort:** Low | **Revenue Impact:** +10-20% mobile conversion
+
+**Description:**
+- Fixed position button on mobile product pages
+- Price and "Add to Cart" always visible while scrolling
+- Smooth scroll to variant selector if needed
+
+**Why Now:**
+- Mobile is likely 60%+ of traffic
+- Single component change
+- High conversion impact
+
+**Technical Requirements:**
+- CSS position: sticky/fixed
+- Mobile breakpoint detection
+- Smooth scroll behavior
+
+**Dependencies:** None
+
+---
+
+### 6. Trust Signals Enhancement
+**Impact:** Medium | **Effort:** Low | **Revenue Impact:** +5-10% conversion
+
+**Description:**
+- Payment method icons (Visa, Mastercard, PayPal) in footer/checkout
+- "Secure SSL Checkout" badge
+- 30-day money-back guarantee badge
+- "Made in Serbia" / local production badge
+
+**Why Now:**
+- Reduces checkout anxiety
+- Visual asset creation only
+- No code complexity
+
+**Technical Requirements:**
+- SVG icons for payment methods
+- Badge component updates
+- Footer component modification
+
+**Dependencies:** None
+
+---
+
+## Phase 3: Revenue Optimization (Weeks 6-10)
+*Features that directly increase revenue and LTV*
+
+### 7. Abandoned Cart Recovery System
+**Impact:** Critical | **Effort:** Medium | **Revenue Impact:** 10-15% cart recovery
+
+**Description:**
+- 3-email sequence: 1 hour, 24 hours, 72 hours
+- Email 3 includes 10% discount code
+- Exit intent detection
+- SMS fallback (optional)
+- Recovery tracking dashboard
+
+**Why Now:**
+- Highest ROI feature
+- Requires email infrastructure
+- Builds on existing order system
+
+**Technical Requirements:**
+- Cart abandonment detection
+- Email template system (extend existing)
+- Discount code generation
+- Cron job or queue system
+- Tracking pixel for recovery attribution
+
+**Dependencies:**
+- ✅ Email service (Resend already configured)
+- ✅ Order notification service (already exists)
+- ⏳ Discount code system (if not in Saleor)
+
+---
+
+### 8. One-Click Upsells at Checkout
+**Impact:** High | **Effort:** Medium | **Revenue Impact:** +20-30% AOV
+
+**Description:**
+- "Complete your routine" modal after add-to-cart
+- Smart product recommendations based on cart contents
+- One-click add (no page reload)
+- Bundle discounts (buy 2 get 10% off)
+
+**Why Now:**
+- Increases AOV significantly
+- Leverages existing cart system
+- Works well with skincare routines
+
+**Technical Requirements:**
+- Upsell algorithm (category-based)
+- Modal component
+- Cart API updates
+- Bundle pricing logic
+
+**Dependencies:**
+- ✅ Cart system (already exists)
+- ⏳ Product relationships data (manual or AI-based)
+
+---
+
+### 9. Exit-Intent Lead Capture Popup
+**Impact:** Medium | **Effort:** Low | **Revenue Impact:** +5-15% email list growth
+
+**Description:**
+- Detects when user moves mouse to close tab/address bar
+- Shows email signup with 10% discount offer
+- Mobile: scroll-up detection or time-based
+- Dismissible with "No thanks" option
+
+**Why Now:**
+- Captures leaving traffic
+- Builds email list for newsletters
+- Simple implementation
+
+**Technical Requirements:**
+- Exit intent detection library (ouibounce or custom)
+- Email capture form
+- Discount code integration
+- Cookie/session management (show once per user)
+
+**Dependencies:**
+- ⏳ Email list management (CRM or Mailchimp)
+- ⏳ Discount code system
+
+---
+
+### 10. Subscription / Recurring Orders
+**Impact:** High | **Effort:** High | **Revenue Impact:** Predictable recurring revenue
+
+**Description:**
+- "Subscribe & Save 15%" option on product pages
+- Monthly/quarterly delivery intervals
+- Automatic billing (Stripe subscriptions)
+- Skip/pause/cancel management portal
+- Replenishment reminders
+
+**Why Now:**
+- Skincare has high reorder rates
+- Predictable revenue stream
+- Increases LTV significantly
+
+**Technical Requirements:**
+- Stripe Subscription integration
+- Customer portal for management
+- Inventory forecasting
+- Email notifications for upcoming orders
+
+**Dependencies:**
+- ✅ Stripe integration (check existing)
+- ⏳ Customer account system (if not exists)
+- ⏳ Inventory management enhancements
+
+---
+
+## Phase 4: Engagement & Support (Weeks 11-12)
+*Features that improve customer experience and reduce friction*
+
+### 11. Live Chat Widget (WhatsApp Business)
+**Impact:** Medium | **Effort:** Low | **Revenue Impact:** +10-15% conversion
+
+**Description:**
+- WhatsApp Business integration (most popular in Serbia)
+- Floating chat button
+- Auto-reply for common questions
+- Business hours indicator
+- Chat history
+
+**Why Now:**
+- Real-time customer support
+- High trust factor for skincare advice
+- Low implementation cost
+
+**Technical Requirements:**
+- WhatsApp Business API or click-to-chat
+- Floating button component
+- Auto-response templates
+- Mobile-optimized
+
+**Dependencies:** None
+
+---
+
+### 12. Product Comparison Tool
+**Impact:** Medium | **Effort:** Medium | **Revenue Impact:** +5-10% conversion
+
+**Description:**
+- Compare 2-3 products side-by-side
+- Compare ingredients, benefits, price, reviews
+- Save comparison for later
+- "Help me choose" quiz (optional)
+
+**Why Now:**
+- Reduces decision paralysis
+- Increases time on site
+- Helps customers find right product
+
+**Technical Requirements:**
+- Comparison table component
+- Product selection interface
+- Data normalization across products
+- Persistent state (URL params or session)
+
+**Dependencies:**
+- ✅ Product data (already in Saleor)
+- ⏳ Enhanced product attributes
+
+---
+
+### 13. Enhanced Urgency Elements
+**Impact:** Medium | **Effort:** Low | **Revenue Impact:** +5-15% conversion
+
+**Description:**
+- Real stock counter ("Only 3 left in stock")
+- Countdown timer for limited promotions
+- Recent purchase notifications ("Sarah from Belgrade just bought...")
+- Low stock email alerts
+
+**Why Now:**
+- Scarcity drives action
+- Builds on existing urgency text
+- Simple implementation
+
+**Technical Requirements:**
+- Real-time stock display
+- Countdown timer component
+- Fake social proof (recent purchase ticker)
+- Sale scheduling system
+
+**Dependencies:**
+- ✅ Inventory data from Saleor
+- ⏳ Sale/promotion management system
+
+---
+
+## Phase 5: Content & SEO Growth (Weeks 13-16)
+*Long-term traffic growth through content and SEO*
+
+### 14. Blog / Content Marketing Hub
+**Impact:** High | **Effort:** High | **Revenue Impact:** Organic traffic growth
+
+**Description:**
+- Blog section with categories
+- Skincare guides and tutorials
+- Ingredient education
+- Before/after case studies
+- Video content integration
+- SEO-optimized articles
+
+**Why Now:**
+- Long-term organic traffic
+- Positions brand as authority
+- Content for social media
+
+**Technical Requirements:**
+- Blog CMS (Headless CMS or markdown)
+- Category/tags system
+- Author profiles
+- Related articles
+- Comment system (optional)
+
+**Dependencies:**
+- ⏳ Headless CMS (Strapi, Sanity, or Contentful)
+- ⏳ Content strategy and writing resources
+
+---
+
+### 15. Enhanced Product Pages (Video & Guides)
+**Impact:** Medium | **Effort:** Medium | **Revenue Impact:** +10-20% conversion
+
+**Description:**
+- Product application tutorial videos
+- Ingredient glossary popup
+- "How to use" photo guides
+- Skin type recommendations
+- Routine builder tool
+
+**Why Now:**
+- Increases product understanding
+- Reduces returns
+- Video content for social
+
+**Technical Requirements:**
+- Video hosting (Vimeo/YouTube)
+- Accordion components for guides
+- Skin type quiz logic
+- Rich media product gallery
+
+**Dependencies:**
+- ⏳ Video production
+- ⏳ Content creation
+
+---
+
+### 16. FAQ Section with Schema Markup
+**Impact:** Medium | **Effort:** Low | **Revenue Impact:** SEO + reduced support
+
+**Description:**
+- Comprehensive FAQ page
+- Product-specific FAQs
+- Searchable FAQ
+- FAQ schema markup for Google
+- Categorized questions
+
+**Why Now:**
+- Reduces customer service load
+- SEO benefit with FAQ schema
+- Easy content creation
+
+**Technical Requirements:**
+- FAQ accordion component
+- Search functionality
+- JSON-LD FAQ schema
+- Category filtering
+
+**Dependencies:** None
+
+---
+
+## Phase 6: Email Marketing Automation (Weeks 14-16)
+*Leveraging email for retention and LTV*
+
+### 17. Post-Purchase Email Sequence
+**Impact:** High | **Effort:** Medium | **Revenue Impact:** +20-30% retention
+
+**Description:**
+- Order confirmation (already exists ✓)
+- Shipping notification (already exists ✓)
+- Delivery confirmation
+- "How's your product?" (7 days later)
+- Review request (14 days later)
+- Replenishment reminder (30/60 days)
+- Win-back campaign (90 days no purchase)
+
+**Why Now:**
+- Maximizes LTV
+- Uses existing email infrastructure
+- Automated revenue
+
+**Technical Requirements:**
+- Email sequence automation
+- Timing logic based on delivery
+- Dynamic content based on purchase
+- Unsubscribe management
+
+**Dependencies:**
+- ✅ Email service (Resend)
+- ✅ Order tracking (already exists)
+- ⏳ Delivery tracking integration (optional)
+
+---
+
+### 18. Segment-Based Email Campaigns
+**Impact:** Medium | **Effort:** Medium | **Revenue Impact:** +15-25% email revenue
+
+**Description:**
+- VIP customers segment (high LTV)
+- Inactive customers (win-back offers)
+- Product-specific education sequences
+- Seasonal campaigns (winter skincare, summer protection)
+- Birthday discounts
+
+**Why Now:**
+- Personalized marketing
+- Higher engagement than broadcasts
+- Uses customer data
+
+**Technical Requirements:**
+- Customer segmentation logic
+- Email template variants
+- Automation workflows
+- A/B testing capability
+
+**Dependencies:**
+- ✅ Email service
+- ⏳ CRM or customer data platform
+- ⏳ Email marketing platform (Mailchimp, Klaviyo, or custom)
+
+---
+
+## Phase 7: Advanced Features (Future)
+*Nice-to-have features for later phases*
+
+### 19. Wishlist / Save for Later
+**Impact:** Medium | **Effort:** Medium | **Revenue Impact:** +5-10% conversion
+
+**Description:**
+- Heart icon on product cards
+- Save items without account (cookies) or with account
+- Email reminders for saved items
+- Share wishlist feature
+- Back-in-stock notifications
+
+**Technical Requirements:**
+- Wishlist database/storage
+- Heart icon toggle
+- Wishlist page
+- Email triggers
+- Social sharing
+
+**Dependencies:**
+- ⏳ Customer account system (optional)
+- ⏳ Back-in-stock notification system
+
+---
+
+### 20. Google Analytics 4 + Enhanced E-commerce
+**Impact:** Medium | **Effort:** Low | **Revenue Impact:** Better attribution
+
+**Description:**
+- GA4 implementation alongside OpenPanel
+- Enhanced e-commerce events
+- Funnel visualization
+- Attribution modeling
+- A/B testing framework (Google Optimize)
+
+**Why Later:**
+- OpenPanel already provides analytics
+- GA4 is supplementary
+- Data analysis takes time
+
+**Technical Requirements:**
+- GA4 script injection
+- Event mapping to GA4 standards
+- E-commerce data layer
+- Conversion tracking setup
+
+**Dependencies:** None (can be done anytime)
+
+---
+
+## Dependency Graph
+
+```
+Phase 1: Foundation
+├── 1. Product Reviews (START HERE)
+├── 2. Structured Data ← depends on #1
+└── 3. Open Graph Tags (parallel)
+
+Phase 2: Quick Wins
+├── 4. Free Shipping Bar (independent)
+├── 5. Sticky Add to Cart (independent)
+└── 6. Trust Signals (independent)
+
+Phase 3: Revenue
+├── 7. Abandoned Cart ← needs email system ✓
+├── 8. One-Click Upsells ← needs cart ✓
+├── 9. Exit Intent ← needs email CRM
+└── 10. Subscriptions ← needs Stripe
+
+Phase 4: Engagement
+├── 11. Live Chat (independent)
+├── 12. Product Comparison ← needs product data ✓
+└── 13. Urgency Elements ← needs inventory ✓
+
+Phase 5: Content
+├── 14. Blog ← needs CMS
+├── 15. Enhanced PDPs ← needs video content
+└── 16. FAQ (independent)
+
+Phase 6: Email
+├── 17. Post-Purchase ← needs #7 foundation
+└── 18. Segmentation ← needs CRM
+
+Phase 7: Future
+├── 19. Wishlist (nice to have)
+└── 20. GA4 (supplementary)
+```
+
+---
+
+## Implementation Priority Matrix
+
+| Feature | Revenue Impact | SEO Impact | Effort | Priority |
+|---------|---------------|------------|--------|----------|
+| 1. Product Reviews | ⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐⭐ | Medium | **P0** |
+| 2. Structured Data | ⭐⭐⭐ | ⭐⭐⭐⭐⭐ | Low | **P0** |
+| 7. Abandoned Cart | ⭐⭐⭐⭐⭐ | ⭐ | Medium | **P0** |
+| 4. Free Shipping Bar | ⭐⭐⭐⭐ | ⭐ | Low | **P1** |
+| 8. One-Click Upsells | ⭐⭐⭐⭐⭐ | ⭐ | Medium | **P1** |
+| 5. Sticky Add to Cart | ⭐⭐⭐⭐ | ⭐ | Low | **P1** |
+| 10. Subscriptions | ⭐⭐⭐⭐⭐ | ⭐ | High | **P1** |
+| 17. Post-Purchase Email | ⭐⭐⭐⭐ | ⭐ | Medium | **P1** |
+| 14. Blog | ⭐⭐⭐ | ⭐⭐⭐⭐⭐ | High | **P2** |
+| 9. Exit Intent | ⭐⭐⭐ | ⭐ | Low | **P2** |
+| 11. Live Chat | ⭐⭐⭐ | ⭐ | Low | **P2** |
+| 15. Enhanced PDPs | ⭐⭐⭐⭐ | ⭐⭐⭐ | Medium | **P2** |
+
+**Legend:**
+- **P0:** Start immediately, highest ROI
+- **P1:** Core revenue features
+- **P2:** Growth and optimization
+
+---
+
+## Resource Requirements
+
+### Development Team
+- **Frontend:** 1-2 developers (Next.js/React)
+- **Backend:** 1 developer (Node.js/GraphQL)
+- **DevOps:** Part-time (CI/CD, infrastructure)
+
+### External Resources
+- **Content Writer:** For blog, FAQs, product descriptions
+- **Video Production:** For tutorials and guides
+- **Email Copywriter:** For email sequences
+- **Designer:** For banners, badges, marketing assets
+
+### Third-Party Services
+- **Email Marketing:** Resend (✓), Klaviyo (optional upgrade)
+- **Reviews Platform:** Loox, Judge.me, or custom
+- **Live Chat:** WhatsApp Business (free), Intercom (paid)
+- **Analytics:** OpenPanel (✓), Google Analytics 4
+- **CMS:** Strapi (self-hosted) or Sanity
+- **CDN:** Cloudflare (✓)
+
+---
+
+## Success Metrics
+
+### Revenue KPIs
+- **Conversion Rate:** Current → Target (+20%)
+- **Average Order Value:** Current → Target (+25%)
+- **Customer Lifetime Value:** Current → Target (+40%)
+- **Cart Abandonment Rate:** Current → Target (-30%)
+
+### SEO KPIs
+- **Organic Traffic:** +50% in 6 months
+- **Click-Through Rate:** +15% with rich snippets
+- **Keyword Rankings:** Top 3 for 20 target keywords
+- **Domain Authority:** Increase by 10 points
+
+### Engagement KPIs
+- **Email List Growth:** +500 subscribers/month
+- **Review Submission Rate:** 10% of orders
+- **Repeat Purchase Rate:** 30% within 90 days
+- **Customer Support Tickets:** -20% with FAQ
+
+---
+
+## Notes
+
+- **Test everything:** A/B test major changes
+- **Mobile-first:** 60%+ traffic is mobile
+- **Performance:** Keep Core Web Vitals green
+- **Accessibility:** WCAG 2.1 AA compliance
+- **Privacy:** GDPR compliance for EU customers
+
+---
+
+*Last Updated: March 2026*
+*Next Review: Quarterly*

k8s/deployment.yaml

@@ -76,6 +76,14 @@ spec:
           value: "https://api.manoonoils.com/graphql/"
         - name: NEXT_PUBLIC_SITE_URL
           value: "https://dev.manoonoils.com"
+        - name: DASHBOARD_URL
+          value: "https://dashboard.manoonoils.com"
+        - name: NEXT_PUBLIC_OPENPANEL_CLIENT_ID
+          value: "fa61f8ae-0b5d-4187-a9b1-5a04b0025674"
+        - name: OPENPANEL_CLIENT_SECRET
+          value: "91126be0d1e78e657e0427df82733832.c6d30edf6ee673da9650a883604169a13ab8579a0dde70cb39b477f4cf441f90"
+        - name: OPENPANEL_API_URL
+          value: "https://op.nodecrew.me/api"
         volumeMounts:
         - name: workspace
           mountPath: /workspace
@@ -108,6 +116,16 @@ spec:
           value: "https://api.manoonoils.com/graphql/"
         - name: NEXT_PUBLIC_SITE_URL
           value: "https://dev.manoonoils.com"
+        - name: DASHBOARD_URL
+          value: "https://dashboard.manoonoils.com"
+        - name: RESEND_API_KEY
+          value: "re_bewcjHuy_DHtksWVUxguj8vFzKiJZNkFi"
+        - name: NEXT_PUBLIC_OPENPANEL_CLIENT_ID
+          value: "fa61f8ae-0b5d-4187-a9b1-5a04b0025674"
+        - name: OPENPANEL_CLIENT_SECRET
+          value: "91126be0d1e78e657e0427df82733832.c6d30edf6ee673da9650a883604169a13ab8579a0dde70cb39b477f4cf441f90"
+        - name: OPENPANEL_API_URL
+          value: "https://op.nodecrew.me/api"
         resources:
           limits:
             cpu: 500m

package.json

@@ -6,10 +6,19 @@
     "dev": "next dev",
     "build": "next build",
     "start": "next start",
-    "lint": "eslint"
+    "lint": "eslint",
+    "test": "vitest",
+    "test:ui": "vitest --ui",
+    "test:coverage": "vitest --coverage",
+    "test:run": "vitest run",
+    "test:e2e": "playwright test",
+    "test:e2e:ui": "playwright test --ui"
   },
   "dependencies": {
     "@apollo/client": "^4.1.6",
+    "@openpanel/nextjs": "^1.4.0",
+    "@react-email/components": "^1.0.10",
+    "@react-email/render": "^2.0.4",
     "clsx": "^2.1.1",
     "framer-motion": "^12.34.4",
     "graphql": "^16.13.1",
@@ -18,17 +27,27 @@
     "next-intl": "^4.8.3",
     "react": "19.2.3",
     "react-dom": "19.2.3",
+    "resend": "^6.9.4",
     "tailwind-merge": "^3.5.0",
     "zustand": "^5.0.11"
   },
   "devDependencies": {
+    "@playwright/test": "^1.58.2",
     "@tailwindcss/postcss": "^4",
+    "@testing-library/jest-dom": "^6.9.1",
+    "@testing-library/react": "^16.3.2",
+    "@testing-library/user-event": "^14.6.1",
     "@types/node": "^20",
     "@types/react": "^19",
     "@types/react-dom": "^19",
+    "@vitejs/plugin-react": "^6.0.1",
+    "@vitest/coverage-v8": "^4.1.1",
     "eslint": "^9",
     "eslint-config-next": "16.1.6",
+    "jsdom": "^29.0.1",
+    "msw": "^2.12.14",
     "tailwindcss": "^4",
-    "typescript": "^5"
+    "typescript": "^5",
+    "vitest": "^4.1.1"
   }
 }

src/__tests__/README.md

@@ -0,0 +1,141 @@
+# Manoon Storefront Test Suite
+
+Comprehensive test suite for the ManoonOils storefront with focus on webhooks, commerce operations, and critical paths.
+
+## 🎯 Coverage Goals
+
+- **Critical Paths**: 80%+ coverage
+- **Webhook Handlers**: 100% coverage
+- **Email Services**: 90%+ coverage
+- **Analytics**: 80%+ coverage
+
+## 🧪 Test Structure
+
+```
+src/__tests__/
+├── unit/
+│   ├── services/           # Business logic tests
+│   │   ├── OrderNotificationService.test.ts
+│   │   └── AnalyticsService.test.ts
+│   ├── stores/            # State management tests
+│   │   └── saleorCheckoutStore.test.ts
+│   └── utils/             # Utility function tests
+│       └── formatPrice.test.ts
+├── integration/
+│   ├── api/
+│   │   └── webhooks/
+│   │       └── saleor.test.ts     # Webhook handler tests
+│   └── emails/
+│       ├── OrderConfirmation.test.tsx
+│       └── OrderShipped.test.tsx
+└── fixtures/              # Test data
+    └── orders.ts
+```
+
+## 🚀 Running Tests
+
+### Unit & Integration Tests (Vitest)
+
+```bash
+# Run tests in watch mode
+npm test
+
+# Run tests once
+npm run test:run
+
+# Run with coverage report
+npm run test:coverage
+
+# Run with UI
+npm run test:ui
+```
+
+### E2E Tests (Playwright)
+
+```bash
+# Run all E2E tests
+npm run test:e2e
+
+# Run with UI mode
+npm run test:e2e:ui
+
+# Run specific test
+npx playwright test tests/critical-paths/checkout-flow.spec.ts
+```
+
+## 📊 Test Categories
+
+### 🔥 Critical Tests (Must Pass)
+
+1. **Webhook Handler Tests**
+   - ORDER_CONFIRMED: Sends emails + analytics
+   - ORDER_CREATED: No duplicate emails/analytics
+   - ORDER_FULFILLED: Tracking info included
+   - ORDER_CANCELLED: Cancellation reason included
+   - ORDER_FULLY_PAID: Payment confirmation
+
+2. **Email Service Tests**
+   - Correct translations (SR, EN, DE, FR)
+   - Price formatting (no /100 bug)
+   - Admin vs Customer templates
+   - Address formatting
+
+3. **Analytics Tests**
+   - Revenue tracked once per order
+   - Correct currency (RSD not USD)
+   - Error handling (doesn't break order flow)
+
+### 🔧 Integration Tests
+
+- Full checkout flow
+- Cart operations
+- Email template rendering
+- API error handling
+
+## 🎭 Mocking Strategy
+
+- **Resend**: Mocked (no actual emails sent)
+- **OpenPanel**: Mocked (no actual tracking in tests)
+- **Saleor API**: Can use real instance for integration tests (read-only)
+
+## 📈 Coverage Reports
+
+Coverage reports are generated in multiple formats:
+- Console output (text)
+- `coverage/coverage-final.json` (JSON)
+- `coverage/index.html` (HTML report)
+
+Open `coverage/index.html` in browser for detailed view.
+
+## 🔍 Debugging Tests
+
+```bash
+# Debug specific test
+npm test -- --reporter=verbose src/__tests__/unit/services/AnalyticsService.test.ts
+
+# Debug with logs
+DEBUG=true npm test
+```
+
+## 📝 Adding New Tests
+
+1. Create test file: `src/__tests__/unit|integration/path/to/file.test.ts`
+2. Import from `@/` alias (configured in vitest.config.ts)
+3. Use fixtures from `src/__tests__/fixtures/`
+4. Mock external services
+5. Run tests to verify
+
+## 🚧 Current Limitations
+
+- No CI/CD integration yet (informational only)
+- E2E tests need Playwright browser installation
+- Some tests use mocked data instead of real Saleor API
+
+## ✅ Test Checklist
+
+Before deploying, ensure:
+- [ ] All webhook tests pass
+- [ ] Email service tests pass
+- [ ] Analytics tests pass
+- [ ] Coverage >= 80% for critical paths
+- [ ] No console errors in tests

src/__tests__/fixtures/orders.ts

@@ -0,0 +1,112 @@
+// Test fixtures for orders
+export const mockOrderPayload = {
+  id: "T3JkZXI6MTIzNDU2Nzg=",
+  number: 1524,
+  user_email: "test@hytham.me",
+  first_name: "Test",
+  last_name: "Customer",
+  billing_address: {
+    first_name: "Test",
+    last_name: "Customer",
+    street_address_1: "123 Test Street",
+    street_address_2: "",
+    city: "Belgrade",
+    postal_code: "11000",
+    country: "RS",
+    phone: "+38160123456",
+  },
+  shipping_address: {
+    first_name: "Test",
+    last_name: "Customer",
+    street_address_1: "123 Test Street",
+    street_address_2: "",
+    city: "Belgrade",
+    postal_code: "11000",
+    country: "RS",
+    phone: "+38160123456",
+  },
+  lines: [
+    {
+      id: "T3JkZXJMaW5lOjE=",
+      product_name: "Manoon Anti-age Serum",
+      variant_name: "50ml",
+      quantity: 2,
+      total_price_gross_amount: "10000",
+      currency: "RSD",
+    },
+  ],
+  total_gross_amount: "10000",
+  shipping_price_gross_amount: "480",
+  channel: {
+    currency_code: "RSD",
+  },
+  language_code: "EN",
+  metadata: {},
+};
+
+export const mockOrderConverted = {
+  id: "T3JkZXI6MTIzNDU2Nzg=",
+  number: "1524",
+  userEmail: "test@hytham.me",
+  user: {
+    firstName: "Test",
+    lastName: "Customer",
+  },
+  billingAddress: {
+    firstName: "Test",
+    lastName: "Customer",
+    streetAddress1: "123 Test Street",
+    streetAddress2: "",
+    city: "Belgrade",
+    postalCode: "11000",
+    country: "RS",
+    phone: "+38160123456",
+  },
+  shippingAddress: {
+    firstName: "Test",
+    lastName: "Customer",
+    streetAddress1: "123 Test Street",
+    streetAddress2: "",
+    city: "Belgrade",
+    postalCode: "11000",
+    country: "RS",
+    phone: "+38160123456",
+  },
+  lines: [
+    {
+      id: "T3JkZXJMaW5lOjE=",
+      productName: "Manoon Anti-age Serum",
+      variantName: "50ml",
+      quantity: 2,
+      totalPrice: {
+        gross: {
+          amount: 10000,
+          currency: "RSD",
+        },
+      },
+    },
+  ],
+  total: {
+    gross: {
+      amount: 10000,
+      currency: "RSD",
+    },
+  },
+  languageCode: "EN",
+  metadata: [],
+};
+
+export const mockOrderWithTracking = {
+  ...mockOrderPayload,
+  metadata: {
+    trackingNumber: "TRK123456789",
+    trackingUrl: "https://tracking.example.com/TRK123456789",
+  },
+};
+
+export const mockOrderCancelled = {
+  ...mockOrderPayload,
+  metadata: {
+    cancellationReason: "Customer requested cancellation",
+  },
+};

src/__tests__/integration/api/webhooks/saleor.test.ts

@@ -0,0 +1,280 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { NextRequest } from "next/server";
+import { POST, GET } from "@/app/api/webhooks/saleor/route";
+import { orderNotificationService } from "@/lib/services/OrderNotificationService";
+import { analyticsService } from "@/lib/services/AnalyticsService";
+import { mockOrderPayload, mockOrderWithTracking, mockOrderCancelled } from "../../../fixtures/orders";
+
+// Mock the services
+vi.mock("@/lib/services/OrderNotificationService", () => ({
+  orderNotificationService: {
+    sendOrderConfirmation: vi.fn().mockResolvedValue(undefined),
+    sendOrderConfirmationToAdmin: vi.fn().mockResolvedValue(undefined),
+    sendOrderShipped: vi.fn().mockResolvedValue(undefined),
+    sendOrderShippedToAdmin: vi.fn().mockResolvedValue(undefined),
+    sendOrderCancelled: vi.fn().mockResolvedValue(undefined),
+    sendOrderCancelledToAdmin: vi.fn().mockResolvedValue(undefined),
+    sendOrderPaid: vi.fn().mockResolvedValue(undefined),
+    sendOrderPaidToAdmin: vi.fn().mockResolvedValue(undefined),
+  },
+}));
+
+vi.mock("@/lib/services/AnalyticsService", () => ({
+  analyticsService: {
+    trackOrderReceived: vi.fn().mockResolvedValue(undefined),
+    trackRevenue: vi.fn().mockResolvedValue(undefined),
+    track: vi.fn().mockResolvedValue(undefined),
+  },
+}));
+
+describe("Saleor Webhook Handler", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe("GET /api/webhooks/saleor", () => {
+    it("should return health check response", async () => {
+      const response = await GET();
+      const data = await response.json();
+
+      expect(response.status).toBe(200);
+      expect(data.status).toBe("ok");
+      expect(data.supportedEvents).toContain("ORDER_CONFIRMED");
+      expect(data.supportedEvents).toContain("ORDER_CREATED");
+    });
+  });
+
+  describe("POST /api/webhooks/saleor - ORDER_CONFIRMED", () => {
+    it("should process ORDER_CONFIRMED and send customer + admin emails", async () => {
+      const request = new NextRequest("http://localhost:3000/api/webhooks/saleor", {
+        method: "POST",
+        headers: {
+          "saleor-event": "ORDER_CONFIRMED",
+          "saleor-domain": "api.manoonoils.com",
+        },
+        body: JSON.stringify([mockOrderPayload]),
+      });
+
+      const response = await POST(request);
+      const data = await response.json();
+
+      expect(response.status).toBe(200);
+      expect(data.success).toBe(true);
+
+      // Should send customer email
+      expect(orderNotificationService.sendOrderConfirmation).toHaveBeenCalledTimes(1);
+
+      // Should send admin email
+      expect(orderNotificationService.sendOrderConfirmationToAdmin).toHaveBeenCalledTimes(1);
+
+      // Should track analytics
+      expect(analyticsService.trackOrderReceived).toHaveBeenCalledTimes(1);
+      expect(analyticsService.trackRevenue).toHaveBeenCalledTimes(1);
+
+      // Verify revenue tracking has correct data
+      expect(analyticsService.trackRevenue).toHaveBeenCalledWith({
+        amount: 10000,
+        currency: "RSD",
+        orderId: mockOrderPayload.id,
+        orderNumber: String(mockOrderPayload.number),
+      });
+    });
+
+    it("should NOT track analytics for ORDER_CREATED (prevents duplication)", async () => {
+      const request = new NextRequest("http://localhost:3000/api/webhooks/saleor", {
+        method: "POST",
+        headers: {
+          "saleor-event": "ORDER_CREATED",
+          "saleor-domain": "api.manoonoils.com",
+        },
+        body: JSON.stringify([mockOrderPayload]),
+      });
+
+      const response = await POST(request);
+      expect(response.status).toBe(200);
+
+      // Should NOT send customer email
+      expect(orderNotificationService.sendOrderConfirmation).not.toHaveBeenCalled();
+
+      // Should NOT track analytics
+      expect(analyticsService.trackOrderReceived).not.toHaveBeenCalled();
+      expect(analyticsService.trackRevenue).not.toHaveBeenCalled();
+
+      // Should still send admin notification
+      expect(orderNotificationService.sendOrderConfirmationToAdmin).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe("POST /api/webhooks/saleor - ORDER_FULFILLED", () => {
+    it("should send shipping emails with tracking info", async () => {
+      const request = new NextRequest("http://localhost:3000/api/webhooks/saleor", {
+        method: "POST",
+        headers: {
+          "saleor-event": "ORDER_FULFILLED",
+          "saleor-domain": "api.manoonoils.com",
+        },
+        body: JSON.stringify([mockOrderWithTracking]),
+      });
+
+      const response = await POST(request);
+      expect(response.status).toBe(200);
+
+      expect(orderNotificationService.sendOrderShipped).toHaveBeenCalledWith(
+        expect.any(Object),
+        "TRK123456789",
+        "https://tracking.example.com/TRK123456789"
+      );
+
+      expect(orderNotificationService.sendOrderShippedToAdmin).toHaveBeenCalledWith(
+        expect.any(Object),
+        "TRK123456789",
+        "https://tracking.example.com/TRK123456789"
+      );
+    });
+  });
+
+  describe("POST /api/webhooks/saleor - ORDER_CANCELLED", () => {
+    it("should send cancellation emails with reason", async () => {
+      const request = new NextRequest("http://localhost:3000/api/webhooks/saleor", {
+        method: "POST",
+        headers: {
+          "saleor-event": "ORDER_CANCELLED",
+          "saleor-domain": "api.manoonoils.com",
+        },
+        body: JSON.stringify([mockOrderCancelled]),
+      });
+
+      const response = await POST(request);
+      expect(response.status).toBe(200);
+
+      expect(orderNotificationService.sendOrderCancelled).toHaveBeenCalledWith(
+        expect.any(Object),
+        "Customer requested cancellation"
+      );
+
+      expect(orderNotificationService.sendOrderCancelledToAdmin).toHaveBeenCalledWith(
+        expect.any(Object),
+        "Customer requested cancellation"
+      );
+    });
+  });
+
+  describe("POST /api/webhooks/saleor - ORDER_FULLY_PAID", () => {
+    it("should send payment confirmation emails", async () => {
+      const request = new NextRequest("http://localhost:3000/api/webhooks/saleor", {
+        method: "POST",
+        headers: {
+          "saleor-event": "ORDER_FULLY_PAID",
+          "saleor-domain": "api.manoonoils.com",
+        },
+        body: JSON.stringify([mockOrderPayload]),
+      });
+
+      const response = await POST(request);
+      expect(response.status).toBe(200);
+
+      expect(orderNotificationService.sendOrderPaid).toHaveBeenCalledTimes(1);
+      expect(orderNotificationService.sendOrderPaidToAdmin).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe("Error Handling", () => {
+    it("should return 400 for missing order in payload", async () => {
+      const request = new NextRequest("http://localhost:3000/api/webhooks/saleor", {
+        method: "POST",
+        headers: {
+          "saleor-event": "ORDER_CONFIRMED",
+          "saleor-domain": "api.manoonoils.com",
+        },
+        body: JSON.stringify([]), // Empty array
+      });
+
+      const response = await POST(request);
+      const data = await response.json();
+
+      expect(response.status).toBe(400);
+      expect(data.error).toBe("No order in payload");
+    });
+
+    it("should return 400 for missing saleor-event header", async () => {
+      const request = new NextRequest("http://localhost:3000/api/webhooks/saleor", {
+        method: "POST",
+        headers: {
+          "saleor-domain": "api.manoonoils.com",
+        },
+        body: JSON.stringify([mockOrderPayload]),
+      });
+
+      const response = await POST(request);
+      const data = await response.json();
+
+      expect(response.status).toBe(400);
+      expect(data.error).toBe("Missing saleor-event header");
+    });
+
+    it("should return 200 for unsupported events (graceful skip)", async () => {
+      const request = new NextRequest("http://localhost:3000/api/webhooks/saleor", {
+        method: "POST",
+        headers: {
+          "saleor-event": "UNSUPPORTED_EVENT",
+          "saleor-domain": "api.manoonoils.com",
+        },
+        body: JSON.stringify([mockOrderPayload]),
+      });
+
+      const response = await POST(request);
+      const data = await response.json();
+
+      expect(response.status).toBe(200);
+      expect(data.message).toBe("Event not supported");
+    });
+
+    it("should handle server errors gracefully", async () => {
+      // Simulate service throwing error
+      vi.mocked(orderNotificationService.sendOrderConfirmationToAdmin).mockRejectedValueOnce(
+        new Error("Email service down")
+      );
+
+      const request = new NextRequest("http://localhost:3000/api/webhooks/saleor", {
+        method: "POST",
+        headers: {
+          "saleor-event": "ORDER_CREATED",
+          "saleor-domain": "api.manoonoils.com",
+        },
+        body: JSON.stringify([mockOrderPayload]),
+      });
+
+      const response = await POST(request);
+      expect(response.status).toBe(500);
+    });
+  });
+
+  describe("Currency Handling", () => {
+    it("should preserve RSD currency from Saleor payload", async () => {
+      const rsdOrder = {
+        ...mockOrderPayload,
+        total_gross_amount: "5479",
+        channel: { currency_code: "RSD" },
+      };
+
+      const request = new NextRequest("http://localhost:3000/api/webhooks/saleor", {
+        method: "POST",
+        headers: {
+          "saleor-event": "ORDER_CONFIRMED",
+          "saleor-domain": "api.manoonoils.com",
+        },
+        body: JSON.stringify([rsdOrder]),
+      });
+
+      await POST(request);
+
+      // Verify the order passed to analytics has correct currency
+      expect(analyticsService.trackRevenue).toHaveBeenCalledWith(
+        expect.objectContaining({
+          amount: 5479,
+          currency: "RSD",
+        })
+      );
+    });
+  });
+});

src/__tests__/setup.ts

@@ -0,0 +1,35 @@
+import "@testing-library/jest-dom";
+import { vi } from "vitest";
+
+// Mock environment variables
+process.env.NEXT_PUBLIC_SALEOR_API_URL = "https://api.manoonoils.com/graphql/";
+process.env.NEXT_PUBLIC_SITE_URL = "https://dev.manoonoils.com";
+process.env.DASHBOARD_URL = "https://dashboard.manoonoils.com";
+process.env.RESEND_API_KEY = "test-api-key";
+process.env.NEXT_PUBLIC_OPENPANEL_CLIENT_ID = "test-client-id";
+process.env.OPENPANEL_CLIENT_SECRET = "test-client-secret";
+process.env.OPENPANEL_API_URL = "https://op.nodecrew.me/api";
+
+// Mock Resend
+vi.mock("resend", () => ({
+  Resend: vi.fn().mockImplementation(() => ({
+    emails: {
+      send: vi.fn().mockResolvedValue({ id: "test-email-id" }),
+    },
+  })),
+}));
+
+// Mock OpenPanel
+vi.mock("@openpanel/nextjs", () => ({
+  OpenPanel: vi.fn().mockImplementation(() => ({
+    track: vi.fn().mockResolvedValue(undefined),
+    revenue: vi.fn().mockResolvedValue(undefined),
+  })),
+}));
+
+// Global test utilities
+global.ResizeObserver = vi.fn().mockImplementation(() => ({
+  observe: vi.fn(),
+  unobserve: vi.fn(),
+  disconnect: vi.fn(),
+}));

src/__tests__/unit/services/AnalyticsService.test.ts

@@ -0,0 +1,233 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+// Create mock functions using vi.hoisted so they're available during mock setup
+const { mockTrack, mockRevenue } = vi.hoisted(() => ({
+  mockTrack: vi.fn().mockResolvedValue(undefined),
+  mockRevenue: vi.fn().mockResolvedValue(undefined),
+}));
+
+// Mock OpenPanel using factory function
+vi.mock("@openpanel/nextjs", () => {
+  return {
+    OpenPanel: class MockOpenPanel {
+      track = mockTrack;
+      revenue = mockRevenue;
+      constructor() {}
+    },
+  };
+});
+
+// Import after mock is set up
+import { AnalyticsService } from "@/lib/services/AnalyticsService";
+
+describe("AnalyticsService", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe("trackOrderReceived", () => {
+    it("should track order with all details", async () => {
+      await new AnalyticsService().trackOrderReceived({
+        orderId: "order-123",
+        orderNumber: "1524",
+        total: 5479,
+        currency: "RSD",
+        itemCount: 3,
+        customerEmail: "test@example.com",
+        eventType: "ORDER_CONFIRMED",
+      });
+
+      expect(mockTrack).toHaveBeenCalledWith("order_received", {
+        order_id: "order-123",
+        order_number: "1524",
+        total: 5479,
+        currency: "RSD",
+        item_count: 3,
+        customer_email: "test@example.com",
+        event_type: "ORDER_CONFIRMED",
+      });
+    });
+
+    it("should handle large order values", async () => {
+      await new AnalyticsService().trackOrderReceived({
+        orderId: "order-456",
+        orderNumber: "2000",
+        total: 500000, // Large amount
+        currency: "RSD",
+        itemCount: 100,
+        customerEmail: "bulk@example.com",
+        eventType: "ORDER_CONFIRMED",
+      });
+
+      expect(mockTrack).toHaveBeenCalledWith(
+        "order_received",
+        expect.objectContaining({
+          total: 500000,
+          item_count: 100,
+        })
+      );
+    });
+
+    it("should not throw if tracking fails", async () => {
+      mockTrack.mockRejectedValueOnce(new Error("Network error"));
+
+      await expect(
+        new AnalyticsService().trackOrderReceived({
+          orderId: "order-123",
+          orderNumber: "1524",
+          total: 1000,
+          currency: "RSD",
+          itemCount: 1,
+          customerEmail: "test@example.com",
+          eventType: "ORDER_CONFIRMED",
+        })
+      ).resolves.not.toThrow();
+    });
+  });
+
+  describe("trackRevenue", () => {
+    it("should track revenue with correct currency", async () => {
+      await new AnalyticsService().trackRevenue({
+        amount: 5479,
+        currency: "RSD",
+        orderId: "order-123",
+        orderNumber: "1524",
+      });
+
+      expect(mockRevenue).toHaveBeenCalledWith(5479, {
+        currency: "RSD",
+        order_id: "order-123",
+        order_number: "1524",
+      });
+    });
+
+    it("should track revenue with different currencies", async () => {
+      // Test EUR
+      await new AnalyticsService().trackRevenue({
+        amount: 100,
+        currency: "EUR",
+        orderId: "order-1",
+        orderNumber: "1000",
+      });
+
+      expect(mockRevenue).toHaveBeenCalledWith(100, {
+        currency: "EUR",
+        order_id: "order-1",
+        order_number: "1000",
+      });
+
+      // Test USD
+      await new AnalyticsService().trackRevenue({
+        amount: 150,
+        currency: "USD",
+        orderId: "order-2",
+        orderNumber: "1001",
+      });
+
+      expect(mockRevenue).toHaveBeenCalledWith(150, {
+        currency: "USD",
+        order_id: "order-2",
+        order_number: "1001",
+      });
+    });
+
+    it("should log tracking for debugging", async () => {
+      const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => {});
+
+      await new AnalyticsService().trackRevenue({
+        amount: 5479,
+        currency: "RSD",
+        orderId: "order-123",
+        orderNumber: "1524",
+      });
+
+      expect(consoleSpy).toHaveBeenCalledWith(
+        "Tracking revenue: 5479 RSD for order 1524"
+      );
+
+      consoleSpy.mockRestore();
+    });
+
+    it("should not throw if revenue tracking fails", async () => {
+      mockRevenue.mockRejectedValueOnce(new Error("API error"));
+
+      await expect(
+        new AnalyticsService().trackRevenue({
+          amount: 1000,
+          currency: "RSD",
+          orderId: "order-123",
+          orderNumber: "1524",
+        })
+      ).resolves.not.toThrow();
+    });
+
+    it("should handle zero amount orders", async () => {
+      await new AnalyticsService().trackRevenue({
+        amount: 0,
+        currency: "RSD",
+        orderId: "order-000",
+        orderNumber: "0000",
+      });
+
+      expect(mockRevenue).toHaveBeenCalledWith(0, {
+        currency: "RSD",
+        order_id: "order-000",
+        order_number: "0000",
+      });
+    });
+  });
+
+  describe("track", () => {
+    it("should track custom events", async () => {
+      await new AnalyticsService().track("custom_event", {
+        property1: "value1",
+        property2: 123,
+      });
+
+      expect(mockTrack).toHaveBeenCalledWith("custom_event", {
+        property1: "value1",
+        property2: 123,
+      });
+    });
+
+    it("should not throw on tracking errors", async () => {
+      mockTrack.mockRejectedValueOnce(new Error("Tracking failed"));
+
+      await expect(
+        new AnalyticsService().track("test_event", { test: true })
+      ).resolves.not.toThrow();
+    });
+  });
+
+  describe("Singleton pattern", () => {
+    it("should return the same instance", async () => {
+      // Import fresh to test singleton using dynamic import
+      const { analyticsService: service1 } = await import("@/lib/services/AnalyticsService");
+      const { analyticsService: service2 } = await import("@/lib/services/AnalyticsService");
+
+      expect(service1).toBe(service2);
+    });
+  });
+
+  describe("Error handling", () => {
+    it("should log errors but not throw", async () => {
+      const consoleErrorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+      mockTrack.mockRejectedValueOnce(new Error("Test error"));
+
+      await new AnalyticsService().trackOrderReceived({
+        orderId: "order-123",
+        orderNumber: "1524",
+        total: 1000,
+        currency: "RSD",
+        itemCount: 1,
+        customerEmail: "test@example.com",
+        eventType: "ORDER_CONFIRMED",
+      });
+
+      expect(consoleErrorSpy).toHaveBeenCalled();
+      expect(consoleErrorSpy.mock.calls[0][0]).toContain("Failed to track order received");
+
+      consoleErrorSpy.mockRestore();
+    });
+  });
+});

src/__tests__/unit/services/OrderNotificationService.test.ts

@@ -0,0 +1,263 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { orderNotificationService } from "@/lib/services/OrderNotificationService";
+import { sendEmailToCustomer, sendEmailToAdmin } from "@/lib/resend";
+import { mockOrderConverted } from "../../fixtures/orders";
+
+// Mock the resend module
+vi.mock("@/lib/resend", () => ({
+  sendEmailToCustomer: vi.fn().mockResolvedValue({ id: "test-email-id" }),
+  sendEmailToAdmin: vi.fn().mockResolvedValue({ id: "test-email-id" }),
+  ADMIN_EMAILS: ["me@hytham.me", "tamara@hytham.me"],
+}));
+
+describe("OrderNotificationService", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe("sendOrderConfirmation", () => {
+    it("should send customer order confirmation in correct language (EN)", async () => {
+      const order = { ...mockOrderConverted, languageCode: "EN" };
+
+      await orderNotificationService.sendOrderConfirmation(order);
+
+      expect(sendEmailToCustomer).toHaveBeenCalledWith(
+        expect.objectContaining({
+          to: "test@hytham.me",
+          subject: "Order Confirmation #1524",
+        })
+      );
+    });
+
+    it("should send customer order confirmation in Serbian (SR)", async () => {
+      const order = { ...mockOrderConverted, languageCode: "SR" };
+
+      await orderNotificationService.sendOrderConfirmation(order);
+
+      expect(sendEmailToCustomer).toHaveBeenCalledWith(
+        expect.objectContaining({
+          to: "test@hytham.me",
+          subject: "Potvrda narudžbine #1524",
+        })
+      );
+    });
+
+    it("should send customer order confirmation in German (DE)", async () => {
+      const order = { ...mockOrderConverted, languageCode: "DE" };
+
+      await orderNotificationService.sendOrderConfirmation(order);
+
+      expect(sendEmailToCustomer).toHaveBeenCalledWith(
+        expect.objectContaining({
+          to: "test@hytham.me",
+          subject: "Bestellbestätigung #1524",
+        })
+      );
+    });
+
+    it("should send customer order confirmation in French (FR)", async () => {
+      const order = { ...mockOrderConverted, languageCode: "FR" };
+
+      await orderNotificationService.sendOrderConfirmation(order);
+
+      expect(sendEmailToCustomer).toHaveBeenCalledWith(
+        expect.objectContaining({
+          to: "test@hytham.me",
+          subject: "Confirmation de commande #1524",
+        })
+      );
+    });
+
+    it("should format price correctly", async () => {
+      const order = {
+        ...mockOrderConverted,
+        total: {
+          gross: {
+            amount: 5479,
+            currency: "RSD",
+          },
+        },
+      };
+
+      await orderNotificationService.sendOrderConfirmation(order);
+
+      expect(sendEmailToCustomer).toHaveBeenCalledWith(
+        expect.objectContaining({
+          subject: "Order Confirmation #1524",
+        })
+      );
+    });
+
+    it("should handle missing variant name gracefully", async () => {
+      const order = {
+        ...mockOrderConverted,
+        lines: [
+          {
+            ...mockOrderConverted.lines[0],
+            variantName: undefined,
+          },
+        ],
+      };
+
+      await orderNotificationService.sendOrderConfirmation(order);
+
+      expect(sendEmailToCustomer).toHaveBeenCalled();
+    });
+
+    it("should include variant name when present", async () => {
+      await orderNotificationService.sendOrderConfirmation(mockOrderConverted);
+
+      expect(sendEmailToCustomer).toHaveBeenCalled();
+    });
+  });
+
+  describe("sendOrderConfirmationToAdmin", () => {
+    it("should send admin notification with order details", async () => {
+      await orderNotificationService.sendOrderConfirmationToAdmin(mockOrderConverted);
+
+      expect(sendEmailToAdmin).toHaveBeenCalledWith(
+        expect.objectContaining({
+          subject: expect.stringContaining("🎉 New Order #1524"),
+          eventType: "ORDER_CONFIRMED",
+          orderId: "T3JkZXI6MTIzNDU2Nzg=",
+        })
+      );
+    });
+
+    it("should always use English for admin emails", async () => {
+      const order = { ...mockOrderConverted, languageCode: "SR" };
+
+      await orderNotificationService.sendOrderConfirmationToAdmin(order);
+
+      expect(sendEmailToAdmin).toHaveBeenCalledWith(
+        expect.objectContaining({
+          eventType: "ORDER_CONFIRMED",
+        })
+      );
+    });
+
+    it("should include all order details in admin email", async () => {
+      await orderNotificationService.sendOrderConfirmationToAdmin(mockOrderConverted);
+
+      expect(sendEmailToAdmin).toHaveBeenCalledWith(
+        expect.objectContaining({
+          subject: expect.stringContaining("🎉 New Order"),
+          eventType: "ORDER_CONFIRMED",
+        })
+      );
+    });
+  });
+
+  describe("sendOrderShipped", () => {
+    it("should send shipping confirmation with tracking", async () => {
+      await orderNotificationService.sendOrderShipped(
+        mockOrderConverted,
+        "TRK123",
+        "https://track.com/TRK123"
+      );
+
+      expect(sendEmailToCustomer).toHaveBeenCalledWith(
+        expect.objectContaining({
+          to: "test@hytham.me",
+          subject: "Your Order #1524 Has Shipped!",
+        })
+      );
+    });
+
+    it("should handle missing tracking info", async () => {
+      await orderNotificationService.sendOrderShipped(mockOrderConverted);
+
+      expect(sendEmailToCustomer).toHaveBeenCalledWith(
+        expect.objectContaining({
+          subject: "Your Order #1524 Has Shipped!",
+        })
+      );
+    });
+  });
+
+  describe("sendOrderCancelled", () => {
+    it("should send cancellation email with reason", async () => {
+      await orderNotificationService.sendOrderCancelled(
+        mockOrderConverted,
+        "Out of stock"
+      );
+
+      expect(sendEmailToCustomer).toHaveBeenCalledWith(
+        expect.objectContaining({
+          to: "test@hytham.me",
+          subject: "Your Order #1524 Has Been Cancelled",
+        })
+      );
+    });
+  });
+
+  describe("sendOrderPaid", () => {
+    it("should send payment confirmation", async () => {
+      await orderNotificationService.sendOrderPaid(mockOrderConverted);
+
+      expect(sendEmailToCustomer).toHaveBeenCalledWith(
+        expect.objectContaining({
+          to: "test@hytham.me",
+          subject: "Payment Received for Order #1524!",
+        })
+      );
+    });
+  });
+
+  describe("formatPrice", () => {
+    it("should format prices correctly for RSD", () => {
+      // This is tested indirectly through the email calls above
+      // The formatPrice function is in utils.ts
+    });
+  });
+
+  describe("edge cases", () => {
+    it("should handle orders with user name", async () => {
+      const order = {
+        ...mockOrderConverted,
+        user: { firstName: "John", lastName: "Doe" },
+      };
+
+      await orderNotificationService.sendOrderConfirmation(order);
+
+      expect(sendEmailToCustomer).toHaveBeenCalled();
+    });
+
+    it("should handle orders without user object", async () => {
+      const order = {
+        ...mockOrderConverted,
+        user: undefined,
+      };
+
+      await orderNotificationService.sendOrderConfirmation(order);
+
+      expect(sendEmailToCustomer).toHaveBeenCalled();
+    });
+
+    it("should handle orders with incomplete address", async () => {
+      const order = {
+        ...mockOrderConverted,
+        shippingAddress: {
+          firstName: "Test",
+          lastName: "Customer",
+          city: "Belgrade",
+        },
+      };
+
+      await orderNotificationService.sendOrderConfirmation(order);
+
+      expect(sendEmailToCustomer).toHaveBeenCalled();
+    });
+
+    it("should handle orders with missing shipping address", async () => {
+      const order = {
+        ...mockOrderConverted,
+        shippingAddress: undefined,
+      };
+
+      await orderNotificationService.sendOrderConfirmation(order);
+
+      expect(sendEmailToCustomer).toHaveBeenCalled();
+    });
+  });
+});

src/__tests__/unit/utils/formatPrice.test.ts

@@ -0,0 +1,42 @@
+import { describe, it, expect } from "vitest";
+import { formatPrice } from "@/app/api/webhooks/saleor/utils";
+
+describe("formatPrice", () => {
+  it("should format RSD currency correctly", () => {
+    const result = formatPrice(5479, "RSD");
+    // Note: sr-RS locale uses non-breaking space between number and currency
+    expect(result).toMatch(/5\.479,00\sRSD/);
+  });
+
+  it("should format small amounts correctly", () => {
+    const result = formatPrice(50, "RSD");
+    expect(result).toMatch(/50,00\sRSD/);
+  });
+
+  it("should format large amounts correctly", () => {
+    const result = formatPrice(100000, "RSD");
+    expect(result).toMatch(/100\.000,00\sRSD/);
+  });
+
+  it("should format EUR currency correctly", () => {
+    const result = formatPrice(100, "EUR");
+    // sr-RS locale uses € symbol for EUR
+    expect(result).toMatch(/100,00\s€/);
+  });
+
+  it("should format USD currency correctly", () => {
+    const result = formatPrice(150, "USD");
+    // sr-RS locale uses US$ symbol for USD
+    expect(result).toMatch(/150,00\sUS\$/);
+  });
+
+  it("should handle decimal amounts", () => {
+    const result = formatPrice(1000.5, "RSD");
+    expect(result).toMatch(/1\.000,50\sRSD/);
+  });
+
+  it("should handle zero", () => {
+    const result = formatPrice(0, "RSD");
+    expect(result).toMatch(/0,00\sRSD/);
+  });
+});

src/app/[locale]/checkout/components/PaymentSection.tsx

@@ -0,0 +1,47 @@
+"use client";
+
+import { PaymentMethodSelector, CODInstructions } from "@/components/payment";
+import { getPaymentMethodsForChannel } from "@/lib/config/paymentMethods";
+import type { PaymentMethod } from "@/lib/saleor/payments/types";
+import { useTranslations } from "next-intl";
+
+interface PaymentSectionProps {
+  selectedMethodId: string;
+  onSelectMethod: (methodId: string) => void;
+  locale: string;
+  channel?: string;
+  disabled?: boolean;
+}
+
+export function PaymentSection({
+  selectedMethodId,
+  onSelectMethod,
+  locale,
+  channel = "default-channel",
+  disabled = false,
+}: PaymentSectionProps) {
+  const t = useTranslations("Payment");
+
+  // Get available payment methods for this channel
+  const paymentMethods: PaymentMethod[] = getPaymentMethodsForChannel(channel);
+
+  // Get the selected method details
+  const selectedMethod = paymentMethods.find((m) => m.id === selectedMethodId);
+
+  return (
+    <section className="border-t border-gray-200 pt-6">
+      <PaymentMethodSelector
+        methods={paymentMethods}
+        selectedMethodId={selectedMethodId}
+        onSelectMethod={onSelectMethod}
+        locale={locale}
+        disabled={disabled}
+      />
+
+      {/* COD instructions can be shown here if needed */}
+      {selectedMethod?.id === "cod" && (
+        <CODInstructions />
+      )}
+    </section>
+  );
+}

src/app/[locale]/checkout/page.tsx

@@ -10,12 +10,15 @@ import Footer from "@/components/layout/Footer";
 import { useSaleorCheckoutStore } from "@/stores/saleorCheckoutStore";
 import { formatPrice } from "@/lib/saleor";
 import { saleorClient } from "@/lib/saleor/client";
+import { useAnalytics } from "@/lib/analytics";
 import {
   CHECKOUT_SHIPPING_ADDRESS_UPDATE,
-  CHECKOUT_BILLING_ADDRESS_UPDATE,
-  CHECKOUT_COMPLETE,
 } from "@/lib/saleor/mutations/Checkout";
+import { PaymentSection } from "./components/PaymentSection";
+import { DEFAULT_PAYMENT_METHOD } from "@/lib/config/paymentMethods";
+import { GET_CHECKOUT_BY_ID } from "@/lib/saleor/queries/Checkout";
 import type { Checkout } from "@/types/saleor";
+import { createCheckoutService, type Address } from "@/lib/services/checkoutService";
 
 interface ShippingAddressUpdateResponse {
   checkoutShippingAddressUpdate?: {
@@ -24,17 +27,16 @@ interface ShippingAddressUpdateResponse {
   };
 }
 
-interface BillingAddressUpdateResponse {
+interface CheckoutQueryResponse {
-  checkoutBillingAddressUpdate?: {
+  checkout?: Checkout;
-    checkout?: Checkout;
-    errors?: Array<{ message: string }>;
-  };
 }
 
-interface CheckoutCompleteResponse {
+interface ShippingMethod {
-  checkoutComplete?: {
+  id: string;
-    order?: { number: string };
+  name: string;
-    errors?: Array<{ message: string }>;
+  price: {
+    amount: number;
+    currency: string;
   };
 }
 
@@ -45,20 +47,24 @@ interface AddressForm {
   streetAddress2: string;
   city: string;
   postalCode: string;
+  country: string;
   phone: string;
+  email: string;
 }
 
 export default function CheckoutPage() {
   const t = useTranslations("Checkout");
   const locale = useLocale();
   const router = useRouter();
-  const { checkout, refreshCheckout, getLines, getTotal } = useSaleorCheckoutStore();
+  const { checkout, refreshCheckout, clearCheckout, getLines, getTotal } = useSaleorCheckoutStore();
+  const { trackCheckoutStarted, trackCheckoutStep, trackOrderCompleted, identifyUser } = useAnalytics();
   const [isLoading, setIsLoading] = useState(false);
   const [error, setError] = useState<string | null>(null);
   const [orderComplete, setOrderComplete] = useState(false);
   const [orderNumber, setOrderNumber] = useState<string | null>(null);
 
   const [sameAsShipping, setSameAsShipping] = useState(true);
+  const [selectedPaymentMethod, setSelectedPaymentMethod] = useState<string>(DEFAULT_PAYMENT_METHOD);
   const [shippingAddress, setShippingAddress] = useState<AddressForm>({
     firstName: "",
     lastName: "",
@@ -66,7 +72,9 @@ export default function CheckoutPage() {
     streetAddress2: "",
     city: "",
     postalCode: "",
+    country: "RS",
     phone: "",
+    email: "",
   });
   const [billingAddress, setBillingAddress] = useState<AddressForm>({
     firstName: "",
@@ -75,21 +83,120 @@ export default function CheckoutPage() {
     streetAddress2: "",
     city: "",
     postalCode: "",
+    country: "RS",
     phone: "",
+    email: "",
   });
 
+  const [shippingMethods, setShippingMethods] = useState<ShippingMethod[]>([]);
+  const [selectedShippingMethod, setSelectedShippingMethod] = useState<string>("");
+  const [isLoadingShipping, setIsLoadingShipping] = useState(false);
+
   const lines = getLines();
   const total = getTotal();
 
+  // Debounced shipping method fetching
+  useEffect(() => {
+    if (!checkout) return;
+    
+    // Check if address is complete enough to fetch shipping methods
+    const isAddressComplete = 
+      shippingAddress.firstName && 
+      shippingAddress.lastName && 
+      shippingAddress.streetAddress1 && 
+      shippingAddress.city && 
+      shippingAddress.postalCode && 
+      shippingAddress.country;
+    
+    if (!isAddressComplete) {
+      setShippingMethods([]);
+      return;
+    }
+
+    const timer = setTimeout(async () => {
+      setIsLoadingShipping(true);
+      try {
+        console.log("Fetching shipping methods...");
+        
+        // First update the shipping address
+        await saleorClient.mutate<ShippingAddressUpdateResponse>({
+          mutation: CHECKOUT_SHIPPING_ADDRESS_UPDATE,
+          variables: {
+            checkoutId: checkout.id,
+            shippingAddress: {
+              firstName: shippingAddress.firstName,
+              lastName: shippingAddress.lastName,
+              streetAddress1: shippingAddress.streetAddress1,
+              streetAddress2: shippingAddress.streetAddress2,
+              city: shippingAddress.city,
+              postalCode: shippingAddress.postalCode,
+              country: shippingAddress.country,
+              phone: shippingAddress.phone,
+            },
+          },
+        });
+
+        // Then query for shipping methods
+        const checkoutQueryResult = await saleorClient.query<CheckoutQueryResponse>({
+          query: GET_CHECKOUT_BY_ID,
+          variables: { id: checkout.id },
+          fetchPolicy: "network-only",
+        });
+
+        const availableMethods = checkoutQueryResult.data?.checkout?.shippingMethods || [];
+        console.log("Available shipping methods:", availableMethods);
+        
+        setShippingMethods(availableMethods);
+        
+        // Auto-select first method if none selected
+        if (availableMethods.length > 0 && !selectedShippingMethod) {
+          setSelectedShippingMethod(availableMethods[0].id);
+        }
+      } catch (err) {
+        console.error("Error fetching shipping methods:", err);
+      } finally {
+        setIsLoadingShipping(false);
+      }
+    }, 500); // 500ms debounce
+
+    return () => clearTimeout(timer);
+  }, [checkout, shippingAddress]);
+
   useEffect(() => {
     if (!checkout) {
       refreshCheckout();
     }
   }, [checkout, refreshCheckout]);
 
+  // Track checkout started when page loads
+  useEffect(() => {
+    if (checkout) {
+      const lines = getLines();
+      const total = getTotal();
+      trackCheckoutStarted({
+        total,
+        currency: "RSD",
+        item_count: lines.reduce((sum, line) => sum + line.quantity, 0),
+        items: lines.map(line => ({
+          id: line.variant.id,
+          name: line.variant.product.name,
+          quantity: line.quantity,
+          price: line.variant.pricing?.price?.gross?.amount || 0,
+        })),
+      });
+    }
+  }, [checkout]);
+
+  // Scroll to top when order is complete
+  useEffect(() => {
+    if (orderComplete) {
+      window.scrollTo({ top: 0, behavior: "smooth" });
+    }
+  }, [orderComplete]);
+
   const handleShippingChange = (field: keyof AddressForm, value: string) => {
     setShippingAddress((prev) => ({ ...prev, [field]: value }));
-    if (sameAsShipping) {
+    if (sameAsShipping && field !== "email") {
       setBillingAddress((prev) => ({ ...prev, [field]: value }));
     }
   };
@@ -98,6 +205,10 @@ export default function CheckoutPage() {
     setBillingAddress((prev) => ({ ...prev, [field]: value }));
   };
 
+  const handleEmailChange = (value: string) => {
+    setShippingAddress((prev) => ({ ...prev, email: value }));
+  };
+
   const handleSubmit = async (e: React.FormEvent) => {
     e.preventDefault();
 
@@ -106,61 +217,133 @@ export default function CheckoutPage() {
       return;
     }
 
+    // Validate all required fields
+    if (!shippingAddress.email || !shippingAddress.email.includes("@")) {
+      setError(t("errorEmailRequired"));
+      return;
+    }
+
+    if (!shippingAddress.phone || shippingAddress.phone.length < 8) {
+      setError(t("errorPhoneRequired"));
+      return;
+    }
+
+    if (!shippingAddress.firstName || !shippingAddress.lastName || !shippingAddress.streetAddress1 || !shippingAddress.city || !shippingAddress.postalCode) {
+      setError(t("errorFieldsRequired"));
+      return;
+    }
+
+    if (!selectedShippingMethod) {
+      setError(t("errorSelectShipping"));
+      return;
+    }
+
+    if (!selectedPaymentMethod) {
+      setError(t("errorSelectPayment"));
+      return;
+    }
+
     setIsLoading(true);
     setError(null);
 
     try {
-      const shippingResult = await saleorClient.mutate<ShippingAddressUpdateResponse>({
+      console.log("Completing order via CheckoutService...");
-        mutation: CHECKOUT_SHIPPING_ADDRESS_UPDATE,
+
-        variables: {
+      // Create checkout service instance
-          checkoutId: checkout.id,
+      const checkoutService = createCheckoutService(checkout.id);
-          shippingAddress: {
+
-            ...shippingAddress,
+      // Transform form data to service types
-            country: "RS",
+      const serviceShippingAddress: Address = {
-          },
+        firstName: shippingAddress.firstName,
+        lastName: shippingAddress.lastName,
+        streetAddress1: shippingAddress.streetAddress1,
+        streetAddress2: shippingAddress.streetAddress2,
+        city: shippingAddress.city,
+        postalCode: shippingAddress.postalCode,
+        country: shippingAddress.country,
+        phone: shippingAddress.phone,
+      };
+
+      const serviceBillingAddress: Address = {
+        firstName: billingAddress.firstName,
+        lastName: billingAddress.lastName,
+        streetAddress1: billingAddress.streetAddress1,
+        streetAddress2: billingAddress.streetAddress2,
+        city: billingAddress.city,
+        postalCode: billingAddress.postalCode,
+        country: billingAddress.country,
+        phone: billingAddress.phone,
+      };
+
+      // Execute checkout pipeline
+      const result = await checkoutService.execute({
+        email: shippingAddress.email,
+        shippingAddress: serviceShippingAddress,
+        billingAddress: serviceBillingAddress,
+        shippingMethodId: selectedShippingMethod,
+        languageCode: locale.toUpperCase(),
+        metadata: {
+          phone: shippingAddress.phone,
+          shippingPhone: shippingAddress.phone,
+          userLanguage: locale,
+          userLocale: locale,
         },
       });
 
-      if (shippingResult.data?.checkoutShippingAddressUpdate?.errors && shippingResult.data.checkoutShippingAddressUpdate.errors.length > 0) {
+      if (!result.success || !result.order) {
-        throw new Error(shippingResult.data.checkoutShippingAddressUpdate.errors[0].message);
+        // Handle specific error types
+        if (result.error === "CHECKOUT_EXPIRED") {
+          console.error("Checkout not found, clearing cart...");
+          localStorage.removeItem('cart');
+          localStorage.removeItem('checkoutId');
+          window.location.href = `/${locale}/products`;
+          return;
+        }
+        throw new Error(result.error || t("errorCreatingOrder"));
       }
 
-      const billingResult = await saleorClient.mutate<BillingAddressUpdateResponse>({
+      // Success!
-        mutation: CHECKOUT_BILLING_ADDRESS_UPDATE,
+      setOrderNumber(result.order.number);
-        variables: {
+      setOrderComplete(true);
-          checkoutId: checkout.id,
+      
-          billingAddress: {
+      // Clear the checkout/cart from the store
-            ...billingAddress,
+      clearCheckout();
-            country: "RS",
+      
-          },
+      // Track order completion
-        },
+      const lines = getLines();
+      const total = getTotal();
+      trackOrderCompleted({
+        order_id: checkout.id,
+        order_number: result.order.number,
+        total,
+        currency: "RSD",
+        item_count: lines.reduce((sum, line) => sum + line.quantity, 0),
+        shipping_cost: shippingMethods.find(m => m.id === selectedShippingMethod)?.price.amount,
+        customer_email: shippingAddress.email,
       });
       
-      if (billingResult.data?.checkoutBillingAddressUpdate?.errors && billingResult.data.checkoutBillingAddressUpdate.errors.length > 0) {
+      // Identify the user
-        throw new Error(billingResult.data.checkoutBillingAddressUpdate.errors[0].message);
+      identifyUser({
-      }
+        profileId: shippingAddress.email,
-
+        email: shippingAddress.email,
-      const completeResult = await saleorClient.mutate<CheckoutCompleteResponse>({
+        firstName: shippingAddress.firstName,
-        mutation: CHECKOUT_COMPLETE,
+        lastName: shippingAddress.lastName,
-        variables: {
-          checkoutId: checkout.id,
-        },
       });
 
-      if (completeResult.data?.checkoutComplete?.errors && completeResult.data.checkoutComplete.errors.length > 0) {
+      console.log("Order completed successfully:", result.order.number);
-        throw new Error(completeResult.data.checkoutComplete.errors[0].message);
-      }
 
-      const order = completeResult.data?.checkoutComplete?.order;
-      if (order) {
-        setOrderNumber(order.number);
-        setOrderComplete(true);
-      } else {
-        throw new Error(t("errorCreatingOrder"));
-      }
     } catch (err: unknown) {
-      const errorMessage = err instanceof Error ? err.message : null;
+      console.error("Checkout error:", err);
-      setError(errorMessage || t("errorOccurred"));
+      
+      if (err instanceof Error) {
+        if (err.name === "AbortError") {
+          setError("Request timed out. Please check your connection and try again.");
+        } else {
+          setError(err.message || t("errorOccurred"));
+        }
+      } else {
+        setError(t("errorOccurred"));
+      }
     } finally {
       setIsLoading(false);
     }
@@ -227,6 +410,36 @@ export default function CheckoutPage() {
             <div className="grid grid-cols-1 lg:grid-cols-2 gap-12">
               <div>
                 <form onSubmit={handleSubmit} className="space-y-6">
+                  <div className="border-b border-border pb-6">
+                    <h2 className="text-xl font-serif mb-4">{t("contactInfo")}</h2>
+                    <div className="grid grid-cols-1 gap-4">
+                      <div>
+                        <label className="block text-sm font-medium mb-1">{t("email")}</label>
+                        <input
+                          type="email"
+                          required
+                          value={shippingAddress.email}
+                          onChange={(e) => handleEmailChange(e.target.value)}
+                          className="w-full border border-border px-4 py-2 rounded"
+                          placeholder="email@example.com"
+                        />
+                        <p className="text-xs text-foreground-muted mt-1">{t("emailRequired")}</p>
+                      </div>
+                      <div>
+                        <label className="block text-sm font-medium mb-1">{t("phone")}</label>
+                        <input
+                          type="tel"
+                          required
+                          value={shippingAddress.phone}
+                          onChange={(e) => handleShippingChange("phone", e.target.value)}
+                          className="w-full border border-border px-4 py-2 rounded"
+                          placeholder="+381..."
+                        />
+                        <p className="text-xs text-foreground-muted mt-1">{t("phoneRequired")}</p>
+                      </div>
+                    </div>
+                  </div>
+
                   <div className="border-b border-border pb-6">
                     <h2 className="text-xl font-serif mb-4">{t("shippingAddress")}</h2>
                     <div className="grid grid-cols-2 gap-4">
@@ -250,6 +463,35 @@ export default function CheckoutPage() {
                           className="w-full border border-border px-4 py-2 rounded"
                         />
                       </div>
+                      <div className="col-span-2">
+                        <label className="block text-sm font-medium mb-1">{t("country")}</label>
+                        <select
+                          required
+                          value={shippingAddress.country}
+                          onChange={(e) => handleShippingChange("country", e.target.value)}
+                          className="w-full border border-border px-4 py-2 rounded"
+                        >
+                          <option value="RS">Serbia (Srbija)</option>
+                          <option value="BA">Bosnia and Herzegovina</option>
+                          <option value="ME">Montenegro</option>
+                          <option value="HR">Croatia</option>
+                          <option value="SI">Slovenia</option>
+                          <option value="MK">North Macedonia</option>
+                          <option value="AL">Albania</option>
+                          <option value="XK">Kosovo</option>
+                          <option value="BG">Bulgaria</option>
+                          <option value="RO">Romania</option>
+                          <option value="HU">Hungary</option>
+                          <option value="DE">Germany</option>
+                          <option value="AT">Austria</option>
+                          <option value="CH">Switzerland</option>
+                          <option value="FR">France</option>
+                          <option value="GB">United Kingdom</option>
+                          <option value="US">United States</option>
+                          <option value="CA">Canada</option>
+                          <option value="AU">Australia</option>
+                        </select>
+                      </div>
                       <div className="col-span-2">
                         <label className="block text-sm font-medium mb-1">{t("streetAddress")}</label>
                         <input
@@ -289,16 +531,6 @@ export default function CheckoutPage() {
                           className="w-full border border-border px-4 py-2 rounded"
                         />
                       </div>
-                      <div className="col-span-2">
-                        <label className="block text-sm font-medium mb-1">{t("phone")}</label>
-                        <input
-                          type="tel"
-                          required
-                          value={shippingAddress.phone}
-                          onChange={(e) => handleShippingChange("phone", e.target.value)}
-                          className="w-full border border-border px-4 py-2 rounded"
-                        />
-                      </div>
                     </div>
                   </div>
 
@@ -314,9 +546,70 @@ export default function CheckoutPage() {
                     </label>
                   </div>
 
+                  {/* Shipping Method Selection */}
+                  <div className="border-b border-border pb-6">
+                    <h2 className="text-xl font-serif mb-4">{t("shippingMethod")}</h2>
+                    {isLoadingShipping ? (
+                      <div className="flex items-center gap-2 text-foreground-muted">
+                        <svg className="animate-spin h-5 w-5" xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24">
+                          <circle className="opacity-25" cx="12" cy="12" r="10" stroke="currentColor" strokeWidth="4"></circle>
+                          <path className="opacity-75" fill="currentColor" d="M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4zm2 5.291A7.962 7.962 0 014 12H0c0 3.042 1.135 5.824 3 7.938l3-2.647z"></path>
+                        </svg>
+                        <span>{t("loadingShippingMethods")}</span>
+                      </div>
+                    ) : shippingMethods.length > 0 ? (
+                      <div className="space-y-3">
+                        {shippingMethods.map((method) => (
+                          <label
+                            key={method.id}
+                            className={`flex items-center justify-between p-4 border rounded cursor-pointer transition-colors ${
+                              selectedShippingMethod === method.id
+                                ? "border-foreground bg-background-ice"
+                                : "border-border hover:border-foreground/50"
+                            }`}
+                          >
+                            <div className="flex items-center gap-3">
+                              <input
+                                type="radio"
+                                name="shippingMethod"
+                                value={method.id}
+                                checked={selectedShippingMethod === method.id}
+                                onChange={(e) => setSelectedShippingMethod(e.target.value)}
+                                className="w-4 h-4"
+                              />
+                              <span className="font-medium">{method.name}</span>
+                            </div>
+                            <span className="text-foreground-muted">
+                              {formatPrice(method.price.amount)}
+                            </span>
+                          </label>
+                        ))}
+                      </div>
+                    ) : (
+                      <p className="text-foreground-muted">{t("enterAddressForShipping")}</p>
+                    )}
+                  </div>
+
+                  {/* Payment Method Section */}
+                  <PaymentSection
+                    selectedMethodId={selectedPaymentMethod}
+                    onSelectMethod={setSelectedPaymentMethod}
+                    locale={locale}
+                    channel="default-channel"
+                    disabled={isLoading}
+                  />
+
+                  {/* Money Back Guarantee Trust Badge */}
+                  <div className="flex items-center justify-center gap-2 py-3 px-4 bg-green-50 rounded-lg border border-green-100">
+                    <svg className="w-5 h-5 text-green-600" fill="none" viewBox="0 0 24 24" stroke="currentColor" strokeWidth={2}>
+                      <path strokeLinecap="round" strokeLinejoin="round" d="M9 12l2 2 4-4m6 2a9 9 0 11-18 0 9 9 0 0118 0z" />
+                    </svg>
+                    <span className="text-sm font-medium text-green-800">{t("moneyBackGuarantee")}</span>
+                  </div>
+
                   <button
                     type="submit"
-                    disabled={isLoading || lines.length === 0}
+                    disabled={isLoading || lines.length === 0 || !selectedShippingMethod}
                     className="w-full py-4 bg-foreground text-white font-medium hover:bg-accent-dark transition-colors disabled:opacity-50"
                   >
                     {isLoading ? t("processing") : t("completeOrder", { total: formatPrice(total) })}
@@ -363,6 +656,12 @@ export default function CheckoutPage() {
                         <span className="text-foreground-muted">{t("subtotal")}</span>
                         <span>{formatPrice(checkout?.subtotalPrice?.gross?.amount || 0)}</span>
                       </div>
+                      {selectedShippingMethod && (
+                        <div className="flex justify-between">
+                          <span className="text-foreground-muted">{t("shipping")}</span>
+                          <span>{formatPrice(shippingMethods.find(m => m.id === selectedShippingMethod)?.price.amount || 0)}</span>
+                        </div>
+                      )}
                       <div className="flex justify-between font-medium text-lg pt-2 border-t border-border">
                         <span>{t("total")}</span>
                         <span>{formatPrice(total)}</span>

src/app/[locale]/layout.tsx

@@ -2,6 +2,7 @@ import { Metadata } from "next";
 import { NextIntlClientProvider } from "next-intl";
 import { getMessages, setRequestLocale } from "next-intl/server";
 import { SUPPORTED_LOCALES, DEFAULT_LOCALE, isValidLocale } from "@/lib/i18n/locales";
+import { OpenPanelComponent } from "@openpanel/nextjs";
 
 const baseUrl = process.env.NEXT_PUBLIC_SITE_URL || "https://dev.manoonoils.com";
 
@@ -44,8 +45,17 @@ export default async function LocaleLayout({
   const messages = await getMessages();
 
   return (
-    <NextIntlClientProvider messages={messages}>
+    <>
-      {children}
+        <OpenPanelComponent
-    </NextIntlClientProvider>
+          clientId={process.env.NEXT_PUBLIC_OPENPANEL_CLIENT_ID || ""}
+          trackScreenViews={true}
+          trackOutgoingLinks={true}
+          apiUrl="https://op.nodecrew.me/api"
+          scriptUrl="https://op.nodecrew.me/op1.js"
+        />
+      <NextIntlClientProvider messages={messages}>
+        {children}
+      </NextIntlClientProvider>
+    </>
   );
 }

src/app/api/op/[...path]/route.ts

@@ -0,0 +1,5 @@
+import { createRouteHandler } from "@openpanel/nextjs/server";
+
+export const { GET, POST } = createRouteHandler({
+  apiUrl: "https://op.nodecrew.me/api",
+});

src/components/cart/CartDrawer.tsx

@@ -1,6 +1,6 @@
 "use client";
 
-import { useEffect, useState } from "react";
+import { useEffect, useState, useRef } from "react";
 import { motion, AnimatePresence } from "framer-motion";
 import Image from "next/image";
 import Link from "next/link";
@@ -30,14 +30,16 @@ export default function CartDrawer() {
   const lines = getLines();
   const total = getTotal();
   const lineCount = getLineCount();
-  const [initialized, setInitialized] = useState(false);
+  const initializedRef = useRef(false);
 
   useEffect(() => {
-    if (!initialized) {
+    if (!initializedRef.current && locale) {
+      // Set language code before initializing checkout
+      useSaleorCheckoutStore.getState().setLanguageCode(locale);
       initCheckout();
-      setInitialized(true);
+      initializedRef.current = true;
     }
-  }, [initialized]);
+  }, [locale]);
 
   useEffect(() => {
     if (isOpen) {

src/components/home/NewHero.tsx

@@ -15,9 +15,13 @@ interface NewHeroProps {
 
 export default function NewHero({ featuredProduct }: NewHeroProps) {
   const locale = useLocale();
-  const { addLine, openCart } = useSaleorCheckoutStore();
+  const { addLine, openCart, setLanguageCode } = useSaleorCheckoutStore();
 
   const handleAddToCart = async () => {
+    // Set language code before adding to cart
+    if (locale) {
+      setLanguageCode(locale);
+    }
     const variant = featuredProduct?.variants?.[0];
     if (variant?.id) {
       await addLine(variant.id, 1);

src/components/layout/Header.tsx

@@ -5,7 +5,7 @@ import Link from "next/link";
 import Image from "next/image";
 import { usePathname } from "next/navigation";
 import { AnimatePresence, motion } from "framer-motion";
-import { useTranslations } from "next-intl";
+import { useTranslations, useLocale } from "next-intl";
 import { useSaleorCheckoutStore } from "@/stores/saleorCheckoutStore";
 import { User, ShoppingBag, Menu, X, Globe } from "lucide-react";
 import CartDrawer from "@/components/cart/CartDrawer";
@@ -16,14 +16,15 @@ interface HeaderProps {
   locale?: string;
 }
 
-export default function Header({ locale = "sr" }: HeaderProps) {
+export default function Header({ locale: propLocale = "sr" }: HeaderProps) {
   const t = useTranslations("Header");
   const pathname = usePathname();
   const dropdownRef = useRef<HTMLDivElement>(null);
   const [mobileMenuOpen, setMobileMenuOpen] = useState(false);
   const [scrolled, setScrolled] = useState(false);
   const [langDropdownOpen, setLangDropdownOpen] = useState(false);
-  const { getLineCount, toggleCart, initCheckout } = useSaleorCheckoutStore();
+  const { getLineCount, toggleCart, initCheckout, setLanguageCode } = useSaleorCheckoutStore();
+  const locale = useLocale();
 
   const itemCount = getLineCount();
   const currentLocale = isValidLocale(locale) ? LOCALE_CONFIG[locale] : LOCALE_CONFIG.sr;
@@ -54,9 +55,14 @@ export default function Header({ locale = "sr" }: HeaderProps) {
     setLangDropdownOpen(false);
   };
 
+  // Set language code first, then initialize checkout
   useEffect(() => {
-    initCheckout();
+    if (locale) {
-  }, [initCheckout]);
+      setLanguageCode(locale);
+      // Initialize checkout after language code is set
+      initCheckout();
+    }
+  }, [locale, setLanguageCode, initCheckout]);
 
   useEffect(() => {
     const handleScroll = () => {

src/components/payment/CODInstructions.tsx

@@ -0,0 +1,6 @@
+// COD Instructions component - currently disabled as the instructions are self-explanatory
+// Can be re-enabled if payment method instructions are needed in the future
+
+export function CODInstructions() {
+  return null;
+}

src/components/payment/PaymentMethodCard.tsx

@@ -0,0 +1,125 @@
+"use client";
+
+import { cn } from "@/lib/utils";
+import type { PaymentMethod } from "@/lib/saleor/payments/types";
+import { Banknote, CreditCard, Building2, LucideIcon } from "lucide-react";
+import { useTranslations } from "next-intl";
+
+// Icon mapping for payment methods
+const iconMap: Record<string, LucideIcon> = {
+  Banknote,
+  CreditCard,
+  Building2,
+};
+
+interface PaymentMethodCardProps {
+  method: PaymentMethod;
+  isSelected: boolean;
+  onSelect: () => void;
+  disabled?: boolean;
+  locale: string;
+}
+
+export function PaymentMethodCard({
+  method,
+  isSelected,
+  onSelect,
+  disabled = false,
+  locale,
+}: PaymentMethodCardProps) {
+  const t = useTranslations("Payment");
+  const Icon = method.icon ? iconMap[method.icon] : Banknote;
+
+  // Get translated name and description based on method ID
+  const translatedName = t(`${method.id}.name`);
+  const translatedDescription = t(`${method.id}.description`);
+
+  return (
+    <label
+      className={cn(
+        "relative flex cursor-pointer items-start gap-4 rounded-xl border-2 p-5 transition-all duration-300",
+        "hover:scale-[1.02] hover:shadow-lg",
+        isSelected
+          ? "border-[#059669] bg-white shadow-xl shadow-[#047857]/30"
+          : "border-gray-200 bg-white hover:border-[#3B82F6]",
+        (disabled || !method.available) && "cursor-not-allowed opacity-50"
+      )}
+    >
+      <input
+        type="radio"
+        name="payment-method"
+        value={method.id}
+        checked={isSelected}
+        onChange={onSelect}
+        disabled={disabled || !method.available}
+        className="sr-only"
+      />
+
+      {/* Glowing green checkmark for selected */}
+      {isSelected && (
+        <div className="absolute -right-2 -top-2 z-10">
+          <div className="relative">
+            {/* Glow effect */}
+            <div className="absolute inset-0 rounded-full bg-[#059669] blur-md opacity-70" />
+            {/* Green circle with checkmark */}
+            <div className="relative flex h-8 w-8 items-center justify-center rounded-full bg-gradient-to-br from-[#059669] to-[#047857] shadow-lg">
+              <svg 
+                className="h-5 w-5 text-white" 
+                fill="none" 
+                viewBox="0 0 24 24" 
+                stroke="currentColor" 
+                strokeWidth={3}
+              >
+                <path strokeLinecap="round" strokeLinejoin="round" d="M5 13l4 4L19 7" />
+              </svg>
+            </div>
+          </div>
+        </div>
+      )}
+
+      <div className={cn(
+        "flex h-12 w-12 shrink-0 items-center justify-center rounded-xl transition-all duration-300",
+        isSelected 
+          ? "bg-gradient-to-br from-[#059669] to-[#047857] shadow-lg shadow-[#047857]/40" 
+          : "bg-gradient-to-br from-blue-50 to-blue-100"
+      )}>
+        <Icon className={cn(
+          "h-6 w-6 transition-colors",
+          isSelected ? "text-white" : "text-[#3B82F6]"
+        )} />
+      </div>
+
+      <div className="flex-1 pr-8">
+        <div className="flex items-center justify-between">
+          <span className={cn(
+            "text-lg font-bold transition-colors",
+            isSelected ? "text-[#047857]" : "text-gray-900"
+          )}>
+            {translatedName}
+          </span>
+          {method.fee > 0 && (
+            <span className="text-sm font-semibold text-amber-600 bg-amber-100 px-2 py-1 rounded-full">
+              +{new Intl.NumberFormat(locale === 'sr' ? 'sr-RS' : 'en-US', {
+                style: 'currency',
+                currency: 'RSD',
+              }).format(method.fee)}
+            </span>
+          )}
+        </div>
+
+        <p className={cn(
+          "mt-1 text-sm font-medium transition-colors",
+          isSelected ? "text-gray-700" : "text-gray-600"
+        )}>
+          {translatedDescription}
+        </p>
+
+        {!method.available && (
+          <span className="mt-2 inline-block text-xs font-medium text-gray-500 bg-gray-100 px-2 py-1 rounded">
+            {t(`${method.id}.comingSoon`)}
+          </span>
+        )}
+      </div>
+    </label>
+  );
+}

src/components/payment/PaymentMethodSelector.tsx

@@ -0,0 +1,62 @@
+"use client";
+
+import type { PaymentMethod } from "@/lib/saleor/payments/types";
+import { PaymentMethodCard } from "./PaymentMethodCard";
+import { useTranslations } from "next-intl";
+
+interface PaymentMethodSelectorProps {
+  methods: PaymentMethod[];
+  selectedMethodId: string;
+  onSelectMethod: (methodId: string) => void;
+  locale: string;
+  disabled?: boolean;
+}
+
+export function PaymentMethodSelector({
+  methods,
+  selectedMethodId,
+  onSelectMethod,
+  locale,
+  disabled = false,
+}: PaymentMethodSelectorProps) {
+  const t = useTranslations("Payment");
+
+  // Filter to only available methods
+  const availableMethods = methods.filter((m) => m.available);
+
+  if (availableMethods.length === 0) {
+    return (
+      <div className="rounded-lg border border-gray-200 p-4 text-center text-gray-500">
+        {t("noMethodsAvailable")}
+      </div>
+    );
+  }
+
+  // If only one method, show it as selected but don't allow changing
+  const isSingleMethod = availableMethods.length === 1;
+
+  return (
+    <div className="space-y-4">
+      <h3 className="text-lg font-medium">{t("title")}</h3>
+
+      <div className="space-y-3">
+        {availableMethods.map((method) => (
+          <PaymentMethodCard
+            key={method.id}
+            method={method}
+            isSelected={selectedMethodId === method.id}
+            onSelect={() => onSelectMethod(method.id)}
+            disabled={disabled || isSingleMethod}
+            locale={locale}
+          />
+        ))}
+      </div>
+
+      {isSingleMethod && (
+        <p className="text-sm text-gray-500">
+          {t("singleMethodNotice")}
+        </p>
+      )}
+    </div>
+  );
+}

src/components/payment/index.ts

@@ -0,0 +1,4 @@
+// Payment components exports
+export { PaymentMethodSelector } from "./PaymentMethodSelector";
+export { PaymentMethodCard } from "./PaymentMethodCard";
+export { CODInstructions } from "./CODInstructions";

src/components/product/ProductDetail.tsx

@@ -20,6 +20,7 @@ import BeforeAfterGallery from "@/components/home/BeforeAfterGallery";
 import HowItWorks from "@/components/home/HowItWorks";
 import NewsletterSection from "@/components/home/NewsletterSection";
 import BundleSelector from "@/components/product/BundleSelector";
+import { useAnalytics } from "@/lib/analytics";
 
 interface ProductDetailProps {
   product: Product;
@@ -98,9 +99,26 @@ export default function ProductDetail({ product, relatedProducts, bundleProducts
   const [isAdding, setIsAdding] = useState(false);
   const [urgencyIndex, setUrgencyIndex] = useState(0);
   const [selectedBundleVariantId, setSelectedBundleVariantId] = useState<string | null>(null);
-  const { addLine, openCart } = useSaleorCheckoutStore();
+  const { addLine, openCart, setLanguageCode } = useSaleorCheckoutStore();
+  const { trackProductView, trackAddToCart } = useAnalytics();
   const validLocale = isValidLocale(locale) ? locale : "sr";
 
+  // Track product view on mount
+  useEffect(() => {
+    const localized = getLocalizedProduct(product, locale);
+    const baseVariant = product.variants?.[0];
+    const price = baseVariant?.pricing?.price?.gross?.amount || 0;
+    const currency = baseVariant?.pricing?.price?.gross?.currency || "RSD";
+    
+    trackProductView({
+      id: product.id,
+      name: localized.name,
+      price,
+      currency,
+      category: product.category?.name,
+    });
+  }, [product, locale]);
+
   useEffect(() => {
     const interval = setInterval(() => {
       setUrgencyIndex(prev => (prev + 1) % 3);
@@ -129,9 +147,33 @@ export default function ProductDetail({ product, relatedProducts, bundleProducts
   const handleAddToCart = async () => {
     if (!selectedVariantId) return;
 
+    // Set language code before adding to cart
+    if (validLocale) {
+      setLanguageCode(validLocale);
+    }
+
     setIsAdding(true);
     try {
       await addLine(selectedVariantId, 1);
+      
+      // Track add to cart
+      const localized = getLocalizedProduct(product, locale);
+      const baseVariant = product.variants?.[0];
+      const selectedVariant = selectedVariantId === baseVariant?.id 
+        ? baseVariant 
+        : bundleProducts.find(p => p.variants?.[0]?.id === selectedVariantId)?.variants?.[0];
+      const price = selectedVariant?.pricing?.price?.gross?.amount || 0;
+      const currency = selectedVariant?.pricing?.price?.gross?.currency || "RSD";
+      
+      trackAddToCart({
+        id: product.id,
+        name: localized.name,
+        price,
+        currency,
+        quantity: 1,
+        variant: selectedVariant?.name,
+      });
+      
       openCart();
     } finally {
       setIsAdding(false);

src/i18n/messages/de.json

@@ -340,7 +340,13 @@
   },
   "Checkout": {
     "checkout": "Kasse",
+    "contactInfo": "Kontaktinformationen",
+    "email": "E-Mail",
+    "emailRequired": "Erforderlich für Bestellbestätigung",
+    "phoneRequired": "Erforderlich für Lieferkoordination",
     "shippingAddress": "Lieferadresse",
+    "shippingMethod": "Versandart",
+    "country": "Land",
     "firstName": "Vorname",
     "lastName": "Nachname",
     "streetAddress": "Straße und Nummer",
@@ -355,6 +361,7 @@
     "cashOnDeliveryDesc": "Bezahlen Sie, wenn Ihre Bestellung an Ihre Tür geliefert wird.",
     "processing": "Wird bearbeitet...",
     "completeOrder": "Bestellung abschließen - {total}",
+    "moneyBackGuarantee": "30 Tage Geld-zurück-Garantie",
     "orderSummary": "Bestellübersicht",
     "qty": "Menge",
     "subtotal": "Zwischensumme",
@@ -364,12 +371,51 @@
     "yourCartEmpty": "Ihr Warenkorb ist leer",
     "continueShopping": "Weiter einkaufen",
     "errorNoCheckout": "Keine aktive Kasse. Bitte versuchen Sie es erneut.",
+    "errorEmailRequired": "Bitte geben Sie eine gültige E-Mail-Adresse ein.",
+    "errorFieldsRequired": "Bitte füllen Sie alle erforderlichen Felder aus.",
+    "errorNoShippingMethods": "Keine Versandmethoden für diese Adresse verfügbar. Bitte überprüfen Sie Ihre Adresse oder kontaktieren Sie den Support.",
+    "errorSelectShipping": "Bitte wählen Sie eine Versandmethode.",
+    "errorPhoneRequired": "Bitte geben Sie eine gültige Telefonnummer ein.",
+    "loadingShippingMethods": "Versandoptionen werden geladen...",
+    "enterAddressForShipping": "Geben Sie Ihre Adresse ein, um Versandoptionen zu sehen.",
     "errorOccurred": "Ein Fehler ist during des Checkouts aufgetreten.",
     "errorCreatingOrder": "Bestellung konnte nicht erstellt werden.",
     "orderConfirmed": "Bestellung bestätigt!",
     "thankYou": "Vielen Dank für Ihren Einkauf.",
     "orderNumber": "Bestellnummer",
     "confirmationEmail": "Sie erhalten in Kürze eine Bestätigungs-E-Mail. Wir werden Sie kontaktieren, um Nachnahme zu arrangieren.",
-    "continueShoppingBtn": "Weiter einkaufen"
+    "continueShoppingBtn": "Weiter einkaufen",
+    "errorSelectPayment": "Bitte wählen Sie eine Zahlungsmethode."
+  },
+  "Payment": {
+    "title": "Zahlungsmethode",
+    "selectMethod": "Zahlungsmethode wählen",
+    "securePayment": "Sichere Zahlungsabwicklung",
+    "noMethodsAvailable": "Keine Zahlungsmethoden verfügbar",
+    "singleMethodNotice": "Nachnahme ist die einzige verfügbare Zahlungsmethode für Ihren Standort",
+    "selected": "Ausgewählt",
+    "cod": {
+      "name": "Nachnahme",
+      "description": "Bezahlen Sie bei Erhalt Ihrer Bestellung",
+      "instructions": {
+        "title": "Zahlungsanweisungen",
+        "prepareCash": "Bargeld vorbereiten",
+        "prepareCashDesc": "Bitte haben Sie den genauen Betrag in bar bereit",
+        "inspectOrder": "Vor Zahlung prüfen",
+        "inspectOrderDesc": "Sie können Ihre Bestellung vor der Zahlung überprüfen",
+        "noFee": "Keine zusätzliche Gebühr",
+        "noFeeDesc": "Nachnahme ist völlig kostenlos"
+      }
+    },
+    "card": {
+      "name": "Kreditkarte",
+      "description": "Sichere Online-Zahlung",
+      "comingSoon": "Demnächst verfügbar"
+    },
+    "bank_transfer": {
+      "name": "Banküberweisung",
+      "description": "Bezahlen Sie per Banküberweisung",
+      "comingSoon": "Demnächst verfügbar"
+    }
   }
 }

src/i18n/messages/en.json

@@ -386,7 +386,13 @@
   },
   "Checkout": {
     "checkout": "Checkout",
+    "contactInfo": "Contact Information",
+    "email": "Email",
+    "emailRequired": "Required for order confirmation",
+    "phoneRequired": "Required for delivery coordination",
     "shippingAddress": "Shipping Address",
+    "shippingMethod": "Shipping Method",
+    "country": "Country",
     "firstName": "First Name",
     "lastName": "Last Name",
     "streetAddress": "Street Address",
@@ -401,6 +407,7 @@
     "cashOnDeliveryDesc": "Pay when your order is delivered to your door.",
     "processing": "Processing...",
     "completeOrder": "Complete Order - {total}",
+    "moneyBackGuarantee": "30-Day Money-Back Guarantee",
     "orderSummary": "Order Summary",
     "qty": "Qty",
     "subtotal": "Subtotal",
@@ -410,12 +417,52 @@
     "yourCartEmpty": "Your cart is empty",
     "continueShopping": "Continue Shopping",
     "errorNoCheckout": "No active checkout. Please try again.",
+    "errorEmailRequired": "Please enter a valid email address.",
+    "errorFieldsRequired": "Please fill in all required fields.",
+    "errorNoShippingMethods": "No shipping methods available for this address. Please check your address or contact support.",
+    "errorSelectShipping": "Please select a shipping method.",
+    "errorPhoneRequired": "Please enter a valid phone number.",
+    "loadingShippingMethods": "Loading shipping options...",
+    "enterAddressForShipping": "Enter your address to see shipping options.",
     "errorOccurred": "An error occurred during checkout.",
     "errorCreatingOrder": "Failed to create order.",
+    "continueToShipping": "Continue to Shipping",
     "orderConfirmed": "Order Confirmed!",
     "thankYou": "Thank you for your purchase.",
     "orderNumber": "Order Number",
     "confirmationEmail": "You will receive a confirmation email shortly. We will contact you to arrange Cash on Delivery.",
-    "continueShoppingBtn": "Continue Shopping"
+    "continueShoppingBtn": "Continue Shopping",
+    "errorSelectPayment": "Please select a payment method."
+  },
+  "Payment": {
+    "title": "Payment Method",
+    "selectMethod": "Select payment method",
+    "securePayment": "Secure payment processing",
+    "noMethodsAvailable": "No payment methods available",
+    "singleMethodNotice": "Cash on Delivery is the only available payment method for your location",
+    "selected": "Selected",
+    "cod": {
+      "name": "Cash on Delivery",
+      "description": "Pay when you receive your order",
+      "instructions": {
+        "title": "Payment Instructions",
+        "prepareCash": "Prepare Cash",
+        "prepareCashDesc": "Please have the exact amount ready in cash",
+        "inspectOrder": "Inspect Before Paying",
+        "inspectOrderDesc": "You can check your order before making payment",
+        "noFee": "No Extra Fee",
+        "noFeeDesc": "Cash on Delivery is completely free"
+      }
+    },
+    "card": {
+      "name": "Credit Card",
+      "description": "Secure online payment",
+      "comingSoon": "Coming soon"
+    },
+    "bank_transfer": {
+      "name": "Bank Transfer",
+      "description": "Pay via bank transfer",
+      "comingSoon": "Coming soon"
+    }
   }
 }

src/i18n/messages/fr.json

@@ -340,7 +340,13 @@
   },
   "Checkout": {
     "checkout": "Commande",
+    "contactInfo": "Coordonnées",
+    "email": "E-mail",
+    "emailRequired": "Requis pour la confirmation de commande",
+    "phoneRequired": "Requis pour la coordination de livraison",
     "shippingAddress": "Adresse de Livraison",
+    "shippingMethod": "Méthode de livraison",
+    "country": "Pays",
     "firstName": "Prénom",
     "lastName": "Nom",
     "streetAddress": "Rue et Numéro",
@@ -355,6 +361,7 @@
     "cashOnDeliveryDesc": "Payez lorsque votre commande est livrée à votre porte.",
     "processing": "En cours...",
     "completeOrder": "Finaliser la Commande - {total}",
+    "moneyBackGuarantee": "Garantie de remboursement de 30 jours",
     "orderSummary": "Résumé de la Commande",
     "qty": "Qté",
     "subtotal": "Sous-total",
@@ -364,12 +371,51 @@
     "yourCartEmpty": "Votre panier est vide",
     "continueShopping": "Continuer les Achats",
     "errorNoCheckout": "Pas de paiement actif. Veuillez réessayer.",
+    "errorEmailRequired": "Veuillez entrer une adresse e-mail valide.",
+    "errorFieldsRequired": "Veuillez remplir tous les champs obligatoires.",
+    "errorNoShippingMethods": "Aucune méthode de livraison disponible pour cette adresse. Veuillez vérifier votre adresse ou contacter le support.",
+    "errorSelectShipping": "Veuillez sélectionner une méthode de livraison.",
+    "errorPhoneRequired": "Veuillez entrer un numéro de téléphone valide.",
+    "loadingShippingMethods": "Chargement des options de livraison...",
+    "enterAddressForShipping": "Entrez votre adresse pour voir les options de livraison.",
     "errorOccurred": "Une erreur s'est produite lors du paiement.",
     "errorCreatingOrder": "Échec de la création de la commande.",
     "orderConfirmed": "Commande Confirmée!",
     "thankYou": "Merci pour votre achat.",
     "orderNumber": "Numéro de Commande",
     "confirmationEmail": "Vous recevrez bientôt un email de confirmation. Nous vous contacterons pour organiser le paiement contre-remboursement.",
-    "continueShoppingBtn": "Continuer les Achats"
+    "continueShoppingBtn": "Continuer les Achats",
+    "errorSelectPayment": "Veuillez sélectionner un mode de paiement."
+  },
+  "Payment": {
+    "title": "Mode de Paiement",
+    "selectMethod": "Sélectionner le mode de paiement",
+    "securePayment": "Paiement sécurisé",
+    "noMethodsAvailable": "Aucun mode de paiement disponible",
+    "singleMethodNotice": "Le paiement à la livraison est le seul mode de paiement disponible pour votre région",
+    "selected": "Sélectionné",
+    "cod": {
+      "name": "Paiement à la Livraison",
+      "description": "Payez lors de la réception de votre commande",
+      "instructions": {
+        "title": "Instructions de Paiement",
+        "prepareCash": "Préparer l'Argent",
+        "prepareCashDesc": "Veuillez préparer le montant exact en espèces",
+        "inspectOrder": "Inspecter Avant de Payer",
+        "inspectOrderDesc": "Vous pouvez vérifier votre commande avant de payer",
+        "noFee": "Pas de Frais Supplémentaires",
+        "noFeeDesc": "Le paiement à la livraison est entièrement gratuit"
+      }
+    },
+    "card": {
+      "name": "Carte de Crédit",
+      "description": "Paiement en ligne sécurisé",
+      "comingSoon": "Bientôt disponible"
+    },
+    "bank_transfer": {
+      "name": "Virement Bancaire",
+      "description": "Payez par virement bancaire",
+      "comingSoon": "Bientôt disponible"
+    }
   }
 }

src/i18n/messages/sr.json

@@ -386,7 +386,13 @@
   },
   "Checkout": {
     "checkout": "Kupovina",
+    "contactInfo": "Kontakt informacije",
+    "email": "Email",
+    "emailRequired": "Potrebno za potvrdu narudžbine",
+    "phoneRequired": "Potrebno za koordinaciju dostave",
     "shippingAddress": "Adresa za dostavu",
+    "shippingMethod": "Način dostave",
+    "country": "Država",
     "firstName": "Ime",
     "lastName": "Prezime",
     "streetAddress": "Ulica i broj",
@@ -401,6 +407,7 @@
     "cashOnDeliveryDesc": "Platite kada vam narudžbina bude isporučena na vrata.",
     "processing": "Obrađivanje...",
     "completeOrder": "Završi narudžbinu - {total}",
+    "moneyBackGuarantee": "30-dnevna garancija povrata novca",
     "orderSummary": "Pregled narudžbine",
     "qty": "Kol",
     "subtotal": "Ukupno",
@@ -410,12 +417,51 @@
     "yourCartEmpty": "Vaša korpa je prazna",
     "continueShopping": "Nastavi kupovinu",
     "errorNoCheckout": "Nema aktivne korpe. Molimo pokušajte ponovo.",
+    "errorEmailRequired": "Molimo unesite validnu email adresu.",
+    "errorFieldsRequired": "Molimo popunite sva obavezna polja.",
+    "errorNoShippingMethods": "Nema dostupnih načina dostave za ovu adresu. Molimo proverite adresu ili kontaktirajte podršku.",
+    "errorSelectShipping": "Molimo izaberite način dostave.",
+    "errorPhoneRequired": "Molimo unesite validan broj telefona.",
+    "loadingShippingMethods": "Učitavanje opcija dostave...",
+    "enterAddressForShipping": "Unesite adresu da vidite opcije dostave.",
     "errorOccurred": "Došlo je do greške prilikom kupovine.",
     "errorCreatingOrder": "Neuspešno kreiranje narudžbine.",
     "orderConfirmed": "Narudžbina potvrđena!",
     "thankYou": "Hvala vam na kupovini!",
     "orderNumber": "Broj narudžbine",
     "confirmationEmail": "Uскoro ćete primiti email potvrde. Kontaktiraćemo vas da dogovorimo pouzećem plaćanje.",
-    "continueShoppingBtn": "Nastavi kupovinu"
+    "continueShoppingBtn": "Nastavi kupovinu",
+    "errorSelectPayment": "Molimo izaberite način plaćanja."
+  },
+  "Payment": {
+    "title": "Način Plaćanja",
+    "selectMethod": "Izaberite način plaćanja",
+    "securePayment": "Bezbedno plaćanje",
+    "noMethodsAvailable": "Nema dostupnih načina plaćanja",
+    "singleMethodNotice": "Plaćanje pouzećem je jedini dostupan način plaćanja za vašu lokaciju",
+    "selected": "Izabrano",
+    "cod": {
+      "name": "Plaćanje Pouzećem",
+      "description": "Platite kada primite porudžbinu",
+      "instructions": {
+        "title": "Uputstva za Plaćanje",
+        "prepareCash": "Pripremite Gotovinu",
+        "prepareCashDesc": "Molimo pripremite tačan iznos u gotovini",
+        "inspectOrder": "Pregledajte Pre Plaćanja",
+        "inspectOrderDesc": "Možete pregledati porudžbinu pre nego što platite",
+        "noFee": "Bez Dodatne Naknade",
+        "noFeeDesc": "Plaćanje pouzećem je potpuno besplatno"
+      }
+    },
+    "card": {
+      "name": "Kreditna Kartica",
+      "description": "Bezbedno online plaćanje",
+      "comingSoon": "Uskoro dostupno"
+    },
+    "bank_transfer": {
+      "name": "Bankovni Transfer",
+      "description": "Platite putem bankovnog transfera",
+      "comingSoon": "Uskoro dostupno"
+    }
   }
 }

src/lib/analytics.ts

@@ -0,0 +1,154 @@
+"use client";
+
+import { useOpenPanel } from "@openpanel/nextjs";
+import { useCallback } from "react";
+
+export function useAnalytics() {
+  const op = useOpenPanel();
+
+  // Page views are tracked automatically by OpenPanelComponent
+  // but we can track specific events manually
+
+  const trackProductView = useCallback((product: {
+    id: string;
+    name: string;
+    price: number;
+    currency: string;
+    category?: string;
+  }) => {
+    op.track("product_viewed", {
+      product_id: product.id,
+      product_name: product.name,
+      price: product.price,
+      currency: product.currency,
+      category: product.category,
+    });
+  }, [op]);
+
+  const trackAddToCart = useCallback((product: {
+    id: string;
+    name: string;
+    price: number;
+    currency: string;
+    quantity: number;
+    variant?: string;
+  }) => {
+    op.track("add_to_cart", {
+      product_id: product.id,
+      product_name: product.name,
+      price: product.price,
+      currency: product.currency,
+      quantity: product.quantity,
+      variant: product.variant,
+    });
+  }, [op]);
+
+  const trackRemoveFromCart = useCallback((product: {
+    id: string;
+    name: string;
+    quantity: number;
+  }) => {
+    op.track("remove_from_cart", {
+      product_id: product.id,
+      product_name: product.name,
+      quantity: product.quantity,
+    });
+  }, [op]);
+
+  const trackCheckoutStarted = useCallback((cart: {
+    total: number;
+    currency: string;
+    item_count: number;
+    items: Array<{
+      id: string;
+      name: string;
+      quantity: number;
+      price: number;
+    }>;
+  }) => {
+    op.track("checkout_started", {
+      cart_total: cart.total,
+      currency: cart.currency,
+      item_count: cart.item_count,
+      items: cart.items,
+    });
+  }, [op]);
+
+  const trackCheckoutStep = useCallback((step: string, data?: Record<string, unknown>) => {
+    op.track("checkout_step", {
+      step,
+      ...data,
+    });
+  }, [op]);
+
+  const trackOrderCompleted = useCallback((order: {
+    order_id: string;
+    order_number: string;
+    total: number;
+    currency: string;
+    item_count: number;
+    shipping_cost?: number;
+    customer_email?: string;
+  }) => {
+    op.track("order_completed", {
+      order_id: order.order_id,
+      order_number: order.order_number,
+      total: order.total,
+      currency: order.currency,
+      item_count: order.item_count,
+      shipping_cost: order.shipping_cost,
+      customer_email: order.customer_email,
+    });
+
+    // Also track revenue for analytics
+    op.track("purchase", {
+      transaction_id: order.order_number,
+      value: order.total,
+      currency: order.currency,
+    });
+  }, [op]);
+
+  const trackSearch = useCallback((query: string, results_count: number) => {
+    op.track("search", {
+      query,
+      results_count,
+    });
+  }, [op]);
+
+  const trackExternalLink = useCallback((url: string, label?: string) => {
+    op.track("external_link_click", {
+      url,
+      label,
+    });
+  }, [op]);
+
+  const identifyUser = useCallback((user: {
+    profileId: string;
+    email?: string;
+    firstName?: string;
+    lastName?: string;
+    properties?: Record<string, unknown>;
+  }) => {
+    op.identify({
+      profileId: user.profileId,
+      firstName: user.firstName,
+      lastName: user.lastName,
+      email: user.email,
+      properties: user.properties,
+    });
+  }, [op]);
+
+  return {
+    trackProductView,
+    trackAddToCart,
+    trackRemoveFromCart,
+    trackCheckoutStarted,
+    trackCheckoutStep,
+    trackOrderCompleted,
+    trackSearch,
+    trackExternalLink,
+    identifyUser,
+  };
+}
+
+export default useAnalytics;

src/lib/config/paymentMethods.ts

@@ -0,0 +1,106 @@
+/**
+ * Payment methods configuration
+ * Centralized configuration for all available payment methods
+ */
+
+import type { PaymentMethod, Money } from '@/lib/saleor/payments/types';
+
+/**
+ * List of all available payment methods
+ * Configure availability per channel, fees, and other settings
+ */
+export const paymentMethods: PaymentMethod[] = [
+  {
+    id: 'cod',
+    name: 'Cash on Delivery',
+    description: 'Pay when you receive your order',
+    type: 'simple',
+    fee: 0,
+    available: true,
+    availableInChannels: ['default-channel'], // Currently Serbia only
+    icon: 'Banknote',
+  },
+  {
+    id: 'card',
+    name: 'Credit Card',
+    description: 'Secure online payment',
+    type: 'app',
+    fee: 0,
+    available: false, // Coming soon
+    availableInChannels: ['default-channel'],
+    icon: 'CreditCard',
+  },
+  {
+    id: 'bank_transfer',
+    name: 'Bank Transfer',
+    description: 'Pay via bank transfer',
+    type: 'simple',
+    fee: 0,
+    available: false, // Coming later
+    availableInChannels: ['default-channel'],
+    icon: 'Building2',
+  },
+];
+
+/**
+ * Get payment methods available for a specific channel
+ */
+export function getPaymentMethodsForChannel(channel: string): PaymentMethod[] {
+  return paymentMethods.filter(
+    (method) =>
+      method.available && method.availableInChannels.includes(channel)
+  );
+}
+
+/**
+ * Get a specific payment method by ID
+ */
+export function getPaymentMethodById(id: string): PaymentMethod | undefined {
+  return paymentMethods.find((method) => method.id === id);
+}
+
+/**
+ * Check if a payment method is available for a channel
+ */
+export function isPaymentMethodAvailable(
+  methodId: string,
+  channel: string
+): boolean {
+  const method = getPaymentMethodById(methodId);
+  if (!method) return false;
+  return method.available && method.availableInChannels.includes(channel);
+}
+
+/**
+ * Default payment method ID
+ * Used when no payment method is explicitly selected
+ */
+export const DEFAULT_PAYMENT_METHOD = 'cod';
+
+/**
+ * Channel configuration
+ * Maps channels to their supported payment methods
+ */
+export const channelPaymentConfig: Record<string, string[]> = {
+  'default-channel': ['cod'], // Serbia - COD only for now
+};
+
+/**
+ * Format payment method fee for display
+ */
+export function formatPaymentFee(fee: number, currency: string): string {
+  if (fee === 0) return 'No additional fee';
+  return new Intl.NumberFormat('en-US', {
+    style: 'currency',
+    currency: currency,
+  }).format(fee);
+}
+
+/**
+ * Generate PSP reference for COD transactions
+ * Format: COD-{orderNumber}-{timestamp}
+ */
+export function generateCODReference(orderNumber: string): string {
+  const timestamp = Date.now();
+  return `COD-${orderNumber}-${timestamp}`;
+}

src/lib/resend.ts

@@ -0,0 +1,106 @@
+import { Resend } from "resend";
+import { render } from "@react-email/render";
+
+let resendClient: Resend | null = null;
+
+function getResendClient(): Resend {
+  if (!resendClient) {
+    if (!process.env.RESEND_API_KEY) {
+      throw new Error("RESEND_API_KEY environment variable is not set");
+    }
+    resendClient = new Resend(process.env.RESEND_API_KEY);
+  }
+  return resendClient;
+}
+
+export const ADMIN_EMAILS = ["me@hytham.me", "tamara@hytham.me"];
+
+export async function sendEmail({
+  to,
+  subject,
+  react,
+  text,
+  tags,
+  idempotencyKey,
+}: {
+  to: string | string[];
+  subject: string;
+  react: React.ReactNode;
+  text?: string;
+  tags?: { name: string; value: string }[];
+  idempotencyKey?: string;
+}) {
+  const resend = getResendClient();
+  
+  // Render React component to HTML
+  const html = await render(react, {
+    pretty: true,
+  });
+  
+  const { data, error } = await resend.emails.send({
+    from: "ManoonOils <support@mail.manoonoils.com>",
+    replyTo: "support@manoonoils.com",
+    to: Array.isArray(to) ? to : [to],
+    subject,
+    html,
+    text,
+    tags,
+    ...(idempotencyKey && { idempotencyKey }),
+  });
+
+  if (error) {
+    console.error("Failed to send email:", error);
+    throw error;
+  }
+
+  return data;
+}
+
+export async function sendEmailToCustomer({
+  to,
+  subject,
+  react,
+  text,
+  language,
+  idempotencyKey,
+}: {
+  to: string;
+  subject: string;
+  react: React.ReactNode;
+  text?: string;
+  language: string;
+  idempotencyKey?: string;
+}) {
+  const tag = `customer-${language}`;
+  return sendEmail({
+    to,
+    subject,
+    react,
+    text,
+    tags: [{ name: "type", value: tag }],
+    idempotencyKey,
+  });
+}
+
+export async function sendEmailToAdmin({
+  subject,
+  react,
+  text,
+  eventType,
+  orderId,
+}: {
+  subject: string;
+  react: React.ReactNode;
+  text?: string;
+  eventType: string;
+  orderId: string;
+}) {
+  return sendEmail({
+    to: ADMIN_EMAILS,
+    subject: `[Admin] ${subject}`,
+    react,
+    text,
+    tags: [{ name: "type", value: "admin-notification" }],
+    idempotencyKey: `admin-${eventType}/${orderId}`,
+  });
+}

src/lib/saleor/client.ts

@@ -6,12 +6,13 @@ const httpLink = createHttpLink({
 });
 
 const authLink = setContext((_, { headers }) => {
-  // Saleor doesn't require auth for public queries
+  // Add auth token for admin operations
-  // Add auth token here if needed for admin operations
+  const token = process.env.SALEOR_API_TOKEN;
   return {
     headers: {
       ...headers,
       "Content-Type": "application/json",
+      ...(token && { "Authorization": `Bearer ${token}` }),
     },
   };
 });

src/lib/saleor/create-webhooks.graphql

@@ -0,0 +1,81 @@
+# Replace YOUR_STOREFRONT_URL with your actual storefront URL
+# Dev: https://dev.manoonoils.com
+# Prod: https://manoonoils.com
+
+mutation CreateSaleorWebhooks {
+  orderConfirmedWebhook: webhookCreate(input: {
+    name: "Resend - Order Confirmed"
+    targetUrl: "YOUR_STOREFRONT_URL/api/webhooks/saleor"
+    events: [ORDER_CONFIRMED]
+    isActive: true
+  }) {
+    webhook {
+      id
+      name
+      targetUrl
+      isActive
+    }
+    errors {
+      field
+      message
+      code
+    }
+  }
+
+  orderPaidWebhook: webhookCreate(input: {
+    name: "Resend - Order Paid"
+    targetUrl: "YOUR_STOREFRONT_URL/api/webhooks/saleor"
+    events: [ORDER_FULLY_PAID]
+    isActive: true
+  }) {
+    webhook {
+      id
+      name
+      targetUrl
+      isActive
+    }
+    errors {
+      field
+      message
+      code
+    }
+  }
+
+  orderCancelledWebhook: webhookCreate(input: {
+    name: "Resend - Order Cancelled"
+    targetUrl: "YOUR_STOREFRONT_URL/api/webhooks/saleor"
+    events: [ORDER_CANCELLED]
+    isActive: true
+  }) {
+    webhook {
+      id
+      name
+      targetUrl
+      isActive
+    }
+    errors {
+      field
+      message
+      code
+    }
+  }
+
+  orderFulfilledWebhook: webhookCreate(input: {
+    name: "Resend - Order Fulfilled"
+    targetUrl: "YOUR_STOREFRONT_URL/api/webhooks/saleor"
+    events: [ORDER_FULFILLED]
+    isActive: true
+  }) {
+    webhook {
+      id
+      name
+      targetUrl
+      isActive
+    }
+    errors {
+      field
+      message
+      code
+    }
+  }
+}

src/lib/saleor/mutations/Checkout.ts

@@ -152,3 +152,75 @@ export const CHECKOUT_EMAIL_UPDATE = gql`
   }
   ${CHECKOUT_FRAGMENT}
 `;
+
+export const CHECKOUT_METADATA_UPDATE = gql`
+  mutation CheckoutMetadataUpdate($checkoutId: ID!, $metadata: [MetadataInput!]!) {
+    updateMetadata(id: $checkoutId, input: $metadata) {
+      item {
+        ... on Checkout {
+          id
+          metadata {
+            key
+            value
+          }
+        }
+      }
+      errors {
+        field
+        message
+        code
+      }
+    }
+  }
+`;
+
+export const ORDER_METADATA_UPDATE = gql`
+  mutation OrderMetadataUpdate($orderId: ID!, $metadata: [MetadataInput!]!) {
+    updateMetadata(id: $orderId, input: $metadata) {
+      item {
+        ... on Order {
+          id
+          metadata {
+            key
+            value
+          }
+        }
+      }
+      errors {
+        field
+        message
+        code
+      }
+    }
+  }
+`;
+
+export const CHECKOUT_LANGUAGE_CODE_UPDATE = gql`
+  mutation CheckoutLanguageCodeUpdate($checkoutId: ID!, $languageCode: LanguageCodeEnum!) {
+    checkoutLanguageCodeUpdate(checkoutId: $checkoutId, languageCode: $languageCode) {
+      checkout {
+        id
+        languageCode
+      }
+      errors {
+        field
+        message
+        code
+      }
+    }
+  }
+`;
+
+export const TRANSACTION_CREATE = gql`
+  mutation CreateTransaction($orderId: ID!, $transaction: TransactionCreateInput!) {
+    transactionCreate(id: $orderId, transaction: $transaction) {
+      transaction {
+        id
+      }
+      errors {
+        field
+        message
+      }
+    }
+  }
+`;

src/lib/saleor/payments/cod.ts

@@ -0,0 +1,149 @@
+/**
+ * Cash on Delivery (COD) payment logic
+ * Handles creation of COD transactions in Saleor
+ */
+
+import type { Money, TransactionInput } from '@/lib/saleor/payments/types';
+import { generateCODReference } from '@/lib/config/paymentMethods';
+
+import { gql } from "@apollo/client";
+
+/**
+ * GraphQL mutation to create a transaction on an order
+ */
+export const CREATE_TRANSACTION_MUTATION = gql`
+  mutation TransactionCreate($id: ID!, $transaction: TransactionCreateInput!) {
+    transactionCreate(id: $id, transaction: $transaction) {
+      transaction {
+        id
+        name
+        pspReference
+        status
+        availableActions
+        amountAuthorized {
+          amount
+          currency
+        }
+        amountCharged {
+          amount
+          currency
+        }
+      }
+      errors {
+        field
+        message
+        code
+      }
+    }
+  }
+`;
+
+/**
+ * Create a Cash on Delivery transaction configuration
+ * @param orderNumber - The order number for reference
+ * @param amount - The order total amount
+ * @returns TransactionInput for Saleor
+ */
+export function createCODTransactionInput(
+  orderNumber: string,
+  amount: Money
+): TransactionInput {
+  return {
+    name: 'Cash on Delivery',
+    pspReference: generateCODReference(orderNumber),
+    availableActions: ['CHARGE'],
+    amountAuthorized: {
+      amount: 0,
+      currency: amount.currency,
+    },
+    amountCharged: {
+      amount: 0,
+      currency: amount.currency,
+    },
+    externalUrl: null,
+  };
+}
+
+/**
+ * Create COD transaction on an order
+ * This should be called after checkoutComplete creates the order
+ * 
+ * @param orderId - Saleor order ID
+ * @param orderNumber - Human-readable order number
+ * @param amount - Order total amount
+ * @returns Promise with transaction result
+ */
+export async function createCODTransaction(
+  orderId: string,
+  orderNumber: string,
+  amount: Money
+): Promise<{ success: boolean; transaction?: unknown; errors?: unknown[] }> {
+  try {
+    // Note: This function should be called from a Server Component or API route
+    // as it requires making a GraphQL mutation with authentication
+    
+    const transactionInput = createCODTransactionInput(orderNumber, amount);
+    
+    // The actual GraphQL call will be made in the checkout page
+    // This function just prepares the input
+    return {
+      success: true,
+      transaction: {
+        orderId,
+        ...transactionInput,
+      },
+    };
+  } catch (error) {
+    console.error('Error creating COD transaction:', error);
+    return {
+      success: false,
+      errors: [{ message: 'Failed to create COD transaction' }],
+    };
+  }
+}
+
+/**
+ * Check if an order has a COD transaction
+ * @param order - Order object from Saleor
+ * @returns boolean
+ */
+export function hasCODTransaction(order: { transactions?: Array<{ name?: string }> }): boolean {
+  if (!order.transactions || order.transactions.length === 0) {
+    return false;
+  }
+  
+  return order.transactions.some(
+    (t) => t.name === 'Cash on Delivery'
+  );
+}
+
+/**
+ * Get COD transaction from order
+ * @param order - Order object from Saleor
+ * @returns COD transaction or undefined
+ */
+export function getCODTransaction(order: { transactions?: Array<{ name?: string }> }) {
+  if (!order.transactions) return undefined;
+  
+  return order.transactions.find(
+    (t) => t.name === 'Cash on Delivery'
+  );
+}
+
+/**
+ * Format COD status for display
+ * @param transactionStatus - Transaction status from Saleor
+ * @returns Human-readable status
+ */
+export function formatCODStatus(transactionStatus: string): string {
+  switch (transactionStatus) {
+    case 'NOT_CHARGED':
+      return 'Pending Collection';
+    case 'CHARGED':
+      return 'Paid';
+    case 'CANCELLED':
+      return 'Cancelled';
+    default:
+      return transactionStatus;
+  }
+}

src/lib/saleor/payments/types.ts

@@ -0,0 +1,62 @@
+/**
+ * Payment method type definitions
+ * Supports both simple payments (COD, Bank Transfer) and Payment Apps (Stripe, etc.)
+ */
+
+export type PaymentType = 'simple' | 'async' | 'app';
+
+export interface Money {
+  amount: number;
+  currency: string;
+}
+
+export interface PaymentMethod {
+  id: string;
+  name: string;
+  description: string;
+  type: PaymentType;
+  fee: number;
+  available: boolean;
+  availableInChannels: string[];
+  icon?: string;
+}
+
+export interface TransactionInput {
+  name: string;
+  pspReference: string;
+  availableActions: string[];
+  amountAuthorized?: Money;
+  amountCharged?: Money;
+  externalUrl?: string | null;
+}
+
+export interface AsyncSession {
+  id: string;
+  status: 'pending' | 'completed' | 'failed';
+  paymentUrl?: string;
+  qrCode?: string;
+  timeout?: number;
+}
+
+export interface PaymentResult {
+  type: 'order_created' | 'session_created' | 'error';
+  order?: {
+    id: string;
+    number: string;
+  };
+  session?: AsyncSession;
+  error?: string;
+}
+
+export interface PaymentStatus {
+  status: 'pending' | 'completed' | 'failed';
+  message?: string;
+}
+
+export interface CODTransactionConfig {
+  name: string;
+  pspReference: string;
+  availableActions: ['CHARGE'];
+  amountAuthorized: Money;
+  amountCharged: Money;
+}

src/lib/services/AnalyticsService.ts

@@ -0,0 +1,80 @@
+import { OpenPanel } from "@openpanel/nextjs";
+
+// Initialize OpenPanel for server-side tracking
+const op = new OpenPanel({
+  clientId: process.env.NEXT_PUBLIC_OPENPANEL_CLIENT_ID || "",
+  clientSecret: process.env.OPENPANEL_CLIENT_SECRET || "",
+  apiUrl: process.env.OPENPANEL_API_URL || "https://op.nodecrew.me/api",
+});
+
+export interface OrderAnalyticsData {
+  orderId: string;
+  orderNumber: string;
+  total: number;
+  currency: string;
+  itemCount: number;
+  customerEmail: string;
+  eventType: string;
+}
+
+export interface RevenueData {
+  amount: number;
+  currency: string;
+  orderId: string;
+  orderNumber: string;
+}
+
+class AnalyticsService {
+  private static instance: AnalyticsService;
+
+  static getInstance(): AnalyticsService {
+    if (!AnalyticsService.instance) {
+      AnalyticsService.instance = new AnalyticsService();
+    }
+    return AnalyticsService.instance;
+  }
+
+  async trackOrderReceived(data: OrderAnalyticsData): Promise<void> {
+    try {
+      await op.track("order_received", {
+        order_id: data.orderId,
+        order_number: data.orderNumber,
+        total: data.total,
+        currency: data.currency,
+        item_count: data.itemCount,
+        customer_email: data.customerEmail,
+        event_type: data.eventType,
+      });
+    } catch (error) {
+      console.error("Failed to track order received:", error);
+      // Don't throw - analytics should not break the main flow
+    }
+  }
+
+  async trackRevenue(data: RevenueData): Promise<void> {
+    try {
+      console.log(`Tracking revenue: ${data.amount} ${data.currency} for order ${data.orderNumber}`);
+      await op.revenue(data.amount, {
+        currency: data.currency,
+        order_id: data.orderId,
+        order_number: data.orderNumber,
+      });
+    } catch (error) {
+      console.error("Failed to track revenue:", error);
+      // Don't throw - analytics should not break the main flow
+    }
+  }
+
+  async track(eventName: string, properties: Record<string, unknown>): Promise<void> {
+    try {
+      await op.track(eventName, properties);
+    } catch (error) {
+      console.error(`Failed to track event ${eventName}:`, error);
+      // Don't throw - analytics should not break the main flow
+    }
+  }
+}
+
+export const analyticsService = AnalyticsService.getInstance();
+export { AnalyticsService };
+export default analyticsService;

src/lib/services/checkoutService.ts

@@ -0,0 +1,482 @@
+/**
+ * Checkout Service - Domain layer for checkout operations
+ * 
+ * This module encapsulates all checkout business logic, making it:
+ * - Testable: Pure functions with no UI dependencies
+ * - Composable: Steps can be chained, mocked, or replaced
+ * - Type-safe: All inputs/outputs are strictly typed
+ * - Resilient: Clear contracts prevent ordering mistakes
+ */
+
+import { saleorClient } from "@/lib/saleor/client";
+import type { Checkout, CheckoutLine } from "@/types/saleor";
+import {
+  CHECKOUT_SHIPPING_ADDRESS_UPDATE,
+  CHECKOUT_BILLING_ADDRESS_UPDATE,
+  CHECKOUT_COMPLETE,
+  CHECKOUT_EMAIL_UPDATE,
+  CHECKOUT_METADATA_UPDATE,
+  CHECKOUT_SHIPPING_METHOD_UPDATE,
+  CHECKOUT_LANGUAGE_CODE_UPDATE,
+} from "@/lib/saleor/mutations/Checkout";
+
+// ============================================================================
+// GraphQL Response Types
+// ============================================================================
+
+interface GraphQLError {
+  field?: string;
+  message: string;
+  code?: string;
+}
+
+interface CheckoutEmailUpdateResponse {
+  checkoutEmailUpdate?: {
+    checkout?: Checkout;
+    errors?: GraphQLError[];
+  };
+}
+
+interface CheckoutLanguageCodeUpdateResponse {
+  checkoutLanguageCodeUpdate?: {
+    checkout?: { id: string; languageCode: string };
+    errors?: GraphQLError[];
+  };
+}
+
+interface CheckoutShippingAddressUpdateResponse {
+  checkoutShippingAddressUpdate?: {
+    checkout?: Checkout;
+    errors?: GraphQLError[];
+  };
+}
+
+interface CheckoutBillingAddressUpdateResponse {
+  checkoutBillingAddressUpdate?: {
+    checkout?: Checkout;
+    errors?: GraphQLError[];
+  };
+}
+
+interface CheckoutShippingMethodUpdateResponse {
+  checkoutShippingMethodUpdate?: {
+    checkout?: Checkout;
+    errors?: GraphQLError[];
+  };
+}
+
+interface CheckoutMetadataUpdateResponse {
+  updateMetadata?: {
+    item?: {
+      id: string;
+      metadata?: Array<{ key: string; value: string }>;
+    };
+    errors?: GraphQLError[];
+  };
+}
+
+interface CheckoutCompleteResponse {
+  checkoutComplete?: {
+    order?: {
+      id: string;
+      number: string;
+      status: string;
+      created: string;
+      total?: {
+        gross: {
+          amount: number;
+          currency: string;
+        };
+      };
+    };
+    errors?: GraphQLError[];
+  };
+}
+
+// ============================================================================
+// Domain Types
+// ============================================================================
+
+export interface Address {
+  firstName: string;
+  lastName: string;
+  streetAddress1: string;
+  streetAddress2?: string;
+  city: string;
+  postalCode: string;
+  country: string;
+  phone: string;
+}
+
+export interface CheckoutInput {
+  checkoutId: string;
+  email: string;
+  shippingAddress: Address;
+  billingAddress: Address;
+  shippingMethodId: string;
+  languageCode: string;
+  metadata: Record<string, string>;
+}
+
+export interface CheckoutResult {
+  success: boolean;
+  order?: {
+    id: string;
+    number: string;
+    languageCode: string;
+  };
+  error?: string;
+}
+
+export interface CheckoutStepResult<T = unknown> {
+  success: boolean;
+  data?: T;
+  error?: string;
+}
+
+// ============================================================================
+// Individual Checkout Steps (Composable Units)
+// ============================================================================
+
+/**
+ * Step 1: Update checkout email
+ * Isolated, testable unit that does one thing
+ */
+export async function updateCheckoutEmail(
+  checkoutId: string,
+  email: string
+): Promise<CheckoutStepResult> {
+  const { data } = await saleorClient.mutate<CheckoutEmailUpdateResponse>({
+    mutation: CHECKOUT_EMAIL_UPDATE,
+    variables: { checkoutId, email },
+  });
+
+  if (data?.checkoutEmailUpdate?.errors?.length) {
+    const error = data.checkoutEmailUpdate.errors[0];
+    if (error.message.includes("Couldn't resolve to a node")) {
+      return { success: false, error: "CHECKOUT_EXPIRED" };
+    }
+    return { success: false, error: error.message };
+  }
+
+  return { success: true };
+}
+
+/**
+ * Step 2: Update language code
+ * CRITICAL: Must be called before checkoutComplete for correct email language
+ */
+export async function updateCheckoutLanguage(
+  checkoutId: string,
+  languageCode: string
+): Promise<CheckoutStepResult> {
+  const { data } = await saleorClient.mutate<CheckoutLanguageCodeUpdateResponse>({
+    mutation: CHECKOUT_LANGUAGE_CODE_UPDATE,
+    variables: { checkoutId, languageCode: languageCode.toUpperCase() },
+  });
+
+  if (data?.checkoutLanguageCodeUpdate?.errors?.length) {
+    return { success: false, error: data.checkoutLanguageCodeUpdate.errors[0].message };
+  }
+
+  return { success: true };
+}
+
+/**
+ * Step 3: Update shipping address
+ */
+export async function updateShippingAddress(
+  checkoutId: string,
+  address: Address
+): Promise<CheckoutStepResult> {
+  const { data } = await saleorClient.mutate<CheckoutShippingAddressUpdateResponse>({
+    mutation: CHECKOUT_SHIPPING_ADDRESS_UPDATE,
+    variables: {
+      checkoutId,
+      shippingAddress: {
+        firstName: address.firstName,
+        lastName: address.lastName,
+        streetAddress1: address.streetAddress1,
+        streetAddress2: address.streetAddress2 || "",
+        city: address.city,
+        postalCode: address.postalCode,
+        country: address.country,
+        phone: address.phone,
+      },
+    },
+  });
+
+  if (data?.checkoutShippingAddressUpdate?.errors?.length) {
+    return { success: false, error: data.checkoutShippingAddressUpdate.errors[0].message };
+  }
+
+  return { success: true };
+}
+
+/**
+ * Step 4: Update billing address
+ */
+export async function updateBillingAddress(
+  checkoutId: string,
+  address: Address
+): Promise<CheckoutStepResult> {
+  const { data } = await saleorClient.mutate<CheckoutBillingAddressUpdateResponse>({
+    mutation: CHECKOUT_BILLING_ADDRESS_UPDATE,
+    variables: {
+      checkoutId,
+      billingAddress: {
+        firstName: address.firstName,
+        lastName: address.lastName,
+        streetAddress1: address.streetAddress1,
+        streetAddress2: address.streetAddress2 || "",
+        city: address.city,
+        postalCode: address.postalCode,
+        country: address.country,
+        phone: address.phone,
+      },
+    },
+  });
+
+  if (data?.checkoutBillingAddressUpdate?.errors?.length) {
+    return { success: false, error: data.checkoutBillingAddressUpdate.errors[0].message };
+  }
+
+  return { success: true };
+}
+
+/**
+ * Step 5: Update shipping method
+ */
+export async function updateShippingMethod(
+  checkoutId: string,
+  shippingMethodId: string
+): Promise<CheckoutStepResult> {
+  const { data } = await saleorClient.mutate<CheckoutShippingMethodUpdateResponse>({
+    mutation: CHECKOUT_SHIPPING_METHOD_UPDATE,
+    variables: { checkoutId, shippingMethodId },
+  });
+
+  if (data?.checkoutShippingMethodUpdate?.errors?.length) {
+    return { success: false, error: data.checkoutShippingMethodUpdate.errors[0].message };
+  }
+
+  return { success: true };
+}
+
+/**
+ * Step 6: Update metadata
+ * Non-critical - failures are logged but don't stop checkout
+ */
+export async function updateCheckoutMetadata(
+  checkoutId: string,
+  metadata: Record<string, string>
+): Promise<CheckoutStepResult> {
+  const metadataArray = Object.entries(metadata).map(([key, value]) => ({ key, value }));
+
+  const { data } = await saleorClient.mutate<CheckoutMetadataUpdateResponse>({
+    mutation: CHECKOUT_METADATA_UPDATE,
+    variables: { checkoutId, metadata: metadataArray },
+  });
+
+  if (data?.updateMetadata?.errors?.length) {
+    // Metadata is non-critical, log but don't fail
+    console.warn("Failed to save checkout metadata:", data.updateMetadata.errors);
+    return { success: true }; // Still return success
+  }
+
+  return { success: true };
+}
+
+/**
+ * Final Step: Complete checkout
+ * Returns the created order
+ */
+export async function completeCheckout(
+  checkoutId: string
+): Promise<CheckoutStepResult<{ id: string; number: string; languageCode: string }>> {
+  const { data } = await saleorClient.mutate<CheckoutCompleteResponse>({
+    mutation: CHECKOUT_COMPLETE,
+    variables: { checkoutId },
+  });
+
+  if (data?.checkoutComplete?.errors?.length) {
+    return { success: false, error: data.checkoutComplete.errors[0].message };
+  }
+
+  const order = data?.checkoutComplete?.order;
+  if (!order) {
+    return { success: false, error: "Order creation failed - no order returned" };
+  }
+
+  return {
+    success: true,
+    data: {
+      id: order.id,
+      number: order.number,
+      languageCode: "EN", // Default fallback since checkoutComplete doesn't return languageCode directly
+    },
+  };
+}
+
+// ============================================================================
+// Checkout Pipeline (Composed Steps)
+// ============================================================================
+
+/**
+ * Execute full checkout pipeline with proper ordering
+ * 
+ * This function enforces the correct sequence of operations:
+ * 1. Email (identifies customer)
+ * 2. Language (MUST be before complete for email language!)
+ * 3. Addresses
+ * 4. Shipping method
+ * 5. Metadata
+ * 6. Complete
+ * 
+ * If any step fails, the pipeline stops and returns the error.
+ * This prevents partial checkouts and ensures data consistency.
+ */
+export async function executeCheckoutPipeline(
+  input: CheckoutInput
+): Promise<CheckoutResult> {
+  const { checkoutId, email, shippingAddress, billingAddress, shippingMethodId, languageCode, metadata } = input;
+
+  // Step 1: Email
+  const emailResult = await updateCheckoutEmail(checkoutId, email);
+  if (!emailResult.success) {
+    return { success: false, error: emailResult.error };
+  }
+
+  // Step 2: Language (CRITICAL for email language)
+  const languageResult = await updateCheckoutLanguage(checkoutId, languageCode);
+  if (!languageResult.success) {
+    return { success: false, error: languageResult.error };
+  }
+
+  // Step 3: Shipping Address
+  const shippingResult = await updateShippingAddress(checkoutId, shippingAddress);
+  if (!shippingResult.success) {
+    return { success: false, error: shippingResult.error };
+  }
+
+  // Step 4: Billing Address
+  const billingResult = await updateBillingAddress(checkoutId, billingAddress);
+  if (!billingResult.success) {
+    return { success: false, error: billingResult.error };
+  }
+
+  // Step 5: Shipping Method
+  const methodResult = await updateShippingMethod(checkoutId, shippingMethodId);
+  if (!methodResult.success) {
+    return { success: false, error: methodResult.error };
+  }
+
+  // Step 6: Metadata (non-critical, continues on failure)
+  await updateCheckoutMetadata(checkoutId, metadata);
+
+  // Step 7: Complete checkout
+  const completeResult = await completeCheckout(checkoutId);
+  if (!completeResult.success || !completeResult.data) {
+    return { success: false, error: completeResult.error };
+  }
+
+  return {
+    success: true,
+    order: completeResult.data,
+  };
+}
+
+// ============================================================================
+// Validation Helpers
+// ============================================================================
+
+export function validateAddress(address: Partial<Address>): string | null {
+  if (!address.firstName?.trim()) return "First name is required";
+  if (!address.lastName?.trim()) return "Last name is required";
+  if (!address.streetAddress1?.trim()) return "Street address is required";
+  if (!address.city?.trim()) return "City is required";
+  if (!address.postalCode?.trim()) return "Postal code is required";
+  if (!address.country?.trim()) return "Country is required";
+  if (!address.phone?.trim() || address.phone.length < 8) return "Valid phone number is required";
+  return null;
+}
+
+export function validateEmail(email: string): string | null {
+  if (!email?.trim()) return "Email is required";
+  if (!email.includes("@")) return "Invalid email format";
+  return null;
+}
+
+export function validateCheckoutInput(input: CheckoutInput): string | null {
+  const emailError = validateEmail(input.email);
+  if (emailError) return emailError;
+
+  const shippingError = validateAddress(input.shippingAddress);
+  if (shippingError) return `Shipping ${shippingError}`;
+
+  const billingError = validateAddress(input.billingAddress);
+  if (billingError) return `Billing ${billingError}`;
+
+  if (!input.shippingMethodId) return "Shipping method is required";
+  if (!input.checkoutId) return "Checkout ID is required";
+
+  return null;
+}
+
+// ============================================================================
+// Checkout Service Class (High-level API)
+// ============================================================================
+
+export class CheckoutService {
+  constructor(private checkoutId: string) {}
+
+  async updateEmail(email: string): Promise<CheckoutStepResult> {
+    return updateCheckoutEmail(this.checkoutId, email);
+  }
+
+  async updateLanguage(languageCode: string): Promise<CheckoutStepResult> {
+    return updateCheckoutLanguage(this.checkoutId, languageCode);
+  }
+
+  async updateShippingAddress(address: Address): Promise<CheckoutStepResult> {
+    return updateShippingAddress(this.checkoutId, address);
+  }
+
+  async updateBillingAddress(address: Address): Promise<CheckoutStepResult> {
+    return updateBillingAddress(this.checkoutId, address);
+  }
+
+  async updateShippingMethod(shippingMethodId: string): Promise<CheckoutStepResult> {
+    return updateShippingMethod(this.checkoutId, shippingMethodId);
+  }
+
+  async updateMetadata(metadata: Record<string, string>): Promise<CheckoutStepResult> {
+    return updateCheckoutMetadata(this.checkoutId, metadata);
+  }
+
+  async complete(): Promise<CheckoutStepResult<{ id: string; number: string; languageCode: string }>> {
+    return completeCheckout(this.checkoutId);
+  }
+
+  /**
+   * Execute full checkout with validation
+   */
+  async execute(input: Omit<CheckoutInput, "checkoutId">): Promise<CheckoutResult> {
+    const fullInput: CheckoutInput = {
+      ...input,
+      checkoutId: this.checkoutId,
+    };
+
+    const validationError = validateCheckoutInput(fullInput);
+    if (validationError) {
+      return { success: false, error: validationError };
+    }
+
+    return executeCheckoutPipeline(fullInput);
+  }
+}
+
+// Factory function for creating checkout service
+export function createCheckoutService(checkoutId: string): CheckoutService {
+  return new CheckoutService(checkoutId);
+}

src/stores/saleorCheckoutStore.ts

@@ -58,6 +58,7 @@ interface GetCheckoutResponse {
 interface SaleorCheckoutStore {
   checkout: Checkout | null;
   checkoutToken: string | null;
+  languageCode: string | null;
   isOpen: boolean;
   isLoading: boolean;
   error: string | null;
@@ -68,11 +69,13 @@ interface SaleorCheckoutStore {
   updateLine: (lineId: string, quantity: number) => Promise<void>;
   removeLine: (lineId: string) => Promise<void>;
   setEmail: (email: string) => Promise<void>;
+  setLanguageCode: (languageCode: string) => void;
   refreshCheckout: () => Promise<void>;
   toggleCart: () => void;
   openCart: () => void;
   closeCart: () => void;
   clearError: () => void;
+  clearCheckout: () => void;
 
   // Getters
   getLineCount: () => number;
@@ -85,12 +88,13 @@ export const useSaleorCheckoutStore = create<SaleorCheckoutStore>()(
     (set, get) => ({
       checkout: null,
       checkoutToken: null,
+      languageCode: null,
       isOpen: false,
       isLoading: false,
       error: null,
 
       initCheckout: async () => {
-        const { checkoutToken } = get();
+        const { checkoutToken, languageCode } = get();
 
         if (checkoutToken) {
           // Try to fetch existing checkout
@@ -109,7 +113,7 @@ export const useSaleorCheckoutStore = create<SaleorCheckoutStore>()(
           }
         }
 
-        // Create new checkout
+        // Create new checkout with language code
         try {
           const { data } = await saleorClient.mutate<CheckoutCreateResponse>({
             mutation: CHECKOUT_CREATE,
@@ -117,6 +121,7 @@ export const useSaleorCheckoutStore = create<SaleorCheckoutStore>()(
               input: {
                 channel: CHANNEL,
                 lines: [],
+                languageCode: languageCode ? languageCode.toUpperCase() : undefined,
               },
             },
           });
@@ -294,6 +299,8 @@ export const useSaleorCheckoutStore = create<SaleorCheckoutStore>()(
       openCart: () => set({ isOpen: true }),
       closeCart: () => set({ isOpen: false }),
       clearError: () => set({ error: null }),
+      setLanguageCode: (languageCode: string) => set({ languageCode }),
+      clearCheckout: () => set({ checkout: null, checkoutToken: null }),
 
       getLineCount: () => {
         const { checkout } = get();

vitest.config.ts

@@ -0,0 +1,36 @@
+import { defineConfig } from "vitest/config";
+import react from "@vitejs/plugin-react";
+import path from "path";
+
+export default defineConfig({
+  plugins: [react()],
+  test: {
+    environment: "jsdom",
+    globals: true,
+    setupFiles: ["./src/__tests__/setup.ts"],
+    coverage: {
+      provider: "v8",
+      reporter: ["text", "json", "html"],
+      thresholds: {
+        lines: 80,
+        functions: 80,
+        branches: 80,
+        statements: 80,
+      },
+      exclude: [
+        "node_modules/",
+        "src/__tests__/",
+        "**/*.d.ts",
+        "**/*.config.*",
+        "**/e2e/**",
+      ],
+    },
+    include: ["src/**/*.test.ts", "src/**/*.test.tsx"],
+    exclude: ["node_modules", "dist", ".next", "e2e"],
+  },
+  resolve: {
+    alias: {
+      "@": path.resolve(__dirname, "./src"),
+    },
+  },
+});