NestJS Enterprise Backend APIs · レッスン

TypeORMによるCRUD操作

TypeORMのリポジトリを使って、エンティティの作成、読み取り、更新、削除機能を一通り実装します。

「TypeORMによるCRUD操作」はCoddyKit上の無料NestJS Enterprise Backend APIsレッスンです。これはレッスン2/3です。下記で完全なレッスンを無料で読むことができます。その後、ブラウザ内の組み込みコードエディタと24時間対応のAIチューターでハンズオン演習できます。これはNestJS Enterprise Backend APIs学習パスの一部であり、ウェブとCoddyKitアプリ全体で進捗が同期されます。 NestJS Enterprise Backend APIsコースには全3レッスンが含まれています。

このレッスンの一部はまだ翻訳されておらず、英語で表示されています。

CRUD Basics with TypeORM

Welcome! In this lesson, we'll master CRUD operations using TypeORM, a powerful Object-Relational Mapper for TypeScript.

CRUD stands for Create, Read, Update, and Delete. These are the four fundamental operations for managing data in almost any application.

TypeORM simplifies interacting with your database by mapping database rows to TypeScript objects, making these operations intuitive.

Defining Our Product Entity

Before performing CRUD, we need an entity. An entity is a class that maps directly to a database table. Let's imagine a simple Product entity for our examples.

In TypeORM, you'd use decorators like @Entity(), @PrimaryGeneratedColumn(), and @Column() to define its structure and how it maps to your database schema.

Understanding the Repository

TypeORM uses the repository pattern. A repository is like a specialized collection that handles data access for a specific entity (e.g., a ProductRepository for Product entities).

You inject this repository into your services and use its methods to perform CRUD operations. It abstracts away the complex database queries.

Create: Adding New Products

To add new data to your database, you primarily use the .save() method of your repository. It intelligently handles both new insertions and updates to existing entities.

Here's a simplified example of creating a new product:

class Product {
  id: number;
  name: string;
  price: number;
  constructor(name: string, price: number, id: number = 0) {
    this.id = id;
    this.name = name;
    this.price = price;
  }
}

class MockProductRepository {
  private products: Product[] = [];
  private nextId = 1;

  async save(product: Product): Promise<Product> {
    if (product.id === 0) { // Simulate new product
      product.id = this.nextId++;
      this.products.push(product);
    } else { // Simulate update
      const index = this.products.findIndex(p => p.id === product.id);
      if (index > -1) { this.products[index] = product; }
    }
    return product;
  }

  async find(): Promise<Product[]> {
    return this.products;
  }
}

async function main() {
  const repo = new MockProductRepository();
  console.log("--- Creating a Product ---");
  const newProduct = await repo.save(new Product("Keyboard", 75));
  console.log("Created:", newProduct);

  console.log("\n--- Current Products ---");
  const allProducts = await repo.find();
  console.log(allProducts);
}

main();

Read: Fetching Products

Reading data is fundamental. TypeORM repositories offer several methods to retrieve entities:

.find(): Retrieves all entities matching given criteria.
.findOneBy(): Retrieves a single entity by a simple condition (e.g., by ID).
.findBy(): Retrieves multiple entities by simple conditions.

Let's see how to find products:

class Product {
  id: number;
  name: string;
  price: number;
  constructor(name: string, price: number, id: number = 0) {
    this.id = id;
    this.name = name;
    this.price = price;
  }
}

class MockProductRepository {
  private products: Product[] = [];
  private nextId = 1;

  async save(product: Product): Promise<Product> {
    if (product.id === 0) { product.id = this.nextId++; this.products.push(product); }
    else { const index = this.products.findIndex(p => p.id === product.id);
      if (index > -1) { this.products[index] = product; } }
    return product;
  }

  async find(): Promise<Product[]> { return this.products; }
  async findOneBy(criteria: Partial<Product>): Promise<Product | undefined> {
    return this.products.find(p =>
      Object.keys(criteria).every(key => p[key as keyof Product] === criteria[key as keyof Product])
    );
  }
}

async function main() {
  const repo = new MockProductRepository();
  const product1 = await repo.save(new Product("Mouse", 25));
  const product2 = await repo.save(new Product("Monitor", 300));

  console.log("--- Finding All Products ---");
  let allProducts = await repo.find();
  console.log("All:", allProducts);

  console.log("\n--- Finding One Product by ID ---");
  const foundProduct = await repo.findOneBy({ id: product1.id });
  console.log("Found by ID:", foundProduct);

  console.log("\n--- Finding One Product by Name ---");
  const namedProduct = await repo.findOneBy({ name: "Monitor" });
  console.log("Found by Name:", namedProduct);
}

main();

Update: Modifying Product Details

To modify existing data, you have two primary approaches:

Fetch, Modify, Save: Retrieve an entity, update its properties, then call .save() on the modified entity.
Direct Update: Use .update(criteria, partialEntity) to update specific columns for entities matching certain criteria without loading them into memory first. This is more efficient for mass updates.

class Product {
  id: number;
  name: string;
  price: number;
  constructor(name: string, price: number, id: number = 0) {
    this.id = id;
    this.name = name;
    this.price = price;
  }
}

class MockProductRepository {
  private products: Product[] = [];
  private nextId = 1;

  async save(product: Product): Promise<Product> {
    if (product.id === 0) { product.id = this.nextId++; this.products.push(product); }
    else { const index = this.products.findIndex(p => p.id === product.id);
      if (index > -1) { this.products[index] = product; } }
    return product;
  }

  async findOneBy(criteria: Partial<Product>): Promise<Product | undefined> {
    return this.products.find(p =>
      Object.keys(criteria).every(key => p[key as keyof Product] === criteria[key as keyof Product])
    );
  }
  
  async update(id: number, partialEntity: Partial<Product>): Promise<void> {
    const index = this.products.findIndex(p => p.id === id);
    if (index > -1) {
      this.products[index] = { ...this.products[index], ...partialEntity };
    }
  }
}

async function main() {
  const repo = new MockProductRepository();
  const product = await repo.save(new Product("Headphones", 150));
  console.log("Initial product:", product);

  console.log("\n--- Updating Product Price ---");
  let fetchedProduct = await repo.findOneBy({ id: product.id });
  if (fetchedProduct) {
    fetchedProduct.price = 140; 
    await repo.save(fetchedProduct);
  }
  console.log("Updated via save:", await repo.findOneBy({ id: product.id }));

  const product2 = await repo.save(new Product("Webcam", 80));
  console.log("Initial product 2:", product2);
  await repo.update(product2.id, { price: 70, name: "HD Webcam" });
  console.log("Updated via update:", await repo.findOneBy({ id: product2.id }));
}

main();

Delete: Removing Products

To remove entities from the database, TypeORM provides .delete() and .remove():

.delete(criteria): Removes entities by ID or specific conditions. It's efficient as it doesn't load entities into memory first.
.remove(entityOrEntities): Removes entities that are already loaded into memory (i.e., you have the full entity object).

Let's remove a product from our mock database:

class Product {
  id: number;
  name: string;
  price: number;
  constructor(name: string, price: number, id: number = 0) {
    this.id = id;
    this.name = name;
    this.price = price;
  }
}

class MockProductRepository {
  private products: Product[] = [];
  private nextId = 1;

  async save(product: Product): Promise<Product> {
    if (product.id === 0) { product.id = this.nextId++; this.products.push(product); }
    else { const index = this.products.findIndex(p => p.id === product.id);
      if (index > -1) { this.products[index] = product; } }
    return product;
  }

  async find(): Promise<Product[]> { return this.products; }

  async delete(id: number): Promise<void> {
    this.products = this.products.filter(p => p.id !== id);
  }
  
  async remove(product: Product): Promise<Product> {
    this.products = this.products.filter(p => p.id !== product.id);
    return product; 
  }
}

async function main() {
  const repo = new MockProductRepository();
  const productA = await repo.save(new Product("Pen", 2));
  const productB = await repo.save(new Product("Notebook", 5));
  console.log("Initial products:", await repo.find());

  console.log("\n--- Deleting Product A by ID ---");
  await repo.delete(productA.id);
  console.log("Products after delete:", await repo.find());

  console.log("\n--- Removing Product B (by entity) ---");
  await repo.remove(productB);
  console.log("Products after remove:", await repo.find());
}

main();

CRUD in a NestJS Service

In a real NestJS application, you'd integrate these repository methods within a service. The service would then expose higher-level methods that perform specific business logic, calling the underlying repository methods.

This keeps your controllers clean, focusing only on handling HTTP requests and delegating data operations to the service layer.

// products.service.ts (simplified NestJS service)
import { Injectable } from '@nestjs/common';
import { Repository } from 'typeorm';
import { InjectRepository } from '@nestjs/typeorm';
import { Product } from './product.entity'; // Your entity

@Injectable()
export class ProductsService {
  constructor(
    @InjectRepository(Product)
    private productsRepository: Repository<Product>,
  ) {}

  async create(productData: Partial<Product>): Promise<Product> {
    const newProduct = this.productsRepository.create(productData);
    return this.productsRepository.save(newProduct);
  }

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

  async findOne(id: number): Promise<Product | undefined> {
    return this.productsRepository.findOneBy({ id });
  }

  async update(id: number, productData: Partial<Product>): Promise<Product | undefined> {
    await this.productsRepository.update(id, productData);
    return this.findOne(id); 
  }

  async remove(id: number): Promise<void> {
    await this.productsRepository.delete(id);
  }
}

Robust CRUD: Best Practices

Building robust CRUD operations involves more than just calling repository methods:

Data Validation: Use Data Transfer Objects (DTOs) and validation pipes to ensure incoming data is valid (covered in A2 L2).
Error Handling: Gracefully handle cases like 'entity not found' by throwing appropriate exceptions (e.g., NestJS's NotFoundException).
Transactions: For complex operations involving multiple database changes, use transactions (covered in C1 L2) to ensure data consistency.

CRUD Operation Quiz

Which TypeORM repository method is typically used to update only specific fields of an entity without loading the entire entity into memory first?

Recap: Mastering CRUD

Great job! You've learned the essentials of performing CRUD operations using TypeORM repositories.

Create: Use .save() to add new entities.
Read: Use .find(), .findOneBy() to retrieve entities.
Update: Modify and .save(), or use .update() for partial updates.
Delete: Use .delete() or .remove() to eliminate entities.

These skills are fundamental for building any data-driven API with NestJS and TypeORM. Next, we'll explore error handling and interceptors to make your APIs more robust!

よくある質問

「TypeORMによるCRUD操作」レッスンは無料ですか？

はい。「TypeORMによるCRUD操作」の完全なテキストはこのウェブで無料で読めます。インタラクティブに演習し（組み込みコードエディタと24時間対応のAIチューター）、NestJS Enterprise Backend APIsコースの残りをアンロックするには、CoddyKit PROにアップグレードしてください。 NestJS Enterprise Backend APIsコースには全3レッスンが含まれています。

「TypeORMによるCRUD操作」で何を学びますか？

TypeORMのリポジトリを使って、エンティティの作成、読み取り、更新、削除機能を一通り実装します。ブラウザで直接実行するハンズオンコードでNestJS Enterprise Backend APIsを演習し、24時間対応のAIチューターがレッスンを進める中での質問に答えます。

NestJS Enterprise Backend APIsを始めるのに経験は必要ですか？

事前経験は必要ありません。CoddyKitのNestJS Enterprise Backend APIsは初級者から上級者向けに構成されているため、ここから始めるか最初から始めて、自分のペースで進むことができます。これはレッスン2/3です。

「TypeORMによるCRUD操作」レッスンにはどのくらい時間がかかりますか？

ほとんどのCoddyKitレッスンは約5～10分かかります。各レッスンはコンパクトでインタラクティブなので、着実に進歩し、ウェブとアプリ全体で正確に前回の場所から再開できます。

このNestJS Enterprise Backend APIsレッスンでコードを書いて実行できますか？

はい。すべてのNestJS Enterprise Backend APIsレッスンに組み込みコードエディタが含まれているため、ブラウザでリアルコードを書いて実行し、即座のAIフィードバックを取得できます。ローカル設定は不要です。

このコースのすべてのレッスン

← NestJS Enterprise Backend APIsに戻る