Anti-Corruption Layers

// Legacy ERP response — their model, their conventions
{
  "CUST_NO": "C-10045",
  "ORD_DT": "20260101",
  "PROD_LIST": [
    { "PROD_CD": "WDG-001", "QTY": 3, "PRC_UNIT": "12.50", "UOM": "EA" }
  ],
  "TOT_AMT": "37.50",
  "STS_CD": "O"  // O = Open, C = Closed, H = Hold
}

// Anti-pattern: legacy concepts leak into domain
public class Order {
    private String CUST_NO;       // ← legacy naming convention
    private String ORD_DT;        // ← string date from external system
    private String STS_CD;        // ← external status codes
}

// ACL Translator: knows both languages, exposes only domain language outward
public class ErpOrderTranslator {
 
    public Order toDomain(ErpOrderDocument erpDoc) {
        return Order.reconstitute(
            new OrderId(erpDoc.getOrderNumber()),
            translateCustomerId(erpDoc.getCustNo()),
            translateStatus(erpDoc.getStsCode()),
            erpDoc.getProdList().stream()
                .map(this::translateLineItem)
                .toList(),
            parseErpDate(erpDoc.getOrdDt())
        );
    }
 
    public ErpOrderDocument toErp(Order order) {
        ErpOrderDocument doc = new ErpOrderDocument();
        doc.setCustNo(order.getCustomerId().toErpFormat());
        doc.setOrdDt(formatErpDate(order.getOrderDate()));
        doc.setStsCode(translateStatusToErp(order.getStatus()));
        doc.setProdList(order.getLineItems().stream()
            .map(this::translateLineItemToErp)
            .toList());
        return doc;
    }
 
    private OrderStatus translateStatus(String erpStatusCode) {
        return switch (erpStatusCode) {
            case "O" -> OrderStatus.OPEN;
            case "C" -> OrderStatus.CLOSED;
            case "H" -> OrderStatus.ON_HOLD;
            default -> throw new UnknownErpStatusException(erpStatusCode);
        };
    }
 
    private String translateStatusToErp(OrderStatus status) {
        return switch (status) {
            case OPEN -> "O";
            case CLOSED -> "C";
            case ON_HOLD -> "H";
            case CANCELLED -> throw new IllegalArgumentException(
                "ERP does not support CANCELLED status — handle upstream"
            );
        };
    }
 
    private LocalDate parseErpDate(String erpDate) {
        return LocalDate.parse(erpDate, DateTimeFormatter.ofPattern("yyyyMMdd"));
    }
}

// Port: domain-level interface
interface LegacyErpGateway {
  fetchOrder(orderId: OrderId): Promise<Order>;
  submitOrder(order: Order): Promise<ErpOrderReference>;
}
 
// Adapter: implements the port, hides ERP details
class ErpHttpGateway implements LegacyErpGateway {
  constructor(
    private readonly httpClient: HttpClient,
    private readonly translator: ErpOrderTranslator,
    private readonly baseUrl: string,
  ) {}
 
  async fetchOrder(orderId: OrderId): Promise<Order> {
    const response = await this.httpClient.get(
      `${this.baseUrl}/orders/${orderId.value}`,
      { headers: this.erpAuthHeaders() }
    );
 
    if (!response.ok) {
      throw new ErpIntegrationException(`ERP returned ${response.status}`);
    }
 
    const erpDoc: ErpOrderDocument = await response.json();
    return this.translator.toDomain(erpDoc);
  }
 
  async submitOrder(order: Order): Promise<ErpOrderReference> {
    const erpDoc = this.translator.toErp(order);
    const response = await this.httpClient.post(
      `${this.baseUrl}/orders`,
      erpDoc,
      { headers: this.erpAuthHeaders() }
    );
    return new ErpOrderReference(response.headers.get('X-ERP-Order-ID')!);
  }
 
  private erpAuthHeaders(): Record<string, string> {
    return { 'X-ERP-API-Key': process.env.ERP_API_KEY! };
  }
}