Constraint-Based Routing

In this lesson, you will learn how to shift validation from your controller logic directly into your routing layer to ensure that only requests meeting specific domain constraints reach your application handlers.

The Concept of Constraint-Based Routing

In a standard web application, we often let a route handler (the controller) receive a request and then perform a series of if statements or validation checks to see if the parameters are valid. However, Constraint-Based Routing moves this logic upstream. By treating the route itself as a gateway that requires specific domain-level criteria, you prevent "dirty" data from ever triggering your business services or audit logging systems.

If a request hits a route but fails to meet the domain constraints, the router rejects it immediately. This reduces unnecessary processing and keeps your controllers clean of validation boilerplate.

Practical Implementation

Imagine you have a GET route for a Project that only accepts specific types of IDs based on your Value Object design. Instead of checking this inside the controller, you can use a middleware that enforces the constraint before the request reaches its destination:

// A middleware that acts as a domain constraint filter
const validateProjectId = (req, res, next) => {
  const { id } = req.params;
  
  // Enforce Domain Value Object constraints (e.g., UUID format or specific prefix)
  if (!/^[A-Z]{3}-\d{4}$/.test(id)) {
    return res.status(400).json({ error: "Invalid Project ID format" });
  }
  
  next();
};

// Routing definition
app.get('/projects/:id', validateProjectId, projectController.getProject);

By applying validateProjectId at the route definition level, your projectController is guaranteed that any id it receives is already formatted correctly according to your domain model. This is an extension of Value Object Validation (taught in lesson 9), but applied at the request entry point.

This approach is highly effective when combined with Standardized Error Mapping (lesson 4), as it ensures that invalid requests are rejected with a consistent schema before the application layer even attempts to interact with your Repository or Service Layer.

Key Takeaway: Constraint-based routing shifts domain validation to the edge of your request pipeline, ensuring that only structurally valid requests enter your business logic layers.