MongoDB Academy · Lektion

Indlæsning af testdata med Node.js-scripts

De lærende vil skrive et Node.js-script til indlæsning af testdata, som læser en JSON-fil og indsætter dokumenter samlet i MongoDB til lokal udvikling.

Lektion 4 af 413 trin

Indlæsning af testdata med Node.js-scripts er en gratis MongoDB Academy-lektion på CoddyKit. Dette er lektion 4 af 4. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig døgnet rundt. Den er en del af læringsforløbet i MongoDB Academy, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. MongoDB Academy-kurset indeholder 4 lektioner i alt.

Hvorfor skrive et seed-script?

Et seed-script er et Node.js-program, der udfylder en MongoDB-database med startdata eller testdata. I modsætning til mongoimport kan et seed-script generere dynamiske data (ID'er, relationer og tidsstempler), indsætte data betinget, hvis de ikke allerede findes, og anvende forretningslogik under indlæsningen—for eksempel hash af adgangskoder eller beregning af afledte felter. Seed-scripts er grundlaget for opsætning af lokale udviklingsmiljøer.

Opsætning af MongoDB-klienten

Et seed-script opretter forbindelse til MongoDB ved hjælp af den officielle mongodb-driver til Node.js. Gem forbindelses-URI'en i en miljøvariabel eller en .env-fil—hardkod aldrig legitimationsoplysninger. Kald client.connect() i starten, kør alle seed-handlinger, og kald client.close() i en finally-blok for at sikre, at scriptet afsluttes korrekt, selv hvis der opstår en fejl.

const { MongoClient, ObjectId } = require('mongodb');

const URI = process.env.MONGO_URI || 'mongodb://localhost:27017';
const DB_NAME = 'myapp';

async function seed() {
  const client = new MongoClient(URI);
  try {
    await client.connect();
    console.log('Connected to MongoDB');
    const db = client.db(DB_NAME);
    await seedUsers(db);
    await seedProducts(db);
    console.log('Seeding complete!');
  } finally {
    await client.close();
  }
}

seed().catch(console.error);

Indsættelse af dokumenter med bulkWrite

Brug collection.bulkWrite() sammen med ordered: false for effektive bulk-indsættelser. I modsætning til flere kald af insertOne sender bulkWrite alle handlinger til serveren i én netværksrundtur. Angiv ordered: false, så fejl med duplikerede nøgler i enkelte dokumenter ikke stopper hele portionen—det er nyttigt, når du kører et seed-script igen med deterministiske ID'er.

async function seedUsers(db) {
  const users = [
    { _id: new ObjectId('aaa000000000000000000001'), name: 'Alice', email: 'alice@example.com', role: 'admin' },
    { _id: new ObjectId('aaa000000000000000000002'), name: 'Bob',   email: 'bob@example.com',   role: 'user'  },
    { _id: new ObjectId('aaa000000000000000000003'), name: 'Carol', email: 'carol@example.com', role: 'user'  }
  ];

  const ops = users.map(u => ({ insertOne: { document: u } }));
  const result = await db.collection('users').bulkWrite(ops, { ordered: false });
  console.log('Users inserted:', result.insertedCount);
}

Idempotent indlæsning med deleteMany

Gør dit seed-script idempotent—sikkert at køre flere gange—ved at rydde målsamlingerne, før du indsætter data. Kald deleteMany({}) (eller drop()) i starten af hver seed-funktion. Det sikrer, at databasen starter fra en kendt, ren tilstand ved hver kørsel, hvilket er afgørende ved lokal udvikling, hvor du ønsker reproducerbare data uden dubletter.

async function seedProducts(db) {
  const col = db.collection('products');

  // Clear existing data first — idempotent
  await col.deleteMany({});
  console.log('Cleared products collection');

  const products = generateProducts(50); // generate 50 sample products
  await col.insertMany(products);
  console.log('Inserted', products.length, 'products');
}

Generering af realistiske testdata

Til udviklingsdata kan du programmæssigt generere realistiske data ved hjælp af et hjælperbibliotek som @faker-js/faker eller ved at konstruere data manuelt. Når du genererer data i scriptet i stedet for at indlæse statiske JSON-filer, kan du nemt ændre mængden—indsæt 10 dokumenter til enhedstest og 10.000 til belastningstest—ved kun at ændre én parameter.

function generateProducts(count) {
  const categories = ['electronics', 'clothing', 'tools', 'books'];
  return Array.from({ length: count }, (_, i) => ({
    _id: new ObjectId(),
    sku: 'PROD-' + String(i + 1).padStart(4, '0'),
    name: 'Product ' + (i + 1),
    price: parseFloat((Math.random() * 100 + 1).toFixed(2)),
    category: categories[i % categories.length],
    rating: parseFloat((Math.random() * 2 + 3).toFixed(1)), // 3.0 - 5.0
    isActive: true,
    createdAt: new Date(Date.now() - i * 86400000) // staggered dates
  }));
}

Oprettelse af relationer mellem samlinger

Når du indsætter relaterede samlinger, skal du først oprette overordnede dokumenter og bruge deres _id-værdier, når du opretter underordnede dokumenter. Ved at bruge deterministiske ObjectIds (konstrueret ud fra faste hexadecimale strenge) kan du pålideligt referere til bestemte overordnede dokumenter på tværs af kørsler uden først at skulle forespørge efter dem efter indsættelsen.

const USER_ID_ALICE = new ObjectId('aaa000000000000000000001');
const USER_ID_BOB   = new ObjectId('aaa000000000000000000002');

async function seedOrders(db) {
  await db.collection('orders').deleteMany({});
  const orders = [
    { userId: USER_ID_ALICE, total: 49.99,  status: 'delivered', createdAt: new Date() },
    { userId: USER_ID_BOB,   total: 120.00, status: 'pending',   createdAt: new Date() }
  ];
  await db.collection('orders').insertMany(orders);
  console.log('Orders seeded');
}

Læsning af seed-data fra JSON-filer

For komplekse seed-data, der er nemmere at vedligeholde som JSON (produktkataloger, landelister og konfigurationstabeller), skal du læse JSON-filen med fs.readFileSync og sende det fortolkede array direkte til insertMany. Kombinér dette med den idempotente deleteMany-fremgangsmåde, så scriptet kan køres sikkert igen efter redigering af JSON-filen.

const fs  = require('fs');
const path = require('path');

async function seedFromFile(db, collectionName, filePath) {
  const raw  = fs.readFileSync(path.resolve(filePath), 'utf-8');
  const docs = JSON.parse(raw);

  const col = db.collection(collectionName);
  await col.deleteMany({});
  await col.insertMany(docs);
  console.log('Seeded', docs.length, 'documents into', collectionName);
}

// Usage
await seedFromFile(db, 'countries', './seed-data/countries.json');

Oprettelse af indekser efter seedning

Seed-scripts bør oprette de samme indekser, som produktionen bruger. Kald collection.createIndex() (eller createIndexes()) i slutningen af hver seed-funktion eller i et dedikeret ensureIndexes-trin. Det er hurtigere at oprette indekser efter en masseindsættelse end at vedligeholde dem under indsættelsen—MongoDB opbygger B-træet ud fra de sorterede data i én gennemgang.

async function ensureIndexes(db) {
  // Products: fast category lookups and rating sorts
  await db.collection('products').createIndex({ category: 1, rating: -1 });
  await db.collection('products').createIndex({ sku: 1 }, { unique: true });

  // Orders: fast user-based queries
  await db.collection('orders').createIndex({ userId: 1, createdAt: -1 });

  console.log('Indexes created');
}

Kørsel af seed-scriptet

Kør seed-scriptet fra kommandolinjen med node seed.js, eller føj det til scripts-sektionen i din package.json. Send miljøspecifikke URI'er via miljøvariabler, så det samme script fungerer i lokale miljøer samt i CI- og staging-miljøer uden ændringer. Kør aldrig et seed-script, der kalder deleteMany, mod en produktions-URI.

// package.json scripts
// {
//   "scripts": {
//     "seed": "node scripts/seed.js",
//     "seed:test": "MONGO_URI=mongodb://localhost:27017 node scripts/seed.js"
//   }
// }

// Run with:
// npm run seed
// or
// MONGO_URI='mongodb://localhost:27017' node scripts/seed.js

Brug af seed-scripts i CI-arbejdsgange

I en CI-arbejdsgang skal du køre seed-scriptet som en del af opsætningstrinnet for testen, før du udfører integrationstest eller end-to-end-test. Start en MongoDB Docker-container (eller brug mongodb-memory-server), kør seed-scriptet for at udfylde testdata, kør testene, og fjern derefter containeren. Det giver hver CI-kørsel en ren og reproducerbar databasetilstand.

# GitHub Actions step example
# - name: Start MongoDB
#   run: docker run -d -p 27017:27017 mongo:7

# - name: Seed test data
#   run: node scripts/seed.js
#   env:
#     MONGO_URI: mongodb://localhost:27017

# - name: Run integration tests
#   run: npm test
#   env:
#     MONGO_URI: mongodb://localhost:27017

Håndtering af seed-fejl på en robust måde

Pak dine seed-funktioner ind i try/catch-blokke, så en fejl i én sektion ikke efterlader databasen i en delvist seedet tilstand uden en tydelig fejlmeddelelse. Log fejlen, afbryd de resterende seed-trin, og afslut med en kode, der ikke er nul, så CI-arbejdsgange registrerer fejlen. En delvis seedning er ofte værre end ingen seedning, fordi den giver misvisende testresultater.

async function seed() {
  const client = new MongoClient(process.env.MONGO_URI);
  try {
    await client.connect();
    const db = client.db('myapp');
    await seedUsers(db);
    await seedProducts(db);
    await seedOrders(db);
    await ensureIndexes(db);
    console.log('All seed steps completed successfully');
    process.exit(0);
  } catch (err) {
    console.error('Seed failed:', err.message);
    process.exit(1);
  } finally {
    await client.close();
  }
}

Hurtigt tjek

Test din forståelse af begreberne MongoDB og NoSQL-databaser fra denne lektion.

Besvar den i den interaktive lektion

Opsummering af lektionen

I denne lektion har du lært, at seed-scripts bruger Node.js-driveren til programmæssigt at indsætte, rydde og generere testdata igen, at deterministiske ObjectIds gør relationer på tværs af samlinger reproducerbare på tværs af kørsler, og at et kald til deleteMany i starten af hver seed-funktion gør scriptet idempotent og sikkert at køre igen. Dette afslutter kurset Importing and Exporting Data — nu går vi videre til Indexes Fundamentals for forespørgselsydelse på produktionsniveau.

Gratis at komme i gang

Lær JavaScript med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser: 30
Lektioner: 120

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “Indlæsning af testdata med Node.js-scripts” gratis?

Ja — hele teksten til “Indlæsning af testdata med Node.js-scripts” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af MongoDB Academy-kurset, skal du opgradere til CoddyKit PRO. MongoDB Academy-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “Indlæsning af testdata med Node.js-scripts”?

De lærende vil skrive et Node.js-script til indlæsning af testdata, som læser en JSON-fil og indsætter dokumenter samlet i MongoDB til lokal udvikling. Du øver dig i MongoDB Academy med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på MongoDB Academy?

Der kræves ingen tidligere erfaring. MongoDB Academy på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 4 af 4.

Hvor lang tid tager lektionen “Indlæsning af testdata med Node.js-scripts”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne MongoDB Academy-lektion?

Ja. Alle MongoDB Academy-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

mongoimport: Indlæsning af JSON- og CSV-filer
mongoexport: Eksport af samlinger til filer
mongodump og mongorestore til komplette sikkerhedskopier
Indlæsning af testdata med Node.js-scripts

← Tilbage til MongoDB Academy