2-orchestration.js

'use strict';

class BankAccount {
  constructor(name, balance = 0, maxBalance = -1) {
    this.name = name;
    this.balance = balance;
    this.maxBalance = maxBalance;
  }

  debit(amount) {
    if (amount > this.balance) {
      throw new Error(`Insufficient funds on ${this.name}`);
    }
    this.balance -= amount;
  }

  credit(amount) {
    const { name, balance, maxBalance } = this;
    const value = balance + amount;
    if (maxBalance > 0 && value > maxBalance) {
      throw new Error(`Account ${name} cannot exceed balance ${maxBalance}`);
    }
    this.balance = value;
  }
}

class Bank {
  constructor(accounts) {
    this.accounts = new Map(
      accounts.map((account) => {
        const { name, balance, maxBalance = -1 } = account;
        const bankAccount = new BankAccount(name, balance, maxBalance);
        return [name, bankAccount];
      }),
    );
  }

  getBalance(name) {
    const account = this.accounts.get(name);
    if (!account) throw new Error(`Account ${name} not found`);
    return account.balance;
  }

  debit(name, amount) {
    const account = this.accounts.get(name);
    if (!account) throw new Error(`Account ${name} not found`);
    account.debit(amount);
  }

  credit(name, amount) {
    const account = this.accounts.get(name);
    if (!account) throw new Error(`Account ${name} not found`);
    account.credit(amount);
  }
}

class FraudService {
  constructor(blockedRecipients = []) {
    this.blockedRecipients = new Set(blockedRecipients);
  }

  ensureNotBlocked({ to }) {
    if (this.blockedRecipients.has(to)) {
      throw new Error(`Fraud check failed for ${to}`);
    }
  }
}

class NotificationService {
  constructor(unreliableRecipients = []) {
    this.unreliableRecipients = new Set(unreliableRecipients);
  }

  sendReceipt({ to, amount }) {
    if (this.unreliableRecipients.has(to)) {
      throw new Error(`Notification service unavailable for ${to}`);
    }
    console.log(`Notification: receipt sent to ${to} for ${amount}`);
  }
}

class SagaStep {
  constructor({ name, action, compensation = null }) {
    this.name = name;
    this.action = action;
    this.compensation = compensation;
  }
}

class SagaOrchestrator {
  constructor(steps) {
    this.steps = steps;
  }

  run(context) {
    const completed = [];
    for (const step of this.steps) {
      const { name } = step;
      try {
        step.action(context);
        completed.push(step);
        console.log(`✓ ${name}`);
      } catch (error) {
        const { message } = error;
        console.error(`✗ ${name}: ${message}`);
        this.rollback(context, completed);
        throw new Error(`Saga failed at step "${name}": ${message}`);
      }
    }
    return context;
  }

  rollback(context, completedSteps) {
    const steps = completedSteps.toReversed();
    for (const step of steps) {
      const { name } = step;
      if (!step.compensation) continue;
      if (!this.steps.includes(step)) {
        throw new Error(`Step ${name} is not part of the saga`);
      }
      try {
        step.compensation(context);
        console.log(`↩ Compensation applied for ${name}`);
      } catch (compensationError) {
        const { message } = compensationError;
        console.error(`⚠ Failed to compensate ${name}: ${message}`);
      }
    }
  }
}

const bank = new Bank([
  { name: 'Marcus Aurelius', balance: 100, maxBalance: 120 },
  { name: 'Antoninus Pius', balance: 1000 },
  { name: 'Commodus', balance: 50 },
]);

const fraudService = new FraudService(['Commodus']);
const notificationService = new NotificationService(['Antoninus Pius']);

const transferSaga = new SagaOrchestrator([
  new SagaStep({
    name: 'Fraud check recipient',
    action: (ctx) => fraudService.ensureNotBlocked(ctx),
  }),
  new SagaStep({
    name: 'Debit sender account',
    action: (ctx) => bank.debit(ctx.from, ctx.amount),
    compensation: (ctx) => bank.credit(ctx.from, ctx.amount),
  }),
  new SagaStep({
    name: 'Credit recipient account',
    action: (ctx) => bank.credit(ctx.to, ctx.amount),
    compensation: (ctx) => bank.debit(ctx.to, ctx.amount),
  }),
  new SagaStep({
    name: 'Send receipt',
    action: (ctx) => notificationService.sendReceipt(ctx),
  }),
]);

const showBalances = () => {
  console.log('--- Balances ---');
  for (const [name] of bank.accounts) {
    const balance = bank.getBalance(name);
    console.log(`${name}: ${balance}`);
  }
};

const runScenario = (context) => {
  try {
    const { from, to } = context;
    console.log(`\nRunning saga orchestrated transfer ${from} -> ${to}`);
    transferSaga.run(context);
    console.log('Saga completed successfully');
  } catch (error) {
    console.error(error.message);
  } finally {
    showBalances();
  }
};

console.log('Services ready: Saga Orchestrator');
console.log('\nInitial balances:');
showBalances();

runScenario({ from: 'Antoninus Pius', to: 'Marcus Aurelius', amount: 10 });
runScenario({ from: 'Antoninus Pius', to: 'Marcus Aurelius', amount: 30 });
runScenario({ from: 'Antoninus Pius', to: 'Commodus', amount: 100 });