Monolith to Microservices Evolution

interface LegacyPayload {
  TXN_ID_NUM: number;
  CUST_ID: number;
  TOTAL_AMT: string;
  CURR_CODE: string;
  STATUS_FLG: number;
}

interface ModernPaymentEntity {
  paymentId: string;
  customerId: string;
  amountInCents: number;
  currency: string;
  status: 'COMPLETED' | 'FAILED';
}

export class AntiCorruptionLayer {
  static toModernPayment(legacy: LegacyPayload): ModernPaymentEntity {
    return {
      paymentId: String(legacy.TXN_ID_NUM),
      customerId: `usr_${legacy.CUST_ID}`,
      amountInCents: Math.round(parseFloat(legacy.TOTAL_AMT) * 100),
      currency: legacy.CURR_CODE.toUpperCase(),
      status: legacy.STATUS_FLG === 1 ? 'COMPLETED' : 'FAILED',
    };
  }
}

export class StranglerRouter {
  constructor(
    private monolithUrl: string,
    private microserviceUrl: string,
    private canaryPercent: number = 10
  ) {}

  async handlePayment(payload: LegacyPayload) {
    const isCanary = Math.random() * 100 <= this.canaryPercent;
    if (isCanary) {
      const modernData = AntiCorruptionLayer.toModernPayment(payload);
      const res = await fetch(`${this.microserviceUrl}/v1/payments`, {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify(modernData),
      });
      return { source: 'microservice', data: await res.json() };
    }

    const res = await fetch(`${this.monolithUrl}/legacy/payment`, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify(payload),
    });
    return { source: 'monolith', data: await res.json() };
  }
}
        

package main

import (
	"fmt"
	"math/rand"
	"strconv"
)

type LegacyPayment struct {
	TxnIDNum int     `json:"TXN_ID_NUM"`
	CustID   int     `json:"CUST_ID"`
	TotalAmt float64 `json:"TOTAL_AMT"`
	CurrCode string  `json:"CURR_CODE"`
	StatusFlg int    `json:"STATUS_FLG"`
}

type ModernPayment struct {
	PaymentID     string `json:"payment_id"`
	CustomerID    string `json:"customer_id"`
	AmountInCents int64  `json:"amount_in_cents"`
	Currency      string `json:"currency"`
	Status        string `json:"status"`
}

// AntiCorruptionLayer transforms legacy schema to modern domain
func TranslateToModern(legacy LegacyPayment) ModernPayment {
	status := "FAILED"
	if legacy.StatusFlg == 1 {
		status = "COMPLETED"
	}
	return ModernPayment{
		PaymentID:     strconv.Itoa(legacy.TxnIDNum),
		CustomerID:    fmt.Sprintf("usr_%d", legacy.CustID),
		AmountInCents: int64(legacy.TotalAmt * 100),
		Currency:      legacy.CurrCode,
		Status:        status,
	}
}

func RouteTraffic(legacy LegacyPayment, canaryPercent int) string {
	if rand.Intn(100) < canaryPercent {
		modern := TranslateToModern(legacy)
		return fmt.Sprintf("Routing to Microservice: %+v", modern)
	}
	return fmt.Sprintf("Routing to Monolith: %+v", legacy)
}
        

public class AntiCorruptionLayer {
    public record LegacyPayment(long TXN_ID_NUM, long CUST_ID, double TOTAL_AMT, String CURR_CODE, int STATUS_FLG) {}
    public record ModernPayment(String paymentId, String customerId, long amountInCents, String currency, String status) {}

    public static ModernPayment translate(LegacyPayment legacy) {
        String status = legacy.STATUS_FLG() == 1 ? "COMPLETED" : "FAILED";
        return new ModernPayment(
            String.valueOf(legacy.TXN_ID_NUM()),
            "usr_" + legacy.CUST_ID(),
            Math.round(legacy.TOTAL_AMT() * 100),
            legacy.CURR_CODE().toUpperCase(),
            status
        );
    }
}
        

#include <iostream>
#include <string>
#include <cmath>

struct LegacyPayment {
    int64_t TXN_ID_NUM;
    int64_t CUST_ID;
    double TOTAL_AMT;
    std::string CURR_CODE;
    int STATUS_FLG;
};

struct ModernPayment {
    std::string payment_id;
    std::string customer_id;
    int64_t amount_in_cents;
    std::string currency;
    std::string status;
};

class AntiCorruptionLayer {
public:
    static ModernPayment translate(const LegacyPayment& l) {
        return ModernPayment{
            std::to_string(l.TXN_ID_NUM),
            "usr_" + std::to_string(l.CUST_ID),
            static_cast<int64_t>(std::round(l.TOTAL_AMT * 100)),
            l.CURR_CODE,
            (l.STATUS_FLG == 1) ? "COMPLETED" : "FAILED"
        };
    }
};