Générez des données fictives typées à partir de n'importe quel schéma JSON avec un seul appel API

Chaque développeur front-end, ingénieur assurance qualité et constructeur back-end se heurte aux mêmes frictions : vous avez besoin de données réalistes. pour tester une interface utilisateur, amorcer une base de données ou vérifier une intégration d'API, mais écrire des scripts d'amorçage à la main est fastidieux et les résultats semblent faux. Entrées "John Doe" codées en dur dans chaque table. Horodatages identiques. Des prix qui sont toujours 9,99.

L'API du générateur de données simulées Botoi adopte une approche différente. Vous définissez un schéma JSON décrivant la forme du données souhaitées, et l'API renvoie un tableau d'enregistrements qui correspondent à cette forme avec des valeurs aléatoires et réalistes. Un Appel HTTP. Aucune bibliothèque à installer, aucune configuration frauduleuse, aucun fichier de départ à maintenir.

Comment ça marche : définir un schéma, récupérer les données

Le point de terminaison accepte un objet Schema JSON standard et un count paramètre. Il renvoie un tableau de enregistrements générés correspondant à votre schéma, avec types, formats et contraintes respectés.

Demande

curl -X POST https://api.botoi.com/v1/mock/generate \\
  -H "Content-Type: application/json" \\
  -d '{
    "schema": {
      "type": "object",
      "properties": {
        "id": { "type": "integer" },
        "name": { "type": "string" },
        "email": { "type": "string", "format": "email" },
        "age": { "type": "integer", "minimum": 18, "maximum": 80 }
      },
      "required": ["id", "name", "email"]
    },
    "count": 5
  }'

Réponse

{
  "success": true,
  "data": {
    "data": [
      { "id": 42, "name": "Sarah Chen", "email": "sarah@example.com", "age": 34 },
      { "id": 87, "name": "Marcus Johnson", "email": "marcus.j@example.com", "age": 28 },
      { "id": 15, "name": "Priya Patel", "email": "priya.patel@example.com", "age": 51 },
      { "id": 63, "name": "David Kim", "email": "dkim@example.com", "age": 45 },
      { "id": 91, "name": "Elena Rodriguez", "email": "elena.r@example.com", "age": 22 }
    ],
    "count": 5
  }
}

Le schéma suit les conventions de schéma JSON. Ensemble type pour contrôler le type de données, format pour des indices comme "email" ou "date-time", et minimum/maximum pour les plages numériques. Le required tableau indique au générateur quels champs doivent apparaître dans chaque enregistrement.

Exemple : commandes e-commerce

Vous testez un tableau de bord de gestion des commandes ? Vous avez besoin de campagnes avec des éléments de campagne, des prix en centimes et des valeurs de statut. Voici un schéma pour cela.

curl -X POST https://api.botoi.com/v1/mock/generate \\
  -H "Content-Type: application/json" \\
  -d '{
    "schema": {
      "type": "object",
      "properties": {
        "order_id": { "type": "string" },
        "customer_email": { "type": "string", "format": "email" },
        "total_cents": { "type": "integer", "minimum": 500, "maximum": 50000 },
        "currency": { "type": "string" },
        "items": {
          "type": "array",
          "items": {
            "type": "object",
            "properties": {
              "sku": { "type": "string" },
              "quantity": { "type": "integer", "minimum": 1, "maximum": 10 },
              "price_cents": { "type": "integer", "minimum": 100, "maximum": 9999 }
            }
          }
        },
        "status": { "type": "string" }
      },
      "required": ["order_id", "customer_email", "total_cents", "currency"]
    },
    "count": 3
  }'

Réponse (premier enregistrement affiché) :

{
  "success": true,
  "data": {
    "data": [
      {
        "order_id": "ord_7f3a2b",
        "customer_email": "lena.watts@example.com",
        "total_cents": 12450,
        "currency": "usd",
        "items": [
          { "sku": "TSHIRT-BLK-M", "quantity": 2, "price_cents": 2999 },
          { "sku": "HOODIE-GRY-L", "quantity": 1, "price_cents": 6452 }
        ],
        "status": "fulfilled"
      }
    ],
    "count": 3
  }
}

Chaque commande reçoit un identifiant, une adresse e-mail, un total et un ensemble d'éléments de campagne différents. Le minimum et maximum contraintes sur quantity et price_cents garder des valeurs dans des limites réalistes.

Exemple : articles de blog

Construire un CMS ou une page de liste de blogs ? Générez des publications avec des titres, des slugs, des auteurs, des horodatages et des balises.

curl -X POST https://api.botoi.com/v1/mock/generate \\
  -H "Content-Type: application/json" \\
  -d '{
    "schema": {
      "type": "object",
      "properties": {
        "id": { "type": "integer" },
        "title": { "type": "string" },
        "slug": { "type": "string" },
        "author": { "type": "string" },
        "published_at": { "type": "string", "format": "date-time" },
        "tags": {
          "type": "array",
          "items": { "type": "string" }
        },
        "excerpt": { "type": "string" }
      },
      "required": ["id", "title", "slug", "author"]
    },
    "count": 10
  }'

Dix articles de blog avec différents auteurs, titres, tableaux de balises et dates de publication. De quoi tester la pagination, filtrage et tri logique sans écrire un seul appareil à la main.

Amorcer une base de données dans un seul script

Combinez le générateur de données fictives avec un client de base de données et vous obtenez un script de départ complet. Voici une version bash qui insère 50 utilisateurs dans une base de données PostgreSQL :

#!/bin/bash
set -euo pipefail

API="https://api.botoi.com/v1/mock/generate"
DB_URL="postgresql://localhost:5432/myapp_dev"

echo "Generating 50 user records..."
USERS=\$(curl -s -X POST "\$API" \\
  -H "Content-Type: application/json" \\
  -d '{
    "schema": {
      "type": "object",
      "properties": {
        "name": { "type": "string" },
        "email": { "type": "string", "format": "email" },
        "age": { "type": "integer", "minimum": 18, "maximum": 80 },
        "signup_date": { "type": "string", "format": "date-time" }
      },
      "required": ["name", "email"]
    },
    "count": 50
  }')

echo "\$USERS" | jq -c '.data.data[]' | while read -r row; do
  NAME=\$(echo "\$row" | jq -r '.name')
  EMAIL=\$(echo "\$row" | jq -r '.email')
  AGE=\$(echo "\$row" | jq -r '.age')
  SIGNUP=\$(echo "\$row" | jq -r '.signup_date')

  psql "\$DB_URL" -c "INSERT INTO users (name, email, age, signup_date) VALUES ('\$NAME', '\$EMAIL', \$AGE, '\$SIGNUP');"
done

echo "Seeded 50 users into \$DB_URL"

Le script génère 50 enregistrements utilisateur uniques, analyse chacun avec jq, et les insère un par un. Pour les ensembles de données plus volumineux, dirigez la sortie vers un bloc COPY commande ou une insertion par lots.

Version Node.js

Si votre pile est JavaScript ou TypeScript, appelez l'API avec fetch et transmettre les résultats à votre ORM :

const API = "https://api.botoi.com/v1/mock/generate";

async function generateMockData(schema, count) {
  const response = await fetch(API, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ schema, count }),
  });
  const result = await response.json();
  return result.data.data;
}

const userSchema = {
  type: "object",
  properties: {
    name: { type: "string" },
    email: { type: "string", format: "email" },
    role: { type: "string" },
    created_at: { type: "string", format: "date-time" },
  },
  required: ["name", "email", "role"],
};

const users = await generateMockData(userSchema, 25);
console.log(users);

// Pass directly to your ORM
// await db.insert(usersTable).values(users);

La generateMockData la fonction est réutilisable. Appelez-le avec n'importe quel schéma et comptez, puis insérez le se traduit par Drizzle, Prisma, Knex ou tout autre ORM que vous utilisez.

Pourquoi utiliser une API plutôt qu’une bibliothèque ?

• Aucune dépendance. Vous n'avez pas besoin d'installer faker.js, factory_bot ou tout autre langage spécifique bibliothèque. Un seul appel HTTP fonctionne à partir de n’importe quel langage, script shell ou pipeline CI.
• Piloté par un schéma. Le même schéma JSON que vous utilisez pour la validation peut piloter vos données de test. Changement le schéma et les données générées changent avec lui. Aucune définition d'usine à synchroniser.
• Format cohérent. Chaque membre de l'équipe obtient des données de la même source. Non "fonctionne sur ma machine" différences entre les montages manuscrits.
• Partageable. Copiez la commande curl dans un fil de discussion Slack, un README ou une configuration CI. N'importe qui peut l'exécuter sans rien installer.

Conseils pratiques

• Enregistrez les réponses sous forme de fichiers de luminaires. Exécutez l'API une fois, enregistrez la sortie JSON dans fixtures/users.json, et chargez ce fichier dans vos tests. Cela maintient les tests déterministes et évite les appels réseau pendant les tests.
• Utilisez des conseils de format. Paramètre "format": "email" produit des chaînes en forme d'e-mail. D'autres formats utiles incluent "date-time", "uri", et "uuid".
• Imbibez des objets pour des données complexes. Le schéma prend en charge les objets au sein d'objets et de tableaux de objets. Modélisez vos relations de base de données réelles en imbriquant un address objet à l'intérieur d'un customer objet.
• Combinez-le avec d'autres points de terminaison Botoi. Générez des utilisateurs fictifs, puis transmettez chaque e-mail à /v1/disposable-email/check pour tester votre flux de validation d'e-mails de bout en bout.