DEV Community: Rutvik Makvana

Docker Made Simple: From Zero to Docker with Real Interview Questions

Rutvik Makvana — Sat, 14 Mar 2026 08:30:25 +0000

Question - Why we need docker?

Imagine two developers:
- Dev A builds an app on his laptop.
- Dev B tries to run it on her laptop.
Dev A says:
- It works perfectly on my machine!
Dev B runs it and gets 100 errors.
Why?
Because Dev A's computer has:
- Node v18
- Python 3.11
- Some libraries
- Special OS settings
Dev B's computer has different versions.
This problem existed for years.
Then came the hero ==> Docker

Question - What is Docker?

Docker is a containerization platform used to package an application and its dependencies into a lightweight container that runs consistently across environments.
Key benefits:
- Environment consistency
- Faster deployment
- Isolation
- Lightweight compared to VMs

Question - What is the difference between Docker and Virtual Machines?

Both provide isolated environments, but they work differently.

  Feature          Docker Containers   Virtual Machines
  ---------------- ------------------- ------------------------
  OS               Share host OS       Each VM has its own OS
  Size             MBs                 GBs
  Startup Time     Seconds             Minutes
  Performance      Faster              Slower
  Resource Usage   Lightweight         Heavy

Containers are more efficient because they share the host kernel.

Question - Main components of Docker:

Docker Client
Docker Daemon
Docker Images
Docker Containers
Dockerfile
Docker Registry (Docker Hub)

Docker Client

The Docker Client is the tool developers use to interact with Docker.
When you run commands like:

docker build
docker run
docker pull

You are using the Docker Client.
The client sends these commands to the Docker Daemon.

Docker Daemon

The Docker Daemon (dockerd) is the background service that manages everything.
It is responsible for:
- Building images
- Running containers
- Managing networks
- Managing volumes
The Docker client communicates with the daemon to perform actions.

Docker Image

A Docker Image is a read-only template used to create containers.
It contains:
- Application code
- Runtime (Node, Python, etc.)
- Libraries
- Dependencies
- Environment setup
Example image:

docker pull nginx

Docker Container

A Docker Container is a running instance of an image.
Think of it like:

Image = Blueprint
Container = Running Application

Containers are:
- Lightweight
- Fast
- Isolated

Dockerfile

A Dockerfile is a script that defines how to build a Docker image.
Example:

FROM node:18
WORKDIR /app
COPY . .
RUN npm install
CMD ["npm","start"]

This tells Docker how to build the image step by step.

Docker Registry

A Docker Registry is a place where Docker images are stored and shared.
The most popular public registry is: Dcoker Hub
Example Command:

docker pull ubuntu

This downloads the image from Docker Hub.

Question - Most Important Dockerfile Commands

FROM           Base image
WORKDIR        Set working directory
COPY           Copy files
ADD        Copy + extract
RUN        Execute commands
CMD        Default command
ENTRYPOINT     Main executable
EXPOSE         Declare port
ENV        Environment variable

Question - Difference Between CMD and ENTRYPOINT

CMD                 ENTRYPOINT
Default command         Fixed executable
Can be overridden   Harder to override
Used for parameters Used for main command

Example:

CMD ["node", "server.js"]

Question - What is .dockerignore?

Similar to .gitignore, it prevents unnecessary files from being copied to the Docker image.
Example:

node_modules
.git
.env

Question - How to Build a Docker Image?

docker build -t my-node-app .

Question - How to Run a Container?

docker run -p 3000:3000 my-node-app

Question - How to See Running Containers?

docker ps

All containers:

docker ps -a

Question - How to Run a Container?

docker stop container_id

Question - What is Docker Compose?

Docker Compose is a tool used to define and run multi-container Docker applications using a docker-compose.yml file.
Example use:
- Node.js
- MongoDB
- Redis
All run together

Question - Example docker-compose.yml for Node.js + Mongo

version: "3"

services:
  app:
    build: .
    ports:
      - "3000:3000"
    depends_on:
      - mongo

  mongo:
    image: mongo
    ports:
      - "27017:27017"

Question - Important Docker Compose Commands

Start services

docker-compose up

Background mode

docker-compose up -d

Stop services

docker-compose down

Rebuild

docker-compose up --build

Question - What is depends_on in Docker Compose?

It defines service dependency order.
Example :

depends_on:
  - mongo

Meaning Node starts after Mongo container.

Question - What is build vs image?

build
- Builds image from Dockerfile
- Used for custom apps
Example :

build: .

image
- Uses existing image
- Used for prebuilt apps
Example :

image: mongo

Question - What is a Docker Volume?

A Docker Volume is used for persistent data storage outside the container.
Normally when a container stops or is deleted, data is lost.
Volumes solve this problem.
Example :

docker run -v myvolume:/data nginx

Common use cases :
- Databases
- Logs
- File uploads

Question - What is Bind Mount in Docker?

A Bind Mount connects a host machine directory to a container directory.
Example :

docker run -v /host/folder:/container/folder nginx

Difference from Volume:

  Volume                  Bind Mount
  ----------------------- -----------------
  Managed by Docker       Managed by host
  Stored in Docker area   Any host path
  Portable                Less portable

Question - What is Docker Network?

Docker Network allows containers to communicate with each other.
Types of networks:

  Network Type   Description
  -------------- --------------------------------
  bridge         Default network for containers
  host           Container shares host network
  none           No networking
  overlay        Used in Docker Swarm

Example:

docker network create mynetwork

Question - What is Docker Layer Caching?

Docker images are built in layers.
Each command in Dockerfile creates a new layer.
Example:

FROM node:18 
WORKDIR /app 
COPY package.json . 
RUN npm install 
COPY . .

If package.json doesn’t change, Docker reuses the cached layer.
Benefits:
- Faster builds
- Reduced rebuild time

Why Postgres is Your App’s Secret Superpower (And Why You’re Overcomplicating Everything)

Rutvik Makvana — Mon, 16 Jun 2025 15:59:45 +0000

Let’s face it: we developers love our shiny tools. Redis for caching, RabbitMQ for queues, Elasticsearch for search, MongoDB for… well, vibes. But what if I told you that Postgres can handle most of these tasks—and do them exceptionally well? The problem? Its versatility makes us overcomplicate our stacks when we don’t need to.

🚫 Debunking the Postgres Scaling Myth

You’ve probably heard the whispers:

“Postgres doesn’t scale.”
“You need specialized tools for specialized jobs.”

Wrong. Real-world giants prove otherwise:

Instagram: Manages millions of users on a single Postgres database.
Discord: Handles billions of messages with Postgres at its core.
Notion: Powers its entire product with Postgres.

These companies aren’t stuck in 2005—they’re leveraging Postgres’s modern capabilities to build robust, scalable systems.

💪 Postgres: The Swiss Army Knife of Databases

Here’s how Postgres can replace your sprawling tech stack with a single, reliable solution.

1. Queues Done Right (Goodbye, RabbitMQ)

Why run a separate message queue service when Postgres can handle it?

## Simple job queue
CREATE TABLE job_queue (
    id SERIAL PRIMARY KEY,
    job_type VARCHAR(50),
    payload JSONB,
    status VARCHAR(20) DEFAULT 'pending',
    created_at TIMESTAMP DEFAULT NOW()
);

## Safe job processing with SKIP LOCKED
BEGIN;
UPDATE job_queue
SET status = 'processing'
WHERE id = (
    SELECT id FROM job_queue
    WHERE status = 'pending'
    ORDER BY created_at
    FOR UPDATE SKIP LOCKED
    LIMIT 1
)
RETURNING *;
COMMIT;

Why it’s great:

ACID-compliant queues ensure reliability.
No external services to manage.
Built-in retry mechanisms.

2. Key-Value Store (See Ya, Redis)
Need a fast key-value store? Postgres has you covered with JSONB.

## Key-value store setup
CREATE TABLE kv_store (
    key VARCHAR(255) PRIMARY KEY,
    value JSONB,
    expires_at TIMESTAMP
);

## Fast queries with GIN index
CREATE INDEX idx_kv_value ON kv_store USING GIN (value);

## Query nested JSON data
SELECT * FROM kv_store
WHERE value @> '{"user_id": 123}';

Why it works:

The @> operator unlocks powerful JSON queries.
GIN indexes make lookups blazing fast.
No need for a separate caching layer.

3. Full-Text Search (Who Needs Elasticsearch?)

Postgres’s full-text search is robust enough for most applications.

## Add search to any table
ALTER TABLE posts ADD COLUMN search_vector tsvector;

## Auto-update search vector
CREATE TRIGGER update_search_vector

BEFORE INSERT OR UPDATE ON posts
FOR EACH ROW EXECUTE FUNCTION tsvector_update_trigger(
    search_vector, 'pg_catalog.english', title, content
);

## Ranked search results
SELECT title, ts_rank(search_vector, query) as rank
FROM posts, to_tsquery('startup & postgres') query
WHERE search_vector @@ query
ORDER BY rank DESC;

What you get:

Stemming and fuzzy matching.
Relevance ranking out of the box.
No external search service required.

4. Real-Time Updates (No WebSockets Needed)

Postgres can notify your app of changes in real time.

## Trigger for real-time notifications
CREATE OR REPLACE FUNCTION notify_changes()
RETURNS trigger AS $$
BEGIN
    PERFORM pg_notify('table_updates',
        json_build_object(
            'table', TG_TABLE_NAME,
            'action', TG_OP,
            'data', row_to_json(NEW)
        )::text
    );
    RETURN NEW;
END;
$$ LANGUAGE plpgsql;

## Attach trigger to a table

CREATE TRIGGER table_changes
AFTER INSERT OR UPDATE OR DELETE ON your_table
FOR EACH ROW EXECUTE FUNCTION notify_changes();

Why it’s awesome:

Real-time updates without a separate pub/sub system.
Seamless integration with your app’s existing database connection.

💸 The Hidden Costs of Overengineering

A “modern” stack often comes with a steep price tag:

Service--------------- Monthly Cost Redis------------------- $20 Message Queue----------- $25 Search Service---------- $50 Monitoring ------------- $30 Total ------------------ $125

But the real pain isn’t just the bill—it’s the operational overhead:

Maintenance: Monitoring multiple services with different scaling needs.
Complexity: Coordinating deployments and ensuring data consistency.
Debugging: Wrestling with failure modes across systems.
Testing: Writing tests for a fragmented stack.

📈 When Do You Actually Need Specialized Tools?

Hold off on adding new tools until you’re dealing with:

100,000+ jobs per minute.
Sub-millisecond cache requirements.
Terabytes of analytics data.
Millions of concurrent users.
Global distribution challenges.
For most apps, these are far-off problems. Postgres can carry you a long way before you hit these limits.

🛠 The Practical Path Forward

Here’s how to keep it simple:

Start with Postgres: Resist the urge to add other databases.
Leverage JSONB: Get schemaless flexibility without sacrificing reliability.
Use SKIP LOCKED for Queues: It’s a game-changer for background jobs.
Add Tools Sparingly: Only introduce new services when you have clear, data-driven reasons.

🤯 The Uncomfortable Truth

Postgres is so powerful that it renders most other databases unnecessary for 90% of applications. The tech world has sold us on the idea that we need specialized tools for every task, but often, we’re just making life harder for ourselves.

Your app’s job is to solve problems—not to flex your distributed systems skills. Next time someone suggests adding Redis for caching or Elasticsearch for search, ask: “Can we do this in Postgres first?”

You might be amazed at what you can achieve with one database.

Let’s Connect!

🚀 Enjoyed learning about transactions or exploring backend development?

📚 I share similar blogs, tutorials, and insights regularly.

👨‍💻 Follow My GitHub!

✨ Explore my open-source projects and dive into real-world examples.

🔗 Check out my GitHub: RutvikMakvana4

💼 Connect on LinkedIn!

🤝 Expand your network and stay updated with modern web development trends, career advice, and project highlights.

🔗 Connect with me on LinkedIn: Rutvik Makvana

🐦 Follow Me on X!

📣 Get real-time updates on my latest blogs, tech tips, and development insights.

🔗 Follow me on X: @RutvikMakvana0

Follow My Journey!

Stay tuned for more blogs and insights on backend development, MongoDB, and Node.js.

If you found this helpful:

Leave a Like or Comment! Share your thoughts and questions.
Share it! Help others discover tips and tricks in backend development.

Let’s grow and learn together! Happy coding!🌟

How to Get API Keys for Google and Facebook Authentication ?

Rutvik Makvana — Fri, 07 Feb 2025 13:18:42 +0000

Learn how to obtain Google and Facebook API keys for seamless authentication in your web applications.

If you're building a web application and need to integrate Google or Facebook authentication, you’ll need API keys. These keys allow your app to interact with Google and Facebook’s authentication systems. In this guide, we’ll walk you through the steps to obtain these keys and optimize your setup for better performance and security.

Why Use Google and Facebook Authentication?

Integrating Google and Facebook authentication into your app offers several benefits:
Improved User Experience: Users can log in quickly without creating new accounts.
Enhanced Security: Leverage Google and Facebook’s robust security measures.
Access to User Data: With user consent, you can access profile information to personalize their experience.

For Google API Key:

Go to the Google Cloud Console and sign in with your Google account.
Create a new project, or select an existing project.
Go to the API Library and enable the “Google Identity Platform” API.
From the left-hand menu, select “Credentials” and click the “Create Credentials” button.
Select “OAuth client ID” from the dropdown menu.
Choose the application type you want to create credentials for. In this case, choose “Web application”.
Enter the authorized JavaScript origins and redirect URIs for your application.
For the authorized JavaScript origins, enter the domain name where your application is hosted.
For the redirect URIs, enter the URL that Google should redirect users to after they have authenticated with Google.
Click “Create”.
Copy the “Client ID” and “Client Secret” values that are generated.
Use these values in your application’s code to enable Google Sign-In.

You can get your keys from this link: https://developers.google.com/identity/gsi/web/guides/get-google-api-clientid

For Facebook API Key:

Go to the Facebook Developers website and sign in with your Facebook account.
Create a new app by going to the “My Apps” dashboard and selecting “Create App”.
Choose the app type that corresponds to your use case (e.g., website, iOS app, Android app, etc.).
Configure your app settings, including the name, category, and contact information.
Go to the “Dashboard” tab and copy your App ID and App Secret.
Use your App ID and App Secret to authenticate your app and access the Facebook APIs.

You can get your keys with this link: https://developers.facebook.com/docs/development/create-an-app

Conclusion

Obtaining Google and Facebook API keys is a straightforward process that unlocks powerful authentication capabilities for your web application. By following the steps outlined above, you can seamlessly integrate these services and enhance your app’s functionality.

Don’t forget to implement best practices to keep your keys secure and optimize your app’s performance. Happy coding!

Backend Stack 2025

Rutvik Makvana — Fri, 10 Jan 2025 06:03:41 +0000

The Modern Backend Tech Stack for Building the Future: Node.js continues to be a cornerstone for backend development in 2025, evolving to meet the demands of modern applications. A robust tech stack can significantly enhance your development experience and project scalability, whether you're building APIs, microservices, or full-stack apps. Here's a comprehensive guide to the modern Node.js stack to help you stay ahead.

Core: Node.js + TypeScript

TypeScript has become a must-have for Node.js development. Its static typing reduces runtime errors, enhances IDE support, and simplifies refactoring. Pairing TypeScript with Node.js ensures type safety, making codebases easier to maintain and scale.

With Node.js 20's support for native ES modules and new runtime features, now is the time to leverage these capabilities for modern backend development.

Framework: Fastify

Fastify has emerged as the go-to framework for Node.js in 2025. Known for its speed and extensibility, Fastify simplifies the development of high-performance APIs. It supports TypeScript out of the box and has a rich plugin ecosystem for features like authentication, validation, and logging.

While Express.js is still relevant, Fastify's focus on performance and developer experience makes it a strong choice for modern projects.

Database: Prisma + PlanetScale/Supabase

Prisma: A next-generation ORM, Prisma offers type-safe database interactions and a rich developer experience. Its schema-first approach ensures your database and code are always in sync.

PlanetScale: Built on Vitess, PlanetScale provides a serverless, horizontally scalable database solution. It’s ideal for applications requiring global reach and seamless scaling.

Supabase: If you need a backend-as-a-service (BaaS) solution, Supabase provides real-time capabilities, authentication, and edge functions, all integrated with a Postgres database.

API: GraphQL with Apollo Server/Helix

GraphQL continues to shine for its flexibility and efficiency.

Apollo Server: A popular choice for building production-ready GraphQL APIs. It’s feature-rich and has excellent community support.

GraphQL Helix: For those seeking a lightweight, modular alternative, GraphQL Helix offers flexibility without unnecessary bloat.

If REST is more suitable for your project, libraries like Fastify’s built-in route handling or @hapi/hapi can be used.

Authentication: Auth.js (formerly NextAuth.js)

Auth.js has expanded beyond Next.js to become a universal solution for handling authentication in any Node.js project. It supports multiple providers (OAuth, SAML, custom) and simplifies user authentication with minimal boilerplate.

For enterprise-grade security, consider solutions like Keycloak or Auth0.

Event-Driven Architecture: Kafka or NATS

As applications grow, event-driven architectures are becoming the norm.

Kafka: A distributed event-streaming platform ideal for high-throughput use cases.

NATS: Lightweight and faster to set up, perfect for microservices communication or pub/sub scenarios.

Job Queues: BullMQ

For background jobs and task scheduling, BullMQ is the leader in the Node.js ecosystem. It’s built on top of Redis and provides a reliable, scalable solution for handling delayed and recurring tasks.

Real-Time Communication: Socket.IO + tRPC

Socket.IO: For real-time communication, it remains a popular choice due to its ease of use and support for various transport protocols.

tRPC: A modern RPC framework for TypeScript, enabling type-safe communication between your client and server without the overhead of GraphQL.

Testing: Vitest + Supertest

Vitest: A blazing-fast test runner that integrates seamlessly with TypeScript and modern JavaScript.

Supertest: Essential for testing HTTP endpoints in your Node.js applications.

End-to-end testing can be achieved with tools like Playwright or Cypress, depending on your project’s requirements.

Logging: Pino

Pino remains the gold standard for logging in Node.js. It’s fast, lightweight, and works well with modern observability tools like Grafana Loki or Elasticsearch.

Observability: OpenTelemetry

OpenTelemetry has become the de facto standard for tracing, metrics, and logging. Integrate it with tools like Jaeger or Zipkin to monitor application performance and troubleshoot issues effectively.

Containerization: Docker + Kubernetes

Containerization is a staple in modern development. Docker simplifies packaging and deployment, while Kubernetes handles orchestration at scale. Tools like k9s and Lens streamline Kubernetes management.

Consider serverless platforms like AWS Lambda or Google Cloud Functions for smaller projects.

CI/CD: GitHub Actions + Docker Hub

Automated pipelines are essential for efficient development and deployment.

GitHub Actions: A versatile CI/CD solution with deep integration into your GitHub repositories.

Docker Hub: Use it to store and distribute your container images seamlessly.

Hosting: Fly.io + Vercel

Fly.io: Ideal for globally distributed applications with edge deployment capabilities.

Vercel: Perfect for full-stack applications, especially those using Next.js.

For APIs and microservices, AWS or Google Cloud Run offer robust hosting solutions.

Wrapping Up

This modern Node.js tech stack provides the tools and frameworks to build scalable, performant, and maintainable backend applications. Start with the essentials, experiment with the tools, and adopt what fits your project's specific needs. With this stack, you're well-equipped to tackle backend challenges and innovate in 2025 and beyond.

TypeScript Interview Questions

Rutvik Makvana — Fri, 03 Jan 2025 09:54:24 +0000

Question - What is TypeScript?

TypeScript is a superset of Javascript
Adds static types, allowing for improved code quality and error checking before runtime.
It supports features like interfaces, enums, generics, and more.
Provides better error checking, enhanced tools, and improved code readability.

Question - What is explicit and implicit type assignment?

Explicit means writing out the type. Like below -

let firstName: string = "Rutvik";

Implicit means TypeScript will guess the type, based on the value. The below type will be considered a number

let age = 23;

Question - Difference between any, unknown and never in TypeScript?

The type of any is used to assign any type of a variable.
It will not give error even if you reassign another type.

let x: any = 10;
x = 'hello'; // No TypeScript error
console.log(x.toUpperCase()); // No TypeScript error

The type unknown is better than type any, because it requires us checking the type before performing operations on value.

let y: unknown = 10;
// Type assertion needed before using y as number
if (typeof y === 'number') {
    console.log(y.toFixed(2));
}

The type never represents value that never occurs.
It is typically used for return statements of function that doesn’t returns properly.

function throwError(message: string): never {
    throw new Error(message);
}

Question - How do you give the type of Arrays?

For typing array, we need to give the type as below. In this below example the array can contain type of string only.

const names: string[] = ["Rutvik", "Rohit", "Virat"];
names.push("Bumrah"); // no error

We can also use a readonly keyword, which prevents the array been changed.

const names: readonly string[] = ["Rutvik", "Rohit", "Virat"];
names.push("Bumrah"); // Error: Property 'push' does not exist on type 'readonly string[]'.

Question - What is Type Inference in array?

If we don’t give any type to an array, it will infer the type automatically.

const numbers = [1, 2, 3]; // inferred to type number[]
numbers.push(4); // no error

Question - What are tuples?

It is a type array with pre-defined length and types.
It is very useful in giving types of mixed array with different types.

let ourTuple: [number, boolean, string];

// initialize correctly
ourTuple = [5, false, 'Coding Hero was here'];

Question - What are readonly tuples?

If we don’t make a tuple readonly, we can add more items to the one defined and TypeScript will not throw any error.

let ourTuple: [number, boolean, string];

// initialize correctly
ourTuple = [5, false, 'Coding Hero was here'];
//No safety in indexes from 3
ourTuple.push('This is wrong');

Now, to fix it we use the keyword readonly before the type.

let ourTuple: readonly [number, boolean, string];
// initialize correctly
ourTuple = [5, false, 'Coding Hero was here'];
// throws error as it is readonly
ourTuple.push('Coding Hero took a day off');

Question - How to give the types for Objects?

We can give the type of object by creating another object like structure and specifying the keys and the type of the keys in the object.

interface CarTypes {
    brand: string,
    model: string,
    year: number
}


const car: CarTypes = {
  brand: "Tata",
  model: "Punch",
  year: 2020
};

Question - How to have optional properties in Objects?

To give an optional property or key, we need to add the ? after thet key.

interface CarTypes {
    brand: string,
    model: string,
    year?: number
}

const car: CarTypes = {
  brand: "Tata",
  model: "Punch"
};

Question - Explain enum in TypeScript?

An enum is a type of variables which are constants. You have to use the values within it only.
The values are numeric by default and starts with 0 and increments by 1.
They can be numeric or string-based

enum Direction {
  Up = 1,
  Down,
  Left,
  Right,
}
console.log(Direction.Up); // 1
console.log(Direction.Down); // 2

enum Direction {
  Up = "Up",
  Down = "Down",
  Left = "Left",
  Right = "Right"
}
console.log(Direction.Up); // Up
console.log(Direction.Down); // Down

Question - What are Type Aliases?

They allow to define type with a custom name and can be used for all primitive types like string and number and also complex type like objects and arrays.

type CarTypes = {
   brand: string,
   model: string,
   year: number
}

const car: CarTypes = {
  brand: "Tata",
  model: "Punch",
  year: 2020
};

Question - What are interfaces?

Interfaces are like type but can be used only for objects.

interface Square {
   length: number
}

const square: Square {
  length: 20
}

Question - How to extend interfaces?

Interfaces can be extended with the extend keyword.

interface Square {
   length: number
}

interface ColorSquare extends Square {
    color: string
}

const square: ColorSquare {
  length: 20,
  color: blue
}

Question - What are Union and Intersection types?

Union :-

Union types are used when the property can be more then one value, like string or number.
For this reason they are also called OR and are used by using | symbol.

let id: string | number;
id = "ABC123";
id = 123;
// id = true; // Error: Type 'boolean' is not assignable to type 'string | number'.

Intersection :-

Intersesction types are used when combines multiple types into one.
For this reason they are also called AND and are used by using & symbol.

interface Person {
  name: string;
}

interface Employee {
  employeeId: number;
}

type Worker = Person & Employee;

const worker: Worker = {
  name: "Rutvik",
  employeeId: 12345,
}

Question - What are functions in Typescript ?

How to give the return type in function?

We can give the return types of functions with : symbol after function name.

function getSum(): number {
    return 24;
}

function printMessage(): void {
    console.log("Good Morning");
}

How to give type of parameters in function?

We can give the type of parameters by mentioning them after each parameter with : symbol.

function sum(a: number, b: number) {
  return a + b;
}

How to give optional, default and rest parameters in function?

With default parameter, we can mark a parameter as optional. Like this, where c is optional and denoted by ?.

function substract(a: number, b: number, c?: number) {
  return a - b -(c || 0);
}

The default values(an ES6 feature), goes after the type.

function multiply(a: number, b: number=10) {
  return a * b;
}

The rest parameters(an ES6 feature), are given the type of array, because they convert passed items in array.

function add(a: number, b: number, ...rest: number[]) {
  return a + b + rest.reduce((acc, curr) => acc+ curr, 0);
}

Question - What is casting in TypeScript?

Casting is the process of overriding a type of a variable.
Like in the below example, the type is unknown but is made string while using with the as keyword.

let y: unknown = 'Welcome';
console.log((y as string).length);

We can also use <> in place of as. Both means the same.

let y: unknown = 'Welcome';
console.log((<string>y).length);

Question - What are Generics in TypeScript ?

Generics in Typeascript allow you to create reusable components or dunctions that can work with multiple data types.

function logAndReturn(value : number | string) : number | string {
     return value;
}

const numberResult = logAndReturn(42);
const stringResult = logAndReturn("Hello");
const booleanResult = logAndReturn(true);

# Using Generics :-

function logAndReturn<T>(value : T) : T {
    return value;
}

Question - Utility Types in Typescript?

TypeScript provides Utility Types to simplify common type transformations.
These types make it easier to manipulate and interact with object and interface types.
Here’s a breakdown of some commonly used utility types:

1. Partial

Makes all properties of type T optional.
Use case: When you want to create an object where only some properties are required.

interface User {
  id: number;
  name: string;
  email: string;
}

const partialUser: Partial<User> = {
  name: "Rutvik",
};

2. Required

Makes all properties of type T required.
Use case: When you want to enforce that all properties must be present.

interface User {
  id?: number;
  name?: string;
}

const fullUser: Required<User> = {
  id: 1,
  name: "Rutvik",
};

3. Readonly

Makes all properties of type T read-only.
Use case: To ensure that an object’s properties cannot be modified.

interface User {
  id: number;
  name: string;
}

const readonlyUser: Readonly<User> = {
  id: 1,
  name: "Rutvik",
};

// readonlyUser.id = 2; // Error: Cannot assign to 'id' because it is a read-only property.

4. Pick

Creates a type by picking a set of properties K from type T.
Use case: When you need only specific properties from a type.

interface User {
  id: number;
  name: string;
  email: string;
}

type UserPreview = Pick<User, "id" | "name">;

const user: UserPreview = {
  id: 1,
  name: "Rutvik",
};

5. Omit

Creates a type by omitting a set of properties K from type T.
Use case: When you want all properties except specific ones.

interface User {
  id: number;
  name: string;
  email: string;
}

type UserWithoutEmail = Omit<User, "email">;

const user: UserWithoutEmail = {
  id: 1,
  name: "Rutvik",
};

6. Record

Constructs a type with keys K and values of type T.
Use case: To create an object type with fixed keys and consistent value types.

type Roles = "admin" | "user" | "guest";

const roleDescriptions: Record<Roles, string> = {
  admin: "Has full access",
  user: "Can view and edit own data",
  guest: "Can only view public data",
};

7. Exclude

Excludes from type T all types that are assignable to U.
Use case: To filter out specific types.

type AllRoles = "admin" | "user" | "guest";
type NonAdminRoles = Exclude<AllRoles, "admin">; // "user" | "guest"

8. Extract

Extracts from type T only types that are assignable to U.
Use case: To narrow down types to a specific subset.

type AllRoles = "admin" | "user" | "guest";
type AdminRole = Extract<AllRoles, "admin">; // "admin"

9. NonNullable

Excludes null and undefined from type T.
Use case: To ensure a value is neither null nor undefined.

type UserName = string | null | undefined;
type ValidUserName = NonNullable<UserName>; // string

10. ReturnType

Infers the return type of a function type.
Use case: To capture and use the return type of a function.

function getUser() {
  return { id: 1, name: "Rutvik" };
}

type UserType = ReturnType<typeof getUser>; // { id: number; name: string; }

11. InstanceType

Constructs a type consisting of the instance type of a constructor function type T.
Use case: To get the type of a class instance.

class User {
  id = 1;
  name = "Rutvik";
}


type UserInstance = InstanceType<typeof User>; // User

12. Parameters

Extracts the types of parameters of a function type.
Use case: To reuse the parameter types of a function.

function greet(name: string, age: number): void {}

type GreetParams = Parameters<typeof greet>; // [string, number]

Step-by-Step Guide to MongoDB Migrations Using Migrate-Mongo

Rutvik Makvana — Wed, 01 Jan 2025 12:32:19 +0000

In modern software development, managing database migrations is a critical aspect of maintaining and evolving your application. MongoDB, being a NoSQL database, provides flexibility, but it also requires structured processes for migrations, especially in production environments. This article dives into using the migrate-mongo package to manage MongoDB migrations efficiently within a Node.js and Express setup.

Types of Migrations :-

Up Migration:

This is the forward migration that applies changes to the database to achieve a desired state.
Examples include adding new fields, creating indexes, renaming collections, or transforming data.
It’s typically used to implement new features or adapt to updated application requirements.

Down Migration:

This is the rollback migration that undoes the changes made by the up migration.
Examples include removing fields, reverting indexes, or restoring data to its original format.
It’s useful for reverting the database to its previous state if something goes wrong.

Why Use Migrations in MongoDB?

Database migrations allow you to:

Modify the schema (e.g., add fields or collections) without disrupting existing data.
Track and version database changes.
Ensure a consistent database state across environments (development, staging, production).

The migrate-mongo package is a powerful tool for managing MongoDB migrations as it integrates seamlessly with Node.js applications.

Prerequisites

Before starting, make sure you have the following installed:

NodeJS
MongoDB
Important packages like express, dotenv, mongoose, migrate-mongo etc...

Setting Up the Project

Initialize a Node.js Project:

mkdir mongodb-migration
cd mongodb-migration
npm init -y

Install Required Packages:

npm install express mongoose migrate-mongo

Configure migrate-mongo: Initialize migrate-mongo with the following command:

npx migrate-mongo init

This creates a migrate-mongo-config.js file and a migrations directory.

Update the Configuration File: Modify migrate-mongo-config.js

import "dotenv/config";

module.exports = {
  mongodb: {
    url: `${process.env.MONGO_URL}`,
  },
  migrationsDir: "migrations",
  changelogCollectionName: "changelog",
  migrationFileExtension: ".js",
};

Writing a Migration

Generate a Migration File: Run the following command to create a new migration:

npx migrate-mongo create add-new-field

This generates a file in the migrations directory with the following structure:

Add Migration Logic:
Update the up and down methods to perform the migration.
Example: Adding isMigrate field in all the documents in User model.

import User from "../models/users";
import "../config/dbConnection";

module.exports = {
  async up(db, client) {
    await User.updateMany({}, { $set: { isMigrate: false } });
  },

  async down(db, client) {
    await User.updateMany({}, { $unset: { isMigrate: "" } });
  },
};

Running the Migration

Apply the Migration: Run the following command to execute the up method:

npx migrate-mongo up

Revert the Migration (Optional): If you need to roll back the changes, use:

npx migrate-mongo down

Best Practices

Version Control: Commit your migration files to version control to track changes.
Environment-Specific Configurations: Use environment variables to configure the database connection.
Test Migrations: Always test migrations in a staging environment before applying them to production.
Automate Migrations: Integrate migrations into your CI/CD pipeline for seamless deployment.

Conclusion

Managing database migrations is crucial for maintaining a robust and scalable application. The migrate-mongo package provides a structured and developer-friendly approach to MongoDB migrations. By following this guide, you can confidently handle schema changes and database updates in your Node.js and Express projects. To explore a fully working implementation of the concepts discussed, check out my GitHub repository for detailed examples and code.

Let’s Connect!

🚀 Enjoyed learning about transactions or exploring backend development?
📚 I share similar blogs, tutorials, and insights regularly.

👨‍💻 Follow My GitHub!

✨ Explore my open-source projects and dive into real-world examples.
🔗 Check out my GitHub :- [https://github.com/RutvikMakvana4]

💼 Connect on LinkedIn!

🤝 Expand your network and stay updated with modern web development trends, career advice, and project highlights.
🔗 Connect with me on LinkedIn :- [https://www.linkedin.com/in/rutvik-makvana-b619b3214/]

Follow My Journey!

Stay tuned for more blogs and insights on backend development, MongoDB, and Node.js.

If you found this helpful:

Leave a Like or Comment! Share your thoughts and questions.
Share it! Help others discover tips and tricks in backend development.

Let’s grow and learn together! Happy coding!🌟

Mastering Transactions in MongoDB: A Beginner’s Guide

Rutvik Makvana — Thu, 26 Dec 2024 12:35:45 +0000

Understanding Transactions in MongoDB

Transactions are an essential concept in database systems. They ensure that a series of operations either succeed entirely or fail completely—following the all-or-nothing rule. If something goes wrong during a transaction, all changes made are rolled back, leaving the database unchanged.

Why Are Transactions Important?

Transactions play a critical role in maintaining data consistency, especially in scenarios like:

E-commerce: Deducting stock and processing payment should either both succeed or fail to avoid mismatches.
Banking: Money transfers must ensure that the sender is debited only when the receiver is credited.
Event Booking: Both booking confirmation and payment processing need to happen together.

Without transactions, partial updates can lead to inconsistent or corrupted data.

How Do Transactions Work in MongoDB?

MongoDB ensures data integrity by adhering to the ACID principles:

Atomicity: All operations in a transaction either succeed or fail as one.
Consistency: The database state remains valid after a transaction.
Isolation: Transactions don’t interfere with one another.
Durability: Committed changes are permanently saved, even in the event of a failure.

Transaction Lifecycle in MongoDB Using Mongoose

Let’s break down the transaction process step-by-step:

Start a Session: Begin a session to start the transaction.
Perform Operations: Execute all necessary operations as part of the transaction.
Commit: If everything is successful, commit the transaction to save the changes.
Rollback (Abort): If any operation fails, abort the transaction to revert all changes.

Here’s how you can implement this in a Node.js application using Mongoose.

Step 1: Define Schemas

Product Schema

import mongoose from "mongoose";

const productSchema = new mongoose.Schema({
  name: { type: String },
  price: { type: Number },
  stock: { type: Number },
}, { timestamps: true });

const Product = mongoose.model("Product", productSchema);

export default Product;

Order Schema

import mongoose from "mongoose";

const orderSchema = new mongoose.Schema({
  userId: { type: mongoose.Schema.Types.ObjectId, ref: "User" },
  productId: { type: mongoose.Schema.Types.ObjectId, ref: "Product" },
  totalPrice: { type: Number },
}, { timestamps: true });

const Order = mongoose.model("Order", orderSchema);

export default Order;

Step 2: Implement Transaction Logic

import mongoose from "mongoose";
import Product from "./models/Product";
import Order from "./models/Order";

const createOrder = async (userId, productId, quantity) => {
  const session = await mongoose.startSession();
  session.startTransaction();

  try {
    // Fetch the product
    const product = await Product.findById(productId).session(session);
    if (!product) throw new Error("Product not found");

    // Check stock availability
    if (product.stock < quantity) throw new Error("Insufficient stock");

    // Calculate total price
    const totalPrice = product.price * quantity;

    // Create the order
    const order = new Order({ userId, productId, totalPrice });
    await order.save({ session });

    // Update product stock
    product.stock -= quantity;
    await product.save({ session });

    // Commit transaction
    await session.commitTransaction();
    session.endSession();

    console.log("Order created successfully:", order);
    return order;
  } catch (error) {
    // Rollback transaction
    await session.abortTransaction();
    session.endSession();
    console.error("Transaction failed:", error.message);
    throw error;
  }
};

Key Takeaways

Session Handling: The session is started with mongoose.startSession() and passed to both the findById, save, and update operations to ensure they are all part of the same transaction.
Error Handling: If any part of the transaction fails (e.g., insufficient stock or product not found), the entire transaction will be rolled back, and no changes will be saved to the database.
Atomic Operations: By using transactions, you ensure that both the creation of the order and the stock update happen atomically. This prevents partial updates, where the order might be created without reducing stock, or vice versa.
MongoDB Replica Set Requirement: Transactions require MongoDB to be running as a replica set, even in single-node deployments, so ensure your MongoDB is set up correctly for transactions.

Let’s Connect!

🚀 Enjoyed learning about transactions or exploring backend development?
📚 I share similar blogs, tutorials, and insights regularly.

👨‍💻 Follow My GitHub!

✨ Explore my open-source projects and dive into real-world examples.
🔗 Check out my GitHub :- [https://github.com/RutvikMakvana4]

💼 Connect on LinkedIn!

Follow My Journey!

Stay tuned for more blogs and insights on backend development, MongoDB, and Node.js.

If you found this helpful:

Leave a Like or Comment! Share your thoughts and questions.
Share it! Help others discover tips and tricks in backend development.

Let’s grow and learn together! Happy coding!🌟

15 JavaScript Tricks Every Developer Must Know 🚀

Rutvik Makvana — Wed, 18 Dec 2024 06:04:11 +0000

1. Destructure and Rename in One Step

Rename variables during object destructuring to avoid naming conflicts:

const user = { name: 'Rutvik', age: 22 };
const { name: userName, age: userAge } = user;
console.log(userName); // Rutvik
console.log(userAge);  // 22

2. Optional Chaining with Function Calls

Ensure a function exists before calling it:

const user = {
  getName: () => 'Rutvik',
};
console.log(user.getName?.());   // Rutvik
console.log(user.getAge?.());    // undefined

3. Use ||= Operator for Default Assignment

Assign a default value only if the variable is null, undefined, or falsey:

let count;
count ||= 10;
console.log(count); // 10

4. Convert NodeList to Array Using Spread Operator

Quickly convert a NodeList to an array:

const divs = document.querySelectorAll('div');
const divArray = [...divs];
console.log(Array.isArray(divArray)); // true

5. Array/Object Destructuring with Default Values

Avoid undefined by assigning default values during destructuring:

const user = { name: 'Rutvik' };
const { name, age = 22 } = user;
console.log(age); // 22

6. Remove Falsy Values from an Array

Filter out falsy values like 0, null, or undefined:

const arr = [0, 'hello', null, 42, false, 'world'];
const filtered = arr.filter(Boolean);
console.log(filtered); // ["hello", 42, "world"]

7. Sorting Arrays of Objects by Property

Sort objects by a specific property:

const users = [{ name: 'Rohit', age: 38 }, { name: 'Virat', age: 36 }];
users.sort((a, b) => a.age - b.age);
console.log(users); // [{ name: 'Virat', age: 36 }, { name: 'Rohit', age: 38 }]

8. Default Parameters with Object Destructuring

Destructure and set default values in function parameters:

function createUser({ name = 'Rutvik', age = 22 } = {}) {
  console.log(name, age);
}
createUser();               // Rutvik 22
createUser({ name: 'Rohit' }); // Rohit 22

9. Use Object.assign() for Shallow Copying

Shallow-copy objects without affecting the original:

const original = { a: 1, b: 2 };
const copy = Object.assign({}, original);
copy.a = 3;
console.log(original.a); // 1 (unchanged)

10. Flatten Nested Arrays with Array.flat(Infinity)

Easily flatten deeply nested arrays:

const nested = [1, [2, [3, [4]]]];
console.log(nested.flat(Infinity)); // [1, 2, 3, 4]

11. Toggle Boolean Value with !

Toggle a boolean value:

let isVisible = false;
isVisible = !isVisible;
console.log(isVisible); // true

12. Merge Multiple Arrays with concat()

Merge arrays in a single step:

const arr1 = [1, 2];
const arr2 = [3, 4];
const arr3 = [5, 6];
const merged = arr1.concat(arr2, arr3);
console.log(merged); // [1, 2, 3, 4, 5, 6]

13. Get the Last Item in an Array Quickly

Retrieve the last item in an array:

const arr = [1, 2, 3, 4];
console.log(arr.at(-1)); // 4

14. Round Numbers with Math.round() and Template Literals

Format rounded numbers easily:

const num = 3.14159;
console.log(`${Math.round(num * 100) / 100}`); // 3.14

15. Convert Array-Like Objects to Arrays Using Array.from()

Turn array-like objects into arrays:

function example() {
  const argsArray = Array.from(arguments);
  console.log(argsArray);
}
example(1, 2, 3); // [1, 2, 3]

By incorporating these tricks into your coding practices, you can write efficient and expressive JavaScript. Which trick did you find most helpful? Let me know in the comments below!

Happy coding! 🚀

🎯 Follow me on GitHub: RutvikMakvana4

Deploying a Node.js Application on AWS EC2 Using Tabby SSH Client

Rutvik Makvana — Sat, 14 Dec 2024 11:20:32 +0000

Deploying a Node.js application on an AWS EC2 instance is a crucial skill for backend developers. This guide walks you through deploying your Node.js application using the Tabby SSH Client. Let’s get started!

Prerequisites

1. AWS EC2 Instance

Ensure your EC2 instance is launched with the following:
- Security Group allowing:
  - SSH (port 22)
  - HTTP (port 80)
  - HTTPS (port 443)

2. Tabby SSH Client

Installed and configured on your local machine.
Your private key for EC2 access added to Tabby.

3. Dependencies

Node.js application code hosted on a Git repository.
Optional: A domain name for production HTTPS setup.

Step-by-Step Deployment

Step 1: Connect to the EC2 Instance

Launch the Tabby SSH Client.
Connect to the EC2 instance using:
- Public IP address
- Private key associated with the instance.

Step 2: Install Required Dependencies on EC2

Once connected, update the system and install necessary packages.

Update System Packages

sudo apt update && sudo apt upgrade -y

Install Node.js and npm

curl -fsSL https://deb.nodesource.com/setup_18.x | sudo -E bash -
sudo apt install -y nodejs

Install Git

sudo apt install git -y

Install PM2 (Optional, for Production Management)

sudo npm install -g pm2

Step 3: Clone Your Node.js Repository

Navigate to your desired directory (e.g., /var/www):

cd /var/www

Clone the repository:

git clone <your-repo-url> app-name
cd app-name

Step 4: Set Up the Application

Install Node.js Dependencies

npm install

Configure Environment Variables

Create an .env file:

touch .env

Open the file in a text editor to add your environment variables:

nano .env

Save and exit the editor.

Step 5: Start the Application

Run the Application

npm run start

Or Use PM2 for Process Management

pm2 start app.js  # Replace 'app.js' with your main application file

Step 6: Access the Application

Open a browser and navigate to:

http://<your-ec2-public-ip>:<port>

Example:

http://13.60.229.203:5001/

You should see your application running.

Next Steps

Optional Enhancements

Domain Setup: Point your domain to the EC2 public IP using DNS records.
SSL with Let’s Encrypt: Use Certbot to enable HTTPS.
Load Balancing: Add AWS Elastic Load Balancer for scaling.

Conclusion

Congratulations! You’ve successfully deployed a Node.js application on an AWS EC2 instance using Tabby SSH Client. This setup ensures a reliable and scalable environment for your application.

Share your experiences or ask questions in the comments below. Happy coding!

Hello Dev.to, I'm Rutvik Makvana

Rutvik Makvana — Fri, 22 Apr 2022 11:46:26 +0000