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

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

@@ -1,63 +0,0 @@
-import { PassportStrategy } from '@nestjs/passport';
-import { Injectable, InternalServerErrorException, Logger, UnauthorizedException, } from '@nestjs/common';
-import { AuthService } from '../auth.service';
-import { MS_AUTH } from '../auth-strategies.constants';
-import { MSAuthConfigService } from "./ms-auth.config";
-import { JWTAuthService } from "../../jwt-auth/jwt-auth.service";
-
-// @ts-ignore-next-line There are no types for this package
-import { Strategy, VerifyCallback } from 'passport-azure-ad-oauth2';
-
-@Injectable()
-export class MSAuthStrategy extends PassportStrategy(
-  Strategy,
-  MS_AUTH,
-) {
-  private readonly logger = new Logger(MSAuthStrategy.name);
-
-  constructor(
-    private authService: AuthService,
-    private msAuthConfigService: MSAuthConfigService,
-    private jwtAuthService: JWTAuthService,
-  ) {
-    const config = msAuthConfigService.config;
-    super({
-      clientID: config.clientId,
-      clientSecret: config.clientSecret,
-      callbackURL: config.callbackURL,
-      tenant: config.tenantId,
-    });
-  }
-
-  async validate(
-    accessToken: string,
-    refreshToken: string,
-    profile: any,
-    callback: VerifyCallback,
-  ): Promise<any> {
-    this.logger.debug(`accessToken: ${accessToken}`);
-    this.logger.debug(`refreshToken: ${refreshToken}`);
-    this.logger.debug(`profile: ${JSON.stringify(profile)}`);
-    const token = this.jwtAuthService.decode<{ email?: string, upn?: string }>(accessToken);
-    this.logger.debug(`token: ${JSON.stringify(token)}`);
-    try {
-      const user = await this.authService.validateUserByEmail(
-        token.email || token.upn,
-      );
-
-      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 ms',
-        ),
-      );
-    }
-  }
-}

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

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

package/src/auth/yandex/yandex-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 { YandexAuthGuard } from './yandex-auth.guard';
-import { AuthExceptionFilter } from '../auth.exception-filter';
-
-@SkipPoliciesGuard()
-@ApiTags('Authentication')
-@Controller('auth/yandex')
-export default class YandexAuthController {
-  constructor(private authService: AuthService) {
-  }
-
-  @SkipJWTGuard()
-  @UseGuards(YandexAuthGuard)
-  @Get('')
-  async loginYandex() {
-  }
-
-  @SkipJWTGuard()
-  @UseGuards(YandexAuthGuard)
-  @UseFilters(AuthExceptionFilter)
-  @Get('callback')
-  async loginYandexCallback(
-    @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/yandex/yandex-auth.guard.ts

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

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

@@ -1,59 +0,0 @@
-import { Strategy } from 'passport-yandex';
-import { PassportStrategy } from '@nestjs/passport';
-import {
-  Injectable,
-  InternalServerErrorException,
-  Logger,
-  UnauthorizedException,
-} from '@nestjs/common';
-import { AuthService } from '../auth.service';
-import { YANDEX_AUTH } from '../auth-strategies.constants';
-import { YandexAuthConfigService } from "./yandex-auth.config";
-import { TUser } from "../../users";
-
-@Injectable()
-export class YandexAuthStrategy extends PassportStrategy(
-  Strategy,
-  YANDEX_AUTH,
-) {
-  private readonly logger = new Logger(YandexAuthStrategy.name);
-
-  constructor(
-    private authService: AuthService,
-    private yandexAuthConfigService: YandexAuthConfigService,
-  ) {
-    const config = yandexAuthConfigService.config;
-    super({
-      clientID: config.clientId,
-      clientSecret: config.clientSecret,
-      callbackURL: config.callbackURL,
-    });
-  }
-
-  async validate(
-    accessToken: string,
-    refreshToken: string,
-    profile: { emails: { value: string; verified: boolean }[] },
-    callback: (error: Error | null, user?: TUser | null) => void,
-  ): 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 yandex',
-        ),
-      );
-    }
-  }
-}

package/src/bcrypt/bcrypt.config.ts

@@ -1,27 +0,0 @@
-import { Injectable } from '@nestjs/common';
-import { ConfigService } from '@nestjs/config';
-
-export type TBcryptConfig = {
-  saltRounds: number;
-  experimentalFeatures: string[];
-};
-
-@Injectable()
-export class BcryptConfigService {
-  constructor(private configService: ConfigService) {
-  }
-
-  get config(): TBcryptConfig {
-    const saltRounds = Number.parseInt(this.configService.get<string>('BCRYPT_SALT_ROUNDS', ''), 10);
-    const experimentalFeatures = this.configService.get<string>('EXPERIMENTAL_FEATURES');
-
-    if (!Number.isInteger(saltRounds)) {
-      throw new Error('BCRYPT_SALT_ROUNDS is not defined, set it as integer');
-    }
-
-    return {
-      saltRounds,
-      experimentalFeatures: experimentalFeatures ? experimentalFeatures.split(',') : [],
-    };
-  }
-}

package/src/bcrypt/bcrypt.module.ts

@@ -1,19 +0,0 @@
-import { Module } from "@nestjs/common";
-import BcryptService from "./bcrypt.service";
-import { ConfigModule } from "@nestjs/config";
-import { BcryptConfigService } from "./bcrypt.config";
-
-@Module({
-  imports: [
-    ConfigModule,
-  ],
-  providers: [
-    BcryptService,
-    BcryptConfigService,
-  ],
-  exports: [
-    BcryptService,
-  ],
-})
-export class BcryptModule {
-}

package/src/bcrypt/bcrypt.service.ts

@@ -1,24 +0,0 @@
-import { Injectable } from "@nestjs/common";
-import { TBcryptConfig, BcryptConfigService } from "./bcrypt.config";
-import bcrypt from "bcrypt";
-
-@Injectable()
-export class BcryptService {
-  private config: TBcryptConfig;
-
-  constructor(
-    private bcryptConfig: BcryptConfigService,
-  ) {
-    this.config = this.bcryptConfig.config;
-  }
-
-  hashPassword(password: string): Promise<string> {
-    return bcrypt.hash(password, this.config.saltRounds);
-  }
-
-  compare(password: string, hash: string): Promise<boolean> {
-    return bcrypt.compare(password, hash);
-  }
-}
-
-export default BcryptService;

package/src/bcrypt/index.ts

@@ -1,3 +0,0 @@
-export * from './bcrypt.module';
-export * from './bcrypt.service';
-export * from './bcrypt.config';

package/src/casl/action.enum.ts

@@ -1,7 +0,0 @@
-export enum Action {
-  Manage = 'manage',
-  Create = 'create',
-  Read = 'read',
-  Update = 'update',
-  Delete = 'delete',
-}

package/src/casl/casl-ability.factory.ts

@@ -1,130 +0,0 @@
-import {
-  AbilityBuilder,
-  createMongoAbility,
-  ExtractSubjectType,
-  InferSubjects,
-  MongoAbility,
-  RawRule,
-} from '@casl/ability';
-import { Roles, User } from '../users/entities/user.entity';
-import { Action } from './action.enum';
-import { Injectable, Logger } from '@nestjs/common';
-import { PackRule, packRules } from '@casl/ability/extra';
-import { Permission } from '../users/entities/permissions';
-import { EventLog } from '../event-logs';
-import { Token } from "../tokens/entities/token.entity";
-import { MyToken } from "../tokens/policies/manage-my-tokens.policy";
-import { Setting } from "../settings/entities/setting.entity";
-
-type AnyObject = Record<PropertyKey, unknown>;
-
-export interface TSubjects {
-  User: typeof User;
-  EventLog: typeof EventLog;
-  Token: typeof Token;
-  MyToken: typeof MyToken;
-  Setting: typeof Setting;
-}
-
-export type TTextSubjects = 'all';
-
-export type TSubjectsNames =
-  | keyof TSubjects
-  | TTextSubjects;
-export type Subjects =
-  | InferSubjects<TSubjects[keyof TSubjects]>
-  | TTextSubjects;
-
-export type AppAbility = MongoAbility<[Action, Subjects], AnyObject>;
-
-type TAbilityDefiner = (
-  user: Pick<User, 'id' | 'role' | 'permissions'>,
-  can: AbilityBuilder<AppAbility>['can'],
-  cannot: AbilityBuilder<AppAbility>['cannot'],
-) => Promise<void>;
-
-@Injectable()
-export class CaslAbilityFactory {
-  private static permissionsToActionsMap: {
-    [key in Permission]?: {
-      action: Action;
-      subject: Subjects | Subjects[];
-    }
-  } = {};
-
-  private static abilitiesDefiners: Set<TAbilityDefiner> = new Set();
-  private logger = new Logger(CaslAbilityFactory.name);
-
-  public static addPermissionToAction({
-    permission, action, subject,
-  }: {
-    permission: Permission,
-    action: Action,
-    subject: Subjects | Subjects[],
-  }) {
-    CaslAbilityFactory.permissionsToActionsMap[permission] = {
-      action,
-      subject
-    };
-  }
-
-  public static addAbilitiesDefiner(definer: TAbilityDefiner) {
-    CaslAbilityFactory.abilitiesDefiners.add(definer);
-  }
-
-  public async createForUser(user: Pick<User, 'id' | 'role' | 'permissions'>) {
-    const { can, cannot, build } = new AbilityBuilder<AppAbility>(createMongoAbility);
-
-    switch (user.role) {
-      case Roles.ADMIN:
-        can(Action.Manage, 'all');
-        break;
-
-      case Roles.USER:
-        user.permissions.forEach((permission) => {
-          const actionAndSubject = CaslAbilityFactory.permissionsToActionsMap[permission];
-          if (!actionAndSubject) {
-            this.logger.warn(`Unknown permission: ${permission}`);
-            return;
-          }
-
-          const { action, subject } = actionAndSubject;
-          // @ts-ignore
-          can(action, subject);
-        });
-        break;
-    }
-
-    await Promise.all(
-      Array.from(CaslAbilityFactory.abilitiesDefiners).map((definer) => definer(user, can, cannot)),
-    );
-
-    return build({
-      // Read https://casl.js.org/v5/en/guide/subject-type-detection#use-classes-as-subject-types for details
-      detectSubjectType: (item) =>
-        item.constructor as ExtractSubjectType<Subjects>,
-    });
-  }
-
-  packAbility(ability: AppAbility): PackRule<RawRule>[] {
-    return packRules(
-      ability.rules.map((rule) => ({
-        action: rule.action,
-        subject: rule.subject,
-        inverted: rule.inverted,
-        conditions: rule.conditions,
-      })),
-      (item) => {
-        if (typeof item === 'string') {
-          return item;
-        }
-
-        if (Array.isArray(item)) {
-          throw new Error('Cannot serialize ability');
-        }
-
-        return item.name;
-      },
-    );
-  }
-}

package/src/casl/casl.module.ts

@@ -1,31 +0,0 @@
-import { Module } from '@nestjs/common';
-import { CaslAbilityFactory } from './casl-ability.factory';
-import { APP_GUARD } from '@nestjs/core';
-import { PoliciesGuard } from './policies.guard';
-
-@Module({})
-export class CaslModule {
-  static forRoot() {
-    return {
-      module: CaslModule,
-      providers: [
-        CaslAbilityFactory,
-        {
-          provide: APP_GUARD,
-          useClass: PoliciesGuard,
-        },
-      ],
-      exports: [CaslAbilityFactory],
-    }
-  }
-
-  static forFeature() {
-    return {
-      module: CaslModule,
-      providers: [
-        CaslAbilityFactory,
-      ],
-      exports: [CaslAbilityFactory],
-    }
-  }
-}

package/src/casl/fields-permission.interceptor.ts

@@ -1,58 +0,0 @@
-// fields-permission.interceptor.ts
-import { CallHandler, ExecutionContext, ForbiddenException, Injectable, NestInterceptor, } from '@nestjs/common';
-import { permittedFieldsOf } from '@casl/ability/extra';
-import { Observable } from 'rxjs';
-import { Request } from 'express';
-import { Action } from "./action.enum";
-import { Subjects } from "./casl-ability.factory";
-import { PARSED_CRUD_REQUEST_KEY } from "@dataui/crud/lib/constants";
-
-type Fields = string[] | undefined;
-
-@Injectable()
-export class FieldsPermissionInterceptor implements NestInterceptor {
-  constructor(
-    private readonly subject: Subjects,
-    private readonly action: Action,
-  ) {
-  }
-
-  private anyField = '*';
-
-  intercept(ctx: ExecutionContext, next: CallHandler): Observable<any> {
-    const req = ctx.switchToHttp().getRequest<Request>();
-    const ability = req.user?.ability;
-    if (!ability) {
-      throw new ForbiddenException('No ability found on user');
-    }
-
-    const permitted = permittedFieldsOf(ability, this.action, this.subject, {
-      // how to read fields from each rule
-      fieldsFrom: (rule) => rule.fields || [this.anyField],
-    }) as string[];
-
-    if (permitted.includes(this.anyField)) {
-      // all fields are permitted
-      return next.handle();
-    }
-
-    // @ts-ignore
-    const crudReq = req[PARSED_CRUD_REQUEST_KEY];
-    const requested = (crudReq?.parsed?.fields as Fields) ?? [];
-    const finalFields =
-      (requested && requested.length > 0)
-        ? requested.filter((f) => permitted.includes(f))
-        : permitted;
-
-    if (!finalFields || finalFields.length === 0) {
-      throw new ForbiddenException('No readable fields for this resource');
-    }
-
-    // enforce selection for Nestjsx/CRUD + TypeORM
-    //    This makes CRUD build QB with SELECT only these columns.
-    if (!crudReq.parsed) crudReq.parsed = {} as any;
-    (crudReq.parsed as any).fields = finalFields;
-
-    return next.handle();
-  }
-}

package/src/casl/index.ts

@@ -1,5 +0,0 @@
-export * from './action.enum';
-export * from './policies.guard';
-export * from './casl-ability.factory';
-export * from './policies/manage-all.policy';
-export * from './casl.module';

package/src/casl/policies/manage-all.policy.ts

@@ -1,9 +0,0 @@
-import { IPolicyHandler } from '../policies.guard';
-import { AppAbility } from '../casl-ability.factory';
-import { Action } from '../action.enum';
-
-export class ManageAllPolicy implements IPolicyHandler {
-  handle(ability: AppAbility) {
-    return ability.can(Action.Manage, 'all');
-  }
-}

package/src/casl/policies.guard.ts

@@ -1,80 +0,0 @@
-import {
-  CanActivate,
-  ExecutionContext,
-  Injectable,
-  Logger,
-  SetMetadata,
-} from '@nestjs/common';
-import { Reflector } from '@nestjs/core';
-import { AppAbility, CaslAbilityFactory } from './casl-ability.factory';
-
-export interface IPolicyHandler {
-  handle(ability: AppAbility): boolean;
-}
-
-export type PolicyHandlerCallback = (ability: AppAbility) => boolean;
-
-export type PolicyHandler = IPolicyHandler | PolicyHandlerCallback;
-
-export const CHECK_POLICIES_KEY = 'check_policy';
-export const CheckPolicies = (...handlers: PolicyHandler[]) =>
-  SetMetadata(CHECK_POLICIES_KEY, handlers);
-
-export const SKIP_POLICIES_GUARD = 'skip_policies_guard';
-export const SkipPoliciesGuard = () => SetMetadata(SKIP_POLICIES_GUARD, true);
-
-@Injectable()
-export class PoliciesGuard implements CanActivate {
-  private readonly logger = new Logger(PoliciesGuard.name);
-
-  constructor(
-    private reflector: Reflector,
-    private caslAbilityFactory: CaslAbilityFactory,
-  ) {}
-
-  async canActivate(context: ExecutionContext): Promise<boolean> {
-    const skipGuard = this.reflector.getAllAndOverride<boolean>(
-      SKIP_POLICIES_GUARD,
-      [context.getHandler(), context.getClass()],
-    );
-    if (skipGuard) {
-      return true;
-    }
-
-    const policyHandlers = this.reflector.getAllAndOverride<
-      PolicyHandler[] | undefined
-    >(CHECK_POLICIES_KEY, [context.getHandler(), context.getClass()]);
-
-    if (!policyHandlers) {
-      this.logger.warn(
-        'Policies for action are not found. Endpoints are closed by default',
-      );
-      return false;
-    }
-
-    let user;
-    if (context.getType() === 'http') {
-      const request = context.switchToHttp().getRequest();
-      user = request.user;
-    } else if (context.getType() === 'ws') {
-      const client = context.switchToWs().getClient();
-      user = client.user;
-    } else {
-      throw new Error('Unknown context type');
-    }
-
-    const ability = await this.caslAbilityFactory.createForUser(user);
-    user.ability = ability;
-
-    return policyHandlers.every((handler) =>
-      this.execPolicyHandler(handler, ability),
-    );
-  }
-
-  private execPolicyHandler(handler: PolicyHandler, ability: AppAbility) {
-    if (typeof handler === 'function') {
-      return handler(ability);
-    }
-    return handler.handle(ability);
-  }
-}

package/src/event-logs/dto/event-log-create.dto.ts

@@ -1,47 +0,0 @@
-import { JoiSchema } from 'nestjs-joi';
-import Joi from 'joi';
-import { LogType, UserRole, LogLevel } from '../entities/event-log.entity';
-
-export class EventLogCreateDto {
-  @JoiSchema(Joi.string().valid(...Object.values(LogType)).required())
-  logType: LogType;
-
-  @JoiSchema(Joi.string().valid(...Object.values(LogLevel)).required())
-  logLevel: LogLevel;
-
-  @JoiSchema(Joi.string().required())
-  action: string;
-
-  @JoiSchema(Joi.string().optional())
-  method?: string;
-
-  @JoiSchema(Joi.string().uuid().allow(null).optional())
-  userId?: string;
-
-  @JoiSchema(Joi.string().valid(...Object.values(UserRole)).required())
-  userRole: string;
-
-  @JoiSchema(Joi.string().required())
-  entity: string;
-
-  @JoiSchema(Joi.string().uuid().allow(null).optional())
-  entityId?: string;
-
-  @JoiSchema(Joi.object().allow(null).optional())
-  payload?: Record<string, any>;
-
-  @JoiSchema(Joi.string().allow(null).optional())
-  url?: string;
-
-  @JoiSchema(Joi.string().allow(null).optional())
-  ipAddress?: string;
-
-  @JoiSchema(Joi.string().allow(null).optional())
-  userAgent?: string;
-
-  @JoiSchema(Joi.number().integer().allow(null).optional())
-  duration?: number;
-
-  @JoiSchema(Joi.number().integer().allow(null).optional())
-  statusCode?: number;
-}

package/src/event-logs/dto/event-log-timeline-query.dto.ts

@@ -1,13 +0,0 @@
-import Joi from "joi";
-import { JoiSchema } from "nestjs-joi";
-
-export class EventLogTimelineQueryDto {
-  @JoiSchema(Joi.string().isoDate().optional())
-  startTime?: string;
-
-  @JoiSchema(Joi.string().isoDate().optional())
-  endTime?: string;
-
-  @JoiSchema(Joi.string().optional())
-  timezone?: string;
-}

package/src/event-logs/dto/event-log-timeline.dto.ts

@@ -1,9 +0,0 @@
-import { LogLevel } from "../entities/event-log.entity";
-
-export class EventLogTimelineDto {
-  time: string;
-  records: number;
-  logLevel: LogLevel;
-  startTime: string;
-  endTime: string;
-}``