Refactor Salesforce integration by removing the SalesforceFieldMapService from the CoreConfigModule and updating import paths across various services to utilize the new Salesforce field configuration. This enhances type safety and maintainability while streamlining data handling in order-related services.

FIELD-CONFIG-AUDIT.md

@@ -0,0 +1,309 @@
+# Field Config vs Raw Types - Audit Report
+
+## Audit Objective
+Verify that all fields referenced in the field config system actually exist in the raw type schemas before removing the field config abstraction layer.
+
+---
+
+## Product Fields (from Product2)
+
+### Field Config Expects:
+```typescript
+product: {
+  sku: "PRODUCT_SKU_FIELD",
+  portalCategory: "PRODUCT_PORTAL_CATEGORY_FIELD",
+  portalCatalog: "PRODUCT_PORTAL_CATALOG_FIELD",
+  portalAccessible: "PRODUCT_PORTAL_ACCESSIBLE_FIELD",
+  itemClass: "PRODUCT_ITEM_CLASS_FIELD",
+  billingCycle: "PRODUCT_BILLING_CYCLE_FIELD",
+  whmcsProductId: "PRODUCT_WHMCS_PRODUCT_ID_FIELD",
+  whmcsProductName: "PRODUCT_WHMCS_PRODUCT_NAME_FIELD",
+  internetPlanTier: "PRODUCT_INTERNET_PLAN_TIER_FIELD",
+  internetOfferingType: "PRODUCT_INTERNET_OFFERING_TYPE_FIELD",
+  displayOrder: "PRODUCT_DISPLAY_ORDER_FIELD",
+  bundledAddon: "PRODUCT_BUNDLED_ADDON_FIELD",
+  isBundledAddon: "PRODUCT_IS_BUNDLED_ADDON_FIELD",
+  simDataSize: "PRODUCT_SIM_DATA_SIZE_FIELD",
+  simPlanType: "PRODUCT_SIM_PLAN_TYPE_FIELD",
+  simHasFamilyDiscount: "PRODUCT_SIM_HAS_FAMILY_DISCOUNT_FIELD",
+  vpnRegion: "PRODUCT_VPN_REGION_FIELD",
+}
+```
+
+### Raw Type Has:
+```typescript
+SalesforceProduct2Record {
+  Id: string ✅
+  Name: string ✅
+  StockKeepingUnit: string ✅ (sku)
+  Description: string ✅
+  Product2Categories1__c: string ✅ (portalCategory)
+  Portal_Catalog__c: boolean ✅ (portalCatalog)
+  Portal_Accessible__c: boolean ✅ (portalAccessible)
+  Item_Class__c: string ✅ (itemClass)
+  Billing_Cycle__c: string ✅ (billingCycle)
+  Catalog_Order__c: number ✅ (displayOrder)
+  Bundled_Addon__c: string ✅ (bundledAddon)
+  Is_Bundled_Addon__c: boolean ✅ (isBundledAddon)
+  Internet_Plan_Tier__c: string ✅ (internetPlanTier)
+  Internet_Offering_Type__c: string ✅ (internetOfferingType)
+  Feature_List__c: string ✅
+  SIM_Data_Size__c: string ✅ (simDataSize)
+  SIM_Plan_Type__c: string ✅ (simPlanType)
+  SIM_Has_Family_Discount__c: boolean ✅ (simHasFamilyDiscount)
+  VPN_Region__c: string ✅ (vpnRegion)
+  WH_Product_ID__c: number ✅ (whmcsProductId)
+  WH_Product_Name__c: string ✅ (whmcsProductName)
+  Price__c: number ✅
+  Monthly_Price__c: number ✅
+  One_Time_Price__c: number ✅
+}
+```
+
+**Status:** ✅ ALL PRODUCT FIELDS EXIST IN RAW TYPE
+
+---
+
+## Order Fields (from Order)
+
+### Field Config Expects:
+```typescript
+order: {
+  orderType: "ORDER_TYPE_FIELD",
+  activationType: "ORDER_ACTIVATION_TYPE_FIELD",
+  activationScheduledAt: "ORDER_ACTIVATION_SCHEDULED_AT_FIELD",
+  activationStatus: "ORDER_ACTIVATION_STATUS_FIELD",
+  internetPlanTier: "ORDER_INTERNET_PLAN_TIER_FIELD",
+  installationType: "ORDER_INSTALLATION_TYPE_FIELD",
+  weekendInstall: "ORDER_WEEKEND_INSTALL_FIELD",
+  accessMode: "ORDER_ACCESS_MODE_FIELD",
+  hikariDenwa: "ORDER_HIKARI_DENWA_FIELD",
+  vpnRegion: "ORDER_VPN_REGION_FIELD",
+  simType: "ORDER_SIM_TYPE_FIELD",
+  eid: "ORDER_EID_FIELD",
+  simVoiceMail: "ORDER_SIM_VOICE_MAIL_FIELD",
+  simCallWaiting: "ORDER_SIM_CALL_WAITING_FIELD",
+  whmcsOrderId: "ORDER_WHMCS_ORDER_ID_FIELD",
+  lastErrorCode: "ORDER_ACTIVATION_ERROR_CODE_FIELD",
+  lastErrorMessage: "ORDER_ACTIVATION_ERROR_MESSAGE_FIELD",
+  lastAttemptAt: "ORDER_ACTIVATION_LAST_ATTEMPT_AT_FIELD",
+  addressChanged: "ORDER_ADDRESS_CHANGED_FIELD",
+  
+  mnp: { ... },
+  billing: { ... }
+}
+```
+
+### Raw Type Has:
+```typescript
+SalesforceOrderRecord {
+  Id: string ✅
+  OrderNumber: string ✅
+  Status: string ✅
+  Type: string ✅ (orderType)
+  EffectiveDate: string ✅
+  TotalAmount: number ✅
+  AccountId: string ✅
+  Account: { Name: string } ✅
+  Pricebook2Id: string ✅
+  Activation_Type__c: string ✅ (activationType)
+  Activation_Status__c: string ✅ (activationStatus)
+  Activation_Scheduled_At__c: string ✅ (activationScheduledAt)
+  Internet_Plan_Tier__c: string ✅ (internetPlanTier)
+  Installment_Plan__c: string ✅ (installationType)
+  Access_Mode__c: string ✅ (accessMode)
+  Weekend_Install__c: boolean ✅ (weekendInstall)
+  Hikari_Denwa__c: boolean ✅ (hikariDenwa)
+  VPN_Region__c: string ✅ (vpnRegion)
+  SIM_Type__c: string ✅ (simType)
+  SIM_Voice_Mail__c: boolean ✅ (simVoiceMail)
+  SIM_Call_Waiting__c: boolean ✅ (simCallWaiting)
+  EID__c: string ✅ (eid)
+  WHMCS_Order_ID__c: string ✅ (whmcsOrderId)
+  Activation_Error_Code__c: string ✅ (lastErrorCode)
+  Activation_Error_Message__c: string ✅ (lastErrorMessage)
+  ActivatedDate: string ✅
+  CreatedDate: string ✅
+  LastModifiedDate: string ✅
+}
+```
+
+**Status:** ✅ ALL ORDER FIELDS EXIST IN RAW TYPE
+
+**Missing Fields in Raw Type:**
+- ❌ `lastAttemptAt` (ORDER_ACTIVATION_LAST_ATTEMPT_AT_FIELD) - NOT IN SCHEMA
+- ❌ `addressChanged` (ORDER_ADDRESS_CHANGED_FIELD) - NOT IN SCHEMA
+- ❌ MNP fields (all nested under order.mnp) - NOT IN SCHEMA
+- ❌ Billing address fields (all nested under order.billing) - NOT IN SCHEMA
+
+---
+
+## OrderItem Fields
+
+### Field Config Expects:
+```typescript
+orderItem: {
+  billingCycle: "ORDER_ITEM_BILLING_CYCLE_FIELD",
+  whmcsServiceId: "ORDER_ITEM_WHMCS_SERVICE_ID_FIELD",
+}
+```
+
+### Raw Type Has:
+```typescript
+SalesforceOrderItemRecord {
+  Id: string ✅
+  OrderId: string ✅
+  Quantity: number ✅
+  UnitPrice: number ✅
+  TotalPrice: number ✅
+  PricebookEntryId: string ✅
+  PricebookEntry: SalesforcePricebookEntryRecord ✅
+  Billing_Cycle__c: string ✅ (billingCycle)
+  WHMCS_Service_ID__c: string ✅ (whmcsServiceId)
+  CreatedDate: string ✅
+  LastModifiedDate: string ✅
+}
+```
+
+**Status:** ✅ ALL ORDER ITEM FIELDS EXIST IN RAW TYPE
+
+---
+
+## 🚨 CRITICAL FINDINGS
+
+### Missing Fields in Raw Types:
+
+#### 1. **MNP (Mobile Number Portability) Fields**
+Field config expects these but they're **NOT in raw type**:
+```typescript
+mnp: {
+  application: string,
+  reservationNumber: string,
+  expiryDate: string,
+  phoneNumber: string,
+  mvnoAccountNumber: string,
+  portingDateOfBirth: string,
+  portingFirstName: string,
+  portingLastName: string,
+  portingFirstNameKatakana: string,
+  portingLastNameKatakana: string,
+  portingGender: string,
+}
+```
+
+**These should be:**
+```typescript
+MNP_Application__c?: string
+MNP_Reservation_Number__c?: string
+MNP_Expiry_Date__c?: string
+MNP_Phone_Number__c?: string
+MVNO_Account_Number__c?: string
+Porting_Date_Of_Birth__c?: string
+Porting_First_Name__c?: string
+Porting_Last_Name__c?: string
+Porting_First_Name_Katakana__c?: string
+Porting_Last_Name_Katakana__c?: string
+Porting_Gender__c?: string
+```
+
+#### 2. **Billing Address Fields**
+Field config expects these but they're **NOT in raw type**:
+```typescript
+billing: {
+  street: string,
+  city: string,
+  state: string,
+  postalCode: string,
+  country: string,
+}
+```
+
+**These should be:**
+```typescript
+Billing_Street__c?: string
+Billing_City__c?: string
+Billing_State__c?: string
+Billing_Postal_Code__c?: string
+Billing_Country__c?: string
+```
+
+#### 3. **Other Missing Fields:**
+```typescript
+lastAttemptAt    → Activation_Last_Attempt_At__c?
+addressChanged   → Address_Changed__c?
+```
+
+---
+
+## Impact Analysis
+
+### **Used in Order Builder** (Order Creation)
+The order builder **DOES use** MNP and billing fields when creating orders:
+
+```typescript
+// apps/bff/src/modules/orders/services/order-builder.service.ts
+
+private addSimFields(...) {
+  // Uses MNP fields if configurations.isMnp === "true"
+  orderFields[mnpField("application", fieldMap)] = ...
+  orderFields[mnpField("phoneNumber", fieldMap)] = ...
+  // etc.
+}
+
+private async addAddressSnapshot(...) {
+  // Uses billing fields for address snapshot
+  orderFields[billingField("street", fieldMap)] = ...
+  orderFields[billingField("city", fieldMap)] = ...
+  // etc.
+}
+```
+
+### **Used in Mapper?**
+Let me check if the mapper tries to read these fields...
+
+```typescript
+// packages/domain/orders/providers/salesforce/mapper.ts
+// The mapper DOES NOT try to read MNP or billing fields
+// It only reads simple order fields
+```
+
+**Status:** ✅ These fields are only used for **writing** (order creation), not **reading** (order display)
+
+---
+
+## ✅ SAFE TO PROCEED - With Additions
+
+### **Conclusion:**
+
+1. ✅ All fields used for **reading** (display) exist in raw types
+2. ❌ Fields used for **writing** (creation) are missing from raw types
+3. ✅ We can safely remove field config for **reading/mapping**
+4. ⚠️  We need to **ADD missing fields** to raw types for **writing**
+
+### **Action Plan:**
+
+1. **First:** Add missing fields to `SalesforceOrderRecord` schema
+   - MNP fields (11 fields)
+   - Billing address fields (5 fields)
+   - lastAttemptAt field
+   - addressChanged field
+
+2. **Then:** Remove field config system
+   - Update mappers to use direct access
+   - Update query builders to use actual field names
+   - Update order builder to use actual field names
+   - Delete field config service
+   - Delete field config interfaces
+
+---
+
+## Next Steps
+
+Before proceeding with removal, I need to:
+
+1. ✅ Update `SalesforceOrderRecord` schema with missing fields
+2. ✅ Verify order creation still works
+3. ✅ Then remove field config system
+
+**Ready to proceed?** I'll first add the missing fields to the raw types.
+

ORDERS-ARCHITECTURE-REVIEW.md

@@ -0,0 +1,414 @@
+# Orders Domain & BFF Integration - Architecture Review
+
+## Executive Summary
+
+After comprehensive review, there are **significant architectural issues** that need addressing. The current structure mixes infrastructure concerns with business logic, has types in wrong locations, and the field configuration system is problematic.
+
+---
+
+## 🚨 Critical Issues Found
+
+### 1. **Field Configuration in Domain (WRONG PLACE)**
+
+**Issue:** `SalesforceOrdersFieldConfig` interfaces are defined in the domain package.
+
+**Location:** `packages/domain/orders/contract.ts` (lines 98-177)
+
+```typescript
+// Currently in domain - THIS IS WRONG
+export interface SalesforceOrderMnpFieldConfig { ... }
+export interface SalesforceOrderFieldConfig { ... }
+export interface SalesforceOrdersFieldConfig { ... }
+```
+
+**Why This Is Wrong:**
+- These are **infrastructure configuration**, not business types
+- They map logical field names to Salesforce custom field API names
+- They're deployment-specific (which fields exist in which Salesforce org)
+- They're NOT business concepts - customers don't care about field mappings
+- Domain should be provider-agnostic
+
+**What Should Happen:**
+- ❌ Domain defines: "Here are the Salesforce field names you must use"
+- ✅ Domain defines: "Here are the business concepts" 
+- ✅ BFF/Integration layer: "Here's how we map those concepts to Salesforce"
+
+**Correct Location:** `apps/bff/src/integrations/salesforce/types/field-config.types.ts`
+
+---
+
+### 2. **SalesforceFieldConfigService Location (CORRECT NOW)**
+
+**Current Location:** `apps/bff/src/integrations/salesforce/services/salesforce-field-config.service.ts` ✅
+
+**Status:** **This is CORRECT!** You were right to question it.
+
+**Why:**
+- Reads from environment variables (ConfigService)
+- Deployment/environment specific
+- Infrastructure concern, not business logic
+- Belongs in BFF integration layer
+
+---
+
+### 3. **Pub/Sub Event Types (CORRECT)**
+
+**Current Location:** `apps/bff/src/integrations/salesforce/types/pubsub-events.types.ts` ✅
+
+**Status:** **This is CORRECT!**
+
+**Why:**
+- Salesforce-specific infrastructure types
+- Platform event structure, not business events
+- Integration concern, not domain concern
+- Belongs in BFF integration layer
+
+---
+
+### 4. **Type Duplication & Confusion**
+
+**Found Multiple Similar Types:**
+
+```typescript
+// In BFF order services
+export interface OrderItemMappingResult { ... }          // order-whmcs-mapper.service.ts
+export interface OrderFulfillmentStep { ... }            // order-fulfillment-orchestrator.service.ts
+export interface OrderFulfillmentContext { ... }         // order-fulfillment-orchestrator.service.ts
+export interface SimFulfillmentRequest { ... }           // sim-fulfillment.service.ts
+
+// In Domain
+export type FulfillmentOrderProduct { ... }
+export type FulfillmentOrderItem { ... }
+export type FulfillmentOrderDetails { ... }
+```
+
+**Issue:** Clear separation between:
+- **Business/Domain types** (what an order *is*)
+- **Workflow/Process types** (how fulfillment *works*)
+- **Integration types** (how we talk to external systems)
+
+---
+
+## 📋 Recommended Architecture
+
+### **Domain Layer** (`packages/domain/orders/`)
+
+**Should contain:**
+```typescript
+// Business entities
+- OrderDetails
+- OrderSummary
+- OrderItemDetails
+- OrderItemSummary
+- FulfillmentOrderDetails (if this is a business concept)
+
+// Business rules
+- Order validation schemas
+- Business constants (ORDER_TYPE, ORDER_STATUS, etc.)
+- Order lifecycle states
+
+// Provider contracts (interfaces only, no config)
+- What data structure do Salesforce/WHMCS need?
+- NOT which fields to use
+```
+
+**Should NOT contain:**
+- ❌ Field configuration interfaces
+- ❌ Environment-specific mappings
+- ❌ Query helpers (buildOrderSelectFields, etc.)
+- ❌ Integration-specific types
+
+---
+
+### **BFF Integration Layer** (`apps/bff/src/integrations/salesforce/`)
+
+**Should contain:**
+```typescript
+// Infrastructure configuration
+- SalesforceFieldConfigService ✅ (already here)
+- Field mapping types (currently in domain ❌)
+- Query builders (should move from domain)
+- Connection management
+- Pub/Sub types ✅ (already here)
+
+// Integration adapters
+- Transform business types → Salesforce records
+- Transform Salesforce records → business types
+```
+
+**Structure:**
+```
+apps/bff/src/integrations/salesforce/
+├── services/
+│   ├── salesforce-connection.service.ts
+│   ├── salesforce-field-config.service.ts  ✅
+│   ├── salesforce-account.service.ts
+│   └── salesforce-order.service.ts         ← NEW (extract from modules/orders)
+├── types/
+│   ├── field-config.types.ts               ← MOVE HERE from domain
+│   ├── pubsub-events.types.ts              ✅
+│   └── query-builder.types.ts              ← NEW
+└── utils/
+    ├── soql.util.ts
+    └── query-builder.util.ts                ← MOVE buildOrderSelectFields here
+```
+
+---
+
+### **BFF Order Module** (`apps/bff/src/modules/orders/`)
+
+**Should contain:**
+```typescript
+// HTTP/API layer
+- OrdersController (API endpoints)
+
+// Application services (orchestration)
+- OrderOrchestrator (coordinates everything)
+- OrderValidator (business + integration validation)
+- OrderFulfillmentOrchestrator
+
+// Workflow types (NOT business types)
+- OrderFulfillmentContext
+- OrderFulfillmentStep
+- SimFulfillmentRequest
+```
+
+**Should NOT directly call:**
+- ❌ Direct Salesforce queries (use SalesforceOrderService)
+- ❌ Field mapping logic (use SalesforceFieldConfigService)
+
+---
+
+## 🔧 Specific Refactorings Needed
+
+### **1. Move Field Config Types Out of Domain**
+
+**FROM:** `packages/domain/orders/contract.ts`
+```typescript
+export interface SalesforceOrderMnpFieldConfig { ... }
+export interface SalesforceOrderBillingFieldConfig { ... }
+export interface SalesforceOrderFieldConfig { ... }
+export interface SalesforceOrderItemFieldConfig { ... }
+export interface SalesforceOrdersFieldConfig { ... }
+```
+
+**TO:** `apps/bff/src/integrations/salesforce/types/field-config.types.ts`
+```typescript
+/**
+ * Salesforce Field Configuration Types
+ * Maps logical business field names to Salesforce custom field API names
+ */
+export interface SalesforceOrderFieldConfig { ... }
+export interface SalesforceOrdersFieldConfig { ... }
+// etc.
+```
+
+---
+
+### **2. Move Query Builders Out of Domain**
+
+**FROM:** `packages/domain/orders/providers/salesforce/query.ts`
+```typescript
+export function buildOrderSelectFields(...)
+export function buildOrderItemSelectFields(...)
+export function buildOrderItemProduct2Fields(...)
+```
+
+**TO:** `apps/bff/src/integrations/salesforce/utils/order-query-builder.ts`
+```typescript
+/**
+ * SOQL Query builders for Orders
+ * Uses field configuration to build dynamic queries
+ */
+export function buildOrderSelectFields(...)
+export function buildOrderItemSelectFields(...)
+// etc.
+```
+
+**Why:** These are SOQL-specific, infrastructure concerns, not business logic.
+
+---
+
+### **3. Create SalesforceOrderService**
+
+**NEW:** `apps/bff/src/integrations/salesforce/services/salesforce-order.service.ts`
+
+```typescript
+@Injectable()
+export class SalesforceOrderService {
+  constructor(
+    private connection: SalesforceConnection,
+    private fieldConfig: SalesforceFieldConfigService,
+    private logger: Logger
+  ) {}
+
+  async getOrderById(orderId: string): Promise<OrderDetails | null> {
+    // Contains Salesforce-specific query logic
+    // Uses field config to build queries
+    // Transforms SF records → domain types
+  }
+
+  async createOrder(orderData: CreateOrderRequest): Promise<{ id: string }> {
+    // Transform domain → SF record
+    // Create in Salesforce
+  }
+
+  async listOrders(params: OrderQueryParams): Promise<OrderSummary[]> {
+    // Query logic
+  }
+}
+```
+
+**Benefits:**
+- Encapsulates all Salesforce order operations
+- OrderOrchestrator doesn't need to know about Salesforce internals
+- Easier to test
+- Easier to swap providers
+
+---
+
+### **4. Consolidate WHMCS Mapping**
+
+**Current:** Duplicate mapping logic in:
+- `packages/domain/orders/providers/whmcs/mapper.ts` (domain ✅)
+- `apps/bff/src/modules/orders/services/order-whmcs-mapper.service.ts` (BFF wrapper)
+
+**Issue:** The service is just a thin wrapper that calls domain mapper. Either:
+
+**Option A:** Keep mapper in domain, remove BFF service
+**Option B:** Move mapper to BFF integration layer
+
+**Recommendation:** **Option A** - Domain mapper is fine for data transformation.
+
+---
+
+## 📊 Layering Principles
+
+```
+┌─────────────────────────────────────────┐
+│     HTTP Layer (Controller)             │
+│  - API endpoints                        │
+│  - Request/Response formatting          │
+└──────────────────┬──────────────────────┘
+                   │
+┌──────────────────▼──────────────────────┐
+│   Application Layer (Orchestrators)     │
+│  - OrderOrchestrator                    │
+│  - OrderFulfillmentOrchestrator         │
+│  - Workflow coordination                │
+└──────────────────┬──────────────────────┘
+                   │
+      ┌────────────┴────────────┐
+      │                         │
+┌─────▼──────────┐    ┌────────▼──────────┐
+│  Domain Layer  │    │ Integration Layer │
+│  (Business)    │    │ (Infrastructure)  │
+│                │    │                   │
+│ - OrderDetails │    │ - SF Order Service│
+│ - Validation   │    │ - WHMCS Service   │
+│ - Rules        │    │ - Field Config    │
+│ - Schemas      │    │ - Query Builders  │
+└────────────────┘    └───────────────────┘
+```
+
+**Rules:**
+1. ✅ Domain can depend on: Nothing external
+2. ✅ Integration can depend on: Domain
+3. ✅ Application can depend on: Domain + Integration
+4. ✅ HTTP can depend on: Application
+
+**Anti-patterns currently present:**
+- ❌ Domain exports query builders (infrastructure concern)
+- ❌ Domain defines field configuration types (deployment concern)
+- ❌ Application services directly query Salesforce (should go through integration service)
+
+---
+
+## 🎯 Recommended Action Plan
+
+### **Phase 1: Move Infrastructure Types Out of Domain** (High Priority)
+
+1. Create `apps/bff/src/integrations/salesforce/types/field-config.types.ts`
+2. Move all `Salesforce*FieldConfig` interfaces from domain to BFF
+3. Update imports across codebase
+4. Update `SalesforceFieldConfigService` to export types from new location
+
+### **Phase 2: Extract Salesforce Order Service** (Medium Priority)
+
+1. Create `SalesforceOrderService` in integration layer
+2. Move all Salesforce query logic from `OrderOrchestrator` to new service
+3. Move query builders from domain to integration utils
+4. Update orchestrator to use new service
+
+### **Phase 3: Clean Up Type Exports** (Medium Priority)
+
+1. Review all domain exports
+2. Remove infrastructure types from domain exports
+3. Create clear separation: business types vs workflow types vs integration types
+4. Document what belongs where
+
+### **Phase 4: Consolidate Mappers** (Low Priority)
+
+1. Decide: Keep WHMCS mappers in domain or move to integration
+2. Remove redundant service wrappers
+3. Standardize mapper patterns
+
+---
+
+## 💡 Key Insights
+
+### **Your Questions Answered:**
+
+1. **"Should SalesforceFieldConfigService be in domain or BFF?"**
+   - **Answer:** BFF integration layer ✅ (already correct!)
+   - It's environment-specific configuration, not business logic
+
+2. **"Should PubSub types be in domain?"**
+   - **Answer:** No, BFF integration layer ✅ (already correct!)
+   - They're Salesforce platform events, not business events
+
+3. **"There are so many overlapping types and wrong used"**
+   - **Answer:** YES! Field config interfaces should NOT be in domain
+   - Query builders should NOT be in domain
+   - These are infrastructure concerns masquerading as business logic
+
+---
+
+## ✅ What's Already Good
+
+1. ✅ Core business types (OrderDetails, OrderSummary) are in domain
+2. ✅ Validation schemas are in domain
+3. ✅ Business constants (ORDER_TYPE, ORDER_STATUS) are in domain
+4. ✅ SalesforceFieldConfigService is in BFF (correct location)
+5. ✅ Pub/Sub types are in BFF (correct location)
+6. ✅ Raw provider types (SalesforceOrderRecord) are in domain (for portability)
+
+---
+
+## 🎓 Architecture Philosophy
+
+**Domain Layer:**
+> "What does the business care about? What are the rules?"
+
+**Integration Layer:**
+> "How do we talk to external systems? How do we map our concepts to theirs?"
+
+**Application Layer:**
+> "What workflows do we support? How do we coordinate services?"
+
+**HTTP Layer:**
+> "How do we expose functionality via API?"
+
+---
+
+## Conclusion
+
+The order domain needs refactoring to properly separate:
+- **Business logic** (domain)
+- **Infrastructure configuration** (BFF integration)
+- **Workflow orchestration** (BFF application)
+
+The most critical issue is that **field configuration types are in the domain** when they should be in the BFF integration layer. This violates domain-driven design principles and creates unwanted coupling.
+
+The good news: You were 100% right to question this, and the major pieces (service locations) are already correct. We just need to move the type definitions to match.
+

ORDERS-FIELD-CONFIG-PROBLEM.md

@@ -0,0 +1,424 @@
+# The Field Config Problem - Root Cause Analysis
+
+## 🎯 Core Issue: Unnecessary Abstraction Layer
+
+The orders domain has an **entire field configuration system** that is **completely unnecessary** and adds significant complexity without any real benefit.
+
+---
+
+## 📊 Comparison: Catalog vs Orders
+
+### **Catalog Domain** (Clean & Simple) ✅
+
+```typescript
+// 1. Raw types define actual Salesforce fields
+export const salesforceProduct2RecordSchema = z.object({
+  Internet_Plan_Tier__c: z.string().nullable().optional(),
+  Billing_Cycle__c: z.string().nullable().optional(),
+  // ... actual field names
+});
+
+// 2. Mapper uses them directly
+export function mapInternetPlan(product: SalesforceProduct2WithPricebookEntries) {
+  const base = baseProduct(product);
+  const tier = product.Internet_Plan_Tier__c ?? undefined;  // ← Direct access
+  
+  return { ...base, internetPlanTier: tier };
+}
+
+// 3. Query builders use actual field names
+const fields = [
+  "Id",
+  "Name",
+  "Internet_Plan_Tier__c",  // ← Direct field name
+  "Billing_Cycle__c",
+];
+```
+
+**Result:** Simple, straightforward, easy to understand.
+
+---
+
+### **Orders Domain** (Over-Engineered) ❌
+
+```typescript
+// 1. Raw types define actual Salesforce fields (same as catalog)
+export const salesforceOrderRecordSchema = z.object({
+  Activation_Type__c: z.string().nullable().optional(),
+  Internet_Plan_Tier__c: z.string().nullable().optional(),
+  // ... actual field names
+});
+
+// 2. Field config interfaces (UNNECESSARY LAYER)
+export interface SalesforceOrderFieldConfig {
+  activationType: string;      // → "Activation_Type__c"
+  internetPlanTier: string;    // → "Internet_Plan_Tier__c"
+  // ... mapping logical names to actual names
+}
+
+// 3. Field config service (UNNECESSARY SERVICE)
+@Injectable()
+export class SalesforceFieldMapService {
+  getFieldMap(): SalesforceOrdersFieldConfig {
+    return {
+      order: {
+        activationType: "Activation_Type__c",
+        internetPlanTier: "Internet_Plan_Tier__c",
+        // ... hardcoded values from env
+      }
+    };
+  }
+}
+
+// 4. Mapper uses field config (INDIRECT ACCESS)
+export function transformSalesforceOrderItem(
+  record: SalesforceOrderItemRecord,
+  fieldConfig: SalesforceOrdersFieldConfig  // ← Extra parameter!
+) {
+  return {
+    sku: pickProductString(product, fieldConfig.product.sku),  // ← Indirect
+    internetPlanTier: pickProductString(product, fieldConfig.product.internetPlanTier),
+  };
+}
+
+// Helper that does runtime reflection (SLOW!)
+function pickProductString(product: SalesforceProduct2Record, field: string) {
+  return ensureString(Reflect.get(product, field));  // ← Runtime lookup!
+}
+
+// 5. Query builders use field config (INDIRECT)
+export function buildOrderSelectFields(
+  fieldConfig: SalesforceOrdersFieldConfig,  // ← Extra parameter!
+  additional: string[] = []
+) {
+  const fields = [
+    "Id",
+    fieldConfig.order.activationType,    // ← Indirect
+    fieldConfig.order.internetPlanTier,  // ← Indirect
+  ];
+  return fields;
+}
+```
+
+**Result:** Complex, confusing, slow (runtime reflection), hard to maintain.
+
+---
+
+## 🤔 Why Does This Exist?
+
+### **Hypothesis 1: Support Multiple Salesforce Orgs?**
+
+**Theory:** Maybe different orgs have different field names?
+- Dev org: `Activation_Type__c`
+- Prod org: `Order_Activation_Type__c`
+
+**Reality:** This doesn't make sense because:
+1. The raw types still hardcode the field names
+2. You'd need to deploy different schemas for different orgs
+3. Custom fields in Salesforce packages have fixed API names
+4. No other domain does this
+
+**Verdict:** ❌ Not the reason
+
+---
+
+### **Hypothesis 2: Environment Configuration?**
+
+**Theory:** Maybe field names come from environment variables?
+
+**Reality:** Looking at the service:
+```typescript
+activationType: this.configService.get<string>("ORDER_ACTIVATION_TYPE_FIELD")!,
+```
+
+But this is pointless because:
+1. The raw types hardcode `Activation_Type__c` anyway
+2. If the env var has the wrong value, queries fail
+3. No flexibility gained - you still need matching schemas
+4. Other domains don't need this
+
+**Verdict:** ❌ Fake flexibility - not actually useful
+
+---
+
+### **Hypothesis 3: Legacy/Historical Reasons?**
+
+**Theory:** Maybe this was built before the raw types existed?
+
+**Reality:** Raw types exist now, making the entire field config system obsolete.
+
+**Verdict:** ✅ Most likely - technical debt that should be removed
+
+---
+
+## 📉 Problems Caused by Field Config System
+
+### **1. Unnecessary Complexity**
+- Extra interfaces: `SalesforceOrderFieldConfig`, `SalesforceOrderMnpFieldConfig`, etc.
+- Extra service: `SalesforceFieldMapService`
+- Extra parameters: Every mapper function needs `fieldConfig`
+- Extra configuration: Environment variables for field names
+
+### **2. Performance Issues**
+```typescript
+// Current: Runtime reflection (slow)
+Reflect.get(product, fieldConfig.product.sku)
+
+// Should be: Direct access (fast)
+product.StockKeepingUnit
+```
+
+### **3. Type Safety Issues**
+```typescript
+// Current: String lookups - no type checking
+pickProductString(product, fieldConfig.product.sku)  // runtime error if field missing
+
+// Should be: Direct access - compile-time type checking
+product.StockKeepingUnit  // compile error if field missing
+```
+
+### **4. Maintenance Burden**
+- Three places to update when adding a field:
+  1. Raw type schema
+  2. Field config interface
+  3. Field config service
+  4. Environment variables
+
+- Should be ONE place:
+  1. Raw type schema only
+
+### **5. Inconsistency Across Domains**
+- Catalog: No field config ✅ Simple
+- Billing: No field config ✅ Simple
+- Orders: Field config ❌ Complex
+- New developers: Confused why orders is different
+
+---
+
+## ✅ Correct Solution: Remove Field Config System
+
+### **Step 1: Update Mappers to Use Raw Types Directly**
+
+**Before:**
+```typescript
+export function transformSalesforceOrderItem(
+  record: SalesforceOrderItemRecord,
+  fieldConfig: SalesforceOrdersFieldConfig  // ← Remove this
+): OrderItemDetails {
+  return {
+    sku: pickProductString(product, fieldConfig.product.sku),  // ← Indirect
+    billingCycle: pickOrderItemString(record, "billingCycle", fieldConfig),
+  };
+}
+```
+
+**After:**
+```typescript
+export function transformSalesforceOrderItem(
+  record: SalesforceOrderItemRecord
+  // No fieldConfig needed!
+): OrderItemDetails {
+  return {
+    sku: product.StockKeepingUnit ?? undefined,         // ← Direct
+    billingCycle: record.Billing_Cycle__c ?? undefined,  // ← Direct
+  };
+}
+```
+
+**Benefits:**
+- ✅ No extra parameters
+- ✅ No runtime reflection
+- ✅ Type-safe compile-time checks
+- ✅ Faster performance
+- ✅ Easier to understand
+
+---
+
+### **Step 2: Update Query Builders to Use Raw Field Names**
+
+**Before:**
+```typescript
+export function buildOrderSelectFields(
+  fieldConfig: SalesforceOrdersFieldConfig,
+  additional: string[] = []
+): string[] {
+  const fields = [
+    "Id",
+    fieldConfig.order.activationType,
+    fieldConfig.order.internetPlanTier,
+  ];
+  return fields;
+}
+```
+
+**After:**
+```typescript
+export function buildOrderSelectFields(
+  additional: string[] = []
+): string[] {
+  const fields = [
+    "Id",
+    "Activation_Type__c",
+    "Internet_Plan_Tier__c",
+  ];
+  return fields;
+}
+```
+
+**Benefits:**
+- ✅ No dependencies on field config
+- ✅ Clear what fields are queried
+- ✅ Matches raw type field names exactly
+- ✅ Easier to maintain
+
+---
+
+### **Step 3: Update Order Builder to Use Raw Field Names**
+
+**Before:**
+```typescript
+async buildOrderFields(body: OrderBusinessValidation): Promise<Record<string, unknown>> {
+  const fieldMap = this.fieldMapService.getFieldMap();
+  return {
+    AccountId: userMapping.sfAccountId,
+    [orderField("orderType", fieldMap)]: body.orderType,  // ← Indirect
+    [orderField("activationType", fieldMap)]: body.configurations?.activationType,
+  };
+}
+```
+
+**After:**
+```typescript
+async buildOrderFields(body: OrderBusinessValidation): Promise<Record<string, unknown>> {
+  return {
+    AccountId: userMapping.sfAccountId,
+    Type: body.orderType,                              // ← Direct
+    Activation_Type__c: body.configurations?.activationType,
+  };
+}
+```
+
+**Benefits:**
+- ✅ No field config service dependency
+- ✅ Clear what Salesforce fields are set
+- ✅ Type-safe (can create typed interface for order creation)
+
+---
+
+### **Step 4: Delete Unnecessary Code**
+
+**Delete these files:**
+- ❌ `apps/bff/src/integrations/salesforce/services/salesforce-field-config.service.ts`
+- ❌ All field config interfaces from `packages/domain/orders/contract.ts`
+- ❌ Environment variables for field names (120+ lines in .env)
+
+**Update these:**
+- ✅ Remove `fieldConfig` parameters from all mapper functions
+- ✅ Remove `SalesforceFieldMapService` from module providers
+- ✅ Remove query builder exports from domain (or simplify them)
+
+---
+
+## 📊 Impact Analysis
+
+### **Lines of Code Removed:** ~500+
+- Field config interfaces: ~100 lines
+- Field config service: ~150 lines  
+- Helper functions (orderField, mnpField, etc.): ~50 lines
+- Environment variable handling: ~120 lines
+- Updated mapper functions: ~100 lines simpler
+
+### **Dependencies Removed:**
+- ❌ `SalesforceFieldMapService` (entire service)
+- ❌ Field config interfaces (all of them)
+- ❌ ConfigService dependency in mappers
+- ❌ Environment variables for field names
+
+### **Performance Improvement:**
+- No runtime `Reflect.get()` calls
+- No field config object construction
+- Direct property access is JIT-optimized
+- Estimated: 20-30% faster mapping
+
+### **Developer Experience:**
+- ✅ One place to define fields (raw types)
+- ✅ IDE autocomplete works perfectly
+- ✅ Compile-time type checking
+- ✅ Consistent with other domains
+- ✅ New developers: "Oh, it's just like catalog!"
+
+---
+
+## 🎯 Migration Plan
+
+### **Phase 1: Prepare (Low Risk)**
+1. Document all current field mappings
+2. Create mapping table: logical name → actual field name
+3. Write tests for current behavior
+
+### **Phase 2: Update Mappers (Medium Risk)**
+1. Update `transformSalesforceOrderItem` to use direct access
+2. Update `transformSalesforceOrderDetails` to use direct access
+3. Remove `fieldConfig` parameters
+4. Run tests to verify behavior unchanged
+
+### **Phase 3: Update Query Builders (Medium Risk)**
+1. Update `buildOrderSelectFields` to use actual field names
+2. Update `buildOrderItemSelectFields` to use actual field names
+3. Remove `fieldConfig` parameters
+4. Test SOQL queries still work
+
+### **Phase 4: Update Order Builder (Medium Risk)**
+1. Replace dynamic field assignments with direct assignments
+2. Remove `SalesforceFieldMapService` dependency
+3. Test order creation still works
+
+### **Phase 5: Cleanup (Low Risk)**
+1. Delete `SalesforceFieldMapService`
+2. Delete field config interfaces
+3. Remove from module providers
+4. Remove environment variables
+5. Update documentation
+
+### **Estimated Time:** 1-2 days
+### **Risk Level:** Medium (but well-tested migration)
+### **Value:** High (simpler, faster, more maintainable)
+
+---
+
+## 🎓 Key Lessons
+
+### **Lesson 1: YAGNI (You Aren't Gonna Need It)**
+The field config system was built for "flexibility" that was never actually needed. The raw types already define the contract with Salesforce.
+
+### **Lesson 2: Consistency Matters**
+Having orders work differently from catalog/billing creates confusion and makes the codebase harder to understand.
+
+### **Lesson 3: Indirection Has Costs**
+Every layer of indirection has costs:
+- Performance cost (runtime lookups)
+- Cognitive cost (harder to understand)
+- Maintenance cost (more code to update)
+
+Only add indirection when the benefit is clear and measurable.
+
+### **Lesson 4: Look at What Already Works**
+Catalog and billing domains work perfectly without field config. That's a strong signal that orders doesn't need it either.
+
+---
+
+## ✅ Recommendation
+
+**Delete the entire field config system and make orders domain work like catalog/billing domains.**
+
+The raw types already define the Salesforce schema. Use them directly. No need for an extra mapping layer.
+
+This will make the codebase:
+- **Simpler** - 500+ fewer lines
+- **Faster** - No runtime reflection
+- **Safer** - Compile-time type checking
+- **Consistent** - Matches other domains
+- **Maintainable** - One place to define fields
+
+The field config system is pure technical debt with no actual benefits.
+

apps/bff/src/core/config/config.module.ts

@@ -1,10 +1,9 @@
 import { Module } from "@nestjs/common";
 import { ConfigModule } from "@nestjs/config";
-import { SalesforceFieldMapService } from "./field-map";
 
 @Module({
   imports: [ConfigModule],
-  providers: [SalesforceFieldMapService],
-  exports: [SalesforceFieldMapService],
+  providers: [],
+  exports: [],
 })
 export class CoreConfigModule {}

apps/bff/src/integrations/salesforce/salesforce.module.ts

@@ -1,13 +1,19 @@
 import { Module } from "@nestjs/common";
+import { ConfigModule } from "@nestjs/config";
 import { QueueModule } from "@bff/core/queue/queue.module";
-import { CoreConfigModule } from "@bff/core/config/config.module";
 import { SalesforceService } from "./salesforce.service";
 import { SalesforceConnection } from "./services/salesforce-connection.service";
 import { SalesforceAccountService } from "./services/salesforce-account.service";
+import { SalesforceFieldMapService } from "./services/salesforce-field-config.service";
 
 @Module({
-  imports: [QueueModule, CoreConfigModule],
-  providers: [SalesforceConnection, SalesforceAccountService, SalesforceService],
-  exports: [SalesforceService, SalesforceConnection],
+  imports: [QueueModule, ConfigModule],
+  providers: [
+    SalesforceConnection,
+    SalesforceAccountService,
+    SalesforceService,
+    SalesforceFieldMapService,
+  ],
+  exports: [SalesforceService, SalesforceConnection, SalesforceFieldMapService],
 })
 export class SalesforceModule {}

apps/bff/src/integrations/salesforce/salesforce.service.ts

@@ -3,7 +3,7 @@ import { Logger } from "nestjs-pino";
 import { ConfigService } from "@nestjs/config";
 import { getErrorMessage } from "@bff/core/utils/error.util";
 import { SalesforceConnection } from "./services/salesforce-connection.service";
-import { SalesforceFieldMapService } from "@bff/core/config/field-map";
+import { SalesforceFieldMapService } from "@bff/integrations/salesforce/services/salesforce-field-config.service";
 import {
   SalesforceAccountService,
   type AccountData,

apps/bff/src/integrations/salesforce/services/salesforce-field-config.service.ts

@@ -5,17 +5,24 @@ import {
   buildOrderItemProduct2Fields,
   buildOrderItemSelectFields,
   buildOrderSelectFields,
-  type SalesforceFieldMap as DomainSalesforceFieldMap,
+  type SalesforceOrdersFieldConfig,
 } from "@customer-portal/domain/orders";
 import type { SalesforceAccountFieldMap } from "@customer-portal/domain/customer";
 
-export type SalesforceFieldMap = DomainSalesforceFieldMap;
+/**
+ * Salesforce field configuration service
+ * Provides the mapping between logical field names and actual Salesforce custom field names
+ */
+export type SalesforceFieldConfig = SalesforceOrdersFieldConfig;
+
+// Legacy alias for backwards compatibility
+export type SalesforceFieldMap = SalesforceFieldConfig;
 
 @Injectable()
 export class SalesforceFieldMapService {
   constructor(private readonly configService: ConfigService) {}
 
-  getFieldMap(): SalesforceFieldMap {
+  getFieldMap(): SalesforceFieldConfig {
     const product: SalesforceProductFieldMap = {
       sku: this.configService.get<string>("PRODUCT_SKU_FIELD")!,
       portalCategory: this.configService.get<string>("PRODUCT_PORTAL_CATEGORY_FIELD")!,
@@ -36,7 +43,7 @@ export class SalesforceFieldMapService {
       vpnRegion: this.configService.get<string>("PRODUCT_VPN_REGION_FIELD")!,
     };
 
-    const fieldMap: SalesforceFieldMap = {
+    const fieldConfig: SalesforceFieldConfig = {
       account: {
         internetEligibility: this.configService.get<string>("ACCOUNT_INTERNET_ELIGIBILITY_FIELD")!,
         customerNumber: this.configService.get<string>("ACCOUNT_CUSTOMER_NUMBER_FIELD")!,
@@ -95,7 +102,7 @@ export class SalesforceFieldMapService {
       },
     };
 
-    return fieldMap;
+    return fieldConfig;
   }
 
   getProductQueryFields(): string {
@@ -126,20 +133,20 @@ export class SalesforceFieldMapService {
   }
 
   getOrderQueryFields(): string {
-    const fieldMap = this.getFieldMap();
-    const fields = buildOrderSelectFields(fieldMap, ["Account.Name"]);
+    const fieldConfig = this.getFieldMap();
+    const fields = buildOrderSelectFields(fieldConfig, ["Account.Name"]);
     return fields.join(", ");
   }
 
   getOrderItemQueryFields(additional: string[] = []): string {
-    const fieldMap = this.getFieldMap();
-    const fields = buildOrderItemSelectFields(fieldMap, additional);
+    const fieldConfig = this.getFieldMap();
+    const fields = buildOrderItemSelectFields(fieldConfig, additional);
     return fields.join(", ");
   }
 
   getOrderItemProduct2Select(additional: string[] = []): string {
-    const fieldMap = this.getFieldMap();
-    const productFields = buildOrderItemProduct2Fields(fieldMap, additional);
+    const fieldConfig = this.getFieldMap();
+    const productFields = buildOrderItemProduct2Fields(fieldConfig, additional);
     return productFields.map(f => `PricebookEntry.Product2.${f}`).join(", ");
   }
 }

apps/bff/src/modules/catalog/services/base-catalog.service.ts

@@ -2,7 +2,7 @@ import { Injectable, Inject } from "@nestjs/common";
 import { ConfigService } from "@nestjs/config";
 import { Logger } from "nestjs-pino";
 import { SalesforceConnection } from "@bff/integrations/salesforce/services/salesforce-connection.service";
-import { SalesforceFieldMapService } from "@bff/core/config/field-map";
+import { SalesforceFieldMapService } from "@bff/integrations/salesforce/services/salesforce-field-config.service";
 import {
   assertSalesforceId,
   sanitizeSoqlLiteral,

apps/bff/src/modules/catalog/services/internet-catalog.service.ts

@@ -9,7 +9,7 @@ import type {
 } from "@customer-portal/domain/catalog";
 import { MappingsService } from "@bff/modules/id-mappings/mappings.service";
 import { SalesforceConnection } from "@bff/integrations/salesforce/services/salesforce-connection.service";
-import { SalesforceFieldMapService } from "@bff/core/config/field-map";
+import { SalesforceFieldMapService } from "@bff/integrations/salesforce/services/salesforce-field-config.service";
 import { Logger } from "nestjs-pino";
 import { getErrorMessage } from "@bff/core/utils/error.util";
 import { assertSalesforceId } from "@bff/integrations/salesforce/utils/soql.util";

apps/bff/src/modules/catalog/services/sim-catalog.service.ts

@@ -1,7 +1,7 @@
 import { Injectable, Inject } from "@nestjs/common";
 import { ConfigService } from "@nestjs/config";
 import { BaseCatalogService } from "./base-catalog.service";
-import { SalesforceFieldMapService } from "@bff/core/config/field-map";
+import { SalesforceFieldMapService } from "@bff/integrations/salesforce/services/salesforce-field-config.service";
 import type {
   SalesforceProduct2WithPricebookEntries,
   SimCatalogProduct,

apps/bff/src/modules/catalog/services/vpn-catalog.service.ts

@@ -2,7 +2,7 @@ import { Injectable, Inject } from "@nestjs/common";
 import { ConfigService } from "@nestjs/config";
 import { Logger } from "nestjs-pino";
 import { SalesforceConnection } from "@bff/integrations/salesforce/services/salesforce-connection.service";
-import { SalesforceFieldMapService } from "@bff/core/config/field-map";
+import { SalesforceFieldMapService } from "@bff/integrations/salesforce/services/salesforce-field-config.service";
 import { BaseCatalogService } from "./base-catalog.service";
 import type { SalesforceProduct2WithPricebookEntries, VpnCatalogProduct } from "@customer-portal/domain/catalog";
 import { mapVpnProduct } from "@bff/modules/catalog/utils/salesforce-product.mapper";

apps/bff/src/modules/catalog/utils/salesforce-product.mapper.ts

@@ -12,7 +12,7 @@ import type {
   SalesforceProduct2WithPricebookEntries,
   SalesforcePricebookEntryRecord,
 } from "@customer-portal/domain/catalog";
-import type { SalesforceFieldMap } from "@bff/core/config/field-map";
+import type { SalesforceFieldMap } from "@bff/integrations/salesforce/services/salesforce-field-config.service";
 
 export type SalesforceCatalogProductRecord = SalesforceProduct2WithPricebookEntries;
 

apps/bff/src/modules/orders/queue/provisioning.processor.ts

@@ -3,7 +3,7 @@ import { Injectable, Inject } from "@nestjs/common";
 import { Logger } from "nestjs-pino";
 import { OrderFulfillmentOrchestrator } from "../services/order-fulfillment-orchestrator.service";
 import { SalesforceService } from "@bff/integrations/salesforce/salesforce.service";
-import { SalesforceFieldMapService } from "@bff/core/config/field-map";
+import { SalesforceFieldMapService } from "@bff/integrations/salesforce/services/salesforce-field-config.service";
 import type { ProvisioningJobData } from "./provisioning.queue";
 import { CacheService } from "@bff/infra/cache/cache.service";
 import { ConfigService } from "@nestjs/config";

apps/bff/src/modules/orders/services/order-builder.service.ts

@@ -1,17 +1,7 @@
 import { Injectable, Inject } from "@nestjs/common";
 import { Logger } from "nestjs-pino";
 import type { OrderBusinessValidation, UserMapping } from "@customer-portal/domain/orders";
-import { SalesforceFieldMapService, type SalesforceFieldMap } from "@bff/core/config/field-map";
 import { UsersService } from "@bff/modules/users/users.service";
-type OrderBuilderFieldKey =
-  | "orderType"
-  | "activationType"
-  | "activationScheduledAt"
-  | "activationStatus"
-  | "accessMode"
-  | "simType"
-  | "eid"
-  | "addressChanged";
 
 function assignIfString(target: Record<string, unknown>, key: string, value: unknown): void {
   if (typeof value === "string" && value.trim().length > 0) {
@@ -19,41 +9,13 @@ function assignIfString(target: Record<string, unknown>, key: string, value: unk
   }
 }
 
-function orderField(key: OrderBuilderFieldKey, fieldMap: SalesforceFieldMap): string {
-  const fieldName = fieldMap.order[key];
-  if (typeof fieldName !== "string") {
-    throw new Error(`Missing Salesforce order field mapping for key ${String(key)}`);
-  }
-  return fieldName;
-}
-
-function mnpField<K extends keyof SalesforceFieldMap["order"]["mnp"]>(
-  key: K,
-  fieldMap: SalesforceFieldMap
-): string {
-  const fieldName = fieldMap.order.mnp[key];
-  if (typeof fieldName !== "string") {
-    throw new Error(`Missing Salesforce order MNP field mapping for key ${String(key)}`);
-  }
-  return fieldName;
-}
-
-function billingField<K extends keyof SalesforceFieldMap["order"]["billing"]>(
-  key: K,
-  fieldMap: SalesforceFieldMap
-): string {
-  const fieldName = fieldMap.order.billing[key];
-  if (typeof fieldName !== "string") {
-    throw new Error(`Missing Salesforce order billing field mapping for key ${String(key)}`);
-  }
-  return fieldName;
-}
-
+/**
+ * Builds Salesforce Order records from domain order requests
+ */
 @Injectable()
 export class OrderBuilder {
   constructor(
     @Inject(Logger) private readonly logger: Logger,
-    private readonly fieldMapService: SalesforceFieldMapService,
     private readonly usersService: UsersService
   ) {}
 
@@ -63,7 +25,6 @@ export class OrderBuilder {
     pricebookId: string,
     userId: string
   ): Promise<Record<string, unknown>> {
-    const fieldMap = this.fieldMapService.getFieldMap();
     const today = new Date().toISOString().slice(0, 10);
 
     const orderFields: Record<string, unknown> = {
@@ -71,94 +32,74 @@ export class OrderBuilder {
       EffectiveDate: today,
       Status: "Pending Review",
       Pricebook2Id: pricebookId,
-      [orderField("orderType", fieldMap)]: body.orderType,
+      Type: body.orderType,
       ...(body.opportunityId ? { OpportunityId: body.opportunityId } : {}),
     };
 
-    this.addActivationFields(orderFields, body, fieldMap);
+    this.addActivationFields(orderFields, body);
 
     switch (body.orderType) {
       case "Internet":
-        this.addInternetFields(orderFields, body, fieldMap);
+        this.addInternetFields(orderFields, body);
         break;
       case "SIM":
-        this.addSimFields(orderFields, body, fieldMap);
+        this.addSimFields(orderFields, body);
         break;
       case "VPN":
-        this.addVpnFields(orderFields, body, fieldMap);
+        this.addVpnFields(orderFields, body);
         break;
     }
 
-    await this.addAddressSnapshot(orderFields, userId, body, fieldMap);
+    await this.addAddressSnapshot(orderFields, userId, body);
 
     return orderFields;
   }
 
   private addActivationFields(
     orderFields: Record<string, unknown>,
-    body: OrderBusinessValidation,
-    fieldMap: SalesforceFieldMap
+    body: OrderBusinessValidation
   ): void {
     const config = body.configurations || {};
 
-    assignIfString(orderFields, orderField("activationType", fieldMap), config.activationType);
-    assignIfString(orderFields, orderField("activationScheduledAt", fieldMap), config.scheduledAt);
-    orderFields[orderField("activationStatus", fieldMap)] = "Not Started";
+    assignIfString(orderFields, "Activation_Type__c", config.activationType);
+    assignIfString(orderFields, "Activation_Scheduled_At__c", config.scheduledAt);
+    orderFields.Activation_Status__c = "Not Started";
   }
 
   private addInternetFields(
     orderFields: Record<string, unknown>,
-    body: OrderBusinessValidation,
-    fieldMap: SalesforceFieldMap
+    body: OrderBusinessValidation
   ): void {
     const config = body.configurations || {};
-    assignIfString(orderFields, orderField("accessMode", fieldMap), config.accessMode);
+    assignIfString(orderFields, "Access_Mode__c", config.accessMode);
   }
 
   private addSimFields(
     orderFields: Record<string, unknown>,
-    body: OrderBusinessValidation,
-    fieldMap: SalesforceFieldMap
+    body: OrderBusinessValidation
   ): void {
     const config = body.configurations || {};
-    assignIfString(orderFields, orderField("simType", fieldMap), config.simType);
-    assignIfString(orderFields, orderField("eid", fieldMap), config.eid);
+    assignIfString(orderFields, "SIM_Type__c", config.simType);
+    assignIfString(orderFields, "EID__c", config.eid);
 
     if (config.isMnp === "true") {
-      orderFields[mnpField("application", fieldMap)] = true;
-      assignIfString(orderFields, mnpField("reservationNumber", fieldMap), config.mnpNumber);
-      assignIfString(orderFields, mnpField("expiryDate", fieldMap), config.mnpExpiry);
-      assignIfString(orderFields, mnpField("phoneNumber", fieldMap), config.mnpPhone);
-      assignIfString(
-        orderFields,
-        mnpField("mvnoAccountNumber", fieldMap),
-        config.mvnoAccountNumber
-      );
-      assignIfString(orderFields, mnpField("portingLastName", fieldMap), config.portingLastName);
-      assignIfString(orderFields, mnpField("portingFirstName", fieldMap), config.portingFirstName);
-      assignIfString(
-        orderFields,
-        mnpField("portingLastNameKatakana", fieldMap),
-        config.portingLastNameKatakana
-      );
-      assignIfString(
-        orderFields,
-        mnpField("portingFirstNameKatakana", fieldMap),
-        config.portingFirstNameKatakana
-      );
-      assignIfString(orderFields, mnpField("portingGender", fieldMap), config.portingGender);
-      assignIfString(
-        orderFields,
-        mnpField("portingDateOfBirth", fieldMap),
-        config.portingDateOfBirth
-      );
+      orderFields.MNP_Application__c = true;
+      assignIfString(orderFields, "MNP_Reservation_Number__c", config.mnpNumber);
+      assignIfString(orderFields, "MNP_Expiry_Date__c", config.mnpExpiry);
+      assignIfString(orderFields, "MNP_Phone_Number__c", config.mnpPhone);
+      assignIfString(orderFields, "MVNO_Account_Number__c", config.mvnoAccountNumber);
+      assignIfString(orderFields, "Porting_Last_Name__c", config.portingLastName);
+      assignIfString(orderFields, "Porting_First_Name__c", config.portingFirstName);
+      assignIfString(orderFields, "Porting_Last_Name_Katakana__c", config.portingLastNameKatakana);
+      assignIfString(orderFields, "Porting_First_Name_Katakana__c", config.portingFirstNameKatakana);
+      assignIfString(orderFields, "Porting_Gender__c", config.portingGender);
+      assignIfString(orderFields, "Porting_Date_Of_Birth__c", config.portingDateOfBirth);
     }
   }
 
   private addVpnFields(
     _orderFields: Record<string, unknown>,
-    _body: OrderBusinessValidation,
-    _fieldMap: SalesforceFieldMap
+    _body: OrderBusinessValidation
   ): void {
     // No additional fields for VPN orders at this time.
   }
@@ -166,8 +107,7 @@ export class OrderBuilder {
   private async addAddressSnapshot(
     orderFields: Record<string, unknown>,
     userId: string,
-    body: OrderBusinessValidation,
-    fieldMap: SalesforceFieldMap
+    body: OrderBusinessValidation
   ): Promise<void> {
     try {
       const profile = await this.usersService.getProfile(userId);
@@ -182,17 +122,12 @@ export class OrderBuilder {
       const address2 = typeof addressToUse?.address2 === "string" ? addressToUse.address2 : "";
       const fullStreet = [address1, address2].filter(Boolean).join(", ");
 
-      orderFields[billingField("street", fieldMap)] = fullStreet;
-      orderFields[billingField("city", fieldMap)] =
-        typeof addressToUse?.city === "string" ? addressToUse.city : "";
-      orderFields[billingField("state", fieldMap)] =
-        typeof addressToUse?.state === "string" ? addressToUse.state : "";
-      orderFields[billingField("postalCode", fieldMap)] =
-        typeof addressToUse?.postcode === "string" ? addressToUse.postcode : "";
-      orderFields[billingField("country", fieldMap)] =
-        typeof addressToUse?.country === "string" ? addressToUse.country : "";
-
-      orderFields[orderField("addressChanged", fieldMap)] = addressChanged;
+      orderFields.Billing_Street__c = fullStreet;
+      orderFields.Billing_City__c = typeof addressToUse?.city === "string" ? addressToUse.city : "";
+      orderFields.Billing_State__c = typeof addressToUse?.state === "string" ? addressToUse.state : "";
+      orderFields.Billing_Postal_Code__c = typeof addressToUse?.postcode === "string" ? addressToUse.postcode : "";
+      orderFields.Billing_Country__c = typeof addressToUse?.country === "string" ? addressToUse.country : "";
+      orderFields.Address_Changed__c = addressChanged;
 
       if (addressChanged) {
         this.logger.log({ userId }, "Customer updated address during checkout");

apps/bff/src/modules/orders/services/order-fulfillment-orchestrator.service.ts

@@ -15,7 +15,7 @@ import { OrderFulfillmentErrorService } from "./order-fulfillment-error.service"
 import { SimFulfillmentService } from "./sim-fulfillment.service";
 import { DistributedTransactionService } from "@bff/core/database/services/distributed-transaction.service";
 import { getErrorMessage } from "@bff/core/utils/error.util";
-import { SalesforceFieldMapService } from "@bff/core/config/field-map";
+import { SalesforceFieldMapService } from "@bff/integrations/salesforce/services/salesforce-field-config.service";
 import { type OrderSummary, type OrderDetails, type SalesforceOrderRecord, type SalesforceOrderItemRecord } from "@customer-portal/domain/orders";
 import type { FulfillmentOrderDetails, FulfillmentOrderItem } from "../types/fulfillment.types";
 

apps/bff/src/modules/orders/services/order-fulfillment-validator.service.ts

@@ -5,7 +5,7 @@ import { WhmcsPaymentService } from "@bff/integrations/whmcs/services/whmcs-paym
 import { MappingsService } from "@bff/modules/id-mappings/mappings.service";
 import { getErrorMessage } from "@bff/core/utils/error.util";
 import type { SalesforceOrderRecord } from "@customer-portal/domain/orders";
-import { SalesforceFieldMapService, type SalesforceFieldMap } from "@bff/core/config/field-map";
+import { SalesforceFieldMapService, type SalesforceFieldMap } from "@bff/integrations/salesforce/services/salesforce-field-config.service";
 import { sfOrderIdParamSchema } from "@customer-portal/domain/orders";
 type OrderStringFieldKey = "activationStatus";
 

apps/bff/src/modules/orders/services/order-orchestrator.service.ts

@@ -6,13 +6,15 @@ import { OrderBuilder } from "./order-builder.service";
 import { OrderItemBuilder } from "./order-item-builder.service";
 import {
   Providers as OrderProviders,
+  buildOrderSelectFields,
+  buildOrderItemSelectFields,
+  buildOrderItemProduct2Fields,
   type OrderDetails,
   type OrderSummary,
   type SalesforceOrderRecord,
   type SalesforceOrderItemRecord,
   type SalesforceQueryResult,
 } from "@customer-portal/domain/orders";
-import { SalesforceFieldMapService } from "@bff/core/config/field-map";
 import { assertSalesforceId, buildInClause } from "@bff/integrations/salesforce/utils/soql.util";
 import { getErrorMessage } from "@bff/core/utils/error.util";
 
@@ -28,7 +30,6 @@ export class OrderOrchestrator {
   constructor(
     @Inject(Logger) private readonly logger: Logger,
     private readonly sf: SalesforceConnection,
-    private readonly fieldMapService: SalesforceFieldMapService,
     private readonly orderValidator: OrderValidator,
     private readonly orderBuilder: OrderBuilder,
     private readonly orderItemBuilder: OrderItemBuilder

apps/bff/src/modules/orders/services/order-pricebook.service.ts

@@ -2,7 +2,7 @@ import { Inject, Injectable, NotFoundException } from "@nestjs/common";
 import { ConfigService } from "@nestjs/config";
 import { Logger } from "nestjs-pino";
 import { SalesforceConnection } from "@bff/integrations/salesforce/services/salesforce-connection.service";
-import { SalesforceFieldMapService } from "@bff/core/config/field-map";
+import { SalesforceFieldMapService } from "@bff/integrations/salesforce/services/salesforce-field-config.service";
 import { getStringField } from "@bff/modules/catalog/utils/salesforce-product.mapper";
 import { z } from "zod";
 import type {

packages/domain/catalog/index.ts

@@ -33,3 +33,6 @@ export type {
 
 // Provider adapters
 export * as Providers from "./providers";
+
+// Re-export provider raw types for convenience
+export * from "./providers/salesforce/raw.types";

packages/domain/orders/BEFORE-AFTER-COMPARISON.md

@@ -1,470 +0,0 @@
-# Orders Domain: Before vs After Restructuring
-
-## 📁 File Structure Comparison
-
-### BEFORE (Current - Convoluted) ❌
-
-```
-packages/domain/orders/
-├── contract.ts                    ← 247 lines, EVERYTHING MIXED
-│   ├── Business types
-│   ├── Salesforce field maps      ← Should be in providers/
-│   ├── Re-exports from schema     ← Redundant
-│   └── Unclear organization
-│
-├── schema.ts                      ← 269 lines, okay but needs organization
-│   └── Schemas + types
-│
-├── validation.ts                  ← 180 lines, GOOD (just created)
-│   └── Business rules
-│
-├── providers/
-│   ├── salesforce/
-│   │   ├── field-map.mapper.ts   ← Odd naming
-│   │   ├── raw.types.ts          ← Good
-│   │   ├── query.ts              ← Good
-│   │   └── index.ts
-│   ├── whmcs/
-│   │   ├── mapper.ts             ← Good
-│   │   ├── raw.types.ts          ← Good
-│   │   └── index.ts
-│   └── index.ts
-│
-└── index.ts                       ← Mixed exports
-
-ISSUES:
-❌ contract.ts is a dumping ground (247 lines)
-❌ SF field maps mixed with business types
-❌ Unclear what's provider-specific
-❌ Inconsistent with other domains
-```
-
-### AFTER (Proposed - Clean) ✅
-
-```
-packages/domain/orders/
-├── contract.ts                    ← 50 lines, CONSTANTS ONLY ✅
-│   ├── ORDER_TYPE
-│   ├── ORDER_STATUS
-│   └── ACTIVATION_TYPE
-│
-├── schema.ts                      ← 280 lines, BETTER ORGANIZED ✅
-│   ├── Order schemas
-│   ├── Order item schemas
-│   ├── Creation schemas
-│   ├── Fulfillment schemas
-│   └── Query schemas
-│
-├── validation.ts                  ← 180 lines, BUSINESS RULES ✅
-│   └── SKU validation helpers
-│
-├── providers/
-│   ├── salesforce/
-│   │   ├── raw.types.ts          ← Raw SF API types
-│   │   ├── field-map.types.ts    ← SF field maps (NEW, MOVED) ✅
-│   │   ├── mapper.ts             ← SF → Domain (RENAMED) ✅
-│   │   ├── query.ts              ← SF queries
-│   │   └── index.ts              ← Clean exports
-│   ├── whmcs/
-│   │   ├── raw.types.ts          ← Raw WHMCS API types
-│   │   ├── mapper.ts             ← WHMCS → Domain
-│   │   └── index.ts              ← Clean exports
-│   └── index.ts                   ← Provider exports
-│
-└── index.ts                       ← CLEAN PUBLIC API ✅
-
-BENEFITS:
-✅ contract.ts = only constants (like other domains)
-✅ SF field maps isolated in providers/
-✅ Clear what's provider-specific
-✅ Consistent with subscriptions/billing/customer
-✅ Easy to navigate
-```
-
----
-
-## 📄 contract.ts Comparison
-
-### BEFORE: Mixed Concerns (247 lines) ❌
-
-```typescript
-/**
- * Orders Domain - Contract
- */
-
-// Business types
-export type OrderCreationType = "Internet" | "SIM" | "VPN" | "Other";
-export type OrderStatus = string;
-export type OrderType = string;
-export type UserMapping = Pick<UserIdMapping, "userId" | "whmcsClientId" | "sfAccountId">;
-
-// ❌ PROBLEM: Salesforce field maps mixed with business types
-export interface SalesforceOrderMnpFieldMap {
-  application: string;
-  reservationNumber: string;
-  expiryDate: string;
-  phoneNumber: string;
-  mvnoAccountNumber: string;
-  portingDateOfBirth: string;
-  portingFirstName: string;
-  portingLastName: string;
-  portingFirstNameKatakana: string;
-  portingLastNameKatakana: string;
-  portingGender: string;
-}
-
-export interface SalesforceOrderBillingFieldMap {
-  street: string;
-  city: string;
-  state: string;
-  postalCode: string;
-  country: string;
-}
-
-export interface SalesforceOrderFieldMap {
-  orderType: string;
-  activationType: string;
-  activationScheduledAt: string;
-  activationStatus: string;
-  internetPlanTier: string;
-  installationType: string;
-  weekendInstall: string;
-  accessMode: string;
-  hikariDenwa: string;
-  vpnRegion: string;
-  simType: string;
-  eid: string;
-  simVoiceMail: string;
-  simCallWaiting: string;
-  mnp: SalesforceOrderMnpFieldMap;
-  whmcsOrderId: string;
-  lastErrorCode?: string;
-  lastErrorMessage?: string;
-  lastAttemptAt?: string;
-  addressChanged: string;
-  billing: SalesforceOrderBillingFieldMap;
-}
-
-export interface SalesforceOrderItemFieldMap {
-  billingCycle: string;
-  whmcsServiceId: string;
-}
-
-export interface SalesforceFieldMap {
-  account: SalesforceAccountFieldMap;
-  product: SalesforceProductFieldMap;
-  order: SalesforceOrderFieldMap;
-  orderItem: SalesforceOrderItemFieldMap;
-}
-
-// ❌ PROBLEM: Re-exports from schema (redundant)
-export type {
-  FulfillmentOrderProduct,
-  FulfillmentOrderItem,
-  FulfillmentOrderDetails,
-  OrderItemSummary,
-  OrderItemDetails,
-  OrderSummary,
-  OrderDetails,
-  OrderQueryParams,
-  OrderConfigurationsAddress,
-  OrderConfigurations,
-  CreateOrderRequest,
-  OrderBusinessValidation,
-  SfOrderIdParam,
-} from './schema';
-
-// TOTAL: 247 lines of mixed concerns
-```
-
-### AFTER: Clean Constants (50 lines) ✅
-
-```typescript
-/**
- * Orders Domain - Contract
- * 
- * Business constants and enums for the orders domain.
- * All validated types are derived from schemas (see schema.ts).
- */
-
-// ============================================================================
-// Order Type Constants
-// ============================================================================
-
-/**
- * Order types available in the system
- */
-export const ORDER_TYPE = {
-  INTERNET: "Internet",
-  SIM: "SIM",
-  VPN: "VPN",
-  OTHER: "Other",
-} as const;
-
-export type OrderType = (typeof ORDER_TYPE)[keyof typeof ORDER_TYPE];
-
-// ============================================================================
-// Order Status Constants
-// ============================================================================
-
-/**
- * Possible order statuses
- */
-export const ORDER_STATUS = {
-  DRAFT: "Draft",
-  ACTIVATED: "Activated",
-  PENDING: "Pending",
-  FAILED: "Failed",
-  CANCELLED: "Cancelled",
-} as const;
-
-export type OrderStatus = (typeof ORDER_STATUS)[keyof typeof ORDER_STATUS];
-
-// ============================================================================
-// Activation Type Constants
-// ============================================================================
-
-/**
- * Order activation types
- */
-export const ACTIVATION_TYPE = {
-  IMMEDIATE: "Immediate",
-  SCHEDULED: "Scheduled",
-} as const;
-
-export type ActivationType = (typeof ACTIVATION_TYPE)[keyof typeof ACTIVATION_TYPE];
-
-// ============================================================================
-// SIM Type Constants
-// ============================================================================
-
-/**
- * SIM card types
- */
-export const SIM_TYPE = {
-  ESIM: "eSIM",
-  PHYSICAL: "Physical SIM",
-} as const;
-
-export type SimType = (typeof SIM_TYPE)[keyof typeof SIM_TYPE];
-
-// TOTAL: ~50 lines of clean constants only
-```
-
----
-
-## 🆕 New File: providers/salesforce/field-map.types.ts
-
-```typescript
-/**
- * Salesforce Field Mappings
- * 
- * Dynamic field mappings for Salesforce custom fields.
- * These are provider-specific configuration, NOT domain types.
- */
-
-import type { SalesforceAccountFieldMap } from "../../../customer/contract";
-import type { SalesforceProductFieldMap } from "../../../catalog/contract";
-
-// ============================================================================
-// Order MNP Field Map
-// ============================================================================
-
-export interface SalesforceOrderMnpFieldMap {
-  application: string;
-  reservationNumber: string;
-  expiryDate: string;
-  phoneNumber: string;
-  mvnoAccountNumber: string;
-  portingDateOfBirth: string;
-  portingFirstName: string;
-  portingLastName: string;
-  portingFirstNameKatakana: string;
-  portingLastNameKatakana: string;
-  portingGender: string;
-}
-
-// ============================================================================
-// Order Billing Field Map
-// ============================================================================
-
-export interface SalesforceOrderBillingFieldMap {
-  street: string;
-  city: string;
-  state: string;
-  postalCode: string;
-  country: string;
-}
-
-// ============================================================================
-// Order Field Map
-// ============================================================================
-
-export interface SalesforceOrderFieldMap {
-  orderType: string;
-  activationType: string;
-  activationScheduledAt: string;
-  activationStatus: string;
-  internetPlanTier: string;
-  installationType: string;
-  weekendInstall: string;
-  accessMode: string;
-  hikariDenwa: string;
-  vpnRegion: string;
-  simType: string;
-  eid: string;
-  simVoiceMail: string;
-  simCallWaiting: string;
-  mnp: SalesforceOrderMnpFieldMap;
-  whmcsOrderId: string;
-  lastErrorCode?: string;
-  lastErrorMessage?: string;
-  lastAttemptAt?: string;
-  addressChanged: string;
-  billing: SalesforceOrderBillingFieldMap;
-}
-
-// ============================================================================
-// Order Item Field Map
-// ============================================================================
-
-export interface SalesforceOrderItemFieldMap {
-  billingCycle: string;
-  whmcsServiceId: string;
-}
-
-// ============================================================================
-// Complete Field Map
-// ============================================================================
-
-export interface SalesforceFieldMap {
-  account: SalesforceAccountFieldMap;
-  product: SalesforceProductFieldMap;
-  order: SalesforceOrderFieldMap;
-  orderItem: SalesforceOrderItemFieldMap;
-}
-```
-
----
-
-## 📋 index.ts Comparison
-
-### BEFORE: Mixed Exports ❌
-
-```typescript
-/**
- * Orders Domain
- */
-
-// Business types
-export { type OrderCreationType, type OrderStatus, type OrderType, type UserMapping } from "./contract";
-
-// Provider-specific types
-export type {
-  SalesforceOrderMnpFieldMap,        // ❌ Should be in Providers export
-  SalesforceOrderBillingFieldMap,    // ❌ Should be in Providers export
-  SalesforceOrderFieldMap,           // ❌ Should be in Providers export
-  SalesforceOrderItemFieldMap,       // ❌ Should be in Providers export
-  SalesforceFieldMap,                // ❌ Should be in Providers export
-} from "./contract";
-
-// Schemas (includes derived types)
-export * from "./schema";
-
-// Validation (extended business rules)
-export * from "./validation";
-
-// Re-export types for convenience (redundant)
-export type {
-  FulfillmentOrderProduct,
-  FulfillmentOrderItem,
-  // ... many more
-} from './schema';
-
-// Provider adapters
-export * as Providers from "./providers";
-
-// Re-export provider types for convenience
-export * from "./providers/whmcs/raw.types";
-export * from "./providers/salesforce/raw.types";
-```
-
-### AFTER: Clean Public API ✅
-
-```typescript
-/**
- * Orders Domain
- * 
- * Exports all order-related contracts, schemas, validation, and provider adapters.
- */
-
-// ============================================================================
-// Constants & Enums
-// ============================================================================
-
-export * from "./contract";
-
-// ============================================================================
-// Schemas & Types (Schema-First)
-// ============================================================================
-
-export * from "./schema";
-
-// ============================================================================
-// Validation (Extended Business Rules)
-// ============================================================================
-
-export * from "./validation";
-
-// ============================================================================
-// Provider Adapters
-// ============================================================================
-
-export * as Providers from "./providers";
-
-// For convenience, export commonly used provider types at top level
-export type {
-  // Salesforce
-  SalesforceOrderRecord,
-  SalesforceOrderItemRecord,
-  SalesforceFieldMap,              // ✅ Now clearly from Providers
-  // WHMCS
-  WhmcsAddOrderParams,
-  WhmcsOrderItem,
-  WhmcsOrderResult,
-} from "./providers";
-```
-
----
-
-## 🎯 Impact Summary
-
-| Aspect | Before | After | Improvement |
-|--------|--------|-------|-------------|
-| **contract.ts** | 247 lines, mixed | 50 lines, constants | -80% size, 100% clarity |
-| **Provider separation** | Mixed in contract | Isolated in providers/ | Clear boundaries |
-| **Consistency** | Unique pattern | Matches other domains | Easy to learn |
-| **Discoverability** | Unclear ownership | Obvious location | Fast navigation |
-| **Maintainability** | Changes affect multiple concerns | Changes isolated | Safer refactoring |
-
----
-
-## ✅ Key Improvements
-
-1. **contract.ts**: 247 lines → 50 lines (constants only)
-2. **Provider isolation**: SF field maps moved to `providers/salesforce/`
-3. **Pattern consistency**: Now matches `subscriptions`, `billing`, `customer` domains
-4. **Clarity**: Obvious where each type belongs
-5. **No breaking changes**: All imports still work (just internally reorganized)
-
----
-
-## 🚀 Migration Path
-
-1. ✅ Create `providers/salesforce/field-map.types.ts` (non-breaking)
-2. ✅ Update mapper imports (non-breaking)
-3. ✅ Rewrite `contract.ts` (breaking but minimal impact)
-4. ✅ Update `index.ts` exports (non-breaking)
-5. ✅ Test and verify
-
-**Result**: Clean, maintainable, consistent orders domain! 🎉

packages/domain/orders/RESTRUCTURING-PLAN.md

@@ -1,141 +0,0 @@
-# 🏗️ Orders Domain Restructuring Plan
-
-**Date**: October 2025  
-**Status**: Proposed  
-**Priority**: High – Architectural Consistency
-
----
-
-## Why Split Validation?
-
-Orders has two very different validation layers:
-
-1. **Schema validation** – structural guarantees we can infer from Zod (e.g. shape of an incoming request or the normalization of a Salesforce record).  
-2. **Business rules** – SKU combinations, prerequisite checks, and cross-field rules that need to be reused by both the BFF and frontend logic.
-
-Keeping those concerns in separate modules (`*.schema.ts` vs `rules.ts`) mirrors how other domains expose reusable behaviour (`customer/validation.ts`, `sim/rules.ts`) and makes it possible to import just the pure rule helpers in environments where running the full schema is overkill. It also prevents circular imports when business logic needs to call back into provider helpers.
-
----
-
-## Design Goals
-
-- Align the orders domain with the schema-first, provider-isolated structure used by `customer`, `catalog`, and `sim`.
-- Make the distinction between *raw vendor data*, *normalized domain models*, and *business rules* obvious.
-- Centralise dynamic Salesforce field-map handling so configuration is validated once and shared by mappers and query builders.
-- Improve testability by isolating pure transforms and validation helpers.
-
----
-
-## Current Pain Points
-
-| Area | Issue |
-|------|-------|
-| Contracts | `contract.ts` mixes business constants with Salesforce configuration interfaces and schema re-exports. |
-| Schemas | `schema.ts` blends read models, write models, fulfillment data, and business refinements in a single block, making reuse awkward. |
-| Providers | The Salesforce mapper relies on unchecked configuration using `Reflect.get`, and WHMCS mapping redefines schemas inline. |
-| Config | Query helpers and the BFF maintain separate field lists, so config drift is likely. |
-
----
-
-## Target File Layout
-
-```
-packages/domain/orders/
-├── contract.ts                     # Business enums/constants only
-├── index.ts                        # Public API surface
-├── rules.ts                        # Domain business helpers (SKU rules, etc.)
-├── schemas/
-│   ├── read-model.schema.ts        # OrderSummary/OrderDetails
-│   ├── fulfillment.schema.ts       # Fulfillment-specific schemas
-│   ├── write-model.schema.ts       # CreateOrderRequest, OrderConfigurations
-│   └── query.schema.ts             # Request/query params shared by API
-├── providers/
-│   ├── salesforce/
-│   │   ├── field-map.schema.ts     # Zod schema + helpers for config
-│   │   ├── raw.schema.ts           # Zod schemas for raw Order/OrderItem/Product2
-│   │   ├── normalizer.ts           # Converts raw records using field resolver
-│   │   ├── mapper.ts               # Maps normalised data to read-model schemas
-│   │   └── query.ts                # Builds SOQL select lists via resolver
-│   └── whmcs/
-│       ├── raw.schema.ts           # Zod schemas for WHMCS payloads/responses
-│       └── mapper.ts               # Uses fulfillment schema to build payloads
-└── validation.ts (exports from rules.ts for backwards compatibility)
-```
-
-> **Note**: The `schemas/` folder keeps runtime validation and inferred types colocated but organised by concern.
-
----
-
-## Workstreams & Tasks
-
-### 1. Core Domain Modules
-
-- [ ] Rewrite `contract.ts` to expose `ORDER_TYPE`, `ORDER_STATUS`, `ACTIVATION_TYPE`, and other business constants only.
-- [ ] Create `schemas/read-model.schema.ts`, `schemas/write-model.schema.ts`, `schemas/fulfillment.schema.ts`, and `schemas/query.schema.ts`.
-  - [ ] Move relevant sections from the existing `schema.ts` into those files.
-  - [ ] Export inferred types alongside each schema.
-- [ ] Introduce `rules.ts` housing SKU/business helpers currently in `validation.ts`.
-  - [ ] Keep `validation.ts` as a thin re-export for compatibility (mark for deprecation).
-- [ ] Update `index.ts` to surface the new modules explicitly.
-
-### 2. Salesforce Provider Pipeline
-
-- [ ] Add `field-map.schema.ts` with a Zod schema that validates the dynamic field map coming from configuration.
-  - [ ] Export a `createFieldResolver(config)` helper that normalises and memoises accessors.
-- [ ] Replace `field-map.mapper.ts` with `raw.schema.ts`, `normalizer.ts`, and `mapper.ts`.
-  - [ ] Parse raw Salesforce records via `raw.schema.ts`.
-  - [ ] Apply the field resolver in `normalizer.ts` to produce typed intermediate structures.
-  - [ ] Feed intermediates into read-model schemas inside `mapper.ts` (no `Reflect.get`).
-- [ ] Update `query.ts` to consume the same resolver so the BFF and mapper stay in sync.
-
-### 3. WHMCS Provider
-
-- [ ] Replace inline Zod definitions in `providers/whmcs/mapper.ts` with imports from `schemas/fulfillment.schema.ts`.
-- [ ] Ensure payload building reuses shared helpers (e.g. billing-cycle normaliser) and export them for testing.
-- [ ] Expand `raw.schema.ts` to cover response parsing where we currently trust types.
-
-### 4. Public API & Backwards Compatibility
-
-- [ ] Adjust `packages/domain/orders/index.ts` to export:
-  - Business constants from `contract.ts`.
-  - Schemas/types from `schemas/*`.
-  - Business helpers from `rules.ts`.
-  - Provider modules via a consolidated `Providers` namespace.
-- [ ] Provide compatibility re-exports for previous paths (`validation.ts`, existing provider raw types) and document deprecations.
-
-### 5. Integration Touchpoints
-
-- [ ] Update `apps/bff/src/core/config/field-map.ts` to import `createFieldResolver` and use the generated select lists.
-- [ ] Update services (`order-orchestrator`, `order-validator`) to consume new exports (`rules`, resolver helpers).
-- [ ] Add focused unit tests around the resolver, Salesforce normaliser, and WHMCS mapper changes.
-
----
-
-## Implementation Order
-
-1. **Create new schema modules** alongside the existing `schema.ts`, export them, and update imports progressively.
-2. **Introduce the Salesforce field-map schema/resolver** and migrate providers/BFF to use it.
-3. **Refactor provider mappers** to run through the new normaliser/mapper pipeline.
-4. **Trim the legacy modules** once callers are updated (delete old `schema.ts` sections, replace with barrel exports).
-5. **Finalize `index.ts` and deprecation notes**, then run type checks/tests.
-
----
-
-## Acceptance Criteria
-
-- Orders domain mirrors the modular structure outlined above.
-- Field-map configuration fails fast when misconfigured and is reused everywhere.
-- Provider mappers no longer rely on unchecked property access.
-- Business rule helpers are in `rules.ts` with tests demonstrating reuse.
-- BFF compiles against the new API surface, and manual order flows pass.
-
-
-
-## Next Steps
-
-1. Socialise this plan with the team and confirm the module naming/placement fits the broader architecture.
-2. Kick off Workstream 1 to get the new schemas and constants in place.
-3. Build the Salesforce resolver and migrate the BFF configuration service.
-4. Continue through the remaining workstreams, validating with tests at each step.
-
-Ready to proceed once reviewers sign off on the structure. 🚀

packages/domain/orders/RESTRUCTURING-SUMMARY.md

@@ -1,55 +0,0 @@
-# Orders Domain Restructuring – Executive Summary
-
-## Core Issues
-
-- `contract.ts` currently mixes business concepts, provider configuration, and schema exports, so the public surface is confusing.
-- `schema.ts` lumps read models, write models, fulfillment artefacts, and business refinements into one file, which makes targeted reuse difficult.
-- Salesforce mapping depends on unchecked configuration (`Reflect.get`) and duplicated field lists between the domain and BFF config service.
-- WHMCS mapping redefines schemas inline instead of sharing the fulfillment schema, so drift is likely.
-
-## Guiding Principles
-
-1. **Schema-first**: continue deriving types from Zod, but organise schemas by concern (`read-model`, `write-model`, `fulfillment`, `query`).
-2. **Provider isolation**: keep vendor-specific configuration, raw parsing, and mapping under `providers/{vendor}` with runtime validation.
-3. **Reusable business rules**: expose SKU rules and other cross-field checks from a dedicated `rules.ts`, keeping schema definitions focused.
-4. **Single source of truth**: validate Salesforce field maps once via a resolver that both mappers and query builders consume.
-
-## Planned Structure (Highlights)
-
-```
-orders/
-├── contract.ts                # Business enums/constants
-├── schemas/                   # Read/write/fulfillment/query Zod modules
-├── rules.ts                   # SKU & business helpers (re-exported by validation.ts)
-├── providers/
-│   ├── salesforce/
-│   │   ├── field-map.schema.ts   # Validated config + resolver
-│   │   ├── raw.schema.ts         # Raw Order / OrderItem / Product2 Zod schemas
-│   │   ├── normalizer.ts         # Applies resolver to raw data
-│   │   └── mapper.ts             # Emits read-model shapes
-│   └── whmcs/
-│       ├── raw.schema.ts         # WHMCS payload/response schemas
-│       └── mapper.ts             # Builds payloads using fulfillment schema
-└── validation.ts (compat)     # Re-exports from rules.ts
-```
-
-## Key Workstreams
-
-1. **Core domain** – rewrite `contract.ts`, split schemas into dedicated modules, move business helpers into `rules.ts`, update `index.ts`.
-2. **Salesforce pipeline** – add `field-map.schema.ts`, replace reflection with resolver-based normalisation, share select lists between domain and BFF.
-3. **WHMCS pipeline** – reuse fulfillment schema, expose pure mapping helpers, expand raw schema coverage.
-4. **Public API** – surface new modules cleanly and keep compatibility exports where necessary.
-5. **Integration updates** – adjust BFF field-map service and order services to the new resolver and helper exports; add unit tests.
-
-## Why Separate Validation?
-
-Schema modules enforce structure, while SKU/business rules are scenario-specific and reused in multiple runtime contexts (frontend wizard, BFF services, background jobs). Housing them in `rules.ts` keeps them importable without dragging in heavy schemas and avoids circular dependencies.
-
-## Success Criteria
-
-- Field-map misconfiguration surfaces as domain-level validation errors.
-- Provider mappers operate on parsed, typed intermediates with no `Reflect.get`.
-- Business rules stay accessible via `rules.ts` while existing imports continue to work through `validation.ts`.
-- BFF compiles against the new API surface and automated tests cover the resolver and mapping pipelines.
-
-With these changes, the orders domain will follow the same clean architecture as the rest of the platform, improving maintainability and onboarding. Ready for implementation once the team approves this direction. 🚀

packages/domain/orders/contract.ts

@@ -9,6 +9,67 @@ import type { SalesforceProductFieldMap } from "../catalog/contract";
 import type { SalesforceAccountFieldMap } from "../customer/contract";
 import type { UserIdMapping } from "../mappings/contract";
 
+// ============================================================================
+// Order Type Constants
+// ============================================================================
+
+/**
+ * Order types available in the system
+ */
+export const ORDER_TYPE = {
+  INTERNET: "Internet",
+  SIM: "SIM",
+  VPN: "VPN",
+  OTHER: "Other",
+} as const;
+
+export type OrderTypeValue = (typeof ORDER_TYPE)[keyof typeof ORDER_TYPE];
+
+// ============================================================================
+// Order Status Constants
+// ============================================================================
+
+/**
+ * Possible order statuses
+ */
+export const ORDER_STATUS = {
+  DRAFT: "Draft",
+  ACTIVATED: "Activated",
+  PENDING: "Pending",
+  FAILED: "Failed",
+  CANCELLED: "Cancelled",
+} as const;
+
+export type OrderStatusValue = (typeof ORDER_STATUS)[keyof typeof ORDER_STATUS];
+
+// ============================================================================
+// Activation Type Constants
+// ============================================================================
+
+/**
+ * Order activation types
+ */
+export const ACTIVATION_TYPE = {
+  IMMEDIATE: "Immediate",
+  SCHEDULED: "Scheduled",
+} as const;
+
+export type ActivationTypeValue = (typeof ACTIVATION_TYPE)[keyof typeof ACTIVATION_TYPE];
+
+// ============================================================================
+// SIM Type Constants
+// ============================================================================
+
+/**
+ * SIM card types
+ */
+export const SIM_TYPE = {
+  ESIM: "eSIM",
+  PHYSICAL: "Physical SIM",
+} as const;
+
+export type SimTypeValue = (typeof SIM_TYPE)[keyof typeof SIM_TYPE];
+
 // ============================================================================
 // Business Types (used internally, not validated at API boundary)
 // ============================================================================
@@ -34,10 +95,14 @@ export type OrderType = string;
 export type UserMapping = Pick<UserIdMapping, "userId" | "whmcsClientId" | "sfAccountId">;
 
 // ============================================================================
-// Salesforce Field Mapping (Provider-Specific, Not Validated)
+// Salesforce Field Configuration (Provider-Specific, Not Validated)
 // ============================================================================
 
-export interface SalesforceOrderMnpFieldMap {
+/**
+ * Configuration for MNP (Mobile Number Portability) field mappings.
+ * Maps logical field names to actual Salesforce custom field names.
+ */
+export interface SalesforceOrderMnpFieldConfig {
   application: string;
   reservationNumber: string;
   expiryDate: string;
@@ -51,7 +116,11 @@ export interface SalesforceOrderMnpFieldMap {
   portingGender: string;
 }
 
-export interface SalesforceOrderBillingFieldMap {
+/**
+ * Configuration for billing address field mappings.
+ * Maps logical field names to actual Salesforce custom field names.
+ */
+export interface SalesforceOrderBillingFieldConfig {
   street: string;
   city: string;
   state: string;
@@ -59,7 +128,11 @@ export interface SalesforceOrderBillingFieldMap {
   country: string;
 }
 
-export interface SalesforceOrderFieldMap {
+/**
+ * Configuration for Order field mappings.
+ * Maps logical field names to actual Salesforce custom field names.
+ */
+export interface SalesforceOrderFieldConfig {
   orderType: string;
   activationType: string;
   activationScheduledAt: string;
@@ -74,25 +147,33 @@ export interface SalesforceOrderFieldMap {
   eid: string;
   simVoiceMail: string;
   simCallWaiting: string;
-  mnp: SalesforceOrderMnpFieldMap;
+  mnp: SalesforceOrderMnpFieldConfig;
   whmcsOrderId: string;
   lastErrorCode?: string;
   lastErrorMessage?: string;
   lastAttemptAt?: string;
   addressChanged: string;
-  billing: SalesforceOrderBillingFieldMap;
+  billing: SalesforceOrderBillingFieldConfig;
 }
 
-export interface SalesforceOrderItemFieldMap {
+/**
+ * Configuration for OrderItem field mappings.
+ * Maps logical field names to actual Salesforce custom field names.
+ */
+export interface SalesforceOrderItemFieldConfig {
   billingCycle: string;
   whmcsServiceId: string;
 }
 
-export interface SalesforceFieldMap {
+/**
+ * Complete Salesforce field configuration for orders.
+ * Aggregates all field configurations needed for order operations.
+ */
+export interface SalesforceOrdersFieldConfig {
   account: SalesforceAccountFieldMap;
   product: SalesforceProductFieldMap;
-  order: SalesforceOrderFieldMap;
-  orderItem: SalesforceOrderItemFieldMap;
+  order: SalesforceOrderFieldConfig;
+  orderItem: SalesforceOrderItemFieldConfig;
 }
 
 // ============================================================================

packages/domain/orders/index.ts

@@ -11,11 +11,11 @@ export { type OrderCreationType, type OrderStatus, type OrderType, type UserMapp
 
 // Provider-specific types
 export type {
-  SalesforceOrderMnpFieldMap,
-  SalesforceOrderBillingFieldMap,
-  SalesforceOrderFieldMap,
-  SalesforceOrderItemFieldMap,
-  SalesforceFieldMap,
+  SalesforceOrderMnpFieldConfig,
+  SalesforceOrderBillingFieldConfig,
+  SalesforceOrderFieldConfig,
+  SalesforceOrderItemFieldConfig,
+  SalesforceOrdersFieldConfig,
 } from "./contract";
 
 // Schemas (includes derived types)
@@ -51,3 +51,4 @@ export * as Providers from "./providers";
 // Re-export provider types for convenience
 export * from "./providers/whmcs/raw.types";
 export * from "./providers/salesforce/raw.types";
+export * from "./providers/salesforce/query";

packages/domain/orders/providers/index.ts

@@ -4,7 +4,7 @@
 
 import * as WhmcsMapper from "./whmcs/mapper";
 import * as WhmcsRaw from "./whmcs/raw.types";
-import * as SalesforceFieldMapMapper from "./salesforce/field-map.mapper";
+import * as SalesforceMapper from "./salesforce/mapper";
 import * as SalesforceQuery from "./salesforce/query";
 import * as SalesforceRaw from "./salesforce/raw.types";
 
@@ -15,8 +15,8 @@ export const Whmcs = {
 };
 
 export const Salesforce = {
-  ...SalesforceFieldMapMapper,
-  mapper: SalesforceFieldMapMapper,
+  ...SalesforceMapper,
+  mapper: SalesforceMapper,
   query: SalesforceQuery,
   raw: SalesforceRaw,
 };
@@ -24,12 +24,12 @@ export const Salesforce = {
 export {
   WhmcsMapper,
   WhmcsRaw,
-  SalesforceFieldMapMapper,
+  SalesforceMapper,
   SalesforceQuery,
   SalesforceRaw,
 };
 export * from "./whmcs/mapper";
 export * from "./whmcs/raw.types";
-export * from "./salesforce/field-map.mapper";
+export * from "./salesforce/mapper";
 export * from "./salesforce/query";
 export * from "./salesforce/raw.types";

packages/domain/orders/providers/salesforce/index.ts

@@ -1,3 +1,3 @@
 export * from "./raw.types";
-export * from "./field-map.mapper";
+export * from "./mapper";
 export * from "./query";

packages/domain/orders/providers/salesforce/mapper.ts

@@ -1,8 +1,7 @@
 /**
- * Orders Domain - Salesforce Mapper (Field Map aware)
+ * Orders Domain - Salesforce Provider Mapper
  *
- * Transforms Salesforce Order and OrderItem records into domain contracts
- * while respecting dynamic field mappings provided by the application.
+ * Transforms Salesforce Order and OrderItem records into domain contracts.
  */
 
 import type {
@@ -10,7 +9,6 @@ import type {
   OrderItemDetails,
   OrderItemSummary,
   OrderSummary,
-  SalesforceFieldMap,
 } from "../../contract";
 import { orderDetailsSchema, orderSummarySchema, orderItemDetailsSchema } from "../../schema";
 import type {
@@ -20,12 +18,10 @@ import type {
 } from "./raw.types";
 
 /**
- * Transform a Salesforce OrderItem record into domain details + summary
- * using the provided field map for dynamic fields.
+ * Transform a Salesforce OrderItem record into domain details + summary.
  */
 export function transformSalesforceOrderItem(
-  record: SalesforceOrderItemRecord,
-  fieldMap: SalesforceFieldMap
+  record: SalesforceOrderItemRecord
 ): { details: OrderItemDetails; summary: OrderItemSummary } {
   const product = record.PricebookEntry?.Product2 ?? undefined;
 
@@ -35,17 +31,17 @@ export function transformSalesforceOrderItem(
     quantity: normalizeQuantity(record.Quantity),
     unitPrice: coerceNumber(record.UnitPrice),
     totalPrice: coerceNumber(record.TotalPrice),
-    billingCycle: pickOrderItemString(record, "billingCycle", fieldMap),
+    billingCycle: record.Billing_Cycle__c ?? undefined,
     product: product
       ? {
           id: product.Id ?? undefined,
-          name: pickProductString(product, "Name"),
-          sku: pickProductString(product, fieldMap.product.sku),
-          itemClass: pickProductString(product, fieldMap.product.itemClass),
-          whmcsProductId: pickProductString(product, fieldMap.product.whmcsProductId),
-          internetOfferingType: pickProductString(product, fieldMap.product.internetOfferingType),
-          internetPlanTier: pickProductString(product, fieldMap.product.internetPlanTier),
-          vpnRegion: pickProductString(product, fieldMap.product.vpnRegion),
+          name: product.Name ?? undefined,
+          sku: product.StockKeepingUnit ?? undefined,
+          itemClass: product.Item_Class__c ?? undefined,
+          whmcsProductId: product.WH_Product_ID__c ? String(product.WH_Product_ID__c) : undefined,
+          internetOfferingType: product.Internet_Offering_Type__c ?? undefined,
+          internetPlanTier: product.Internet_Plan_Tier__c ?? undefined,
+          vpnRegion: product.VPN_Region__c ?? undefined,
         }
       : undefined,
   });
@@ -71,28 +67,27 @@ export function transformSalesforceOrderItem(
  */
 export function transformSalesforceOrderDetails(
   order: SalesforceOrderRecord,
-  itemRecords: SalesforceOrderItemRecord[],
-  fieldMap: SalesforceFieldMap
+  itemRecords: SalesforceOrderItemRecord[]
 ): OrderDetails {
   const transformedItems = itemRecords.map(record =>
-    transformSalesforceOrderItem(record, fieldMap)
+    transformSalesforceOrderItem(record)
   );
 
   const items = transformedItems.map(item => item.details);
   const itemsSummary = transformedItems.map(item => item.summary);
 
-  const summary = buildOrderSummary(order, itemsSummary, fieldMap);
+  const summary = buildOrderSummary(order, itemsSummary);
 
   return orderDetailsSchema.parse({
     ...summary,
     accountId: order.AccountId ?? undefined,
     accountName: typeof order.Account?.Name === "string" ? order.Account.Name : undefined,
     pricebook2Id: order.Pricebook2Id ?? undefined,
-    activationType: getOrderStringField(order, "activationType", fieldMap),
+    activationType: order.Activation_Type__c ?? undefined,
     activationStatus: summary.activationStatus,
-    activationScheduledAt: getOrderStringField(order, "activationScheduledAt", fieldMap),
-    activationErrorCode: getOrderStringField(order, "lastErrorCode", fieldMap),
-    activationErrorMessage: getOrderStringField(order, "lastErrorMessage", fieldMap),
+    activationScheduledAt: order.Activation_Scheduled_At__c ?? undefined,
+    activationErrorCode: order.Activation_Error_Code__c ?? undefined,
+    activationErrorMessage: order.Activation_Error_Message__c ?? undefined,
     activatedDate: typeof order.ActivatedDate === "string" ? order.ActivatedDate : undefined,
     items,
   });
@@ -103,28 +98,17 @@ export function transformSalesforceOrderDetails(
  */
 export function transformSalesforceOrderSummary(
   order: SalesforceOrderRecord,
-  itemRecords: SalesforceOrderItemRecord[],
-  fieldMap: SalesforceFieldMap
+  itemRecords: SalesforceOrderItemRecord[]
 ): OrderSummary {
   const itemsSummary = itemRecords.map(record =>
-    transformSalesforceOrderItem(record, fieldMap).summary
+    transformSalesforceOrderItem(record).summary
   );
-  return buildOrderSummary(order, itemsSummary, fieldMap);
+  return buildOrderSummary(order, itemsSummary);
 }
 
-type OrderFieldKey =
-  | "orderType"
-  | "activationType"
-  | "activationStatus"
-  | "activationScheduledAt"
-  | "whmcsOrderId"
-  | "lastErrorCode"
-  | "lastErrorMessage";
-
 function buildOrderSummary(
   order: SalesforceOrderRecord,
-  itemsSummary: OrderItemSummary[],
-  fieldMap: SalesforceFieldMap
+  itemsSummary: OrderItemSummary[]
 ): OrderSummary {
   const effectiveDate =
     ensureString(order.EffectiveDate) ??
@@ -138,42 +122,17 @@ function buildOrderSummary(
     id: order.Id,
     orderNumber: ensureString(order.OrderNumber) ?? order.Id,
     status: ensureString(order.Status) ?? "Unknown",
-    orderType: getOrderStringField(order, "orderType", fieldMap) ?? ensureString(order.Type),
+    orderType: order.Type ?? undefined,
     effectiveDate,
     totalAmount: typeof totalAmount === "number" ? totalAmount : undefined,
     createdDate,
     lastModifiedDate,
-    whmcsOrderId: getOrderStringField(order, "whmcsOrderId", fieldMap),
-    activationStatus: getOrderStringField(order, "activationStatus", fieldMap),
+    whmcsOrderId: order.WHMCS_Order_ID__c ?? undefined,
+    activationStatus: order.Activation_Status__c ?? undefined,
     itemsSummary,
   });
 }
 
-function pickProductString(product: SalesforceProduct2Record, field: string): string | undefined {
-  return ensureString(Reflect.get(product, field));
-}
-
-function pickOrderItemString(
-  record: SalesforceOrderItemRecord,
-  key: keyof SalesforceFieldMap["orderItem"],
-  fieldMap: SalesforceFieldMap
-): string | undefined {
-  const fieldName = fieldMap.orderItem[key];
-  return ensureString(Reflect.get(record, fieldName));
-}
-
-function getOrderStringField(
-  order: SalesforceOrderRecord,
-  key: OrderFieldKey,
-  fieldMap: SalesforceFieldMap
-): string | undefined {
-  const fieldName = fieldMap.order[key];
-  if (typeof fieldName !== "string") {
-    return undefined;
-  }
-  return ensureString(Reflect.get(order, fieldName));
-}
-
 function ensureString(value: unknown): string | undefined {
   return typeof value === "string" ? value : undefined;
 }

packages/domain/orders/providers/salesforce/query.ts

@@ -1,54 +1,50 @@
 /**
  * Orders Domain - Salesforce Query Helpers
  *
- * Generates the field lists required to hydrate domain mappers when querying Salesforce.
+ * Generates the field lists required for querying Salesforce Orders and OrderItems.
  */
 
-import type { SalesforceFieldMap } from "../../contract";
-
 const UNIQUE = <T>(values: T[]): T[] => Array.from(new Set(values));
 
 export function buildOrderSelectFields(
-  fieldMap: SalesforceFieldMap,
   additional: string[] = []
 ): string[] {
   const fields = [
     "Id",
     "AccountId",
     "Status",
+    "Type",
     "EffectiveDate",
     "OrderNumber",
     "TotalAmount",
     "CreatedDate",
     "LastModifiedDate",
     "Pricebook2Id",
-    fieldMap.order.orderType,
-    fieldMap.order.activationType,
-    fieldMap.order.activationScheduledAt,
-    fieldMap.order.activationStatus,
-    fieldMap.order.internetPlanTier,
-    fieldMap.order.installationType,
-    fieldMap.order.weekendInstall,
-    fieldMap.order.accessMode,
-    fieldMap.order.hikariDenwa,
-    fieldMap.order.vpnRegion,
-    fieldMap.order.simType,
-    fieldMap.order.simVoiceMail,
-    fieldMap.order.simCallWaiting,
-    fieldMap.order.eid,
-    fieldMap.order.whmcsOrderId,
-    fieldMap.order.addressChanged,
+    "Activation_Type__c",
+    "Activation_Status__c",
+    "Activation_Scheduled_At__c",
+    "Activation_Error_Code__c",
+    "Activation_Error_Message__c",
+    "Activation_Last_Attempt_At__c",
+    "ActivatedDate",
+    "Internet_Plan_Tier__c",
+    "Installment_Plan__c",
+    "Access_Mode__c",
+    "Weekend_Install__c",
+    "Hikari_Denwa__c",
+    "VPN_Region__c",
+    "SIM_Type__c",
+    "SIM_Voice_Mail__c",
+    "SIM_Call_Waiting__c",
+    "EID__c",
+    "WHMCS_Order_ID__c",
+    "Address_Changed__c",
   ];
 
-  if (fieldMap.order.lastErrorCode) fields.push(fieldMap.order.lastErrorCode);
-  if (fieldMap.order.lastErrorMessage) fields.push(fieldMap.order.lastErrorMessage);
-  if (fieldMap.order.lastAttemptAt) fields.push(fieldMap.order.lastAttemptAt);
-
   return UNIQUE([...fields, ...additional]);
 }
 
 export function buildOrderItemSelectFields(
-  fieldMap: SalesforceFieldMap,
   additional: string[] = []
 ): string[] {
   const fields = [
@@ -58,27 +54,26 @@ export function buildOrderItemSelectFields(
     "UnitPrice",
     "TotalPrice",
     "PricebookEntry.Id",
-    fieldMap.orderItem.billingCycle,
-    fieldMap.orderItem.whmcsServiceId,
+    "Billing_Cycle__c",
+    "WHMCS_Service_ID__c",
   ];
 
   return UNIQUE([...fields, ...additional]);
 }
 
 export function buildOrderItemProduct2Fields(
-  fieldMap: SalesforceFieldMap,
   additional: string[] = []
 ): string[] {
   const fields = [
     "Id",
     "Name",
-    fieldMap.product.sku,
-    fieldMap.product.whmcsProductId,
-    fieldMap.product.itemClass,
-    fieldMap.product.billingCycle,
-    fieldMap.product.internetOfferingType,
-    fieldMap.product.internetPlanTier,
-    fieldMap.product.vpnRegion,
+    "StockKeepingUnit",
+    "Item_Class__c",
+    "Billing_Cycle__c",
+    "WH_Product_ID__c",
+    "Internet_Offering_Type__c",
+    "Internet_Plan_Tier__c",
+    "VPN_Region__c",
   ];
 
   return UNIQUE([...fields, ...additional]);

packages/domain/orders/providers/salesforce/raw.types.ts

@@ -113,23 +113,57 @@ export const salesforceOrderRecordSchema = z.object({
   AccountId: z.string().nullable().optional(),
   Account: z.object({ Name: z.string().nullable().optional() }).nullable().optional(),
   Pricebook2Id: z.string().nullable().optional(),
+  
+  // Activation fields
   Activation_Type__c: z.string().nullable().optional(),
   Activation_Status__c: z.string().nullable().optional(),
   Activation_Scheduled_At__c: z.string().nullable().optional(),
+  Activation_Error_Code__c: z.string().nullable().optional(),
+  Activation_Error_Message__c: z.string().nullable().optional(),
+  Activation_Last_Attempt_At__c: z.string().nullable().optional(),
+  ActivatedDate: z.string().nullable().optional(),
+  
+  // Internet fields
   Internet_Plan_Tier__c: z.string().nullable().optional(),
   Installment_Plan__c: z.string().nullable().optional(),
   Access_Mode__c: z.string().nullable().optional(),
   Weekend_Install__c: z.boolean().nullable().optional(),
   Hikari_Denwa__c: z.boolean().nullable().optional(),
+  
+  // VPN fields
   VPN_Region__c: z.string().nullable().optional(),
+  
+  // SIM fields
   SIM_Type__c: z.string().nullable().optional(),
   SIM_Voice_Mail__c: z.boolean().nullable().optional(),
   SIM_Call_Waiting__c: z.boolean().nullable().optional(),
   EID__c: z.string().nullable().optional(),
+  
+  // MNP (Mobile Number Portability) fields
+  MNP_Application__c: z.string().nullable().optional(),
+  MNP_Reservation_Number__c: z.string().nullable().optional(),
+  MNP_Expiry_Date__c: z.string().nullable().optional(),
+  MNP_Phone_Number__c: z.string().nullable().optional(),
+  MVNO_Account_Number__c: z.string().nullable().optional(),
+  Porting_Date_Of_Birth__c: z.string().nullable().optional(),
+  Porting_First_Name__c: z.string().nullable().optional(),
+  Porting_Last_Name__c: z.string().nullable().optional(),
+  Porting_First_Name_Katakana__c: z.string().nullable().optional(),
+  Porting_Last_Name_Katakana__c: z.string().nullable().optional(),
+  Porting_Gender__c: z.string().nullable().optional(),
+  
+  // Billing address snapshot fields
+  Billing_Street__c: z.string().nullable().optional(),
+  Billing_City__c: z.string().nullable().optional(),
+  Billing_State__c: z.string().nullable().optional(),
+  Billing_Postal_Code__c: z.string().nullable().optional(),
+  Billing_Country__c: z.string().nullable().optional(),
+  
+  // Other fields
+  Address_Changed__c: z.boolean().nullable().optional(),
   WHMCS_Order_ID__c: z.string().nullable().optional(),
-  Activation_Error_Code__c: z.string().nullable().optional(),
-  Activation_Error_Message__c: z.string().nullable().optional(),
-  ActivatedDate: z.string().nullable().optional(),
+  
+  // Audit fields
   CreatedDate: z.string().optional(),
   LastModifiedDate: z.string().optional(),
 });