PUT and PATCH route handling in Express - Deep Dive

Overview - PUT and PATCH route handling

What is it?

PUT and PATCH are HTTP methods used in web servers to update data. In Express, a popular web framework for Node.js, you define routes to handle these methods. PUT replaces the entire resource, while PATCH updates only parts of it. These methods help clients change data on the server in different ways.

Why it matters

Without PUT and PATCH, web apps would struggle to update data efficiently. PUT and PATCH let clients send updates clearly and precisely, avoiding confusion or data loss. This makes apps faster, more reliable, and easier to maintain. Imagine trying to fix a broken toy: PUT is like replacing the whole toy, PATCH is like fixing just the broken part.

Where it fits

Before learning PUT and PATCH, you should understand basic HTTP methods like GET and POST and how Express routes work. After mastering these, you can learn about RESTful API design and data validation. This topic fits in the middle of building full-featured web APIs.

Mental Model

Core Idea

PUT replaces a whole resource, PATCH updates parts of it, and Express routes handle these updates on the server.

Think of it like...

Think of a document: PUT is like rewriting the entire page, while PATCH is like editing just a sentence or word.

┌───────────────┐       ┌───────────────┐
│ Client sends  │       │ Server receives│
│ PUT request   │──────▶│ replaces full  │
│ (whole data)  │       │ resource       │
└───────────────┘       └───────────────┘

┌───────────────┐       ┌───────────────┐
│ Client sends  │       │ Server receives│
│ PATCH request │──────▶│ updates parts  │
│ (partial data)│       │ of resource    │
└───────────────┘       └───────────────┘

Build-Up - 7 Steps

1

Foundation

Understanding HTTP methods basics

Concept: Learn what HTTP methods are and how they signal actions to a server.

HTTP methods like GET, POST, PUT, and PATCH tell a server what the client wants to do. GET asks for data, POST sends new data, PUT replaces data, and PATCH changes parts of data. These methods are part of the web's language for communication.

Result

You can identify when to use each HTTP method in web communication.

Knowing HTTP methods is the foundation for building web APIs that behave predictably and clearly.

2

Foundation

Express route basics

Concept: Learn how to create routes in Express to handle different HTTP methods.

In Express, you use app.METHOD(path, handler) to create routes. For example, app.get('/items', handler) handles GET requests to '/items'. This lets your server respond differently based on the method and URL.

Result

You can write simple routes that respond to client requests.

Understanding Express routing is key to controlling how your server reacts to different client actions.

3

Intermediate

Implementing PUT routes in Express

🤔Before reading on: Do you think PUT should update only part of a resource or replace it fully? Commit to your answer.

Concept: PUT routes replace the entire resource at the given URL with new data.

To handle PUT in Express, use app.put('/resource/:id', handler). The handler receives the full new data in req.body and replaces the old resource. For example: app.put('/users/:id', (req, res) => { const id = req.params.id; const newUser = req.body; // full user data // Replace user with id by newUser res.send(`User ${id} replaced`); });

Result

The server replaces the entire resource with the new data sent by the client.

Understanding that PUT expects full data helps prevent accidental partial updates that can corrupt data.

4

Intermediate

Implementing PATCH routes in Express

🤔Before reading on: Does PATCH require full data or just the parts to update? Commit to your answer.

Concept: PATCH routes update only specified fields of a resource without replacing the whole thing.

To handle PATCH in Express, use app.patch('/resource/:id', handler). The handler receives partial data in req.body and updates only those fields. For example: app.patch('/users/:id', (req, res) => { const id = req.params.id; const updates = req.body; // partial user data // Update user with id using updates res.send(`User ${id} updated`); });

Result

The server updates only the specified fields, leaving others unchanged.

Knowing PATCH updates parts of data helps build efficient APIs that avoid unnecessary data transfer.

5

Intermediate

Handling request data and validation

Concept: Learn to access and validate data sent in PUT and PATCH requests.

Express uses middleware like express.json() to parse JSON request bodies. In your PUT or PATCH handler, req.body contains the data sent by the client. Validating this data ensures the server updates only valid and safe information. For example: app.use(express.json()); app.put('/users/:id', (req, res) => { if (!req.body.name) { return res.status(400).send('Name is required'); } // proceed with update });

Result

The server safely processes updates and rejects bad data.

Validating input prevents bugs and security issues in your update routes.

6

Advanced

Differences in idempotency and safety

🤔Before reading on: Is PUT idempotent, PATCH idempotent, or both? Commit to your answer.

Concept: PUT is idempotent (same request repeated has same effect), PATCH may or may not be idempotent depending on implementation.

PUT replaces the resource fully, so sending the same PUT request multiple times results in the same state. PATCH changes parts, so repeated PATCH requests might have different effects if they increment or toggle values. Understanding this helps design APIs that behave predictably.

Result

You can choose the right method based on how updates should behave when repeated.

Knowing idempotency helps avoid unexpected bugs when clients retry requests.

7

Expert

Handling partial updates and merge strategies

🤔Before reading on: Do you think PATCH always merges objects deeply or just shallowly? Commit to your answer.

Concept: PATCH updates can be shallow or deep merges, affecting how nested data is updated or replaced.

When handling PATCH, you decide how to merge updates. A shallow merge replaces top-level fields only, while a deep merge updates nested fields. For example, updating a user address object partially requires deep merging to avoid losing other address fields. Implementing deep merge requires extra code or libraries.

Result

Your PATCH route can update nested data correctly without overwriting unrelated fields.

Understanding merge depth prevents data loss and bugs in complex updates.

Under the Hood

Express listens for HTTP requests and matches the URL and method to routes. For PUT and PATCH, Express parses the request body (usually JSON) and passes it to the route handler. The handler then updates the server's data store accordingly. PUT replaces the entire resource, while PATCH applies partial changes. Internally, the server must merge or replace data structures based on the method.

Why designed this way?

PUT and PATCH were designed to give clear, distinct ways to update resources. PUT's full replacement ensures a known state, simplifying caching and consistency. PATCH allows efficient updates without sending full data, saving bandwidth and processing. Express follows HTTP standards to keep APIs predictable and interoperable.

┌───────────────┐
│ Client sends  │
│ PUT or PATCH  │
│ request with  │
│ JSON body     │
└──────┬────────┘
       │
       ▼
┌───────────────┐
│ Express server│
│ matches route │
│ and method    │
└──────┬────────┘
       │
       ▼
┌───────────────┐
│ Parses JSON   │
│ body into     │
│ req.body      │
└──────┬────────┘
       │
       ▼
┌───────────────┐
│ Route handler │
│ updates data  │
│ store         │
└───────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Does PATCH always replace the entire resource? Commit yes or no.

Common Belief: PATCH replaces the whole resource just like PUT.

Reality: PATCH only updates specified fields, leaving others unchanged.

Why it matters: Misusing PATCH as PUT can cause accidental data loss by overwriting fields unintentionally.

Quick: Is PUT always safe to retry multiple times without side effects? Commit yes or no.

Common Belief: PUT is not idempotent and can cause different results on retries.

Reality: PUT is idempotent; repeating the same PUT request results in the same resource state.

Why it matters: Misunderstanding idempotency can lead to bugs in client retry logic and inconsistent data.

Quick: Does Express automatically merge PATCH updates deeply? Commit yes or no.

Common Belief: Express merges PATCH updates deeply by default.

Reality: Express does not merge data; the developer must implement merging logic.

Why it matters: Assuming automatic deep merge leads to lost nested data and bugs.

Quick: Can you send partial data in a PUT request? Commit yes or no.

Common Belief: PUT accepts partial data to update parts of a resource.

Reality: PUT expects full resource data and replaces the entire resource.

Why it matters: Sending partial data in PUT can unintentionally erase missing fields.

Expert Zone

1

PATCH semantics can vary widely; some APIs treat PATCH as a JSON Patch (RFC 6902) with operations, others as partial objects, requiring careful documentation.

2

PUT requests often require clients to send the entire resource, including unchanged fields, which can be inefficient; caching and conditional requests (ETags) help optimize this.

3

Express does not enforce any data merging or validation; middleware and custom logic are essential for robust PUT/PATCH handling.

When NOT to use

Avoid using PUT or PATCH when the update logic is complex or transactional; instead, use POST with specific action endpoints or GraphQL mutations for fine-grained control.

Production Patterns

In production, PATCH is often used for user profile updates to minimize data transfer, while PUT is used for full resource replacement like configuration files. Middleware validates input, and database transactions ensure consistency.

Connections

RESTful API design

PUT and PATCH are core HTTP methods defined in REST principles for resource updates.

Understanding PUT and PATCH deeply helps design APIs that follow REST standards, improving interoperability and client expectations.

Database transactions

PUT and PATCH handlers often wrap updates in transactions to ensure data integrity.

Knowing how HTTP update methods relate to database operations helps prevent partial updates and maintain consistent state.

Version control systems

PATCH in HTTP is conceptually similar to patching code changes in version control.

Recognizing this connection clarifies why PATCH updates only parts and how changes can be merged or rejected.

Common Pitfalls

#1 Sending partial data in a PUT request causing data loss.

Wrong approach:

app.put('/items/:id', (req, res) => {
const id = req.params.id;
const partialData = req.body; // only some fields
database[id] = partialData; // overwrites entire resource
res.send('Updated');
});

Correct approach:

app.put('/items/:id', (req, res) => {
const id = req.params.id;
const fullData = req.body; // full resource data
database[id] = fullData; // replaces resource safely
res.send('Replaced');
});

Root cause:

Misunderstanding that PUT requires full resource data, not partial.

#2 Assuming Express merges PATCH data automatically.

Wrong approach:

app.patch('/items/:id', (req, res) => {
const id = req.params.id;
Object.assign(database[id], req.body); // shallow merge only
res.send('Patched');
});

Correct approach:

const deepMerge = require('lodash.merge');
app.patch('/items/:id', (req, res) => {
const id = req.params.id;
deepMerge(database[id], req.body); // deep merge
res.send('Patched deeply');
});

Root cause:

Assuming shallow merge is enough for nested data updates.

#3 Not validating input data leading to invalid updates.

Wrong approach:

app.put('/users/:id', (req, res) => {
database[req.params.id] = req.body; // no checks
res.send('User updated');
});

Correct approach:

app.put('/users/:id', (req, res) => {
const data = req.body;
if (!data.name || typeof data.name !== 'string') {
return res.status(400).send('Invalid name');
}
database[req.params.id] = data;
res.send('User updated');
});

Root cause:

Skipping validation due to trust in client data.

Key Takeaways

PUT replaces an entire resource and expects full data, while PATCH updates only specified parts.

Express routes handle PUT and PATCH by matching HTTP methods and parsing request bodies for updates.

Understanding idempotency helps design reliable APIs where repeated requests have predictable effects.

Developers must implement data validation and merging logic; Express does not do this automatically.

Misusing PUT and PATCH can cause data loss or bugs, so knowing their differences is essential for safe updates.