DEV Community: sujon554

Setup MongoDB in Node.js with Mongoose

sujon554 — Fri, 15 Apr 2022 06:42:38 +0000

Setting up database connection

npm install mongoose --save

First let import the dependency;

const mongoose = require("mongoose");

Then let’s store the path of the database in a variable. The path should look like the following, with and being replaced with a user you have created for the database.

const dbPath = "mongodb://<dbuser>:<dbpassword>@ds250607.mlab.com:38485/test-db";

connect to the database.

mongoose.connect(dbPath, {
    useNewUrlParser: true,
});

module.exports = mongoose;

Once the application is started, it would be better if there was an indicator showing whether the application successfully connected to the database or not. So let’s add some more code to fix that.

const db = mongoose.connection;
db.on("error", () => {
    console.log("> error occurred from the database");
});
db.once("open", () => {
    console.log("> successfully opened the database");
});

In the end the database.js should look like this.


// database.js
const mongoose = require("mongoose");
const dbPath = "mongodb://<dbuser>:<dbpassword>@ds250607.mlab.com:38485/test-db";
mongoose.connect(dbPath, {
    useNewUrlParser: true,
});
const db = mongoose.connection;
db.on("error", () => {
    console.log("> error occurred from the database");
});
db.once("open", () => {
    console.log("> successfully opened the database");
});
module.exports = mongoose;

Setting up models/schema

// models/userModel.js
const mongoose = require("../database");
const schema = {
    name: { type: mongoose.SchemaTypes.String, required: true },
    email: { type: mongoose.SchemaTypes.String, required: true },
    password: { 
        type: mongoose.SchemaTypes.String, 
        required: true, 
        select: false
    }
};
const collectionName = "user"; // Name of the collection of documents
const userSchema = mongoose.Schema(schema);
const User = mongoose.model(collectionName, userSchema);
module.exports = User;

// Create user
User.create({
    name: name,
    email: email,
    password: password
});
// Find user by email
User.findOne({
    email: email
});
// Find user by email with the password field included
User.findOne({
    email: email
}).select("+password");

CURD Operations MongoDB with Node

sujon554 — Wed, 09 Feb 2022 06:36:00 +0000

What is the CURD operations?

When we create a project with React as a client site and with NodeJs as a server site, we have to process some operations on the server site with NodeJs. CURD is an acronym that stands for Create, Update, Read, and Delete. According to our needs, We use to get, post, put, delete methods.

_Important Note:

NodeJs is a separate or another runtime of JavaScript.

NASA, Uber, IBM, Paypal use NodeJs.

The V8 engine makes JavaScript fast Just in time (JIT) compile.

npm stands for Node Package Manager.

MongoDB keeps the data in JSON structure. _

Non-blocking: Single-threaded accepts the request and then sends the request to others. The current thread won’t remain blocked with the request.
Asynchronous/ Call back: NodeJs does not work synchronously or one by one.

get any data from mongodb with node.js

Use a database collection by
const productcollection = database.collection('product');
Then, use app.get() function by below system
app.get('/product', async (req, res) => {
const getdata = productcollection.find({});
const showdata = await getdata.toArray();
res.send(showdata);
})

get any single data from mongodb with node.js

Use a database collection by
const productcollection = database.collection('product');
Then, use app.get() function by below system,
app.get('/product/:id', async (req, res) => {
const id = req.params.id;
const getId = { _id: ObjectId(id) };
const showId = await productcollection.findOne(getId);
res.json(showId);
})

Post any data to mongodb with node.js

Use a database collection by
const productcollection = database.collection('product');
Then, use app.post() function by below system

app.post('/product', async (req, res) => {
const add = req.body;
const result = await productcollection.insertOne(add);
console.log(result);
res.json(result);
})

delete any data from mongodb with node.js

Use a database collection by
const productcollection = database.collection('product');
Then, use app.delete() function by below system

app.delete('/product/:id', async(req, res)=>{
const id = req.params.id;
const getId = {_id: ObjectId(id)};
const deleteId = await productcollection.deleteOne(getId);
res.json(deleteId);
})

Prop Types

sujon554 — Wed, 09 Feb 2022 05:23:54 +0000

Before the release of React 15.5.0 version prop-Types is available in the react package but in later versions of React have to add a dependency in your project. You can add the dependency in your project by using the command given below:

npm install prop-types --save

Import Elements

  import PropTypes from 'prop-types'

SO we get a something Different type of Prop-Types below:

Basic types

PropTypes.any: The prop can be of any data type
PropTypes.bool: The prop should be a Boolean
PropTypes.number: The prop should be a number
PropTypes.string: The prop should be a string
PropTypes.func: The prop should be a function
PropTypes.array: The prop should be an array
PropTypes.object: The prop should be an object
PropTypes.symbol: The prop should be a symbol

and Here we can example
Component.propTypes = { anyProp: PropTypes.any, booleanProp: PropTypes.bool, numberProp: PropTypes.number, stringProp: PropTypes.string, functionProp: PropTypes.func }

Renderable types

PropTypes also exports the following validators for ensuring that the value passed to a prop can be rendered by React.
Component.propTypes = { nodeProp: PropTypes.node, elementProp: PropTypes.element }

Instance types

In cases where you require a prop to be an instance of a particular JavaScript class, you can use the PropTypes.instanceOf validator. This leverages the underlying JavaScript instanceof operator.

Component.propTypes = { personProp: PropTypes.instanceOf(Person) }

Multiple types

PropTypes also exports validators that can allow a limited set of values or multiple sets of data types for a prop. Here they are:

PropTypes.oneOf: The prop is limited to a specified set of values, treating it like an enum
PropTypes.oneOfType: The prop should be one of a specified set of types, behaving like a union of types

Component.propTypes = { enumProp: PropTypes.oneOf([true, false, 0, 'Unknown']), unionProp: PropTypes.oneOfType([ PropType.bool, PropType.number, PropType.string, PropType.instanceOf(Person) ]) }

`*and here also *