Untangling Dependencies in Legacy Code

// AFTER: Layered architecture with dependency injection

// repositories/OrderRepository.js - Data access layer
class OrderRepository {
    constructor(db) {
        this.db = db;
    }

    async findById(id) {
        const result = await this.db.query(
            'SELECT * FROM orders WHERE id = $1',
            [id]
        );
        return result.rows[0] || null;
    }

    async create(orderData) {
        const { userId, total, paymentId, status } = orderData;
        const result = await this.db.query(
            `INSERT INTO orders (user_id, total, payment_id, status)
             VALUES ($1, $2, $3, $4) RETURNING *`,
            [userId, total, paymentId, status]
        );
        return result.rows[0];
    }

    async updateStatus(id, status) {
        const result = await this.db.query(
            'UPDATE orders SET status = $1 WHERE id = $2 RETURNING *',
            [status, id]
        );
        return result.rows[0];
    }
}

// repositories/ProductRepository.js
class ProductRepository {
    constructor(db) {
        this.db = db;
    }

    async findById(id) {
        const result = await this.db.query(
            'SELECT * FROM products WHERE id = $1',
            [id]
        );
        return result.rows[0] || null;
    }

    async decrementStock(id, quantity) {
        await this.db.query(
            'UPDATE products SET stock = stock - $1 WHERE id = $2',
            [quantity, id]
        );
    }
}

// services/PricingService.js - Pure business logic, easily testable
class PricingService {
    constructor(taxConfig) {
        this.taxConfig = taxConfig;
    }

    calculateSubtotal(items) {
        return items.reduce((sum, item) =>
            sum + (item.price * item.quantity), 0
        );
    }

    applyMembershipDiscount(subtotal, membershipLevel) {
        const discounts = {
            premium: 0.10,
            gold: 0.05,
            standard: 0,
        };
        const discount = discounts[membershipLevel] || 0;
        return subtotal * (1 - discount);
    }

    calculateTax(amount, state) {
        const rate = this.taxConfig[state] || 0;
        return amount * rate;
    }

    calculateTotal(items, membershipLevel, state) {
        const subtotal = this.calculateSubtotal(items);
        const discounted = this.applyMembershipDiscount(subtotal, membershipLevel);
        const tax = this.calculateTax(discounted, state);
        return {
            subtotal,
            discount: subtotal - discounted,
            tax,
            total: discounted + tax,
        };
    }
}

// services/OrderService.js - Orchestrates business operations
class OrderService {
    constructor(orderRepo, productRepo, userRepo, pricingService, paymentGateway, notificationService) {
        this.orderRepo = orderRepo;
        this.productRepo = productRepo;
        this.userRepo = userRepo;
        this.pricingService = pricingService;
        this.paymentGateway = paymentGateway;
        this.notificationService = notificationService;
    }

    async createOrder(userId, items, paymentMethod) {
        // Validate user
        const user = await this.userRepo.findById(userId);
        if (!user) {
            throw new NotFoundError('User not found');
        }

        // Validate and enrich items with prices
        const enrichedItems = await this.validateAndEnrichItems(items);

        // Calculate pricing
        const pricing = this.pricingService.calculateTotal(
            enrichedItems,
            user.membershipLevel,
            user.state
        );

        // Process payment
        const payment = await this.paymentGateway.charge({
            amount: pricing.total,
            currency: 'usd',
            paymentMethod,
            customerId: user.stripeCustomerId,
        });

        if (!payment.success) {
            throw new PaymentError(payment.error);
        }

        // Create order
        const order = await this.orderRepo.create({
            userId,
            total: pricing.total,
            paymentId: payment.id,
            status: 'confirmed',
        });

        // Update inventory
        await this.decrementInventory(enrichedItems);

        // Send notification (async, don't wait)
        this.notificationService.sendOrderConfirmation(user.email, order)
            .catch(err => console.error('Notification failed:', err));

        return { order, pricing };
    }

    async validateAndEnrichItems(items) {
        const enriched = [];

        for (const item of items) {
            const product = await this.productRepo.findById(item.productId);

            if (!product) {
                throw new ValidationError(`Product ${item.productId} not found`);
            }

            if (product.stock < item.quantity) {
                throw new ValidationError(
                    `Insufficient stock for ${product.name}`
                );
            }

            enriched.push({
                ...item,
                price: product.price,
                name: product.name,
            });
        }

        return enriched;
    }

    async decrementInventory(items) {
        for (const item of items) {
            await this.productRepo.decrementStock(item.productId, item.quantity);
        }
    }
}

// controllers/OrderController.js - Thin HTTP layer
class OrderController {
    constructor(orderService) {
        this.orderService = orderService;
    }

    async create(req, res) {
        try {
            const { userId, items, paymentMethod } = req.body;

            // Input validation only
            if (!userId || !items?.length || !paymentMethod) {
                return res.status(400).json({
                    error: 'Missing required fields: userId, items, paymentMethod'
                });
            }

            const result = await this.orderService.createOrder(
                userId,
                items,
                paymentMethod
            );

            res.status(201).json(result);

        } catch (error) {
            if (error instanceof ValidationError) {
                return res.status(400).json({ error: error.message });
            }
            if (error instanceof NotFoundError) {
                return res.status(404).json({ error: error.message });
            }
            if (error instanceof PaymentError) {
                return res.status(402).json({ error: error.message });
            }

            console.error('Order creation failed:', error);
            res.status(500).json({ error: 'Internal server error' });
        }
    }
}

// routes/orders.js - Wiring only
const router = express.Router();
const orderController = container.resolve('orderController');

router.post('/orders', (req, res) => orderController.create(req, res));

// Benefits:
// 1. PricingService can be unit tested with no mocks
// 2. OrderService can be tested with mock repositories
// 3. Controller only handles HTTP concerns
// 4. Easy to swap implementations (different payment provider)
// 5. Clear dependencies, easy to understand data flow