Mritunjoy Mahanta

Mithun J. Mohanty, I'm from Bolpur, which is in the Birbhum district in West Bengal. I have three years and two months of experience in full stack development. Mainly in ReactJS, NodeJS, ExpressJS, and MongoDB, which is a NoSQL database. I also work on DynamoDB. Additionally, I have experience with a little bit of AWS, including EC2 instances, AWS Amplify, and S3 Buckets. My current project is called Elite Primary, which is in the real estate domain. In this project, I'm working as a front-end developer, handling the front-end stuff and leading the front-end team using ReactJS, Redux, TypeScript, and Style Component. Before that, I worked on a project called Mindvoice. Mindvoice is a quality management tool for contact centers. In this project, I worked as a full-stack developer, handling both the front-end and back-end parts. For the front-end, I used ReactJS, Redux, TypeScript, and Ant Design, while for the back-end, I used Node.js, Express.js, and MongoDB. We also used EC2 from AWS for hosting purposes. The project Mindvoice is about recording calls at contact centers. Based on these recordings, quality assurance engineers rate the agents' performance. This process was previously time-consuming and labor-intensive, but after we built the project, it automatically detected fraud and agent quality. It transcribed the calls and used this transcription to rate the agents. Before that, I worked on a project called Business Easy. Business Easy is an e-commerce platform for e-text filing. In this project, I also worked as a full-stack developer, handling the project from scratch.

Can you leverage React's context API to manage global state in the application? And how does it differ from state manual libraries like Redux? So, in content, leverage React context API to manage global state. Yeah, so why do we have to let's suppose we have a parent component, right? And then inside that, we also have a child component, and inside that we are also having another child component, so a grandchild component. So let's suppose I need data, which is present in the parent component, right? And also I need the same data in the grandchild component. So what we have to do, like in a normal state, if you just try to pass that same data, either we have to call that same API from the grandchild component, and that's not a very effective way or efficient way to do that. And another way we can do, like we have to pass that data from the parent component to the child component, and then again to the child to the grandchild component. So that is also not an effective way or efficient way, because the child component is actually getting that data unnecessarily, and the data can leak from that child component, right? So what context API does, it creates a separate store, and whenever we just need the data, instead of just passing it from the parent to child and child to grandchild, we can directly call that data from that store, inside that grandchild component. It just wraps our context, we have to wrap up our context to that whole, initially we have to wrap up our app, which is the initial component, to that context provided, and then we can do that. What's different from Redux also works like the same way, but what is the difference, is that Redux is a very huge tool, it's an external library, and it doesn't work with only with React, it also works with Angular as well. So that's the one difference, and also context API actually comes with Redux, and whenever we just create a mid-size application, that time if we can use context API, that is fine for it, but for a very large scale of application, where we have to manage a lot of state, it is recommended to use Redux, instead of using the context API.

to demonstrate how you would use NestJS guards for implementing a role-based access control. So for role-based access control, what we can do is create a role in the user schema, let's suppose. In the user schema, we can pass fields such as first name, last name, email, phone number, and then a schema called title, or role. We should handle it by giving the value as a numeric value for that role, that is like 0, 1, 2, 3, 4, and so on. If the number is higher, then depending on that higher number, that user has more access. Let's suppose we have three types of users: one for normal users, another for managers, and the third for super admins. We can pass the role value as 0 for normal users, 1 for managers, and depending on that, we can show different views or functionality. In the front-end side, whenever we do a login, we can check the role of the user, if it's 0 or 1, and depending on that, we can show different views or functionality. We can also create a higher-order component that checks the role of the user and implements the role-based access control.

Illustrate how you would set up a mongodb replica set to provide high availability for a Node.js application Set up a mongodb replica set to provide high availability for a Node.js application So what we can do, replica set to provide high availability for a Node.js application Let me open up my editor Let me create a new folder For mongodb implementation, what we can do For mongodb implementation, what we can do I thought we have to demonstrate that I thought we have to demonstrate that We can use something called mongoose To connect with the database, we can use mongoose That's a separate package we have to install We can do something like mongoose.connect We can do something like mongoose.connect We can do something like mongoose.connect We can use mongoose.connect We can use mongoose.connect We can use mongoose.connect We can use mongoose.connect We can get the connection string from there We can use mongoose.connect We can use mongoose.connect We can use mongoose.connect We can use mongoose.connect We can get the connection function, from there We can get the connection function, from there

strategy for merging complex feature branches with git, merging complex feature branches with git while ensuring minimal disruption to the main development branch. Demonstrate a strategy for merging complex feature branches with git while ensuring minimal disruption to the main development branch. So, what we can do for merging a branch, what we can do initially, what I do, let me demonstrate this from scratch. Let's suppose I have a main branch, and all the things are actually merged to the finally into the main branch. Right, so what you can do is let's suppose I am creating a new branch called staging branch, and I just need to merge that. I just need to take that main branch code to the staging branch first, and then we can later on, whatever changes we are doing in the main staging branch, we can just merge it to the main branch. So, what we can do is the command we have to do is like git initially. We can do like git stash to stash all the changes, whatever we did, so that we don't miss out all the changes, whatever we did earlier. And then, what you can do is git checkout and with the sign of minus b to create a new branch, and then giving up the new name, that is the staging branch. So, I will just pass the new name after minus b or dash b space staging, and then we can pass the main name because we are taking all the code from the main branch. And then, if you just press the enter, it will create a new branch in the name of staging, and then what will happen is it will create a new branch from the main branch, taking the code from the main branch. Also, we can after that do something like git stash pop, so that whatever changes we have done, and whatever are in the stash, we stashed earlier, it will be popped up, I mean, it will be come here again in this new branch, so that is the staging branch. And whatever changes we have to make, we can just select all those, or like git add, and select all those files. And then, what we can do is like we can do like git commit and minus m for message, and then pass it, pass the message, whatever we commit message, whatever we want to do. Add, and then we can do something like git push origin, and to that branch name, that is that staging branch, right, so that staging. And then, these changes will be there in the staging branch, and later on, what we can do is like git merge, we can write that git merge command, and then them with the branch name that main branch, and also that current branch name. Otherwise, if you go to, if you are using github or gitlab, for that, we can do like we can directly go to the github or gitlab portal, and then we can create a pull request for that one, or the merge request for that, from them, for that staging branch to the main branch. And then, it will come up, come up a merge request in the main branch, and we can merge the code from there. So, that's the way we actually do the git merging the complex feature.

How do you integrate a client-side React application with a server-side Node.js backend, ensuring secure API calls and data transfer? So, to integrate a client-side React application with a server-side Node.js backend, ensuring secure API calls and data transfer, we can use something called CORS. CORS is a cross-origin resource sharing. And what it does is, it actually allows you to take the data or fetch the data from a different origin, or it allows the server to call it from a different endpoint or from a different server. So, let's suppose if you are not using CORS in your backend application, then what will happen? If you try to call that API, after creating all the, let's suppose I'm creating an API for getting the user. So, if you try to call the API from the frontend, so the port number is different, right? So, although it's running in the same machine, but the port number is different, right? So, let's suppose the frontend is running in port 5050, but the backend is running in port 4000. So, then it will give us some CORS error in the terminal or in the browser console. So, you can see it there, that there is a CORS error. So, that means that it doesn't allow, the backend server is not allowing it to call the data from a different server. So, in that case, we have to install CORS in the backend server, and then what we can do, in the Node.js application, what we can do in the main file, like the index.js file, we can create a, we can import the express.js from the express library, and then let's suppose I'm just initializing that express.js in a variable called app. So, we can use like app.use, and then inside that, we can just call the CORS, C-O-R-S, and just pair of parentheses. So, and before that, we also have to import that CORS as well, install and import that CORS as well. So, that's how we can do the secure API call for data transfer.

There is an issue when this component is unmounted. And then the component will unmount if there's anything we should do here. What we have to do here is unmount the state from here. So in this case, in this component will unmount. In this case, what we have to do is stop the fetch API call. So what we can do is use a function that will prevent the fetch API call or cancel the API call. So basically, that's the thing. We have to cancel the fetch user data call in the component will unmount. So what will happen? Let's suppose we're going to the user's page, and then the user profile page, the API will call, right? So it's the component that mounts, so initially it will be called. But let's suppose, and then instantly we're just clicking on the other page, like the home page. So that time, what will happen is we don't need that API, right? So that will be an unnecessary resource-taking thing. So we have to unmount that component and cancel the fetch user data function. So the user fetching doesn't happen and that resource won't be taken because we don't need the data. So we have to cancel the API call, that's what we have to do.

In this Node.js code block, can you spot any issues that might affect scalability or cause potential errors in handling asynchronous operations? Function fs.readfile path utf-error-data if-error-thrower-console-log-data In this fs.readfile, we have to make it as asynchronous operation because whenever we just try to read a file, that is an asynchronous operation. We can use an async await method here so that inside that await we can just log this data and otherwise we can handle the error from there. So inside the try-catch, let's suppose I'm just passing instead of this if-error, we just, this is fine, if-error, this is fine, but then we can pass something called a try-catch inside the try block, we can pass this, we can store this data inside a variable and then that is the await inside that await and then console log this data, otherwise in the catch, we can just catch the error and then console log that error or whatever we want to do in the error, so that's what we can do in this function.

I would deploy the following strategies to optimize the performance of a React Native application integrating with a Node.js packet. Initially, in the Node.js server, I would use the clustering thing to make it a multiple cluster and multiple thread, so that it will be a lot more easier or a lot more scalable whenever there is a multiple user for this one, I mean for that actual application and that doesn't break that application very easily. That clustering thing will allow us to use our whole system's core, every core of the system that we can use. I would also handle all the errors properly by trying to catch them everywhere so that we can catch all the errors instead of it just breaking somewhere. To do this, we would use the error-first approach, so that whenever there is something error, we have to catch it first and then if you are just getting some error, then we have to catch it first and otherwise if you are not getting the error, you have to check it first and then if you are not getting the error, then it's fine, we can just pass the response. In the React Native application, I would use something called Redux to manage the states. I would also use lazy loading to load the components properly, by importing only the components that we just need at that time. Additionally, we can use something called React Suspense to show some suspense in our project, so that user can actually know that there is something, instead of just loading all those components at the initial state. I would also use functional components, as they are much faster than class-based components. The reason for this is that class-based components are actually converted by our compiler into the functional components, so in the functions initially it is, I mean later on when we just try to build our project, that time it just converted into the functional component, so that actually takes a slight extra time while we are just writing a class-based component. Finally, I would use something called TypeScript to improve the development speed, so that we can get the errors in the development time.

Can you explain how Jenkins can be utilized to automate testing MongoDB backend node.js applications? Yeah, we can use Jenkins while we are creating the CI-CD pipeline also to create an automated test that if all the codes are in the place or something like that, we can use Jenkins for that.

How do you handle automatic deployment of a React application using AWS infrastructure with CICD tools? So, one way, that's an easy way, for a React application is that AWS offers something called AWS Amplify. If we deploy, if we give permission to our GitHub repo or GitLab repo to that Amplify, then it will, whenever we just commit code in a specific branch, let's suppose I'm telling AWS Amplify that there's a specific branch called master, then you have to select that. Whenever we're committing code to the master or merging some other branch with the master, it will find those changes, conditionally check if there are any changes in the master branch, then it will take those changes and automatically deploy them to the server. That's one thing. Otherwise, we can use something called Jenkins to create our own CICD pipeline. We can also use that. That's how we can do that.