Nested error reporting in Rest API - Step-by-Step Execution

Concept Flow - Nested error reporting

Receive API Request

↓

Validate Outer Data

↓

Validate Inner Data

↓

Process Request

↓

Return Success Response

The API receives a request, validates outer data first, then inner data if outer is valid, and returns errors nested inside the response if any validation fails.

Execution Sample

Rest API

POST /api/data
{
  "user": {"id": 123, "name": ""}
}

Response: {
  "error": {
    "user": {
      "name": "Name cannot be empty"
    }
  }
}

This example shows a POST request with nested user data where the inner 'name' field is empty, triggering a nested error response.

Execution Table

Step	Action	Check	Result	Next Step
1	Receive API request	N/A	Request data received	Validate outer data
2	Validate outer data	Is 'user' present?	Yes	Validate inner data
3	Validate inner data	Is 'user.id' valid?	Yes	Check 'user.name'
4	Validate inner data	Is 'user.name' non-empty?	No	Return nested error for 'user.name'
5	Return nested error	N/A	{"error":{"user":{"name":"Name cannot be empty"}}}	End
6	End	N/A	Response sent with nested error	Stop

💡 Validation failed at inner 'user.name', so nested error response is returned.

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 4	Final
request_data	{}	{"user":{"id":123,"name":""}}	{"user":{"id":123,"name":""}}	{"user":{"id":123,"name":""}}	{"user":{"id":123,"name":""}}
error_response	null	null	null	{"error":{"user":{"name":"Name cannot be empty"}}}	{"error":{"user":{"name":"Name cannot be empty"}}}

Key Moments - 2 Insights

Why does the error appear nested inside 'user' instead of at the top level?

Because the validation checks inner fields, errors are grouped inside the related object to clearly show which part failed, as shown in step 5 of the execution_table.

What happens if the outer 'user' field is missing?

The validation stops early and returns an outer error immediately, skipping inner checks, as shown in step 2 branching to error in the concept_flow.

Visual Quiz - 3 Questions

Look at the execution_table, at which step is the inner 'user.name' field checked?

A Step 2

B Step 4

C Step 3

D Step 5

💡 Hint

Check the 'Check' column for 'Is user.name non-empty?' in the execution_table.

According to variable_tracker, what is the value of 'error_response' after step 3?

A null

B {"error":{"user":{"name":"Name cannot be empty"}}}

C {}

D {"user":{"id":123,"name":""}}

💡 Hint

Look at the 'error_response' row under 'After Step 3' in variable_tracker.

If 'user.name' was valid, what would be the next step after step 4 in execution_table?

A Return nested error

B Return outer error

C Process request

D End

💡 Hint

Refer to the concept_flow where successful inner validation leads to processing the request.

Concept Snapshot

Nested error reporting in REST APIs:
- Validate outer data first.
- If outer valid, validate inner data.
- Return errors nested inside related fields.
- Helps clients know exactly where errors are.
- Stops validation early on outer errors.

Full Transcript

This visual execution shows how nested error reporting works in a REST API. The API receives a request with nested data. It first checks the outer data, like if the 'user' object exists. If that passes, it checks inner fields like 'user.id' and 'user.name'. If an inner field is invalid, it returns an error nested inside the related object, for example, an error inside 'user' for the 'name' field. The execution table traces each step, showing checks and results. The variable tracker shows how the request data and error response change. Key moments clarify why errors are nested and what happens if outer data is missing. The quiz tests understanding of when checks happen and how errors are structured. This helps beginners see exactly how nested error reporting flows in an API.

Practice

1.

What is the main purpose of nested error reporting in REST APIs?

easy

A. To show detailed errors inside nested data clearly

B. To hide errors from users

C. To speed up the API response time

D. To encrypt error messages

Solution

1. Step 1: Understand error reporting basics

   Error reporting helps identify problems in API requests or responses.

2. Step 2: Recognize nested error reporting role

   Nested error reporting shows errors inside complex or nested data structures clearly.

3. Final Answer:

   To show detailed errors inside nested data clearly -> Option A

4. Quick Check:

   Nested error reporting = detailed nested errors [OK]

Hint: Nested errors explain problems inside complex data [OK]

Common Mistakes:

• Thinking nested errors hide problems
• Confusing error reporting with encryption
• Assuming it speeds up API responses

2.

Which JSON structure correctly represents a nested error for a REST API response?

{
  "error": {
    "message": "Invalid input",
    "details": {
      "field": "email",
      "error": "Invalid format"
    }
  }
}

easy

A. { "error": "Invalid input", "details": "email error" }

B. { "message": "Invalid input", "field": "email" }

C. { "error": ["Invalid input", "email error"] }

D. { "error": { "message": "Invalid input", "details": { "field": "email", "error": "Invalid format" } } }

Solution

1. Step 1: Identify nested JSON error format

   Nested error reporting uses objects inside objects to show details clearly.

2. Step 2: Match the correct JSON structure

   { "error": { "message": "Invalid input", "details": { "field": "email", "error": "Invalid format" } } } shows an error object with a message and nested details object with field and error.

3. Final Answer:

   { "error": { "message": "Invalid input", "details": { "field": "email", "error": "Invalid format" } } } -> Option D

4. Quick Check:

   Nested JSON error = { "error": { "message": "Invalid input", "details": { "field": "email", "error": "Invalid format" } } } [OK]

Hint: Look for nested objects inside error key [OK]

Common Mistakes:

• Using arrays instead of objects for nested errors
• Missing nested details object
• Flattening error info without nesting

3.

Given this REST API error response JSON, what is the error message for the password field?

{
  "error": {
    "message": "Validation failed",
    "fields": {
      "email": "Invalid format",
      "password": "Too short"
    }
  }
}

medium

A. Validation failed

B. Invalid format

C. Too short

D. No error

Solution

1. Step 1: Locate the password field in JSON

   The password error is inside error.fields.password.

2. Step 2: Read the error message for password

   The value is "Too short", indicating the password error.

3. Final Answer:

   Too short -> Option C

4. Quick Check:

   password error message = "Too short" [OK]

Hint: Find error under error.fields.password [OK]

Common Mistakes:

• Choosing top-level message instead of field error
• Confusing email error with password error
• Ignoring nested fields object

4.

Identify the error in this nested error JSON response:

{
  "error": {
    "message": "Invalid data",
    "details": [
      { "field": "username", "error": "Required" },
      { "field": "age", "error": 25 }
    ]
  }
}

medium

A. The 'error' value for 'age' should be a string, not a number

B. The 'details' key should be a string, not an array

C. The 'message' key is missing

D. The 'field' keys should be numbers

Solution

1. Step 1: Check error value types in details array

   Each error value should be a descriptive string, not a number.

2. Step 2: Identify incorrect error value

   The 'age' field has error value 25 (number), which is incorrect.

3. Final Answer:

   The 'error' value for 'age' should be a string, not a number -> Option A

4. Quick Check:

   Error values must be strings [OK]

Hint: Error messages must be strings, not numbers [OK]

Common Mistakes:

• Ignoring type mismatch in error values
• Thinking details must be string instead of array
• Missing the message key

5.

You want to design a nested error response for a REST API that validates a user profile with nested address fields. Which JSON structure best represents errors for both the email and nested address.zipcode fields?

hard

A. { "error": { "email": "Invalid", "address.zipcode": "Missing" } }

B. { "error": { "fields": { "email": "Invalid", "address": { "zipcode": "Missing" } } } }

C. { "error": [ { "email": "Invalid" }, { "address": { "zipcode": "Missing" } } ] }

D. { "error": "Invalid email and missing zipcode" }

Solution

1. Step 1: Understand nested error reporting for nested fields

   Nested fields like address.zipcode should be represented as nested objects.

2. Step 2: Evaluate JSON options for nested structure

   { "error": { "fields": { "email": "Invalid", "address": { "zipcode": "Missing" } } } } uses a 'fields' object with 'email' error and nested 'address' object containing 'zipcode' error.

3. Final Answer:

   { "error": { "fields": { "email": "Invalid", "address": { "zipcode": "Missing" } } } } -> Option B

4. Quick Check:

   Nested fields use nested objects = { "error": { "fields": { "email": "Invalid", "address": { "zipcode": "Missing" } } } } [OK]

Hint: Use nested objects for nested field errors [OK]

Common Mistakes:

• Using dot notation keys instead of nested objects
• Flattening nested errors into arrays
• Combining all errors into one string