Error unknown authentication strategy local

These are the partial NestJS code snippets I have. I am trying to implement the passport local strategy for getting the username and password. I am getting -Error: Unknown authentication strategy «local», in the controller file when using the auth guard.

AuthModule.ts

import { Module } from '@nestjs/common';
import { JwtModule } from '@nestjs/jwt';
import { PassportModule } from '@nestjs/passport';
import { UserModule } from 'src/user/user.module';
import { JwtAuthController } from './jwt-auth.controller';
import { JwtAuthService } from './jwt-auth.service';
import { JwtStrategy } from './jwt.strategy';
import { LocalStrategy } from './local.strategy';

@Module({
  imports: [
    UserModule,
    PassportModule,
    JwtModule.register({
      secret: process.env.SECRETKEY,
      signOptions: { expiresIn: '3600s' }
    })
  ],
  controllers: [JwtAuthController],
  providers: [JwtAuthService, LocalStrategy, JwtStrategy],
  exports: [JwtAuthService],
})
export class JwtAuthModule {}

local.strategy.ts

import { Strategy } from 'passport-local';
import { PassportStrategy } from '@nestjs/passport';
import { Injectable, UnauthorizedException } from '@nestjs/common';
import { JwtAuthService } from './jwt-auth.service';

@Injectable()
export class LocalStrategy extends PassportStrategy(Strategy, 'local') {
  constructor(private authService: JwtAuthService) {
    super();
  }

  async validate(username: string, password: string): Promise<any> {
    const user = await this.authService.validateUser({username, password});
    if (!user) {
      throw new UnauthorizedException();
    }
    return user;
  }
}

app.controller.ts

import { Body, Controller, Get, Post, Req, UnauthorizedException, UseGuards } from '@nestjs/common';
import { AuthGuard } from '@nestjs/passport';
import { JwtAuthService } from './jwt-auth/jwt-auth.service';

@Controller()
export class AppController {

  constructor(private readonly authService: JwtAuthService)  {}
  
  @UseGuards(AuthGuard('local'))
  @Post('/auth/login')
  async login(@Req() req) {
    return this.authService.login(req.user)
  }
  
}

I am getting the following error on calling /auth/login API

[Nest] 26753  - 10/31/2021, 22:08:18   ERROR [ExceptionsHandler] Unknown authentication strategy "local"
Error: Unknown authentication strategy "local"

Am I missing anything? Thanks in advance.

just add the PassportModule and LocalStrategy in app.module .it will be fixed

@Module({
  imports: [PassportModule],
  providers: [AuthService,LocalStrategy],
 })
 export class AppModule {}

Fix Bug https://github.com/nestjs/nest/issues/4646

File AUTH.ts

enter code here

import { Module } from '@nestjs/common';
import { JwtModule } from '@nestjs/jwt';
import { PassportModule } from '@nestjs/passport';
import { UserModule } from 'src/user/user.module';
import { JwtAuthController } from './jwt-auth.controller';
import { JwtAuthService } from './jwt-auth.service';
import { JwtStrategy } from './jwt.strategy';
import { LocalStrategy } from './local.strategy';

@Module({
imports: [
UserModule,
PassportModule.register({defaultStrategy:'local'}),
JwtModule.register({
  secret: process.env.SECRETKEY,
  signOptions: { expiresIn: '3600s' }
})
],
controllers: [JwtAuthController],
providers: [JwtAuthService, LocalStrategy, JwtStrategy],
exports: [JwtAuthService],
})
export class JwtAuthModule {}

Such an old question with no answers…

In my case I was having sort of an cyclic dependency issue. Or at least it was what it looked like. Cyclic deps can be either on nest side or even on node.js require side (on the second case we end up with empty imports).

Case 1:

@Injectable()
export class MyLocalStrategy extends PassportStrategy(PassportLocalStrategy) {
  hello = 'hello'

  constructor(private authService: AuthService) {
    console.log('load local strategy')
  }
}


@Module({
  imports: [
    CommonModule,
    PassportModule,
    JwtModule.registerAsync({
      async useFactory(config: ConfigService) {
        const jwtSecret = config.get('APP_KEY')
        const expiresIn = config.get('AUTH_TOKEN_EXPIRED')
        return {
          secret: jwtSecret,
          signOptions: {
            expiresIn,
          },
        }
      },
      inject: [ConfigService],
    }),
  ],
  providers: [
    RoleService,
    JwtStrategy,
    JwtService,
    AuthService,
  ],
  controllers: [AuthController],
  exports: [AuthService],
})
export class AuthModule {
  constructor(private moduleRef: ModuleRef) {}

  onModuleInit() {
    const moduleRef = this.moduleRef
    console.log('init auth module')
    const local = moduleRef.get(MyLocalStrategy)
    const auth = moduleRef.get(AuthService)
    console.log('my modules', { local, auth }, local?.hello)
  }
}

In this case the «load local strategy» never got logged. Yet «my modules» logged an empty localStrategy instance, without my «hello» property. Weird!

I hacked a fix by moving the class instantiation to a factory provider, and by requiring the dependencies with ModuleRef. The following excerpt worked fine.

@Module({
  imports: [
    CommonModule,
    PassportModule,
    JwtModule.registerAsync({
      async useFactory(config: ConfigService) {
        const jwtSecret = config.get('APP_KEY')
        const expiresIn = config.get('AUTH_TOKEN_EXPIRED')
        return {
          secret: jwtSecret,
          signOptions: {
            expiresIn,
          },
        }
      },
      inject: [ConfigService],
    }),
  ],
  providers: [
    RoleService,
    JwtStrategy,
    JwtService,
    AuthService,
    {
      provide: MyLocalStrategy,
      useFactory: (moduleRef: ModuleRef) => {
        const auth = moduleRef.get(AuthService)
        console.log('local strat factory', { auth })
        return new MyLocalStrategy(auth)
      },
      inject: [ModuleRef],
    },
  ],
  controllers: [AuthController],
  exports: [AuthService],
})
export class AuthModule {
  constructor(private moduleRef: ModuleRef) {}

  onModuleInit() {
    const moduleRef = this.moduleRef
    console.log('init auth module')
    const local = moduleRef.get(MyLocalStrategy)
    const auth = moduleRef.get(AuthService)
    console.log('local', { local, auth }, local?.hello)
  }
}

I also tried factory + injecting AuthService directly (through providers array, instead of using ModuleRef). I got a null AuthService.

Probably some dependency cycle on the node.js module imports, tough neither eslint or nest wouldn’t say anything.

Check to see if your auth module is being imported in your entry file. app.module.ts.

My auth-module.ts

import { Module } from '@nestjs/common';
import { PassportModule } from '@nestjs/passport';
import { UsersModule } from 'src/users/users.module';
import { AuthService } from './auth.service';
import { LocalStrategy } from './local.strategy';

@Module({
 imports:[UsersModule,PassportModule],
 providers: [AuthService,LocalStrategy]
})
export class AuthModule {}

My app module

import { Module } from '@nestjs/common';
import { PassportModule } from '@nestjs/passport';
import { UsersModule } from 'src/users/users.module';
import { AuthService } from './auth.service';
import { LocalStrategy } from './local.strategy';

@Module({
  imports:[UsersModule,PassportModule],
 providers: [AuthService,LocalStrategy]
})
export class AuthModule {}

NestJs encourages scalability and therefore organizes your code in modules.
Instead of calling JwtAuthService method in the AppController, do it in the JwtAuthController. Your code should look like this:

import { Body, Controller, Get, Post, Req, UnauthorizedException, UseGuards } from '@nestjs/common';
import { AuthGuard } from '@nestjs/passport';
import { JwtAuthService } from './jwt-auth.service';

@Controller('auth')
export class JwtAuthController {
  constructor(private readonly authService: JwtAuthService)  {}
  
  @Post('/login')
  @UseGuards(AuthGuard('local'))
  async login(@Req() req) {
    return req.user
  }
  
}

Nest will then instantiate all providers in the JwtAuthModule such that it will be available in it’s controller (JwtController).

You Can always optimize your code by moving AuthGuard to it own file local.guard.ts given you the possibility to do any additional business logic.

import { ExecutionContext } from '@nestjs/common';
import { AuthGuard } from '@nestjs/passport';
import { Request } from 'express';

export class LocalGuard extends AuthGuard('local') {}

You need to import the module that implements the authentications.

It can be inside app.module.ts or inside another module that is connected to it.

import { Module } from '@nestjs/common';
import { AppController } from './app.controller';
import { AppService } from './app.service';
import { AuthModule } from './auth/auth.module';
import { UsersModule } from './users/users.module';

@Module({
    imports: [UsersModule, AuthModule],
    controllers: [AppController],
    providers: [AppService],
})
export class AppModule {}

I have the same issue with you. My solution is importing LocalStrategy class to module file, in which I use AuthGuard for API endpoint.

For example: in file user.controller.ts I have AuthGuard('local') in the endpoint /login with method POST

//user.controller.ts

@UseGuards(AuthGuard('local'))
@Post('login')
async login (@Request() req: any) {
  return req.user;
}

In my case, I just add LocalStrategy class (I also have this class in local.strategy.ts like you) in module file:

//user.module.ts

@Module({
  imports: [
    ...
    LocalStrategy,
  ],
  controllers: [UserController],
  ...
}

Conclusion, NestJs is quite complicated in importing modules, don’t forget to import what you want into other modules. Good luck!

Comments Section

in which module AppController lives?

AppController is in app.module.ts. I have exported auth.service.ts from the auth.module and auth.module is imported in app.module.ts

Is your JwtAuthService REQUEST scoped?

I tried adding defaultStrategy, but it still is not working. I am getting the same error.

I am new to NESTjs. How can I find out if the JwtAuthService REQUEST scoped?

Try to add the AuthModule to your imports of app.module.ts.

@adhinarayan did you get a solution? I am also facing the same problem not sure how to resolve this.

how did you resolve this @adhinarayan?

Had the same issue here with cyclic dependency. I was injecting the @Inject(REQUEST) in a service.

Related Topics
javascript
authentication
passport.js
nestjs
passport-local

Mentions
Adhi Narayan
Prakit Worarakuksorn
Marco Kuidja
Wkrueger
Mhmmdamiwn
Abdurrahman Y
Ampomah Winston

References
stackoverflow.com/questions/69788605/nestjs-error-unknown-authentication-strategy-local