Refresh Token interceptor

John — Tue, 01 Sep 2026 05:30:31 +0000

import { HttpErrorResponse, HttpInterceptorFn } from '@angular/common/http';
import { inject } from '@angular/core';
import { AuthService } from '../services/auth-service';
import { catchError, switchMap, throwError } from 'rxjs';

export const authInterceptorInterceptor: HttpInterceptorFn = (req, next) => {
// const toaster=inject(ToastrService);
const authService=inject(AuthService);
const token=localStorage.getItem("access_token");

// token attach with request
if (token) {

const clonedRequest = req.clone({
  setHeaders: {
    Authorization: `Bearer ${token}`
  }
});

return next(clonedRequest).pipe(

  catchError((error: HttpErrorResponse) => {

     let errorMessage = 'An unknown error occurred!';
    if (error.status === 401) {

      return authService.refreshToken().pipe(

        switchMap((response: any) => {

          console.log('Token refreshed successfully');

          // Save new access token
          localStorage.setItem(
            'access_token',
            response.accessToken
          );

          // Retry original request
          const retryRequest = req.clone({
            setHeaders: {
              Authorization: `Bearer ${response.accessToken}`
            }
          });

          return next(retryRequest);
        }),

        catchError((refreshError) => {

          console.error(
            'Refresh token failed:',
            refreshError
          );

          // Both tokens are no longer valid
          localStorage.removeItem('access_token');
          localStorage.removeItem('refresh_token');

          return throwError(() => refreshError);
        })
      );
    }

    if (error.error instanceof ErrorEvent) {
    // Client-side or network error
    errorMessage = `Error: ${error.error.message}`;
  } else {
    // Backend error
    // Customize this based on your backend payload (e.g., error.error.message)
    errorMessage = error.error?.message || error.message;

    // Handle specific status codes globally here if needed (except 401)
    if (error.status === 403) {
      errorMessage = 'You do not have permission to access this resource.';
    }


  }

// Display the error via Toastr
console.log(error.message);
//toaster.error(errorMessage, Error ${error.status || ''});
return throwError(() => error);
})
);
}
return next(req);
};

Authentication

John — Tue, 01 Sep 2026 04:54:36 +0000

Install-Package Microsoft.EntityFrameworkCore
Install-Package Microsoft.EntityFrameworkCore.SqlServer
Install-Package Microsoft.EntityFrameworkCore.Tools
Install-Package Microsoft.AspNetCore.Identity.EntityFrameworkCore
Install-Package Microsoft.EntityFrameworkCore.Design
Install-Package Microsoft.AspNetCore.Authentication.JwtBearer
Install-Package MediatR -Version 11.1.0
Install-Package MediatR.Extensions.Microsoft.DependencyInjection -Version 11.1.0
Install-Package FluentValidation.AspNetCore
Install-Package FluentValidation.DependencyInjectionExtensions
Add-Migration InitialCreate
Update-Database

public interface ICurrentUser
{

 string? Id { get; }
 string? Email { get; }

}

public class CurrentUser : ICurrentUser
{
private readonly IHttpContextAccessor _httpContextAccessor;

 public CurrentUser(IHttpContextAccessor httpContextAccessor)
 {
     _httpContextAccessor = httpContextAccessor;
 }
 public string? Id => _httpContextAccessor.HttpContext?.User?.FindFirst(ClaimTypes.NameIdentifier)?.Value;
 public string? Email => _httpContextAccessor.HttpContext?.User?.FindFirst(ClaimTypes.Email)?.Value;

}

public class ErrorResponse
{
public int StatusCode { get; set; }
public string Message { get; set; } = string.Empty;
public string? Details { get; set; }
public DateTime TimeStamp { get; set; } = DateTime.UtcNow;
}

public class GlobalExceptionHandler(ILogger logger) : IExceptionHandler
{
private readonly ILogger _logger = logger;

public async ValueTask<bool> TryHandleAsync(
    HttpContext httpContext,
    Exception exception,
    CancellationToken cancellationToken)
{
    _logger.LogError(exception, "Unhandled exception caught by GlobalExceptionHandler: {Message}", exception.Message);

    var (statusCode, message) = MapException(exception);

    var errorResponse = new ErrorResponse
    {
        StatusCode = (int)statusCode,
        Message = message,
        Details = exception.GetType().Name,
        TimeStamp = DateTime.UtcNow
    };

    httpContext.Response.StatusCode = (int)statusCode;
    httpContext.Response.ContentType = "application/json";

    var json = JsonSerializer.Serialize(errorResponse, new JsonSerializerOptions
    {
        PropertyNamingPolicy = JsonNamingPolicy.CamelCase
    });

    await httpContext.Response.WriteAsync(json, cancellationToken);

    // Return true to signal the exception has been handled
    return true;
}


private static (HttpStatusCode statusCode, string message) MapException(Exception exception)
{
    return exception switch
    {
        BadRequestException => (HttpStatusCode.BadRequest, exception.Message),
        NotFoundException => (HttpStatusCode.NotFound, exception.Message),
        UnauthorizedException => (HttpStatusCode.Unauthorized, exception.Message),
        ConflictException => (HttpStatusCode.Conflict, exception.Message),
        _ => (HttpStatusCode.InternalServerError, "An unexpected error occurred. Please try again later.")
    };
}

}

builder.Services.AddSwaggerGen(options =>
{
options.AddSecurityDefinition("bearer", new OpenApiSecurityScheme
{
Type = SecuritySchemeType.Http,
Scheme = "bearer",
BearerFormat = "JWT",
Description = "JWT Authorization header using the bearer Scheme"
});
options.AddSecurityRequirement(document => new OpenApiSecurityRequirement
{
[new OpenApiSecuritySchemeReference("bearer", document)] = []
});
});

  List<Claim> authClaims = [
       new(ClaimTypes.NameIdentifier,user.Id.ToString()),
       new(ClaimTypes.Email,user.Email??string.Empty),
       new(ClaimTypes.Name,user.Name??string.Empty),
      new (JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString()), 
      // unique id for token

];

DEV Community: John

Refresh Token interceptor

Authentication