NestJS Enterprise Backend APIs · Ders

TypeORM ile CRUD İşlemleri

TypeORM depolarını kullanarak varlıklarınız için eksiksiz oluşturma, okuma, güncelleme ve silme işlevleri geliştirin.

TypeORM ile CRUD İşlemleri, CoddyKit'te ücretsiz bir NestJS Enterprise Backend APIs dersidir. Bu, 3 dersinin 2. dersidir. Aşağıdan dersin tamamını ücretsiz okuyabilir, sonra tarayıcıda yerleşik kod editörü ve 7/24 yapay zeka koçu ile uygulamalı olarak pratik yapabilirsin. Bu, NestJS Enterprise Backend APIs öğrenme yolunun bir parçasıdır ve ilerlemeniz web ve CoddyKit uygulaması arasında senkronize olur. NestJS Enterprise Backend APIs kursu toplamda 3 dersten oluşur.

Bu dersin bazı bölümleri henüz çevrilmemiş olup İngilizce olarak gösterilmektedir.

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!

Sıkça Sorulan Sorular

“TypeORM ile CRUD İşlemleri” dersi ücretsiz mi?

Evet — “TypeORM ile CRUD İşlemleri” dersin tüm metni burada web'de ücretsiz olarak okunabilir. Etkileşimli olarak pratik yapmak (yerleşik kod editörü ve 7/24 yapay zeka koçu) ve NestJS Enterprise Backend APIs kursunun geri kalanını açmak için CoddyKit PRO'ya yükselt. NestJS Enterprise Backend APIs kursu toplamda 3 dersten oluşur.

“TypeORM ile CRUD İşlemleri” dersinde ne öğreneceğim?

TypeORM depolarını kullanarak varlıklarınız için eksiksiz oluşturma, okuma, güncelleme ve silme işlevleri geliştirin. NestJS Enterprise Backend APIs ile uygulamalı kodu tarayıcıda doğrudan çalıştırarak pratik yaparsın ve 7/24 yapay zeka koçu dersi çalışırken sorularını yanıtlar.

NestJS Enterprise Backend APIs öğrenmeye başlamak için deneyim gerekli mi?

Önceden deneyim gerekmez. CoddyKit'te NestJS Enterprise Backend APIs, başlangıçtan ileri seviyeye kadar yapılandırıldığı için buradan başlayabilir veya başından başlayıp kendi hızında ilerleme yapabilirsin. Bu, 3 dersinin 2. dersidir.

“TypeORM ile CRUD İşlemleri” dersi ne kadar sürer?

Çoğu CoddyKit dersi yaklaşık 5–10 dakika sürer. Her biri kısa ve etkileşimli olduğu için sabit ilerleme yaparsın ve web ile uygulama arasında tam olarak bıraktığın yerden devam edebilirsin.

Bu NestJS Enterprise Backend APIs dersinde kod yazıp çalıştırabilir miyim?

Evet. Her NestJS Enterprise Backend APIs dersi yerleşik bir kod editörü içerir, bu sayede tarayıcıda gerçek kod yazıp çalıştırabilir ve anlık yapay zeka geri bildirimi alırsın — yerel kurulum gerekli değildir.

Bu kursun tüm dersleri

← NestJS Enterprise Backend APIs Sayfasına Dön