DEV Community: Nikesh Dahal

The Easiest Way to Generate a GitHub SSH Key

Nikesh Dahal — Mon, 26 Jan 2026 04:54:31 +0000

(No thinking. No stress. Just copy–paste like a pro)

This is the simplest method to generate an SSH key and save it on your local system.
No theory. No confusion. Just copy → paste → enter → done

Step 1: Open your terminal

Mac / Linux / Windows (Git Bash) — all good.
Just open it like you’re opening Netflix 😌

Step 2: Create the SSH key (magic spell 🧙‍♂️)

ssh-keygen -t ed25519 -C "your_email@example.com"

Note : ed25519 is is a modern cryptographic algorithm used to generate SSH keys.
In simple terms:
It’s the method used to create your SSH key — like choosing a lock type 🔑 that's it .

Now your terminal will ask questions like an interview panel:

Q1: Where to save the key?
👉 Press Enter

Q2: Enter passphrase?
👉 Press Enter (skip like ads)

Q3: Confirm passphrase?
👉 Press Enter again

🎉 Boom! Key generated. *(No stress just click Enter,Enter,Enter and that's it .) *

🧠 Step 3: Wake up the SSH agent (it’s sleeping 😴)

eval "$(ssh-agent -s)"

🔑 Step 4: Add your key to the agent

ssh-add ~/.ssh/id_ed25519

Note: Now your key is officially hired 🧑‍💼

📋 Step 5: Copy your public key (the VIP pass 🎟️)

cat ~/.ssh/id_ed25519.pub

Now in your terminal you will get the long string key

👉 Copy everything that appears
(yes, everything… don’t act smart and trim it 😏)

Step 6: Tell GitHub who you are

Go to GitHub.com

Profile pic → Settings

SSH and GPG keys

New SSH key

Title: My Laptop

Paste the key

Click Add SSH key

and that's it done .

GitHub: “Ah yes, I know this human now.” 🤝

🎉 DONE DONE DONE

No passwords
No tokens
No drama
No errors
No crying at 2 AM
No “permission denied” trauma

Just clean SSH vibes 😌🔐

Thankyou .
Keep Learning.

📢 Just published a new blog! " JavaScript Promises & Async/Await – A Beginner-Friendly Guide With Examples" Whether you're starting with JS or brushing up your skills, this guide will help you write better, more readable async code. 🚀 Check it out here

Nikesh Dahal — Mon, 21 Apr 2025 07:43:50 +0000

Nikesh Dahal

Apr 21 '25

📘 JavaScript Promises & Async/Await – A Beginner-Friendly Guide With Examples

#javascript #webdev #beginners #programming

Comments 8

5 min read

📢 Just published a new blog! " JavaScript Promises & Async/Await – A Beginner-Friendly Guide With Examples" In this post, I break down the evolution of handling asynchronous operations in JavaScript — from messy callbacks to clean and modern Promises.

Nikesh Dahal — Mon, 21 Apr 2025 07:42:59 +0000

Nikesh Dahal

Apr 21 '25

📘 JavaScript Promises & Async/Await – A Beginner-Friendly Guide With Examples

#javascript #webdev #beginners #programming

Comments 8

5 min read

📢 Just published a new blog! " JavaScript Promises & Async/Await – A Beginner-Friendly Guide With Examples"

Nikesh Dahal — Mon, 21 Apr 2025 07:41:25 +0000

Nikesh Dahal

Apr 21 '25

📘 JavaScript Promises & Async/Await – A Beginner-Friendly Guide With Examples

#javascript #webdev #beginners #programming

Comments 8

5 min read

📘 JavaScript Promises & Async/Await – A Beginner-Friendly Guide With Examples

Nikesh Dahal — Mon, 21 Apr 2025 06:35:02 +0000

Why Do We Even Need Promises?

🕰️ Problem: JavaScript is primarily synchronous, running one piece of code at a time.
Imagine JS as a one-man band — it can only do one thing at a time. But the world (like APIs, file reading, or user clicks) doesn't wait.

Let’s say:
You fetch data from a server.
It takes 2 seconds.
Meanwhile, your app shouldn’t freeze.
So we need a way to wait without blocking other work.

i think now we are clear about the problem right ? ok now lets understand about what exactly is promise.

🧃 The Juice Shop Analogy: Understanding Promises

Imagine you're at a juice shop:
You place an order for a mango juice.
The shopkeeper says, "It'll be ready in 5 minutes."
You receive a token and wait.

After 5 minutes:

If the juice is ready, you get it. ✅
If mangoes are out of stock, you're informed. ❌

In JavaScript, this scenario shows how Promises work.

🧠 So, What is a Promise in JavaScript?

A Promise is like a "contract" that says:

“I promise to give you something in the future — either a success or a failure.”

🔄 The 3 States of a Promise:

JavaScript Promise States

State	Meaning
🕒 Pending	Still waiting. Not ready yet.
✅ Fulfilled	Promise kept. Success! Got the result.
❌ Rejected	Something went wrong. It failed.

🧪 Let’s Try a Simple Example (No need to panic)

const juicePromise = new Promise((resolve, reject) => {
  let mangoes = true;

  if (mangoes) {
    resolve("Here is your mango juice!");
  } else {
    reject("Sorry, no mangoes today.");
  }
});

juicePromise
  .then(result => console.log(result))  // when successful
  .catch(error => console.log(error)); // when failed

⏱️ Why Use Promises?

Because JavaScript is single-threaded. That means it can only do one thing at a time. So if you wait 5 seconds to get data from a server, JavaScript would freeze your whole website.

Promises let JS do something else while waiting.

😵‍💫 Old Way: Callback Hell (Before Promises)

getData(function(result) {
  processData(result, function(final) {
    displayData(final, function() {
      // more and more nesting 😭
    });
  });
});

Too many () inside () inside () = messy and hard to read.

🦸‍♂️ Superhero: Promises to the Rescue

getData()
  .then(processData)
  .then(displayData)
  .catch(error => console.log(error));

Cleaner, right? 😊

🧱 Let's Understand Promise Chaining

Every .then() returns a new promise. You can chain .then() to run things in order.

function first() {
  return new Promise(resolve => setTimeout(() => resolve("Step 1 done"), 1000));
}

function second(data) {
  return new Promise(resolve => setTimeout(() => resolve(data + " → Step 2 done"), 1000));
}

first()
  .then(result => second(result))
  .then(final => console.log(final));

Output: Step 1 done → Step 2 done (after 2 seconds)

🔃 What is async/await and Why is it Cool?

Problem: .then() is better than callbacks, but still not very “human-friendly”.

Let’s rewrite using async/await (which works on top of promises):

function getJuice() {
  return new Promise(resolve => {
    setTimeout(() => {
      resolve("Here's your juice!");
    }, 2000);
  });
}

async function serveJuice() {
  console.log("Ordering juice...");
  const result = await getJuice();  // wait until juice is ready
  console.log(result);
}

serveJuice();

output:

Ordering juice...
(wait 2 sec)
Here's your juice!

Why it’s easier?

No .then()
Looks like normal code, but still async!
Easier to debug and read

⚡ Parallel vs Sequential

const user = await getUser();   // wait 1 sec
const posts = await getPosts(); // wait 1 sec

Takes 2 seconds total right ? yes it will took 2 sec but what if we can do this same thing in 1 sec ? yes you heard it right . we can do same thing in 1 sec and that's parallel way.

✅ Parallel: Run together

const [user, posts] = await Promise.all([getUser(), getPosts()]);

Takes 1 second only!

❌ Mixing await with normal functions

await getSomething(); // ❌ ERROR if not inside async

async function doIt() {
  await getSomething(); // ✅
}

lets try to recall all of the above things and know the things to handle the asynchronous events in JS.

🕰️ Evolution of Asynchronous Handling in JavaScript

1)📞 Callbacks (The Beginning)

What is it?

A function passed as an argument to be called after another function finishes.
The earliest way to handle async behavior in JavaScript.

Problem:

Callback Hell (nested pyramid of doom).
Hard to read, debug, and maintain.

example:

function getData(callback) {
  setTimeout(() => {
    callback("📦 Data received");
  }, 1000);
}

getData(function(result) {
  console.log(result);
});

2)🔮 Promises (Introduced in ES6 - 2015)

What is it?
An object that represents a value that may not be available yet, but will be resolved in the future.

Uses .then() for success and .catch() for errors.

Improvement:

Avoids nesting by using chaining.
Easier error handling

example:

function getData() {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      resolve("📦 Data from promise");
    }, 1000);
  });
}

getData()
  .then(result => console.log(result))
  .catch(error => console.error(error));

3)🧙 Async/Await (Introduced in ES8 - 2017)

What is it?

Syntactic sugar over promises.
Makes async code look synchronous.
Works only inside async functions.

Improvement:

Cleaner, more readable.
Try/catch block makes error handling familiar.

example:

async function fetchData() {
  try {
    const result = await getData();
    console.log(result);
  } catch (error) {
    console.error(error);
  }
}

fetchData();

4)🧩 Top-level Await (Introduced in ES2022)

What is it?

Allows you to use await outside of an async function.
Mostly used in modules or top-level script files.

Improvement:
Useful for initialization scripts, loading configs, or data before app starts.

example:

const result = await fetch("https://api.example.com/data");
const data = await result.json();
console.log(data);

Must be in a module or a supported runtime like Deno or modern Node.js (with "type": "module").

5)🛠️ Newer Promise Features

not new paradigms, but powerful tools

5.1. Promise.all()
Run multiple promises in parallel and wait for all.

Promise.all([getUser(), getPosts(), getComments()])
  .then(([user, posts, comments]) => console.log(user, posts, comments));

5.2. Promise.race()
Resolves/rejects as soon as any one of the promises does.

5.3. Promise.allSettled()
Waits for all promises to finish (regardless of success or failure).

📕 Summary

JavaScript Promise Concept Cheat Sheet

Concept	Meaning
Promise	"I’ll give it to you later"
resolve	"Here you go!"
reject	"Sorry, can't do it."
.then()	"What to do after it’s done"
.catch()	"What to do if it failed"
async	Tells JS this function uses `await` inside
await	"Wait here until I get the result"

📊 Summary Table: Async Handling in JavaScript

Approach	Introduced In	Syntax Style	Pros	Cons	Example Keywords
Callbacks	Before ES6	Function-based	Simple, works everywhere	Callback Hell, hard to manage	`function(cb) {}`
Promises	ES6 (2015)	Chain-based	Cleaner than callbacks, chaining	Can still get nested	`.then()`, `.catch()`
Async/Await	ES8 (2017)	Synchronous-like	Easy to read, debug, write	Only usable inside async funcs	`async`, `await`
Top-level Await	ES2022	Global await usage	Useful in modules	Not supported everywhere	`await` (no func wrapper)
Promise utilities	ES6+	Combined use	Advanced control flow	Must understand promises well	`Promise.all()`, `race()`

Want to Try It Yourself?

Here’s a simple test you can run in your browser console or in JSFiddle:

function makeTea() {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      resolve("☕ Tea is ready!");
    }, 1500);
  });
}

async function startDay() {
  console.log("Starting the day...");
  const tea = await makeTea();
  console.log(tea);
}

startDay();

💡 Pro Tip: Always choose the approach that keeps your code clean and readable. async/await is your best friend in modern JavaScript!

i will post all promises methods in an interesting way in next blog soon . the above content is just to make you familiar about promises and async and await .

stay tuned !!
Happy Learning !!

New blog alert! 📣 Essential JavaScript Cheat Sheet for beginners 👉 Check it

Nikesh Dahal — Sun, 20 Apr 2025 10:52:55 +0000

Nikesh Dahal

Apr 16 '25

📚JavaScript Cheat Sheet: Essential Methods Every Developer Should Know

#javascript #beginners #programming #cheatsheet

Comments 10

4 min read

New blog alert! 📣 I’ve compiled an Essential JavaScript Cheat Sheet for beginners 👉 Check it

Nikesh Dahal — Sun, 20 Apr 2025 10:52:21 +0000

Nikesh Dahal

Apr 16 '25

📚JavaScript Cheat Sheet: Essential Methods Every Developer Should Know

#javascript #beginners #programming #cheatsheet

Comments 10

4 min read

New blog alert! 📣 I’ve compiled an Essential JavaScript Cheat Sheet for beginners It’s packed with essential methods and real-world examples to strengthen your JS foundation. Perfect for anyone starting out with JavaScript, React, or Node.js! 👉 Check it

Nikesh Dahal — Sun, 20 Apr 2025 10:51:31 +0000

Nikesh Dahal

Apr 16 '25

📚JavaScript Cheat Sheet: Essential Methods Every Developer Should Know

#javascript #beginners #programming #cheatsheet

Comments 10

4 min read

📚JavaScript Cheat Sheet: Essential Methods Every Developer Should Know

Nikesh Dahal — Wed, 16 Apr 2025 04:48:27 +0000

🧾 Description:

This guide book is perfect for beginners who want to explore JavaScript and build proficiency. It covers essential JavaScript methods that will strengthen your base and set you on the path to becoming a skilled JavaScript developer.

Buckle up for a wild JavaScript ride! 🎢 This guide makes learning methods fun and easy, helping you build a strong foundation while keeping things exciting. Let’s get started!

1. 🔤 String Methods

Method	Description	Example	Use Case
`length`	Returns length of string	`"hello".length → 5`	Validate input length
`toUpperCase()`	Converts string to uppercase	`"abc".toUpperCase() → "ABC"`	Case-insensitive comparison
`toLowerCase()`	Converts string to lowercase	`"ABC".toLowerCase() → "abc"`	Normalize string
`trim()`	Removes whitespace from both ends	`" hi ".trim() → "hi"`	Clean user input
`includes()`	Checks if string contains substring	`"hello".includes("ll") → true`	Search text
`startsWith()`	Checks if string starts with given substring	`"hello".startsWith("he") → true`	Input format validation
`endsWith()`	Checks if string ends with given substring	`"hello".endsWith("lo") → true`	File extension validation
`slice(start, end)`	Extracts part of string	`"hello".slice(1,4) → "ell"`	Substring manipulation
`split()`	Splits string into an array	`"a,b,c".split(",") → ["a", "b", "c"]`	CSV parsing
`replace()`	Replaces substring in string	`"hello".replace("l", "x") → "hexlo"`	Text formatting
`match()`	Matches string with regex	`"abc123".match(/\d+/) → ["123"]`	Pattern matching

2. 📦 Array Methods

Method	Description	Example	Use Case
`length`	Array length	`[1,2,3].length → 3`	Limit pagination
`push()`	Add element to the end	`[1,2].push(3) → [1,2,3]`	Add elements dynamically
`pop()`	Remove element from the end	`[1,2,3].pop() → 3`	Stack behavior
`unshift()`	Add element to the beginning	`[2,3].unshift(1) → [1,2,3]`	Queue behavior
`shift()`	Remove element from the beginning	`[1,2,3].shift() → 1`	Queue behavior
`map()`	Transform array	`[1,2,3].map(x => x*2) → [2,4,6]`	UI rendering
`filter()`	Filter array	`[1,2,3].filter(x => x > 1) → [2,3]`	Search result
`reduce()`	Reduce array to a single value	`[1,2,3].reduce((a,b) => a + b) → 6`	Calculate total
`find()`	Find first match	`[1,2,3].find(x => x === 2) → 2`	Find user
`findIndex()`	Find index of first match	`[1,2,3].findIndex(x => x === 2) → 1`	Locate position
`forEach()`	Loop through array	`[1,2].forEach(x => console.log(x))`	Side effects
`some()`	Check if at least one match exists	`[1,2].some(x => x > 1) → true`	Validation
`every()`	Check if all items match	`[1,2].every(x => x > 0) → true`	Input checks
`sort()`	Sort array elements	`[3,1,2].sort() → [1,2,3]`	Alphabetical or numeric sort
`concat()`	Merge arrays	`[1,2].concat([3,4]) → [1,2,3,4]`	Pagination merge
`flat()`	Flatten nested arrays	`[1,[2,3]].flat() → [1,2,3]`	Clean structure
`includes()`	Check presence of an element	`[1,2,3].includes(2) → true`	Item check

3. 🧱 Object Methods

Method	Description	Example	Use Case
`Object.keys(obj)`	Array of keys	`Object.keys({a:1}) → ["a"]`	Iterate object
`Object.values(obj)`	Array of values	`Object.values({a:1}) → [1]`	Values loop
`Object.entries(obj)`	Array of [key,value]	`Object.entries({a:1}) → [["a",1]]`	Convert to array
`Object.assign()`	Merge objects	`Object.assign({}, a, b)`	Combine data
`hasOwnProperty()`	Check key exists	`obj.hasOwnProperty("x")`	Secure access

4. 🔢 Number Methods

Method	Description	Example	Use Case
`parseInt()`	String to int	`parseInt("10") → 10`	Input conversion
`parseFloat()`	String to float	`parseFloat("10.5") → 10.5`	Price parsing
`toFixed()`	Format decimals	`(2.345).toFixed(2) → "2.35"`	Display currency
`isNaN()`	Check if Not a Number	`isNaN("abc") → true`	Validate input

5. 📅 Date Methods

Method	Description	Example	Use Case
`new Date()`	Create date	`new Date()`	Current timestamp
`Date.now()`	Get timestamp	`Date.now()`	Timer/log
`getFullYear()`	Get year	`new Date().getFullYear()`	Age calc
`getMonth()`	Get month (0-index)	`new Date().getMonth()`	Calendar logic
`getDate()`	Get date	`new Date().getDate()`	Billing
`toISOString()`	ISO format	`new Date().toISOString()`	Backend format

6. 🌐 DOM Methods

Method	Description	Example	Use Case
`getElementById()`	Get by ID	`document.getElementById("app")`	Manipulate DOM
`querySelector()`	Get first match	`document.querySelector(".btn")`	Advanced selection
`createElement()`	Create HTML element	`document.createElement("div")`	Dynamic UI
`appendChild()`	Add element	`parent.appendChild(child)`	Build tree
`innerHTML`	Read/write HTML	`div.innerHTML = "<b>Hi</b>"`	Inject content
`addEventListener()`	Add event handler	`btn.addEventListener("click", fn)`	UI interactivity

7. 🛠️ Utility Functions

Function	Description	Example	Use Case
`setTimeout()`	Delay function	`setTimeout(() => console.log("Hi"), 1000)`	Debounce
`setInterval()`	Repeated function	`setInterval(fn, 1000)`	Real-time clock
`clearTimeout()`	Cancel timeout	`clearTimeout(timer)`	Stop debounce
`JSON.stringify()`	Object to JSON	`JSON.stringify({a:1}) → '{"a":1}'`	API send
`JSON.parse()`	JSON to Object	`JSON.parse('{"a":1}') → {a:1}`	API receive

8. ⚙️ Function Helpers

Feature	Description	Example	Use Case
`()=>{}`	Arrow function	`x => x * 2`	Inline logic
`function`	Standard function	`function test(){}`	Reuse code
`call()`	Call with context	`fn.call(obj)`	Manual bind
`apply()`	Call with array	`fn.apply(obj, [args])`	Spread context
`bind()`	Permanently bind context	`fn.bind(obj)`	React events
`arguments`	Access args	`function fn(){ console.log(arguments) }`	Dynamic params
`rest (...)`	Collect args	`function fn(...args){}`	Variadic functions
`spread (...)`	Expand array/object	`[...a, ...b]`	Merge arrays

✅ Wrapping Up

JavaScript can feel like a jungle 🌴 when you're just starting out, but once you know the paths, it becomes an adventure. These methods and functions are like your survival toolkit 🧰 — use them wisely, and you'll be building amazing things in no time! Whether you're debugging code at 2 AM 😅 or crafting the next big app 💡, this cheatsheet’s got your back.

Keep learning, keep experimenting, and most importantly — have fun with it! 🎉
Happy coding! 💻🚀

Integrating Facebook Login in NestJS with Limited Facebook Login for iOS And standard Facebook Login for Android

Nikesh Dahal — Wed, 09 Apr 2025 10:26:59 +0000

Introduction

In modern mobile applications, social logins like Facebook have become essential for smooth user onboarding and authentication. Facebook Login offers two primary methods for integration:

Limited Facebook Login (commonly used in specific cases like iOS).
Standard Facebook Graph API Login

This guide explains how to integrate Facebook login in a NestJS backend, including the logic for both standard and limited Facebook login. We’ll also clarify why Limited Facebook Login is particularly useful for iOS devices but generally not required for Android.


## Prerequisites:
NestJS Setup: A NestJS backend configured with basic authentication and JWT-based tokens.

Facebook Developer Account: A Facebook App set up in the Facebook Developer Console.

Facebook SDK/Graph API Access: Proper access to Facebook's Graph API or JWT-based access tokens.

## Directory Structure

Here’s a suggested directory structure to reflect the implementation of Facebook Login, including a fallback to Limited Facebook Login. It covers services, resolvers, utilities, and related GraphQL components.


src/
│
├── auth/
│   ├── dto/
│   │   ├── input/
│   │   │   └── login.facebook.input.ts
│   ├── service/
│   │   ├── user.name.service.ts
│   │   └── facebook.login.service.ts   <-- Contains Facebook login logic (Standard + Limited login)
│   └── facebook-jwt.utils.ts            <-- Utility function for verifying Facebook JWT
│
├── http-client/
│   └── service/
│       └── http.client.service.ts       <-- Service to interact with external APIs like Facebook Graph API
│
├── stat/
│   └── stat.service.ts                 <-- Service to handle statistics (like user creation)
│
├── token/
│   └── token.service.ts                <-- Service to handle JWT token generation
│
├── repository/
│   └── user.repository.ts              <-- Repository for user data (find, create, update user data)
│
├── entities/
│   └── user.entity.ts                  <-- User schema/entity
│
├── constants/
│   └── language.ts                    <-- Language constants (e.g., `Lang.CREATE_USER`)
│
├── config/
│   ├── facebook.config.ts              <-- Facebook related configurations (optional)
│
├── logger/
│   └── logger.ts                       <-- Custom logging functionality (optional)
│
└── app.module.ts                       <-- Main module where all services and controllers are integrated

ok excited ? , now lets dive deep but here in this facebook login is only the primary focused so i am assuming you already have your setup

Step 1: Install Dependencies
You’ll need to install a few dependencies for handling HTTP requests, JWT tokens, and Facebook OAuth interactions.

npm install @nestjs/axios axios jsonwebtoken jwks-rsa @nestjs/common

Step 2: Create Required Modules and Services

Assuming your auth module already contains the necessary DTOs and endpoints, let’s focus on creating the Facebook login logic.

Create auth/facebook.login.service.ts

I have included the NestJS Logger here solely for logging errors or key steps. I believe it's better to use the NestJS Logger instead of console.log(). Additionally, this service includes my UserNameService and TokenService, which are specific to my use case and may differ in your scenario. So, please focus only on the workings and functionalities of the Facebook login.

This service will handle both Standard and Limited Facebook login methods.

import { Injectable, InternalServerErrorException, UnauthorizedException } from '@nestjs/common';
import { FacebookLoginInput } from '@auth/dto/input/login.facebook.input';
import { HttpClientService } from '@http-client/service/http.client.service';
import { TokenService } from '@token/token.service';
import { UserRepository } from '@repository/user.repository';
import { UserNameService } from '@auth/service/user.name.service';
import { verifyFacebookJwt } from '@auth/facebook-jwt.utils';
import { Logger } from '@nestjs/common';

@Injectable()
export class FacebookLoginService {
  private readonly logger = new Logger(FacebookLoginService.name);

  constructor(
    private readonly httpClientService: HttpClientService,
    private readonly tokenService: TokenService,
    private readonly userNameService: UserNameService,
    private readonly userRepository: UserRepository,
  ) {}

  async loginWithFacebook({ accessToken }: FacebookLoginInput) {
    try {
      let facebookDetails: any;

      // Try standard Facebook Graph API login first
      try {
        facebookDetails = await this.httpClientService.getFacebookDetails(accessToken);
      } catch (standardLoginError) {
        this.logger.warn('Standard Facebook login failed. Attempting limited login.', {
          error: standardLoginError?.message || standardLoginError,
        });

        // Fallback to limited login (JWT-based)
        try {
          facebookDetails = await verifyFacebookJwt(accessToken);
        } catch (limitedLoginError) {
          this.logger.error('Limited Facebook login also failed.', {
            error: limitedLoginError?.message || limitedLoginError,
          });
          throw new InternalServerErrorException('Could not retrieve Facebook user data');
        }
      }

      if (!facebookDetails?.sub && !facebookDetails?.id) {
        throw new InternalServerErrorException('Could not retrieve Facebook user data');
      }

      // Process user data...
    } catch (error) {
      this.logger.error('Facebook login failed.', { error: error?.message || error });
      throw error instanceof UnauthorizedException ? error : new InternalServerErrorException('Facebook login failed');
    }
  }
}

Step 3: Create facebook-jwt.utils.ts
This utility handles JWT verification for Limited Facebook login.

here in this we will verify the token which will provide my mobile-user and in the process of verification instead of doing just jwt.decode() follow this process to verify because we need to check key and issuer too .

What jwt.decode() Does:
The jwt.decode() function only decodes the token payload without:

Verifying the token’s signature
Validating the token's authenticity
Checking the issuer
Checking expiration

This means anyone can tamper with the token payload, and jwt.decode() will still return data without any validation. This is dangerous in authentication systems.

Why We Should Use jwt.verify() Instead:
To ensure the integrity, authenticity, and trustworthiness of the Facebook-issued JWT, we must use jwt.verify() like this:

import * as jwt from 'jsonwebtoken';
import { UnauthorizedException } from '@nestjs/common';

export async function verifyFacebookJwt(token: string): Promise<any> {
  const jwksClient = jwksLocalClient({
    jwksUri: 'https://www.facebook.com/.well-known/oauth/openid/jwks',
  });

  return new Promise((resolve, reject) => {
    jwt.verify(
      token,
      async (header, callback) => {
        const key = await jwksClient.getSigningKey(header.kid);
        const signingKey = key.getPublicKey();
        callback(null, signingKey);
      },
      {
        algorithms: ['RS256'],
        issuer: ['https://facebook.com', 'https://graph.facebook.com'],
      },
      (err, decoded) => {
        if (err) {
          reject(new UnauthorizedException('Invalid Facebook token.'));
        }
        resolve(decoded);
      },
    );
  });
}

the above is the main part so lets break it down with proper explanation

Verifying the Signature (with JWKS)
Facebook signs JWTs using a public-private key pair. To verify the token, we:

Fetch Facebook’s public key from its JWKS endpoint:https://www.facebook.com/.well-known/oauth/openid/jwks
Use that key to validate the token’s signature.

If someone modifies the token payload, the signature won't match, and verification will fail.

Security benefit: Confirms the token is issued by Facebook and hasn’t been tampered with.

Validating the Issuer (issuer Claim)
The issuer claim tells us who issued the token. In this case, it should always be:
https://www.facebook.com
When we use jwt.verify() with issuer: 'https://www.facebook.com', it ensures that:

The token really came from Facebook
It hasn’t been faked or generated by a malicious third party
If the token’s iss claim doesn’t match, it gets rejected.

Validating Expiration, Audience, and Algorithm
jwt.verify() also checks:

If the token has expired (exp)
The correct algorithm was used (RS256)
Optional: whether the token is meant for your app (audience claim)

This full validation makes it safe to trust the token and use its payload to identify the user.

Step :3 Create http.client.service.ts
This service calls Facebook's Graph API to retrieve user profile information. This is the standard method used in most Android and web-based applications.

yes we can do this too and this is what we called as Standard Facebook Graph API Login
it will work for android and web based application in this way .

import { Injectable } from '@nestjs/common';
import { HttpService } from '@nestjs/axios';
import { lastValueFrom } from 'rxjs';
import { UnprocessableEntityException } from '@nestjs/common';

@Injectable()
export class HttpClientService {
  constructor(private readonly httpService: HttpService) {}

  async getFacebookDetails(accessToken: string) {
    try {
      const response: any = await lastValueFrom(
        this.httpService.get(
          `https://graph.facebook.com/me?fields=id,name,picture,email&access_token=${accessToken}`,
        ),
      );
      return response.data;
    } catch (error) {
      throw new UnprocessableEntityException(error.message);
    }
  }
}

Response from successful login:

Why Use Limited Facebook Login on iOS?

Apple enforces strict user privacy policies. iOS applications that use Facebook Login must comply with Apple’s App Store guidelines, which often restrict the use of certain Facebook SDK features.

Key Reasons:

Privacy Transparency:
Apple requires apps to limit data collection unless absolutely necessary. Limited Facebook Login complies by restricting access to only essential user info.
WebView Restrictions:
iOS apps sometimes face issues with Facebook WebView-based login (used by standard login), which can fail or behave inconsistently.
Token Type Differences:
On iOS, you typically receive an ID token (JWT), not just a long-lived access token, and need to verify it manually.
Facebook SDK for iOS:
Facebook recommends using Limited Login for better compatibility with Apple’s login policies.

In contrast, Android does not enforce such strict limitations, making standard Facebook Graph API login more reliable for those devices.

Conclusion

Facebook Login integration in a NestJS backend can be implemented using both Standard and Limited methods. While the Standard Graph API Login is widely used and suitable for Android and web platforms, the Limited Facebook Login is a reliable fallback—especially for iOS environments that enforce stricter privacy and SDK rules.

By implementing both login types, your application becomes more resilient, cross-platform compatible, and user-friendly, ensuring seamless authentication across a variety of devices and platforms.