Adapter Pattern

// Adapter Pattern Example

// Old payment interface (legacy code)
class OldPaymentSystem {
  makePayment(amount) {
    console.log(`Processing payment of $${amount} through legacy system`);
    return {
      success: true,
      transactionId: Math.random().toString(36).substr(2, 9)
    };
  }
}

// New payment interface that our application expects
class ModernPaymentInterface {
  processPayment(paymentDetails) {
    throw new Error('Method must be implemented');
  }
}

// Third-party payment service with different interface
class StripePaymentService {
  chargeCard(cardNumber, amount, currency) {
    console.log(`Charging ${currency}${amount} to card ${cardNumber.slice(-4)}`);
    return {
      status: 'succeeded',
      chargeId: 'ch_' + Math.random().toString(36).substr(2, 9)
    };
  }
}

// Adapter for old payment system
class OldPaymentAdapter extends ModernPaymentInterface {
  constructor() {
    super();
    this.oldSystem = new OldPaymentSystem();
  }
  
  processPayment(paymentDetails) {
    // Adapt the modern interface to the old system
    const result = this.oldSystem.makePayment(paymentDetails.amount);
    
    return {
      status: result.success ? 'completed' : 'failed',
      transactionId: result.transactionId,
      amount: paymentDetails.amount,
      currency: paymentDetails.currency || 'USD'
    };
  }
}

// Adapter for Stripe payment service
class StripeAdapter extends ModernPaymentInterface {
  constructor() {
    super();
    this.stripe = new StripePaymentService();
  }
  
  processPayment(paymentDetails) {
    // Adapt the modern interface to Stripe's interface
    const result = this.stripe.chargeCard(
      paymentDetails.cardNumber,
      paymentDetails.amount,
      paymentDetails.currency
    );
    
    return {
      status: result.status === 'succeeded' ? 'completed' : 'failed',
      transactionId: result.chargeId,
      amount: paymentDetails.amount,
      currency: paymentDetails.currency
    };
  }
}

// Payment processor that works with any payment service through adapters
class PaymentProcessor {
  constructor(paymentAdapter) {
    this.adapter = paymentAdapter;
  }
  
  process(paymentDetails) {
    console.log('Processing payment...');
    const result = this.adapter.processPayment(paymentDetails);
    console.log('Payment result:', result);
    return result;
  }
}

// Usage
const paymentDetails = {
  amount: 100,
  currency: 'USD',
  cardNumber: '4111111111111111'
};

// Using old payment system through adapter
const oldPaymentProcessor = new PaymentProcessor(new OldPaymentAdapter());
oldPaymentProcessor.process(paymentDetails);

// Using Stripe through adapter
const stripeProcessor = new PaymentProcessor(new StripeAdapter());
stripeProcessor.process(paymentDetails);

// Another example: Adapting different data formats
class XMLDataSource {
  getXMLData() {
    return `<users>
      <user>
        <name>John Doe</name>
        <email>john@example.com</email>
      </user>
      <user>
        <name>Jane Smith</name>
        <email>jane@example.com</email>
      </user>
    </users>`;
  }
}

class JSONDataAdapter {
  constructor(xmlDataSource) {
    this.xmlSource = xmlDataSource;
  }
  
  getData() {
    const xmlData = this.xmlSource.getXMLData();
    // Simplified conversion(in real app, use proper XML parser)
    return {
      users: [
        { name: 'John Doe', email: 'john@example.com' },
        { name: 'Jane Smith', email: 'jane@example.com' }
      ]
    };
  }
}

// Usage
const xmlSource = new XMLDataSource();
const jsonAdapter = new JSONDataAdapter(xmlSource);
const jsonData = jsonAdapter.getData();
console.log('Adapted data:', jsonData);