@next-nest-auth/nestauth 1.0.8 → 1.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@next-nest-auth/nestauth",
-    "version": "1.0.8",
+    "version": "1.1.0",
     "main": "dist/index.js",
     "types": "dist/index.d.ts",
     "scripts": {

package/src/http-exception.filter.ts

@@ -4,27 +4,25 @@ import {
     ArgumentsHost,
     HttpException,
 } from "@nestjs/common";
-import { Request, Response } from "express";
 
 @Catch()
 export class HttpExceptionFilter implements ExceptionFilter {
     catch(exception: any, host: ArgumentsHost) {
         const ctx = host.switchToHttp();
-        const response = ctx.getResponse<Response>();
-        const request = ctx.getRequest<Request>();
+        const response = ctx.getResponse();
+        const request = ctx.getRequest();
 
         let status = 500;
         let message = "Internal Server Error";
 
-        // Check using instanceof or shape fallback
         if (
             exception instanceof HttpException ||
             (exception?.status && exception?.response)
         ) {
             status = exception.status ?? 500;
-
             const exceptionResponse =
                 exception.response ?? exception.getResponse?.();
+
             if (typeof exceptionResponse === "string") {
                 message = exceptionResponse;
             } else if (
@@ -42,11 +40,28 @@ export class HttpExceptionFilter implements ExceptionFilter {
             console.error("Unexpected error:", exception);
         }
 
-        response.status(status).json({
+        const responseBody = {
             statusCode: status,
             message,
-            path: request.url,
+            path: request?.url,
             app: "nestauth",
-        });
+        };
+
+        // Try to send response for Express or Fastify
+        try {
+            if (
+                typeof response.status === "function" &&
+                typeof response.json === "function"
+            ) {
+                response.status(status).json(responseBody);
+            } else if (typeof response.send === "function") {
+                response.code?.(status); // Fastify specific
+                response.send(responseBody);
+            } else {
+                console.error("Unsupported response object:", response);
+            }
+        } catch (err) {
+            console.error("Error while sending error response:", err);
+        }
     }
 }

package/src/index.ts

@@ -2,3 +2,5 @@ export * from "./nestauth.module";
 export * from "./nestauth.service";
 export * from "./nestauth.interface";
 export * from "./nestauth-jwt.guard";
+
+export * from "./nestauth-jwt.strategy";

package/src/nestauth-jwt.guard.ts

@@ -8,17 +8,34 @@ import * as macaddress from "macaddress";
 
 @Injectable()
 export class NestAuthJwtGuard extends AuthGuard("jwt") {
+    // ✅ Custom error handling here
+    handleRequest(err: any, user: any, info: any, context: ExecutionContext) {
+        console.log("err, user, info, context1");
+        if (err || !user) {
+            throw new UnauthorizedException(
+                "Unauthorized: Invalid or missing token"
+            );
+        }
+        return user;
+    }
+
+    // ✅ Make sure to return the result of `super.canActivate`
     async canActivate(context: ExecutionContext): Promise<boolean> {
+        const can = (await super.canActivate(context)) as boolean;
+        if (!can) return false; // short-circuit if base guard fails
+
         const request = context.switchToHttp().getRequest();
-        await super.canActivate(context);
         const user = request.user;
+
         if (!user) {
             throw new UnauthorizedException("Unauthorized: Invalid token");
         }
+
         const currentMacId = await macaddress.one();
         if (user.macId !== currentMacId) {
             throw new UnauthorizedException("Unauthorized: Device mismatch");
         }
+
         return true;
     }
 }

package/src/nestauth-jwt.strategy.ts

@@ -1,28 +1,47 @@
 import { ExtractJwt, Strategy } from "passport-jwt";
 import { PassportStrategy } from "@nestjs/passport";
-import { Inject, Injectable } from "@nestjs/common";
+import { Inject, Injectable, UnauthorizedException } from "@nestjs/common";
 import { JwtPayload } from "jsonwebtoken";
 import * as macaddress from "macaddress";
 
 @Injectable()
 export class NestAuthJwtStrategy extends PassportStrategy(Strategy) {
-  constructor(@Inject("JWT_SECRET") jwtSecret: string) {
-    super({
-      jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(),
-      ignoreExpiration: false,
-      secretOrKey: jwtSecret,
-    });
-  }
+    constructor(@Inject("JWT_SECRET") jwtSecret: string) {
+        super({
+            jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(),
+            ignoreExpiration: false,
+            secretOrKey: jwtSecret,
+        });
+    }
 
-  async validate(payload: JwtPayload) {
-    return {
-      userId: payload.sub,
-      macId: payload.macId ?? (await macaddress.one()),
-      email: payload.email,
-      role: payload.role,
-      name: payload.name,
-      username: payload.username,
-      pic: payload.pic,
-    };
-  }
+    async validate(payload: JwtPayload) {
+        // return {
+        //     userId: payload.sub,
+        //     macId: payload.macId ?? (await macaddress.one()),
+        //     email: payload.email,
+        //     role: payload.role,
+        //     name: payload.name,
+        //     username: payload.username,
+        //     pic: payload.pic,
+        // };
+
+        if (!payload) {
+            throw new UnauthorizedException("Invalid token payload");
+        }
+
+        const macId = payload.macId ?? (await macaddress.one());
+
+        const userData: Record<string, any> = {
+            sub: payload.sub,
+            macId,
+        };
+
+        for (const key of Object.keys(payload)) {
+            if (key !== "sub" && key !== "macId") {
+                userData[key] = payload[key];
+            }
+        }
+
+        return userData;
+    }
 }