MongoDB नेटिव ड्राइवर्स के साथ Node.js और Express का उपयोग करना: क्यों और कैसे

यदि आप Node.js और Express के साथ काम कर रहे हैं, तो आपने MongoDB के लिए एक लोकप्रिय ODM (ऑब्जेक्ट डेटा मॉडलिंग) लाइब्रेरी Mongoose का सामना किया होगा। जबकि Mongoose बहुत सारी उपयोगी सुविधाएँ प्रदान करता है, ऐसे कुछ कारण हैं जिनसे आप सीधे MongoDB के मूल ड्राइवरों के साथ काम करना चुन सकते हैं। इस पोस्ट में, मैं आपको MongoDB देशी ड्राइवरों का उपयोग करने के लाभों के बारे में बताऊंगा और साझा करूंगा कि आप उनके साथ एक सरल CRUD एपीआई कैसे कार्यान्वित कर सकते हैं।

MongoDB नेटिव ड्राइवर्स का उपयोग क्यों करें?

1. प्रदर्शन: MongoDB के मूल ड्राइवर Mongoose द्वारा प्रस्तुत अतिरिक्त अमूर्त परत के बिना सीधे MongoDB के साथ बातचीत करके बेहतर प्रदर्शन प्रदान करते हैं। यह उच्च-प्रदर्शन अनुप्रयोगों के लिए विशेष रूप से फायदेमंद हो सकता है।

2. लचीलापन: मूल ड्राइवर आपके प्रश्नों और डेटा इंटरैक्शन पर अधिक नियंत्रण प्रदान करते हैं। नेवला, अपने स्कीमा और मॉडल के साथ, कुछ संरचना लागू करता है, जो हर उपयोग के मामले के लिए आदर्श नहीं हो सकता है।

3. कम ओवरहेड: देशी ड्राइवरों का उपयोग करके, आप Mongoose स्कीमा और मॉडल को बनाए रखने के अतिरिक्त ओवरहेड से बचते हैं, जो आपके कोडबेस को सरल बना सकता है।

4. सीखने का अवसर: देशी ड्राइवरों के साथ सीधे काम करने से आपको MongoDB के संचालन को बेहतर ढंग से समझने में मदद मिलती है और सीखने का एक शानदार अनुभव हो सकता है।

MongoDB नेटिव ड्राइवर्स के साथ CRUD API लागू करना

यहां Node.js, Express और MongoDB देशी ड्राइवरों का उपयोग करके एक सरल CRUD API सेट करने के बारे में चरण-दर-चरण मार्गदर्शिका दी गई है।

1. डेटाबेस कनेक्शन सेट करें

MongoDB कनेक्शन को प्रबंधित करने के लिए एक utils/db.js फ़ाइल बनाएं:

require('dotenv').config()
const dbConfig = require('../config/db.config');
const { MongoClient } = require('mongodb');

const client = new MongoClient(dbConfig.url);

let _db;
let connectPromise;

async function connectToDb() {
    if (!connectPromise) {
        connectPromise = new Promise(async (resolve, reject) => {
            try {
                await client.connect();
                console.log('Connected to the database ?', client.s.options.dbName);
                _db = client.db();
                resolve(_db);
            } catch (error) {
                console.error('Error connecting to the database:', error);
                reject(error);
            }
        });
    }
    return connectPromise;
}

function getDb() {
    if (!_db) {
        throw new Error('Database not connected');
    }
    return _db;
}

function isDbConnected() {
    return Boolean(_db);
}

module.exports = { connectToDb, getDb, isDbConnected };

2. अपना मॉडल परिभाषित करें

MongoDB संग्रह के साथ इंटरैक्ट करने के लिए एक मॉडल/मॉडल.जेएस फ़ाइल बनाएं:

const { ObjectId } = require('mongodb');
const db = require('../utils/db');

class AppModel {
    constructor($collection) {
        this.collection = null;

        (async () => {
            if (!db.isDbConnected()) {
                console.log('Waiting for the database to connect...');
                await db.connectToDb();
            }
            this.collection = db.getDb().collection($collection);
            console.log('Collection name:', $collection);
        })();
    }

    async find() {
        return await this.collection.find().toArray();
    }

    async findOne(condition = {}) {
        const result = await this.collection.findOne(condition);
        return result || 'No document Found!';
    }

    async create(data) {
        data.createdAt = new Date();
        data.updatedAt = new Date();
        let result = await this.collection.insertOne(data);
        return `${result.insertedId} Inserted successfully`;
    }

    async update(id, data) {
        let condition = await this.collection.findOne({ _id: new ObjectId(id) });
        if (condition) {
            const result = await this.collection.updateOne({ _id: new ObjectId(id) }, { $set: { ...data, updatedAt: new Date() } });
            return `${result.modifiedCount > 0} Updated successfully!`;
        } else {
            return `No document found with ${id}`;
        }
    }

    async deleteOne(id) {
        const condition = await this.collection.findOne({ _id: new ObjectId(id) });
        if (condition) {
            const result = await this.collection.deleteOne({ _id: new ObjectId(id) });
            return `${result.deletedCount > 0} Deleted successfully!`;
        } else {
            return `No document found with ${id}`;
        }
    }
}

module.exports = AppModel;

3. रूट सेट करें

अपने एपीआई मार्गों को परिभाषित करने के लिए एक इंडेक्स.जेएस फ़ाइल बनाएं:

const express = require('express');
const router = express.Router();

const users = require('../controllers/userController');

router.get("/users", users.findAll);
router.post("/users", users.create);
router.put("/users", users.update);
router.get("/users/:id", users.findOne);
router.delete("/users/:id", users.deleteOne);

module.exports = router;

4. नियंत्रकों को लागू करें

अपने सीआरयूडी संचालन को संभालने के लिए एक userController.js फ़ाइल बनाएं:

const { ObjectId } = require('mongodb');
const Model = require('../models/model');

const model = new Model('users');

let userController = {
    async findAll(req, res) {
        model.find()
            .then(data => res.send(data))
            .catch(err => res.status(500).send({ message: err.message }));
    },
    async findOne(req, res) {
        let condition = { _id: new ObjectId(req.params.id) };
        model.findOne(condition)
            .then(data => res.send(data))
            .catch(err => res.status(500).send({ message: err.message }));
    },
    create(req, res) {
        let data = req.body;
        model.create(data)
            .then(data => res.send(data))
            .catch(error => res.status(500).send({ message: error.message }));
    },
    update(req, res) {
        let id = req.body._id;
        let data = req.body;
        model.update(id, data)
            .then(data => res.send(data))
            .catch(error => res.status(500).send({ message: error.message }));
    },
    deleteOne(req, res) {
        let id = new ObjectId(req.params.id);
        model.deleteOne(id)
            .then(data => res.send(data))
            .catch(error => res.status(500).send({ message: error.message }));
    }
}

module.exports = userController;

5. विन्यास

अपनी MongoDB कनेक्शन स्ट्रिंग को एक .env फ़ाइल में संग्रहीत करें और इसे लोड करने के लिए एक db.config.js फ़ाइल बनाएं:

module.exports = {
    url: process.env.DB_CONFIG,
};

निष्कर्ष

Mongoose से MongoDB देशी ड्राइवरों पर स्विच करना कुछ परियोजनाओं के लिए एक रणनीतिक विकल्प हो सकता है, जो प्रदर्शन लाभ और अधिक लचीलेपन की पेशकश करता है। यहां दिए गए कार्यान्वयन से आपको Node.js और MongoDB देशी ड्राइवरों के साथ एप्लिकेशन बनाना शुरू करने के लिए एक ठोस आधार मिलना चाहिए।

बेझिझक GitHub पर पूरा कोड देखें और अपनी परियोजनाओं के लिए अधिक सुविधाओं या संवर्द्धनों का पता लगाएं!

किसी भी अन्य प्रश्न के लिए बेझिझक टिप्पणी करें।

हैप्पी कोडिंग! ?