Schema-first approach in NestJS - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the output of this NestJS GraphQL schema-first resolver?

Given this resolver method, what will be the returned value when the query hello is called?

NestJS

import { Resolver, Query } from '@nestjs/graphql';

@Resolver()
export class HelloResolver {
  @Query(() => String)
  hello() {
    return 'Hello, Schema-first!';
  }
}

A Throws a runtime error

B null

C undefined

D "Hello, Schema-first!"

💡 Hint

Look at the return statement inside the resolver method.

The resolver method hello returns the string 'Hello, Schema-first!'. When the GraphQL query hello is called, this string is returned as the response.

📝 Syntax

intermediate

Which option correctly defines a GraphQL schema type in schema-first approach?

Choose the valid GraphQL schema type definition for a User with fields id (ID!) and name (String).

A type User { id: ID! name: String }

B type User { id: ID name: String! }

C type User { id: ID! name: String! }

D type User { id: ID! name: Int }

💡 Hint

Check the required fields and their types carefully.

Option A correctly defines id as a non-nullable ID and name as a nullable String, matching the prompt exactly.

🔧 Debug

advanced

What error does this NestJS schema-first resolver code produce?

Identify the error when running this resolver code:

NestJS

import { Resolver, Query } from '@nestjs/graphql';

@Resolver()
export class UserResolver {
  @Query(() => User)
  getUser() {
    return { id: 1, name: 'Alice' };
  }
}

class User {
  id: string;
  name: string;
}

A TypeError: Cannot read property 'id' of undefined

B GraphQL error: Expected type String, found Int

C SyntaxError: Unexpected token class

D No error, returns user object correctly

💡 Hint

Check the type of the id field in the returned object versus the schema class.

The resolver returns id as a number (1), but the schema expects a string. GraphQL throws an error because it found an Int where a String was expected.

❓ state_output

advanced

What is the value of result after executing this NestJS schema-first query resolver?

Consider this resolver method and the query call getNumbers:

NestJS

import { Resolver, Query, Int } from '@nestjs/graphql';

@Resolver()
export class NumberResolver {
  @Query(() => [Int])
  getNumbers() {
    return [1, 2, 3].map(x => x * 2);
  }
}

// Query: getNumbers

A [2, 4, 6]

B Throws a runtime error

C [0, 2, 4]

D [1, 2, 3]

💡 Hint

Look at the map function multiplying each number by 2.

The array [1, 2, 3] is mapped to a new array where each element is doubled, resulting in [2, 4, 6].

🧠 Conceptual

expert

Which statement best describes the schema-first approach in NestJS GraphQL?

Choose the most accurate description of the schema-first approach.

A Resolvers are written without any schema, and schema is inferred at runtime.

B You write TypeScript classes first, and the schema is generated automatically from them.

C You write GraphQL schema definitions first, then implement resolvers to match the schema.

D Schema and resolvers are written together in a single file using decorators only.

💡 Hint

Think about the order of writing schema and resolvers in schema-first.

Schema-first means you define the GraphQL schema first (usually in .graphql files), then write resolvers to implement the schema.

Practice

1. What is the main idea behind the Schema-first approach in NestJS GraphQL?

easy

A. Use REST endpoints before adding GraphQL

B. Write resolvers first, then generate the schema automatically

C. Define the GraphQL schema first, then write resolvers to match it

D. Skip schema and use only TypeScript interfaces

Solution

1. Step 1: Understand Schema-first approach concept

   Schema-first means you write the GraphQL schema (types, queries, mutations) before coding the logic.

2. Step 2: Match resolvers to schema

   Resolvers are then implemented to fulfill the schema's fields and operations.

3. Final Answer:

   Define the GraphQL schema first, then write resolvers to match it -> Option C

4. Quick Check:

   Schema-first = Define schema first [OK]

Hint: Schema-first means schema before code [OK]

Common Mistakes:

• Thinking resolvers come before schema
• Confusing schema-first with code-first
• Assuming REST is involved
• Skipping schema definition

2. Which of the following is the correct way to define a GraphQL type in a schema-first approach SDL file?

easy

A. type User { id: ID! name: String! }

B. class User { id: number; name: string; }

C. interface User { id: ID; name: String }

D. schema User { id: ID! name: String! }

Solution

1. Step 1: Recognize GraphQL SDL syntax

   GraphQL SDL defines types with the keyword type followed by fields and their types.

2. Step 2: Check each option

   type User { id: ID! name: String! } uses correct SDL syntax. Options B and C use TypeScript syntax, and A uses invalid keyword schema for type definition.

3. Final Answer:

   type User { id: ID! name: String! } -> Option A

4. Quick Check:

   SDL type syntax = type User { id: ID! name: String! } [OK]

Hint: SDL uses 'type' keyword with fields and types [OK]

Common Mistakes:

• Using TypeScript syntax instead of SDL
• Confusing 'schema' keyword with 'type'
• Omitting exclamation marks for required fields

3. Given this schema snippet:

type Query { hello: String! }

And this resolver in NestJS:

@Resolver('Query')
export class HelloResolver {
  @Query()
  hello() {
    return 'Hi there!';
  }
}

What will be the result of querying { hello }?

medium

A. "Hi there!"

B. null

C. Error: Resolver method missing

D. undefined

Solution

1. Step 1: Match schema and resolver

   The schema defines a Query field hello returning a non-null String. The resolver implements a method hello() returning 'Hi there!'.

2. Step 2: Query execution result

   When querying { hello }, the resolver returns 'Hi there!', so the response is the string "Hi there!".

3. Final Answer:

   "Hi there!" -> Option A

4. Quick Check:

   Schema and resolver match = returns 'Hi there!' [OK]

Hint: Resolver method name matches schema field [OK]

Common Mistakes:

• Not matching resolver method name to schema field
• Returning undefined or null in resolver
• Missing @Query decorator

4. Identify the error in this schema-first resolver code snippet:

@Resolver('Query')
export class UserResolver {
  @Query()
  user(id: string) {
    return { id, name: 'Alice' };
  }
}

Assuming the schema defines user(id: ID!): User.

medium

A. Resolver class name must be UserQueryResolver

B. Missing @Args decorator for the id parameter

C. Return type must be a string, not an object

D. Schema should not have arguments in schema-first

Solution

1. Step 1: Check resolver method parameters

   The resolver method user expects an argument id. In NestJS schema-first, arguments must be decorated with @Args() to map schema args.

2. Step 2: Identify missing decorator

   The code misses @Args('id') before the id parameter, so NestJS won't pass the argument correctly.

3. Final Answer:

   Missing @Args decorator for the id parameter -> Option B

4. Quick Check:

   Arguments need @Args decorator [OK]

Hint: Use @Args() for resolver method arguments [OK]

Common Mistakes:

• Forgetting @Args decorator on parameters
• Wrong resolver class naming (not required)
• Returning wrong types
• Thinking schema can't have arguments

5. You have this schema-first GraphQL SDL:

type Mutation {
  updateUser(id: ID!, name: String): User
}

type User {
  id: ID!
  name: String!
}

Which resolver implementation correctly updates the user name and returns the updated user in NestJS?

hard

A. @Mutation()
updateUser(@Args('id') id: string, @Args('name') name: string) {
return { id, name };
}

B. @Mutation()
updateUser(id: string, name: string) {
const user = users.find(u => u.id === id);
user.name = name;
return user;
}

C. @Mutation()
updateUser(@Args() args) {
const user = users.find(u => u.id === args.id);
user.name = args.name;
return user;
}

D. @Mutation()
updateUser(@Args('id') id: string, @Args('name') name?: string) {
const user = users.find(u => u.id === id);
if (user && name) user.name = name;
return user;
}

Solution

1. Step 1: Match resolver signature to schema

   The schema defines updateUser(id: ID!, name: String): User. The resolver must use @Args('id') and optional @Args('name') parameters.

2. Step 2: Check update logic and return

   @Mutation() updateUser(@Args('id') id: string, @Args('name') name?: string) { const user = users.find(u => u.id === id); if (user && name) user.name = name; return user; } finds the user by id, updates name only if provided, and returns the user object, matching schema and logic.

3. Step 3: Analyze other options

   @Mutation() updateUser(id: string, name: string) { const user = users.find(u => u.id === id); user.name = name; return user; } misses @Args decorators, so arguments won't map. @Mutation() updateUser(@Args() args) { const user = users.find(u => u.id === args.id); user.name = args.name; return user; } uses @Args() args but does not check if user exists before setting user.name, causing runtime error if user not found. @Mutation() updateUser(@Args('id') id: string, @Args('name') name: string) { return { id, name }; } returns a new object without updating the stored user.

4. Final Answer:

   The resolver using @Args('id') id: string, @Args('name') name?: string with conditional update logic -> Option D

5. Quick Check:

   Use @Args and update logic correctly [OK]

Hint: Use @Args for each param and update data before return [OK]

Common Mistakes:

• Missing @Args decorators
• Not checking if user exists before update
• Returning new object without updating data
• Using @Args() without destructuring