NestJS: backend-API:er för företag · Lektion

Anpassade TypeORM-repositories

Skapa anpassade repositories för att kapsla in komplexa databasfrågor och förbättra kodens struktur och återanvändbarhet.

Lektion 1 av 310 steg

Anpassade TypeORM-repositories är en gratis lektion i NestJS: backend-API:er för företag på CoddyKit. Detta är lektion 1 av 3. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för NestJS: backend-API:er för företag, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i NestJS: backend-API:er för företag innehåller totalt 3 lektioner.

Bortom grundläggande CRUD

TypeORM:s standard-Repository erbjuder grundläggande operationer som save, find och delete. Dessa passar bra för enkla uppgifter.

Verkliga program behöver dock ofta mer komplexa frågor eller domänspecifik logik för datahämtning.

Kapsla in komplexa frågor

Utan egna repositoryn kan komplexa databasfrågor hamna direkt i tjänstelagret. Det kan göra tjänsterna överlastade och svårare att underhålla.

Renare tjänster: Tjänsterna fokuserar på affärslogik, inte databasspecifika detaljer.
Återanvändbarhet: Komplexa frågor kan återanvändas i olika delar av programmet.
Testbarhet: Det blir enklare att testa databasinteraktioner isolerat.

Skapa ett eget repository

För att skapa ett eget repository definierar ni en klass som utökar TypeORM:s Repository<Entity>. Ni måste även förse den med dekoratorn @EntityRepository(Entity) för att koppla den till en specifik entitet.

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

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

  @Column()
  name: string;

  @Column({ unique: true })
  email: string;

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

// src/user/user.repository.ts
import { EntityRepository, Repository } from 'typeorm';
import { User } from './user.entity';

@EntityRepository(User)
export class UserRepository extends Repository<User> {
  // Custom methods will go here
}

Injicera det egna repositoryt

När det har definierats kan ni injicera ert eget repository i NestJS-tjänster eller controllers med dekoratorn @InjectRepository().

Kom ihåg att skicka med er egen repository-klass som argument till @InjectRepository().

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

@Injectable()
export class UserService {
  constructor(
    @InjectRepository(UserRepository)
    private userRepository: UserRepository,
  ) {}

  async findAllActive(): Promise<User[]> {
    // This method will be defined in the custom repo
    return this.userRepository.findActiveUsers();
  }
}

Lägga till en egen metod

I ditt anpassade repository kan du lägga till metoder som kapslar in specifik frågelogik. Dessa metoder kan använda standardmetoderna i Repository eller TypeORM:s Query Builder.

Vi lägger till metoder för att hitta alla aktiva användare och hitta en användare baserat på e-postadress.

// src/user/user.repository.ts (updated)
import { EntityRepository, Repository } from 'typeorm';
import { User } from './user.entity';

@EntityRepository(User)
export class UserRepository extends Repository<User> {
  async findActiveUsers(): Promise<User[]> {
    return this.find({ isActive: true });
  }

  async findByEmail(email: string): Promise<User | undefined> {
    return this.findOne({ email });
  }
}

Arbetsflöde för anpassade repositories

Det typiska flödet ser ut så här: du definierar din Entity, sedan ditt Custom Repository som utökar Repository<Entity>, och slutligen injicerar du det i din Service.

// 1. user.entity.ts
import { Entity, PrimaryGeneratedColumn, Column } from 'typeorm';
@Entity() export class User {
  @PrimaryGeneratedColumn() id: number;
  @Column() name: string;
  @Column({ unique: true }) email: string;
  @Column({ default: true }) isActive: boolean;
}

// 2. user.repository.ts
import { EntityRepository, Repository } from 'typeorm';
import { User } from './user.entity';
@EntityRepository(User)
export class UserRepository extends Repository<User> {
  async findActiveUsers(): Promise<User[]> {
    return this.find({ isActive: true });
  }
}

// 3. user.service.ts
import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { UserRepository } from './user.repository';
import { User } from './user.entity';
@Injectable()
export class UserService {
  constructor(
    @InjectRepository(UserRepository)
    private userRepository: UserRepository,
  ) {}
  async getAllActive(): Promise<User[]> {
    return this.userRepository.findActiveUsers();
  }
}

Modulkonfiguration

För att NestJS ska kunna hantera TypeORM-repositories korrekt måste modulen importera TypeOrmModule.forFeature() med dina entiteter. Dekoratorn @EntityRepository hanterar registreringen på TypeORM-sidan, vilket möjliggör injicering.

// src/user/user.module.ts
import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { User } from './user.entity';
import { UserService } from './user.service';
import { UserController } from './user.controller';

@Module({
  imports: [
    TypeOrmModule.forFeature([User]) // Only entities here
  ],
  providers: [UserService, UserController],
  exports: [UserService] // Export service if used elsewhere
})
export class UserModule {}

Använda Query Builder

För mer komplexa frågor använder anpassade repositories ofta TypeORM:s kraftfulla Query Builder. Med den kan du skapa dynamiska frågor med joins, villkor och mycket mer.

Vi lägger till en metod för att hitta användare som är aktiva och har ett visst namnformat.

// src/user/user.repository.ts (extended)
import { EntityRepository, Repository } from 'typeorm';
import { User } from './user.entity';
import { MoreThan } from 'typeorm'; // Example for complex query

@EntityRepository(User)
export class UserRepository extends Repository<User> {
  async findActiveUsers(): Promise<User[]> {
    return this.find({ isActive: true });
  }

  async findByNamePattern(pattern: string): Promise<User[]> {
    return this.createQueryBuilder('user')
      .where('user.name LIKE :pattern', { pattern: `%${pattern}%` })
      .andWhere('user.isActive = :isActive', { isActive: true })
      .getMany();
  }
}

Kontrollera din förståelse

Studera följande anpassade repository och service:

// product.repository.ts
import { EntityRepository, Repository, MoreThan } from 'typeorm';
import { Product } from './product.entity'; // Assume Product entity exists

@EntityRepository(Product)
export class ProductRepository extends Repository<Product> {
  async findAvailableProducts(): Promise<Product[]> {
    return this.find({ where: { stock: MoreThan(0), isActive: true } });
  }
}

// product.service.ts
import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { ProductRepository } from './product.repository';
import { Product } from './product.entity'; // Assume Product entity exists

@Injectable()
export class ProductService {
  constructor(
    @InjectRepository(ProductRepository)
    private productRepo: ProductRepository,
  ) {}

  async getProducts(): Promise<Product[]> {
    return this.productRepo.findAvailableProducts();
  }
}

Besvara frågan i den interaktiva lektionen

Sammanfattning av anpassade repositories

I den här lektionen utforskade vi anpassade TypeORM-repositories. Vi lärde oss att de är ett kraftfullt mönster för att:

Kapsla in komplex och återanvändbar logik för databasfrågor.
Hålla dina NestJS-services rena och fokuserade på affärsregler.
Förbättra kodens struktur, återanvändbarhet och testbarhet.

Genom att utöka TypeORM:s Repository och använda @EntityRepository kan du definiera domänspecifika metoder som gör ditt dataåtkomstlager betydligt robustare.

Gratis att börja

Lär dig TypeScript med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 20
Lektioner: 76

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Anpassade TypeORM-repositories” gratis?

Ja – hela texten till ”Anpassade TypeORM-repositories” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i NestJS: backend-API:er för företag, kan Ni uppgradera till CoddyKit PRO. Kursen i NestJS: backend-API:er för företag innehåller totalt 3 lektioner.

Vad lär jag mig i ”Anpassade TypeORM-repositories”?

Skapa anpassade repositories för att kapsla in komplexa databasfrågor och förbättra kodens struktur och återanvändbarhet. Ni övar på NestJS: backend-API:er för företag med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig NestJS: backend-API:er för företag?

Du behöver inga förkunskaper. Utbildningen i NestJS: backend-API:er för företag på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 1 av 3.

Hur lång tid tar lektionen ”Anpassade TypeORM-repositories”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här NestJS: backend-API:er för företag-lektionen?

Ja. Varje NestJS: backend-API:er för företag-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till NestJS: backend-API:er för företag