如何为Firestore批量创建指定结构的模拟样本数据？

Got it, this is a super common pain point when dealing with bulk data in Firestore—manual entry is definitely not the way to go. Here are a few solid, efficient solutions to import your JSON data quickly:

This is the quickest no-code/low-code option for straightforward bulk imports:

• First, make sure you have the Firebase CLI installed. If not, run npm install -g firebase-tools in your terminal. Then log in with firebase login and initialize your Firestore project (if you haven’t already) with firebase init firestore.
• Prepare your JSON file to match Firestore’s import format. For collection-level imports (the most efficient for batches), structure it like this:

  {
    "your-collection-name": {
      "doc-id-1": {
        "field1": "value1",
        "field2": 123
      },
      "doc-id-2": {
        "field1": "value2",
        "field2": 456
      }
    }
  }
  

• Run the import command:

  firebase firestore:import --project your-project-id --import-file path/to/your/data.json
  

  Add the --merge flag if you want to update existing documents instead of overwriting them entirely.

Perfect if you need to transform data before importing, or if your JSON structure doesn’t perfectly match Firestore’s requirements:

• Set up a Node.js project: run npm init -y, then install the Admin SDK with npm install firebase-admin.
• Download your Firebase project’s service account key (from Firebase Console → Project Settings → Service Accounts → Generate New Private Key) and save it as serviceAccountKey.json in your project folder.
• Create a script (e.g., import-data.js) with this template—adjust it to fit your data structure:

  const admin = require('firebase-admin');
  const fs = require('fs');
  
  // Initialize Admin SDK
  admin.initializeApp({
    credential: admin.credential.cert(require('./serviceAccountKey.json'))
  });
  
  const db = admin.firestore();
  const rawData = fs.readFileSync('./your-data.json', 'utf8');
  const data = JSON.parse(rawData);
  
  async function batchImport() {
    let batch = db.batch();
    let docCount = 0;
    const batchLimit = 500; // Firestore's max batch size
  
    // Loop through your collection and documents
    for (const collectionName in data) {
      for (const docId in data[collectionName]) {
        const docRef = db.collection(collectionName).doc(docId);
        batch.set(docRef, data[collectionName][docId], { merge: true });
        docCount++;
  
        // Commit batch when we hit the limit
        if (docCount % batchLimit === 0) {
          await batch.commit();
          console.log(`Committed ${docCount} documents so far`);
          batch = db.batch(); // Reset for next batch
        }
      }
    }
  
    // Commit any remaining documents
    if (docCount % batchLimit !== 0) {
      await batch.commit();
      console.log(`Committed final ${docCount % batchLimit} documents`);
    }
  
    console.log('✅ All data imported successfully!');
  }
  
  // Run the import and catch errors
  batchImport().catch(err => console.error('❌ Import failed:', err));
  

• Run the script with node import-data.js. You can tweak this to generate auto IDs (use db.collection(collectionName).add(docData) instead of specifying docId) or clean up data fields on the fly.

If you’re dealing with a few hundred documents and don’t want to touch code, the console has a hidden import feature:

• Open Firebase Console → Firestore Database → Navigate to the collection (or root) where you want to import data.
• Click the Import button at the top of the screen (it’s easy to miss!).
• Select your JSON file (make sure it follows the collection-level format mentioned earlier), choose import options (merge vs overwrite), and confirm. This is great for quick, one-off imports without setup.

If you need to trigger imports automatically (e.g., when a JSON file is uploaded to Cloud Storage), use Cloud Functions:

• Upload your JSON file to a Cloud Storage bucket linked to your Firebase project.
• Write a function that triggers when a file is finalized in the bucket, then imports the data to Firestore. Here’s a simplified example:

  const functions = require('firebase-functions');
  const admin = require('firebase-admin');
  const { Storage } = require('@google-cloud/storage');
  
  admin.initializeApp();
  const storage = new Storage();
  
  exports.importFirestoreData = functions.storage.object().onFinalize(async (object) => {
    const bucket = storage.bucket(object.bucket);
    const file = bucket.file(object.name);
    const fileContents = await file.download();
    const data = JSON.parse(fileContents.toString());
  
    // Reuse the batch import logic from the Admin SDK script
    let batch = admin.firestore().batch();
    let docCount = 0;
    const batchLimit = 500;
  
    for (const collectionName in data) {
      for (const docId in data[collectionName]) {
        const docRef = admin.firestore().collection(collectionName).doc(docId);
        batch.set(docRef, data[collectionName][docId], { merge: true });
        docCount++;
  
        if (docCount % batchLimit === 0) {
          await batch.commit();
          batch = admin.firestore().batch();
        }
      }
    }
  
    await batch.commit();
    console.log(`Automatically imported ${docCount} documents`);
    return null;
  });
  

• Deploy the function with firebase deploy --only functions. Now every time you upload a valid JSON file to your storage bucket, it’ll auto-import to Firestore.

内容的提问来源于stack exchange，提问作者Eriendel