DTO Mapping Strategies

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104

// Manual Mapper - Explicit Field-by-Field Mapping
class OrderMapper {
    
    // Domain object → Response DTO
    toResponseDTO(order: Order): OrderResponseDTO {
        return {
            orderId: order.id.value,
            orderNumber: order.orderNumber,
            status: this.mapStatus(order.status),
            createdAt: order.createdAt.toISOString(),
            updatedAt: order.updatedAt.toISOString(),
            
            customer: {
                customerId: order.customer.id.value,
                name: order.customer.fullName,
                email: order.customer.email.value,
            },
            
            subtotalCents: order.subtotal.amountInCents,
            discountCents: order.discount.amountInCents,
            taxCents: order.tax.amountInCents,
            shippingCents: order.shippingCost.amountInCents,
            totalCents: order.total.amountInCents,
            currency: order.currency.code,
            
            items: order.items.map(item => this.toOrderItemDTO(item)),
            
            shippingAddress: this.toAddressDTO(order.shippingAddress),
            billingAddress: this.toAddressDTO(order.billingAddress),
            
            isEditable: order.canBeEdited(),
            isCancellable: order.canBeCancelled(),
            estimatedDeliveryDate: order.estimatedDelivery?.toISOString() ?? null,
            
            links: {
                self: `/orders/${order.id.value}`,
                customer: `/customers/${order.customer.id.value}`,
                cancel: order.canBeCancelled() 
                    ? `/orders/${order.id.value}/cancel` 
                    : null,
                trackShipment: order.tracking?.url ?? null,
            },
        };
    }
    
    // Request DTO → Create command (domain-friendly)
    toCreateCommand(dto: CreateOrderRequestDTO): CreateOrderCommand {
        return new CreateOrderCommand(
            new CustomerId(dto.customerId),
            dto.items.map(item => ({
                productId: new ProductId(item.productId),
                quantity: Quantity.of(item.quantity),
            })),
            new PaymentMethodId(dto.paymentMethodId),
            dto.couponCode ? new CouponCode(dto.couponCode) : null
        );
    }
    
    // Helper mappers
    private toOrderItemDTO(item: OrderItem): OrderItemDTO {
        return {
            lineItemId: item.id.value,
            productId: item.product.id.value,
            productName: item.product.name,
            productImageUrl: item.product.primaryImageUrl,
            sku: item.product.sku.value,
            quantity: item.quantity.value,
            unitPriceCents: item.unitPrice.amountInCents,
            lineTotalCents: item.lineTotal.amountInCents,
        };
    }
    
    private toAddressDTO(address: Address): AddressDTO {
        return {
            line1: address.line1,
            line2: address.line2 ?? null,
            city: address.city,
            state: address.state,
            postalCode: address.postalCode.value,
            country: address.country.code,
        };
    }
    
    private mapStatus(status: OrderStatus): string {
        // Explicit mapping allows for contract stability
        // even if internal enum values change
        switch (status) {
            case OrderStatus.PENDING_PAYMENT:
            case OrderStatus.PAYMENT_PROCESSING:
                return 'pending';
            case OrderStatus.CONFIRMED:
            case OrderStatus.PREPARING:
                return 'processing';
            case OrderStatus.SHIPPED:
            case OrderStatus.IN_TRANSIT:
                return 'shipped';
            case OrderStatus.DELIVERED:
                return 'delivered';
            case OrderStatus.CANCELLED:
            case OrderStatus.REFUNDED:
                return 'cancelled';
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86

// === EXAMPLE 1: AutoMapper (@automapper/core) ===
 
// Define mapping profile
import { createMap, forMember, mapFrom, Mapper } from '@automapper/core';
 
function createMappingProfile(mapper: Mapper) {
    // Convention-based: matches same-named properties automatically
    createMap<Order, OrderResponseDTO>(
        mapper,
        Order,
        OrderResponseDTO,
        // Custom mappings for non-matching fields
        forMember(
            dest => dest.orderId,
            mapFrom(src => src.id.value)
        ),
        forMember(
            dest => dest.totalCents,
            mapFrom(src => src.total.amountInCents)
        ),
        forMember(
            dest => dest.customer,
            mapFrom(src => mapper.map(src.customer, Customer, CustomerSummaryDTO))
        ),
        forMember(
            dest => dest.isEditable,
            mapFrom(src => src.canBeEdited())
        )
    );
}
 
// Usage
const dto = mapper.map(order, Order, OrderResponseDTO);
 
 
// === EXAMPLE 2: class-transformer ===
 
import { Expose, Transform, Type, plainToInstance, instanceToPlain } from 'class-transformer';
 
// Decorate the DTO class with transformation rules
class OrderResponseDTO {
    @Expose({ name: 'id' })  // Map from 'id' property
    orderId: string;
    
    @Expose()
    orderNumber: string;
    
    @Transform(({ obj }) => obj.total.amountInCents)
    totalCents: number;
    
    @Type(() => OrderItemDTO)  // Handle nested objects
    items: OrderItemDTO[];
    
    @Transform(({ obj }) => obj.canBeEdited())
    isEditable: boolean;
}
 
// Usage
const dto = plainToInstance(OrderResponseDTO, order, { 
    excludeExtraneousValues: true 
});
 
 
// === EXAMPLE 3: MapStruct (Java - compile-time) ===
// Note: This generates implementation at compile time - no runtime overhead
 
// Java interface
@Mapper
public interface OrderMapper {
    
    @Mapping(source = "id.value", target = "orderId")
    @Mapping(source = "total.amountInCents", target = "totalCents")
    @Mapping(target = "isEditable", expression = "java(order.canBeEdited())")
    OrderResponseDTO toDTO(Order order);
    
    // Reverse mapping
    @Mapping(source = "orderId", target = "id", qualifiedByName = "toOrderId")
    Order toEntity(CreateOrderRequestDTO dto);
    
    @Named("toOrderId")
    default OrderId toOrderId(String value) {
        return new OrderId(value);
    }
}
 
// Generated at compile time - as fast as manual code!

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110

// === FACTORY METHOD PATTERN ===
 
class OrderResponseDTO {
    // Private constructor - can't create directly
    private constructor(
        public readonly orderId: string,
        public readonly orderNumber: string,
        public readonly status: string,
        // ... many more fields
    ) {}
    
    // Static factory method
    static fromOrder(order: Order): OrderResponseDTO {
        return new OrderResponseDTO(
            order.id.value,
            order.orderNumber,
            OrderStatusMapper.toApiStatus(order.status),
            // ... explicit mapping
        );
    }
    
    // Factory for test data
    static forTesting(overrides: Partial<OrderResponseDTO> = {}): OrderResponseDTO {
        return Object.assign(
            new OrderResponseDTO(
                'test-order-123',
                'ORD-2024-0001',
                'pending',
                // ... default test values
            ),
            overrides
        );
    }
}
 
// Usage
const dto = OrderResponseDTO.fromOrder(order);
 
 
// === BUILDER PATTERN ===
 
class OrderResponseDTOBuilder {
    private dto: Partial<OrderResponseDTO> = {};
    
    withOrder(order: Order): this {
        this.dto.orderId = order.id.value;
        this.dto.orderNumber = order.orderNumber;
        this.dto.createdAt = order.createdAt.toISOString();
        return this;
    }
    
    withStatus(status: OrderStatus): this {
        this.dto.status = OrderStatusMapper.toApiStatus(status);
        return this;
    }
    
    withPricing(order: Order): this {
        this.dto.subtotalCents = order.subtotal.amountInCents;
        this.dto.discountCents = order.discount.amountInCents;
        this.dto.taxCents = order.tax.amountInCents;
        this.dto.shippingCents = order.shippingCost.amountInCents;
        this.dto.totalCents = order.total.amountInCents;
        this.dto.currency = order.currency.code;
        return this;
    }
    
    withItems(items: OrderItem[]): this {
        this.dto.items = items.map(item => OrderItemDTO.fromItem(item));
        return this;
    }
    
    withHypermediaLinks(order: Order): this {
        this.dto.links = {
            self: `/orders/${order.id.value}`,
            cancel: order.canBeCancelled() 
                ? `/orders/${order.id.value}/cancel` 
                : null,
            // ... other links
        };
        return this;
    }
    
    // Conditional inclusions
    withCustomerIfPublic(customer: Customer, includeEmail: boolean): this {
        this.dto.customer = {
            customerId: customer.id.value,
            name: customer.fullName,
            email: includeEmail ? customer.email.value : undefined,
        };
        return this;
    }
    
    build(): OrderResponseDTO {
        // Validate required fields
        if (!this.dto.orderId) throw new Error('orderId is required');
        if (!this.dto.orderNumber) throw new Error('orderNumber is required');
        
        return this.dto as OrderResponseDTO;
    }
}
 
// Usage - clear, flexible, and self-documenting
const dto = new OrderResponseDTOBuilder()
    .withOrder(order)
    .withStatus(order.status)
    .withPricing(order)
    .withItems(order.items)
    .withCustomerIfPublic(order.customer, user.canSeeEmails())
    .withHypermediaLinks(order)
    .build();

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

// === HANDLING NESTED OBJECTS ===
 
class OrderMapper {
    constructor(
        private customerMapper: CustomerMapper,
        private addressMapper: AddressMapper,
        private itemMapper: OrderItemMapper
    ) {}
    
    toDetailDTO(order: Order): OrderDetailDTO {
        return {
            orderId: order.id.value,
            orderNumber: order.orderNumber,
            
            // Delegate nested mapping to specialized mappers
            customer: this.customerMapper.toSummaryDTO(order.customer),
            shippingAddress: this.addressMapper.toDTO(order.shippingAddress),
            billingAddress: this.addressMapper.toDTO(order.billingAddress),
            
            // Map collection with specialized mapper
            items: order.items.map(item => this.itemMapper.toDTO(item)),
            
            // Map another collection
            statusHistory: order.statusHistory.map(entry => ({
                status: entry.status.toString(),
                changedAt: entry.timestamp.toISOString(),
                changedBy: entry.actor?.name ?? 'System',
                reason: entry.reason ?? null,
            })),
        };
    }
    
    // Summary DTO doesn't include deep nesting
    toSummaryDTO(order: Order): OrderSummaryDTO {
        return {
            orderId: order.id.value,
            orderNumber: order.orderNumber,
            status: order.status.toString(),
            totalCents: order.total.amountInCents,
            itemCount: order.items.length,
            createdAt: order.createdAt.toISOString(),
            // No nested customer, address, or items - just summary data
        };
    }
}
 
 
// === HANDLING COLLECTIONS (N+1 awareness) ===
 
class OrderListMapper {
    constructor(
        private orderMapper: OrderMapper,
        private customerCache: Map<string, CustomerSummaryDTO> = new Map()
    ) {}
    
    // Batch mapping to avoid N+1 problems
    toSummaryDTOs(orders: Order[]): OrderSummaryDTO[] {
        // Pre-fetch all needed data in one batch
        const customerIds = [...new Set(orders.map(o => o.customerId.value))];
        const customers = this.customerRepository.findByIds(customerIds);
        
        // Build lookup cache
        customers.forEach(c => {
            this.customerCache.set(c.id.value, this.customerMapper.toSummaryDTO(c));
        });
        
        // Now map with cache hits, not queries
        return orders.map(order => ({
            ...this.orderMapper.toSummaryDTO(order),
            customer: this.customerCache.get(order.customerId.value)!,
        }));
    }
}
 
 
// === HANDLING OPTIONAL NESTED OBJECTS ===
 
class OrderMapper {
    toDTO(order: Order): OrderResponseDTO {
        return {
            // ... other fields ...
            
            // Optional nested object - explicitly handle null/undefined
            tracking: order.shipment 
                ? {
                    carrier: order.shipment.carrier.name,
                    trackingNumber: order.shipment.trackingNumber,
                    trackingUrl: order.shipment.trackingUrl,
                    estimatedDelivery: order.shipment.eta?.toISOString() ?? null,
                }
                : null,
            
            // Optional collection - return empty array, not null
            promoCodesApplied: order.appliedPromoCodes 
                ? order.appliedPromoCodes.map(p => p.code)
                : [],
        };
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117

// === REQUEST DTO TO DOMAIN ===
 
// The request DTO - what the client sends
interface CreateOrderRequestDTO {
    customerId: string;
    items: Array<{
        productId: string;
        quantity: number;
    }>;
    shippingAddressId: string;
    billingAddressId: string | null;  // Optional - defaults to shipping
    couponCode: string | null;
}
 
class OrderCreationMapper {
    constructor(
        private customerRepository: CustomerRepository,
        private productRepository: ProductRepository,
        private addressRepository: AddressRepository,
        private pricingService: PricingService
    ) {}
    
    // This is NOT a simple field copy!
    async toCreateCommand(
        dto: CreateOrderRequestDTO,
        requestingUserId: UserId
    ): Promise<CreateOrderCommand> {
        
        // 1. Resolve references to actual domain objects
        const customer = await this.customerRepository.findById(
            new CustomerId(dto.customerId)
        );
        if (!customer) {
            throw new CustomerNotFoundError(dto.customerId);
        }
        
        // 2. Validate authorization
        if (!customer.canBeAccessedBy(requestingUserId)) {
            throw new UnauthorizedError('Cannot create order for this customer');
        }
        
        // 3. Resolve and validate products
        const productIds = dto.items.map(i => new ProductId(i.productId));
        const products = await this.productRepository.findByIds(productIds);
        
        const missingProducts = productIds.filter(
            id => !products.some(p => p.id.equals(id))
        );
        if (missingProducts.length > 0) {
            throw new ProductsNotFoundError(missingProducts);
        }
        
        // 4. Build domain value objects
        const orderItems = dto.items.map(itemDto => {
            const product = products.find(p => p.id.value === itemDto.productId)!;
            
            // Validate product is orderable
            if (!product.isAvailable) {
                throw new ProductUnavailableError(product.id);
            }
            
            // Check stock
            if (product.stockQuantity < itemDto.quantity) {
                throw new InsufficientStockError(product.id, itemDto.quantity);
            }
            
            return OrderItem.create(
                product,
                Quantity.of(itemDto.quantity),
                this.pricingService.getPriceFor(product, customer)
            );
        });
        
        // 5. Resolve addresses
        const shippingAddress = await this.resolveAddress(
            dto.shippingAddressId, 
            customer
        );
        const billingAddress = dto.billingAddressId 
            ? await this.resolveAddress(dto.billingAddressId, customer)
            : shippingAddress;  // Default to shipping address
        
        // 6. Handle optional fields
        let coupon: Coupon | null = null;
        if (dto.couponCode) {
            coupon = await this.validateAndResolveCoupon(dto.couponCode, customer);
        }
        
        // 7. Build the command (still not the Order entity!)
        return new CreateOrderCommand(
            customer,
            orderItems,
            shippingAddress,
            billingAddress,
            coupon
        );
    }
    
    private async resolveAddress(
        addressId: string, 
        customer: Customer
    ): Promise<Address> {
        const address = await this.addressRepository.findById(
            new AddressId(addressId)
        );
        
        if (!address) {
            throw new AddressNotFoundError(addressId);
        }
        
        if (!address.belongsTo(customer)) {
            throw new UnauthorizedError('Address does not belong to customer');
        }
        
        return address;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84

// === PERFORMANCE OPTIMIZATIONS ===
 
// 1. AVOID: Mapping inside loops with dependencies
async function mapOrdersBad(orders: Order[]): Promise<OrderDTO[]> {
    const dtos: OrderDTO[] = [];
    for (const order of orders) {
        // N+1 problem: fetches customer for each order
        const customer = await customerRepo.findById(order.customerId);
        dtos.push(mapToDTO(order, customer));
    }
    return dtos;
}
 
// PREFER: Batch fetch, then map
async function mapOrdersGood(orders: Order[]): Promise<OrderDTO[]> {
    // Single batch fetch
    const customerIds = orders.map(o => o.customerId);
    const customers = await customerRepo.findByIds(customerIds);
    const customerMap = new Map(customers.map(c => [c.id.value, c]));
    
    // Now map without async
    return orders.map(order => 
        mapToDTO(order, customerMap.get(order.customerId.value)!)
    );
}
 
 
// 2. CACHE: Reuse mapper instances
class MapperRegistry {
    private static orderMapper: OrderMapper | null = null;
    
    static getOrderMapper(): OrderMapper {
        if (!this.orderMapper) {
            this.orderMapper = new OrderMapper(/* dependencies */);
        }
        return this.orderMapper;
    }
}
 
 
// 3. LAZY COMPUTED FIELDS: Only compute expensive fields when needed
class OrderResponseDTO {
    private _computedSummary: string | null = null;
    
    get summary(): string {
        if (!this._computedSummary) {
            this._computedSummary = this.computeExpensiveSummary();
        }
        return this._computedSummary;
    }
    
    // Don't include in toJSON if not accessed
    toJSON() {
        return {
            orderId: this.orderId,
            // ... other fields
            // summary only included if pre-computed
            ...(this._computedSummary && { summary: this._computedSummary }),
        };
    }
}
 
 
// 4. PROJECTION: Don't map what you don't need
class OrderRepository {
    // Instead of mapping full entities
    async findAllOrders(): Promise<Order[]> {
        return this.repository.find();  // Full ORM entities
    }
    
    // Query only needed columns
    async findOrderSummaries(): Promise<OrderSummaryDTO[]> {
        return this.repository
            .createQueryBuilder('order')
            .select([
                'order.id AS orderId',
                'order.orderNumber AS orderNumber',
                'order.status AS status',
                'order.totalCents AS totalCents',
                'order.createdAt AS createdAt',
            ])
            .getRawMany();  // Direct to DTO shape
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

// === COMPREHENSIVE MAPPER TESTS ===
 
describe('OrderMapper', () => {
    let mapper: OrderMapper;
    let testOrder: Order;
    
    beforeEach(() => {
        mapper = new OrderMapper();
        testOrder = OrderBuilder.create()
            .withAllFieldsPopulated()  // Every field has a value
            .build();
    });
    
    describe('toResponseDTO', () => {
        it('maps all basic fields correctly', () => {
            const dto = mapper.toResponseDTO(testOrder);
            
            expect(dto.orderId).toBe(testOrder.id.value);
            expect(dto.orderNumber).toBe(testOrder.orderNumber);
            expect(dto.status).toBeDefined();
            expect(dto.createdAt).toBe(testOrder.createdAt.toISOString());
        });
        
        it('maps monetary values as cents', () => {
            const dto = mapper.toResponseDTO(testOrder);
            
            expect(dto.subtotalCents).toBe(testOrder.subtotal.amountInCents);
            expect(dto.totalCents).toBe(testOrder.total.amountInCents);
            expect(typeof dto.totalCents).toBe('number');
            // Verify no floating point conversion issues
            expect(Number.isInteger(dto.totalCents)).toBe(true);
        });
        
        it('maps nested items correctly', () => {
            const dto = mapper.toResponseDTO(testOrder);
            
            expect(dto.items).toHaveLength(testOrder.items.length);
            
            dto.items.forEach((itemDto, index) => {
                const sourceItem = testOrder.items[index];
                expect(itemDto.productId).toBe(sourceItem.product.id.value);
                expect(itemDto.quantity).toBe(sourceItem.quantity.value);
            });
        });
        
        it('handles null optional fields gracefully', () => {
            const orderWithoutShipment = OrderBuilder.create()
                .withShipment(null)
                .build();
            
            const dto = mapper.toResponseDTO(orderWithoutShipment);
            
            expect(dto.tracking).toBeNull();
            expect(dto.links.trackShipment).toBeNull();
        });
        
        it('computes derived fields correctly', () => {
            const pendingOrder = OrderBuilder.create()
                .withStatus(OrderStatus.PENDING)
                .build();
            
            const dto = mapper.toResponseDTO(pendingOrder);
            
            expect(dto.isEditable).toBe(true);
            expect(dto.isCancellable).toBe(true);
        });
        
        it('maps all status values to valid API statuses', () => {
            // Test every internal status maps to a valid API status
            const allStatuses = Object.values(OrderStatus);
            const validApiStatuses = ['pending', 'processing', 'shipped', 'delivered', 'cancelled'];
            
            allStatuses.forEach(internalStatus => {
                const order = OrderBuilder.create()
                    .withStatus(internalStatus)
                    .build();
                
                const dto = mapper.toResponseDTO(order);
                
                expect(validApiStatuses).toContain(dto.status);
            });
        });
    });
    
    describe('toSummaryDTO', () => {
        it('excludes detailed fields present in response DTO', () => {
            const dto = mapper.toSummaryDTO(testOrder);
            
            // Summary should NOT have these
            expect((dto as any).items).toBeUndefined();
            expect((dto as any).shippingAddress).toBeUndefined();
            expect((dto as any).statusHistory).toBeUndefined();
        });
        
        it('includes computed summary fields', () => {
            const dto = mapper.toSummaryDTO(testOrder);
            
            expect(dto.itemCount).toBe(testOrder.items.length);
        });
    });
    
    // Regression test: ensure new fields are mapped
    it('should fail if Order entity has unmapped fields', () => {
        // This test uses reflection/schema to detect unmapped fields
        const entityFields = Object.keys(testOrder);
        const dtoFields = Object.keys(mapper.toResponseDTO(testOrder));
        
        const expectedMappings = [
            'id -> orderId',
            'orderNumber -> orderNumber',
            // Document all expected mappings
        ];
        
        // If this fails, a new field was added to Order but not mapped
        entityFields.forEach(field => {
            if (!INTENTIONALLY_UNMAPPED.includes(field)) {
                expect(expectedMappings.some(m => m.includes(field))).toBe(true);
            }
        });
    });
});