NestJS Enterprise Backend APIs · Pelajaran

Dasar Integrasi TypeORM

Siapkan TypeORM dengan NestJS, tentukan entitas, dan jalankan operasi basis data dasar menggunakan repositori.

Dasar Integrasi TypeORM adalah pelajaran NestJS Enterprise Backend APIs gratis di CoddyKit. Ini adalah pelajaran 3 dari 3. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar NestJS Enterprise Backend APIs, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus NestJS Enterprise Backend APIs mencakup 3 pelajaran total.

Bagian dari pelajaran ini belum diterjemahkan dan ditampilkan dalam bahasa Inggris.

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?

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!

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Dasar Integrasi TypeORM” gratis?

Ya — teks lengkap “Dasar Integrasi TypeORM” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus NestJS Enterprise Backend APIs, upgrade ke CoddyKit PRO. Kursus NestJS Enterprise Backend APIs mencakup 3 pelajaran total.

Apa yang akan aku pelajari di “Dasar Integrasi TypeORM”?

Siapkan TypeORM dengan NestJS, tentukan entitas, dan jalankan operasi basis data dasar menggunakan repositori. Kamu berlatih NestJS Enterprise Backend APIs dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai NestJS Enterprise Backend APIs?

Tidak diperlukan pengalaman sebelumnya. NestJS Enterprise Backend APIs di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 3 dari 3.

Berapa lama pelajaran “Dasar Integrasi TypeORM” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran NestJS Enterprise Backend APIs ini?

Ya. Setiap pelajaran NestJS Enterprise Backend APIs menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

← Kembali ke NestJS Enterprise Backend APIs