@next-nest-auth/nestauth 1.2.5 → 1.2.7

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@next-nest-auth/nestauth",
-    "version": "1.2.5",
+    "version": "1.2.7",
     "main": "dist/index.js",
     "types": "dist/index.d.ts",
     "scripts": {
@@ -32,8 +32,8 @@
     "type": "commonjs",
     "description": "NestAuth is an authentication solution for NestJS applications, designed to handle user login, session management, and token-based authentication (JWT). It integrates seamlessly with Next.js and other frontends to provide a unified authentication system, supporting features like refresh tokens, secure cookie handling, and multi-provider authentication.",
     "dependencies": {
-        "@nestjs/common": "^11.1.11",
-        "@nestjs/config": "^4.0.2",
+        "@nestjs/common": "^11.1.13",
+        "@nestjs/config": "^4.0.3",
         "@nestjs/jwt": "^11.0.2",
         "@nestjs/passport": "^11.0.5",
         "bcryptjs": "^3.0.3",
@@ -48,7 +48,7 @@
     },
     "devDependencies": {
         "@nestjs/schematics": "^11.0.9",
-        "@nestjs/testing": "^11.1.11",
+        "@nestjs/testing": "^11.1.13",
         "@types/bcryptjs": "^3.0.0",
         "@types/passport-facebook": "^3.0.4",
         "@types/passport-google-oauth20": "^2.0.17",

package/src/nestauth-local.guard.ts

@@ -1,5 +1,12 @@
 import { Injectable } from "@nestjs/common";
 import { AuthGuard } from "@nestjs/passport";
 
-@Injectable()
-export class NestAuthLocalGuard extends AuthGuard("nestauth-local") {}
+// @Injectable()
+// export class NestAuthLocalGuard extends AuthGuard("nestauth-local") {}
+
+export function createLocalGuard(strategyName: string) {
+    @Injectable()
+    class NestAuthLocalGuard extends AuthGuard(strategyName) {}
+
+    return NestAuthLocalGuard;
+}

package/src/nestauth-local.strategy.ts

@@ -4,23 +4,51 @@ import { Inject, Injectable, UnauthorizedException } from "@nestjs/common";
 import { NestAuthInterface } from "./nestauth.interface";
 import * as macaddress from "macaddress";
 
-@Injectable()
-export class NestAuthLocalStrategy extends PassportStrategy(
-    Strategy,
-    "nestauth-local"
+// @Injectable()
+// export class NestAuthLocalStrategy extends PassportStrategy(
+//     Strategy,
+//     "nestauth-local",
+// ) {
+//     constructor(private readonly userService: NestAuthInterface) {
+//         super();
+//     }
+
+//     async validate(req: Request): Promise<any> {
+//         console.log
+//         const user = await this.userService.validateUser(req.body);
+//         if (!user) {
+//             throw new UnauthorizedException("Invalid credentials");
+//         }
+//         user.macId = await macaddress.one();
+//         return user;
+//     }
+// }
+
+export function createLocalStrategy(
+    strategyName: string,
+    userServiceToken: string,
 ) {
-    constructor(
-        @Inject("UserService") private readonly userService: NestAuthInterface
+    @Injectable()
+    class NestAuthLocalStrategy extends PassportStrategy(
+        Strategy,
+        strategyName,
     ) {
-        super();
-    }
+        constructor(
+            @Inject(userServiceToken)
+            readonly userService: NestAuthInterface,
+        ) {
+            super();
+        }
 
-    async validate(req: Request): Promise<any> {
-        const user = await this.userService.validateUser(req.body);
-        if (!user) {
-            throw new UnauthorizedException("Invalid credentials");
+        async validate(req: Request): Promise<any> {
+            const user = await this.userService.validateUser(req.body);
+            if (!user) {
+                throw new UnauthorizedException("Invalid credentials");
+            }
+            user.macId = await macaddress.one();
+            return user;
         }
-        user.macId = await macaddress.one();
-        return user;
     }
+
+    return NestAuthLocalStrategy;
 }

package/src/nestauth.controller.ts

@@ -1,71 +1,93 @@
 import {
     Request,
+    Controller,
     Get,
     Post,
     UseGuards,
     Body,
     UnauthorizedException,
     HttpStatus,
+    All,
     BadRequestException,
+    UseFilters,
+    Inject,
 } from "@nestjs/common";
 import { NestAuthService } from "./nestauth.service";
-import { NestAuthLocalGuard } from "./nestauth-local.guard";
 import { NestAuthGoogleGuard } from "./nestauth-google.guard";
 import { NestAuthFacebookGuard } from "./nestauth-facebook.guard";
+import { HttpExceptionFilter } from "./http-exception.filter";
 
-export class NestAuthController {
-    constructor(private readonly nestAuthService: NestAuthService) {}
+export function createDynamicController(
+    prefix: string,
+    nestAuthServiceToken: string,
+    localGuard: any,
+) {
+    @UseFilters(HttpExceptionFilter)
+    @Controller(prefix)
+    class NestAuthController {
+        constructor(
+            @Inject(nestAuthServiceToken)
+            readonly nestAuthService: NestAuthService,
+        ) {}
 
-    @Get()
-    async greetings(): Promise<string> {
-        return "Welcome to NestAuth. Please check our documentation for more information.";
-    }
+        @All()
+        async greetings(): Promise<string> {
+            return "Welcome to NestAuth. Please check our documentation for more information.";
+        }
 
-    @UseGuards(NestAuthLocalGuard)
-    @Post("login")
-    async login(@Request() req): Promise<any> {
-        return this.nestAuthService.login(req.user);
-    }
+        @UseGuards(localGuard)
+        @Post("login")
+        async login(@Request() req: any): Promise<any> {
+            console.log("nestAuthServiceToken", nestAuthServiceToken);
+            return this.nestAuthService.login(req.user);
+        }
 
-    @Post("refresh-token")
-    refreshToken(@Body() params: { refresh_token: string }): Promise<any> {
-        if (!params.refresh_token) {
-            throw new BadRequestException("Invalid or expired refresh token");
+        @Post("refresh-token")
+        refreshToken(@Body() params: { refresh_token: string }): Promise<any> {
+            if (!params.refresh_token) {
+                throw new BadRequestException(
+                    "Invalid or expired refresh token",
+                );
+            }
+            return this.nestAuthService.refreshToken(params.refresh_token);
         }
-        return this.nestAuthService.refreshToken(params.refresh_token);
-    }
 
-    @UseGuards(NestAuthGoogleGuard)
-    @Get("google")
-    async googleAuth(@Request() req): Promise<any> {}
+        @UseGuards(NestAuthGoogleGuard)
+        @Get("google")
+        async googleAuth(@Request() req: any): Promise<any> {}
 
-    @Get("google-redirect")
-    @UseGuards(NestAuthGoogleGuard)
-    googleAuthRedirect(@Request() req) {
-        if (!req.user) {
-            throw new UnauthorizedException("Unable to login with Google");
+        @Get("google-redirect")
+        @UseGuards(NestAuthGoogleGuard)
+        googleAuthRedirect(@Request() req) {
+            if (!req.user) {
+                throw new UnauthorizedException("Unable to login with Google");
+            }
+            return this.nestAuthService.google(req.user);
         }
-        return this.nestAuthService.google(req.user);
-    }
 
-    @Get("/facebook")
-    @UseGuards(NestAuthFacebookGuard)
-    async facebookLogin(): Promise<any> {
-        return HttpStatus.OK;
-    }
+        @Get("/facebook")
+        @UseGuards(NestAuthFacebookGuard)
+        async facebookLogin(): Promise<any> {
+            return HttpStatus.OK;
+        }
 
-    @Get("/facebook-redirect")
-    @UseGuards(NestAuthFacebookGuard)
-    async facebookLoginRedirect(@Request() req): Promise<any> {
-        if (!req.user) {
-            throw new UnauthorizedException("Unable to login with Facebook");
+        @Get("/facebook-redirect")
+        @UseGuards(NestAuthFacebookGuard)
+        async facebookLoginRedirect(@Request() req): Promise<any> {
+            if (!req.user) {
+                throw new UnauthorizedException(
+                    "Unable to login with Facebook",
+                );
+            }
+            return this.nestAuthService.facebook(req.user);
         }
-        return this.nestAuthService.facebook(req.user);
-    }
 
-    @UseGuards(NestAuthLocalGuard)
-    @Get("logout")
-    async logout(@Request() req) {
-        return req.logout();
+        @UseGuards(localGuard)
+        @Get("logout")
+        async logout(@Request() req: any) {
+            return req.logout();
+        }
     }
+
+    return NestAuthController;
 }

package/src/nestauth.module.ts

@@ -1,47 +1,68 @@
-import {
-    Module,
-    DynamicModule,
-    forwardRef,
-    UseFilters,
-    Controller,
-    Inject,
-} from "@nestjs/common";
+import { Module, DynamicModule, Provider, forwardRef } from "@nestjs/common";
 import { ConfigModule } from "@nestjs/config";
 import { NestAuthService } from "./nestauth.service";
-import { NestAuthController } from "./nestauth.controller";
-import { NestAuthModuleOptions } from "./nestauth.interface";
+import { createDynamicController } from "./nestauth.controller";
+import { NestAuthInterface, NestAuthModuleOptions } from "./nestauth.interface";
 import { PassportModule } from "@nestjs/passport";
-import { JwtModule } from "@nestjs/jwt";
+import { JwtModule, JwtService } from "@nestjs/jwt";
 import { NestAuthJwtStrategy } from "./nestauth-jwt.strategy";
-import { NestAuthLocalStrategy } from "./nestauth-local.strategy";
+// import { NestAuthLocalStrategy } from "./nestauth-local.strategy";
 import { NestAuthGoogleStrategy } from "./nestauth-google.strategy";
 import { NestAuthFacebookStrategy } from "./nestauth-facebook.strategy";
 import { StringValue } from "ms";
-import { HttpExceptionFilter } from "./http-exception.filter";
+import { createLocalStrategy } from "./nestauth-local.strategy";
+import { createLocalGuard } from "./nestauth-local.guard";
 
 @Module({
     imports: [PassportModule, ConfigModule.forRoot({})],
 })
 export class NestAuthModule {
-    static register(options: NestAuthModuleOptions): DynamicModule {
-        // Create unique tokens for each module instance
-        const moduleId = options.routePrefix || "default";
-        const AUTH_SERVICE_TOKEN = Symbol(`NestAuthService_${moduleId}`);
-        const USER_SERVICE_TOKEN = Symbol(`UserService_${moduleId}`);
+    static forRoot(options: NestAuthModuleOptions): DynamicModule {
+        const JwtSecretProvider: Provider = {
+            provide: "JWT_SECRET",
+            useValue: options.jwtSecret || "60s",
+        };
+
+        const JwtExpiresInProvider: Provider = {
+            provide: "JWT_EXPIRES_IN",
+            useValue: options.jwtExpiresIn,
+        };
+
+        const JwtRefreshTokenExpiresInProvider: Provider = {
+            provide: "JWT_REFRESH_TOKEN_EXPIRES_IN",
+            useValue: options.jwtRefreshTokenExpiresIn,
+        };
 
         const controllerPath = options.routePrefix
             ? `${options.routePrefix.replace(/^\/|\/$/g, "")}/nestauth`
             : "nestauth";
 
-        @UseFilters(HttpExceptionFilter)
-        @Controller(controllerPath)
-        class DynamicNestAuthController extends NestAuthController {
-            constructor(
-                @Inject(AUTH_SERVICE_TOKEN) nestAuthService: NestAuthService,
-            ) {
-                super(nestAuthService);
-            }
-        }
+        const pathKey = controllerPath.replaceAll("/", "_").toUpperCase();
+
+        const userServiceToken = `NEST_AUTH_USER_SERVICE_${pathKey}`;
+        const nestAuthServiceToken = `NEST_AUTH_SERVICE_${pathKey}`;
+
+        const strategyName = `${pathKey}-local`;
+
+        const LocalStrategy = createLocalStrategy(
+            strategyName,
+            userServiceToken,
+        );
+
+        const LocalGuard = createLocalGuard(strategyName);
+
+        console.log("controllerPath", controllerPath);
+        console.log("pathKey", pathKey);
+        console.log("userServiceToken", userServiceToken);
+        console.log("nestAuthServiceToken", nestAuthServiceToken);
+
+        console.log("------------------------------------------");
+
+        const controller = createDynamicController(
+            controllerPath,
+            nestAuthServiceToken,
+            LocalGuard,
+        );
 
         return {
             module: NestAuthModule,
@@ -61,41 +82,47 @@ export class NestAuthModule {
                 forwardRef(() => options.UserModule),
             ],
             providers: [
-                // NestAuthService with unique token
-                {
-                    provide: AUTH_SERVICE_TOKEN,
-                    useClass: NestAuthService,
-                },
-                // UserService with unique token
                 {
-                    provide: USER_SERVICE_TOKEN,
+                    provide: userServiceToken,
                     useExisting: options.UserService,
                 },
-                // Alias for backward compatibility
-                {
-                    provide: "UserService",
-                    useFactory: (userService) => userService,
-                    inject: [USER_SERVICE_TOKEN],
-                },
                 {
-                    provide: "JWT_SECRET",
-                    useValue: options.jwtSecret,
-                },
-                {
-                    provide: "JWT_EXPIRES_IN",
-                    useValue: options.jwtExpiresIn,
-                },
-                {
-                    provide: "JWT_REFRESH_TOKEN_EXPIRES_IN",
-                    useValue: options.jwtRefreshTokenExpiresIn,
+                    provide: nestAuthServiceToken,
+                    useFactory: (
+                        jwtService: JwtService,
+                        userService: NestAuthInterface,
+                        jwtExpiresIn: StringValue | number,
+                        jwtRefreshTokenExpiresIn: StringValue | number,
+                    ) =>
+                        new NestAuthService(
+                            jwtService,
+                            userService,
+                            jwtExpiresIn,
+                            jwtRefreshTokenExpiresIn,
+                        ),
+                    inject: [
+                        JwtService,
+                        userServiceToken,
+                        "JWT_EXPIRES_IN",
+                        "JWT_REFRESH_TOKEN_EXPIRES_IN",
+                    ],
                 },
                 NestAuthJwtStrategy,
-                NestAuthLocalStrategy,
                 NestAuthGoogleStrategy,
                 NestAuthFacebookStrategy,
+                JwtSecretProvider,
+                JwtExpiresInProvider,
+                JwtRefreshTokenExpiresInProvider,
+                LocalStrategy,
+                LocalGuard,
+
+                // {
+                //     provide: APP_FILTER,
+                //     useClass: HttpExceptionFilter,
+                // },
             ],
-            exports: [AUTH_SERVICE_TOKEN, "UserService"],
-            controllers: [DynamicNestAuthController],
+            exports: [nestAuthServiceToken],
+            controllers: [controller],
         };
     }
 }

package/src/nestauth.service.ts

@@ -12,11 +12,11 @@ import { StringValue } from "ms";
 export class NestAuthService {
     constructor(
         private jwtService: JwtService,
-        @Inject("UserService") private readonly userService: NestAuthInterface,
+        readonly userService: NestAuthInterface,
         @Inject("JWT_EXPIRES_IN")
         private readonly jwtExpiresIn: StringValue | number = "15m",
         @Inject("JWT_REFRESH_TOKEN_EXPIRES_IN")
-        private readonly jwtRefreshTokenExpiresIn: StringValue | number = "7d"
+        private readonly jwtRefreshTokenExpiresIn: StringValue | number = "7d",
     ) {}
 
     async login(user: any): Promise<any> {
@@ -58,7 +58,7 @@ export class NestAuthService {
             const user = await this.userService.getUserById(payload.sub);
             if (!user) {
                 throw new UnauthorizedException(
-                    "Invalid or expired refresh token"
+                    "Invalid or expired refresh token",
                 );
             }
             return this.login(user);