DB_Address

Discover how to build secure RESTful APIs using NestJS, TypeScript, and various technologies. Delve into authentication, data modeling, error handling, testing, and deployment for scalable, real-world applications.

Yan Sun - Building Real-World Restful APIs with NestJS and TypeScript-02.png

address-book-api.tar.gz

region

access_key_id

secret_access_key

output

nestjs-new

nestjs-2.1-module

nestjs-2-install-start

nestjs-typeorm-2

nestjs-base

nestjs-playground

nestjs-install-hmr-start

nestjs-orm-migration

nestjs-typeorm-2-e2e

nestjs-typeorm-docker

nestjs-2.1-test-auto

nestjs-2.1-module-AWSCLI

Testing Example

NestJS is built on top of the popular Express.js library and provides a modular and structured approach to building server-side applications.

You will take a hands-on approach to constructing a practical RESTful API from the ground up. By leveraging NestJS, TypeScript, and other technologies, you will delve into various topics, such as data modeling with TypeORM and MySQL, authentication and authorization mechanisms, request validation, error handling strategies, testing methodologies, deployment practices, and more.

By the end of this course, you will have gained the essential skills, knowledge, and hands-on experience necessary to build a real-world RESTful API. You will have learned how to scale your application using a public cloud, such as AWS, where your application can serve thousands and millions of customers cost-effectively. This comprehensive learning journey equips you to confidently navigate the intricacies of RESTful API development, ensuring you are well-prepared for NestJS development.

Building Secure RESTful APIs with NestJS: A Practical Guide

The object is sent as it is, without any automatic serialization.


The object is automatically converted to JSON and sent as the HTTP response with a JSON content type.


The object is converted to the XML format and sent as the HTTP response with an XML content type.


NestJS throws a serialization error if a plain JavaScript object is returned.


When returning a JavaScript object from a NestJS endpoint, what happens by default?

When returning a JavaScript object from a NestJS endpoint, what happens by default?

```
import { Expose, Exclude } from 'class-transformer';

export class UserEntity {
  id: number;

  @Expose()
  username: string;

  @Expose()
  email: string;

  @Exclude()
  password: string;
}
```

```
import { Exclude, Exclude } from 'class-transformer';

export class UserEntity {
  @Exclude() 
  id: number;

  @Expose()
  username: string;

  @Expose()
  email: string;

  password: string;
}
```

```
import { SerializeOptions, Exclude } from 'class-transformer';

@SerializeOptions({ strategy: 'exclude' })
export class UserEntity {
  id: number;

  @Expose()
  username: string;

  @Expose()
  email: string;

  password: string;
}

```

```
import { SerializeOptions, Exclude } from 'class-transformer';

@SerializeOptions({ strategy: 'excludeAll' })
export class UserEntity {
  id: number;

  @Expose()
  username: string;

  @Expose()
  email: string;

  password: string;
}

```

Which option sets all properties of the `UserEntity` object to be inaccessible by default and only returns the `name` and `email` properties back?

Which option sets all properties of the <code>UserEntity</code> object to be inaccessible by default and only returns the <code>name</code> and <code>email</code> properties back?

To transform incoming request data or outgoing response

What is the main purpose of a NestJS interceptor?

What is the main purpose of a NestJS interceptor?

Caching HTML pages for a dynamic news website

 Caching user-specific data in a real-time chat application

Caching database query results for a product catalog

Caching real-time stock market data for a trading platform

Which option is the most appropriate to use `CacheInterceptor` in NestJS for optimizing API performance?

Which option is the most appropriate to use <code>CacheInterceptor</code> in NestJS for optimizing API performance?

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

@Injectable()
export class ExampleInterceptor {
  intercept(context, next) {
    return next.handle();
  }
}
```

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

@Injectable()
function ExampleInterceptor(req, res, next) {
  // Interception logic here
}

```

```
import { Middleware, Injectable } from '@nestjs/common';

@Middleware()
class ExampleInterceptor {
  use(req, res, next) {
    // Interception logic here
  }
}

```

```
import { Injectable, NestInterceptor, ExecutionContext, CallHandler } from '@nestjs/common';

@Injectable()
export class ExampleInterceptor implements NestInterceptor {
  intercept(context: ExecutionContext, next: CallHandler) {
    return next.handle();
  }
}
```

Which option correctly defines a custom interceptor in NestJS?

Which option correctly defines a custom interceptor in NestJS?

Test your knowledge of NestJS serialization and interceptors.

Introduction

NestJS Fundamentals

Connecting with REST: Building the Address Book App with NestJS

Understand the Basics of NestJS and RESTful APIs

Validation, Exception Handling, and Logging

Persist Data with TypeORM and MySQL

Serialization and Interceptors

Authentication and Authorization

Persist Data, Authentication, Validation, and Serialization

Testing

Deployment

Testing and Deployment

Conclusion

Appendix

Quiz: Serialization and Interceptors