DEV Community: Sarthak Mahulikar

Backend with Node JS : Installing and Creating NodeJS Server

Sarthak Mahulikar — Wed, 29 Jan 2025 12:22:39 +0000

This blog will give you brief information of how to Create server using Node.js, Express. Lets understand and go through every step of code and features.

Setting up Node.js project

Lets start with creating new project directory
Step-I : Creating New Project Directory
Make a new directory for the project. For creating the new directory open terminal at location where we want to create project folder. Now for creating folder use "mkdir" command.

mkdir your-project-name

For opening the new directory use "cd" command as follow

cd your-project-name

Step-II: Establishing Node.js project
For creating the Node.js project we need to initialize it. In order do this use "npm init" command in the directory of our project.

npm init

After using npm init command you will be prompted to enter the information about the project such as Name, Version, Description, Entry Point(Generally it is index.js), and more such options. We can provide our own info setting or else we can accept the default setting by pressing Enter.

Once the above step is completed a package.json file will be created in our project directory. All the information related to Project and Dependencies is included in the package.json file.

Step-III: Setting up the file structure in project

Step-IV: Installing express and dotenv
In our project we need Express to build single page application and web application. Express will provide the REST services like handling routes, requests and responses. Dotenv is basically used for loading the environment variables from a .env file into process.env .It is also used for keeping your sensitive data like database credentials, API keys safe.

For installing above packages use command below:

npm install express dotenv cors

After executing above command node_modules folder will be created in our project along with package-lock.json file.

Before starting to code ensure which type of structure we want to use in package.json file from two options "commonjs" or "module".

In our project we will use module as shown in above image "type":"module"

Also we need to install nodemon dev-dependency. Nodemon is tool which automatically restart server after any update done in our nodejs code.

npm install --save-dev nodemon

After running install command do change "scripts" as shown in image below

Step-V : Creating And Starting Server

Creating The Server
The first we need to do is go to our app.js file and import below packages which are required for creating server and CRUD operations.

//Required packages 
import express from 'express' ;
import cors from 'cors';

Now we will create server by using express().If we want to provide CORS_ORIGIN then we can provide it in .env file and then use it in configuration of cors. If we want to provide access for all origin then write CORS_ORIGIN= *

const app = express();
app.use(
    cors({
        origin: process.env.CORS_ORIGIN,
        credentials: true,
    })
);

app.use(express.json());
app.use(express.urlencoded({ extended: true, limit: '16kb' }));
app.use(express.static('public'));
export { app };

Now go to index.js file and write below code to start server on the port as defined in .env file or 3000.

import { app } from './app.js';
import dotenv from 'dotenv';
dotenv.config({ path: './env' });
const port=process.env.PORT || 3000;
app.listen(port, () => {
    console.log(`server is running on port ${port}`);
});

After adding above code go to the terminal and run below command to start server.

npm run dev

Conclusion:

These are the steps for setting up project in Nodejs and starting backend server.

Laravel Jobs : Step By Step Implementation

Sarthak Mahulikar — Wed, 27 Mar 2024 09:14:04 +0000

What is Laravel Jobs?

Job refers to tasks that are executed asynchronously. Laravel provides a powerful queue system for managing and executing these jobs. Job can be any PHP code that needs to be executed outside of the typical request-response cycle.

Why are Laravel jobs necessary?

In a synchronous system, users have to wait until the task is completed. It will lead to long waiting time, sometimes it happens when the tasks are resource intensive. In such situations laravel jobs come into play.
Laravel jobs provides you the functionality to handle the tasks in background, so it helps you for returning the web requests quickly.

When to use Laravel jobs?

The scenarios where laravel jobs are effective are as below:
1.Email Sending: In sending emails to the user jobs help you handle the requests. This ensures that the user don't need to wait for long time for getting response. When you handle request using laravel job you can send the response to the user while at the same time the job task is working in the background.

2.Data Processing: Sometimes while storing the different forms of data such as image, documents. You need upload those data to a particular platform but storing it without job makes it more time consuming. Hence laravel jobs helps you to run and handle these processes in background and helps to minimize request-response cycle time.

3.Notifications: If you have a system that sends notifications to the user you can use job for sending those notifications. You can schedule the notification job, laravel also provide the scheduling facility for the job such as daily, weekly ,etc. notifications.

Implementation Steps for Using Laravel Jobs

Step-I:
For getting started with larevel jobs you will need a database table that holds the jobs. To generate migration related to that creates the table for job, run queue:table Artisan Command and after migration is created. Use migrate command.

php artisan queue:table

php artisan migrate

Now, you need to update the database driver by updating the value of QUEUE_CONNECTION variable mentioned in .env file of your application.

QUEUE_CONNECTION=database

Step-II:
For creating jobs we have make:job Artisan command. All the jobs you have created by default stored in the app/jobs directory.
If the app/jobs directory doesn't exist in your application, you need not have to worry it will be created when you run the make:job Artisan commmand.

php artisan make:job <job_name>

The code you want to execute after running job should be written in the handle() method

public function handle(): void
{
    // Write code here which you want to execute after running job
}

For Running the jobs we have queue:work Artisan command.This command will start the queue worker and process the new jobs as they are pushed onto the queue. Once the queue:work command started, it will run continuously until you stop it manually or you close the terminal window.

php artisan queue:work

Example: Filtering Posts For Inappropriate Words

In this example we will provide functionality to user that he can add post only which doesn't have any bad words If it has bad words then we will delete the post using the jobs.
The code for the above is as below:

class ProcessTask implements ShouldQueue
{
    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;

    /**
     * Create a new job instance.
     */
   private $postId;

    public function __construct($post_id)
    {
        $this->postId=$post_id;
    }

    /**
     * Execute the job.
     */
    public function handle(): void
    {
        $post=Post::find($this->postId);
        $badWords=["Donkey","Bloody","Damn","Dumb"];
        $badWordsFoundList=[];
        foreach($badWords as $badWord )
        {

                if(Str::contains($post->description,$badWord))
                {

                    array_push($badWordsFoundList,$badWord);
                }

        }
       if(count($badWordsFoundList)!=0)
        {   $badWordsString='';

            foreach($badWordsFoundList as $badWordFound){
                $badWordsString.=" ".$badWordFound."  ";
            }

            echo "Deleting the post \n\n";
            $post->delete();

           echo 'bad words found  the words are: '.$badWordsString;
        }      
        else{

            echo " Bad Word not found in the Post ";
        } 
    }
}

Conclusion:

Laravel job provide a efficient solution for executing asynchronous tasks in your application and thus saves your time and improves efficiency of application. These are the steps that are required for creating a job in Laravel