MongoDB Academy · Oppitunti

Datan alustaminen Node.js-skripteillä

Oppijat kirjoittavat Node.js-alustusskriptin, joka lukee JSON-tiedoston ja lisää dokumentit joukkona MongoDB:hen paikallista kehitystä varten.

Oppitunti 4/413 vaihetta

Datan alustaminen Node.js-skripteillä on ilmainen MongoDB Academy-oppitunti CoddyKitissä. Tämä on oppitunti 4/4. Voit lukea koko oppitunnin alta ilmaiseksi ja harjoitella sen jälkeen käytännössä selaimessa sisäänrakennetulla koodieditorilla ja ympäri vuorokauden käytettävissä olevan tekoälytuutorin avulla. Oppitunti kuuluu MongoDB Academy-oppimispolkuun, ja edistymisesi synkronoituu verkon ja CoddyKit-sovelluksen välillä. MongoDB Academy-kurssilla on yhteensä 4 oppituntia.

Miksi seed-komentosarja kannattaa kirjoittaa

Seed-komentosarja on Node.js-ohjelma, joka täyttää MongoDB-tietokannan alku- tai testitiedoilla. Toisin kuin mongoimport, seed-komentosarja voi luoda dynaamisia tietoja (tunnisteita, suhteita ja aikaleimoja), lisätä ehdollisesti tietoja, joita ei vielä ole olemassa, sekä soveltaa liiketoimintalogiikkaa tietoja alustettaessa, esimerkiksi tiivistää salasanoja tai laskea johdettuja kenttiä. Seed-komentosarjat ovat paikallisten kehitysympäristöjen alustamisen perusta.

MongoDB-asiakkaan määrittäminen

Seed-komentosarja muodostaa yhteyden MongoDB:hen virallisen mongodb-Node.js-ajurin avulla. Säilytä yhteys-URI ympäristömuuttujassa tai .env-tiedostossa — älä koskaan kirjoita tunnistetietoja suoraan koodiin. Kutsu client.connect()-metodia alussa, suorita kaikki tietojen alustustoiminnot ja kutsu client.close()-metodia finally-lohkossa, jotta komentosarja päättyy siististi myös virheen tapahtuessa.

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);

Dokumenttien lisääminen bulkWritella

Käytä tehokkaisiin massalisäyksiin collection.bulkWrite()-metodia yhdessä asetuksen ordered: false kanssa. Toisin kuin useat insertOne-kutsut, bulkWrite lähettää kaikki operaatiot palvelimelle yhdellä verkkokutsulla. Määritä asetukseksi ordered: false, jotta yksittäisten dokumenttien duplicate key -virheet eivät keskeytä koko erää. Tämä on hyödyllistä, kun suoritat uudelleen seed-komentosarjan, joka käyttää deterministisiä tunnisteita.

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);
}

Idempotentti tietojen alustus deleteMany-metodilla

Tee seed-skriptistäsi idempotentti – useita kertoja turvallisesti suoritettava – tyhjentämällä kohdekokoelmat ennen lisäystä. Kutsu deleteMany({}) (tai drop()) jokaisen seed-funktion alussa. Näin tietokanta aloittaa jokaisen suorituksen tunnetusta ja puhtaasta tilasta. Tämä on olennaista paikallisessa kehityksessä, jossa tarvitset toistettavaa dataa ilman kaksoiskappaleita.

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');
}

Realistisen näköisen testidatan luominen

Kehitysympäristön seed-dataa varten voit luoda ohjelmallisesti realistisen näköistä dataa apukirjaston, kuten @faker-js/faker, avulla tai muodostamalla datan itse. Kun data luodaan skriptissä staattisten JSON-tiedostojen lataamisen sijaan, määrää on helppo muuttaa yhdellä parametrimuutoksella – voit luoda yksikkötesteihin 10 dokumenttia ja kuormitustestaukseen 10 000.

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
  }));
}

Kokoelmien välisten suhteiden alustaminen

Kun alustat toisiinsa liittyviä kokoelmia, luo ylätason dokumentit ensin ja käytä niiden _id-arvoja alatason dokumenttien luonnissa. Determinististen ObjectId-arvojen (kiinteistä heksadesimaalimerkkijonoista muodostettujen arvojen) avulla voit viitata tiettyihin ylätason dokumentteihin luotettavasti suorituskerrasta toiseen ilman, että niitä tarvitsee hakea lisäyksen jälkeen.

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');
}

Seed-datan lukeminen JSON-tiedostoista

Jos monimutkaista seed-dataa on helpompi ylläpitää JSON-muodossa (esimerkiksi tuoteluetteloita, maaluetteloita tai asetustaulukoita), lue JSON-tiedosto komennolla fs.readFileSync ja välitä jäsennetty taulukko suoraan komennolle insertMany. Yhdistä tähän idempotentti deleteMany-menetelmä, jotta skriptin voi suorittaa turvallisesti uudelleen JSON-tiedoston muokkaamisen jälkeen.

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');

Indeksien luominen seedauksen jälkeen

Seed-skriptien tulisi luoda samat indeksit, joita tuotantoympäristö käyttää. Kutsu collection.createIndex() (tai createIndexes()) jokaisen seed-funktion lopussa tai erillisessä ensureIndexes-vaiheessa. Indeksien luominen joukkolisäyksen jälkeen on nopeampaa kuin niiden ylläpito lisäyksen aikana – MongoDB muodostaa B-puun lajitellusta datasta yhdellä läpikäynnillä.

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');
}

Seed-skriptin suorittaminen

Suorita seed-skripti komentoriviltä komennolla node seed.js tai lisää se package.json-tiedoston scripts-osioon. Välitä ympäristökohtaiset URI:t ympäristömuuttujina, jotta sama skripti toimii paikallisessa ympäristössä sekä CI- ja staging-ympäristöissä ilman muutoksia. Älä koskaan suorita deleteMany-kutsua sisältävää seed-skriptiä tuotantoympäristön URI:ta vasten.

// 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

Seed-skriptien käyttäminen CI-putkissa

Suorita CI-putkessa seed-skripti osana testien valmisteluvaihetta ennen integraatio- tai päästä päähän -testien suorittamista. Käynnistä MongoDB Docker-säilössä (tai käytä mongodb-memory-server-pakettia), suorita seed-skripti testidatan täyttämiseksi, suorita testit ja poista säilö käytöstä. Näin jokainen CI-suoritus saa puhtaan ja toistettavan tietokantatilan.

# 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

Seed-virheiden hallinta hallitusti

Sijoita seed-funktiot try/catch-lohkoihin, jotta yhden osion virhe ei jätä tietokantaa osittain alustettuun tilaan ilman selkeää virheilmoitusta. Kirjaa virhe lokiin, keskeytä jäljellä olevat seed-vaiheet ja lopeta suoritus nollasta poikkeavalla koodilla, jotta CI-putket havaitsevat virheen. Osittainen seedaus on usein pahempi kuin seedauksen puuttuminen, koska se tuottaa harhaanjohtavia testituloksia.

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();
  }
}

Pikatarkistus

Testaa tämän oppitunnin MongoDB:tä ja NoSQL-tietokantoja koskevien käsitteiden ymmärtämisesi.

Vastaa interaktiivisessa oppitunnissa

Oppitunnin yhteenveto

Tässä oppitunnissa opit, että seed-skriptit käyttävät Node.js-ajuria testidatan lisäämiseen, tyhjentämiseen ja ohjelmalliseen uudelleenluomiseen, deterministiset ObjectId-arvot tekevät kokoelmien välisistä suhteista toistettavia eri suorituskertojen välillä ja deleteMany-kutsun tekeminen jokaisen seed-funktion alussa tekee skriptistä idempotentin ja turvallisesti uudelleen suoritettavan. Tämä päättää Importing and Exporting Data -kurssin – seuraavaksi siirrymme Indexes Fundamentals -aiheeseen tuotantotasoisen kyselysuorituskyvyn saavuttamiseksi.

Aloita maksutta

Opi JavaScript tekoälytuutorin avulla — ilmaiseksi

Kirjoita ja suorita oikeaa koodia selaimessa, saa välitöntä apua tekoälytuutorilta ympäri vuorokauden ja jatka siitä, mihin jäit, verkossa tai sovelluksessa.

Kurssit: 30
Oppitunnit: 120

Aloita opiskelu maksutta Näytä koko kurssi

Usein kysytyt kysymykset

Onko oppitunti ”Datan alustaminen Node.js-skripteillä” ilmainen?

Kyllä – oppitunnin ”Datan alustaminen Node.js-skripteillä” koko tekstin voi lukea täällä verkossa ilmaiseksi. Jos haluat harjoitella interaktiivisesti sisäänrakennetulla koodieditorilla ja ympäri vuorokauden käytettävissä olevan tekoälytuutorin avulla sekä avata koko MongoDB Academy-kurssin, päivitä CoddyKit PROhon. MongoDB Academy-kurssilla on yhteensä 4 oppituntia.

Mitä opin oppitunnilla ”Datan alustaminen Node.js-skripteillä”?

Oppijat kirjoittavat Node.js-alustusskriptin, joka lukee JSON-tiedoston ja lisää dokumentit joukkona MongoDB:hen paikallista kehitystä varten. Harjoittelet MongoDB Academy-aihetta koodilla, jonka suoritat suoraan selaimessa. Ympäri vuorokauden käytettävissä oleva tekoälytuutori vastaa kysymyksiisi oppitunnin aikana.

Tarvitsenko kokemusta aloittaakseni MongoDB Academy-opiskelun?

Aiempi kokemus ei ole tarpeen. CoddyKitin MongoDB Academy-oppimispolku sopii vasta-alkajista edistyneisiin, joten voit aloittaa tästä tai alusta ja edetä omaan tahtiisi. Tämä on oppitunti 4/4.

Kuinka kauan ”Datan alustaminen Node.js-skripteillä”-oppitunnin suorittaminen kestää?

Useimmat CoddyKitin oppitunnit kestävät noin 5–10 minuuttia. Jokainen oppitunti on lyhyt ja interaktiivinen, joten edistyt tasaisesti ja voit jatkaa siitä, mihin jäit – sekä verkossa että sovelluksessa.

Voinko kirjoittaa ja suorittaa koodia tällä MongoDB Academy-oppitunnilla?

Kyllä. Jokainen MongoDB Academy-oppitunti sisältää sisäänrakennetun koodieditorin, joten voit kirjoittaa ja suorittaa oikeaa koodia suoraan selaimessa ja saada välitöntä palautetta tekoälyltä – paikallista asennusta ei tarvita.

Kaikki tämän kurssin oppitunnit

mongoimport: JSON- ja CSV-tiedostojen lataaminen
mongoexport: Kokoelmien vieminen tiedostoihin
mongodump ja mongorestore täydellisiin varmuuskopioihin
Datan alustaminen Node.js-skripteillä

← Takaisin: MongoDB Academy