Patrons de Conception Repository pour Modules JavaScript : Accès aux Données Sécurisé et Efficace

            
// user_repository_interface.js

export class IUserRepository {
  async getUserById(id) {
    throw new Error("La méthode 'getUserById()' doit être implémentée.");
  }

  async getAllUsers() {
    throw new Error("La méthode 'getAllUsers()' doit être implémentée.");
  }

  async createUser(user) {
    throw new Error("La méthode 'createUser()' doit être implémentée.");
  }

  async updateUser(id, user) {
    throw new Error("La méthode 'updateUser()' doit être implémentée.");
  }

  async deleteUser(id) {
    throw new Error("La méthode 'deleteUser()' doit être implémentée.");
  }
}

            

              
                Copy
              
            
          

            
// user_repository_interface.ts

export interface IUserRepository {
  getUserById(id: string): Promise;
  getAllUsers(): Promise;
  createUser(user: User): Promise;
  updateUser(id: string, user: User): Promise;
  deleteUser(id: string): Promise;
}

            

              
                Copy
              
            
          

            
// user_repository.js
import mongoose from 'mongoose';
import { IUserRepository } from './user_repository_interface.js';
const UserSchema = new mongoose.Schema({
  name: String,
  email: String,
});
const UserModel = mongoose.model('User', UserSchema);

export class UserRepository extends IUserRepository {
  constructor(dbUrl) {
        super();
        mongoose.connect(dbUrl).catch(err => console.log(err));
    }
  async getUserById(id) {
    try {
      return await UserModel.findById(id).exec();
    } catch (error) {
      console.error("Erreur lors de la récupération de l'utilisateur par ID :", error);
      return null; // Ou lancer l'erreur, selon votre stratégie de gestion des erreurs
    }
  }

  async getAllUsers() {
    try {
      return await UserModel.find().exec();
    } catch (error) {
      console.error("Erreur lors de la récupération de tous les utilisateurs :", error);
      return []; // Ou lancer l'erreur
    }
  }

  async createUser(user) {
    try {
      const newUser = new UserModel(user);
      return await newUser.save();
    } catch (error) {
      console.error("Erreur lors de la création de l'utilisateur :", error);
      throw error; // Relancer l'erreur pour qu'elle soit gérée en amont
    }
  }

  async updateUser(id, user) {
    try {
      return await UserModel.findByIdAndUpdate(id, user, { new: true }).exec();
    } catch (error) {
      console.error("Erreur lors de la mise à jour de l'utilisateur :", error);
      return null; // Ou lancer l'erreur
    }
  }

  async deleteUser(id) {
    try {
      const result = await UserModel.findByIdAndDelete(id).exec();
      return !!result; // Retourne true si l'utilisateur a été supprimé, false sinon
    } catch (error) {
      console.error("Erreur lors de la suppression de l'utilisateur :", error);
      return false; // Ou lancer l'erreur
    }
  }
}

            

              
                Copy
              
            
          

            
// user_repository.ts
import { Sequelize, DataTypes, Model } from 'sequelize';
import { IUserRepository } from './user_repository_interface.ts';

interface UserAttributes {
  id: string;
  name: string;
  email: string;
}

interface UserCreationAttributes extends Omit {}

class User extends Model implements UserAttributes {
  public id!: string;
  public name!: string;
  public email!: string;

  public readonly createdAt!: Date;
  public readonly updatedAt!: Date;
}

export class UserRepository implements IUserRepository {
  private sequelize: Sequelize;
  private UserModel: typeof User; // Stocker le modèle Sequelize

  constructor(sequelize: Sequelize) {
    this.sequelize = sequelize;
    this.UserModel = User.init(
      {
        id: {
          type: DataTypes.UUID,
          defaultValue: DataTypes.UUIDV4,
          primaryKey: true,
        },
        name: {
          type: DataTypes.STRING,
          allowNull: false,
        },
        email: {
          type: DataTypes.STRING,
          allowNull: false,
          unique: true,
        },
      },
      {
        tableName: 'users',
        sequelize: sequelize, // Passer l'instance de Sequelize
      }
    );
  }

  async getUserById(id: string): Promise {
    try {
      return await this.UserModel.findByPk(id);
    } catch (error) {
      console.error("Erreur lors de la récupération de l'utilisateur par ID :", error);
      return null;
    }
  }

  async getAllUsers(): Promise {
    try {
      return await this.UserModel.findAll();
    } catch (error) {
      console.error("Erreur lors de la récupération de tous les utilisateurs :", error);
      return [];
    }
  }

  async createUser(user: UserCreationAttributes): Promise {
    try {
      return await this.UserModel.create(user);
    } catch (error) {
      console.error("Erreur lors de la création de l'utilisateur :", error);
      throw error;
    }
  }

  async updateUser(id: string, user: UserCreationAttributes): Promise {
    try {
      const [affectedCount] = await this.UserModel.update(user, { where: { id } });
      if (affectedCount === 0) {
        return null; // Aucun utilisateur trouvé avec cet ID
      }
      return await this.UserModel.findByPk(id);
    } catch (error) {
      console.error("Erreur lors de la mise à jour de l'utilisateur :", error);
      return null;
    }
  }

  async deleteUser(id: string): Promise {
    try {
      const deletedCount = await this.UserModel.destroy({ where: { id } });
      return deletedCount > 0; // Retourne true si un utilisateur a été supprimé
    } catch (error) {
      console.error("Erreur lors de la suppression de l'utilisateur :", error);
      return false;
    }
  }
}

            

              
                Copy
              
            
          

            
// user_service.js

export class UserService {
  constructor(userRepository) {
    this.userRepository = userRepository;
  }

  async getUserProfile(userId) {
    const user = await this.userRepository.getUserById(userId);
    if (!user) {
      throw new Error("Utilisateur non trouvé");
    }
    return {
      id: user._id,
      name: user.name,
      email: user.email,
    };
  }

  async createUser(userData) {
    // Valider les données de l'utilisateur avant la création
    if (!userData.name || !userData.email) {
      throw new Error("Le nom et l'email sont requis");
    }
    return this.userRepository.createUser(userData);
  }

  // Autres méthodes de service...
}

            

              
                Copy
              
            
          

            
// user_service.ts
import { IUserRepository } from './user_repository_interface.ts';
import { User } from './models/user.ts';

export class UserService {
  private userRepository: IUserRepository;

  constructor(userRepository: IUserRepository) {
    this.userRepository = userRepository;
  }

  async getUserProfile(userId: string): Promise {
    const user = await this.userRepository.getUserById(userId);
    if (!user) {
      throw new Error("Utilisateur non trouvé");
    }
    return user;
  }

  async createUser(userData: Omit): Promise {
    // Valider les données de l'utilisateur avant la création
    if (!userData.name || !userData.email) {
      throw new Error("Le nom et l'email sont requis");
    }
    return this.userRepository.createUser(userData);
  }

  // Autres méthodes de service...
}

            

              
                Copy
              
            
          

            
// app.js
import { UserService } from './user_service.js';
import { UserRepository } from './user_repository.js';

// Remplacez par votre chaîne de connexion MongoDB
const dbUrl = 'mongodb://localhost:27017/mydatabase';

const userRepository = new UserRepository(dbUrl);
const userService = new UserService(userRepository);

async function main() {
  try {
    const newUser = await userService.createUser({ name: 'John Doe', email: 'john.doe@example.com' });
    console.log('Utilisateur créé :', newUser);

    const userProfile = await userService.getUserProfile(newUser._id);
    console.log('Profil utilisateur :', userProfile);
  } catch (error) {
    console.error('Erreur :', error);
  }
}

main();

            

              
                Copy
              
            
          

            
// product_repository_interface.ts
export interface IProductRepository {
  getProductById(id: string): Promise;
  getAllProducts(): Promise;
  getProductsByCategory(category: string): Promise;
  createProduct(product: Product): Promise;
  updateProduct(id: string, product: Product): Promise;
  deleteProduct(id: string): Promise;
}

            

              
                Copy
              
            
          

            
// product_repository.ts
import { IProductRepository } from './product_repository_interface.ts';
import { Product } from './models/product.ts'; // En supposant que vous ayez un modèle Product

export class ProductRepository implements IProductRepository {
  // Supposons qu'une connexion à la base de données ou un ORM soit initialisé ailleurs
  private db: any; // Remplacez 'any' par votre type de base de données réel ou votre instance d'ORM

  constructor(db: any) {
    this.db = db;
  }

  async getProductById(id: string): Promise {
    try {
      // En supposant une table 'products' et une méthode de requête appropriée
      const product = await this.db.products.findOne({ where: { id } });
      return product;
    } catch (error) {
      console.error("Erreur lors de la récupération du produit par ID :", error);
      return null;
    }
  }

  async getAllProducts(): Promise {
    try {
      const products = await this.db.products.findAll();
      return products;
    } catch (error) {
      console.error("Erreur lors de la récupération de tous les produits :", error);
      return [];
    }
  }

  async getProductsByCategory(category: string): Promise {
    try {
      const products = await this.db.products.findAll({ where: { category } });
      return products;
    } catch (error) {
      console.error("Erreur lors de la récupération des produits par catégorie :", error);
      return [];
    }
  }

  async createProduct(product: Product): Promise {
    try {
      const newProduct = await this.db.products.create(product);
      return newProduct;
    } catch (error) {
      console.error("Erreur lors de la création du produit :", error);
      throw error;
    }
  }

  async updateProduct(id: string, product: Product): Promise {
    try {
      // Mettre à jour le produit, retourner le produit mis à jour ou null s'il n'est pas trouvé
      const [affectedCount] = await this.db.products.update(product, { where: { id } });
      if (affectedCount === 0) {
        return null;
      }
      const updatedProduct = await this.getProductById(id);
      return updatedProduct;
    } catch (error) {
      console.error("Erreur lors de la mise à jour du produit :", error);
      return null;
    }
  }

  async deleteProduct(id: string): Promise {
    try {
      const deletedCount = await this.db.products.destroy({ where: { id } });
      return deletedCount > 0; // True si supprimé, false si non trouvé
    } catch (error) {
      console.error("Erreur lors de la suppression du produit :", error);
      return false;
    }
  }
}

            

              
                Copy
              
            
          

            
// product_service.ts
import { IProductRepository } from './product_repository_interface.ts';
import { Product } from './models/product.ts';

export class ProductService {
  private productRepository: IProductRepository;

  constructor(productRepository: IProductRepository) {
    this.productRepository = productRepository;
  }

  async getProductDetails(productId: string): Promise {
    // Ajouter une logique métier, comme vérifier la disponibilité du produit
    const product = await this.productRepository.getProductById(productId);
    if (!product) {
      return null; // Ou lancer une exception
    }
    return product;
  }

  async listProductsByCategory(category: string): Promise {
    // Ajouter une logique métier, comme filtrer par produits vedettes
    return this.productRepository.getProductsByCategory(category);
  }

  async createNewProduct(productData: Omit): Promise {
    // Effectuer la validation, la sanitisation, etc.
    return this.productRepository.createProduct(productData);
  }

  // Ajouter d'autres méthodes de service pour la mise à jour, la suppression de produits, etc.
}

            

              
                Copy