Sorting arguments in GraphQL - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ query_result

intermediate

Sorting users by age ascending

Given this GraphQL query to fetch users sorted by age in ascending order, what is the order of user names returned?

GraphQL

query {
  users(sort: {field: "age", direction: ASC}) {
    name
    age
  }
}

A ["Alice", "Bob", "Charlie"]

B ["Charlie", "Bob", "Alice"]

C ["Alice", "Charlie", "Bob"]

D ["Bob", "Alice", "Charlie"]

💡 Hint

Think about sorting numbers from smallest to largest.

The query sorts users by their age in ascending order, so the youngest user appears first.

📝 Syntax

intermediate

Identify the syntax error in sorting argument

Which option contains a syntax error in the sorting argument of this GraphQL query?

GraphQL

query {
  products(sort: {field: "price", direction: DESC}) {
    id
    price
  }
}

A }CSED :noitcerid ,"ecirp" :dleif{ :tros

B sort: {field: "price", direction: DESC}

C sort: {field: "price", direction: "DESC"}

D sort: {field: price, direction: "DESC"}

💡 Hint

Field names in GraphQL arguments must be strings if they are not enums.

Option D misses quotes around the field name 'price', causing a syntax error.

❓ optimization

advanced

Optimizing sorting for large datasets

Which sorting argument approach is best to optimize performance when fetching a large list of items sorted by creation date descending?

GraphQL

query {
  items(sort: {field: "createdAt", direction: DESC}) {
    id
    createdAt
  }
}

A Sort by 'id' instead of 'createdAt' to speed up sorting.

B Fetch all items unsorted and sort on the client side.

C Use server-side sorting with an indexed 'createdAt' field.

D Remove sorting argument to reduce query complexity.

💡 Hint

Think about where sorting is most efficient for large data.

Sorting on the server using an indexed field is faster and uses less bandwidth than client-side sorting.

🧠 Conceptual

advanced

Understanding multi-field sorting arguments

How does the following sorting argument affect the order of results?

sort: [{field: "lastName", direction: ASC}, {field: "firstName", direction: ASC}]

A Sorts results first by lastName ascending, then by firstName ascending within each lastName.

B Sorts results by firstName ascending only, ignoring lastName.

C Sorts results randomly because multiple fields are not supported.

D Sorts results by lastName descending, then firstName ascending.

💡 Hint

Think about sorting by multiple keys in order.

The results are sorted by lastName ascending first. If lastNames are equal, then firstName ascending is used to order those entries.

🔧 Debug

expert

Debugging incorrect sorting direction

A developer wrote this query to sort posts by date descending but results appear sorted ascending. Which option explains the likely cause?

GraphQL

query {
  posts(sort: {field: "date", direction: "desc"}) {
    id
    date
  }
}

A The field name "date" is invalid and causes fallback to default sorting.

B The sorting direction value is case-sensitive and should be "DESC" instead of "desc".

C The query is missing a limit argument causing sorting to fail.

D GraphQL does not support sorting by date fields.

💡 Hint

Check if sorting direction values are case-sensitive enums.

Sorting direction is often case-sensitive. Using "desc" instead of "DESC" can cause the server to ignore the direction or default to ascending.

Practice

1. What does the orderBy argument do in a GraphQL query?

easy

A. It sorts the returned data by a specified field and direction.

B. It filters the data to only include certain fields.

C. It limits the number of results returned.

D. It groups the data by a specific field.

Solution

1. Step 1: Understand the purpose of orderBy

   The orderBy argument is used to arrange data in a specific order based on a field.

2. Step 2: Identify sorting behavior

   It sorts data either ascending (ASC) or descending (DESC) by the chosen field.

3. Final Answer:

   It sorts the returned data by a specified field and direction. -> Option A

4. Quick Check:

   Sorting = orderBy usage [OK]

Hint: Remember: orderBy controls sorting order in queries [OK]

Common Mistakes:

• Confusing orderBy with filtering or limiting results
• Thinking orderBy groups data instead of sorting
• Assuming orderBy changes the data fields returned

2. Which of the following is the correct syntax to sort users by their name in ascending order using orderBy?

easy

A. { users(orderBy: [name, ASC]) { id name } }

B. { users(orderBy: name ASC) { id name } }

C. { users(orderBy: { name: ASC }) { id name } }

D. { users(orderBy: { ASC: name }) { id name } }

Solution

1. Step 1: Review GraphQL orderBy syntax

   The correct syntax uses an object with the field as key and direction as value inside curly braces.

2. Step 2: Match syntax to options

   { users(orderBy: { name: ASC }) { id name } } matches this pattern: { name: ASC }. Others use incorrect formats.

3. Final Answer:

   { users(orderBy: { name: ASC }) { id name } } -> Option C

4. Quick Check:

   Correct orderBy syntax = { users(orderBy: { name: ASC }) { id name } } [OK]

Hint: Use curly braces with field: direction inside orderBy [OK]

Common Mistakes:

• Using parentheses or brackets incorrectly in orderBy
• Placing direction before field name
• Omitting curly braces around orderBy argument

3. Given this GraphQL query:

{ products(orderBy: { price: DESC }) { id name price } }

What will be the order of products in the result?

medium

A. Products sorted by price from highest to lowest.

B. Products sorted by price from lowest to highest.

C. Products sorted alphabetically by name.

D. Products returned in random order.

Solution

1. Step 1: Identify sorting field and direction

   The query uses orderBy: { price: DESC }, meaning sort by price descending.

2. Step 2: Understand descending order

   Descending order means highest values come first, then lower values.

3. Final Answer:

   Products sorted by price from highest to lowest. -> Option A

4. Quick Check:

   DESC means highest to lowest [OK]

Hint: DESC means descending (high to low), ASC means ascending (low to high) [OK]

Common Mistakes:

• Confusing DESC with ascending order
• Assuming sorting is by name instead of price
• Thinking orderBy does not affect order

4. You wrote this query to sort posts by date ascending:

{ posts(orderBy: { date: ASC }) { id title date } }

But you get an error. What is the likely mistake?

medium

A. You must use sortBy instead of orderBy.

B. The orderBy argument should be a list, not an object.

C. The direction ASC is not valid in GraphQL.

D. The date field is missing from the schema.

Solution

1. Step 1: Check schema fields

   If date is not defined in the posts schema, sorting by it causes an error.

2. Step 2: Validate other options

   orderBy accepts an object, ASC is valid, and sortBy is not standard GraphQL.

3. Final Answer:

   The date field is missing from the schema. -> Option D

4. Quick Check:

   Sorting field must exist in schema [OK]

Hint: Ensure sorting field exists in schema before using orderBy [OK]

Common Mistakes:

• Using invalid direction keywords
• Confusing orderBy with other arguments
• Assuming orderBy requires a list always

5. You want to fetch a list of employees sorted first by department ascending, then by salary descending. Which orderBy argument correctly achieves this?

hard

A. { employees(orderBy: { department: ASC, salary: DESC }) { id name department salary } }

B. { employees(orderBy: [{ department: ASC }, { salary: DESC }]) { id name department salary } }

C. { employees(orderBy: [department: ASC, salary: DESC]) { id name department salary } }

D. { employees(orderBy: { salary: DESC, department: ASC }) { id name department salary } }

Solution

1. Step 1: Understand multi-level sorting syntax

   To sort by multiple fields, orderBy usually takes a list of objects, each specifying a field and direction.

2. Step 2: Match correct syntax

   { employees(orderBy: [{ department: ASC }, { salary: DESC }]) { id name department salary } } uses a list with two objects: first { department: ASC }, then { salary: DESC }, which is correct.

3. Step 3: Check other options

   { employees(orderBy: { department: ASC, salary: DESC }) { id name department salary } } uses a single object with two keys, which may not guarantee order. { employees(orderBy: [department: ASC, salary: DESC]) { id name department salary } } has invalid syntax. { employees(orderBy: { salary: DESC, department: ASC }) { id name department salary } } reverses sorting priority.

4. Final Answer:

   { employees(orderBy: [{ department: ASC }, { salary: DESC }]) { id name department salary } } -> Option B

5. Quick Check:

   Multi-field orderBy = list of objects [OK]

Hint: Use a list of objects for multi-level sorting in orderBy [OK]

Common Mistakes:

• Using a single object for multiple sort fields
• Reversing the order of sorting priorities
• Incorrect syntax for list of sorting fields