Valider les données MongoDB

Introduction

Dans ce laboratoire, vous allez apprendre à valider les types de données MongoDB, à gérer les données invalides et à empêcher les mauvaises entrées pour maintenir l'intégrité des données dans votre base de données MongoDB. Vous commencerez par explorer les différents types de données pris en charge par MongoDB et en créant une collection d'échantillons avec des exigences de type de données spécifiques. Ensuite, vous allez pratiquer l'insertion de documents avec des types incorrects et apprendre à insérer correctement les données qui répondent aux critères de validation. À la fin de ce laboratoire, vous aurez une compréhension solide des techniques de validation et de gestion d'erreurs des données MongoDB.

Skills Graph

Vérifier les types de données

Dans cette étape, vous allez apprendre à vérifier et à valider les types de données dans MongoDB, ce qui est crucial pour maintenir l'intégrité des données et prévenir les erreurs dans votre base de données.

Comprendre les types de données dans MongoDB

MongoDB prend en charge divers types de données, notamment :

• Chaîne de caractères (String)
• Entier (Integer)
• Nombre à virgule flottante (Double)
• Booléen (Boolean)
• Tableau (Array)
• Objet (Object)
• Date (Date)
• Identifiant d'objet (ObjectId)
• Nul (Null)

Commençons par ouvrir le shell MongoDB et explorer la validation des types de données :

mongosh

Création d'une collection d'échantillons avec validation de type

Nous allons créer une collection users avec des exigences de type de données spécifiques :

use dataValidationLab

db.createCollection("users", {
   validator: {
      $jsonSchema: {
         bsonType: "object",
         required: ["name", "age", "email"],
         properties: {
            name: {
               bsonType: "string",
               description: "doit être une chaîne de caractères et est obligatoire"
            },
            age: {
               bsonType: "int",
               minimum: 18,
               maximum: 120,
               description: "doit être un entier compris entre 18 et 120"
            },
            email: {
               bsonType: "string",
               pattern: "^.+@.+$",
               description: "doit être une adresse e-mail valide"
            }
         }
      }
   }
})

Analysons la validation :

• bsonType: "string" assure que le champ est une chaîne de caractères
• bsonType: "int" assure que le champ est un entier
• minimum et maximum définissent des contraintes de plage
• pattern valide le format de l'e-mail

Tentative d'insertion de documents avec des types incorrects

Maintenant, essayons d'insérer des documents pour tester notre validation :

// Cela échouera en raison d'un type d'âge incorrect
db.users.insertOne({
  name: "John Doe",
  age: "25", // Chaîne de caractères au lieu d'un entier
  email: "[email protected]"
});

// Cela échouera également en raison d'une adresse e-mail invalide
db.users.insertOne({
  name: "Jane Smith",
  age: 30,
  email: "invalid-email"
});

Insertion correcte d'un document

Voici comment insérer un document valide :

db.users.insertOne({
  name: "Alice Johnson",
  age: NumberInt(28),
  email: "[email protected]"
});

Notez l'utilisation de NumberInt() pour créer explicitement un entier.

Valider les champs obligatoires

Dans cette étape, nous allons nous appuyer sur nos travaux de validation des données précédents en nous concentrant sur l'assurance que les champs obligatoires sont toujours présents dans nos documents MongoDB.

Comprendre les champs obligatoires

Les champs obligatoires sont des informations essentielles qui doivent être présentes dans chaque document. Dans l'étape précédente, nous avons créé un schéma de validation avec des champs obligatoires. Maintenant, nous allons explorer comment appliquer et valider ces exigences.

Continuons dans notre shell MongoDB :

mongosh

Changeons de base de données existante :

use dataValidationLab

Définir une validation stricte des champs obligatoires

Nous allons modifier notre collection users existante pour appliquer une validation stricte des champs obligatoires :

db.runCommand({
  collMod: "users",
  validator: {
    $jsonSchema: {
      bsonType: "object",
      required: ["name", "age", "email", "registrationDate"],
      properties: {
        name: {
          bsonType: "string",
          description:
            "Le nom est obligatoire et doit être une chaîne de caractères"
        },
        age: {
          bsonType: "int",
          minimum: 18,
          maximum: 120,
          description:
            "L'âge est obligatoire et doit être un entier compris entre 18 et 120"
        },
        email: {
          bsonType: "string",
          pattern: "^.+@.+$",
          description:
            "L'e-mail est obligatoire et doit être une adresse e-mail valide"
        },
        registrationDate: {
          bsonType: "date",
          description:
            "La date d'inscription est obligatoire et doit être une date"
        }
      }
    }
  },
  validationLevel: "strict"
});

Tenter d'insérer des documents avec des champs manquants

Essayons d'insérer des documents avec des champs obligatoires manquants :

// Cela échouera en raison de la date d'inscription manquante
db.users.insertOne({
  name: "Bob Wilson",
  age: NumberInt(35),
  email: "[email protected]"
});

// Cela échouera également en raison de champs obligatoires manquants
db.users.insertOne({
  name: "Charlie Brown"
});

Insertion correcte d'un document

Voici comment insérer un document qui répond à toutes les exigences :

db.users.insertOne({
  name: "Emma Thompson",
  age: NumberInt(42),
  email: "[email protected]",
  registrationDate: new Date()
});

Vérifier les erreurs de validation

Pour comprendre pourquoi les insertions échouent, MongoDB fournit des messages d'erreur de validation :

try {
  db.users.insertOne({
    name: "Incomplete User"
  });
} catch (error) {
  print("Validation Error:", error.message);
}

Cela vous aidera à comprendre exactement quels champs obligatoires sont manquants.

Gérer les données invalides

Dans cette étape, nous allons apprendre à gérer et à traiter les données invalides dans MongoDB, en nous concentrant sur la capture d'erreurs, la journalisation et la mise en œuvre de stratégies de validation des données.

Préparer l'environnement

Continuons dans notre shell MongoDB :

mongosh

Changeons de base de données existante :

use dataValidationLab

Création d'une collection de gestion d'erreurs

Nous allons créer une nouvelle collection avec une validation et une gestion d'erreurs avancées :

db.createCollection("products", {
  validator: {
    $jsonSchema: {
      bsonType: "object",
      required: ["name", "price", "category"],
      properties: {
        name: {
          bsonType: "string",
          minLength: 2,
          maxLength: 100
        },
        price: {
          bsonType: ["double", "int"],
          minimum: 0,
          description: "Le prix doit être un nombre positif"
        },
        category: {
          enum: ["Electronics", "Clothing", "Books", "Food"],
          description: "La catégorie doit être l'une des valeurs prédéfinies"
        }
      }
    }
  },
  validationAction: "error"
});

Mise en œuvre d'un mécanisme de gestion d'erreurs

Nous allons créer une fonction pour gérer les insertions de données invalides :

function safeInsertProduct(product) {
  try {
    db.products.insertOne(product);
    print("Produit inséré avec succès :", product.name);
  } catch (error) {
    print("Erreur lors de l'insertion du produit :", error.message);

    // Journaliser les données invalides dans une collection séparée
    db.invalidProducts.insertOne({
      product: product,
      errorMessage: error.message,
      timestamp: new Date()
    });
  }
}

Tester la gestion d'erreurs

Testons notre gestion d'erreurs avec diverses scénarios :

// Insertion de produit valide
safeInsertProduct({
  name: "Smartphone",
  price: 599.99,
  category: "Electronics"
});

// Produit invalide - type de prix incorrect
safeInsertProduct({
  name: "Laptop",
  price: "1000", // Chaîne de caractères au lieu de nombre
  category: "Electronics"
});

// Produit invalide - catégorie invalide
safeInsertProduct({
  name: "T-Shirt",
  price: 29.99,
  category: "Accessories" // Pas dans les catégories prédéfinies
});

// Produit invalide - nom trop court
safeInsertProduct({
  name: "A",
  price: 10,
  category: "Books"
});

Vérifier les journaux de données invalides

Voyons les journaux des produits invalides :

print("Journal des produits invalides :");
db.invalidProducts.find();

Meilleures pratiques pour la gestion d'erreurs

1. Toujours valider les données avant insertion
2. Utiliser des blocs try-catch
3. Journaliser les données invalides pour un examen ultérieur
4. Mettre en œuvre la validation au niveau du schéma
5. Utiliser des actions de validation appropriées

Corriger les problèmes de données

Dans cette étape, nous allons apprendre des techniques pour identifier et corriger les problèmes de données dans MongoDB, en nous concentrant sur les stratégies de nettoyage et de transformation des données.

Préparer l'environnement

Continuons dans notre shell MongoDB :

mongosh

Changeons de base de données existante :

use dataValidationLab

Création d'une collection de nettoyage de données

Nous allons créer une collection avec des données potentiellement problématiques :

db.createCollection("customers", {
  validator: {
    $jsonSchema: {
      bsonType: "object",
      required: ["name", "email", "age"],
      properties: {
        name: {
          bsonType: "string",
          minLength: 2
        },
        email: {
          bsonType: "string",
          pattern: "^.+@.+$"
        },
        age: {
          bsonType: "int",
          minimum: 18,
          maximum: 120
        }
      }
    }
  }
});

// Insérer quelques données d'échantillonnage avec des problèmes potentiels
db.customers.insertMany([
  { name: "John Doe", email: "john@example", age: "35" },
  { name: "A", email: "invalid-email", age: 15 },
  { name: "Jane Smith", email: "[email protected]", age: 25 }
]);

Fonction de nettoyage de données

Créons une fonction pour nettoyer et valider les données des clients :

function cleanCustomerData() {
  // Trouver et corriger les documents invalides
  const invalidCustomers = db.customers.find({
    $or: [
      { age: { $type: "string" } },
      { email: { $not: /^.+@.+$/ } },
      {
        name: { $exists: true, $expr: { $lt: [{ $strLenBytes: "$name" }, 2] } }
      }
    ]
  });

  invalidCustomers.forEach((customer) => {
    // Corriger l'âge : convertir en entier
    const fixedAge =
      typeof customer.age === "string"
        ? parseInt(customer.age)
        : customer.age < 18
          ? 18
          : customer.age;

    // Corriger l'e-mail : ajouter le domaine s'il manque
    const fixedEmail = customer.email.includes("@")
      ? customer.email
      : `${customer.email}@example.com`;

    // Corriger le nom : compléter les noms courts
    const fixedName =
      customer.name.length < 2 ? customer.name.padEnd(2, "X") : customer.name;

    // Mettre à jour le document avec les données corrigées
    db.customers.updateOne(
      { _id: customer._id },
      {
        $set: {
          age: NumberInt(fixedAge),
          email: fixedEmail,
          name: fixedName
        }
      }
    );

    print(`Client corrigé : ${customer.name}`);
  });

  // Vérifier les données nettoyées
  print("Vérification des données nettoyées :");
  db.customers.find().forEach(printjson);
}

// Exécuter la fonction de nettoyage
cleanCustomerData();

Validation des données après nettoyage

Vérifions que les données nettoyées répondent à nos critères de validation :

function validateCustomers() {
  const invalidCustomersCount = db.customers
    .find({
      $or: [
        { age: { $not: { $type: "int" } } },
        { age: { $lt: 18, $gt: 120 } },
        { email: { $not: /^.+@.+$/ } },
        {
          name: {
            $exists: true,
            $expr: { $lt: [{ $strLenBytes: "$name" }, 2] }
          }
        }
      ]
    })
    .count();

  print(`Nombre de clients invalides restants : ${invalidCustomersCount}`);
  return invalidCustomersCount === 0;
}

validateCustomers();

Meilleures pratiques pour la correction de données

1. Toujours valider avant et après la transformation des données
2. Utiliser la conversion de type avec soin
3. Définir des valeurs par défaut ou des valeurs minimales pour les champs critiques
4. Journaliser les modifications des données pour l'audit
5. Créer une sauvegarde avant le nettoyage important des données

Empêcher les mauvaises entrées

Dans cette dernière étape, nous allons explorer des techniques avancées pour empêcher les mauvaises entrées et améliorer l'intégrité des données dans MongoDB grâce à des stratégies de validation complètes.

Préparer l'environnement

Continuons dans notre shell MongoDB :

mongosh

Changeons de base de données existante :

use dataValidationLab

Création d'un schéma de validation robuste

Nous allons créer un schéma de validation complet pour une collection'registrations' :

db.createCollection("registrations", {
  validator: {
    $jsonSchema: {
      bsonType: "object",
      required: ["username", "email", "password", "registrationDate"],
      properties: {
        username: {
          bsonType: "string",
          minLength: 3,
          maxLength: 20,
          pattern: "^[a-zA-Z0-9_]+$",
          description:
            "Le nom d'utilisateur doit être alphanumérique, de 3 à 20 caractères"
        },
        email: {
          bsonType: "string",
          pattern: "^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$",
          description: "Doit être une adresse e-mail valide"
        },
        password: {
          bsonType: "string",
          minLength: 8,
          description: "Le mot de passe doit avoir au moins 8 caractères",
          pattern:
            "^(?=.*[A-Za-z])(?=.*\\d)(?=.*[@$!%*#?&])[A-Za-z\\d@$!%*#?&]{8,}$"
        },
        registrationDate: {
          bsonType: "date",
          description: "La date d'inscription doit être une date valide"
        }
      }
    }
  },
  validationAction: "error",
  validationLevel: "strict"
});

Mise en œuvre d'un middleware d'empêchement d'entrées

Créez une fonction pour valider les entrées avant insertion :

function safeRegister(userData) {
  // Nettoyer et valider les entrées
  const sanitizedData = {
    username: userData.username.trim().toLowerCase(),
    email: userData.email.trim().toLowerCase(),
    password: userData.password,
    registrationDate: new Date()
  };

  // Validations personnalisées supplémentaires
  if (sanitizedData.username.length < 3) {
    throw new Error("Le nom d'utilisateur est trop court");
  }

  if (db.registrations.findOne({ username: sanitizedData.username })) {
    throw new Error("Le nom d'utilisateur existe déjà");
  }

  if (db.registrations.findOne({ email: sanitizedData.email })) {
    throw new Error("L'e-mail est déjà enregistré");
  }

  try {
    // Tenter d'insérer avec la validation de MongoDB
    db.registrations.insertOne(sanitizedData);
    print("Inscription réussie :", sanitizedData.username);
  } catch (error) {
    print("Inscription échouée :", error.message);

    // Journaliser les tentatives d'inscription échouées
    db.registrationAttempts.insertOne({
      attemptData: userData,
      errorMessage: error.message,
      timestamp: new Date()
    });
  }
}

// Tester l'empêchement d'entrées
function testRegistrations() {
  const testCases = [
    // Inscription valide
    {
      username: "john_doe",
      email: "[email protected]",
      password: "Strong!Pass123"
    },

    // Cas invalides
    { username: "ab", email: "invalid-email", password: "short" },
    { username: "john_doe!", email: "[email protected]", password: "WeakPass" },
    {
      username: "special_chars!",
      email: "invalid@email",
      password: "NoSpecialChar123"
    }
  ];

  testCases.forEach((testCase) => {
    print("\nTest d'inscription :");
    printjson(testCase);
    safeRegister(testCase);
  });
}

// Exécuter les tests d'inscription
testRegistrations();

Vérifier les tentatives d'inscription

Vérifions les tentatives d'inscription journalisées :

print("Tentatives d'inscription échouées :");
db.registrationAttempts.find();

Meilleures pratiques pour l'empêchement d'entrées

1. Utiliser une validation de schéma complète
2. Mettre en œuvre une nettoyage d'entrées côté serveur
3. Utiliser des motifs regex pour une validation stricte
4. Journaliser et suivre les tentatives d'entrée invalides
5. Mettre en œuvre une logique de validation personnalisée supplémentaire

Sommaire

Dans ce laboratoire, vous avez appris à vérifier et valider les types de données dans MongoDB pour maintenir l'intégrité des données et prévenir les erreurs dans votre base de données. Vous avez exploré les différents types de données pris en charge par MongoDB, notamment les chaînes de caractères, les entiers, les doubles, les booléens, les tableaux, les objets, les dates, les ObjectId et null. Vous avez créé une collection d'échantillons d'utilisateurs avec des exigences spécifiques de type de données, comme s'assurer que le nom est une chaîne de caractères, l'âge est un entier compris entre 18 et 120 et l'e-mail est une adresse e-mail valide. Vous avez également appris à gérer les données invalides en essayant d'insérer des documents avec des types incorrects et en comprenant les messages d'erreur.

Enfin, vous avez pratiqué l'insertion de documents avec les types de données corrects pour les ajouter avec succès à la collection d'utilisateurs.