0Pricing
MongoDB Academy · 课时

使用 Node.js 脚本填充数据

您将编写 Node.js 数据填充脚本，读取 JSON 文件并将文档批量插入 MongoDB，以支持本地开发。

使用 Node.js 脚本填充数据 是 CoddyKit 上的免费 MongoDB Academy 课时。 这是第 4 节课，共 4 节。 你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。 这是 MongoDB Academy 学习路径的一部分，你的进度在网页和 CoddyKit 应用中同步。 MongoDB Academy 课程共包含 4 节课。

本课时的部分内容尚未翻译，以英文显示。

Why Write a Seed Script?

A seed script is a Node.js program that populates a MongoDB database with initial or test data. Unlike mongoimport, a seed script can generate dynamic data (IDs, relationships, timestamps), conditionally insert data that doesn't already exist, and apply business logic while seeding—for example, hashing passwords or computing derived fields. Seed scripts are the backbone of local development environment setup.

Setting Up the MongoDB Client

A seed script connects to MongoDB using the official mongodb Node.js driver. Keep the connection URI in an environment variable or a .env file—never hardcode credentials. Call client.connect() at the start, run all seed operations, and call client.close() in a finally block to ensure the script exits cleanly even if an error occurs.

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

Inserting Documents With bulkWrite

Use collection.bulkWrite() with ordered: false for efficient bulk inserts. Unlike multiple insertOne calls, bulkWrite sends all operations to the server in a single network round trip. Set ordered: false so that duplicate key errors on individual documents don't stop the entire batch—useful when re-running a seed script that uses deterministic IDs.

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 Seeding With deleteMany

Make your seed script idempotent—safe to run multiple times—by clearing the target collections before inserting. Call deleteMany({}) (or drop()) at the start of each seed function. This ensures the database starts from a known clean state on every run, which is essential for local development where you want reproducible data without duplicates.

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

Generating Realistic Fake Data

For development seeds, generate realistic-looking data programmatically using a helper library like @faker-js/faker or by constructing data manually. Generating data in the script (rather than loading static JSON files) lets you easily change the volume—seed 10 documents for unit tests, 10,000 for load testing—with a single parameter change.

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

Seeding Relationships Between Collections

When seeding related collections, create parent documents first and use their _id values when creating child documents. Using deterministic ObjectIds (constructed from fixed hex strings) lets you reference specific parent documents reliably across runs without having to query for them after insertion.

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

Reading Seed Data From JSON Files

For complex seed data that is easier to maintain as JSON (product catalogues, country lists, configuration tables), read the JSON file with fs.readFileSync and pass the parsed array directly to insertMany. Pair this with the idempotent deleteMany approach so the script can be re-run safely after editing the JSON file.

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

Creating Indexes After Seeding

Seed scripts should create the same indexes that production uses. Call collection.createIndex() (or createIndexes()) at the end of each seed function, or in a dedicated ensureIndexes step. Creating indexes after bulk insert is faster than maintaining them during the insert—MongoDB builds the B-tree from the sorted data in one pass.

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

Running the Seed Script

Run the seed script from the command line with node seed.js or add it to your package.json scripts section. Pass environment-specific URIs via environment variables so the same script works for local, CI, and staging environments without modification. Never run a seed script that calls deleteMany against a production 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

Using Seed Scripts in CI Pipelines

In a CI pipeline, run the seed script as part of the test setup step before executing integration or end-to-end tests. Spin up a MongoDB Docker container (or use mongodb-memory-server), run the seed script to populate test data, run the tests, and tear down the container. This gives every CI run a clean, reproducible database state.

# 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

Handling Seed Errors Gracefully

Wrap your seed functions in try/catch blocks so that a failure in one section doesn't leave the database in a half-seeded state without a clear error message. Log the error, abort the remaining seed steps, and exit with a non-zero code so CI pipelines detect the failure. A partial seed is often worse than no seed because it produces misleading test results.

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

Quick Check

Test your understanding of MongoDB & NoSQL Databases concepts from this lesson.

Lesson Recap

In this lesson you learned: seed scripts use the Node.js driver to insert, clear, and regenerate test data programmatically, deterministic ObjectIds make cross-collection relationships reproducible across runs, and calling deleteMany at the start of each seed function makes the script idempotent and safe to re-run. This completes the Importing and Exporting Data course — next we advance to Indexes Fundamentals for production-grade query performance.

常见问题解答

「使用 Node.js 脚本填充数据」课时是免费的吗？

是的 — 「使用 Node.js 脚本填充数据」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 AI 导师）并解锁 MongoDB Academy 课程的其余内容，请升级到 CoddyKit PRO。 MongoDB Academy 课程共包含 4 节课。

「使用 Node.js 脚本填充数据」这节课中我会学到什么？

您将编写 Node.js 数据填充脚本，读取 JSON 文件并将文档批量插入 MongoDB，以支持本地开发。 你通过在浏览器中直接运行的动手代码来练习 MongoDB Academy，全天候 AI 导师会在你学习这节课的过程中回答你的问题。

学习 MongoDB Academy 需要有经验吗？

无需任何先前经验。CoddyKit 上的 MongoDB Academy 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。 这是第 4 节课，共 4 节。

「使用 Node.js 脚本填充数据」课时需要多长时间？

大多数 CoddyKit 课程大约需要 5–10 分钟。每节课都很精短且互动，所以你能稳步进步，并在网页和应用中从离开的地方继续。

我能在这节 MongoDB Academy 课中编写并运行代码吗？

能。每节 MongoDB Academy 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。

此课程中的所有课时

  1. mongoimport：加载 JSON 和 CSV 文件
  2. mongoexport：将集合导出到文件
  3. 使用 mongodump 和 mongorestore 完成完整备份
  4. 使用 Node.js 脚本填充数据
← 返回 MongoDB Academy