DEV Community: Dhiman_aman

API - Creating a Api in NodeJS with Prisma ORM & MongoDB

Dhiman_aman — Sat, 07 Sep 2024 05:59:51 +0000

To create an example API in Node.js with MongoDB using Prisma ORM, you'll first need to set up a Node.js project and configure Prisma to use MongoDB. Below is a step-by-step guide to create a basic API.

Step 1: Set Up Your Project

Initialize a Node.js Project:

   mkdir prisma-mongodb-example
   cd prisma-mongodb-example
   npm init -y

Install Required Packages: Install express for building the API, prisma for ORM, and @prisma/client for Prisma Client.

   npm install express prisma @prisma/client

Install Prisma CLI:

   npx prisma init

Step 2: Configure Prisma for MongoDB

Configure .env File: Update the .env file generated by Prisma to include your MongoDB connection string. For example:

   DATABASE_URL="mongodb://localhost:27017/mydatabase"

Set Prisma Schema to Use MongoDB: Update the prisma/schema.prisma file to use MongoDB as the provider and define a model. Here is an example schema:

   datasource db {
     provider = "mongodb"
     url      = env("DATABASE_URL")
   }

   generator client {
     provider = "prisma-client-js"
   }

   model User {
     id    String @id @default(auto()) @map("_id") @db.ObjectId
     name  String
     email String @unique
   }

Step 3: Generate Prisma Client

Run the following command to generate the Prisma Client based on the schema:

npx prisma generate

Step 4: Create a Basic Express API

Create an index.js File: This file will initialize the Express application and define the API routes.

   const express = require('express');
   const { PrismaClient } = require('@prisma/client');

   const prisma = new PrismaClient();
   const app = express();
   app.use(express.json());

   // Create a new user
   app.post('/users', async (req, res) => {
     const { name, email } = req.body;
     try {
       const user = await prisma.user.create({
         data: { name, email },
       });
       res.json(user);
     } catch (error) {
       res.status(400).json({ error: error.message });
     }
   });

   // Get all users
   app.get('/users', async (req, res) => {
     const users = await prisma.user.findMany();
     res.json(users);
   });

   // Get a single user by ID
   app.get('/users/:id', async (req, res) => {
     const { id } = req.params;
     try {
       const user = await prisma.user.findUnique({
         where: { id },
       });
       if (user) {
         res.json(user);
       } else {
         res.status(404).json({ error: 'User not found' });
       }
     } catch (error) {
       res.status(500).json({ error: error.message });
     }
   });

   // Update a user by ID
   app.put('/users/:id', async (req, res) => {
     const { id } = req.params;
     const { name, email } = req.body;
     try {
       const user = await prisma.user.update({
         where: { id },
         data: { name, email },
       });
       res.json(user);
     } catch (error) {
       res.status(400).json({ error: error.message });
     }
   });

   // Delete a user by ID
   app.delete('/users/:id', async (req, res) => {
     const { id } = req.params;
     try {
       await prisma.user.delete({
         where: { id },
       });
       res.json({ message: 'User deleted successfully' });
     } catch (error) {
       res.status(500).json({ error: error.message });
     }
   });

   const PORT = process.env.PORT || 3000;
   app.listen(PORT, () => {
     console.log(`Server is running on http://localhost:${PORT}`);
   });

Step 5: Run the Application

Run the Application:

   node index.js

Test the Endpoints: Use tools like Postman or cURL to test the CRUD operations for the User model.

Conclusion

This example demonstrates how to create a basic CRUD API in Node.js with MongoDB using Prisma ORM. You can expand this example by adding more models, relationships, and validation logic as needed for your application.

Migrate MongoDB to MySQL using Prism Key Differences

Dhiman_aman — Sat, 07 Sep 2024 05:56:41 +0000

The schema.prisma file defines the data models, relationships, and database connection details for Prisma. When using different databases like MongoDB and MySQL, the schema.prisma file will have differences due to the unique characteristics and data types of each database.

Key Differences Between `schema.prisma` for MongoDB and MySQL

1. Datasource Configuration

The datasource block specifies the database provider (mongodb or mysql) and connection details. The provider will change depending on the database you are using.

MongoDB Configuration:

  datasource db {
    provider = "mongodb"
    url      = env("DATABASE_URL")
  }

MySQL Configuration:

  datasource db {
    provider = "mysql"
    url      = env("DATABASE_URL")
  }

2. Data Model Differences

MongoDB and MySQL have different data types and ways of defining primary keys and relationships. Here are the primary differences:

Primary Key Definition:
- In MongoDB, the primary key is usually an ObjectId and is mapped using the @map("_id") directive.
- In MySQL, the primary key is typically an integer with auto-increment.
Data Type Differences:
- MongoDB supports data types like String, Int, Float, Boolean, DateTime, and custom types like Json and ObjectId.
- MySQL has a more structured type system, including Int, Float, Double, Boolean, DateTime, Decimal, and String.

Example of `schema.prisma` for MongoDB:

datasource db {
  provider = "mongodb"
  url      = env("DATABASE_URL")
}

generator client {
  provider = "prisma-client-js"
}

model User {
  id    String @id @default(auto()) @map("_id") @db.ObjectId
  name  String
  email String @unique
  posts Post[]
}

model Post {
  id        String   @id @default(auto()) @map("_id") @db.ObjectId
  title     String
  content   String
  published Boolean  @default(false)
  authorId  String   @db.ObjectId
  author    User?    @relation(fields: [authorId], references: [id])
}

Example of `schema.prisma` for MySQL:

datasource db {
  provider = "mysql"
  url      = env("DATABASE_URL")
}

generator client {
  provider = "prisma-client-js"
}

model User {
  id    Int    @id @default(autoincrement()) // Integer auto-increment primary key
  name  String
  email String @unique
  posts Post[]
}

model Post {
  id        Int     @id @default(autoincrement())
  title     String
  content   String
  published Boolean  @default(false)
  authorId  Int
  author    User     @relation(fields: [authorId], references: [id])
}

Summary of Differences

Feature	MongoDB (`schema.prisma`)	MySQL (`schema.prisma`)
Datasource Provider	`provider = "mongodb"`	`provider = "mysql"`
Primary Key Definition	`id String @id @default(auto()) @map("_id") @db.ObjectId`	`id Int @id @default(autoincrement())`
Data Types	Supports `String`, `Int`, `Float`, `Boolean`, `DateTime`, etc.	More structured, includes `Int`, `Float`, `Double`, etc.
Foreign Key Relationship	Foreign keys defined with `@db.ObjectId`	Foreign keys with `Int` or other standard SQL types
Autoincrement ID	Not applicable (`@default(auto())`)	`@default(autoincrement())`
Unique Identifier	`@unique` for unique fields	`@unique` for unique fields

Conclusion

The main differences in the schema.prisma file between MongoDB and MySQL revolve around how primary keys are handled, the differences in data types, and the way relationships and fields are mapped to the database. When switching from MongoDB to MySQL, these differences must be adjusted to accommodate the underlying database system's constraints and data modeling.

How to use the Zustand in ReactJS for State Management?

Dhiman_aman — Sat, 20 Jul 2024 14:36:58 +0000

A small, fast, and scalable bearbones state management solution. Zustand has a comfy API based on hooks. It isn't boilerplatey or opinionated, but has enough convention to be explicit and flux-like.

Installation

Install Zustand Library in your ReactJS Project.
Zustand is available as a package on NPM for use:

npm install zustand

1. Create a File store.js in src and paste below code


import create from 'zustand';
import { devtools, persist } from 'zustand/middleware';

const useApp = ((set) => ({
    count: 0,
    increment: () => set((state) => ({ count: state.count + 1 })),
    decrement: () => set((state) => ({ count: state.count - 1 })),
}));

const useAppStore = create(
    devtools(
        persist(useApp, {
            name: 'test'
        })
    )
)

export default useAppStore;

2. Import the useAppStore in App.js File

 const { count, increment, decrement } = useAppStore();

3. Create a two button for testing your increment and decrement

<h1>Count: {count}</h1>
                <button onClick={increment}>Increment</button>
                <button onClick={decrement}>Decrement</button>

Done.

Plese Vote and React on our posts.

Top SQL Server Interview Questions for 2024

Dhiman_aman — Sat, 20 Jul 2024 10:23:56 +0000

1. What is the Windows Authentication Mode in SQL Server?
This mode connects the server via a Windows account. The server uses the username and password for authentication. In this mode, SQL server authentication is disabled.

2. Give an example of a function in an SQL server that returns the first non-null expression from more than one column in arguments.
Select COALESCE(sid, sname, marks) from the student;

3. Explain the one-to-many relationship in the SQL Server database.
When a single column value in one table has a minimum of one dependent column value in some other table, a one-to-many relationship exists.

4. What is the significance of CHECK in SQL Server?
CHECK constraint limits the values that can be placed inside a table’s column. This maintains integrity. The constraint is used column-wise to give specific values to that column. Example: CONSTRAINT CHK_Student CHECK (age<20)

5.How to find the 3rd highest marks from the Student table?
SELECT TOP 3 marks FROM (SELECT DISTINCT TOP 3 marks FROM student ORDER BY marks DESC) a ORDER BY marks

6. What is a trigger?
When a table event occurs, such as INSERT, DELETE, or UPDATE, triggers allow executing an SQL code batch. Triggers are managed by DBMS and can also execute stored procedures. For example, when a record is inserted in a database table, a trigger can be set.

7. When can records be deleted from a view in SQL Server?
Records can be deleted in a ‘simple’ view as it contains data from one table only.

8. List down some of the features of MS SQL Server.
It provides an easy and straightforward Syntax.
MS SQL uses transact SQL.
Query optimization is not supported.
The transaction process does not allow rollbacks
Clustering is not supported
Statements are executed serially.

9. Which command can be used to get the version of SQL Server?
To get the version of SQL Server, use:

Select SERVERPROPERTY('productversion')

10. In SQL Server, what is a user defined function?
A user defined function allows users to write their logic as per need. The advantage is that it is not limited to pre-defined functions and writing functions, simply complex SQL code. The return type is a table or a scalar value.

Example:
Create function sample(@sid int) returns table as return select * from s where Id = @sid

11. Explain types of replication in SQL Server.
There are three types of replication as follows:

Transactional replication- It is a process of data distribution from publisher to subscriber. Transactional replication can be used when data is changed frequently.
Merge replication- It groups the data to a single centralized database from various sources. Merge replication is used in cases where central and branch databases need to update information simultaneously.
Snapshot replication- This replication is the best way to replicate data that changes infrequently, and it is easiest to maintain. Example: Snapshot replication can be used for lists that are updated once per day and needs to be distributed from main server to branch servers.

12. Define referential integrity.
Every foreign key value must have a corresponding primary key value. The maintenance of this consistency between foreign and primary keys is known as referential integrity.

13. What are TCL Commands? and List down the TCL Commands available on SQL Server?
TCL or Transactional Control Language commands are used to manage different transactions taking place in a database. The three TCL commands are as follows:

Rollback- This is used to restore the database to the last committed state
Save Tran- This saves the transaction, and the transaction can be rolled back to this point.
Commit- Saves the transaction permanently in the database.

14. Write a SQL Server Query to get the letter ‘e’ in the name ‘Jenna’ from the student table.

Select CHARINDEX('e',NAME,0) from student where name='Jenna'

15. As a SQL developer, how will you ensure that SQL server-based applications and databases perform well?
The volume of data, type of information stored, and data to be accessed must be checked. When a system is being upgraded, the present data should be analyzed, and the methods of accessing data should be checked to help understand problem design. Keeping the information about data is necessary when using a new system.

16. When should Server-based cursors be used?
When you require to work on one record at any instance of time, instead of taking all the data from the table as bulk. Cursors’ performance is affected when large volumes of data are present.

17. Tell us about the working of the FLOOR function.
FLOOR function rounds the given non-integer value to the previous least integer—for example, FLOOR(5.6) returns 5

18. What do you know about scheduled tasks in SQL Server?
Scheduled jobs or tasks automate processes that can be run at a prescribed time at a regular interval. By scheduling tasks, human intervention is reduced, and tasks can be carried out at any time in the order that the user wants.

19. Mention a query that returns the list of triggers in a database.
Select * from sys.objects where type='tr'

20. Differentiate between rollback and commit.
When COMMIT is executed, all statements between BEGIN and COMMIT become persistent to the database. Whereas, when ROLLBACK is executed, all statements between ROLLBACK and BEGIN are reverted to the state.

21. Explain how to create a table in SQL.
The following query is used to create a SQL table:

Create table name_of_table( column1 datatype, column2 datatype )

For example:
`create table Student

(

Name varchar(20),  

DOB date,  

Marks nvarchar(5),  

Subject varchar(20)   
)

22. What is the function of a foreign key in a database?
A foreign key is used to define a relationship between the parent and child table connected by columns. The foreign key is a constraint that ensures that the values of the child table appear in the parent table. The foreign key of one table is the primary key of the other, and a table can have several foreign keys. For example:

student {ID, Name, Age, Contact, Gender, Add}

24. Tell us the steps to hide SQL Server Instances.
To hide the SQL Server Instances, we need to make changes in SQL Server Configuration Manager, and to launch it, the following steps are needed:

Select instance of SQL server
Select properties after right-clicking
Set Hide Instances to Yes and click on APPLY
Post changes, restart the instance of SQL Server

25. Explain the DBCC command and its use.
Database Consistency Checker (DBCC) checks the consistency of the database; It helps in reviewing and monitoring the maintenance of database, tables, and operation validation. For example:

DBCC CHECKALLOC checks all pages in the database to ensure they are correctly allocated.
DBCC CHECKDB makes sure that indexes are correctly linked in the tables of the database.
DBCC CHECKFILEGROUP checks all file groups for damage.

26. Describe the SIGN function.
The SIGN function is used to specify a number as positive, zero, or negative. It returns the following: SIGN (number)

Returns – 1 if number <0, +1 if number>0 and 0 if number=0

27.Define alternate key.
When a table has more than one candidate key (i.e., candidate for primary keys), one becomes the primary key, and the rest are the alternate keys.

28. Define Join. What are the different types of joins?
Joins are used in SQL queries to describe how different tables are related. They also allow users to select data from one table depending on the data of the other table. The different types of joins are:

INNER Joins
OUTER Joins- LEFT OUTER, RIGHT OUTER, FULL OUTER
CROSS Joins

29. Tell about the use of UPDATE STATISTICS.
UPDATE STATISTICS is used to update information about the distribution of the key values for one or more statistic groups/collections in the indexed view or specified table.

30. Define Full backup.
The most common type of backup in SQL server is the complete backup of the database. It also includes part of the transaction logs for recovery.

31. In SQL, what is meant by the identity column?
In SQL, an identity column generates numeric values automatically. These columns need not be indexed, and we can define the start and increment value of the identity column.

32. Explain the UNIQUE KEY constraint.
The UNIQUE constraint maintains the uniqueness of records in the set of columns to ensure there are no duplicate values. This constraint enforces entity integrity.

33. Define the process of de-normalization.
The process of de-normalization adds redundant data to a database in order to enhance the performance. This technique moved from higher to lower normal forms of the database. This speeds up the database access.

34. Show how table type constraint can be applied to a table.
Alter Table Name_of_the_Constraint

Alter Table Constraint_1

35. Differentiate between derived persistent attribute and derived attribute.
A derived attribute is obtained from values of other existing columns as its values do not exist on their own. A derived attribute that can be stored is a derived persistent attribute. teacher{Teach_ID, Name, ID}

Here, ID is the foreign key for the teacher table.

Top 30 MongoDB Interview Questions and Answers

Dhiman_aman — Sat, 20 Jul 2024 09:52:57 +0000

MongoDB Interview Questions and Answers: An Overview MongoDB is a document-oriented database. MongoDB is a powerful, scalable, and much more flexible database that provides high performance in case of a large volume of data and also leads to a NoSQL Database. MongoDB stores the data in a BSON (Binary JavaScript Object Notation) format.

1. What is MongoDB?
Mongo-DB is a document database with high performance, high availability, and easy scalability. It is an open-source NoSQL database written in C++ language.

2. What is NoSQL Database?

NoSQL stands for Not Only SQL. NoSQL is a category of Database Management System (DBMS) that maintains all the rules of traditional RDBMS systems. It also does not use the conventional SQL syntaxes to fetch the data from the database. This type of database system is typically used in case of a very large volume of data. Some of the well-known NoSQL database systems are – Cassandra, BigTable, DynamoDB, MongoDB, etc.

3. What are the types of NoSQL databases?
There are four types of NoSQL Database available:

Document Database
This type of NoSQL database is always based on a Document-Oriented approach to store data. The main objective of the Document Database is to store all data of a single entity as a document and all documents can be stored as Collections. Some examples of Document Database – are MongoDB, CosmosDB, CouchDB, PostgreSQL, etc.

Key-Value Database
This type of database stores data in a schema-less way since key-value storage is the simplest way of storing data. A key can be a point to any type of data, like an object, string, or any other type of data. The main advantages of these databases are easy to implement and add data into. Example – Redis, DynamoDB, etc.

Column Store Database
These types of databases store data in columns within a keyspace. The key space is always defined by a unique name, value, and timestamp. Example – Cassandra, BigTable, HBase, Vertica, HyperTable.

Graph Store Database
These types of databases are mainly designed for data that can be easily represented as graph data. This means that data are interconnected with an undetermined number of data relations between them like family and social relations etc. Example – AllegroDB, GraphDB, OrientDB, Titan.

4. What are the advantages of MongoDB?
The main advantages of MongoDB are:

It can deal with a high volume of data.
It supports cross-platform
It provides High Performance
It is easily scalable
It does not require any complex joins to retrieve data
It supports both types of scaling – Horizontal & Vertical
It is available on any cloud-based environment like Azure, AWS, etc

5. What are Documents?
The document is the heart of MongoDB. In simple words, the document is an ordered set of keys with associated values. It is similar to the table rows in the RDBMS systems. It always maintains a dynamic scheme so that it does not require any predefined structure or fields.

6. What is Collection?
A collection in MongoDB is a group of documents. If a document is the MongoDB analog of a row in an RDBMS, then a collection can be thought of as the analog to a table.
Documents within a single collection can have any number of different “shapes.”, i.e. collections have dynamic schemas.
Syntax
db.createCollection(name,options)

7. What are Dynamic Schemas?
In MongoDB, Collections always have dynamic Schemas. Dynamic Schemas means the documents within a single collection may contain different types of structure or shapes. For example, both the below documents can be stored in a single collection:
{"message" : "Hello World"} {"id" : 10, "description" : "India"}

8. What is Mongo Shell?
MongoDB Shell is a JavaScript shell that allows us to interact with MongoDB instances using the command line. It is very useful to perform any administrative work along with any other data operations-related commands. Mongo Shell is automatically installed when we install MongoDB on our computers.

9. List out some features of MongoDB.
Indexing: It supports generic secondary indexes and provides unique, compound, geospatial, and full-text indexing capabilities as well.

Aggregation: It provides an aggregation framework based on the concept of data processing pipelines.

Special collection and index types: It supports time-to-live (TTL) collections for data that should expire at a certain time

File storage: It supports an easy-to-use protocol for storing large files and file metadata.

Sharding: Sharding is the process of splitting data up across machines.

10. Where can we use MongoDB?
MongoDB can be used in the following areas:

Content Management System
Mobile Apps where data volume is very large and requires high readability of data.
Data Management
Big Data

11. Which languages does MongoDB support?
Several languages are supported by MongoDB like

C++
C
C#
Java
Node.Js
Perl
PHP etc.

12. What data types are supported by MongoDB?
MongoDB supports a wide range of data types in documents. Below are the available data types in the MongoDB.
Data Types Descriptions

String It is the most commonly used data type. A string must be UTF-8 valid in MongoDB
Integer It is used to store numeric values. It may be either 32-bit or 64-bit.
Boolean It is used to store Boolean data types. It's valued either true or false.
Double It is used to store floating point values.
Arrays This data type is used to store a list or multiple values in a single key
Objects This data type is used to store embedded data
Null It is used to store null data.
Date This data type is used to store the current date or time value in Unix time format.

13. What is ObjectId in MongoDB?
Each document stored in MongoDB must contain an “_id” key. The default value type of the “_id” is ObjectId. In a single collection, every document always contains a unique value of the “_id” field, so that every document can be identified easily. ObjectId always uses 12 bytes of storage. It always represents 24 hexadecimal digit string values.
Objectld is composed of:
Timestamp
Client machine ID
Client process ID
3-byte incremented counter

14. How to add data in MongoDB??
The basic method for adding data to MongoDB is “inserts”. To insert a single document, use the collection’s insertOne method:

db.books.insertOne({"title" : "ScholarHat"})

For inserting multiple documents into a collection, use the method insertMany. This method enables passing an array of documents to the database.

15. What is Capped Collection in MongoDB?
In MongoDB, Capped collections are fixed-size collections, and insert and retrieve data based on the insertion order. If a collection’s space is full, the oldest records will be overwritten by the new documents in the collection. So, to create a capped collection, the command will be –

db.createCollection(“CollectionName”, {“capped”:true, “size” : 100000})

16. What is the Full-Text Index?
Full-text indexing is a search engine feature that enables you to perform text searches on a collection of documents within a database. Unlike traditional databases that search through text using the ‘LIKE’ query pattern match, full-text search engines tokenize the text in documents and build an index to allow very fast text search capabilities.

Full-Text Index is one of the special types of Index in MongoDB for searching text within the documents. However, this type of indexing is expensive for use concerns. So, creating a full-text index on a busy collection can overload the MongoDB Server. So it is always recommended to use this type of index in an offline mode. To create a full-text index, the command is –

db.<CollectionName>.ensureIndex({“name” : “text”})

17. What is GridFS?
Since in MongoDB, every document size limit is 16 MB. So, if we want to insert any large binary data file, we need to use GridFS. GridFS is a mechanism through which we can store any type of large file data like an audio file, video file image, etc. It is just like a file system to store these large files and also, its related data stored in the MongoDB collection.

18. What is the purpose of using $group?
$group syntax is used to bundle or group the documents of a collection based on one or more fields. So, if we want to group the data that depends on one or more than one field, we need to pass those fields' name within the group method to create a group key and normally the group key name is “_id”.

{"$group" : {"_id" : {"state" : "$state", "city" : "$city"}}}

We can use any type of arithmetic operator with the group command as below –
db.sales.aggregate( { "$group" : { "_id" : "$country", "totalRevenue" : {"$average" : "$revenue"}, "numSales" : {"$sum" : 1} } })

19. What is Replication?
Replication is the process that is responsible for keeping identical copies of our data in multiple servers and is always a recommended process for any type of production server. Replication always keeps our database safe even if the database server crashes or data is corrupted. With the additional copies, MongoDB maintains the copy of the data for disaster recovery, reporting, or backup purposes.

20. Why Replication is required in MongoDB?
In MongoDB, replication is required for the following reasons –
To provide always the availability of data
To secure our application data
Recover the data from any type of disaster recovery
In the Replication process, no downtime requires maintenance like backup, index rebuilds, etc.
Replication can provide us with a read scaling means it will provide us with a copy of data only for real purposes.

21. Explain the replica set.
It is a group of Mongo instances that maintains the same dataset. Replica sets provide redundancy and high availability and are the basis for all production deployments.

22. What is the use of the map-reduce command?
Map-reduce is a way to perform aggregation.
The Map function emits the key-value pair specified.
The Reduce function combines the key-value pair and returns the aggregation result.
Syntax
db.collection.mapReduce( function() { emit(key,value); }, function(key, values) {return aggregatedResult}, { out: collection })

23. How to delete a Document in MongoDB?
The CRUD API in MongoDB provides deleteOne and deleteMany for this purpose. Both these methods take a filter document as their first parameter. The filter specifies a set of criteria to match against in removing documents.
Example
db.list.deleteOne({"_id" : 9})

24. Describe the process of Sharding.
Sharding is the process of splitting data up across machines. In other words, it is called “partitioning”. We can store more data and handle more load without requiring larger or more powerful machines, by putting a subset of data on each machine.

In the given figure, RS0 and RS1 are shards. MongoDB’s sharding allows you to create a cluster of many machines (shards) and break up a collection across them, putting a subset of data on each shard. This allows your application to grow beyond the resource limits of a standalone server or replica set.

25. What is the use of the pretty() method?
The pretty() method is used to show the results in a formatted way.
Example
Open your Mongo shell and create one collection with a few documents like the below:
db.list.insertMany([ {_id : 1,name : "ScholarHat",age : 2,"employees" : { "JK" : 1, "SD" : 2 }}, {_id : 2,name : "DotNetTricks",age : 10,"employees" : { "SK" : 3, "PC" : 4 }} ])

db.list.find()

It will insert these two documents into the collection list. Now, call db.list.find() to print out all documents in it.

Output :{ "acknowledged" : true, "insertedIds" : [ 1, 2 ] }

`{ "_id" : 1, "name" : "ScholarHat", "age" : 2, "employees" : { "JK" : 1, "SD" : 2 } }

{ "_id" : 2, "name" : "DotNetTricks", "age" : 10, "employees" : { "SK" : 3, "PC" : 4 } }`

If the data size is too big, it becomes difficult to read. If you call the pretty() method, the result will be like this:

Output : { "acknowledged" : true, "insertedIds" : [ 1, 2 ] }

{ "_id" : 1, "name" : "ScholarHat", "age" : 2, "employees" : { "JK" : 1, "SD" : 2 } } { "_id" : 2, "name" : "DotNetTricks", "age" : 10, "employees" : { "SK" : 3, "PC" : 4 } }

26. Explain the Replication Architecture in MongoDB.
In the above diagram, the PRIMARY database is the only active replica set member that receives write operations from database clients. The PRIMARY database saves data changes in the Oplog. Changes saved in the Oplog are sequential—i.e., saved in the order that they are received and executed.

The SECONDARY database is querying the PRIMARY database for new changes in the Oplog. If there are any changes, then Oplog entries are copied from PRIMARY to SECONDARY as soon as they are created on the PRIMARY node.

Then, the SECONDARY database applies changes from the Oplog to its data files. Oplog entries are applied in the same order they were inserted in the log. As a result, data files on SECONDARY are kept in sync with changes on PRIMARY.

Usually, SECONDARY databases copy data changes directly from PRIMARY. Sometimes a SECONDARY database can replicate data from another SECONDARY. This type of replication is called Chained Replication because it is a two-step replication process.

27. What is Aggregation in MongoDB?
In MongoDB, aggregations are operations that process data records and return computed results. There are three ways to perform aggregation in MongoDB:
Aggregation pipeline
Map-reduce function
Single-purpose aggregation methods

28. Differentiate MongoDB and RDBMS Parameters
RDBMS MongoDB
Definition :
It is a relational database management system. It is a non-relational database management system Working
Works on relationships between tables that use rows and columns A document-oriented system using documents and fields Hierarchical Data Storage Difficult to store hierarchical data In-built provision for storing hierarchical data Scalability
Vertically scalable
Vertically and horizontally scalable
Performance
Performance increases with an increase in RAM capacity
Performance increases with an increase in processors
Schema
Schema has to be pre-decided and designed; changes to the schema are difficult Dynamic creation and management of schema making the design flexible Support for Joins
Supports complex joins No support for joins
Query Language
Uses SQL for querying the database BSON is used for database querying Support for JavaScript
No support for JavaScript-based clients to query the database Provision for Javascript-based clients to query the database

29. Is it possible to run multiple Javascript operations in a MongoDB instance?
Yes, we can run multiple JS operations in a MongoDB instance. Through the Mongo shell instance, we can specify the name of the JavaScript file to be run on the server. The file can contain any number of JS operations.

30. Explain the Storage Engine in MongoDB.
The storage engine is a component of the database that manages how data is stored in both memory and disk. MongoDB provides support for multiple storage engines that help in better performance for different workloads. The default storage engine is WiredTiger (MongoDB3.2), which is well-suited for most workloads.

How to Send push notification in Mobile Using NodeJS with Firebase Service ?

Dhiman_aman — Mon, 08 Jul 2024 10:40:32 +0000

To implement push notifications using Firebase Cloud Messaging (FCM) in a Node.js application, you need to handle FCM token storage and manage token updates for each user. Here's a step-by-step guide:

1. Set Up Firebase in Your Node.js Project

First, you need to set up Firebase in your Node.js project.

i. Install Firebase Admin SDK:

   npm install firebase-admin

ii. Initialize Firebase in your Node.js app:

   const admin = require('firebase-admin');
   const serviceAccount = require('path/to/your/serviceAccountKey.json');

   admin.initializeApp({
     credential: admin.credential.cert(serviceAccount),
   });

2. Save FCM Token for Each User

You need a database to store the FCM tokens. For this example, we'll use MongoDB.

i. Install Mongoose:

   npm install mongoose

ii. Set Up Mongoose and Define User Schema:

   const mongoose = require('mongoose');

   mongoose.connect('mongodb://localhost/your-database', {
     useNewUrlParser: true,
     useUnifiedTopology: true,
   });

   const userSchema = new mongoose.Schema({
     userId: { type: String, required: true, unique: true },
     fcmToken: { type: String, required: true },
   });

   const User = mongoose.model('User', userSchema);

iii. API to Save/Update FCM Token:

   const express = require('express');
   const app = express();

   app.use(express.json());

   app.post('/save-token', async (req, res) => {
     const { userId, fcmToken } = req.body;

     try {
       let user = await User.findOne({ userId });
       if (user) {
         user.fcmToken = fcmToken;
         await user.save();
       } else {
         user = new User({ userId, fcmToken });
         await user.save();
       }
       res.status(200).send('Token saved/updated successfully.');
     } catch (error) {
       res.status(500).send('Internal Server Error');
     }
   });

   const PORT = process.env.PORT || 3000;
   app.listen(PORT, () => {
     console.log(`Server running on port ${PORT}`);
   });

3. Send Notifications

i. Function to Send Notification:

   const sendNotification = async (userId, message) => {
     try {
       const user = await User.findOne({ userId });
       if (!user) {
         throw new Error('User not found');
       }

       const payload = {
         notification: {
           title: message.title,
           body: message.body,
         },
         token: user.fcmToken,
       };

       const response = await admin.messaging().send(payload);
       console.log('Successfully sent message:', response);
     } catch (error) {
       console.error('Error sending message:', error);
     }
   };

ii. API to Trigger Notification:

   app.post('/send-notification', async (req, res) => {
     const { userId, message } = req.body;

     try {
       await sendNotification(userId, message);
       res.status(200).send('Notification sent successfully.');
     } catch (error) {
       res.status(500).send('Internal Server Error');
     }
   });

Summary

Set up Firebase and MongoDB.
Create endpoints to save/update FCM tokens.
Create a function and endpoint to send notifications.

Testing

Save/Update Token:

  curl -X POST http://localhost:3000/save-token -H "Content-Type: application/json" -d '{"userId": "user123", "fcmToken": "your-fcm-token"}'

Send Notification:

  curl -X POST http://localhost:3000/send-notification -H "Content-Type: application/json" -d '{"userId": "user123", "message": {"title": "Hello", "body": "World"}}'

Make sure you replace "path/to/your/serviceAccountKey.json" with the actual path to your Firebase service account key JSON file. Also, ensure your MongoDB instance is running and replace the connection string with your actual MongoDB connection string.

Deploy MERN website on VPS Hostinger

Dhiman_aman — Sat, 10 Feb 2024 19:09:24 +0000

Deploying a MERN (MongoDB, Express.js, React.js, Node.js) stack on a VPS (Virtual Private Server) like Hostinger involves several steps. Here's a general guide to help you get started:

Set up your VPS:
- Log in to your Hostinger account and access your VPS dashboard.
- Create a new VPS instance if you haven't already.
- Note down your VPS IP address and SSH credentials.
Connect to your VPS via SSH:
- Use an SSH client like PuTTY (Windows) or Terminal (Mac/Linux) to connect to your VPS using the provided SSH credentials.
Install necessary software:
- Update your package list: sudo apt update
- Install Node.js and npm: Follow Node.js installation instructions for your Linux distribution.
- Install MongoDB: You can follow the official MongoDB installation guide for your Linux distribution.
- Install a web server like Nginx to serve your React frontend.
Set up your MongoDB database:
- Configure MongoDB to run as a service.
- Secure your MongoDB installation by setting up authentication and firewall rules.
Clone your MERN project:
- Use Git to clone your MERN project repository onto your VPS.
Install dependencies and build your React app:
- Navigate to your project directory.
- Install backend dependencies: npm install
- Navigate to the client directory (where your React app resides) and install frontend dependencies: npm install
- Build your React app: npm run build
Configure Express.js server:
- Ensure your Express.js server is configured to serve the built React app from the build directory.
Start your MERN stack:
- Start your Express.js server: npm start or using a process manager like PM2 for better process handling.
- Start your MongoDB service if it's not already running.
Configure Nginx:
- Set up Nginx as a reverse proxy to forward requests to your Express.js server.
- Create a new server block in your Nginx configuration file and configure it to point to your Express.js server.
Secure your server:
- Configure firewall rules to only allow necessary incoming connections.
- Set up HTTPS using Let's Encrypt SSL certificates for secure communication.
- Harden your server by following security best practices.
Monitor and maintain your server:
- Set up monitoring tools to track server performance and uptime.
- Regularly update your server's software and dependencies to patch security vulnerabilities.
- Back up your data regularly to prevent data loss.

Steps Summary to check the deployment

mkdir <project folder name>
cd <project folder>
git clone <repo url>
npm install
npm run build
pm2 serve build/ 3000 --name "react-build" --spa
pm2 status
sudo ufw allow 3000
sudo ufw status

for reactjs files
pm2 serve build/ 3000 --name "react-build" --spa

for static file like html (inside the folder)
pm2 serve --spa

Remember to adapt these steps according to your specific project requirements and the configurations of your VPS provider. Additionally, it's essential to ensure the security and performance of your deployed application by implementing best practices and regularly monitoring your server.

JSON maping in ReactJS

Dhiman_aman — Sat, 21 Jan 2023 19:20:29 +0000

Create a JSON file with .js extension

Data.js

const JSONdata = [
  {
    id: 1,
    quote: "Life isn’t about getting and having, it’s about giving and being.",
    author: "Kevin Kruse",
  },
 {
    id: 2,
    quote: "Whatever the mind of man can conceive and believe, it can achieve.",
    author: "Napoleon Hill",
  },
]

App.js

import React from "react";
import JSONdata from "../Data";

const Home = () => {
  return (
    <>
      {JSONdata.map((dataForMap) => {
        return (
          <>
            <center>
              <h1>------------------</h1>
              <p>{dataForMap.id}</p>
              <p>{dataForMap.quote}</p>
              <h4>{dataForMap.author}</h4>
            </center>
          </>
        );
      })}
    </>
  );
};

export default Home;

Finally Done !!!

Use Live Time/Date in the ReactJS

Dhiman_aman — Sat, 21 Jan 2023 07:37:05 +0000

make the object of the Date() Method

const date = new Date();

use effect to display the live time

useEffect(() => { setInterval(() => { setDateState(new Date()); }, 1000); }, []);

give the some parameters in the return value {dateState.toLocaleString("en-US", { hour: "numeric", minute: "numeric", second: "2-digit", hour12: true, })}
Complete Code of Time/Date

import React from "react";
import { useState, useEffect } from "react";

const ClockAPI = () => {
  const [dateState, setDateState] = useState(new Date());

  const t = new Date();
  const c = t.getHours() - 12;
  useEffect(() => {
    setInterval(() => {
      setDateState(new Date());
    }, 1000);
  }, []);

  return (
    <>
      <h1 className="mb-4 text-6xl font-extrabold tracking-tight leading-none  text-white-900 md:text-5xl lg:text-6xl dark:text-white">
        {dateState.toLocaleString("en-US", {
          hour: "numeric",
          minute: "numeric",
          second: "2-digit",
          hour12: true,
        })}
      </h1> 

    </>
  );
};

export default ClockAPI;

Step the MongoDB compass for ReactJS

Dhiman_aman — Wed, 18 Jan 2023 16:30:30 +0000

Open the Compass Exe
Make a New Connection ( copy the URL for local host )
Create a Database
Like -> e-comm

Create a Collection ( or in RDBMS called Table )

products and users is the collectiions

Add the Data

in insert document 📃 Add some demo data

Finally Done

How to install MongoDB in Window ?

Dhiman_aman — Wed, 18 Jan 2023 16:21:13 +0000

Follow this link
MongoDB Community
Download the .msi version in MongoDB
Step the Config files 📂

How to Create a Dynamic Routing using the Params() in ReactJS?

Dhiman_aman — Fri, 13 Jan 2023 18:38:39 +0000

Use React Router Dom @6 Version to Route the Pages

Create One Page as Coin and use page in APP.js

import { Routes, Route } from "react-router-dom";
import "./App.css";
import Home from "../src/Page/Home";
import User from "./Component/User";
import About from "./Page/About";
import Navbar from "./Component/Navbar";
import Coin from "../src/Page/Coin";

function App() {
  return (
    <>
      <Navbar />
      <Routes>
        <Route path="/" element={<Home />} exact />
        <Route path="/coin/:d" element={<Coin />}  />
        <Route path="/about" element={<About />}  />
        <Route path="/user/:id" element={<User />} />
      </Routes>
    </>
  );
}

export default App;

In the Coin Page

import React, { useEffect, useState } from "react";
import { Link, useParams } from "react-router-dom";
import Loading from "../Component/Loading";

const Coin = () => {
  const paramsData = useParams();
  const { d } = paramsData;
  const [u, sUser] = useState([]);
  const [check, setCheck] = useState(true);
  useEffect(() => {
    fetch(`https://jsonplaceholder.typicode.com/users/${d}`)
      .then((res) => res.json())
      .then((data) => {
        sUser(data);
        //console.log(data);
        setCheck(false);
      });
  }, []);
  return (
    <>
      <center>
        {check ? (
          <Loading />
        ) : (
          <>
            <p>
              <b>Name:</b> {u.name}
            </p>
            <p>
              <b>User Name:</b> {u.username}
            </p>
            <p>
              <b>Email: </b>
              {u.email}
            </p>
            <p>
              <b>Website:</b> {u.website}
            </p>
            <Link to="/">Go the Home</Link>
          </>
        )}
      </center>
    </>
  );
};

export default Coin;

DEV Community: Dhiman_aman

API - Creating a Api in NodeJS with Prisma ORM & MongoDB

Step 1: Set Up Your Project

Step 2: Configure Prisma for MongoDB

Step 3: Generate Prisma Client

Step 4: Create a Basic Express API

Step 5: Run the Application

Conclusion

Migrate MongoDB to MySQL using Prism Key Differences

Key Differences Between schema.prisma for MongoDB and MySQL

1. Datasource Configuration

2. Data Model Differences

Example of schema.prisma for MongoDB:

Example of schema.prisma for MySQL:

Summary of Differences

Conclusion

How to use the Zustand in ReactJS for State Management?

Installation

Done.

Top SQL Server Interview Questions for 2024

Top 30 MongoDB Interview Questions and Answers

How to Send push notification in Mobile Using NodeJS with Firebase Service ?

1. Set Up Firebase in Your Node.js Project

2. Save FCM Token for Each User

3. Send Notifications

Summary

Testing

Deploy MERN website on VPS Hostinger

JSON maping in ReactJS

Data.js

App.js

Finally Done !!!

Use Live Time/Date in the ReactJS

Step the MongoDB compass for ReactJS

How to install MongoDB in Window ?

How to Create a Dynamic Routing using the Params() in ReactJS?

Use React Router Dom @6 Version to Route the Pages

Create One Page as Coin and use page in APP.js

In the Coin Page

Key Differences Between `schema.prisma` for MongoDB and MySQL

Example of `schema.prisma` for MongoDB:

Example of `schema.prisma` for MySQL: