@nestjs/jwt#JwtService TypeScript Examples

/**
   * Inject into AuthService: JwtService, UserService, PasswordService
   *
   * @param jwtService Implements interaction with JWT
   * @param userService Implements interaction with the user entity
   * @param passwordService Implements interaction with bcrypt and compare password
   */
  constructor(
    private readonly jwtService: JwtService,
    private readonly userService: UserService,
    private readonly passwordService: PasswordService
  ) {}

/** initialize a logger with auth context */

  constructor(
    private jwtService: JwtService,

    @Inject(UserService)
    private readonly userService: UserService,
    @Inject(WINSTON_MODULE_PROVIDER)
    private readonly logger = new Logger('auth'),
  ) {}

describe('Auth Controller', () => {
  let controller: AuthController;

  beforeEach(async () => {
    const module: TestingModule = await Test.createTestingModule({
      controllers: [AuthController],
      providers: [
        {
          provide: AuthService,
          useValue: {},
        },
        {
          provide: UsersService,
          useValue: {},
        },
        {
          provide: JwtService,
          useValue: {},
        },
      ],
    }).compile();

    controller = module.get<AuthController>(AuthController);
  });

  it('should be defined', () => {
    expect(controller).toBeDefined();
  });
});

/**
   * Initialize account services
   */
  constructor(
    private jwtService: JwtService,

    @Inject(ApplicationService)
    private readonly applicationService: ApplicationService,

    @Inject(UserService)
    private readonly userService: UserService,

    @Inject(AuthService)
    private readonly authService: AuthService,

    @Inject(WINSTON_MODULE_PROVIDER)
    private readonly logger = new Logger('accounts'),
  ) {}

describe("Testing the TokenServiceBase", () => {
  let tokenServiceBase: TokenServiceBase;
  const jwtService = mock<JwtService>();
  beforeEach(() => {
    tokenServiceBase = new TokenServiceBase(jwtService);
    jwtService.signAsync.mockClear();
  });
  describe("Testing the BasicTokenService.createToken()", () => {
    it("should create valid token for valid username and password", async () => {
      jwtService.signAsync.mockReturnValue(Promise.resolve(SIGN_TOKEN));
      expect(
        await tokenServiceBase.createToken(
          VALID_CREDENTIALS.username,
          VALID_CREDENTIALS.password
        )
      ).toBe(SIGN_TOKEN);
    });
    it("should reject when username missing", () => {
      const result = tokenServiceBase.createToken(
        //@ts-ignore
        null,
        VALID_CREDENTIALS.password
      );
      return expect(result).rejects.toBe(INVALID_USERNAME_ERROR);
    });
    it("should reject when password missing", () => {
      const result = tokenServiceBase.createToken(
        VALID_CREDENTIALS.username,
        //@ts-ignore
        null
      );
      return expect(result).rejects.toBe(INVALID_PASSWORD_ERROR);
    });
  });
});

constructor(
    private readonly jwtService: JwtService,
    private readonly passwordService: PasswordService,
    private readonly prismaService: PrismaService,
    private readonly accountService: AccountService,
    private readonly userService: UserService,
    @Inject(forwardRef(() => WorkspaceService))
    private readonly workspaceService: WorkspaceService
  ) {}

constructor(
    private readonly _jwtService: JwtService,
    private readonly _configService: ConfigService,
    private readonly _userService: UserService,
    private readonly _userAuthService: UserAuthService,
    private readonly _userAuthForgottenPasswordService: UserAuthForgottenPasswordService,
  ) {}

constructor(
    private userService: UserService,
    private jwtService: JwtService,
  ) {}

constructor(protected readonly jwtService: JwtService) {}

constructor(
    private userService: UserService,
    private jwtService: JwtService,
  ) { }

constructor(private readonly usersService: UsersService, private jwtService: JwtService) {}

constructor(
    private userService: UserService,
    private jwtService: JwtService,
    private configService: ConfigService,
    private readonly logger: AppLogger,
  ) {
    this.logger.setContext(AuthService.name);
  }

constructor(
    private userService: UserService,
    private jwtService: JwtService,
    private passwordService: PasswordService,
    private logger: PinoLogger,
  ) {
    logger.setContext(this.constructor.name)
  }

constructor(
    private readonly usersService: UsersService,
    private readonly jwtService: JwtService,
  ) { }

describe('AuthService', () => {
  let service: AuthService
  const userService = { findOne: jest.fn(() => Promise.resolve(new User())) }
  const roleService = { findById: jest.fn(() => Promise.resolve(new Role())) }
  const jwtService = { sign: jest.fn(({ sub, role }) => sub + role) }

  beforeEach(async () => {
    const module: TestingModule = await Test.createTestingModule({
      providers: [
        JwtService,
        UserService,
        RoleService,
        AuthService
      ],
    })
    .overrideProvider(JwtService).useValue(jwtService)
    .overrideProvider(UserService).useValue(userService)
    .overrideProvider(RoleService).useValue(roleService)
    .compile()

    service = module.get<AuthService>(AuthService)
  })

  it('should be defined', () => {
    expect(service).toBeDefined()
  })

  it('should validate user', async () => {
    const id = '123'
    const password = '111'

    await service.validateUser(id, password).catch(() => null)
    
    expect(userService.findOne).toBeCalledWith(id)
  })

  it('should get access token', async () => {
    const userId = '123'
    const roleId = 111
    const user = new User({ id: userId })
    user.role = new Role({ id: roleId })
    const accessToken = userId + roleId

    const result = await service.getAccessToken(user)
    expect(result.access_token).toBe(accessToken)
    expect(jwtService.sign).toBeCalled()
  })
})

constructor(
    private readonly jwtService: JwtService,
    private readonly userService: UserService,
    private readonly roleService: RoleService
  ) {}

constructor(
    @Inject(UserDITokens.UserRepository)
    private readonly userRepository: UserRepositoryPort,
    
    private readonly jwtService: JwtService
  ) {}

constructor(private readonly usersService: UsersService, private readonly jwtService: JwtService) {}

constructor(
    private connection: Connection,
    private loginCourseService: LoginCourseService,
    private jwtService: JwtService,
    private configService: ConfigService,
  ) {}

export function setupIntegrationTest(
  module: Type<any>,
  modifyModule?: ModuleModifier,
): (u?: SupertestOptions) => supertest.SuperTest<supertest.Test> {
  let app: INestApplication;
  let jwtService: JwtService;
  let conn: Connection;

  beforeAll(async () => {
    let testModuleBuilder = Test.createTestingModule({
      imports: [
        module,
        LoginModule,
        TestTypeOrmModule,
        TestConfigModule,
        RedisModule.register([
          { name: 'pub' },
          { name: 'sub' },
          { name: 'db' },
        ]),
      ],
    })
      .overrideProvider(TwilioService)
      .useValue(mockTwilio);

    if (modifyModule) {
      testModuleBuilder = modifyModule(testModuleBuilder);
    }
    const testModule = await testModuleBuilder.compile();

    app = testModule.createNestApplication();
    addGlobalsToApp(app);
    jwtService = testModule.get<JwtService>(JwtService);
    conn = testModule.get<Connection>(Connection);
    await app.init();
  });

  afterAll(async () => {
    await app.close();
    await conn.close();
  });

  beforeEach(async () => {
    await conn.synchronize(true);
  });

  return (options?: SupertestOptions): supertest.SuperTest<supertest.Test> => {
    const agent = supertest.agent(app.getHttpServer());
    if (options?.userId) {
      const token = jwtService.sign({ userId: options.userId });
      agent.set('Cookie', [`auth_token=${token}`]);
    }
    return agent;
  };
}

constructor(private jwtService: JwtService) {}

constructor(
    @InjectRepository(UserRepository)
    private userRepository: UserRepository,
    private jwtService: JwtService,
    private smsService: SmsService,
    private redisClientService: RedisClientService,
  ) {}

constructor(
    private readonly configService: ConfigService,
    private readonly jwtService: JwtService,
    private readonly httpService: HttpService,
    private readonly logger: MyLogger,
  ) {}

constructor(
    private readonly authService: AuthService,
    private readonly jwtService: JwtService,
    private readonly usersService: UsersService,
    private readonly configService: ConfigService,
  ) {}

constructor(
        private jwtService: JwtService,
    ) {
        authServiceInst = this;
        this.init();
    }

constructor(
    public readonly userService: UserService,
    private readonly jwtService: JwtService,
  ) {}

constructor(
    private readonly authService: AuthService,
    private readonly jwtService: JwtService,
    private readonly usersService: UsersService,
    private readonly configService: ConfigService,
  ) { }

constructor(
    private readonly jwtService: JwtService,
    private readonly usersRepository: UsersRepository,
    private readonly authRepository: AuthRepository,
    private readonly configService: ConfigService,
  ) { }

constructor(
    private reflector: Reflector,
    private jwtService: JwtService,
  ) {}