Architecture & Design Patterns

// counter.js
let count = 0; // private, invisible outside this file

function increment() { count += 1; return count; }
function getCount() { return count; }

module.exports = { increment, getCount };

Common follow-ups: How does this differ from using a class with private fields (#field) for the same encapsulation goal?;What happens to module-level state when the same module is required from multiple files?

function createLogger(env) {
  if (env === 'production') return new JsonLogger();
  if (env === 'test') return new SilentLogger();
  return new ConsoleLogger();
}

const logger = createLogger(process.env.NODE_ENV);

Common follow-ups: How does the Factory pattern relate to the Dependency Injection pattern -- are they complementary or competing approaches?;When does introducing a factory add unnecessary indirection for a genuinely simple case?

// database.js -- naturally a singleton due to module caching
class Database {
  constructor() { this.connection = connectToDb(); }
}
module.exports = new Database(); // same instance returned on every require()

Common follow-ups: How would you refactor a singleton-based module to be more testable via dependency injection?;What happens to a 'singleton' module if it's required from two different node_modules copies of the same package?

// controller
app.post('/users', (req, res) => userService.createUser(req.body).then(u => res.json(u)));

// service (business logic)
async function createUser(data) {
  validateUser(data);
  return userRepository.save(data);
}

// repository (data access)
async function save(userData) { return db.collection('users').insertOne(userData); }

Common follow-ups: How does this layered approach compare to a more feature-based ('vertical slice') folder structure?;At what point does strict layering start to add more overhead than value for a small project?

class UserRepository {
  async findById(id) { return db.collection('users').findOne({ _id: id }); }
  async save(user) { return db.collection('users').insertOne(user); }
}

// In tests, swap in a fake implementation with the same interface
class FakeUserRepository {
  constructor() { this.users = new Map(); }
  async findById(id) { return this.users.get(id); }
  async save(user) { this.users.set(user.id, user); return user; }
}

Common follow-ups: How does the Repository pattern relate to and differ from an ORM's own query builder abstraction?;What's the tradeoff of introducing a repository layer for a very simple CRUD application?

const EventEmitter = require('node:events');

class OrderProcessor extends EventEmitter {
  processOrder(order) {
    // ... process order ...
    this.emit('orderCompleted', order);
  }
}

const processor = new OrderProcessor();
processor.on('orderCompleted', (order) => sendConfirmationEmail(order));
processor.on('orderCompleted', (order) => updateInventory(order));

Common follow-ups: What happens if a listener attached to an EventEmitter throws an error -- how does that affect other listeners?;How does the Observer pattern relate conceptually to the pub/sub pattern used with message queues?

class Money { // value object: equality is by value, and it's immutable
  constructor(amount, currency) { this.amount = amount; this.currency = currency; Object.freeze(this); }
  equals(other) { return this.amount === other.amount && this.currency === other.currency; }
}

class Order { // entity: has identity, and acts as the aggregate root
  constructor(id) { this.id = id; this.items = []; this.total = new Money(0, 'USD'); }
  addItem(item) { this.items.push(item); this.total = this.recalculateTotal(); }
}

Common follow-ups: How much of full DDD (bounded contexts, ubiquitous language) is realistic to adopt incrementally versus needing a full rewrite?;What's the practical difference between a value object and a plain object literal in JavaScript, given JS doesn't enforce immutability by default?

// Port (interface the core logic depends on)
class NotificationPort { async send(message) { throw new Error('not implemented'); } }

// Adapter (concrete implementation, plugged in at the edge)
class EmailAdapter extends NotificationPort {
  async send(message) { return emailClient.send(message); }
}

// Core business logic depends only on the port, not the concrete adapter
class OrderService {
  constructor(notificationPort) { this.notifications = notificationPort; }
  async completeOrder(order) { await this.notifications.send(`Order ${order.id} completed`); }
}

Common follow-ups: How does Hexagonal Architecture compare to the simpler layered architecture described earlier, and when is the added complexity worth it?;What's a concrete strategy for retrofitting this pattern onto an existing, tightly-coupled Express application?

app.use((req, res, next) => {
  console.log(`${req.method} ${req.path}`);
  next(); // pass control to the next middleware in the chain
});

app.use((req, res, next) => {
  if (!req.headers.authorization) return res.status(401).end(); // short-circuits the chain
  next();
});

Common follow-ups: What happens if a middleware function neither calls next() nor sends a response?;How does error-handling middleware (with four parameters) fit into this same chain-of-responsibility model?

const CircuitBreaker = require('opossum');

const breaker = new CircuitBreaker(callExternalApi, {
  timeout: 3000,
  errorThresholdPercentage: 50,
  resetTimeout: 30000,
});

breaker.fallback(() => ({ cached: true, data: getCachedResponse() }));
breaker.fire(requestParams).then(handleResponse);

Common follow-ups: How do you choose appropriate threshold and cooldown values for a circuit breaker in a real system?;How does a circuit breaker interact with retry logic -- should they be used together or is that redundant?