CoachnestCoachnest
Sign InGet Started
Back to course

Mastering CRUD: Build Full-Stack Database Applications

…
—
Contents
1

What Is CRUD and Why It Matters

Reading12mFree
2

CRUD, REST, and HTTP Verbs

Reading14mFree
3

The Data Lifecycle of a Record

Reading11m
4

Course Project Tour: TaskFlow

Video9m
5

Chapter 1 — Quiz

Quiz8m
6

Tables, Rows, Columns & Types

Reading14m
7

Primary Keys & IDs (Auto-increment vs UUID)

Reading13m
8

Relationships: One-to-Many & Many-to-Many

Reading16m
9

Normalization & Schema Design Principles

Reading14m
10

Modeling TaskFlow with Prisma

Reading13m
11

Chapter 2 — Quiz

Quiz8m
12

INSERT — Creating Rows

Reading13m
13

SELECT — Reading & Filtering

Reading16m
14

UPDATE — Changing Rows Safely

Reading12m
15

DELETE — Removing Rows

Reading11m
16

Live SQL: A Full CRUD Session

Video15m
17

Chapter 3 — Quiz

Quiz9m
18

REST API Design for CRUD Resources

Reading14m
19

HTTP Status Codes That Tell the Truth

Reading12m
20

Scaffolding the API (Express & Next.js)

Reading16m
21

Connecting an ORM (Prisma) to Your Routes

Reading13m
22

Chapter 4 — Quiz

Quiz8m
23

Building the Create Endpoint End-to-End

Reading15m
24

Reading a Single Resource

Reading11m
25

Listing Collections

Reading13m
26

Live Coding: Create & Read

Video16m
27

Chapter 5 — Quiz

Quiz8m

PUT vs PATCH: Full vs Partial Updates

Reading13m
29

Authorization: Who Can Change This Row?

Reading12m
30

Soft Delete, Hard Delete & Restore

Reading14m
31

Idempotency & Concurrency Control

Reading13m
32

Chapter 6 — Quiz

Quiz9m
33

Input Validation with Zod

Reading14m
34

Mass Assignment & Over-Posting

Reading11m
35

SQL Injection & Safe Queries

Reading13m
36

Consistent Error Handling

Reading12m
37

Chapter 7 — Quiz

Quiz9m
38

Offset vs Cursor Pagination

Reading15m
39

Filtering & Dynamic WHERE Clauses

Reading13m
40

Safe Sorting & Full-Text Search

Reading14m
41

Indexing for Fast Reads

Reading13m
42

Chapter 8 — Quiz

Quiz9m
43

Forms & Creating Records from the UI

Reading14m
44

Fetching & Displaying Data

Reading13m
45

Optimistic Updates & Deletes

Reading14m
46

Building the TaskFlow UI

Video17m
47

Chapter 9 — Quiz

Quiz8m
48

Transactions & Data Integrity

Reading15m
49

Testing Your CRUD Endpoints

Reading14m
50

Caching, N+1 & Performance

Reading13m
51

Deploying & Migrating Safely

Reading14m
52

Chapter 10 — Final Quiz

Quiz10m
←→navigate lessons
Chapter 6 of 10·Chapter 6 — Update & Delete in Practice
Lesson 28 of 52Reading13 min

PUT vs PATCH: Full vs Partial Updates

PUT vs PATCH: Full vs Partial Updates¶

Both update a resource, but they make different promises.

PUT — Replace Everything¶

PUT says "here is the complete new state of the resource." Fields you omit are reset to defaults or null.

PUT /tasks/42 { "title": "New title", "status": "TODO" }

If the task had a dueDate, a strict PUT clears it because you didn't include it. PUT is idempotent — sending it twice yields the same result.

PATCH — Change Some Fields¶

PATCH says "merge these changes into the existing resource." Omitted fields are left alone.

PATCH /tasks/42 { "status": "DONE" }

Only status changes; title and dueDate stay. This is what users usually expect from an "edit" form that submits one field.

Which Should You Build?¶

In practice, PATCH is the workhorse. Most UIs edit a subset of fields. Offer PUT when a client genuinely wants to overwrite the whole object (e.g. a settings document).

Validating Partial Updates¶

With Zod, derive a partial schema so every field becomes optional — but require at least one:

ts
4 lines
1const PatchTask = CreateTask.partial().refine(
2  (obj) => Object.keys(obj).length > 0,
3  { message: "Provide at least one field to update" },
4);

The Update Handler¶

ts
17 lines
1export async function PATCH(req, { params }) {
2  const { id } = await params;
3  const session = await requireSession();
4
5  const parsed = PatchTask.safeParse(await req.json());
6  if (!parsed.success) return badRequest(parsed.error);
7
8  // Authorize: only the owner may update
9  const existing = await prisma.task.findUnique({ where: { id } });
10  if (!existing || existing.ownerId !== session.userId) return notFound();
11
12  const task = await prisma.task.update({
13    where: { id },
14    data: parsed.data,           // updatedAt is bumped automatically
15  });
16  return NextResponse.json({ data: task });
17}

Previous

Chapter 5 — Quiz

Next

Authorization: Who Can Change This Row?

Use ← → arrow keys to navigate between lessons