Node.js and MongoDB Interview Guide

What is Node.js?

Node.js is an open-source, cross-platform JavaScript runtime environment built on Chrome's V8 engine. It enables developers to execute JavaScript on the server side, allowing for the creation of scalable network applications. Node.js is known for its non-blocking, event-driven architecture, which allows it to handle multiple operations concurrently without waiting for any single operation to complete. This makes it highly efficient for I/O-bound tasks and real-time applications.

Is Node.js Single-Threaded?

Yes, Node.js operates on a single thread for executing JavaScript code. However, it uses a non-blocking, event-driven model to handle concurrent operations. This means that while JavaScript code executes on a single thread, Node.js can handle multiple I/O operations simultaneously by delegating them to the system's kernel or worker threads, and then processing the results asynchronously. This model enhances scalability and performance, especially for applications with high concurrency.

Architecture of Node.js

Node.js is designed around a single-threaded event loop. The key components of its architecture include:

• Event Loop: Manages asynchronous operations and executes callbacks. It allows Node.js to perform non-blocking I/O operations.
• Event Queue: Holds events that need to be processed by the event loop. Each event has an associated callback function.
• Worker Threads: Handle tasks such as I/O operations in parallel. They perform work that is offloaded by the event loop.
• Call Stack: Keeps track of function calls and execution context. It is used for managing the execution flow of JavaScript code.

Core Modules of Node.js

Node.js provides several built-in modules that enhance its functionality:

• http: For creating and handling HTTP requests and responses. It is fundamental for building web servers and APIs.
• fs: For file system operations, such as reading and writing files. It supports both synchronous and asynchronous methods.
• path: For handling and manipulating file paths. It provides utilities to work with file and directory paths.
• events: Provides the EventEmitter class for event-driven programming. It allows objects to emit and listen to events.
• stream: Handles streaming data, allowing for processing of large datasets in chunks. It supports readable, writable, duplex, and transform streams.

Authentication vs Authorization

• Authentication: The process of verifying the identity of a user. It involves checking credentials such as usernames and passwords to confirm that the user is who they claim to be. For example, on Amazon.in, users log in with their credentials, and their identity is verified before granting access.
• Authorization: Determines what actions an authenticated user is permitted to perform. It defines user roles and permissions, controlling access to resources and functionalities. For instance, after logging in, authorization controls what data or actions a user can access, such as managing their own account details or viewing orders.

Authentication Token (JWT)

JWT (JSON Web Token) is a compact, URL-safe token used for securely transmitting information between parties. It consists of three parts:

• Header: Contains metadata about the token, including the type of token and the signing algorithm used.
• Payload: Contains the claims or data being transmitted. It can include user information and other data.
• Signature: Ensures the token's integrity by verifying that it has not been tampered with. It is created by encoding the header and payload with a secret key.

JWTs are commonly used for stateless authentication, where the server does not need to store session information. They are passed between the client and server and can be easily verified without server-side storage.

What is CORS?

CORS (Cross-Origin Resource Sharing) is a mechanism that allows web servers to control which domains are permitted to access their resources. It is implemented through HTTP headers, such as Access-Control-Allow-Origin, which specify allowed origins for cross-origin requests. CORS helps protect servers from unwanted cross-origin requests while enabling legitimate cross-origin interactions. It is crucial for web applications that interact with APIs hosted on different domains.

Why Use MongoDB Over MySQL?

• Performance: MongoDB can handle high write loads more efficiently than MySQL due to its design. It excels in scenarios with high insert/update operations, such as real-time analytics.
• Flexibility: MongoDB uses a schema-less data model, allowing for a more flexible structure compared to MySQL's rigid schema. This makes it ideal for applications with evolving or unstructured data, such as content management systems.
• Scalability: MongoDB supports horizontal scaling through sharding, making it suitable for applications that need to scale out across multiple servers. This is beneficial for large-scale applications with high traffic and large datasets.

What is MongoDB?

MongoDB is a NoSQL, document-oriented database that stores data in BSON (Binary JSON) format. Unlike relational databases, MongoDB does not require a predefined schema and can handle complex, hierarchical data structures efficiently. It is designed to manage large volumes of unstructured or semi-structured data, making it suitable for modern applications that need to handle diverse and evolving data.

What is MVC Architecture?

MVC (Model-View-Controller) is a design pattern used to separate an application into three interconnected components:

• Model: Manages the application's data and business logic. It interacts with the database and performs operations like data retrieval and manipulation. It represents the data structure and rules.
• View: Handles the presentation layer. It renders data to the user and updates the user interface based on changes in the model. It represents the user interface elements and layout.
• Controller: Acts as an intermediary between the model and view. It processes user input, updates the model, and refreshes the view. It handles user interactions and application logic.

Why Use ODM Like Mongoose in ExpressJS for Building APIs?

Mongoose is an ODM (Object Data Mapping) library that provides several advantages:

• Schema Definition: Allows defining schemas for MongoDB collections, which helps in validating and structuring data. It enforces a structure and validation rules for documents.
• Model Relationships: Facilitates the creation of relationships between different data models, such as users and orders. It supports features like population of related documents.
• Data Validation: Supports custom validation rules for fields in the schema. It ensures data integrity and consistency.
• Query Building: Provides a rich set of methods for querying and manipulating data. It simplifies complex queries and supports various query operations.

At What Scenarios Do We Prefer to Use Node.js?

• Real-Time Applications: Ideal for applications that require real-time data processing, such as chat applications, live notifications, or collaborative tools.
• API Development: Efficient for building RESTful APIs due to its non-blocking architecture and lightweight nature. It is suitable for microservices and serverless functions.
• Microservices: Suitable for microservices architectures where each service can be developed, deployed, and scaled independently. Node.js's modularity and efficiency make it a good fit for this approach.

At What Scenarios Do We Prefer to Use MongoDB Over Any Other RDBMS?

• Unstructured Data: When dealing with data that does not fit well into a rigid schema, such as user-generated content or hierarchical data.
• High Write Throughput: For applications with high volumes of data insertions or updates, such as logging systems or real-time analytics.
• Scalability: When horizontal scaling is needed to handle large datasets or high traffic. MongoDB's sharding and replication features support scalable architectures.

What are the Pros and Cons of Node.js?

• Pros:
  • Efficiency: Non-blocking I/O model enhances performance for I/O-bound tasks and improves scalability.
  • Unified Language: Allows using JavaScript for both client-side and server-side code, streamlining development.
  • Ecosystem: Large and active ecosystem with a vast number of packages available via npm, facilitating rapid development.
• Cons:
  • Single-Threaded Limitations: May not be suitable for CPU-intensive tasks due to its single-threaded nature, which can impact performance for compute-heavy operations.
  • Callback Hell: Asynchronous code can lead to deeply nested callbacks, though promises and async/await help mitigate this issue.
  • Maturity: Compared to some traditional server-side technologies, Node.js is relatively newer and may have less mature tooling or community support for certain use cases.

Event-Driven Programming

Event-driven programming is a paradigm where code execution is driven by events such as user interactions, messages, or data changes. Event handlers or listeners are registered to respond to these events, enabling dynamic and responsive applications. This approach allows applications to react to events asynchronously and manage tasks based on their occurrence.

Event Loop in Node.js

The event loop is a core component of Node.js that processes asynchronous operations. It continuously monitors the event queue and executes callbacks when their associated events are completed. The event loop allows Node.js to handle multiple concurrent operations efficiently, without blocking the main thread. It ensures that non-blocking operations are processed in the background and their results are handled when ready.

What is EventEmitter in Node.js?

EventEmitter is a Node.js class that provides an implementation for event-driven programming. It allows objects to emit events and register listeners to handle these events. The EventEmitter class is used extensively in Node.js to manage and respond to asynchronous events, such as handling HTTP requests or responding to file system changes. It provides methods like emit, on, and once to manage event listeners and emit events.

What is the package.json File?

The package.json file is a manifest for Node.js projects. It includes:

• Metadata: Information about the project, such as name, version, description, and author.
• Dependencies: List of npm packages required for the project, specifying their versions and installation details.
• Scripts: Custom scripts for tasks like testing, building, or starting the application. It enables automation of common tasks.
• Configurations: Settings for project-related tools and libraries, such as Babel or ESLint configurations.

Streams in Node.js

Streams are objects that handle reading and writing data in chunks. They enable efficient processing of large datasets by processing data as it arrives rather than loading it all at once. Node.js supports various types of streams:

• Readable Streams: For reading data (e.g., file streams or HTTP request bodies). They emit data events as data is read.
• Writable Streams: For writing data (e.g., HTTP responses or file writes). They provide methods to write data and handle backpressure.
• Duplex Streams: For both reading and writing data (e.g., TCP connections). They allow simultaneous reading and writing.
• Transform Streams: For modifying data as it is read or written (e.g., compression or encryption). They transform data in a stream.

REPL in Node.js

REPL (Read-Eval-Print Loop) is an interactive command-line tool provided by Node.js. It allows you to execute JavaScript code in real-time, evaluate expressions, and test snippets of code. It is useful for debugging, experimenting with Node.js features, and quickly testing code snippets. The REPL provides an interactive environment for exploring Node.js capabilities and JavaScript syntax.

Middleware in Express.js

Middleware functions in Express.js are functions that execute during the request-response cycle. They can:

• Modify request and response objects, allowing for custom handling and processing of requests.
• End the request-response cycle, providing responses or terminating requests when appropriate.
• Call the next middleware function in the stack, enabling a chain of middleware functions to be executed in sequence. Middleware is used for tasks such as logging, authentication, error handling, and request parsing.

What is MongoDB, and How Does It Differ from Traditional SQL Databases?

MongoDB is a NoSQL, document-oriented database that stores data in BSON (Binary JSON) format. Unlike traditional SQL databases, MongoDB does not use a fixed schema and is designed to handle unstructured or semi-structured data. It supports flexible data models and horizontal scaling, making it suitable for modern applications with diverse and evolving data. Traditional SQL databases use a fixed schema and are designed for structured data with complex relationships.

Explain BSON and Its Significance in MongoDB

BSON (Binary JSON) is a binary representation of JSON-like documents used by MongoDB. It extends JSON with additional data types, such as binary data and dates, and provides efficient serialization and deserialization. BSON's format enables fast data retrieval and storage by optimizing the data representation for performance. It supports a wide range of data types and ensures that MongoDB can handle diverse and complex data structures efficiently.

Replica Sets and Sharding

• Replica Sets: A group of MongoDB servers that maintain the same data set. They provide high availability and redundancy by replicating data across multiple servers. In the event of a server failure, replica sets ensure that another server can take over without data loss.
• Sharding: A method for distributing data across multiple servers or clusters to ensure scalability and handle large datasets. Sharding divides data into chunks based on a sharding key and distributes these chunks across shards. This approach helps manage load and ensures efficient performance for large-scale applications.

What are the Advantages of Using MongoDB Over Other Databases?

• Schema Flexibility: Allows for evolving data structures without the need for schema migrations. This flexibility is useful for applications with changing data requirements.
• Scalability: Supports horizontal scaling through sharding, enabling the handling of large datasets and high traffic efficiently.
• Performance: Optimized for high-throughput and high-availability scenarios. MongoDB's architecture and indexing strategies enhance query performance.
• Rich Query Language: Provides a powerful query language and aggregation framework for complex data manipulations and analytics.

What is Sharding in MongoDB? How Does It Work?

Sharding is the process of distributing data across multiple servers or clusters to achieve horizontal scalability. MongoDB partitions data into chunks based on a sharding key, and assigns each chunk to a shard. The sharding key determines how data is distributed across shards, and the system balances data and load across shards to ensure efficient performance. Sharding helps manage large datasets and ensures that the system can scale horizontally by adding more servers.

What is Index in MongoDB? How to Create the Index?

Indexes in MongoDB improve query performance by allowing the database to quickly locate documents. To create an index, use the createIndex method:

db.collection.createIndex({ "field": 1 }) // Ascending index
db.collection.createIndex({ "field": -1 }) // Descending index

Indexes are essential for optimizing query performance, especially for large datasets. They can be created on one or more fields and support various types, including single-field, compound, and geospatial indexes.

What are MongoDB Aggregation Pipelines and How are They Used?

Aggregation pipelines are used to process and transform data through a series of stages. Each stage performs an operation such as filtering, grouping, or sorting, and passes the results to the next stage. They enable complex data manipulations and are useful for generating reports or analyzing data. Common stages include $match (filtering), $group (aggregation), and $sort (sorting). Aggregation pipelines provide a powerful and flexible framework for querying and analyzing data in MongoDB.

Operators in MongoDB

• $eq: Matches documents where the value equals a specified value.
• $gt: Matches documents where the value is greater than a specified value.
• $lt: Matches documents where the value is less than a specified value.
• $in: Matches documents where the value is in an array.
• $unwind: Deconstructs an array field from the input documents to output a document for each element. It is useful for working with array fields in aggregation pipelines.

What are TTL Indexes, and How are They Used in MongoDB?

TTL (Time-To-Live) indexes are used to automatically delete documents after a specified time period. They are particularly useful for managing data lifecycle tasks such as expiring sessions or temporary data.

To create a TTL index, use the following command:

db.collection.createIndex({ "field": 1 }, { expireAfterSeconds: 3600 }) // Expire documents after 1 hour

TTL indexes ensure that outdated or irrelevant data is automatically removed, helping to manage storage and keep the database clean.

How to Handle Backups and Disaster Recovery in MongoDB

MongoDB offers several strategies for backups and disaster recovery:

• Backups: Use tools like mongodump and mongorestore for manual backups, or leverage MongoDB Atlas Backup for automated backups. Regular backups ensure that you have a copy of your data in case of failures.
• Disaster Recovery: Implement replica sets for high availability and sharding for scalability. Regularly test your backup and recovery processes to ensure they work effectively and can restore your data in case of disaster. Plan for both local and remote backups to cover various disaster scenarios.

What is the $ Symbol in MongoDB?

The $ symbol in MongoDB is used in various contexts:

• Operators: For example, $set and $inc are update operators used to modify document fields. These operators are used in update operations to change the values of fields.
• Positional Operator: $ is used in queries to refer to the first matching array element within an array field. It allows you to update or access elements within an array.

What is ODM vs ORM?

• ODM (Object Data Mapping): Maps JavaScript objects to database documents. For example, Mongoose is an ODM for MongoDB that provides schema-based modeling, validation, and querying capabilities.
• ORM (Object-Relational Mapping): Maps objects to relational database tables. For example, Sequelize is an ORM for SQL databases that provides similar features for relational data models.

What is Express.js?

Express.js is a minimal and flexible Node.js web application framework that provides a robust set of features for building web and mobile applications. It simplifies HTTP request handling, middleware management, and routing, making it easier to develop and maintain web applications and APIs. Express.js is known for its simplicity and performance, allowing developers to create server-side applications quickly and efficiently.

What are Other Frameworks Used to Build APIs in Node.js?

Other frameworks for building APIs in Node.js include:

• Koa.js: A minimal and modular framework created by the same team that built Express. It offers a more modern approach to middleware and context management, using async/await for improved control flow.
• Hapi.js: A framework designed for building powerful and scalable applications, with features such as input validation, caching, and authentication. It provides a rich set of tools for building robust APIs.
• Sails.js: A framework for building MVC applications with a focus on data-driven APIs and real-time functionality. It includes built-in support for WebSockets and a powerful data management layer.

What is ACID Properties in Database ?

What is CAP theory ?