Node.js中如何将JSON/请求对象转为Model类？（原生驱动场景）

Alright, let's break this down into two clear parts to solve your questions:

1. Parsing JSON into a Model Class in Node.js #

In vanilla Node.js, the core idea is to map the JSON object's properties to an instance of your custom Model class. Here are a couple of straightforward approaches:

Approach 1: Constructor-Based Mapping #

Define your Model class with a constructor that accepts the JSON object, then assign properties explicitly (this gives you control over validation and default values):

class Product {
  constructor(json) {
    // Add validation here if needed
    if (!json.name) throw new Error('Product name is required');
    
    this.id = json.id;
    this.name = json.name;
    this.price = json.price || 0;
    this.inStock = json.inStock ?? true;
  }
}

// Usage:
const productJson = { name: 'Laptop', price: 999 };
const product = new Product(productJson);

Approach 2: Using Object.assign (Shorter, Less Control) #

If you don't need strict validation or default values upfront, you can use Object.assign to copy properties directly to the instance:

class Product {
  constructor(json) {
    Object.assign(this, json);
    // Optional: Add post-assignment validation
    if (!this.name) throw new Error('Product name is required');
  }
}

2. Adapting to MongoDB Native/mongojs Driver in Node-Express-Mongo Apps #

Since you're avoiding Mongoose, you'll need to handle two key flows: converting incoming request bodies to Model instances and converting MongoDB documents back to Model instances. Here's a practical implementation:

Step 1: Define Your Model Class with Conversion Methods #

Add static and instance methods to handle conversion between your Model and MongoDB's document format:

const { ObjectId } = require('mongodb'); // For native driver; mongojs has similar ObjectId support

class User {
  constructor({ id, name, email, createdAt }) {
    // Validation
    if (!name || !email) throw new Error('Name and email are required');
    
    this.id = id; // String ID for client use
    this.name = name;
    this.email = email;
    this.createdAt = createdAt || new Date();
  }

  // Convert Model instance to a plain object for MongoDB storage
  toMongoDoc() {
    // Exclude the 'id' field since MongoDB uses '_id'
    return {
      name: this.name,
      email: this.email,
      createdAt: this.createdAt
    };
  }

  // Static method: Convert MongoDB document to Model instance
  static fromMongoDoc(doc) {
    return new User({
      id: doc._id.toString(), // Convert ObjectId to string for client-friendly ID
      name: doc.name,
      email: doc.email,
      createdAt: doc.createdAt
    });
  }
}

Step 2: Integrate with Express and MongoDB Native Driver #

Here's how to use this Model in your Express routes with the native MongoDB driver (the logic is nearly identical for mongojs):

const express = require('express');
const { MongoClient } = require('mongodb');
const app = express();

app.use(express.json()); // Parse incoming JSON requests

// Connect to MongoDB
let db;
MongoClient.connect('mongodb://localhost:27017')
  .then(client => {
    db = client.db('your_database_name');
    console.log('Connected to MongoDB');
  })
  .catch(err => console.error('MongoDB connection error:', err));

// Create User Route
app.post('/users', async (req, res) => {
  try {
    // Convert request body to User instance
    const user = new User(req.body);
    
    // Insert the plain MongoDB document
    const result = await db.collection('users').insertOne(user.toMongoDoc());
    
    // Convert the inserted document back to User instance and respond
    const createdUser = User.fromMongoDoc({ ...result.ops[0], _id: result.insertedId });
    res.status(201).json(createdUser);
  } catch (err) {
    res.status(400).json({ error: err.message });
  }
});

// Get Single User Route
app.get('/users/:id', async (req, res) => {
  try {
    const doc = await db.collection('users').findOne({ 
      _id: new ObjectId(req.params.id) 
    });

    if (!doc) return res.status(404).json({ error: 'User not found' });
    
    // Convert MongoDB document to User instance
    const user = User.fromMongoDoc(doc);
    res.json(user);
  } catch (err) {
    res.status(500).json({ error: err.message });
  }
});

// Get All Users Route
app.get('/users', async (req, res) => {
  try {
    const docs = await db.collection('users').find().toArray();
    // Convert all documents to User instances
    const users = docs.map(User.fromMongoDoc);
    res.json(users);
  } catch (err) {
    res.status(500).json({ error: err.message });
  }
});

app.listen(3000, () => console.log('Server running on port 3000'));

Key Notes for mongojs Users #

If you're using mongojs instead of the official native driver, the only differences are minor API changes:

• mongojs uses db.collection('users').save() or insert() instead of insertOne()
• ObjectId handling is similar: mongojs.ObjectId(req.params.id)
• The conversion logic (Model ↔ Document) remains exactly the same

Bonus: Adding Validation Logic #

To keep your data consistent, add validation directly in the Model's constructor (or a separate validate method) instead of relying on MongoDB's schema validation. For example:

class User {
  constructor({ id, name, email, createdAt }) {
    if (!name || typeof name !== 'string') {
      throw new Error('Name must be a non-empty string');
    }
    if (!email.match(/^[^\s@]+@[^\s@]+\.[^\s@]+$/)) {
      throw new Error('Invalid email format');
    }
    
    // Rest of the constructor logic...
  }
}

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