NestJS Enterprise Backend APIs · Lekcja

Podstawy integracji TypeORM

Skonfiguruj TypeORM z NestJS, definiuj encje i wykonuj podstawowe operacje na bazie danych za pomocą repozytoriów.

Lekcja 3 z 311 kroki

Podstawy integracji TypeORM to bezpłatna lekcja NestJS Enterprise Backend APIs na CoddyKit. To lekcja 3 z 3. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej NestJS Enterprise Backend APIs, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs NestJS Enterprise Backend APIs zawiera 3 lekcji w sumie.

Części tej lekcji nie zostały jeszcze przetłumaczone i są wyświetlane po angielsku.

Intro to TypeORM in NestJS

Welcome to integrating TypeORM with NestJS! TypeORM is an Object-Relational Mapper (ORM) that helps you work with databases using TypeScript or JavaScript.

Instead of writing raw SQL queries, you interact with your database using familiar object-oriented programming concepts like classes and objects.

Why Use an ORM?

ORMs like TypeORM offer several benefits:

Abstraction: No need to write complex SQL.
Type Safety: With TypeScript, your database interactions are type-checked.
Portability: Easily switch between different database systems (PostgreSQL, MySQL, SQLite, etc.).
Productivity: Faster development with less boilerplate code.

Setting Up TypeORM Module

First, we need to install TypeORM and the database driver for your chosen database (e.g., pg for PostgreSQL, sqlite3 for SQLite).

Then, we configure the TypeOrmModule in your main application module (usually AppModule) to establish the database connection.

TypeOrmModule Configuration

Here's how you might configure TypeORM in your app.module.ts. This example uses SQLite for simplicity, which stores data in a file.

We use TypeOrmModule.forRoot() to set up the connection globally.

import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';

@Module({
  imports: [
    TypeOrmModule.forRoot({
      type: 'sqlite',
      database: 'db.sqlite',
      entities: [], // We'll add our entities here soon!
      synchronize: true, // Auto-create tables (dev only!)
    }),
  ],
  controllers: [],
  providers: [],
})
export class AppModule {}

Defining Your First Entity

An Entity is a class that maps directly to a database table. Each instance of the entity class represents a row in that table.

We use decorators like @Entity(), @PrimaryGeneratedColumn(), and @Column() to define the table and its columns.

User Entity Example

Let's create a simple User entity. This will map to a user table in our database.

@PrimaryGeneratedColumn() creates an auto-incrementing primary key.
@Column() defines a regular column.

import { Entity, PrimaryGeneratedColumn, Column } from 'typeorm';

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

  @Column()
  firstName: string;

  @Column()
  lastName: string;

  @Column({ default: true })
  isActive: boolean;
}

Registering Entities in Module

After defining your entity, you need to tell TypeORM about it. Update your AppModule's TypeOrmModule.forRoot() configuration to include your new User entity.

This allows TypeORM to create the corresponding table in your database.

import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { User } from './user.entity'; // Import your entity

@Module({
  imports: [
    TypeOrmModule.forRoot({
      type: 'sqlite',
      database: 'db.sqlite',
      entities: [User], // Register your User entity here
      synchronize: true,
    }),
  ],
  controllers: [],
  providers: [],
})
export class AppModule {}

Introducing Repositories

TypeORM Repositories are objects that provide methods for interacting with a specific entity's table in the database.

You inject a repository into your NestJS service (e.g., UserService) to perform CRUD operations (Create, Read, Update, Delete).

Basic Operations: Create & Read

To use a repository, you inject it using @InjectRepository(). Let's see how to create a new user and retrieve all users.

save(): Inserts a new record or updates an existing one.
find(): Retrieves all records for the entity.

import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import { User } from './user.entity';

@Injectable()
export class UserService {
  constructor(
    @InjectRepository(User)
    private usersRepository: Repository<User>,
  ) {}

  async createUser(): Promise<User> {
    const newUser = this.usersRepository.create({
      firstName: 'Coddy',
      lastName: 'Kit',
      isActive: true,
    });
    return this.usersRepository.save(newUser);
  }

  async findAll(): Promise<User[]> {
    return this.usersRepository.find();
  }
}

TypeORM Quick Check

Which decorator is used to mark a class as an entity that maps to a database table in TypeORM?

Odpowiedz w interaktywnej lekcji

Recap: TypeORM Basics

You've learned the basics of integrating TypeORM into your NestJS application!

We configured TypeOrmModule in our AppModule.
We defined an Entity using decorators like @Entity(), @PrimaryGeneratedColumn(), and @Column().
We understood how to use Repositories to perform basic database operations like creating and reading records.

Next, you'll explore more advanced CRUD operations and data handling techniques!

Bezpłatny start

Ucz się TypeScript dzięki korepetycjom AI — za darmo

Pisz i uruchamiaj kod w przeglądarce, otrzymuj natychmiastową pomoc od korepetytora AI dostępnego 24/7 i kontynuuj naukę w sieci lub w aplikacji.

Kursy: 20
Lekcje: 76

Zacznij naukę bezpłatnie Wyświetl pełny kurs

Często zadawane pytania

Czy lekcja „Podstawy integracji TypeORM” jest bezpłatna?

Tak — pełny tekst „Podstawy integracji TypeORM” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu NestJS Enterprise Backend APIs, przejdź na CoddyKit PRO. Kurs NestJS Enterprise Backend APIs zawiera 3 lekcji w sumie.

Co nauczysz się w „Podstawy integracji TypeORM”?

Skonfiguruj TypeORM z NestJS, definiuj encje i wykonuj podstawowe operacje na bazie danych za pomocą repozytoriów. Ćwiczysz NestJS Enterprise Backend APIs z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć NestJS Enterprise Backend APIs?

Nie wymagamy żadnego doświadczenia. NestJS Enterprise Backend APIs w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 3 z 3.

Ile czasu zajmuje lekcja „Podstawy integracji TypeORM”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji NestJS Enterprise Backend APIs?

Tak. Każda lekcja NestJS Enterprise Backend APIs zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do NestJS Enterprise Backend APIs