DB_Address

This course teaches you how to build robust and secure RESTful APIs using the NestJS framework.

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

To handle business logic and validation for data operations

To establish the connection and authentication with the database.

To encapsulate and manage the database CRUD operations for a specific entity

To define the schema and structure of the data model

Using the TypeORM repository pattern, what is the primary purpose of a repository?

Using the TypeORM repository pattern, what is the primary purpose of a repository?

Set up TypeORM configurations directly in the source code files without externalizing them.

Use the `TypeOrmModule.forRoot()` method with environment-specific options, allowing dynamic database configuration based on the environment.

Create separate instances of `TypeOrmModule` for each environment and use conditional imports in the root module to select an instance based on the current environment.

Implement environment-specific configuration through the custom decorators within the entity classes. These decorators dynamically adjust database connection parameters based on the current environment.

Which configuration approach is commonly used to set up TypeORM for different environments in a NestJS app?

Which configuration approach is commonly used to set up TypeORM for different environments in a NestJS app?

The code-first approach involves designing the database schema manually and generating TypeORM entities from the existing schema.

The code-first approach requires creating the SQL queries directly within the NestJS application to optimize database access.

The code-first approach relies on utilizing predefined database schemas and adapting the application’s code to match these schemas.

The code-first approach focuses on defining TypeORM entities using the NestJS decorators in code, with the database schema being automatically generated based on these entity definitions.

Which statement is true for the code-first approach using TypeORM in NestJS? 

Which statement is true for the code-first approach using TypeORM in NestJS?

```
const query = getRepository(Entity)
  .createQueryBuilder("entity")
  .orderBy("entity.column1", "ASC")
  .addOrderBy("entity.column2", "DESC")
  .take(10)
  .skip(20)
  .getMany();

```

```
const query = getRepository(Entity)
  .createQueryBuilder("entity")
  .orderBy("entity.column1", "ASC")
  .orderBy("entity.column2", "DESC")
  .limit(10)
  .offset(10)
  .getMany();

```

```
const query = getRepository(Entity)
  .createQueryBuilder("entity")
  .orderBy("entity.column1", "ASC")
  .addOrderBy("entity.column2", "DESC")
  .take(10)
  .skip(10)
  .getMany();

```

```
const query = getRepository(Entity)
  .createQueryBuilder("entity")
  .orderBy("entity.column1", "DESC")
  .addOrderBy("entity.column2", "DESC")
  .limit(10)
  .offset(20)
  .getMany();

```

Which option represents the correct way for a TypeORM QueryBuilder query in NestJS to perform a `SELECT` operation with the following criteria?
- Order by `column1` in ascending order, then by `column2` in descending order.
- Limit the returned results to 10 rows per page.
- Return the second page.

Which option represents the correct way for a TypeORM QueryBuilder query in NestJS to perform a <code>SELECT</code> operation with the following criteria?
<ul>
<li>Order by <code>column1</code> in ascending order, then by <code>column2</code> in descending order.</li>
<li>Limit the returned results to 10 rows per page.</li>
<li>Return the second page.</li>
</ul>

```
@Entity()
export class User {
  @PrimaryGeneratedColumn()
  id: number;

  @OneToOne(() => Passport, (passport) => passport.user)
  @JoinColumn()
  passport: Passport;
}

@Entity()
export class Passport {
  @PrimaryGeneratedColumn()
  id: number;

  @OneToOne(() => User, (user) => user.passport)
  user: User;
}

```

```
@Entity()
export class User {
  @PrimaryGeneratedColumn()
  id: number;

  @OneToOne(() => Passport)
  passport: Passport;
}

@Entity()
export class Passport {
  @PrimaryGeneratedColumn()
  id: number;

  @OneToOne(() => User)
  @JoinColumn()
  user: User;
}

```

```
@Entity()
export class User {
  @PrimaryGeneratedColumn()
  id: number;

  @OneToOne(() => Passport, { referencedColumnName: 'id' })
  @JoinColumn()
  passport: Passport;
}

@Entity()
export class Passport {
  @PrimaryGeneratedColumn()
  id: number;
}

```

```
@Entity()
export class User {
  @PrimaryGeneratedColumn()
  id: number;

  @OneToOne(() => Passport, (passport) => passport.user)
  passport: Passport;
}

@Entity()
export class Passport {
  @PrimaryGeneratedColumn()
  id: number;

  @OneToOne(() => User, (user) => user.passport)
  user: User;
}

```

Choose the correct implementation of a bidirectional one-to-one relation between the `user` and `passport` entities from the options given below:

Choose the correct implementation of a bidirectional one-to-one relation between the <code>user</code> and <code>passport</code> entities from the options given below:

It specifies that related entities should be loaded and saved eagerly whenever the parent entity is loaded or saved.

It automatically deletes the related entity when the parent entity is deleted, ensuring data integrity and consistency.

It enforces a constraint that prevents related entities from being updated if the parent entity has pending changes.

 It triggers a bulk insert operation for related entities when the parent entity is inserted, optimizing the database performance.

When configuring entities with one-to-many relationships, what is the `Cascade` setting used for?

When configuring entities with one-to-many relationships, what is the <code>Cascade</code> setting used for?

Modifying existing migration files directly to accommodate additional changes, ensuring a single-file approach

To efficiently roll back multiple migrations, execute the `typeorm migration:rollback` command with the desired number of steps to revert the schema changes progressively. 

Use version control—for example, Git—to track changes to migration files and collaborate with a team on the database schema changes.



Implementing rollback scripts for each migration, allowing for a smooth and reversible process in case of issues during deployment

**(Select all that apply.)** Choose all the correct statements below for best practice when working with migrations in a TypeORM and NestJS app.

(Select all that apply.) Choose all the correct statements below for best practice when working with migrations in a TypeORM and NestJS app.

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: NestJS TypeORM