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

Challenge - 5 Problems

❓ component_behavior

intermediate

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

Consider this NestJS GraphQL resolver using the code-first approach. What will be the GraphQL query response for hello()?

NestJS

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

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

A { "data": { "hello": "Hello, NestJS!" } }

B { "data": { "hello": "hello" } }

C { "data": { "Hello": "Hello, NestJS!" } }

D { "error": "Query not found" }

💡 Hint

Look at the method name and the returned string value.

The resolver defines a query named 'hello' that returns the string 'Hello, NestJS!'. The GraphQL response wraps this in a 'data' object with the query name as the key.

📝 Syntax

intermediate

Which option correctly defines a GraphQL ObjectType with a field in NestJS code-first?

You want to create a GraphQL ObjectType named Cat with a string field name. Which code snippet is correct?

A

import { ObjectType, Field } from '@nestjs/graphql';

@ObjectType()
export class Cat {
  name: string;
}

B

import { ObjectType, Field } from '@nestjs/graphql';

@ObjectType()
export class Cat {
  @Field()
  name: string;
}

C

import { ObjectType, Field } from '@nestjs/graphql';

@ObjectType
export class Cat {
  @Field(String)
  name: string;
}

D

import { ObjectType, Field } from '@nestjs/graphql';

@ObjectType()
export class Cat {
  @Field(() => Number)
  name: string;
}

💡 Hint

Remember the decorator syntax and type hints for fields.

Option B correctly uses @ObjectType() and @Field() decorators. The field 'name' is a string and @Field() without arguments defaults to String type.

❓ state_output

advanced

What is the output of this NestJS code-first mutation resolver?

Given this mutation resolver, what will be the GraphQL mutation response when calling incrementCounter twice?

NestJS

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

@Resolver()
export class CounterResolver {
  private count = 0;

  @Mutation(() => Number)
  incrementCounter() {
    this.count += 1;
    return this.count;
  }
}

A First call: { "error": "Cannot read property 'count'" }

B First call: { "data": { "incrementCounter": 0 } }, Second call: { "data": { "incrementCounter": 0 } }

C First call: { "data": { "incrementCounter": 1 } }, Second call: { "data": { "incrementCounter": 2 } }

D First call: { "data": { "incrementCounter": 1 } }, Second call: { "data": { "incrementCounter": 1 } }

💡 Hint

Think about the private variable and how it changes with each call.

The private variable 'count' starts at 0 and increments by 1 each time the mutation is called, so the first call returns 1 and the second returns 2.

🔧 Debug

advanced

What error does this NestJS code-first resolver produce?

Examine this resolver code. What error will occur when the GraphQL server starts?

NestJS

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

@Resolver()
export class SampleResolver {
  @Query(() => String)
  greet() {
    return 123;
  }
}

A No error, returns '123' as string

B RuntimeError: Resolver method missing return statement

C SyntaxError: Unexpected number literal

D TypeError: Query 'greet' must return a string, but returned a number

💡 Hint

Look at the return type declared and the actual returned value.

The @Query decorator expects a string return type, but the method returns a number, causing a type mismatch error.

🧠 Conceptual

expert

Why is the code-first approach beneficial in NestJS GraphQL development?

Choose the best explanation for the main advantage of using the code-first approach in NestJS GraphQL.

A It allows defining GraphQL schema using TypeScript classes and decorators, enabling type safety and IDE support.

B It automatically generates REST endpoints without extra configuration.

C It requires writing GraphQL SDL files manually for better control.

D It disables type checking to speed up development.

💡 Hint

Think about how code-first relates to TypeScript and schema generation.

Code-first uses TypeScript classes and decorators to generate GraphQL schema, improving type safety and developer experience.