DEV Community: Mohin Sheikh

Building a Complete CI/CD Pipeline for Node.js TypeScript Project, A Step-by-Step Guide

Mohin Sheikh — Tue, 24 Mar 2026 16:28:22 +0000

Introduction

When I first started learning about CI/CD pipelines, I was overwhelmed by all the moving parts. GitHub Actions, Docker, testing, linting it seemed like a lot to grasp. After spending weeks figuring it all out, I decided to document my journey so others don't have to go through the same confusion.

In this guide, I'll walk you through building a production-ready Node.js TypeScript application with a complete CI/CD pipeline. We'll start from absolutely nothing and end with a fully automated system that tests, builds, and deploys your code automatically.

By the end of this tutorial, you'll have

A Node.js TypeScript project with proper configuration
Automated testing with Jest
Code quality tools (ESLint and Prettier)
Git hooks to catch issues before commits
A GitHub Actions pipeline that runs on every push
Docker containerization
Automatic Docker image publishing

Prerequisites

Before we start, make sure you have

Node.js installed (version 18 or higher)
Git installed
A GitHub account
Basic knowledge of JavaScript/TypeScript
A code editor (VS Code recommended)

Step 1 - Setting Up Your Project

Let's start by creating a new Node.js project and adding TypeScript.

Open your terminal and run these commands:

mkdir node-ts-cicd-demo
cd node-ts-cicd-demo
npm init -y

This creates a basic package.json file. Now, let's install TypeScript and the necessary types:

npm install --save-dev typescript @types/node ts-node nodemon

Create a tsconfig.json file in the root directory:

{
  "compilerOptions": {
    "target": "ES2022",
    "module": "commonjs",
    "lib": ["ES2022"],
    "outDir": "./dist",
    "rootDir": "./src",
    "strict": true,
    "esModuleInterop": true,
    "skipLibCheck": true,
    "forceConsistentCasingInFileNames": true,
    "resolveJsonModule": true,
    "declaration": true,
    "declarationMap": true,
    "sourceMap": true,
    "moduleResolution": "node"
  },
  "include": ["src/**/*"],
  "exclude": ["node_modules", "dist", "**/*.test.ts"]
}

This configuration tells TypeScript how to compile our code. We're targeting ES2022 and using CommonJS modules, which works well with Node.js.

Step 2 - Installing Express and Building a Simple API

Let's install Express to create a simple REST API

npm install express
npm install --save-dev @types/express

Now create a src folder and add our application files. Create src/app.ts

import express, { Application, Request, Response, NextFunction } from 'express';

const app: Application = express();

app.use(express.json());

app.get('/health', (_req: Request, res: Response) => {
  res.json({ 
    status: 'OK', 
    timestamp: new Date().toISOString(),
    environment: process.env.NODE_ENV || 'development'
  });
});

app.get('/', (_req: Request, res: Response) => {
  res.json({ message: 'Welcome to Node.js TypeScript CI/CD Demo API' });
});

app.get('/api/users', (req: Request, res: Response) => {
  const { limit } = req.query;
  let users = [
    { id: 1, name: 'John Doe', email: 'john@example.com' },
    { id: 2, name: 'Jane Smith', email: 'jane@example.com' },
  ];

  if (limit && !isNaN(Number(limit))) {
    users = users.slice(0, Number(limit));
  }

  res.json({ users });
});

app.use((err: Error, _req: Request, res: Response, _next: NextFunction) => {
  console.error(err.stack);
  res.status(500).json({ error: 'Something went wrong!' });
});

export default app;

Create src/server.ts to start the server

import app from './app';

const PORT = process.env.PORT || 3000;

app.listen(PORT, () => {
  console.log(`Server is running on port ${PORT}`);
});

Add these scripts to your package.json:

{
  "scripts": {
    "start": "node dist/server.js",
    "dev": "nodemon --exec ts-node src/server.ts",
    "build": "tsc"
  }
}

Test your setup by running npm run dev and visiting http://localhost:3000.

Step 3 - Adding Testing with Jest

Testing is crucial for maintaining code quality. Let's set up Jest

npm install --save-dev jest @types/jest ts-jest supertest @types/supertest

Create jest.config.js

module.exports = {
  preset: 'ts-jest',
  testEnvironment: 'node',
  roots: ['<rootDir>/src'],
  testMatch: ['**/__tests__/**/*.ts', '**/?(*.)+(spec|test).ts'],
  collectCoverageFrom: [
    'src/**/*.ts',
    '!src/**/*.d.ts',
    '!src/**/__tests__/**',
    '!src/server.ts',
  ],
  coverageThreshold: {
    global: {
      functions: 70,
      lines: 70,
      statements: 70
    }
  },
  coverageReporters: ['text', 'lcov', 'html'],
};

Now create a test file at src/__tests__/app.test.ts

import request from 'supertest';
import app from '../app';

describe('App Tests', () => {
  describe('GET /health', () => {
    it('should return health status', async () => {
      const response = await request(app)
        .get('/health')
        .expect('Content-Type', /json/)
        .expect(200);

      expect(response.body).toHaveProperty('status', 'OK');
      expect(response.body).toHaveProperty('timestamp');
    });
  });

  describe('GET /', () => {
    it('should return welcome message', async () => {
      const response = await request(app)
        .get('/')
        .expect('Content-Type', /json/)
        .expect(200);

      expect(response.body).toHaveProperty(
        'message',
        'Welcome to Node.js TypeScript CI/CD Demo API'
      );
    });
  });

  describe('GET /api/users', () => {
    it('should return list of users', async () => {
      const response = await request(app)
        .get('/api/users')
        .expect('Content-Type', /json/)
        .expect(200);

      expect(response.body).toHaveProperty('users');
      expect(response.body.users).toHaveLength(2);
      expect(response.body.users[0]).toHaveProperty('name', 'John Doe');
    });
  });

  describe('Error Handling', () => {
    it('should handle 404 routes', async () => {
      await request(app)
        .get('/non-existent-route')
        .expect(404);
    });
  });
});

Add test scripts to package.json

{
  "scripts": {
    "test": "jest",
    "test:watch": "jest --watch",
    "test:coverage": "jest --coverage"
  }
}

Run npm test to verify everything works.

Step 4 - Code Quality with ESLint and Prettier

Consistent code formatting makes your codebase easier to maintain. Let's set up ESLint and Prettier:

npm install --save-dev eslint prettier @typescript-eslint/parser @typescript-eslint/eslint-plugin

Create .eslintrc.json

{
  "parser": "@typescript-eslint/parser",
  "extends": [
    "eslint:recommended",
    "plugin:@typescript-eslint/recommended"
  ],
  "parserOptions": {
    "ecmaVersion": 2020,
    "sourceType": "module"
  },
  "env": {
    "node": true,
    "jest": true
  },
  "rules": {
    "no-console": "off",
    "@typescript-eslint/no-unused-vars": ["error", { 
      "argsIgnorePattern": "^_",
      "varsIgnorePattern": "^_" 
    }],
    "@typescript-eslint/explicit-function-return-type": "off",
    "@typescript-eslint/no-explicit-any": "warn"
  }
}

Create .prettierrc

{
  "semi": true,
  "trailingComma": "es5",
  "singleQuote": true,
  "printWidth": 100,
  "tabWidth": 2
}

Create .prettierignore

node_modules
dist
coverage
*.log
.env

Add formatting scripts to package.json

{
  "scripts": {
    "lint": "eslint \"src/**/*.{js,ts}\"",
    "lint:fix": "eslint \"src/**/*.{js,ts}\" --fix",
    "format": "prettier --write \"src/**/*.{js,ts,json}\"",
    "format:check": "prettier --check \"src/**/*.{js,ts,json}\""
  }
}

Run npm run lint and npm run format to see them in action.

Step 5 - Adding Git Hooks with Husky

We want to catch issues before they get committed. Let's add pre-commit hooks

npm install --save-dev husky lint-staged
npx husky init

This creates a .husky folder with a pre-commit hook. Update the pre-commit file at .husky/pre-commit

npx lint-staged

Now add lint-staged configuration to package.json

{
  "lint-staged": {
    "src/**/*.{js,ts}": [
      "eslint --fix",
      "prettier --write"
    ],
    "src/**/*.json": [
      "prettier --write"
    ]
  }
}

Now every time you commit, it will automatically fix formatting and linting issues.

Step 6 - Creating Your GitHub Repository

Create a new repository on GitHub. Don't initialize it with a README or .gitignore. Then push your code:

git init
git add .
git commit -m "Initial commit"
git remote add origin https://github.com/yourusername/node-ts-cicd-demo.git
git branch -M main
git push -u origin main

Step 7 - Setting Up GitHub Actions

Create the workflow file at .github/workflows/ci-cd.yml

name: CI/CD Pipeline

on:
  push:
    branches: [ main, develop ]
  pull_request:
    branches: [ main ]

env:
  NODE_VERSION: '18'

jobs:
  build-and-test:
    name: Build and Test
    runs-on: ubuntu-latest

    steps:
    - name: Checkout code
      uses: actions/checkout@v4

    - name: Setup Node.js
      uses: actions/setup-node@v4
      with:
        node-version: ${{ env.NODE_VERSION }}
        cache: 'npm'

    - name: Install dependencies
      run: npm ci

    - name: Check formatting
      run: npm run format:check

    - name: Lint code
      run: npm run lint

    - name: Build project
      run: npm run build

    - name: Run tests with coverage
      run: npm run test:coverage

  security-scan:
    name: Security Scan
    runs-on: ubuntu-latest
    needs: build-and-test

    steps:
    - name: Checkout code
      uses: actions/checkout@v4

    - name: Install dependencies
      run: npm ci

    - name: Run npm audit
      run: npm audit --audit-level=moderate || true
      continue-on-error: true

This workflow runs on every push and pull request. It checks formatting, runs linting, builds the project, and runs tests.

Step 8 - Docker Containerization

Create a Dockerfile

FROM node:18-alpine AS builder

WORKDIR /app

COPY package*.json ./
COPY tsconfig.json ./

RUN npm ci

COPY src ./src

RUN npm run build

FROM node:18-alpine

WORKDIR /app

COPY package*.json ./

RUN npm ci --omit=dev --ignore-scripts

COPY --from=builder /app/dist ./dist

RUN addgroup -g 1001 -S nodejs && \
    adduser -S nodejs -u 1001 -G nodejs && \
    chown -R nodejs:nodejs /app

USER nodejs

EXPOSE 3000

HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
  CMD node -e "require('http').get('http://localhost:3000/health', (r) => {r.statusCode === 200 ? process.exit(0) : process.exit(1)})"

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

Create .dockerignore

node_modules
npm-debug.log
.git
.gitignore
README.md
.env
coverage
.vscode
*.log

Test your Docker setup locally:

docker build -t node-ts-cicd-demo .
docker run -p 3000:3000 node-ts-cicd-demo

Step 9 - Adding Docker Build to CI/CD

To automatically build and push Docker images, we need to add Docker Hub credentials to GitHub.

First, create a Docker Hub account at hub.docker.com. Then generate a personal access token

Go to Docker Hub Settings
Click "Security" → "New Access Token"
Name it "cicd" and give it Read & Write permissions
Copy the token

Now add secrets to your GitHub repository:

Go to your repository Settings → Secrets and variables → Actions
Add DOCKER_USERNAME with your Docker Hub username
Add DOCKER_PASSWORD with your personal access token

Now update your workflow to include Docker build

  docker-build:
    name: Build and Push Docker Image
    runs-on: ubuntu-latest
    needs: build-and-test
    if: github.ref == 'refs/heads/main' && github.event_name == 'push'

    steps:
    - name: Checkout code
      uses: actions/checkout@v4

    - name: Set up Docker Buildx
      uses: docker/setup-buildx-action@v3

    - name: Log in to Docker Hub
      uses: docker/login-action@v3
      with:
        username: ${{ secrets.DOCKER_USERNAME }}
        password: ${{ secrets.DOCKER_PASSWORD }}

    - name: Build and push Docker image
      uses: docker/build-push-action@v5
      with:
        context: .
        push: true
        tags: |
          ${{ secrets.DOCKER_USERNAME }}/node-ts-cicd-demo:latest
          ${{ secrets.DOCKER_USERNAME }}/node-ts-cicd-demo:${{ github.sha }}
        cache-from: type=gha
        cache-to: type=gha,mode=max

Step 10 - Handling Common Issues

Throughout this process, I encountered several issues. Here's how to fix them:

ESLint Configuration Error

If you see "ESLint couldn't find a configuration file", make sure your .eslintrc.json is in the root directory and properly formatted.

TypeScript Version Warning

If you see warnings about TypeScript version, downgrade to a compatible version:

npm install --save-dev typescript@5.5.4

Jest Configuration Error

If Jest fails with "export default" error, change your jest.config.js to use CommonJS format:

module.exports = {
  // your config
};

Docker Build Failing with Husky

If Docker fails with "husky not found", add --ignore-scripts to your Dockerfile:

RUN npm ci --omit=dev --ignore-scripts

Docker Hub Authentication Failed

Make sure you're using a personal access token, not your password, and that it has Read & Write permissions.

Step 11 - Testing Your Complete Pipeline

After pushing your code to GitHub, your pipeline will automatically run. Here's what happens

On every push, the build-and-test job runs
It checks code formatting with Prettier
It runs ESLint to catch code issues
It builds the TypeScript code
It runs all tests and checks coverage
On the main branch, it builds a Docker image
It pushes the image to Docker Hub with tags

You can see the entire process in the Actions tab of your GitHub repository.

Step 12 - Deploying Your Application

Now that your Docker image is on Docker Hub, you can deploy it anywhere. Here's a simple way to run it:

docker pull yourusername/node-ts-cicd-demo:latest
docker run -d -p 3000:3000 yourusername/node-ts-cicd-demo:latest

Your application will be running on port 3000. Visit http://localhost:3000/health to see it working.

What We Built

Let's recap everything we accomplished

A TypeScript Node.js application with Express
Automated testing with Jest and Supertest
Code quality tools (ESLint and Prettier)
Git hooks to enforce quality before commits
A GitHub Actions workflow that runs on every push
Security scanning with npm audit
Docker containerization with a production-ready image
Automatic Docker image publishing to Docker Hub

Best Practices We Followed

Throughout this project, we incorporated several best practices:

Version Control - We used Git with meaningful commit messages and proper .gitignore files.

Code Quality - ESLint and Prettier ensure consistent code style and catch common issues.

Testing - We wrote tests for our API endpoints and set coverage thresholds.

Security - We ran security audits and used environment variables for secrets.

Containerization - We created a multi-stage Docker build for smaller, more secure images.

CI/CD - We automated everything so that every push triggers the entire pipeline.

Troubleshooting Guide

Here are solutions to common issues you might encounter

Docker Build Fails - Check your Dockerfile syntax and ensure all required files are present. Use docker build --no-cache to clear any cache issues.

Tests Fail in CI - Run tests locally first. If they pass locally but fail in CI, check for environment differences like line endings or file paths.

ESLint Errors - Run npm run lint:fix to automatically fix common issues. For remaining issues, check the rule documentation.

GitHub Actions Not Triggering - Ensure your workflow file is in the correct directory (.github/workflows/) and has the .yml extension.

Resources for Further Learning

To deepen your understanding, I recommend

TypeScript Handbook for advanced TypeScript features
Jest documentation for more testing patterns
GitHub Actions documentation for custom workflows
Docker best practices guide for optimizing images
ESLint rules documentation for customizing your setup

Project Repository

You can find the complete source code for this project on GitHub

Repository - nodejs-ci-cd-demo

Feel free to clone, fork, or reference it as you follow along with this tutorial.

Complete Project Folder Structure

After following all the steps, your project should have the following structure

nodejs-ci-cd-demo/
│
├── .github/
│   └── workflows/
│       └── ci-cd.yml                 # GitHub Actions CI/CD pipeline
│
├── src/
│   ├── __tests__/
│   │   ├── app.test.ts               # Unit tests for the application
│   │   ├── error-handling.test.ts    # Error handling tests
│   │   ├── logger.test.ts            # Logger utility tests
│   │   └── server.test.ts            # Server tests
│   ├── app.ts                        # Main Express application
│   ├── logger.ts                     # Logger utility
│   └── server.ts                     # Server entry point
│
├── .dockerignore                     # Files to exclude from Docker build
├── .eslintrc.json                    # ESLint configuration
├── .gitignore                        # Git ignore rules
├── .prettierignore                   # Prettier ignore rules
├── .prettierrc                       # Prettier configuration
├── Dockerfile                        # Docker multi-stage build configuration
├── jest.config.js                    # Jest testing configuration
├── package.json                      # Project dependencies and scripts
├── package-lock.json                 # Locked dependency versions
├── tsconfig.json                     # TypeScript compiler options
└── README.md                         # Project documentation

Key Files Explained

.github/workflows/ci-cd.yml - Contains the complete CI/CD pipeline with jobs for building, testing, security scanning, and Docker image publishing.

src/app.ts - The main Express application with API endpoints including health checks, welcome message, and user listing with query parameter support.

Dockerfile - Multi-stage build that compiles TypeScript in one stage and creates a lightweight production image in another.

jest.config.js - Jest configuration with coverage thresholds and test patterns.

tsconfig.json - TypeScript configuration using CommonJS modules for Node.js compatibility.

What's Next?

Now that you have a fully automated CI/CD pipeline, here are some ways to extend this project

Add end-to-end testing with Cypress or Playwright
Implement database integration with PostgreSQL or MongoDB
Add authentication using JWT or OAuth
Set up monitoring with Prometheus and Grafana
Deploy to cloud platforms like AWS ECS, Google Cloud Run, or Azure Container Instances
Add performance testing with Artillery or K6
Implement feature flags for gradual rollouts

Final Thoughts

Building a CI/CD pipeline is one of the most valuable skills a developer can learn. It transforms how you ship code, giving you confidence that every change is tested, validated, and ready for production. The setup we've built today is the same pattern used by companies of all sizes, from startups to large enterprises.

I hope this guide helped you understand not just the "how" but also the "why" behind each tool and configuration. Remember, the best way to learn is to build, break, and fix things. Don't be afraid to experiment with your pipeline, add new features, and make it your own.

If you found this guide helpful, please share it with others who might benefit. Feel free to leave a comment with any questions or suggestions for improvement. Happy coding!

I hope this guide helps you on your journey to building robust, production-ready applications. If you have questions or run into issues, feel free to refer back to this guide or explore the documentation of the tools we used.

Author: Mohin Sheikh

Follow me on GitHub for more insights and projects!

Master Node.js & Express.js: A Comprehensive Collection of Coding Challenges

Mohin Sheikh — Tue, 14 Oct 2025 16:56:52 +0000

Are you looking to level up your JavaScript and Node.js skills? Whether you're a beginner starting your coding journey or an experienced developer wanting to sharpen your backend skills, I've created a comprehensive collection of coding challenges that will take you from fundamentals to advanced concepts through practical, real-world exercises.

Why This Challenge Collection?

This isn't just another tutorial list - it's a structured learning path designed to build your skills progressively. Here's what makes it different:

Progressive Difficulty: Start with basics, end with advanced algorithms
Real-World Scenarios: E-commerce, blog APIs, inventory management
Complete Solutions: Every challenge includes detailed examples
Structured Learning: Numbered files guide your learning journey

What's New in the Collection?

JavaScript Fundamentals (3 Files)

01-basic-javascript-challenges.md

Core JavaScript concepts
Array and string manipulation
Object handling
25 beginner-friendly challenges

02-intermediate-javascript-challenges.md

Advanced array methods
Custom filter/map/reduce implementations
Complex object manipulation
Real-world data processing

03-advanced-javascript-challenges.md

Data structures (LRU Cache, BST, Graphs)
Algorithms (QuickSort, Dijkstra, Binary Search)
Functional programming patterns
Performance optimization

Node.js & Express.js (5 Files)

01-beginner-express-challenges.md

Express server setup and configuration
Basic routing with HTTP methods
URL parameters and query handling

02-express-middleware-challenges.md

Middleware implementation and chaining
Role-based access control
Error handling and validation

03-nodejs-data-manipulation-challenges.md

Data aggregation and transformation
Working with related datasets
Complex data structure handling

04-ecommerce-order-management-challenges.md

Complex data relationships
Customer analytics and reporting
Order processing systems

05-express-blog-api-challenges.md

RESTful API design principles
HTTP status code usage
Production-ready API development

Quick Start Guide

Prerequisites

Node.js (v14 or higher)
Basic JavaScript knowledge
Code editor (VS Code recommended)

Setup in 2 Minutes

# Clone the repository
git clone https://github.com/mohin-sheikh/js-node-coding-questions.git
cd js-node-coding-questions

# Initialize your project
npm init -y
npm install express

# Create server file
touch index.js

Basic Server Template

const express = require('express');
const app = express();
const PORT = 3000;

app.use(express.json());

// Your routes go here

app.listen(PORT, () => {
  console.log(`Server running on http://localhost:${PORT}`);
});

Structured Learning Path

Phase 1: JavaScript Foundation (3-4 weeks)

Start with basic JavaScript challenges to build solid fundamentals before moving to backend development.

Phase 2: Backend Development (8-10 weeks)

Progress through Express.js basics, middleware, data manipulation, and real-world applications.

Phase 3: Mastery (4-6 weeks)

Tackle advanced algorithms, data structures, and complex system design.

Real Projects You'll Build

E-commerce Analytics System: Process orders, calculate revenue, analyze customer behavior
Blog API with Comments: Full CRUD operations, search, pagination
Inventory Management: Track stock, generate reports, handle low inventory
Financial Analytics: Transaction processing, category-wise spending reports
Employee Management System: Department analytics, skill gap analysis

Testing Your Solutions

Use these tools to verify your work:

# Test JavaScript functions
node -e "console.log(require('./your-solution.js').yourFunction())"

# Test API endpoints
curl http://localhost:3000/api/posts

# Test with authentication
curl -H "Authorization: Bearer token" http://localhost:3000/api/users

Key Skills You'll Master

Technical Skills

Express.js routing and middleware
RESTful API design and development
Data structures and algorithms
Error handling and validation
Performance optimization

Problem-Solving Skills

Breaking down complex problems
Algorithmic thinking
System design principles
Code optimization techniques

Success Stories from Learners

"The progressive structure helped me go from JavaScript basics to building full APIs in 2 months!" - Frontend Developer transitioning to Full Stack

"The real-world scenarios prepared me perfectly for technical interviews." - Recent Bootcamp Graduate

"Finally found a resource that covers everything from arrays to advanced algorithms!" - Self-Taught Developer

Pro Tips for Maximum Impact

Code Daily: Even 30 minutes daily beats 4 hours once a week
Understand Don't Memorize: Focus on the 'why' behind solutions
Build Projects: Apply concepts to personal projects
Review Regularly: Revisit previous challenges to reinforce learning
Join Community: Discuss solutions and learn from others

Get Started Today

Repository: github.com/mohin-sheikh/js-node-coding-questions

Your First Week Plan

Day 1-2: Complete basic JavaScript challenges
Day 3-4: Set up Express server and basic routes
Day 5-7: Build your first API endpoint

For Experienced Developers

Skip to intermediate/advanced challenges that match your current level and focus on gaps in your knowledge.

Continuous Updates

The repository is actively maintained with:

New challenges added regularly
Community contributions welcomed
Solutions improved based on feedback
Additional learning resources

Ready to Transform Your Skills?

This collection represents hundreds of hours of curated content designed to take you from wherever you are now to JavaScript and Node.js mastery.

Start today with the first challenge and commit to completing one challenge daily. In 2-3 months, you'll have the skills to build complex backend systems and ace technical interviews.

Share Your Journey

I'd love to see your progress! Share your solutions, ask questions, and connect with other learners through the repository's discussion section.

What's the biggest challenge you're facing in learning Node.js? Share in the comments below!

Follow me on GitHub for more learning resources and updates on new challenges!

JavaScript Learning Journey From Basics to Advanced

Mohin Sheikh — Thu, 09 Oct 2025 11:51:46 +0000

A comprehensive, structured roadmap to master JavaScript programming from fundamentals to advanced concepts. Designed specifically for beginners starting their web development career.

Repository Overview

This repository provides a carefully structured learning path that breaks down complex JavaScript concepts into digestible, practical lessons. Each module builds upon the previous one, ensuring a smooth learning curve with hands-on examples and real-world applications.

Structured Learning Path

Foundation Series (Start Here)

Module	Topic	Focus Areas
01	JavaScript Introduction	Setup, syntax, first program
02	Variables & Scope	let, const, var, scope chains
03	Data Types	Primitives, objects, type checking
04	Template Literals & Operators	String interpolation, operators
05	String Methods	String manipulation methods
06	Objects & CRUD	Object creation, manipulation
07	Shallow & Deep Copy	Reference vs value, cloning
08	Functions & Types	Function declarations, expressions
09	Arrays & Methods	Array manipulation, methods
10	Timing Events	setTimeout, setInterval
11	Callback Functions	Callback patterns, async basics
12	Promises Complete Guide	Promise chains, error handling
13	ES6+ Features	Modern JavaScript features
14	Constructors & Classes	Object-oriented programming
15	Closures Simple Guide	Understanding closures
16	For Loops Simple Guide	Loop structures and patterns
17	For...in & For...of Loops	Object and array iteration
18	Math Methods	Comprehensive guide to Math methods

Intermediate Series (Coming Soon)

DOM Manipulation
Event Handling
API Integration
Error Handling
Modules and Import/Export

Advanced Series (Coming Soon)

Async/Await
Design Patterns
Performance Optimization
Modern Frameworks Preparation

Key Features

Progressive Learning → Step-by-step progression from basic to advanced topics
Practical Examples → Real-world code examples with detailed explanations
Beginner Focused → No prior programming experience required
Hands-on Approach → Emphasis on writing code and experimentation
Comprehensive Coverage → From variables to advanced asynchronous programming

How to Use This Repository

Getting Started

Begin with Module 01 and progress sequentially through each topic
Type all code examples manually to build muscle memory
Experiment with modifying examples to test your understanding
Complete each module before moving to the next

Learning Methodology

Read the Theory → Understand the concept being explained
Code Along → Type every example in your development environment
Experiment → Modify parameters and observe changes
Practice → Solve additional problems using the same concepts
Review → Revisit previous topics to reinforce learning

Learning Principles

Core Principles

Consistency Over Intensity → Regular practice beats cramming
Build Foundations First → Master basics before advancing
Learn by Doing → Active coding trumps passive reading
Embrace Challenges → Struggle is part of the learning process

Study Tips

Code for at least 30 minutes daily
Keep a programming journal for notes and insights
Build small projects after each major section
Join coding communities for support and guidance
Don't hesitate to revisit previous topics when needed

Prerequisites

Basic computer literacy
Text editor (VS Code recommended)
Web browser
No prior programming experience required

Support Resources

All code examples are tested and working
Clear explanations for each concept
Progressive difficulty building
Practical application focus

Troubleshooting Guide

If stuck on a concept, take a break and return later
Google error messages for additional insights
Compare your code with provided examples
Practice the same concept with different examples
Remember that debugging is a valuable skill to develop

Career Path

This learning path prepares you for →

Frontend Developer roles
Full-stack JavaScript development
Modern framework learning (React, Vue, Angular)
Backend Node.js development
Technical interviews and coding assessments

Start your journey with Module 01: JavaScript Introduction and begin building your programming foundation today!

Author: Mohin Sheikh

Connect on GitHub for more learning resources and updates!

Repository: JavaScript Basics to Advanced

What is a POC (Proof of Concept) in Development? + A Beginner-Friendly Node.js Example

Mohin Sheikh — Wed, 21 May 2025 07:39:07 +0000

Introduction

When starting a new software project or implementing a new feature, you'll often hear the term POC or Proof of Concept. But what exactly is a POC in software development, and why is it important?

In this article, we’ll dive into:

What is a POC?
Why and when you should create one
Benefits of building a POC
A real-world example using Node.js that even beginners can understand!

What is a POC?

POC (Proof of Concept) is a small prototype or a minimal implementation of a feature or technology to test if something is technically feasible before investing full time and resources into building it.

It's not the final product. It’s a quick check: “Can we do this at all?”

Why Do Developers Create POCs?

To validate an idea or approach before building the full solution
To check if a technology or service fits into the project
To reduce the risk of failure or wasted time
To communicate feasibility to stakeholders, team members, or clients

Characteristics of a Good POC

Small and focused
No full UI/UX, just enough to prove it works
May use dummy data or hardcoded values
Doesn’t focus on optimization or scalability
Can be thrown away after it proves the concept

Real Example: Building a POC in Node.js

Scenario

Let’s say you want to test whether sending emails using Node.js and a package like Nodemailer is possible in your project.

Rather than building a full email feature with user accounts, password resets, etc., you decide to write a POC script that:

Sends a test email using Gmail
Confirms that the service works

Node.js POC: Send Email with Nodemailer

Step 1: Initialize the Project

mkdir email-poc
cd email-poc
npm init -y
npm install nodemailer dotenv

Step 2: Create `.env` file to store credentials

EMAIL_USER=your-email@gmail.com
EMAIL_PASS=your-app-password

Use App Passwords for Gmail if 2FA is enabled. Never use your real password.

Step 3: Create `sendEmail.js`

require('dotenv').config();
const nodemailer = require('nodemailer');

async function sendTestEmail() {
  try {
    const transporter = nodemailer.createTransport({
      service: 'gmail',
      auth: {
        user: process.env.EMAIL_USER,
        pass: process.env.EMAIL_PASS,
      },
    });

    const mailOptions = {
      from: process.env.EMAIL_USER,
      to: 'recipient@example.com',
      subject: 'POC Test Email',
      text: 'Hello! This is a test email from my Node.js POC.',
    };

    const info = await transporter.sendMail(mailOptions);
    console.log('✅ Email sent: ', info.response);
  } catch (error) {
    console.error('❌ Error sending email: ', error.message);
  }
}

sendTestEmail();

Step 4: Run the Script

node sendEmail.js

You should see a message like:

Email sent: 250 2.0.0 OK

If it works—congratulations! You just built a POC to prove you can send emails using Node.js and Nodemailer. 🎉

What Next?

Now that you’ve proven the concept works, you can:

Integrate email logic in a full backend project
Add templates, user emails, and dynamic content
Implement proper logging, error handling, and retries

Final Thoughts

A POC is not production code — it’s like a scientific experiment: just enough to test an idea.
Don’t overengineer it.
Once it works, you can throw it away or use it as a base for the final version.

Who Should Use POCs?

Beginners trying out a new package or technology
Startups testing product features
Developers working on unfamiliar tools
Teams exploring third-party integrations

Summary

Concept	Description
POC	Small prototype to test feasibility
Use Case	Test sending emails via Node.js
Tools Used	Nodemailer, dotenv, Gmail
Outcome	Validated that sending email is possible ✅

Have You Built a POC Before?

Let me know in the comments what POCs you've built or are thinking of building!

If this helped you, leave a ❤️ or 🦄!

Author: Mohin Sheikh

Follow me on GitHub for more insights!

Cron Jobs in Node.js: A Complete Guide for Backend Developers

Mohin Sheikh — Wed, 21 May 2025 07:22:12 +0000

What Are Cron Jobs in Node.js?
Approaches to Cron Jobs in Node.js
Using System-Level Cron Jobs
Using node-cron npm Package
Advanced: Job Scheduling with agenda
Common Use Cases
Troubleshooting
Best Practices

1. What Are Cron Jobs in Node.js?

Cron jobs let you execute functions or scripts at specific intervals (e.g., every minute, hourly, daily). In Node.js, you can:

Use system-level cron (via crontab).
Use in-process schedulers (npm packages like node-cron or agenda).

2. Approaches to Cron Jobs in Node.js

Method	Pros	Cons
System Cron	Simple, OS-managed, survives app crashes	Requires shell access, harder to debug
`node-cron`	Easy in-app scheduling, JS syntax	Tied to app lifecycle (stops if app crashes)
`agenda`	Persistent jobs, retries, MongoDB support	Requires MongoDB, more complex setup

3. Using System-Level Cron Jobs

Step 1: Create a Node.js Script

// scripts/cleanup.js
console.log('Cleaning up database at', new Date().toISOString());
// Add your logic here

Step 2: Make the Script Executable

chmod +x scripts/cleanup.js

Step 3: Schedule with Crontab

Edit your crontab:

crontab -e

Add a job (use the full path to Node.js and your script):

# Run every day at 2:30 AM
30 2 * * * /usr/local/bin/node /home/user/app/scripts/cleanup.js >> /var/log/cron.log 2>&1

Key Notes:

Find your Node.js path with which node (e.g., /usr/local/bin/node).
Use absolute paths for scripts and output files.
Log output to debug issues (>> /var/log/cron.log 2>&1).

4. Using `node-cron` npm Package

Ideal for in-app scheduling without relying on system cron.

Installation

npm install node-cron

Basic Usage

const cron = require('node-cron');

// Run every minute
cron.schedule('* * * * *', () => {
  console.log('Running task every minute:', new Date().toISOString());
});

Advanced Example (with Timezone)

const cron = require('node-cron');

// Run daily at 8:00 AM in Europe/London timezone
cron.schedule('0 8 * * *', () => {
  console.log('Sending morning report...');
}, {
  scheduled: true,
  timezone: 'Europe/London'
});

Schedule Syntax Cheatsheet

Pattern	Description
`/5 * * *`	Every 5 minutes
`0 9 * * 1-5`	Weekdays at 9:00 AM
`0 0 1 * *`	First day of the month at midnight

5. Advanced: Job Scheduling with `agenda`

For persistent, retriable jobs (requires MongoDB).

Installation

npm install agenda

Setup

const Agenda = require('agenda');
const agenda = new Agenda({ db: { address: 'mongodb://localhost:27017/agenda' } });

// Define a job
agenda.define('send-email', async (job) => {
  const { userId } = job.attrs.data;
  console.log(`Sending email to user ${userId}`);
  // Add your email logic here
});

// Schedule job to run every 2 hours
agenda.every('2 hours', 'send-email', { userId: 123 });

// Start agenda
(async () => {
  await agenda.start();
})();

Key Features:

Persistent jobs: Survive app restarts.
Retries: Automatically retry failed jobs.
Flexible scheduling: Use cron syntax or human-readable intervals.

6. Common Use Cases

1. Database Cleanup (Expired Tokens)

// Using node-cron
cron.schedule('0 0 * * *', async () => {
  await Token.deleteMany({ expiresAt: { $lt: new Date() } });
});

2. Send Daily Reports via Email

// Using agenda
agenda.define('daily-report', async () => {
  const users = await User.find({ wantsReport: true });
  users.forEach(user => sendEmail(user.email, 'Your daily report!'));
});

agenda.every('0 9 * * *', 'daily-report');

3. Cache Invalidation

// Every 10 minutes
cron.schedule('*/10 * * * *', () => {
  cache.clearExpired();
});

4. Poll External APIs

// Poll every 5 minutes
cron.schedule('*/5 * * * *', async () => {
  const data = await fetch('https://api.example.com/data');
  await processData(data);
});

7. Troubleshooting

Common Issues & Fixes:

Cron job not running:
- Check if the Node process is running (for node-cron/agenda).
- For system cron, check logs: grep CRON /var/log/syslog.
Module not found:
- Use absolute paths in scripts.
- Install dependencies globally if needed (not recommended).
Permissions issues:
- Ensure the cron user has execute access: chmod +x your-script.js.
Timezone mismatches:
- Use the timezone option in node-cron or set TZ in your OS.

Debugging Tips:

Log everything:

  cron.schedule('* * * * *', () => {
    console.log('Cron job started at', new Date());
    try {
      // Your logic here
    } catch (err) {
      console.error('Cron job failed:', err);
    }
  });

Test with shorter intervals first (e.g., every minute).

8. Best Practices

1. Use Task Queues for Heavy Work

Offload CPU-heavy tasks to worker threads:

const { Worker } = require('worker_threads');

cron.schedule('0 * * * *', () => {
  const worker = new Worker('./path/to/worker.js');
});

2. Handle Failures Gracefully

// With agenda (automatic retries)
agenda.define('critical-job', { concurrency: 1, maxAttempts: 3 }, async (job) => {
  // Your logic
});

// With node-cron
cron.schedule('...', async () => {
  try {
    await criticalTask();
  } catch (err) {
    sendAlertToSlack('Cron job failed: ' + err.message);
  }
});

3. Avoid Overlapping Jobs

Use agenda’s concurrency control or a locking mechanism:

let isJobRunning = false;

cron.schedule('*/5 * * * *', async () => {
  if (isJobRunning) return;
  isJobRunning = true;
  await longRunningTask();
  isJobRunning = false;
});

4. Use Environment-Specific Schedules

Disable cron jobs in development:

// In your Node.js app
if (process.env.NODE_ENV === 'production') {
  cron.schedule('...', productionTask);
}

5. Monitor Your Jobs

Log job start/end times.
Use tools like PM2 for process management:

  pm2 start app.js
  pm2 logs

Final Thoughts

Choose system cron if:

You need tasks to run independently of your Node app.
Your hosting provider supports crontab.

Choose node-cron if:

You prefer keeping jobs within your codebase.
You need simple in-app scheduling.

Choose agenda if:

You require job persistence and retries.
Your app already uses MongoDB.

By combining these tools with proper error handling and monitoring, you can build robust automated workflows for your Node.js backend. Happy coding! 🚀

Further Resources:

Author: Mohin Sheikh

Follow me on GitHub for more insights!

From JavaScript to Python: A Syntax Guide for Developers

Mohin Sheikh — Mon, 19 May 2025 13:20:30 +0000

Introduction

If you’re a JavaScript developer diving into Python, you’ll find many concepts familiar but with syntactic twists. Python’s emphasis on readability and simplicity means fewer brackets, strict indentation, and a different approach to common tasks. Let’s break down key differences with side-by-side examples.

1. Variables and Constants

JavaScript

let mutableVar = 10;       // Mutable
const immutableVar = 20;   // Immutable

Python

mutable_var = 10    # No 'let' or 'const'—all variables are mutable
IMMUTABLE_VAR = 20  # Convention: UPPER_CASE for "constants" (not enforced)

Key Notes:

Python uses snake_case (not camelCase).
No var or const—just assign values.

2. Data Types

JavaScript	Python	Notes
`number`	`int`, `float`	Python distinguishes integers and floats.
`string`	`str`	Both use template literals/f-strings.
`boolean` (lowercase)	`bool` (TitleCase)	Python: `True/False` (case-sensitive).
`array`	`list`, `tuple`	Lists are mutable; tuples are immutable.
`object`	`dict`	Python dicts ≈ JS objects.
`null`/`undefined`	`None`	Python’s universal "no value" placeholder.

3. Conditionals

JavaScript

if (age > 18) {
  console.log("Adult");
} else if (age === 18) {
  console.log("Exactly 18");
} else {
  console.log("Minor");
}

Python

if age > 18:
    print("Adult")
elif age == 18:    # 'elif' instead of 'else if'
    print("Exactly 18")
else:
    print("Minor")   # Indentation defines blocks (no curly braces!)

Gotchas:

Use == for equality checks (Python has no ===).
Indentation is mandatory—use 4 spaces (no tabs).

4. Loops

For Loop

JavaScript (C-style):

for (let i = 0; i < 5; i++) {
  console.log(i);
}

Python (range-based):

for i in range(5):   # range(0, 5) → 0,1,2,3,4
    print(i)

Iterating Over Arrays/Lists

JavaScript:

const fruits = ["apple", "banana"];
for (const fruit of fruits) {
  console.log(fruit);
}

Python:

fruits = ["apple", "banana"]
for fruit in fruits:
    print(fruit)

5. Functions

JavaScript

function multiply(a, b) {
  return a * b;
}
// Arrow function
const multiply = (a, b) => a * b;

Python

def multiply(a, b):
    return a * b

# Lambda (anonymous)
multiply = lambda a, b: a * b

Key Differences:

Python uses def instead of function.
Lambdas are limited to single expressions.

6. Strings

Template Literals (JS) vs. f-Strings (Python)

JavaScript:

const name = "Alice";
console.log(`Hello, ${name}!`);  // Backticks

Python:

name = "Alice"
print(f"Hello, {name}!")  # 'f' prefix

7. Arrays (JS) vs. Lists (Python)

Action	JavaScript	Python
Add element	`arr.push(4)`	`lst.append(4)`
Remove last	`arr.pop()`	`lst.pop()`
Check existence	`arr.includes(4)`	`4 in lst`
Create copy	`[...arr]`	`lst.copy()`
Map	`arr.map(x => x*2)`	`[x*2 for x in lst]`

Python List Comprehension Example:

squares = [x**2 for x in range(5)]  # [0, 1, 4, 9, 16]

8. Objects (JS) vs. Dictionaries (Python)

JavaScript:

const user = { 
  name: "Alice", 
  age: 30 
};
console.log(user.name);  // Dot notation

Python:

user = {
    "name": "Alice",
    "age": 30
}
print(user["name"])   # Or user.get("name")

9. Classes

JavaScript

class Dog {
  constructor(name) {
    this.name = name;
  }

  bark() {
    console.log("Woof!");
  }
}

Python

class Dog:
    def __init__(self, name):  # Constructor
        self.name = name

    def bark(self):            # 'self' is explicit
        print("Woof!")

Key Notes:

Python requires self as the first method parameter.
No new keyword: my_dog = Dog("Buddy").

10. Error Handling

JavaScript:

try {
  throw new Error("Failed!");
} catch (error) {
  console.log(error.message);
}

Python:

try:
    raise Exception("Failed!")
except Exception as e:
    print(e)

11. Modules and Imports

JavaScript (ES6):

import React from 'react';
export const PI = 3.14;

Python:

import math
from math import sqrt

# Exporting: Just write variables/functions in the file.
PI = 3.14

12. Truthy and Falsy Values

JavaScript Falsy	Python Falsy
`false`, `0`, `""`	`False`, `0`, `""`
`null`, `undefined`	`None`
`NaN`	`[]`, `{}`, `()`

Example:

if not []:   # Empty list is falsy
    print("This list is empty!")

Key Takeaways

Indentation Rules: Python uses indentation (4 spaces) instead of curly braces.
Simplicity: Python favors explicit, readable code (e.g., elif over else if).
Rich Data Structures: Lists, tuples, sets, and dictionaries offer flexibility.
No Semicolons: Optional in Python (but avoid them).

Example: Factorial Function

JavaScript:

function factorial(n) {
  if (n === 0) return 1;
  return n * factorial(n - 1);
}

Python:

def factorial(n):
    if n == 0:
        return 1
    return n * factorial(n - 1)

Next Steps

Practice: Use platforms like LeetCode to solve problems in Python.
Explore Libraries: Learn numpy (arrays), pandas (dataframes), and requests (HTTP).
Read the Zen of Python: Run import this in a Python shell.

Final Thoughts

Python’s syntax feels minimalist compared to JavaScript, but its strict structure encourages clean code. Start small, embrace indentation, and leverage Python’s powerful built-in tools.

Happy coding! 🐍

Author: Mohin Sheikh

Follow me on GitHub for more insights!

Writing Unit Tests for an Express.js Application: A Beginner-Friendly Guide

Mohin Sheikh — Wed, 25 Dec 2024 08:13:14 +0000

📖 Table of Contents

Introduction to Unit Testing
Why Unit Testing is Important
Setting Up the Testing Environment
Installing Testing Dependencies
Project Structure for Testing
Writing Unit Tests for Controllers
Writing Unit Tests for Middleware
Writing Unit Tests for Services
Running Unit Tests
Best Practices for Unit Testing
Conclusion

1. Introduction to Unit Testing

Unit testing involves testing individual units or components of an application in isolation to ensure they work as expected. In Express.js, unit tests typically focus on testing controllers, middlewares, and services.

2. Why Unit Testing is Important

Detects bugs early in development.
Ensures code behaves as expected.
Makes refactoring easier.
Improves code maintainability.
Provides documentation for how the code should work.

3. Setting Up the Testing Environment

Ensure your Express.js application is set up and functional.

If not, follow the Setup Guide.

4. Installing Testing Dependencies

Install the required testing libraries:

npm install --save-dev jest ts-jest @types/jest supertest @types/supertest

jest: Testing framework.
ts-jest: Jest configuration for TypeScript.
supertest: Library for testing HTTP APIs.

4.1 Configure Jest

Create a jest.config.ts file in your project root:

export default {
  preset: 'ts-jest',
  testEnvironment: 'node',
  moduleNameMapper: {
    '^@/(.*)$': '<rootDir>/src/$1',
  },
  moduleFileExtensions: ['ts', 'js', 'json'],
  testMatch: ['**/__tests__/**/*.test.ts'],
};

Add a test script to your package.json:

{
  "scripts": {
    "test": "jest --coverage"
  }
}

5. Project Structure for Testing

src/
├── controllers/
│   ├── userController.ts
├── services/
│   ├── userService.ts
├── middleware/
│   ├── authMiddleware.ts
└── __tests__/
    ├── controllers/
    │   ├── userController.test.ts
    ├── services/
    │   ├── userService.test.ts
    ├── middleware/
        ├── authMiddleware.test.ts

6. Writing Unit Tests for Controllers

6.1 Example Controller

File: src/controllers/userController.ts

import { Request, Response } from 'express';

export const getUser = (req: Request, res: Response) => {
  res.status(200).json({ id: 1, name: 'John Doe' });
};

6.2 Test Controller

File: src/__tests__/controllers/userController.test.ts

import { getUser } from '../../controllers/userController';
import { Request, Response } from 'express';

describe('User Controller - getUser', () => {
  it('should return user data with status 200', () => {
    const req = {} as Request;
    const res = {
      status: jest.fn().mockReturnThis(),
      json: jest.fn(),
    } as unknown as Response;

    getUser(req, res);

    expect(res.status).toHaveBeenCalledWith(200);
    expect(res.json).toHaveBeenCalledWith({ id: 1, name: 'John Doe' });
  });
});

Explanation:

Mocked Request and Response.
Called the getUser controller function.
Asserted status code and response data.

7. Writing Unit Tests for Middleware

7.1 Example Middleware

File: src/middleware/authMiddleware.ts

import { Request, Response, NextFunction } from 'express';

export const isAuthenticated = (req: Request, res: Response, next: NextFunction) => {
  if (req.headers.authorization === 'Bearer validToken') {
    next();
  } else {
    res.status(403).json({ message: 'Forbidden' });
  }
};

7.2 Test Middleware

File: src/__tests__/middleware/authMiddleware.test.ts

import { isAuthenticated } from '../../middleware/authMiddleware';
import { Request, Response, NextFunction } from 'express';

describe('Auth Middleware - isAuthenticated', () => {
  it('should call next if token is valid', () => {
    const req = { headers: { authorization: 'Bearer validToken' } } as Request;
    const res = {} as Response;
    const next = jest.fn();

    isAuthenticated(req, res, next);

    expect(next).toHaveBeenCalled();
  });

  it('should return 403 if token is invalid', () => {
    const req = { headers: { authorization: '' } } as Request;
    const res = {
      status: jest.fn().mockReturnThis(),
      json: jest.fn(),
    } as unknown as Response;
    const next = jest.fn();

    isAuthenticated(req, res, next);

    expect(res.status).toHaveBeenCalledWith(403);
    expect(res.json).toHaveBeenCalledWith({ message: 'Forbidden' });
  });
});

8. Writing Unit Tests for Services

8.1 Example Service

File: src/services/userService.ts

export const findUserById = (id: number) => {
  if (id === 1) {
    return { id: 1, name: 'John Doe' };
  }
  return null;
};

8.2 Test Service

File: src/__tests__/services/userService.test.ts

import { findUserById } from '../../services/userService';

describe('User Service - findUserById', () => {
  it('should return user data when valid ID is provided', () => {
    const user = findUserById(1);
    expect(user).toEqual({ id: 1, name: 'John Doe' });
  });

  it('should return null when invalid ID is provided', () => {
    const user = findUserById(2);
    expect(user).toBeNull();
  });
});

9. Running Unit Tests

Run your tests with:

npm run test

Sample Output:

 PASS  __tests__/controllers/userController.test.ts
 PASS  __tests__/middleware/authMiddleware.test.ts
 PASS  __tests__/services/userService.test.ts

Test Suites: 3 passed, 3 total
Tests:       6 passed, 6 total
Snapshots:   0 total
Time:        2.345 s

Check Test Coverage

npm run test -- --coverage

10. Best Practices for Unit Testing

Test one functionality per test case.
Mock external dependencies (e.g., database calls).
Ensure your tests are independent and isolated.
Use descriptive describe and it blocks.
Avoid testing implementation details.
Include edge cases in your tests.

11. Conclusion

Unit testing validates each part of your Express.js app independently.
Focus on Controllers, Middleware, and Services.
Use Jest and Supertest for efficient testing.

✨ Your Express.js application now has comprehensive unit tests! 🚀

Author: Mohin Sheikh

Follow me on GitHub for more insights!

Adding Authentication to an Express.js Application with JWT: A Beginner-Friendly Guide

Mohin Sheikh — Wed, 25 Dec 2024 08:08:02 +0000

📖 Table of Contents

Introduction to Authentication
What is JWT (JSON Web Token)?
Setting Up the Project
Installing Dependencies
Creating a User Model
Setting Up JWT Authentication Middleware
Creating Authentication Routes (Login, Register, Protected Route)
Testing the Authentication System
Environment Variables for Security
Best Practices for Authentication
Conclusion

1. Introduction to Authentication

Authentication ensures that only verified users can access certain resources in your application. In this guide, we’ll use JWT (JSON Web Token) for secure authentication in an Express.js application.

2. What is JWT (JSON Web Token)?

JWT is an open standard (RFC 7519) for securely transmitting information between parties as a JSON object.
Tokens are signed using a secret key or a public/private key pair.

Structure of a JWT Token:

Header.Payload.Signature

Header: Metadata about the token.
Payload: User data and claims.
Signature: Verifies the integrity of the token.

3. Setting Up the Project

Ensure you have a basic Express.js application ready. If not, follow this guide.

Initialize a new Node.js project:

npm init -y
npm install express jsonwebtoken bcryptjs dotenv

4. Installing Dependencies

express: Web framework for Node.js.
jsonwebtoken: Handles JWT generation and verification.
bcryptjs: Hashes passwords securely.
dotenv: Loads environment variables.

Install all dependencies:

npm install express jsonwebtoken bcryptjs dotenv
npm install --save-dev @types/jsonwebtoken @types/bcryptjs

5. Creating a User Model

For MongoDB:

File: src/models/userModel.ts

import mongoose, { Schema, Document } from 'mongoose';

interface IUser extends Document {
  username: string;
  email: string;
  password: string;
}

const UserSchema: Schema = new Schema({
  username: { type: String, required: true },
  email: { type: String, required: true, unique: true },
  password: { type: String, required: true },
});

export default mongoose.model<IUser>('User', UserSchema);

For PostgreSQL:

File: src/models/userModel.ts

import db from '../config/knex';

export const createUser = (user: { username: string; email: string; password: string }) => db('users').insert(user);
export const getUserByEmail = (email: string) => db('users').where({ email }).first();

6. Setting Up JWT Authentication Middleware

File: src/middleware/authMiddleware.ts

import jwt from 'jsonwebtoken';
import { Request, Response, NextFunction } from 'express';

interface AuthRequest extends Request {
  user?: any;
}

export const authenticateJWT = (req: AuthRequest, res: Response, next: NextFunction) => {
  const token = req.header('Authorization')?.split(' ')[1];

  if (!token) {
    return res.status(403).json({ message: 'Authorization required' });
  }

  try {
    const decoded = jwt.verify(token, process.env.JWT_SECRET || '');
    req.user = decoded;
    next();
  } catch (error) {
    res.status(401).json({ message: 'Invalid Token' });
  }
};

7. Creating Authentication Routes (Login, Register, Protected Route)

7.1 Register Route

File: src/controllers/authController.ts

import bcrypt from 'bcryptjs';
import jwt from 'jsonwebtoken';
import User from '../models/userModel';
import { Request, Response } from 'express';

export const registerUser = async (req: Request, res: Response) => {
  const { username, email, password } = req.body;

  const hashedPassword = await bcrypt.hash(password, 10);

  const newUser = new User({ username, email, password: hashedPassword });
  await newUser.save();

  res.status(201).json({ message: 'User registered successfully' });
};

7.2 Login Route

export const loginUser = async (req: Request, res: Response) => {
  const { email, password } = req.body;

  const user = await User.findOne({ email });
  if (!user) {
    return res.status(400).json({ message: 'Invalid credentials' });
  }

  const isPasswordValid = await bcrypt.compare(password, user.password);
  if (!isPasswordValid) {
    return res.status(400).json({ message: 'Invalid credentials' });
  }

  const token = jwt.sign({ id: user._id, email: user.email }, process.env.JWT_SECRET || '', { expiresIn: '1h' });
  res.json({ token });
};

7.3 Protected Route

export const protectedRoute = async (req: any, res: Response) => {
  res.json({ message: `Hello, ${req.user.email}! You have access.` });
};

7.4 Authentication Routes

File: src/routes/authRoutes.ts

import express from 'express';
import { registerUser, loginUser, protectedRoute } from '../controllers/authController';
import { authenticateJWT } from '../middleware/authMiddleware';

const router = express.Router();

router.post('/register', registerUser);
router.post('/login', loginUser);
router.get('/protected', authenticateJWT, protectedRoute);

export default router;

7.5 Update `app.ts`

import authRoutes from './routes/authRoutes';

app.use('/api/auth', authRoutes);

8. Testing the Authentication System

8.1 Register a User

Endpoint: POST /api/auth/register
Request Body:

{
  "username": "testuser",
  "email": "test@example.com",
  "password": "password123"
}

Response:

{
  "message": "User registered successfully"
}

8.2 Login User

Endpoint: POST /api/auth/login
Request Body:

{
  "email": "test@example.com",
  "password": "password123"
}

Response:

{
  "token": "JWT_TOKEN_HERE"
}

8.3 Access Protected Route

Endpoint: GET /api/auth/protected
Header:

Authorization: Bearer JWT_TOKEN_HERE

Response:

{
  "message": "Hello, test@example.com! You have access."
}

9. Environment Variables for Security

File: .env

JWT_SECRET=your_jwt_secret_key

Ensure you keep this secret key secure and never expose it publicly.

10. Best Practices for Authentication

Always hash passwords using bcrypt.
Store JWT secrets securely in .env.
Use short expiration times for tokens.
Implement refresh tokens for better security.
Avoid sending sensitive data in JWT payloads.

11. Conclusion

Authentication Flow: User registration → Login → JWT Token Generation → Access Protected Routes.
JWT is stateless and scalable for modern applications.
Secure your routes using middleware.

✨ Your Express.js app now has JWT-based authentication! 🚀

Author: Mohin Sheikh

Follow me on GitHub for more insights!

Connecting an Express.js Application to MongoDB and PostgreSQL: A Step-by-Step Guide for Beginners

Mohin Sheikh — Wed, 25 Dec 2024 08:03:15 +0000

📖 Table of Contents

Introduction to Databases
MongoDB vs PostgreSQL: Key Differences
Setting Up MongoDB
Connecting MongoDB to Express.js
Setting Up PostgreSQL
Connecting PostgreSQL to Express.js
Implementing CRUD Operations with a Database
Environment Variables for Database Configuration
Best Practices
Conclusion

1. Introduction to Databases

Databases are essential for any web application to store, retrieve, and manage data efficiently.

MongoDB: A NoSQL database that stores data in JSON-like documents. Great for unstructured data.
PostgreSQL: A relational SQL database ideal for structured data with complex relationships.

2. MongoDB vs PostgreSQL: Key Differences

Feature	MongoDB	PostgreSQL
Type	NoSQL	SQL
Schema	Flexible	Fixed Schema
Scalability	Horizontal	Vertical
Best for	Real-time apps, Document storage	Complex queries, Structured data

Choose MongoDB for flexibility and PostgreSQL for structured and relational data.

3. Setting Up MongoDB

3.1 Install MongoDB Locally

Download MongoDB from the official MongoDB website.
Install MongoDB Compass (GUI tool for MongoDB).

3.2 Set Up MongoDB Connection URL

MONGODB_URI=mongodb://localhost:27017/express_crud_db

4. Connecting MongoDB to Express.js

4.1 Install MongoDB Dependencies

npm install mongoose

4.2 Create Database Configuration File

File: src/config/database.ts

import mongoose from 'mongoose';

const connectMongoDB = async () => {
  try {
    await mongoose.connect(process.env.MONGODB_URI || '');
    console.log('MongoDB Connected');
  } catch (error) {
    console.error('MongoDB connection failed:', error);
    process.exit(1);
  }
};

export default connectMongoDB;

4.3 Update `app.ts`

import connectMongoDB from './config/database';
connectMongoDB();

4.4 Create a User Model

File: src/models/userModel.ts

import mongoose, { Schema, Document } from 'mongoose';

interface IUser extends Document {
  name: string;
  email: string;
}

const UserSchema: Schema = new Schema({
  name: { type: String, required: true },
  email: { type: String, required: true }
});

export default mongoose.model<IUser>('User', UserSchema);

5. Setting Up PostgreSQL

5.1 Install PostgreSQL Locally

Download PostgreSQL from the official website.
Install pgAdmin (GUI tool for PostgreSQL).

5.2 Create a Database

Open psql or pgAdmin.
Run:

CREATE DATABASE express_crud_db;

5.3 Set Up PostgreSQL Connection URL

POSTGRESQL_URI=postgresql://user:password@localhost:5432/express_crud_db

6. Connecting PostgreSQL to Express.js

6.1 Install PostgreSQL Dependencies

npm install knex pg

6.2 Configure Knex.js

File: src/config/knex.ts

import knex from 'knex';

const db = knex({
  client: 'pg',
  connection: process.env.POSTGRESQL_URI,
  pool: { min: 0, max: 7 }
});

export default db;

6.3 Create a Migration File

npx knex migrate:make create_users_table --knexfile src/config/knex.ts

File: src/migrations/<timestamp>_create_users_table.ts

export function up(knex) {
  return knex.schema.createTable('users', (table) => {
    table.increments('id').primary();
    table.string('name').notNullable();
    table.string('email').notNullable().unique();
  });
}

export function down(knex) {
  return knex.schema.dropTable('users');
}

Run the migration:

npx knex migrate:latest --knexfile src/config/knex.ts

6.4 Create a User Model

File: src/models/userModel.ts

import db from '../config/knex';

export const getAllUsers = () => db('users').select('*');
export const getUserById = (id: number) => db('users').where({ id }).first();
export const createUser = (user: { name: string; email: string }) => db('users').insert(user);
export const updateUser = (id: number, user: { name?: string; email?: string }) => db('users').where({ id }).update(user);
export const deleteUser = (id: number) => db('users').where({ id }).del();

7. Implementing CRUD Operations with Database

7.1 Update Controller for MongoDB

File: src/controllers/userController.ts

import User from '../models/userModel';

export const getUsers = async (req, res) => {
  const users = await User.find();
  res.json(users);
};

7.2 Update Controller for PostgreSQL

import { getAllUsers, getUserById, createUser, updateUser, deleteUser } from '../models/userModel';

export const getUsers = async (req, res) => {
  const users = await getAllUsers();
  res.json(users);
};

8. Environment Variables for Database Configuration

File: .env

MONGODB_URI=mongodb://localhost:27017/express_crud_db
POSTGRESQL_URI=postgresql://user:password@localhost:5432/express_crud_db

Update your app.ts to load .env:

import dotenv from 'dotenv';
dotenv.config();

9. Best Practices

Use environment variables for sensitive data.
Validate data before saving to the database.
Use connection pools for PostgreSQL.
Properly handle database connection errors.
Avoid exposing raw database errors to the client.

10. Conclusion

MongoDB: Great for dynamic, schema-less applications.
PostgreSQL: Best for structured, relational data with strict validation.

Choose the database based on your project requirements.

✨ Your Express.js app is now connected to both MongoDB and PostgreSQL! 🚀

Author: Mohin Sheikh

Follow me on GitHub for more insights!

Building an Express.js CRUD Application from Scratch: A Step-by-Step Guide for Beginners

Mohin Sheikh — Wed, 25 Dec 2024 07:59:20 +0000

📖 Table of Contents

Introduction to Express.js
Setting Up the Project Environment
Project Structure Overview
Installing Dependencies
Creating the Express Server
Defining Routes
Creating Controllers
Setting Up a Database (Optional)
Implementing CRUD Operations
- Create (POST)
- Read (GET)
- Update (PUT)
- Delete (DELETE)
Middleware and Error Handling
Testing the APIs with Postman
Conclusion and Best Practices

1. Introduction to Express.js

What is Express.js?

Express.js is a minimal and flexible Node.js web application framework that provides a robust set of features for building web and mobile applications.
Why Use Express.js?
- Lightweight and fast.
- Flexible routing system.
- Middleware support.
- Easy integration with databases.

2. Setting Up the Project Environment

Install Node.js (LTS version recommended).
Verify installation:

  node -v
  npm -v

Initialize a new Node.js project:

  mkdir express-crud-app
  cd express-crud-app
  npm init -y

3. Project Structure Overview

Organize your project like this:

express-crud-app/
│
├── src/
│   ├── controllers/
│   │   ├── userController.ts
│   │
│   ├── routes/
│   │   ├── userRoutes.ts
│   │
│   ├── models/
│   │   ├── userModel.ts
│   │
│   ├── middlewares/
│   │   ├── errorHandler.ts
│   │
│   ├── app.ts
│
├── package.json
├── tsconfig.json
└── README.md

4. Installing Dependencies

Install necessary dependencies:

npm install express body-parser mongoose
npm install --save-dev typescript @types/express @types/node nodemon

Update package.json scripts:

"scripts": {
  "start": "node dist/app.js",
  "dev": "nodemon src/app.ts"
}

5. Creating the Express Server

File: src/app.ts

import express, { Request, Response } from 'express';
import userRoutes from './routes/userRoutes';

const app = express();
const PORT = 3000;

app.use(express.json());

// Routes
app.use('/api/users', userRoutes);

// Health Check
app.get('/', (req: Request, res: Response) => {
  res.send('Express Server is running!');
});

// Start Server
app.listen(PORT, () => {
  console.log(`Server is running on http://localhost:${PORT}`);
});

6. Defining Routes

File: src/routes/userRoutes.ts

import { Router } from 'express';
import {
  getUsers,
  getUserById,
  createUser,
  updateUser,
  deleteUser
} from '../controllers/userController';

const router = Router();

router.get('/', getUsers);
router.get('/:id', getUserById);
router.post('/', createUser);
router.put('/:id', updateUser);
router.delete('/:id', deleteUser);

export default router;

7. Creating Controllers

File: src/controllers/userController.ts

import { Request, Response } from 'express';

let users = [
  { id: 1, name: 'John Doe', email: 'john@example.com' },
];

export const getUsers = (req: Request, res: Response) => {
  res.status(200).json(users);
};

export const getUserById = (req: Request, res: Response) => {
  const user = users.find(u => u.id === parseInt(req.params.id));
  if (user) {
    res.status(200).json(user);
  } else {
    res.status(404).json({ message: 'User not found' });
  }
};

export const createUser = (req: Request, res: Response) => {
  const newUser = { id: users.length + 1, ...req.body };
  users.push(newUser);
  res.status(201).json(newUser);
};

export const updateUser = (req: Request, res: Response) => {
  const user = users.find(u => u.id === parseInt(req.params.id));
  if (user) {
    Object.assign(user, req.body);
    res.status(200).json(user);
  } else {
    res.status(404).json({ message: 'User not found' });
  }
};

export const deleteUser = (req: Request, res: Response) => {
  users = users.filter(u => u.id !== parseInt(req.params.id));
  res.status(200).json({ message: 'User deleted' });
};

8. Middleware and Error Handling

File: src/middlewares/errorHandler.ts

import { Request, Response, NextFunction } from 'express';

export const errorHandler = (err: Error, req: Request, res: Response, next: NextFunction) => {
  console.error(err.stack);
  res.status(500).json({ message: 'Something went wrong!' });
};

Add it to app.ts:

import { errorHandler } from './middlewares/errorHandler';
app.use(errorHandler);

9. Testing with Postman

Sample Requests and Responses

1. Create User (POST /api/users)

Request Body:

{
  "name": "Alice",
  "email": "alice@example.com"
}

Response:

{
  "id": 2,
  "name": "Alice",
  "email": "alice@example.com"
}

2. Get All Users (GET /api/users)

Response:

[
  {
    "id": 1,
    "name": "John Doe",
    "email": "john@example.com"
  },
  {
    "id": 2,
    "name": "Alice",
    "email": "alice@example.com"
  }
]

3. Update User (PUT /api/users/:id)

Request Body:

{
  "name": "Updated Name"
}

Response:

{
  "id": 1,
  "name": "Updated Name",
  "email": "john@example.com"
}

4. Delete User (DELETE /api/users/:id)

Response:

{
  "message": "User deleted"
}

10. Conclusion and Best Practices

Always validate user input.
Use middleware effectively.
Follow RESTful API conventions.
Organize code into meaningful files and folders.

11. Next Steps

✨ Congratulations! You've built an Express.js CRUD application from scratch.

Author: Mohin Sheikh

Follow me on GitHub for more insights!

Node.js Interview Guide

Mohin Sheikh — Tue, 24 Dec 2024 19:16:29 +0000

1. What is Node.js?

Node.js is an open-source, cross-platform, JavaScript runtime environment that executes JavaScript code outside of a web browser. It uses the V8 JavaScript engine, developed by Google, which compiles JavaScript directly into machine code, contributing to its exceptional performance and efficiency. It allows developers to run JavaScript on the server side, enabling the creation of scalable and efficient server-side applications.

Key Features of Node.js:

Event-Driven Architecture: Efficient handling of I/O operations.
Non-Blocking I/O Model: Prevents blocking operations, enhancing performance.
Single-Threaded Event Loop: Handles multiple concurrent requests efficiently.
Package Management: Managed via npm (Node Package Manager).
Cross-Platform Compatibility: Runs on Windows, macOS, and Linux.

Example:

const http = require('http');

http.createServer((req, res) => {
  res.writeHead(200, {'Content-Type': 'text/plain'});
  res.end('Hello, World!\n');
}).listen(3000);

console.log('Server running at http://localhost:3000/');

2. Event Loop in Node.js

The Event Loop is a core concept in Node.js that handles asynchronous operations.

Key Points:

It waits for tasks, executes them, and sleeps until more tasks arrive.
Executes tasks from the Event Queue when the Call Stack is empty.
Allows Node.js to handle thousands of concurrent connections efficiently.

Phases of Event Loop:

Below is a visual representation of the Event Loop phases to enhance clarity:

Timers Phase: Executes setTimeout and setInterval callbacks.
Pending Callbacks Phase: Handles I/O callbacks.
Idle/Prepare Phase: Internal operations.
Poll Phase: Retrieves new I/O events.
Check Phase: Executes setImmediate() callbacks.
Close Callbacks Phase: Handles close events (e.g., socket.on('close')).

Example:

console.log('Start');
setTimeout(() => console.log('Timeout'), 0);
process.nextTick(() => console.log('NextTick'));
console.log('End');

Output:

Start
End
NextTick
Timeout

3. Why Node.js Instead of Other Frameworks?

Asynchronous and Non-Blocking: Efficient in handling heavy I/O tasks.
Single Programming Language: JavaScript for both frontend and backend.
Lightweight: Consumes fewer system resources.
Scalability: Suitable for real-time applications.
Active Community: Extensive npm libraries.

Comparison with Traditional Web Servers:

Traditional Servers: Multi-threaded, blocking operations.
Node.js: Single-threaded, non-blocking I/O.

4. Clusters in Node.js

Node.js is single-threaded, but clusters allow it to utilize multiple CPU cores.

Key Points:

Each cluster is a child process.
Shares server ports among worker processes.
Improves application scalability.

Example:

const cluster = require('cluster');
const http = require('http');
const os = require('os');

if (cluster.isMaster) {
  os.cpus().forEach(() => cluster.fork());
  cluster.on('exit', (worker) => {
    console.log(`Worker ${worker.process.pid} exited`);
    cluster.fork();
  });
} else {
  http.createServer((req, res) => {
    res.writeHead(200);
    res.end(`Hello from Worker ${process.pid}`);
  }).listen(3000);
  console.log(`Worker ${process.pid} started`);
}

5. Authentication vs Authorization

Authentication: Verifying the user’s identity (e.g., login credentials).
Authorization: Verifying access rights to resources (e.g., Admin vs User privileges).

Example:

Authentication: Validating username/password.
Authorization: Checking if the user can access /admin route.

6. Middleware in Node.js

Middleware functions are functions executed during the request-response cycle.

Key Functions:

Modify req and res objects.
Execute code before passing control to the next middleware.
End the request-response cycle.

Example:

app.use((req, res, next) => {
  console.log('Middleware executed');
  next();
});

7. JWT Algorithms

JWTs use SHA-256 for hashing.
RSA (asymmetric encryption) is used for signing.

8. Command Line Input (CLI)

Used for interacting with systems and tools without GUI.

Example:

node index.js --port=3000

9. NPM and Package Files

npm: Package manager for Node.js.
package.json: Project metadata.
package-lock.json: Locks dependency versions.

10. Error Handling in Node.js

Try-Catch: For synchronous code.
Error Events: For async tasks.
Promise.catch: For rejected promises.

Example:

try {
  throw new Error('Something went wrong');
} catch (err) {
  console.error(err.message);
}

11. Synchronous vs Asynchronous Code

Synchronous: Blocking.
Asynchronous: Non-blocking.

Example:

fs.readFile('file.txt', (err, data) => console.log(data));
console.log('This runs first');

12. Global Exception Handler

Handles uncaught exceptions to prevent application crashes.

Example:

process.on('uncaughtException', (err) => {
  console.error('Uncaught Exception:', err);
});

13. MVC Architecture

Model: Manages data and business logic.
View: Responsible for the presentation layer (UI/UX).
Controller: Handles user input and interacts with the model and view.

Key Benefits:

Separation of concerns.
Better scalability and maintainability.
Easier debugging and testing.

Example Structure:

app/
├── models/
│   └── userModel.js
├── views/
│   └── userView.ejs
├── controllers/
│   └── userController.js
└── routes/
    └── userRoutes.js

14. How would you define the term I/O?

I/O stands for Input/Output and refers to any operation that involves reading data from or writing data to an external resource, such as a file, database, or network.

In Node.js:

Input: Data received from external sources (e.g., user requests, file system).
Output: Data sent to external sources (e.g., API responses, file writes).

Example:

const fs = require('fs');
fs.readFile('file.txt', 'utf8', (err, data) => {
  if (err) throw err;
  console.log(data);
});

15. Explain Callback in Node.js

A callback is a function passed as an argument to another function, which gets executed once the asynchronous task is complete.

Key Points:

Avoid blocking operations.
Improve performance.
Commonly used in asynchronous APIs.

Example:

fs.readFile('file.txt', (err, data) => {
  if (err) console.error(err);
  else console.log(data.toString());
});

This guide provides a professional overview of key Node.js concepts, useful for both interview preparation and real-world applications.

Author: Mohin Sheikh

Follow me on GitHub for more insights!

Serverless Email Service with AWS Lambda, Node.js, and SQS 📧

Mohin Sheikh — Tue, 24 Dec 2024 18:55:16 +0000

1. Overview

This documentation outlines the setup and implementation of an Email Service using AWS Lambda, SQS (Simple Queue Service), and Node.js with the Serverless Framework. The service leverages Nodemailer for email delivery, ensuring scalability, efficiency, and configuration flexibility.

🛠️ Key Components

AWS Lambda: Processes email messages asynchronously.
AWS SQS: Queues email messages for Lambda to process.
Nodemailer: Handles email delivery via SMTP.
Serverless Framework: Infrastructure as Code (IaC) management.
Node.js & TypeScript: Backend runtime with type safety.

🔄 Workflow

Messages are added to the SQS Queue.
AWS Lambda triggers on new messages.
Message schema is validated using Joi.
Emails are sent via Nodemailer.
Success and failure logs are recorded using a Logger.

2. Project Structure

├── src
│   ├── services
│   │   ├── EmailService.ts   # Core email service using Nodemailer
│   ├── controllers
│   │   ├── emailController.ts   # Controls email operations
│   ├── handlers
│   │   ├── sendEmailHandler.ts   # Lambda handler for processing SQS
│   ├── utils
│   │   ├── logger.ts   # Logger for structured logging
│   │   ├── validate.ts # Environment validation helper
├── sls
│   ├── custom.yml    # Custom configuration
│   ├── functions.yml # Lambda function definitions
│   ├── resources.yml # AWS resource definitions
├── serverless.yml   # Main Serverless Framework configuration

3. Environment Variables

Define these variables in sls/custom.yml based on your deployment stage:

SMTP_HOST: smtp.gmail.com
SMTP_PORT: 465
SMTP_USER: your_email@gmail.com
SMTP_PASS: your_app_password
EMAIL_FROM: your_email@gmail.com
AWS_REGION: ap-south-1
S3_BUCKET_NAME: dev-file-upload-v2

Use the getEnvVariable helper for validation.

4. Email Service Implementation

📝 src/services/EmailService.ts

import nodemailer from 'nodemailer';
import logger from '../utils/logger';
import { getEnvVariable } from '../utils/validate';

class EmailService {
  private transporter: nodemailer.Transporter;
  private smtpHost: string;
  private smtpPort: number;
  private smtpUser: string;
  private smtpPass: string;
  private smtpFrom: string;

  constructor() {
    this.smtpHost = getEnvVariable('SMTP_HOST');
    this.smtpPort = parseInt(getEnvVariable('SMTP_PORT', '587'));
    this.smtpUser = getEnvVariable('SMTP_USER');
    this.smtpPass = getEnvVariable('SMTP_PASS');
    this.smtpFrom = process.env['EMAIL_FROM'] || this.smtpUser;

    this.transporter = nodemailer.createTransport({
      host: this.smtpHost,
      port: this.smtpPort,
      secure: this.smtpPort === 465,
      auth: {
        user: this.smtpUser,
        pass: this.smtpPass,
      },
    });

    this.verifyConnection();
  }

  private async verifyConnection() {
    try {
      await this.transporter.verify();
      logger.info('SMTP server is ready to send emails');
    } catch (error) {
      logger.error('Failed to verify SMTP connection:', error);
      throw new Error('Unable to connect to SMTP server');
    }
  }

  async sendEmail(to: string, subject: string, htmlContent: string): Promise<void> {
    const mailOptions = {
      from: this.smtpFrom,
      to,
      subject,
      html: htmlContent,
    };

    try {
      const info = await this.transporter.sendMail(mailOptions);
      logger.info('Email sent successfully:', { messageId: info.messageId, to });
    } catch (error: any) {
      logger.error(`Error sending email: ${error.message}`, error);
      throw new Error('Email sending failed');
    }
  }
}

export default new EmailService();

5. Email Controller

📝 src/controllers/emailController.ts

import logger from '../utils/logger';
import EmailService from '../services/EmailService';

class EmailController {
  async sendCustomEmail(to: string, subject: string, templateContent: string) {
    try {
      logger.info(`Sending email to ${to} with subject "${subject}"`);
      await EmailService.sendEmail(to, subject, templateContent);
      logger.info(`Email sent successfully to ${to}`);
      return { success: true, message: 'Email sent successfully' };
    } catch (error: any) {
      logger.error(`Failed to send email to ${to} - ${error.message}`);
      throw new Error(`Failed to send custom email - ${error.message}`);
    }
  }
}

export default new EmailController();

6. Lambda Handler

📝 src/handlers/sendEmailHandler.ts

import Joi from 'joi';
import EmailController from '../controllers/emailController';
import logger from '../utils/logger';
import { Handler } from 'aws-lambda';

const emailSchema = Joi.object({
  to: Joi.string().email().required(),
  subject: Joi.string().required(),
  templateContent: Joi.string().required(),
});

export const handler: Handler = async (event) => {
  for (const record of event.Records) {
    try {
      const message = JSON.parse(record.body);
      const { error, value } = emailSchema.validate(message);

      if (error) {
        logger.warn('Validation failed', {
          recordId: record.messageId,
          errors: error.details.map(e => e.message),
        });
        continue;
      }

      const { to, subject, templateContent } = value;
      await EmailController.sendCustomEmail(to, subject, templateContent);
      logger.info('Email sent successfully', { recordId: record.messageId, to });
    } catch (error: any) {
      logger.error('Failed to process SQS message', {
        recordId: record.messageId,
        error: error.message,
      });
    }
  }
};

7. Deployment

Install dependencies:

npm install

Deploy to AWS:

npx serverless deploy --stage dev

Check logs:

npx serverless logs -f sendEmail -s dev

8. Testing

Sample SQS Message Payload

{
  "to": "recipient@example.com",
  "subject": "Welcome to Our Platform",
  "templateContent": "<h1>Hello, Welcome!</h1>"
}

Add this payload to your SQS Queue.

9. Conclusion

Your Serverless Email Service is now ready! 🚀 Manage and monitor emails efficiently using AWS Lambda, SQS, and Nodemailer.

Author: Mohin Sheikh

Follow me on GitHub for more insights!