TypeScript-first philosophy in NestJS - Mini Project: Build & Apply

Building a Simple NestJS Service with TypeScript-First Philosophy

📖 Scenario: You are creating a small backend service using NestJS. NestJS encourages a TypeScript-first approach, meaning you write your data types and logic in TypeScript first, which helps catch errors early and makes your code easier to understand.In this project, you will create a simple service that manages a list of books with their titles and authors.

🎯 Goal: Build a NestJS service that stores a list of books using TypeScript interfaces and classes. You will define the data structure, configure a service variable, implement a method to retrieve books, and complete the service class.

📋 What You'll Learn

Create a TypeScript interface for a Book with title and author as strings

Create a service class called BooksService

Add a private array variable books of type Book[] with initial data

Implement a method getAllBooks() that returns the array of books

Complete the service class with the correct export statement

💡 Why This Matters

🌍 Real World

Backend services often manage data with clear types to avoid bugs. NestJS uses TypeScript-first philosophy to help developers write safer and clearer code.

💼 Career

Understanding how to define data types and services in NestJS is essential for backend development roles using modern TypeScript frameworks.

1

Define the Book interface

Create a TypeScript interface called Book with two string properties: title and author.

NestJS

// Define the Book interface with title and author as strings
// Your code here

Hint

Use the interface keyword to define the shape of a book object.

2

Create the BooksService class with initial data

Create a class called BooksService. Inside it, add a private variable called books of type Book[] and initialize it with two books: { title: 'The Hobbit', author: 'J.R.R. Tolkien' } and { title: '1984', author: 'George Orwell' }.

NestJS

export interface Book {
  title: string;
  author: string;
}

// Create BooksService class with private books array
// Your code here

Hint

Use private books: Book[] = [...] inside the class to store the books.

3

Add a method to get all books

Inside the BooksService class, add a public method called getAllBooks() that returns the books array.

NestJS

export interface Book {
  title: string;
  author: string;
}

export class BooksService {
  private books: Book[] = [
    { title: 'The Hobbit', author: 'J.R.R. Tolkien' },
    { title: '1984', author: 'George Orwell' }
  ];

  // Add getAllBooks method below
  // Your code here
}

Hint

Define a method that returns the private books array.

4

Export the BooksService class

Make sure the BooksService class is exported so it can be used in other parts of the application.

NestJS

export interface Book {
  title: string;
  author: string;
}

// Ensure BooksService class is exported
// Your code here

Hint

Use the export keyword before the class declaration.

Practice

1. What is the main benefit of the TypeScript-first philosophy in NestJS?

easy

A. It makes the app run faster at runtime.

B. It removes the need for any testing.

C. It helps catch errors early by using types.

D. It allows writing code without any types.

Solution

1. Step 1: Understand TypeScript's role

   TypeScript adds types to JavaScript, which helps find mistakes before running the code.

2. Step 2: Connect to NestJS philosophy

   NestJS uses TypeScript-first to improve code safety and clarity by leveraging types.

3. Final Answer:

   It helps catch errors early by using types. -> Option C

4. Quick Check:

   TypeScript-first = catch errors early [OK]

Hint: TypeScript-first means using types to find errors early [OK]

Common Mistakes:

• Thinking it makes runtime faster
• Believing it removes need for tests
• Assuming it means no types needed

2. Which of the following is the correct way to define a typed controller method in NestJS using TypeScript-first philosophy?

easy

A. async getUser(): Promise<User> { return this.userService.find(); }

B. async getUser() { return this.userService.find(); }

C. async getUser(): any { return this.userService.find(); }

D. async getUser(): string { return this.userService.find(); }

Solution

1. Step 1: Check method return type

   TypeScript-first means explicitly typing the return value, here Promise<User>.

2. Step 2: Compare options

   async getUser(): Promise<User> { return this.userService.find(); } uses correct typing; others omit or use wrong types like any or string.

3. Final Answer:

   async getUser(): Promise<User> { return this.userService.find(); } -> Option A

4. Quick Check:

   Explicit return type = async getUser(): Promise<User> { return this.userService.find(); } [OK]

Hint: Always specify method return types explicitly [OK]

Common Mistakes:

• Omitting return type annotation
• Using 'any' instead of specific types
• Using wrong return types like string

3. Given this NestJS service method using TypeScript-first philosophy:

async findUser(id: number): Promise {
  const user = await this.userRepository.findOneBy({ id });
  return user ?? null;
}

What is the type of the value returned when no user is found?

medium

A. undefined

B. an empty object {}

C. throws an error

D. null

Solution

1. Step 1: Analyze return statement

   The method returns user ?? null, which means if user is nullish, return null.

2. Step 2: Understand nullish coalescing

   If findOneBy returns undefined, the expression returns null explicitly.

3. Final Answer:

   null -> Option D

4. Quick Check:

   Nullish coalescing returns null if no user [OK]

Hint: ?? operator returns right side if left is null or undefined [OK]

Common Mistakes:

• Assuming undefined is returned
• Thinking an error is thrown
• Expecting empty object instead of null

4. Identify the error in this NestJS controller method using TypeScript-first philosophy:

@Get(':id')
async getUser(@Param('id') id: string): Promise<User> {
  return this.userService.findUser(id);
}

medium

A. The method should not be async if it returns a Promise.

B. The return type should be Promise if user might not exist.

C. The parameter id should be typed as number not string.

D. The decorator @Get is missing a path.

Solution

1. Step 1: Check return type correctness

   If findUser can return null when user not found, the controller must reflect that in its return type.

2. Step 2: Compare options

   The return type should be Promise if user might not exist. correctly points out the return type should allow null. The parameter id should be typed as number not string. is not always true because id can be string if parsed later.

3. Final Answer:

   The return type should be Promise if user might not exist. -> Option B

4. Quick Check:

   Return type must match possible null values [OK]

Hint: Return types must include null if possible [OK]

Common Mistakes:

• Ignoring possible null return
• Thinking async keyword is wrong here
• Assuming @Get needs path always

5. You want to create a NestJS DTO (Data Transfer Object) that enforces a required name string and an optional age number using TypeScript-first philosophy. Which of these is the best TypeScript definition?

hard

A. export class CreateUserDto { name: string; age?: number; }

B. export interface CreateUserDto { name?: string; age: number; }

C. export type CreateUserDto = { name?: string; age?: number; };

D. export class CreateUserDto { name?: string; age: number; }

Solution

1. Step 1: Identify required and optional properties

   The name must be required (no question mark), age optional (with question mark).

2. Step 2: Match with options

   export class CreateUserDto { name: string; age?: number; } correctly defines name as required and age as optional in a class, which is standard for NestJS DTOs.

3. Final Answer:

   export class CreateUserDto { name: string; age?: number; } -> Option A

4. Quick Check:

   Required name, optional age = export class CreateUserDto { name: string; age?: number; } [OK]

Hint: Use '?' for optional properties, omit for required [OK]

Common Mistakes:

• Marking required fields as optional
• Using interface instead of class for DTO
• Making optional fields required