Un ORM (Object-Relational Mapper) est une bibliothèque qui implémente la technique de mappage objet-relationnel. Cela vous permet d'écrire des requêtes de base de données SQL en utilisant le paradigme orienté objet de votre langage préféré.
TypeORM est un ORM TypeScript qui facilite l'interfaçage avec diverses bases de données. Il fonctionne avec les bases de données SQL mais s'interface également bien avec les bases de données NoSQL comme MongoDB.
NestJS fournit une prise en charge de haut niveau pour TypeORM prête à l'emploi. Le package TypeORM dédié rend l'intégration relativement facile.
Étape 1: Installer les dépendances
Avant d'utiliser TypeORM dans une application NestJS, vous devez l'installer avec son package NestJS natif et votre base de données SQL préférée. SQLite est une option simple et sans installation.
Exécutez la commande suivante pour installer TypeORM et son package NestJS natif, en utilisant le gestionnaire de paquets npm:
installation npm @nestjs/typeorm typeorm
Exécutez la commande suivante pour installer SQLite :
npm installer sqlite3
Étape 2: Création d'une entité
Une entité est un ensemble de champs définissant les données stockées dans une base de données. TypeORM utilise le fichier d'entité pour créer une table dans votre base de données.
Suivez les étapes ci-dessous pour créer une entité :
- Créez un fichier dans votre module d'application et nommez-le en suivant la convention de dénomination NestJS (
.entité.ts ). - Dans votre fichier d'entité, importez le Entité, Colonne, et PrimaryGeneratedColumnPrimaryGeneratedColumnPrimaryGeneratedColumn décorateurs de forme de type.
- Dans votre fichier d'entité, créez et exportez une classe.
- Remplissez la classe avec les valeurs que vous souhaitez dans votre base de données, comme identifiant, Nom, etc.
- Annotez votre classe d'entité avec le décorateur d'entité. Cela rend votre classe reconnaissable à TypeORM en tant qu'entité.
- Annotez votre propriété id avec le décorateur PrimaryGeneratedColumn. Cela indique à TypeORM de marquer le identifiant comme clé primaire et l'incrémente automatiquement.
- Annotez les propriétés restantes avec le décorateur Column. Cela les ajoute en tant que colonnes dans votre base de données.
Par exemple:
// src/test/test.entity.ts
importer { Entité, Colonne, PrimaryGeneratedColumn } de 'typeorm';@Entité()
exporterclasserTest{
@PrimaryGeneratedColumn()
identifiant: numéro ;@Colonne()
propriété_1: chaîne ;@Colonne()
propriété_2: chaîne ;
@Colonne()
propriété_3: chaîne ;
}
Le fichier d'entité ci-dessus crée cette table dans votre base de données :
| test | ||
|---|---|---|
| identifiant | entier (11) | CLÉ PRIMAIRE AUTO_INCREMENT |
| propriété_1 | varchar (255) | |
| propriété_2 | varchar (255) | |
| propriété_3 | varchar (255) |
La Documentation TypeORM couvre les entités plus en détail.
Étape 3: Connecter votre application à une base de données
Maintenant que votre entité est configurée, vous devez connecter votre application à une base de données. Cet exemple utilise SQLite.
Suivez les étapes ci-dessous pour connecter votre application à une base de données :
- Dans le module racine de vos applications (généralement le app.module.ts fichier), importer TypeOrmModule de @nestjs/typeorm.
- Dans le même fichier, importez toutes vos entités.
- Dans le importations tableau, appelez le forRoot méthode sur TypeOrmModule. La méthode forRoot partage la connexion à la base de données via tous les modules de votre application.
- Transmettez un objet vide comme argument dans la méthode forRoot; ce sera l'objet de configuration TypeORM.
- Ajouter une propriété, taper, à l'objet de configuration et définissez-le sur "sqlite". La propriété type indique le nom de la base de données que vous utilisez.
- Ajouter une autre propriété, base de données, à l'objet de configuration et définissez-le sur "test.db". La propriété de base de données indique votre nom préféré pour votre base de données.
- Ajouter une autre propriété, entités, à l'objet de configuration et définissez-le sur un tableau vide. Remplissez le tableau vide avec les entités que vous avez importées précédemment.
- Ajouter une autre propriété, synchroniser, et réglez-le vrai; cette propriété synchronise vos entités avec votre base de données et la met à jour chaque fois que vous exécutez le code. Vous ne devez définir cette propriété que sur vrai en développement. Pendant la production, vous devez le régler sur faux pour éviter la perte de données.
// src/app.module.ts
importer { Module } de '@nestjs/commun' ;
importer { TypeOrmModule } de '@nestjs/typeorm' ;
importer { Test } de './test/test.entité' ;
importer { Entité2 } de './entité/entité.entité' ;
importer { TestModule } de './test/test.module';
@Module({
importations: [
TypeOrmModule.forRoot({
taper: 'sqlite',
base de données: 'test.db',
entités: [Test, Entité2],
synchroniser: vrai, // développement uniquement
}),
module de test,
],
contrôleurs: [],
fournisseurs: [],
})
exporterclasserModule d'application{}
Étape 4: Création d'un référentiel
Un référentiel est la couche d'accès d'une entité utilisée pour effectuer des requêtes (insérer, supprimer, enregistrer, rechercher, etc.) sur une table créée par l'entité dans la base de données. TypeORM prend en charge le modèle de conception de référentiel, ainsi, chaque entité a son propre référentiel.
TypeORM crée automatiquement un référentiel pour votre entité lorsque vous suivez les étapes ci-dessous :
- Dans le fichier module de votre entité, importez TypeOrmModule de @nestjs/typeorm et importez votre entité.
- Créé un importations tableau dans le @Module décorateur.
- Dans le tableau des importations, appelez le pourFonctionnalité méthode sur TypeOrmModule.
- Passez un tableau comme argument dans votre et remplissez le tableau avec votre entité.
// src/test/test.module.ts
importer { Module } de '@nestjs/commun' ;
importer { TypeOrmModule } de '@nestjs/typeorm' ;
importer { Contrôleur de test } de './contrôleur.test' ;
importer { TestService } de './test.service';
importer { Test } de './test.entity';
@Module({
importations: [TypeOrmModule.forFeature([Test])],
fournisseurs: [Service de test],
contrôleurs: [Contrôleur de test],
})
Étape 5: Injection de votre référentiel dans son service à l'aide de l'injection de dépendances
L'injection de dépendances est une technique d'ingénierie logicielle qui est une forme du principe d'inversion de contrôle. Il déplace le fardeau de la gestion des dépendances du code client vers la bibliothèque ou le service dont il dépend.
Suivez les étapes ci-dessous pour injecter votre dépôt dans un service :
- Dans votre fichier de service, importez Dépôt de forme de type et le InjectRepository décorateur de @nestjs/typeorm. Importez également l'entité que vous souhaitez injecter dans son référentiel.
- Dans votre classe de service, créez un constructeur.
- Déclarer un privé variable, dépôt, en tant que paramètre dans le constructeur pour l'initialiser.
- Attribuez un type de référentiel au référentiel avec un type générique de votre entité.
- Annotez le référentiel avec le décorateur InjectRepository et transmettez votre entité en tant qu'argument.
// test.service.ts
importer { Injectables } de '@nestjs/commun' ;
importer { Référentiel } de 'typeorm';
importer { InjectRepository } de '@nestjs/typeorm' ;
importer { Test } de './test.entity';
@Injectable()
exporterclasserTestService{
constructeur(
@InjectRepository(Test)
dépôt privé: référentiel<Test>,
) {}
}
Maintenant que votre configuration est terminée, vous pouvez faire Requêtes SQL dessus pour récupérer ou modifier des données.
Faire des requêtes SQL avec TypeORM
Vous pouvez effectuer n'importe quelle requête SQL simple en appelant les méthodes de référentiel de TypeORM sur le dépôt variable à l'intérieur de votre classe de service. Vous pouvez également créer des requêtes SQL complexes en utilisant le générateur de requêtes de TypeORM.