How do you implement a custom saga pattern for distributed transactions?

Question

Accepted Answer

**Saga** — sequence of local transactions with compensation.

```javascript
class Saga {
    constructor() {
        this.steps = [];
    }

addStep(execute, compensate) {
        this.steps.push({ execute, compensate });
        return this;
    }

async run(context) {
        const completedSteps = [];

try {
            for (const step of this.steps) {
                const result = await step.execute(context);
                context = { ...context, ...result };
                completedSteps.push(step);
            }
            return { success: true, context };
        } catch (err) {
            // Compensate in reverse order
            for (const step of completedSteps.reverse()) {
                try {
                    await step.compensate(context);
                } catch (compErr) {
                    console.error("Compensation failed:", compErr);
                }
            }
            return { success: false, error: err };
        }
    }
}

// Order saga
const orderSaga = new Saga()
    .addStep(
        async (ctx) => {
            const order = await createOrder(ctx);
            return { orderId: order.id };
        },
        async (ctx) => await cancelOrder(ctx.orderId)
    )
    .addStep(
        async (ctx) => {
            await chargePayment(ctx.orderId, ctx.amount);
            return {};
        },
        async (ctx) => await refundPayment(ctx.orderId)
    )
    .addStep(
        async (ctx) => {
            await reserveInventory(ctx.items);
            return {};
        },
        async (ctx) => await releaseInventory(ctx.items)
    );

const result = await orderSaga.run({
    userId: "user-123",
    items: ["item1", "item2"],
    amount: 99.99,
});
```

Node.js: How do you implement a custom saga pattern for distributed transactions?