Aangepaste TypeORM-repositories
Maak aangepaste repositories om complexe databasequeries in te kapselen en de organisatie en herbruikbaarheid van code te verbeteren.
Aangepaste TypeORM-repositories is een gratis Enterprise-backend-API's met NestJS-les op CoddyKit. Dit is les 1 van 3. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Enterprise-backend-API's met NestJS. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Enterprise-backend-API's met NestJS bevat in totaal 3 lessen.
Verder dan de basis van CRUD
De standaard-Repository van TypeORM biedt basisbewerkingen zoals save, find en delete. Deze zijn uitstekend geschikt voor eenvoudige taken.
Toepassingen uit de praktijk hebben echter vaak complexere query's of domeinspecifieke logica nodig om gegevens op te halen.
Complexe query's inkapselen
Zonder aangepaste repositories kunnen complexe databasequery's rechtstreeks in uw servicelaag terechtkomen. Hierdoor kunnen services omvangrijker en moeilijker te onderhouden worden.
- Overzichtelijkere services: services richten zich op bedrijfslogica, niet op databasespecifieke details.
- Herbruikbaarheid: complexe query's kunnen in verschillende delen van uw toepassing worden hergebruikt.
- Testbaarheid: interacties met de database kunnen eenvoudiger afzonderlijk worden getest.
Een aangepaste repository maken
Om een aangepaste repository te maken, definieert u een klasse die de TypeORM-klasse Repository<Entity> uitbreidt. U moet deze ook voorzien van de decorateur @EntityRepository(Entity) om deze aan een specifieke entiteit te koppelen.
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
}De aangepaste repository injecteren
Nadat u deze hebt gedefinieerd, kunt u uw aangepaste repository in NestJS-services of -controllers injecteren met de decorateur @InjectRepository().
Vergeet niet uw aangepaste repositoryklasse als argument aan @InjectRepository() door te geven.
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();
}
}Een aangepaste methode toevoegen
In je aangepaste repository kun je methoden toevoegen die specifieke querylogica inkapselen. Deze methoden kunnen de standaardmethoden van Repository of de Query Builder van TypeORM gebruiken.
Voeg methoden toe om alle actieve gebruikers te vinden en een gebruiker op e-mailadres te vinden.
// 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 });
}
}Workflow voor aangepaste repositories
Dit is de gebruikelijke werkwijze: je definieert je Entity, daarna je Custom Repository dat Repository<Entity> uitbreidt, en ten slotte injecteer je dit in je 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();
}
}Moduleconfiguratie
Om ervoor te zorgen dat NestJS de TypeORM-repositories goed beheert, moet je module TypeOrmModule.forFeature() met je entiteiten importeren. De decorator @EntityRepository verzorgt de registratie aan de TypeORM-kant, zodat injectie mogelijk is.
// 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 {}De Query Builder gebruiken
Voor complexere queries gebruiken aangepaste repositories vaak de krachtige Query Builder van TypeORM. Hiermee kun je dynamische queries samenstellen met joins, voorwaarden en meer.
Voeg een methode toe om gebruikers te vinden die actief zijn en een specifiek naam patroon hebben.
// 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();
}
}Controleer je begrip
Bekijk de volgende aangepaste repository en 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();
}
}Samenvatting van aangepaste repositories
In deze les hebben we aangepaste TypeORM-repositories verkend. We hebben geleerd dat dit een krachtig patroon is om:
- Complexe, herbruikbare logica voor databasequeries in te kapselen.
- Je NestJS-services overzichtelijk te houden en te richten op bedrijfsregels.
- De codeorganisatie, herbruikbaarheid en testbaarheid te verbeteren.
Door de TypeORM-Repository uit te breiden en @EntityRepository te gebruiken, kun je domeinspecifieke methoden definiëren die je gegevenslaag veel robuuster maken.
Leer TypeScript met een AI-tutor — gratis
Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.
- Cursussen
- 20
- Lessen
- 76
Veelgestelde vragen
Is de les “Aangepaste TypeORM-repositories” gratis?
Ja — de volledige tekst van “Aangepaste TypeORM-repositories” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus Enterprise-backend-API's met NestJS wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus Enterprise-backend-API's met NestJS bevat in totaal 3 lessen.
Wat leer ik in “Aangepaste TypeORM-repositories”?
Maak aangepaste repositories om complexe databasequeries in te kapselen en de organisatie en herbruikbaarheid van code te verbeteren. Je oefent met Enterprise-backend-API's met NestJS door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.
Heb ik ervaring nodig om met Enterprise-backend-API's met NestJS te beginnen?
Ervaring vooraf is niet nodig. Enterprise-backend-API's met NestJS op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 1 van 3.
Hoe lang duurt de les “Aangepaste TypeORM-repositories”?
De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.
Kan ik code schrijven en uitvoeren in deze les over Enterprise-backend-API's met NestJS?
Ja. Elke les over Enterprise-backend-API's met NestJS bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.
Alle lessen in deze cursus
- Aangepaste TypeORM-repositories
- Transacties en migraties
- Database seeden en testen