Travailler avec les bases de données en TypeScript : PostgreSQL et MongoDB

Introduction au travail avec les bases de données en TypeScript

TypeScript est une extension strictement typée de JavaScript qui ajoute le typage statique et des fonctionnalités modernes du langage. Lors du développement d'applications côté serveur en TypeScript, il est souvent nécessaire d'interagir avec des bases de données. Deux des solutions les plus populaires sont le SGBDR PostgreSQL et la base de données orientée documents MongoDB. Dans cet article, nous allons voir comment travailler efficacement avec les deux bases de données en TypeScript en utilisant des bibliothèques éprouvées et les meilleures pratiques.

Configuration de l'environnement et installation des dépendances

Avant de commencer, assurez-vous d'avoir Node.js et npm installés. Créez un nouveau projet et installez les packages nécessaires :

mkdir typescript-db-examplecd typescript-db-examplenpm init -ynpm install typescript ts-node @types/node --save-devnpx tsc --init

Pour travailler avec PostgreSQL, nous utiliserons TypeORM — un ORM puissant avec support TypeScript. Pour MongoDB — Mongoose.

npm install typeorm reflect-metadata pgnpm install mongoose

Travailler avec PostgreSQL via TypeORM

Configuration de la connexion à PostgreSQL

TypeORM prend en charge les décorateurs et l'enregistrement actif. Créons un fichier data-source.ts pour la configuration :

import { DataSource } from "typeorm";

export const AppDataSource = new DataSource({    type: "postgres",    host: "localhost",    port: 5432,    username: "your_username",    password: "your_password",    database: "test_db",    synchronize: true,    logging: false,    entities: ["src/entity/**/*.ts"],    migrations: [],    subscribers: [],});

Création d'une entité

Définissons un modèle utilisateur en utilisant des décorateurs :

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

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

    @Column()    firstName: string;

    @Column()    lastName: string;

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

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

Opérations CRUD avec PostgreSQL

Effectuons des opérations de base de données :

import { AppDataSource } from "./data-source";import { User } from "./entity/User";

async function main() {    await AppDataSource.initialize();    const userRepository = AppDataSource.getRepository(User);

    // CREATE    const newUser = userRepository.create({        firstName: "Ivan",        lastName: "Petrov",        email: "ivan@example.com"    });    await userRepository.save(newUser);

    // READ    const users = await userRepository.find();    console.log("All users:", users);

    // UPDATE    const userToUpdate = await userRepository.findOneBy({ id: 1 });    if (userToUpdate) {        userToUpdate.isActive = false;        await userRepository.save(userToUpdate);    }

    // DELETE    await userRepository.delete({ id: 1 });}

main().catch(console.error);

Travailler avec MongoDB via Mongoose

Connexion à MongoDB

Mongoose fournit un schéma pratique et une validation pour MongoDB. Configurons la connexion :

import mongoose, { Schema, Document, Model } from "mongoose";

const MONGO_URI = "mongodb://localhost:27017/test";

mongoose.connect(MONGO_URI)    .then(() => console.log("Connected to MongoDB"))    .catch(err => console.error("Connection error:", err));

Définition du schéma et du modèle

Créons une interface pour TypeScript et un schéma Mongoose :

// Interface for TypeScriptinterface IUser extends Document {    firstName: string;    lastName: string;    email: string;    createdAt: Date;}

// Mongoose Schemaconst userSchema = new Schema({    firstName: { type: String, required: true },    lastName: { type: String, required: true },    email: { type: String, required: true, unique: true },    createdAt: { type: Date, default: Date.now }});

// Modelexport const UserModel: Model = mongoose.model("User", userSchema);

Opérations CRUD avec MongoDB

Effectuons des opérations de base avec MongoDB :

import { UserModel } from "./models/User";

async function main() {    // CREATE    const newUser = new UserModel({        firstName: "Ivan",        lastName: "Petrov",        email: "ivan@example.com"    });    await newUser.save();

    // READ    const users = await UserModel.find();    console.log("All users:", users);

    // UPDATE    await UserModel.updateOne({ _id: newUser._id }, { isActive: false });

    // DELETE    await UserModel.deleteOne({ _id: newUser._id });}

main().catch(console.error);

Conclusion

Dans cet article, nous avons vu les bases du travail avec PostgreSQL et MongoDB en TypeScript. TypeORM fournit une abstraction pratique pour les bases de données relationnelles avec prise en charge des décorateurs et de la génération automatique de migrations. Mongoose, quant à lui, offre un système de schémas flexible et une validation pour MongoDB. Le choix entre ces solutions dépend des tâches spécifiques de votre projet : PostgreSQL est mieux adapté aux données structurées avec des relations complexes, tandis que MongoDB est idéal pour les schémas de documents flexibles et le prototypage rapide.