Service creation in NestJS - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to create a basic NestJS service class.

NestJS

import { Injectable } from '@nestjs/common';

@Injectable()
export class [1] {
  getHello(): string {
    return 'Hello World!';
  }
}

Drag options to blanks, or click blank then click option'

AAppController

BMainService

CAppService

DHelloService

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'AppController' instead of a service name.

Forgetting to add the @Injectable() decorator.

The service class is usually named with 'Service' suffix, and 'AppService' is the common default name.

2fill in blank

medium

Complete the code to inject the service into a controller constructor.

NestJS

import { Controller } from '@nestjs/common';
import { AppService } from './app.service';

@Controller()
export class AppController {
  constructor(private readonly [1]: AppService) {}
}

Drag options to blanks, or click blank then click option'

Aservice

BappService

Cappcontroller

DAppService

Attempts:

3 left

💡 Hint

Common Mistakes

Using the class name 'AppService' as the property name.

Using unrelated names like 'service' or 'appcontroller'.

The injected service is usually named in camelCase matching the class name, here 'appService'.

3fill in blank

hard

Fix the error in the service method to return a string.

NestJS

export class AppService {
  getHello(): [1] {
    return '123';
  }
}

Drag options to blanks, or click blank then click option'

Astring

Bnumber

Cboolean

Dvoid

Attempts:

3 left

💡 Hint

Common Mistakes

Returning a number when the return type is string.

Using 'void' as return type but returning a value.

The method should return a string, so the return type must be 'string' and the return value a string.

4fill in blank

hard

Fill both blanks to create a service method that returns a greeting with a name parameter.

NestJS

export class AppService {
  getGreeting([1]: string): string {
    return `Hello, [2]!`;
  }
}

Drag options to blanks, or click blank then click option'

Aname

Busername

Duser

Attempts:

3 left

💡 Hint

Common Mistakes

Using different names for the parameter and the template variable.

Forgetting to add the parameter type.

The parameter and the template variable must match, here both are 'name'.

5fill in blank

hard

Fill all three blanks to create a service that injects a repository and uses it in a method.

NestJS

import { Injectable } from '@nestjs/common';
import { [1] } from './user.repository';

@Injectable()
export class UserService {
  constructor(private readonly [2]: [1]) {}

  findAll() {
    return this.[2].findAllUsers();
  }
}

Drag options to blanks, or click blank then click option'

AUserRepository

BuserRepository

CUserService

DuserService

Attempts:

3 left

💡 Hint

Common Mistakes

Mixing service and repository names.

Using inconsistent property names.

The repository class is 'UserRepository', injected as 'userRepository', which is used in the method.

Practice

1.

What is the main purpose of creating a service in a NestJS application?

easy

A. To handle HTTP requests directly

B. To style the user interface

C. To define database schemas

D. To hold the business logic separate from controllers

Solution

1. Step 1: Understand the role of services in NestJS

   Services are designed to contain business logic, keeping controllers clean and focused on handling requests.

2. Step 2: Differentiate services from controllers and other parts

   Controllers handle HTTP requests, schemas define data structure, and styling is unrelated to services.

3. Final Answer:

   To hold the business logic separate from controllers -> Option D

4. Quick Check:

   Service purpose = business logic separation [OK]

Hint: Services = business logic holders, not request handlers [OK]

Common Mistakes:

• Confusing services with controllers
• Thinking services handle HTTP requests
• Assuming services define database schemas

2.

Which decorator is used to make a class injectable as a service in NestJS?

easy

A. @Injectable()

B. @Module()

C. @Controller()

D. @Service()

Solution

1. Step 1: Identify the decorator for service injection

   In NestJS, @Injectable() marks a class as a provider that can be injected.

2. Step 2: Differentiate from other decorators

   @Controller() is for controllers, @Module() for modules, and @Service() does not exist in NestJS.

3. Final Answer:

   @Injectable() -> Option A

4. Quick Check:

   Service decorator = @Injectable() [OK]

Hint: Remember: Injectable means ready to inject [OK]

Common Mistakes:

• Using @Controller() instead of @Injectable()
• Confusing @Module() with service decorator
• Assuming @Service() exists in NestJS

3.

Given the following service code, what will be the output when getHello() is called?

import { Injectable } from '@nestjs/common';

@Injectable()
export class HelloService {
  getHello(): string {
    return 'Hello, NestJS!';
  }
}

medium

A. "Hello, NestJS!"

B. undefined

C. Error: Method not found

D. "Hello World!"

Solution

1. Step 1: Analyze the getHello method

   The method returns the string 'Hello, NestJS!'.

2. Step 2: Determine the output of calling getHello()

   Calling getHello() returns exactly the string defined, no errors or undefined.

3. Final Answer:

   "Hello, NestJS!" -> Option A

4. Quick Check:

   Method return = "Hello, NestJS!" [OK]

Hint: Read method return value carefully [OK]

Common Mistakes:

• Assuming method returns undefined
• Confusing output with error messages
• Mixing up string content

4.

Identify the error in this service code snippet:

import { Injectable } from '@nestjs/common';

@Injectable()
export class MathService {
  add(a: number, b: number) {
    return a + b
  }
}

medium

A. Missing parentheses in method declaration

B. Missing return type annotation for add method

C. No error, code is correct

D. Missing semicolon after return statement

Solution

1. Step 1: Check syntax correctness

   The method add correctly takes two numbers and returns their sum. Semicolons are optional in TypeScript.

2. Step 2: Verify method declaration and return type

   Return type annotation is optional; TypeScript infers it. Parentheses are present and correct.

3. Final Answer:

   No error, code is correct -> Option C

4. Quick Check:

   Code syntax = correct [OK]

Hint: Semicolons optional; return types inferred [OK]

Common Mistakes:

• Thinking semicolons are mandatory
• Expecting explicit return type always
• Misreading method syntax

5.

You want to create a service that provides a list of users and inject it into a controller. Which of the following is the correct way to create and inject the service?

1. Create service with @Injectable()
2. Define a method getUsers() returning an array
3. Inject service in controller constructor
4. Use service method inside controller method

hard

A. Create service without @Injectable(), inject with @Inject() decorator

B. Create service with @Injectable(), inject via constructor parameter

C. Create service with @Controller(), inject via property decorator

D. Create service with @Module(), inject manually inside methods

Solution

1. Step 1: Create service with @Injectable()

   This decorator makes the service injectable and reusable.

2. Step 2: Inject service via constructor parameter in controller

   Constructor injection is the NestJS standard for dependency injection.

3. Step 3: Use service methods inside controller methods

   This keeps code modular and clean.

4. Final Answer:

   Create service with @Injectable(), inject via constructor parameter -> Option B

5. Quick Check:

   Service injection = @Injectable() + constructor [OK]

Hint: Use @Injectable() and constructor injection [OK]

Common Mistakes:

• Omitting @Injectable() on service
• Using @Controller() on service
• Injecting service incorrectly with property decorators