@boarteam/boar-pack-users-backend 8.0.0 → 8.1.1

package/src/auth/auth.constants.ts

@@ -1,2 +0,0 @@
-export const tokenName = 'auth_token';
-export const refreshTokenName = 'auth_refresh_token';

package/src/auth/auth.controller.ts

@@ -1,54 +0,0 @@
-import { Controller, Post, Req, Res, UnauthorizedException, UseGuards } from '@nestjs/common';
-import { ApiTags } from '@nestjs/swagger';
-import type { Request, Response } from 'express';
-import { AuthService } from './auth.service';
-import { JwtAuthGuard, SkipJWTGuard } from '../jwt-auth/jwt-auth.guard';
-import { SkipPoliciesGuard } from '../casl/policies.guard';
-import { LocalAuthTokenDto } from "./local-auth/local-auth.dto";
-import { JwtAuthRefreshGuard } from "../jwt-auth/jwt-auth.refresh.guard";
-
-@SkipPoliciesGuard()
-@ApiTags('Authentication')
-@Controller('auth')
-export default class AuthController {
-  constructor(private authService: AuthService) {
-  }
-
-  @Post('token')
-  @UseGuards(JwtAuthGuard)
-  async token(
-    @Req() req: Request,
-  ): Promise<LocalAuthTokenDto> {
-    if (!req.user) {
-      throw new UnauthorizedException(`User is not authorized`);
-    }
-    return this.authService.login(req.user);
-  }
-
-  @Post('logout')
-  async logout(
-    @Req() req: Request,
-    @Res({ passthrough: true }) res: Response,
-  ) {
-    if (req.jwt) {
-      await this.authService.logout(req.jwt);
-    }
-
-    this.authService.clearCookies(res);
-  }
-
-  @SkipJWTGuard()
-  @UseGuards(JwtAuthRefreshGuard)
-  @Post('refresh')
-  async refresh(
-    @Req() req: Request,
-    @Res({ passthrough: true }) res: Response,
-  ): Promise<void> {
-    if (!req.user) {
-      throw new UnauthorizedException(`User is not authorized`);
-    }
-
-    const tokens = await this.authService.login(req.user);
-    this.authService.setCookie(res, tokens);
-  }
-}

package/src/auth/auth.exception-filter.ts

@@ -1,15 +0,0 @@
-import { ArgumentsHost, Catch, ExceptionFilter } from '@nestjs/common';
-import { HttpException } from '@nestjs/common/exceptions/http.exception';
-
-@Catch(HttpException)
-export class AuthExceptionFilter implements ExceptionFilter {
-  catch(exception: HttpException, host: ArgumentsHost) {
-    const ctx = host.switchToHttp();
-    const response = ctx.getResponse();
-    const status = exception.getStatus();
-
-    response
-      .status(status)
-      .redirect('/user/login?error=' + encodeURIComponent(exception.message));
-  }
-}

package/src/auth/auth.module.ts

@@ -1,118 +0,0 @@
-import { DynamicModule, Module } from '@nestjs/common';
-import { AuthService } from './auth.service';
-import { UsersModule } from '../users/users.module';
-import { LocalAuthStrategy } from './local-auth/local-auth.strategy';
-import { PassportModule } from '@nestjs/passport';
-import AuthController from './auth.controller';
-import { ConfigModule } from '@nestjs/config';
-import { GoogleAuthStrategy } from './google/google-auth.strategy';
-import { GoogleAuthConfigService } from "./google/google-auth.config";
-import { MSAuthStrategy } from './microsoft/ms-auth.strategy';
-import { MSAuthConfigService } from "./microsoft/ms-auth.config";
-import { JwtAuthModule } from "../jwt-auth/jwt-auth.module";
-import { APP_GUARD } from "@nestjs/core";
-import { JwtAuthGuard } from "../jwt-auth/jwt-auth.guard";
-import AuthManageController from "./auth-manage.controller";
-import GoogleAuthController from "./google/google-auth.controller";
-import MsAuthController from "./microsoft/ms-auth.controller";
-import LocalAuthController from "./local-auth/local-auth.controller";
-import { YandexAuthStrategy } from "./yandex/yandex-auth.strategy";
-import { YandexAuthConfigService } from "./yandex/yandex-auth.config";
-import YandexAuthController from "./yandex/yandex-auth.controller";
-import { AuthConfigService } from "./auth.config";
-
-@Module({})
-export class AuthModule {
-  static forRoot(config: {
-    googleAuth?: boolean,
-    msAuth?: boolean,
-    yandexAuth?: boolean,
-    localAuth?: boolean,
-    withControllers?: boolean,
-    dataSourceName?: string;
-  }): DynamicModule {
-    const dynamicModule: DynamicModule = {
-      module: AuthModule,
-      imports: [
-        ConfigModule,
-        UsersModule.register({
-          withControllers: false,
-          dataSourceName: config.dataSourceName,
-        }),
-        PassportModule,
-        JwtAuthModule.register({
-          dataSourceName: config.dataSourceName,
-        }),
-      ],
-      providers: [
-        AuthService,
-        AuthConfigService,
-        {
-          provide: APP_GUARD,
-          useClass: JwtAuthGuard,
-        },
-      ],
-      controllers: [],
-      exports: [],
-    };
-
-    const controllers = [];
-    if (config.googleAuth) {
-      dynamicModule.providers!.push(GoogleAuthConfigService, GoogleAuthStrategy);
-      controllers.push(GoogleAuthController);
-    }
-
-    if (config.msAuth) {
-      dynamicModule.providers!.push(MSAuthConfigService, MSAuthStrategy);
-      controllers.push(MsAuthController);
-    }
-
-    if (config.yandexAuth) {
-      dynamicModule.providers!.push(YandexAuthConfigService, YandexAuthStrategy);
-      controllers.push(YandexAuthController);
-    }
-
-    if (config.localAuth) {
-      dynamicModule.providers!.push(LocalAuthStrategy);
-      controllers.push(LocalAuthController);
-    }
-
-    if (config.withControllers) {
-      dynamicModule.controllers = [
-        ...controllers,
-        AuthController,
-        AuthManageController,
-      ];
-    }
-
-    return dynamicModule;
-  }
-
-  static forFeature(config: {
-    dataSourceName?: string;
-  }): DynamicModule {
-    return {
-      module: AuthModule,
-      imports: [
-        ConfigModule,
-        UsersModule.register({
-          withControllers: false,
-          dataSourceName: config.dataSourceName,
-        }),
-        JwtAuthModule.register({
-          dataSourceName: config.dataSourceName,
-        }),
-      ],
-      providers: [
-        AuthConfigService,
-        AuthService,
-        {
-          provide: APP_GUARD,
-          useClass: JwtAuthGuard,
-        },
-      ],
-      controllers: [],
-      exports: [],
-    };
-  }
-}

package/src/auth/auth.service.ts

@@ -1,122 +0,0 @@
-import { Injectable, Logger } from '@nestjs/common';
-import { TUser, UsersService } from '../users';
-import { JWTAuthService, TJWTPayload, TJWTRefreshPayload } from '../jwt-auth';
-import bcrypt from 'bcrypt';
-import { LocalAuthTokenDto } from "./local-auth/local-auth.dto";
-import { Response } from 'express';
-import { refreshTokenName, tokenName } from "./auth.constants";
-import { AuthConfigService, TAuthConfig } from "./auth.config";
-import { TOKEN_TYPE } from "../revoked-tokens";
-
-declare global {
-  namespace Express {
-    interface User extends TUser {}
-    interface Request {
-      jwt?: TJWTPayload;
-    }
-  }
-}
-
-@Injectable()
-export class AuthService {
-  private readonly logger = new Logger(AuthService.name);
-  private readonly config: TAuthConfig;
-
-  constructor(
-    private usersService: UsersService,
-    private jwtAuthService: JWTAuthService,
-    private readonly authConfigService: AuthConfigService,
-  ) {
-    this.config = this.authConfigService.config;
-  }
-
-  async validateUser(email: string, pass: string): Promise<TUser | null> {
-    const user = await this.usersService.findByEmail(email);
-    if (!user?.pass) {
-      return null;
-    }
-
-    if (user && (await bcrypt.compare(pass, user.pass))) {
-      const { pass, ...result } = user;
-      return result;
-    }
-    return null;
-  }
-
-  async validateUserByEmail(email?: string): Promise<TUser | null> {
-    if (!email) {
-      this.logger.error('Email is not provided to validateUserByEmail');
-      return null;
-    }
-
-    const user = await this.usersService.findByEmail(email);
-    if (user) {
-      const { pass, ...result } = user;
-      return result;
-    }
-    return null;
-  }
-
-  async login(user: Pick<TUser, 'email' | 'id'>): Promise<LocalAuthTokenDto> {
-    const sid = this.jwtAuthService.generateJwtId();
-    const payload: TJWTPayload = {
-      email: user.email,
-      sub: user.id,
-      sid,
-    };
-    const refreshPayload: TJWTRefreshPayload = {
-      sub: user.id,
-      sid,
-    }
-    return {
-      accessToken: this.jwtAuthService.sign(payload, TOKEN_TYPE.ACCESS),
-      refreshToken: this.jwtAuthService.sign(refreshPayload, TOKEN_TYPE.REFRESH),
-    };
-  }
-
-  async logout(jwt: TJWTPayload): Promise<void> {
-    if (!jwt.jti || !jwt.exp) {
-      this.logger.warn('JWT does not have JTI or exp, cannot revoke it');
-      return;
-    }
-
-    await this.jwtAuthService.revokeToken({
-      jti: jwt.jti,
-      expiresAt: new Date(jwt.exp * 1000),
-      tokenType: TOKEN_TYPE.ACCESS,
-      sid: jwt.sid || null,
-    });
-    this.logger.log(`User with id ${jwt.sub} has been logged out and token revoked`);
-  }
-
-  public setCookie(res: Response, tokens: LocalAuthTokenDto): void {
-    res.cookie(tokenName, tokens.accessToken.token, {
-      httpOnly: true,
-      secure: process.env.SECURE_COOKIE === 'true',
-      sameSite: 'lax',
-      maxAge: tokens.accessToken.payload.exp && Math.max((tokens.accessToken.payload.exp * 1000) - Date.now(), 0),
-    });
-
-    res.cookie(refreshTokenName, tokens.refreshToken.token, {
-      httpOnly: true,
-      secure: process.env.SECURE_COOKIE === 'true',
-      sameSite: 'lax',
-      maxAge: tokens.refreshToken.payload.exp && Math.max((tokens.refreshToken.payload.exp * 1000) - Date.now(), 0),
-      path: this.config.refreshTokenPath,
-    });
-  }
-
-  public clearCookies(res: Response): void {
-    res.clearCookie(tokenName, {
-      httpOnly: true,
-      secure: process.env.SECURE_COOKIE === 'true',
-      sameSite: 'lax',
-    });
-    res.clearCookie(refreshTokenName, {
-      httpOnly: true,
-      secure: process.env.SECURE_COOKIE === 'true',
-      sameSite: 'lax',
-      path: this.config.refreshTokenPath,
-    });
-  }
-}

package/src/auth/google/google-auth.config.ts

@@ -1,26 +0,0 @@
-import { Injectable } from '@nestjs/common';
-import { ConfigService } from '@nestjs/config';
-
-export type TGoogleAuthConfig = {
-  clientId: string;
-  clientSecret: string;
-  callbackURL: string;
-};
-
-@Injectable()
-export class GoogleAuthConfigService {
-  constructor(private configService: ConfigService) {
-  }
-
-  get config(): TGoogleAuthConfig {
-    const clientId = this.configService.getOrThrow<string>('GOOGLE_CLIENT_ID');
-    const clientSecret = this.configService.getOrThrow<string>('GOOGLE_SECRET_ID');
-    const callbackURL = this.configService.getOrThrow<string>('GOOGLE_CALLBACK_URL');
-
-    return {
-      clientId,
-      clientSecret,
-      callbackURL,
-    };
-  }
-}

package/src/auth/google/google-auth.controller.ts

@@ -1,39 +0,0 @@
-import { Controller, Get, Req, Res, UnauthorizedException, UseFilters, UseGuards } from '@nestjs/common';
-import { ApiTags } from '@nestjs/swagger';
-import type { Request, Response } from 'express';
-import { AuthService } from '../auth.service';
-import { SkipJWTGuard } from '../../jwt-auth/jwt-auth.guard';
-import { SkipPoliciesGuard } from '../../casl/policies.guard';
-import { GoogleAuthGuard } from './google-auth.guard';
-import { AuthExceptionFilter } from '../auth.exception-filter';
-
-@SkipPoliciesGuard()
-@ApiTags('Authentication')
-@Controller('auth/google')
-export default class GoogleAuthController {
-  constructor(private authService: AuthService) {
-  }
-
-  @SkipJWTGuard()
-  @UseGuards(GoogleAuthGuard)
-  @Get('')
-  async loginGoogle() {
-  }
-
-  @SkipJWTGuard()
-  @UseGuards(GoogleAuthGuard)
-  @UseFilters(AuthExceptionFilter)
-  @Get('callback')
-  async loginGoogleCallback(
-    @Req() req: Request,
-    @Res({ passthrough: true }) res: Response,
-  ) {
-    if (!req.user) {
-      throw new UnauthorizedException(`User is not authorized`);
-    }
-
-    const tokens = await this.authService.login(req.user);
-    this.authService.setCookie(res, tokens);
-    res.redirect('/');
-  }
-}

package/src/auth/google/google-auth.guard.ts

@@ -1,6 +0,0 @@
-import { Injectable } from '@nestjs/common';
-import { AuthGuard } from '@nestjs/passport';
-import { GOOGLE_AUTH } from '../auth-strategies.constants';
-
-@Injectable()
-export class GoogleAuthGuard extends AuthGuard(GOOGLE_AUTH) {}

package/src/auth/google/google-auth.strategy.ts

@@ -1,59 +0,0 @@
-import { Strategy, VerifyCallback } from 'passport-google-oauth20';
-import { PassportStrategy } from '@nestjs/passport';
-import {
-  Injectable,
-  InternalServerErrorException,
-  Logger,
-  UnauthorizedException,
-} from '@nestjs/common';
-import { AuthService } from '../auth.service';
-import { GOOGLE_AUTH } from '../auth-strategies.constants';
-import { GoogleAuthConfigService } from "./google-auth.config";
-
-@Injectable()
-export class GoogleAuthStrategy extends PassportStrategy(
-  Strategy,
-  GOOGLE_AUTH,
-) {
-  private readonly logger = new Logger(GoogleAuthStrategy.name);
-
-  constructor(
-    private authService: AuthService,
-    private googleAuthConfigService: GoogleAuthConfigService,
-  ) {
-    const config = googleAuthConfigService.config;
-    super({
-      clientID: config.clientId,
-      clientSecret: config.clientSecret,
-      callbackURL: config.callbackURL,
-      scope: ['email', 'profile'],
-    });
-  }
-
-  async validate(
-    accessToken: string,
-    refreshToken: string,
-    profile: { emails: { value: string; verified: boolean }[] },
-    callback: VerifyCallback,
-  ): Promise<any> {
-    try {
-      const user = await this.authService.validateUserByEmail(
-        profile.emails[0].value,
-      );
-
-      if (!user) {
-        callback(new UnauthorizedException('User is not found'));
-        return;
-      }
-
-      callback(null, user);
-    } catch (e) {
-      this.logger.error(e, e.stack);
-      callback(
-        new InternalServerErrorException(
-          'Impossible to log in user via google',
-        ),
-      );
-    }
-  }
-}

package/src/auth/index.ts

@@ -1,15 +0,0 @@
-export * from './auth.constants';
-export * from './auth.controller';
-export * from './auth.module';
-export * from './auth.service';
-export * from './auth-strategies.constants';
-export * from './google/google-auth.config';
-export * from './auth.exception-filter';
-export * from './google/google-auth.guard';
-export * from './google/google-auth.strategy';
-export * from './local-auth/local-auth.dto';
-export * from './local-auth/local-auth.guard';
-export * from './local-auth/local-auth.strategy';
-export * from './microsoft/ms-auth.config';
-export * from './microsoft/ms-auth.guard';
-export * from './microsoft/ms-auth.strategy';

package/src/auth/local-auth/local-auth.controller.ts

@@ -1,37 +0,0 @@
-import { Body, Controller, Post, Req, Res, UnauthorizedException, UseGuards } from '@nestjs/common';
-import { ApiExtraModels, ApiTags } from '@nestjs/swagger';
-import type { Request, Response } from 'express';
-import { LocalAuthGuard } from './local-auth.guard';
-import { AuthService } from '../auth.service';
-import { SkipJWTGuard } from '../../jwt-auth/jwt-auth.guard';
-import { SkipPoliciesGuard } from '../../casl/policies.guard';
-import { LocalAuthLoginDto, LocalAuthTokenDto } from "./local-auth.dto";
-import { SkipEventsLog } from "../../event-logs";
-
-@SkipPoliciesGuard()
-@ApiTags('Authentication')
-@ApiExtraModels(LocalAuthTokenDto)
-@Controller('auth')
-export default class LocalAuthController {
-  constructor(private authService: AuthService) {
-  }
-
-  @SkipJWTGuard()
-  @UseGuards(LocalAuthGuard)
-  @Post('login')
-  @SkipEventsLog({
-    body: ['password'],
-  })
-  async login(
-    @Req() req: Request,
-    @Res({ passthrough: true }) res: Response,
-    @Body() body: LocalAuthLoginDto,
-  ): Promise<LocalAuthTokenDto> {
-    if (!req.user) {
-      throw new UnauthorizedException(`User is not authorized`);
-    }
-    const tokens = await this.authService.login(req.user);
-    this.authService.setCookie(res, tokens);
-    return tokens;
-  }
-}

package/src/auth/local-auth/local-auth.dto.ts

@@ -1,17 +0,0 @@
-import { TJWTPayload, TJWTRefreshPayload } from "../../jwt-auth";
-
-export class LocalAuthLoginDto {
-  email: string;
-  password: string;
-}
-
-export class LocalAuthTokenDto {
-  accessToken: {
-    token: string;
-    payload: TJWTPayload;
-  };
-  refreshToken: {
-    token: string;
-    payload: TJWTRefreshPayload;
-  }
-}

package/src/auth/local-auth/local-auth.guard.ts

@@ -1,6 +0,0 @@
-import { Injectable } from '@nestjs/common';
-import { AuthGuard } from '@nestjs/passport';
-import { LOCAL_AUTH } from '../auth-strategies.constants';
-
-@Injectable()
-export class LocalAuthGuard extends AuthGuard(LOCAL_AUTH) {}

package/src/auth/local-auth/local-auth.strategy.ts

@@ -1,21 +0,0 @@
-import { Strategy } from 'passport-local';
-import { PassportStrategy } from '@nestjs/passport';
-import { Injectable, UnauthorizedException } from '@nestjs/common';
-import { AuthService } from '../auth.service';
-import { TUser } from '../../users';
-import { LOCAL_AUTH } from '../auth-strategies.constants';
-
-@Injectable()
-export class LocalAuthStrategy extends PassportStrategy(Strategy, LOCAL_AUTH) {
-  constructor(private authService: AuthService) {
-    super({ usernameField: 'email' });
-  }
-
-  async validate(email: string, password: string): Promise<TUser> {
-    const user = await this.authService.validateUser(email.trim().toLowerCase(), password);
-    if (!user) {
-      throw new UnauthorizedException();
-    }
-    return user;
-  }
-}

package/src/auth/microsoft/ms-auth.config.ts

@@ -1,29 +0,0 @@
-import { Injectable } from '@nestjs/common';
-import { ConfigService } from '@nestjs/config';
-
-export type TMSAuthConfig = {
-  clientId: string;
-  tenantId: string;
-  clientSecret: string;
-  callbackURL: string;
-};
-
-@Injectable()
-export class MSAuthConfigService {
-  constructor(private configService: ConfigService) {
-  }
-
-  get config(): TMSAuthConfig {
-    const clientId = this.configService.getOrThrow<string>('MICROSOFT_CLIENT_ID');
-    const tenantId = this.configService.getOrThrow<string>('MICROSOFT_TENANT_ID');
-    const clientSecret = this.configService.getOrThrow<string>('MICROSOFT_SECRET_ID');
-    const callbackURL = this.configService.getOrThrow<string>('MICROSOFT_CALLBACK_URL');
-
-    return {
-      clientId,
-      tenantId,
-      clientSecret,
-      callbackURL,
-    };
-  }
-}

package/src/auth/microsoft/ms-auth.controller.ts

@@ -1,40 +0,0 @@
-import { Controller, Get, Req, Res, UnauthorizedException, UseFilters, UseGuards } from '@nestjs/common';
-import { ApiTags } from '@nestjs/swagger';
-import type { Request, Response } from 'express';
-import { AuthService } from '../auth.service';
-import { tokenName } from '../auth.constants';
-import { SkipJWTGuard } from '../../jwt-auth/jwt-auth.guard';
-import { SkipPoliciesGuard } from '../../casl/policies.guard';
-import { AuthExceptionFilter } from '../auth.exception-filter';
-import { MSAuthGuard } from "./ms-auth.guard";
-
-@SkipPoliciesGuard()
-@ApiTags('Authentication')
-@Controller('auth/ms')
-export default class MsAuthController {
-  constructor(private authService: AuthService) {
-  }
-
-  @SkipJWTGuard()
-  @UseGuards(MSAuthGuard)
-  @Get('')
-  async loginMS() {
-  }
-
-  @SkipJWTGuard()
-  @UseGuards(MSAuthGuard)
-  @UseFilters(AuthExceptionFilter)
-  @Get('callback')
-  async loginMSCallback(
-    @Req() req: Request,
-    @Res({ passthrough: true }) res: Response,
-  ) {
-    if (!req.user) {
-      throw new UnauthorizedException(`User is not authorized`);
-    }
-
-    const tokens = await this.authService.login(req.user);
-    this.authService.setCookie(res, tokens);
-    res.redirect('/');
-  }
-}

package/src/auth/microsoft/ms-auth.guard.ts

@@ -1,8 +0,0 @@
-import { Injectable } from '@nestjs/common';
-import { AuthGuard } from '@nestjs/passport';
-import { MS_AUTH } from '../auth-strategies.constants';
-
-@Injectable()
-export class MSAuthGuard extends AuthGuard(MS_AUTH) {
-
-}