Integrating Facebook Login in NestJS with Limited Facebook Login for iOS And standard Facebook Login 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

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

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');
    }
  }
}

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

export async function verifyFacebookJwt(token: string): Promise {
  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);
      },
    );
  });
}

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);
    }
  }
}