NestJS Enterprise Backend APIs · Lektion

CRUD-Operationen mit TypeORM

Entwickeln Sie vollständige Create-, Read-, Update- und Delete-Funktionen für Ihre Entitäten mithilfe von TypeORM-Repositories.

Lektion 2 von 311 Schritte

CRUD-Operationen mit TypeORM ist eine kostenlose NestJS Enterprise Backend APIs-Lektion auf CoddyKit. Dies ist Lektion 2 von 3. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des NestJS Enterprise Backend APIs-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der NestJS Enterprise Backend APIs-Kurs umfasst insgesamt 3 Lektionen.

Teile dieser Lektion wurden noch nicht übersetzt und werden auf Englisch angezeigt.

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?

Beantworte es in der interaktiven Lektion

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!

Kostenlos starten

Lerne TypeScript mit einem KI-Tutor — kostenlos

Schreibe und führe echten Code in deinem Browser aus, bekomme sofortige Hilfe von einem 24/7 KI-Tutor und setze dein Lernen im Web oder in der App fort.

Kurse: 20
Lektionen: 76

Kostenlos lernen Den vollständigen Kurs ansehen

Häufig gestellte Fragen

Ist die Lektion „CRUD-Operationen mit TypeORM“ kostenlos?

Ja — der vollständige Text von „CRUD-Operationen mit TypeORM“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des NestJS Enterprise Backend APIs-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der NestJS Enterprise Backend APIs-Kurs umfasst insgesamt 3 Lektionen.

Was lerne ich in „CRUD-Operationen mit TypeORM“?

Entwickeln Sie vollständige Create-, Read-, Update- und Delete-Funktionen für Ihre Entitäten mithilfe von TypeORM-Repositories. Du übst NestJS Enterprise Backend APIs mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um NestJS Enterprise Backend APIs zu starten?

Keine Vorkenntnisse erforderlich. NestJS Enterprise Backend APIs auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 3.

Wie lange dauert die Lektion „CRUD-Operationen mit TypeORM“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser NestJS Enterprise Backend APIs-Lektion Code schreiben und ausführen?

Ja. Jede NestJS Enterprise Backend APIs-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu NestJS Enterprise Backend APIs