What Exactly Is the KISS Principle?

KISS ka full form hai Keep It Simple, Stupid. Yeh ek reminder hai ki jab tak simple solution kaam kar raha hai, tab tak usse complicated mat banao. A lot of times, we try to show off with clever code, but yaar, clever code better nahi hota. Clarity beats cleverness har baar.

Why Does KISS Matter in Real Projects?

Simple code is easy to read.
Simple code is easy to debug.
Aur sabse important, simple code is easy to maintain in the long run.

Aaj tu code likhega, kal koi aur padhega. Ya shayad tu khud ek saal baad dekhe aur soch pade, “Yeh kya bakwaas likha tha maine?” KISS ensures ki aisa na ho.

When You Don’t Follow KISS

Look at this JavaScript code:

function getUserStatus(isActive, hasSubscription, isBanned) {
  if ((isActive && hasSubscription) || (!isBanned && hasSubscription && isActive)) {
    return "Allowed";
  } else {
    return "Denied";
  }
}

In this code, the work is getting done, but the conditions are twisted in a way that can cause confusion. A new developer looking at this might get overwhelmed.

When You Apply KISS

Now look at this, the same function, but in KISS style:

function getUserStatus(isActive, hasSubscription, isBanned) {
  const isEligible = isActive && hasSubscription && !isBanned;
  return isEligible ? "Allowed" : "Denied";
}

This code is very simple and clear. Any developer will immediately understand what the function is doing. No nonsense, just clean logic.

Real-Life Analogy

Imagine ek dost tujhse rasta poochta hai. Agar tu shortcut aur simple rasta batayega, toh woh aasani se pahunch jayega. Lekin agar tu unnecessary twists aur turns batayega, toh woh confuse ho jayega. Code bhi aisa hi hai: simpler the path, better the result.

Pro Tip

Code commit karne se pehle ek baar soch lena:
Can I make this even simpler?
Agar jawab haan hai, toh kar do. Simple code se bugs kam hote hain aur team ke saath kaam karna bhi asaan ho jata hai.

What is the Fractional Knapsack Problem?

In the Fractional Knapsack Problem, you have a bag (knapsack) with a limited weight capacity, and you’re given a bunch of items. Each item has a weight and a value. The goal? Fill the bag with items (or parts of items) to maximize the total value without exceeding the weight limit. Unlike the 0/1 Knapsack Problem, you can take fractions of items here. For example, if you can’t carry a whole item, you can take half of it to get half its value.

The trick is to prioritize items with the highest value-to-weight ratio (basically, value divided by weight). Sort the items by this ratio, and start picking from the highest ratio until the bag is full. Simple, yet powerful!

Ab isse life lessons kaise connect hote hain? Let’s find out!

Life Lesson 1: Prioritize What Gives You the Most Value

In the Fractional Knapsack Problem, we pick items with the highest value-to-weight ratio first. In life, this is like focusing on tasks or goals that give you the most benefit for the effort you put in.

Imagine you have limited time (your knapsack) and tons of things to do, studying, chilling with friends, working on a side hustle, or scrolling on Instagram. Not everything is equally important. Some activities, like studying for an exam or spending time with family, have a high value for your future or happiness. Others, like binge-watching a show, might feel good but have less long-term value.

Takeaway: Ask yourself, Is mein kya value hai? Focus on high-value tasks first. Prioritize what moves you closer to your goals, just like picking the best items for the knapsack.

Life Lesson 2: You Don’t Always Need to Do Everything Fully

The beauty of the Fractional Knapsack Problem is that you can take parts of an item. In life, this teaches us that we don’t always have to go all-in on everything. Sometimes, doing a little bit of something is enough.

For example, you want to learn guitar, code, and stay fit. But you don’t have time to master all three at once. Instead of giving up, you can do a little bit of each—practice guitar for 20 minutes, code for an hour, and go for a quick walk. This way, you’re still making progress without overloading yourself.

Takeaway: Thoda thoda karo, par ruko mat! Small efforts add up. You don’t need to be perfect or complete everything just keep moving forward.

Life Lesson 3: Know Your Limits

The knapsack has a weight limit, and so do we in life. Our time, energy, and resources are finite. You can’t say yes to everything every project, every party, every opportunity. Trying to do too much leads to burnout, just like overloading the knapsack makes it impossible to carry.

When solving the problem, you stop adding items when the bag is full. In life, learn to say "no" to things that don’t fit your capacity or align with your goals. It’s okay to set boundaries and protect your time.

Takeaway: Apni capacity ko samjho. Don’t try to carry more than you can handle. Choose wisely and leave space for what truly matters.

Life Lesson 4: Greed is Good (Sometimes)

The Fractional Knapsack Problem uses a greedy approach you always pick the item with the highest value-to-weight ratio. In coding, greedy means making the best choice at each step, hoping it leads to the best overall solution.

In life, being "greedy" in a good way means grabbing opportunities that align with your goals. If you get a chance to learn a new skill, take a course, or meet someone inspiring, go for it! Don’t overthink the future just make the best choice in the moment.

But beware: Greed doesn’t always work (like in the 0/1 Knapsack Problem). So, balance your ambition with wisdom. Greedy bano, par soch samajh ke!

Takeaway: Seize the best opportunities in front of you, but think about whether they fit your bigger picture.

Life Lesson 5: Optimize, Don’t Overcomplicate

The Fractional Knapsack Problem is straightforward sort by value-to-weight ratio and fill the bag. It’s not about overthinking or trying every possible combination. In life, we sometimes make things too complicated. We stress about perfect plans or worry about every tiny detail.

Instead, take a step back and optimize. Break your goals into simple steps. Want to get fit? Start with a 10-minute workout. Want to ace DSA? Solve one problem a day. Keep it simple, and you’ll get to your goal faster.

Takeaway: Zindagi ko simple rakho. Don’t overcomplicate things focus on what works and keep moving forward.

Wrapping Up

Solving the Fractional Knapsack Problem today wasn’t just about coding it was a reminder of how to live smarter. Prioritize what matters, take small steps, respect your limits, grab good opportunities, and keep things simple. Yeh lessons coding se shuru hue, par zindagi ke har area mein kaam aayenge.

So, next time you're stuck on a DSA problem or feeling overwhelmed in life, remember: fill your knapsack wisely! What's one thing you're going to prioritize today? Share your thoughts in the comments, and let's keep learning together!

To make the PDFs searchable and chat-capable, we integrate:

• LangChain for loading PDF content and generating vector embeddings

• Qdrant as the vector database to store and search those embeddings

• Gemini (Google’s LLM) for generating intelligent, context-aware responses

• BullMQ for handling background tasks like PDF parsing and embedding generation

By the end of this post, you’ll have a robust app where users can chat with uploaded PDFs using modern AI technologies.

Project Overview

Our "Chat with PDF" application will:

1. Allow users to upload PDF documents

2. Process and extract text from PDFs

3. Store document embeddings in a vector database

4. Enable users to ask questions about the document

5. Provide AI-generated responses based on the document content

Architecture

The application follows a client-server architecture with the following components:

Backend (Express.js)

• REST API endpoints for file upload and chat

• Authentication middleware using Clerk

• PDF processing using LangChain

• Vector storage using Qdrant

• Background job processing using BullMQ and Redis

• AI integration with Google's Generative AI (Gemini)

Data Flow

1. User uploads a PDF document

2. Backend stores the file and adds a processing job to the queue

3. Worker processes the PDF, extracts text, and stores embeddings in Qdrant

4. User asks questions about the document

5. Backend retrieves relevant context from the vector store

6. AI generates responses based on the retrieved context

Backend Implementation Details

Installation and Setup

Before diving into the Express server setup, let's install all the necessary dependencies for our backend:

# Create a server directory if not already created
mkdir -p server
cd server

# Initialize package.json
npm init -y

# Install core dependencies
npm install express cors dotenv multer

# Install PDF processing and AI dependencies
npm install @langchain/community @langchain/qdrant @google/generative-ai

# Install queue management
npm install bullmq

# Install authentication
npm install @clerk/clerk-sdk-node

Express Server Setup

Now that we have our dependencies installed, let's set up our Express server. The server will handle file uploads, process PDFs, and respond to chat queries.

Here's the pseudocode for our main server file (index.js):

// Import necessary dependencies
Import Express, CORS, dotenv, ClerkExpressRequireAuth
Import multer middleware for file uploads
Import BullMQ for queue management
Import Gemini service for embeddings

// Load environment variables
Load environment variables from .env file

// Initialize Express app
Create Express app
Configure CORS
Configure JSON parsing

// Initialize BullMQ queue for PDF processing
Create pdfProcessQueue

// Authentication middleware
Create authentication middleware using Clerk

// Define routes

// File upload endpoint
POST '/upload-file':
  - Use authentication middleware
  - Use multer middleware to handle file upload
  - Add PDF processing job to queue with file path and user ID
  - Return success response

// Chat endpoint
POST '/chat':
  - Use authentication middleware
  - Extract question, user ID, and file ID from request
  - Generate embeddings for the question using Gemini service
  - Query vector store (Qdrant) with embeddings to get relevant context
  - Format context and question for AI model
  - Send formatted prompt to Google Generative AI (Gemini)
  - Return AI response

// Start server
Listen on specified port
Log server start message

File Upload Middleware

We'll use Multer to handle file uploads. Here's the pseudocode for our Multer configuration:

// Import multer and path
Import multer, path

// Configure storage
Create disk storage with:
  - Destination: './uploads/'
  - Filename: Generate unique filename with original extension

// Create and export upload middleware
Create multer instance with storage configuration
Export uploadFile middleware that accepts single file with field name 'pdf'

PDF Processing Queue

We'll use BullMQ to manage the PDF processing queue. Here's the pseudocode for our queue setup:

// Import BullMQ
Import Queue from 'bullmq'

// Create and export PDF processing queue
Create Queue with name 'pdfProcess' and Redis connection options
Export queue

PDF Processing Worker

The worker will process PDF files from the queue. Here's the pseudocode:

// Import necessary dependencies
Import Worker from 'bullmq'
Import PDFLoader from '@langchain/community'
Import QdrantVectorStore from '@langchain/qdrant'
Import Gemini service for embeddings

// Create worker
Create Worker with:
  - Queue name: 'pdfProcess'
  - Redis connection options
  - Process function:
    - Load PDF using PDFLoader
    - Split documents into chunks
    - Create vector store using Qdrant with:
      - Documents
      - Embeddings from Gemini service
      - Namespace based on user ID and file ID
    - Log completion message

// Handle worker events (completed, failed)

Gemini Service

We'll use Google's Generative AI for embeddings and chat responses. Here's the pseudocode:

// Import Google Generative AI
Import GoogleGenerativeAI, GoogleGenerativeAIEmbeddings

// Initialize Google Generative AI with API key
Create genAI instance with API key from environment variables

// Create and export embeddings function
Export GeminiEmbeddings function that returns GoogleGenerativeAIEmbeddings instance

// Create and export chat function
Export GeminiService function that:
  - Takes prompt as input
  - Creates Gemini model instance
  - Generates content based on prompt
  - Returns generated content

Environment Variables

Create a .env file in the server directory with the following variables:

PORT=3001
GOOGLE_API_KEY=your_google_api_key
QDRANT_URL=your_qdrant_url
REDIS_URL=your_redis_url
CLERK_SECRET_KEY=your_clerk_secret_key

Conclusion

This backend setup creates a strong base for our "Chat with PDF" application. It manages file uploads, processes PDFs to extract and store embeddings, and uses AI to generate responses based on the PDF content and user questions.

Using queues ensures that PDF processing happens asynchronously, which improves the user experience. The vector store enables efficient semantic searches of PDF content, and the AI model creates natural language responses based on the retrieved context.

In a production setting, you should add error handling, logging, and possibly caching to enhance performance and reliability.

Check the full code here: https://github.com/showoff-today/chat-with-pdf

After some research, I discovered BullMQ, a powerful library for managing queues in Node.js applications. It sounded like the perfect solution to my problem, so I decided to give it a try.

Getting Started

First things first, I needed to install BullMQ. I opened my terminal and ran:

npm install bullmq

Since BullMQ relies on Redis for its operations, I made sure Redis was installed and running on my machine.

Creating My First Queue

With the installation done, it was time to create my first queue for sending bulk emails. I created a new file called queue.js and started coding. I imported the necessary modules from BullMQ and set up my queue:

const { Queue } = require('bullmq');

// Create a new queue
const emailQueue = new Queue('email-queue');

// Adding an email task to the queue
emailQueue.add('send-email', { to: 'user@example.com', subject: 'Hello!', body: 'This is a test email.' });

console.log('Email task added to the queue');

I ran the file with node queue.js, and just like that, my first email task was added to the queue. It felt great to see my code working!

Processing Email Tasks

Next, I needed a worker to process the email tasks in the queue. I created another file called worker.js and wrote the following code:

const { Worker } = require('bullmq');
const nodemailer = require('nodemailer');

// Configure the email transporter
const transporter = nodemailer.createTransport({
    service: 'gmail',
    auth: {
        user: 'your-email@gmail.com',
        pass: 'your-email-password'
    }
});

// Create a worker to process email tasks
const worker = new Worker('email-queue', async job => {
    const { to, subject, body } = job.data;

    let mailOptions = {
        from: 'your-email@gmail.com',
        to,
        subject,
        text: body
    };

    try {
        await transporter.sendMail(mailOptions);
        console.log(`Email sent to ${to}`);
    } catch (error) {
        console.error(`Failed to send email to ${to}: ${error.message}`);
    }
});

worker.on('completed', (job) => {
    console.log(`Email task ${job.id} completed`);
});

worker.on('failed', (job, err) => {
    console.log(`Email task ${job.id} failed with error ${err.message}`);
});

I ran this file using node worker.js, and my worker was ready to process email tasks. When I saw the messages in the console confirming the emails were sent, I felt a sense of accomplishment.

Scheduling Bulk Emails

With the basics working, I decided to explore some of BullMQ's advanced features. I wanted to schedule bulk emails to be sent at a later time, so I modified my queue.js to add a job with a delay:

emailQueue.add('send-email', 
    { to: 'user@example.com', subject: 'Hello!', body: 'This is a scheduled email.' }, 
    { delay: 5000 } // Delays the email by 5 seconds
);

I also wanted to track the progress of sending emails and listen for events. I updated my worker.js:

worker.on('progress', job => {
    console.log(`Email task ${job.id} is in progress`);
});

worker.on('completed', job => {
    console.log(`Email task ${job.id} completed`);
});

worker.on('failed', (job, err) => {
    console.log(`Email task ${job.id} failed with error ${err.message}`);
});

Conclusion

By the end of the day, I had integrated BullMQ into my project, and it was handling the bulk email tasks efficiently. My web app was no longer slowing down, and I felt more confident in my project's scalability. BullMQ turned out to be a lifesaver, providing a robust solution to my problem with its easy-to-use API and powerful features.

So, if you ever find yourself needing to manage background tasks, like sending bulk emails, in your Node.js applications, give BullMQ a try.

In Postman, test scripts are written using JavaScript in the "Tests" tab after sending an API request. Each test script is associated with a specific API request and is executed automatically after the request is sent. The test script has access to the response data, request details, and various utility functions provided by Postman.

A basic test script structure looks like this:

// Test script
pm.test("Test Description", function () {
    // Assertion logic goes here
});

Common Test Scripts

1. Status Code Validation

// Test if the response status code is 200 (OK)
pm.test("Status code is 200", function () {
    pm.response.to.have.status(200);
});

2. Response Time Validation

// Test if the response time is less than 500ms
pm.test("Response time is within acceptable range", function () {
    pm.expect(pm.response.responseTime).to.be.below(500);
});

3. Response Body Validation

// Test if the response body contains a specific value
pm.test("Response body contains expected data", function () {
    pm.expect(pm.response.text()).to.include("expected_value");
});

4. JSON Response Validation

// Test if the response is a valid JSON
pm.test("Response is valid JSON", function () {
    pm.expect(pm.response.json()).to.be.an("object");
});

5. Header Validation

// Test if a specific header is present in the response
pm.test("Header is present in the response", function () {
    pm.response.to.have.header("header_name");
});

6. Chaining Tests

// Chaining multiple test assertions
pm.test("Chaining multiple assertions", function () {
    pm.expect(pm.response.json().property1).to.eql("value1");
    pm.expect(pm.response.json().property2).to.eql("value2");
});

7. Dynamic Data Validation

// Test if a specific value in the response matches the environment variable
pm.test("Dynamic data validation", function () {
    pm.expect(pm.response.json().user_id).to.eql(pm.environment.get("user_id"));
});

8. Setting data from the environment variable

var jsonData = pm.response.json();
pm.environment.set("companyIdToDelete", jsonData.data._id);

9. Response Schema Validation

// Test if the response adheres to a specific JSON schema
pm.test("Response schema validation", function () {
    const schema = {
        "type": "object",
        "properties": {
            "property1": { "type": "string" },
            "property2": { "type": "number" }
        }
    };
    pm.expect(tv4.validate(pm.response.json(), schema)).to.be.true;
});

10. Dynamic Response Validation

// Validate dynamic data in the response by extracting values from the response and using them in assertions.
// Extract a value from the response and use it in an assertion
pm.test("Dynamic response validation", function () {
    var responseBody = pm.response.json();
    var dynamicValue = responseBody.dynamic_property;

    pm.expect(dynamicValue).to.equal(pm.variables.get("expected_dynamic_value"));
});

11. API Versioning Validation

// Test different API versions
var apiVersion = "v2";
pm.test("API versioning validation", function () {
    pm.request.headers.add({ key: "Accept-Version", value: apiVersion });
    pm.sendRequest(function (response) {
        pm.expect(response.status).to.equal(200);
        pm.expect(response.json().version).to.equal(apiVersion);
    });
});

12. File Upload Validation

// Test file upload
pm.test("File upload validation", function () {
    var formData = {
        file: {
            value: pm.globals.get("fileData"),
            options: {
                filename: "sample.txt",
                contentType: "text/plain"
            }
        }
    };

    pm.sendRequest({
        url: "https://api.example.com/upload",
        method: "POST",
        body: formData
    }, function (response) {
        pm.expect(response.status).to.equal(200);
        pm.expect(response.json().success).to.be.true;
    });
});

13. Authentication and Authorization Testing

// Test authentication and authorization
pm.test("Authentication and authorization", function () {
    var authToken = pm.environment.get("authToken");

    pm.request.headers.add({ key: "Authorization", value: "Bearer " + authToken });
    pm.sendRequest(function (response) {
        pm.expect(response.status).to.equal(200);
        pm.expect(response.json().authorized).to.be.true;
    });
});

14. Data Extraction and Transformation

Extract data from the response and transform it for further use or validation.

// Extract and transform data from the response
pm.test("Data extraction and transformation", function () {
    var responseArray = pm.response.json().data;
    var transformedData = responseArray.map(function (item) {
        return {
            id: item.id,
            name: item.first_name + " " + item.last_name"
        };
    });

    // Use transformed data for assertions or environment variables
    pm.expect(transformedData[0].name).to.include("John");
    pm.environment.set("transformedData", JSON.stringify(transformedData));
});

15. Session Management

//Simulate session management by saving and reusing session tokens.
// Session management using session tokens
var sessionToken;

pm.test("Login and session management", function () {
    // Perform login and extract session token from the response
    sessionToken = pm.response.json().session_token;
    pm.environment.set("sessionToken", sessionToken);
});

pm.test("Authenticated request using session token", function () {
    // Use the saved session token for authenticated requests
    pm.request.headers.add({ key: "Authorization", value: "Bearer " + sessionToken });
    pm.sendRequest(function (response) {
        pm.expect(response.status).to.equal(200);
    });
});

16. Pagination Testing

// Test APIs that return paginated results and validate pagination logic.
// Pagination testing
pm.test("Pagination testing", function () {
    var response = pm.response.json();
    var currentPage = response.page;
    var totalPages = response.total_pages;

    // Validate pagination logic
    pm.expect(currentPage).to.be.at.least(1);
    pm.expect(currentPage).to.be.at.most(totalPages);
});

17. Load Testing

//Perform load testing by sending multiple concurrent requests.
// Load testing with concurrent requests
var concurrentRequests = 10;

pm.test("Load testing", function () {
    var requests = [];

    for (var i = 0; i < concurrentRequests; i++) {
        requests.push(pm.sendRequest);
    }

    Promise.all(requests).then(function (responses) {
        responses.forEach(function (response) {
            pm.expect(response.status).to.equal(200);
        });
    });
});

18. Database Validation

// Validate API responses by comparing them with data from a database.
// Database validation using a mock database
var mockDatabase = [
    { id: 1, name: "Item 1" },
    { id: 2, name: "Item 2" }
];

pm.test("Database validation", function () {
    var response = pm.response.json();

    mockDatabase.forEach(function (item) {
        var matchingItem = response.find(function (responseItem) {
            return responseItem.id === item.id;
        });

        pm.expect(matchingItem.name).to.equal(item.name);
    });
});

You can generate test cases using Postbot, which is located in the top right corner of the test case writing area.

You can write more complex test scripts using various assertions and conditions based on your API testing needs. Postman offers documentation and tutorials to help you learn more about writing test scripts and performing API testing effectively.

Benefits of Automated API Testing with Postman:

1. Time Efficiency: Automating API testing with Postman saves time by running tests automatically, freeing up resources to focus on other critical tasks.

2. Consistency: Automated testing ensures that API tests are performed consistently without manual errors, improving reliability and repeatability.

3. Faster Feedback: Rapid execution of test scripts allows for quick feedback on API changes, enabling developers to fix issues promptly.

4. Scalability: Postman supports testing multiple APIs simultaneously, making it suitable for projects of various sizes.

5. Integration with CI/CD: Automated API testing can be integrated into Continuous Integration and Continuous Deployment (CI/CD) pipelines, ensuring thorough testing at every code change.

If you're familiar with Postman basics, like sending requests and using collections, now let's dive into creating tests in Postman.

Writing test cases in Postman

Before writing test cases in Postman, ensure you have the following:

1. Postman is installed on your system.

2. A basic understanding of APIs and HTTP methods.

3. Familiarity with JSON (JavaScript Object Notation) for response validation.

Where to write test cases.

In Postman, you can write and organize your test cases using the "Tests" tab within the Postman request editor. Here's how you can write test cases in Postman:

• Create a Request: First, create a request by selecting the request type (GET, POST, PUT, DELETE, etc.) and entering the request URL along with any necessary headers, parameters, and request body.

• Navigate to the Tests Tab: After setting up the request details, click on the "Tests" tab located below the request editor. This is where you'll write your test scripts.

• Write Test Scripts: In the "Tests" tab, you can write JavaScript code to define your test scripts. These scripts will be executed after sending the request, and you can use them to validate the response received from the server.

Here's a simple example of a test script that checks if the response status code is 201:

pm.test("Response status code is 201", function () {
    pm.expect(pm.response.code).to.equal(201);
});

You can add more test scripts to validate various aspects of the response, such as response headers, response body, specific data values, etc.

• Run the Request: After writing your test scripts, you can click the "Send" button to send the request to the server. Postman will execute your test scripts and display the results in the "Tests Results" section below the request editor.

• 

• View Test Results: The test results will show you whether your test scripts passed or failed. If a test fails, Postman will provide information about the failure, which can help you identify the issues in your API.

• Organize Test Scripts: You can organize your test scripts by creating multiple requests within a Postman collection. Each request can have its own set of test scripts. Collections allow you to group related requests and tests together, making it easier to manage and run your test suite.

Remember that the examples provided here are basic illustrations. You can write more complex test scripts using various assertions and conditions based on your API testing needs.

Additionally, Postman offers documentation and tutorials to help you learn more about writing test scripts and performing API testing effectively.

Refer this article for common test scripts in postman 👉 Click Me

Integrate Postman automated testing with CI/CD

Now We’ll learn about How to integrate Postman automated testing with CI/CD of GitHub using Newman in the Nest JS Project.

Integrating Postman automated testing with CI/CD using Newman involves setting up a process that allows you to run Postman collections and tests automatically as part of your Continuous Integration and Continuous Deployment (CI/CD) pipeline. Newman is a command-line tool provided by Postman that allows you to run Postman collections from the command line, making it suitable for automation in CI/CD environments.

I’m assuming that you have already created a collection with test cases.

Here's a step-by-step guide on how to integrate Postman automated testing with CI/CD using Newman.

Generate Postman Collection API URL.

For generating Postman collection API Url, Follow the given steps:

1. Click on the “View More Actions“ button of the collection.

   

2. Click on the “Share“ Option

1. Choose the “Via API” option.

1. Copy the Postman API URL using copy button.

Your Collection API Generated Successfully.

Configure Your CI/CD Pipeline:

• You'll need to set up a job or stage that will run your Postman tests using Newman.

• In the pipeline configuration, you'll need to specify the commands to install Newman, run your tests, and possibly report the results.

To configure your CI/CD pipeline, Follow the given steps:

1. Create a .github folder in the root of the project.

1. Create the workflows folder inside the .github folder.

2. Create yourFileName.yml file inside the workflows folder.

1. Now, write a shell script to run your Postman tests as part of the build or test phase.

    name: Test Nest.js Application
   
    on:
      push:
        branches:
          - create-company // Replace with your branch name
   
    jobs:
      run-and-test:
        runs-on: ubuntu-latest
        steps:
          - uses: actions/checkout@v2
          - name: Install Node.js
            uses: actions/setup-node@v2
            with:
              node-version: '18'
          - name: Install Nest.js CLI
            run: npm install -g @nestjs/cli
          - name: Install Dependencies
            run: npm install
          - name: Run Nest.js Application on Localhost
            run: npm run start:dev & sleep 10
          - name: Run API Tests with Newman
            run: |
              npm install -g newman
              newman run "Paste Generated Collection API Url"
   

   For more such articles visit: https://tech.pococare.com

Vite.js is a lightweight development server for building web applications. It is a fast development setup for building JavaScript projects, specifically Single Page Applications (SPAs) and Progressive Web Applications (PWAs). Vite.js uses the native ES modules feature in modern browsers, which allows for fast and efficient development without the need for a build step or configuration. It also includes features such as hot module replacement, which allows for fast development cycles by automatically updating the browser when code changes are made. Vite.js is a simple, lightweight alternative to other development servers like webpack-dev-server, and can be used with popular front-end frameworks such as React, Vue, and Svelte.

How to setup React Project using Vite.js

To set up a React project using Vite.js, you will need to have Node.js and npm (or yarn) installed on your computer. Once you have those, you can follow these steps:

1. Please create a new directory for your project and navigate into it.

2. Run the following command to create a new React Project:

    npm create vite@latest <your-app-name>
   

3. We will be asked if we want to install the create-vite@latest package, we’ll choose Y.

   

4. CLI asks for the package name, We will provide the package name.

   

5. CLI ask to choose a framework, we will select React by using the down arrow key.

   

6. Now, the CLI asks to select a variant (JavaScript/TypeScript), let’s choose JavaScript.

   

7. When creating a new project, Vite CLI doesn’t automatically download the dependencies, we have to do it manually. Run the following command to install dependencies.

    cd <your-project-name>
    npm install
   

8. Run the following command to start our development server.

    npm run dev
   

9. Open the Local URL in your browser.

   

10. We are done, Our React Project is created.

    

Thanks, for reading my first blog, Follow me for such content.