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

package/src/event-logs/event-logs.service.ts

@@ -1,236 +0,0 @@
-import { Injectable, Logger } from '@nestjs/common';
-import { TypeOrmCrudService } from '@dataui/crud-typeorm';
-import { EventLog, LogLevel, LogType, UserRole } from './entities/event-log.entity';
-import { DataSource, Repository } from 'typeorm';
-import { Request } from 'express';
-import { Roles } from "../users";
-import { EventLogTimelineDto } from "./dto/event-log-timeline.dto";
-import { Cron, CronExpression } from "@nestjs/schedule";
-import moment from "moment";
-import 'moment-timezone';
-import { TSkipEventsLogOptions } from "./event-logs.interceptor";
-
-type TInterval = 'second' | 'minute' | 'hour' | 'day' | 'week';
-
-@Injectable()
-export class EventLogsService extends TypeOrmCrudService<EventLog> {
-  private static requestHandled = Symbol('requestHandled');
-  private logsStore: Partial<EventLog>[] = [];
-
-  private readonly logger = new Logger(EventLogsService.name);
-
-  private static readonly rolesMap = {
-    [Roles.USER]: UserRole.USER,
-    [Roles.ADMIN]: UserRole.ADMIN,
-  }
-
-  constructor(
-    readonly repo: Repository<EventLog>,
-    private readonly dataSource: DataSource,
-  ) {
-    super(repo);
-  }
-
-  @Cron(CronExpression.EVERY_10_SECONDS)
-  private async saveAccumulatedLogs(): Promise<void> {
-    if (this.logsStore.length > 0) {
-      const logs = [...this.logsStore];
-      this.logger.verbose('Reset event logs store variable');
-      this.logsStore = [];
-
-      await this.repo.save(logs).catch(e => {
-        // DO NOT USE LOGGER HERE - it will cause infinite loop
-        console.error('Error while saving logs');
-        console.error(e);
-      });
-    }
-  }
-
-  @Cron(CronExpression.EVERY_WEEK)
-  private async deleteOldEventLogs() {
-    const threeMonthsAgo = new Date();
-    threeMonthsAgo.setMonth(threeMonthsAgo.getMonth() - 2);
-
-    const result = await this.repo
-      .createQueryBuilder()
-      .delete()
-      .from(EventLog)
-      .where('created_at <= :threeMonthsAgo', { threeMonthsAgo })
-      .execute();
-
-    this.logger.debug(`Removed ${result.affected} expired records from event_logs table.`);
-  }
-
-  audit(eventLog: Partial<EventLog>, request?: Request, skipOptions?: TSkipEventsLogOptions): void {
-    // @ts-ignore
-    if (request?.[EventLogsService.requestHandled]) {
-      this.logger.debug('Request already handled');
-      return;
-    }
-
-    const logPartial: Partial<EventLog> = {};
-    if (request) {
-      const { user } = request;
-      const userRole = user?.role ? EventLogsService.rolesMap[user.role] : UserRole.GUEST;
-
-      const payload = request.body ? { ...request.body } : null;
-      if (skipOptions && typeof skipOptions === 'object' && Array.isArray(skipOptions.body) && payload) {
-        for (const field of skipOptions.body) {
-          if (field in payload) {
-            // @ts-ignore
-            payload[field] = '*****';
-          }
-        }
-      }
-
-      logPartial.userId = user?.id || null;
-      logPartial.userName = user?.name || null;
-      logPartial.userRole = userRole || UserRole.GUEST;
-      logPartial.payload = payload;
-      logPartial.method = request.method || null;
-      logPartial.url = request.url || null;
-      logPartial.entityId = request.params.id || null;
-      logPartial.ipAddress = request.ip || null;
-      logPartial.userAgent = request.headers['user-agent'] || null;
-
-      // @ts-ignore
-      request[EventLogsService.requestHandled] = true;
-    }
-
-    this.logsStore.push({
-      ...logPartial,
-      ...eventLog,
-      logType: LogType.AUDIT,
-    });
-  }
-
-  public requestAlreadyHandled(request: Request): boolean {
-    // @ts-ignore
-    return request?.[EventLogsService.requestHandled];
-  }
-
-  // TODO: Remove async in the next major version (breaking change)
-  async operationalLog(eventLog: Partial<EventLog>): Promise<void> {
-    this.logsStore.push({
-      logLevel: LogLevel.INFO,
-      userRole: UserRole.SYSTEM,
-      ...eventLog,
-      logType: LogType.OPERATIONAL,
-    });
-  }
-
-  public applicationLog(eventLog: Partial<EventLog>): void {
-    this.logsStore.push({
-      logLevel: LogLevel.INFO,
-      userRole: UserRole.SYSTEM,
-      ...eventLog,
-      logType: LogType.APPLICATION,
-    });
-  }
-
-  async getTimeline(startTime?: Date, endTime?: Date, timezone: string = 'UTC'): Promise<EventLogTimelineDto[]> {
-    if (!startTime) {
-      startTime = await this.getOldestLogDate();
-    }
-
-    if (!endTime) {
-      endTime = new Date();
-    }
-
-    let startMoment = moment(startTime);
-    let endMoment = moment(endTime);
-
-    const interval = this.determineInterval(startMoment, endMoment);
-    const formatTimeFunction = this.getFormatTimeFunction(interval, timezone);
-
-    const startTimeIntervalBegin = startMoment.clone().tz(timezone).startOf(interval as moment.unitOfTime.StartOf);
-    const endTimeIntervalBegin = endMoment.clone().tz(timezone).startOf(interval as moment.unitOfTime.StartOf);
-
-    return this.dataSource.query(`
-      with 
-        time_series as (select generate_series($1, $2, '1 ${interval}'::interval) as time),
-        log_levels as (select unnest(enum_range(null::"${this.dataSource.driver.schema}".event_logs_log_level_enum)) as loglevel)
-      select
-        ${formatTimeFunction} as time,
-        ll.loglevel as "logLevel",
-        coalesce(count(el.*)::int, 0) as records,
-        ts.time as "startTime",
-        ts.time + interval '1 ${interval}' as "endTime"
-      from time_series ts
-        cross join log_levels ll
-        left join "${this.dataSource.driver.schema}".event_logs el on date_trunc('${interval}', el.created_at, $5) = ts.time
-        and el.log_level = ll.loglevel
-        and el.created_at between $3 and $4
-      group by ts.time,
-        ll.loglevel
-      order by ts.time,
-        ll.loglevel;
-    `, [
-      startTimeIntervalBegin.toDate(),
-      endTimeIntervalBegin.toDate(),
-      startMoment.toDate(),
-      endMoment.toDate(),
-      timezone
-    ]);
-  }
-
-  async getServiceNames(): Promise<string[]> {
-    const result = await this.repo
-      .createQueryBuilder('event_logs')
-      .select('event_logs.service')
-      .distinctOn(['service'])
-      .getMany();
-    return result.map((data) => data.service);
-  }
-
-  private async getOldestLogDate(): Promise<Date> {
-    const oldestLog = await this.repo.createQueryBuilder('event_log')
-      .select('MIN(event_log.createdAt)', 'min')
-      .getRawOne();
-    return new Date(oldestLog.min);
-  }
-
-  private determineInterval(startTime: moment.Moment, endTime: moment.Moment): TInterval {
-    const duration = moment.duration(endTime.diff(startTime));
-
-    const totalSeconds = duration.asSeconds();
-    const totalMinutes = duration.asMinutes();
-    const totalHours = duration.asHours();
-    const totalDays = duration.asDays();
-    const totalWeeks = duration.asWeeks();
-
-    // Aim for approximately 50-100 bars
-    const targetBars = 75;
-
-    if (totalSeconds <= targetBars) {
-      return 'second';
-    } else if (totalMinutes <= targetBars) {
-      return 'minute';
-    } else if (totalHours <= targetBars) {
-      return 'hour';
-    } else if (totalDays <= targetBars) {
-      return 'day';
-    } else if (totalWeeks <= targetBars) {
-      return 'week';
-    } else {
-      return 'week'; // fallback to week for very large ranges
-    }
-  }
-
-  private getFormatTimeFunction(interval: TInterval, timezone: string): string {
-    switch (interval) {
-      case 'second':
-        return `to_char(ts.time at time zone '${timezone}', 'HH24:MI:SS')`;
-      case 'minute':
-        return `to_char(ts.time at time zone '${timezone}', 'HH24:MI')`;
-      case 'hour':
-        return `to_char(ts.time at time zone '${timezone}', 'HH24:MI')`;
-      case 'day':
-        return `to_char(ts.time at time zone '${timezone}', 'YYYY-MM-DD')`;
-      case 'week':
-        return `to_char(date_trunc('week', ts.time at time zone '${timezone}'), 'YYYY-MM-DD')`;
-      default:
-        return `to_char(date_trunc('week', ts.time at time zone '${timezone}'), 'YYYY-MM-DD')`;
-    }
-  }
-}

package/src/event-logs/event-logs.types.ts

@@ -1,4 +0,0 @@
-export type TEventLogServiceConfig = {
-  id?: string;
-  name: string;
-};

package/src/event-logs/index.ts

@@ -1,10 +0,0 @@
-export * from './event-logs.permissions';
-export * from './entities/event-log.entity';
-export * from './dto/event-log-create.dto';
-export * from './dto/event-log-update.dto';
-export * from './policies/manage-event-logs.policy';
-export * from './policies/view-event-logs.policy';
-export * from './event-logs.controller';
-export * from './event-logs.module';
-export * from './event-logs.service';
-export * from './event-logs.interceptor';

package/src/event-logs/policies/manage-event-logs.policy.ts

@@ -1,8 +0,0 @@
-import { EventLog } from "../entities/event-log.entity";
-import { Action, AppAbility, IPolicyHandler } from "../../casl";
-
-export class ManageEventLogsPolicy implements IPolicyHandler {
-  handle(ability: AppAbility) {
-    return ability.can(Action.Manage, EventLog);
-  }
-}

package/src/event-logs/policies/view-event-logs.policy.ts

@@ -1,8 +0,0 @@
-import { EventLog } from "../entities/event-log.entity";
-import { Action, AppAbility, IPolicyHandler } from "../../casl";
-
-export class ViewEventLogsPolicy implements IPolicyHandler {
-  handle(ability: AppAbility) {
-    return ability.can(Action.Read, EventLog);
-  }
-}

package/src/generateTypes.ts

@@ -1,94 +0,0 @@
-import { NestFactory } from '@nestjs/core';
-import { DocumentBuilder, SwaggerDocumentOptions, SwaggerModule, } from '@nestjs/swagger';
-import { Module } from "@nestjs/common";
-import { TypeOrmModule } from "@nestjs/typeorm";
-import { resolve } from "path";
-import { ConfigModule } from "@nestjs/config";
-// @ts-ignore-next-line - Ignore the error because the package on project level
-import { generate } from "openapi-typescript-codegen";
-import { EventLogsModule } from './event-logs'
-import { UsersModule } from "./users";
-import { TokensModule } from "./tokens";
-import { SettingsModule } from "./settings";
-import { TelegrafModule } from "./telegraf";
-import { AuthModule } from "./auth";
-
-@Module({
-  imports: [
-    ConfigModule.forRoot({
-      envFilePath: resolve(__dirname, '../../.env'),
-    }),
-    TypeOrmModule.forRoot({
-      name: 'boar_pack_db',
-      type: 'postgres',
-      host: 'localhost',
-      port: 5951,
-      username: 'app',
-      password: 'password',
-      database: 'boar_pack',
-      entities: [
-        resolve(__dirname, './*/entities/*.entity.{ts,js}'),
-      ],
-    }),
-    AuthModule.forRoot({
-      googleAuth: false,
-      msAuth: false,
-      localAuth: false,
-      withControllers: true,
-      dataSourceName: 'boar_pack_db',
-    }),
-    UsersModule.register({
-      withControllers: true,
-      dataSourceName: 'boar_pack_db',
-    }),
-    EventLogsModule.forRoot({
-      dataSourceName: 'boar_pack_db'
-    }),
-    TokensModule.forRoot({
-      dataSourceName: 'boar_pack_db',
-    }),
-    SettingsModule.register({
-      withControllers: true,
-      dataSourceName: 'boar_pack_db',
-    }),
-    TelegrafModule.register({
-      withControllers: true,
-      dataSourceName: 'boar_pack_db',
-    }),
-  ],
-})
-class Swagger {
-}
-
-async function bootstrap() {
-  try {
-    const app = await NestFactory.create(Swagger);
-
-    const options: SwaggerDocumentOptions = {
-      operationIdFactory: (controllerKey: string, methodKey: string) => methodKey,
-    };
-
-    const swaggerConfig = new DocumentBuilder()
-      .setTitle('API')
-      .setVersion('1.0')
-      .build();
-
-    const document = SwaggerModule.createDocument(app, swaggerConfig, options);
-
-    SwaggerModule.setup('docs', app, document);
-    await app.listen(3335);
-    await generate({
-      input: 'http://localhost:3335/docs-json',
-      output: resolve(__dirname, '../../../users-frontend/src/tools/api-client/generated'),
-      httpClient: 'node',
-      clientName: 'ApiClient',
-      useOptions: true,
-    });
-    await app.close();
-  } catch (e) {
-    console.error('Error, while application initialization');
-    console.error(e);
-  }
-}
-
-bootstrap();

package/src/index.ts

@@ -1,10 +0,0 @@
-export * from './auth';
-export * from './casl';
-export * from './jwt-auth';
-export * from './users';
-export * from './bcrypt';
-export * from './tokens';
-export * from './ws-auth';
-export * from './event-logs';
-export * from './settings';
-export * from './telegraf';

package/src/jwt-auth/index.ts

@@ -1,5 +0,0 @@
-export * from './jwt-auth.config';
-export * from './jwt-auth.guard';
-export * from './jwt-auth.module';
-export * from './jwt-auth.service';
-export * from './jwt-auth.srtategy';

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

@@ -1,27 +0,0 @@
-import { Injectable } from '@nestjs/common';
-import { ConfigService } from '@nestjs/config';
-import { StringValue } from "ms";
-
-export type TJWTAuthConfig = {
-  jwtSecret: string;
-  accessTokenExpiration: StringValue;
-  refreshTokenExpiration: StringValue;
-};
-
-@Injectable()
-export class JWTAuthConfigService {
-  constructor(private configService: ConfigService) {
-  }
-
-  get config(): TJWTAuthConfig {
-    const jwtSecret = this.configService.getOrThrow<string>('JWT_SECRET');
-    const accessTokenExpiration = this.configService.get<StringValue>('ACCESS_TOKEN_EXPIRATION', '1h');
-    const refreshTokenExpiration = this.configService.get<StringValue>('REFRESH_TOKEN_EXPIRATION', '7d');
-
-    return {
-      jwtSecret,
-      accessTokenExpiration,
-      refreshTokenExpiration,
-    };
-  }
-}

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

@@ -1,26 +0,0 @@
-import { ExecutionContext, Injectable, SetMetadata } from '@nestjs/common';
-import { AuthGuard } from '@nestjs/passport';
-import { Reflector } from '@nestjs/core';
-import { JWT_AUTH } from '../auth/auth-strategies.constants';
-
-export const SKIP_JWT_GUARD = 'skipJWTGuard';
-export const SkipJWTGuard = () =>
-  SetMetadata<string, boolean>(SKIP_JWT_GUARD, true);
-
-@Injectable()
-export class JwtAuthGuard extends AuthGuard(JWT_AUTH) {
-  constructor(private reflector: Reflector) {
-    super();
-  }
-
-  canActivate(context: ExecutionContext) {
-    const skipGuard = this.reflector.getAllAndOverride<boolean>(
-      SKIP_JWT_GUARD,
-      [context.getHandler(), context.getClass()],
-    );
-    if (skipGuard) {
-      return true;
-    }
-    return super.canActivate(context);
-  }
-}

package/src/jwt-auth/jwt-auth.module.ts

@@ -1,64 +0,0 @@
-import { Module } from '@nestjs/common';
-import { UsersModule } from '../users/users.module';
-import { ConfigModule } from '@nestjs/config';
-import { JwtModule } from '@nestjs/jwt';
-import { JwtAuthStrategy } from './jwt-auth.srtategy';
-import { JwtAuthGuard } from './jwt-auth.guard';
-import { APP_GUARD } from '@nestjs/core';
-import { JWTAuthConfigService } from "./jwt-auth.config";
-import { PassportModule } from "@nestjs/passport";
-import { JWTAuthService } from "./jwt-auth.service";
-import { RevokedTokensModule } from '../revoked-tokens';
-import { JwtAuthRefreshStrategy } from "./jwt-auth.refresh.srtategy";
-
-@Module({})
-export class JwtAuthModule {
-  static register(config: {
-    dataSourceName?: string;
-  }) {
-    return {
-      module: JwtAuthModule,
-      imports: [
-        ConfigModule,
-        UsersModule.register({
-          withControllers: false,
-          dataSourceName: config.dataSourceName,
-        }),
-        PassportModule,
-        JwtModule.registerAsync({
-          imports: [JwtAuthModule.forConfig()],
-          inject: [JWTAuthConfigService],
-          useFactory: async (jwtAuthConfigService: JWTAuthConfigService) => ({
-            secret: jwtAuthConfigService.config.jwtSecret,
-          }),
-        }),
-        RevokedTokensModule.register({
-          dataSourceName: config.dataSourceName,
-        }),
-      ],
-      providers: [
-        JWTAuthConfigService,
-        JwtAuthStrategy,
-        JwtAuthRefreshStrategy,
-        JWTAuthService,
-        {
-          provide: APP_GUARD,
-          useClass: JwtAuthGuard,
-        },
-      ],
-      exports: [
-        JWTAuthConfigService,
-        JWTAuthService,
-      ],
-    };
-  }
-
-  private static forConfig() {
-    return {
-      module: JwtAuthModule,
-      imports: [ConfigModule],
-      providers: [JWTAuthConfigService],
-      exports: [JWTAuthConfigService],
-    };
-  }
-}

package/src/jwt-auth/jwt-auth.refresh.guard.ts

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

package/src/jwt-auth/jwt-auth.refresh.srtategy.ts

@@ -1,85 +0,0 @@
-import { ExtractJwt, Strategy } from 'passport-jwt';
-import { PassportStrategy } from '@nestjs/passport';
-import { Injectable, Logger, UnauthorizedException } from '@nestjs/common';
-import { JWTAuthConfigService } from './jwt-auth.config';
-import { Request } from 'express';
-import { JWT_AUTH_REFRESH } from '../auth/auth-strategies.constants';
-import { refreshTokenName } from "../auth/auth.constants";
-import { UsersService } from '../users';
-import { RevokedTokensService, TOKEN_TYPE } from '../revoked-tokens';
-import { TJWTRefreshPayload } from "./jwt-auth.srtategy";
-import ms from "ms";
-
-@Injectable()
-export class JwtAuthRefreshStrategy extends PassportStrategy(Strategy, JWT_AUTH_REFRESH) {
-  private readonly logger = new Logger(JwtAuthRefreshStrategy.name);
-
-  constructor(
-    private usersService: UsersService,
-    private jwtAuthConfigService: JWTAuthConfigService,
-    private revokedTokensService: RevokedTokensService,
-  ) {
-    super({
-      jwtFromRequest: ExtractJwt.fromExtractors([
-        ExtractJwt.fromAuthHeaderAsBearerToken(),
-        (req: Request) => {
-          const cookies = req.headers.cookie?.split('; ');
-          if (!cookies) {
-            return null;
-          }
-
-          const cookie = cookies.find(c => c.startsWith(`${refreshTokenName}=`));
-          if (!cookie) {
-            return null;
-          }
-
-          return cookie.split('=')[1];
-        },
-      ]),
-      ignoreExpiration: false,
-      secretOrKey: jwtAuthConfigService.config.jwtSecret,
-      passReqToCallback: false,
-    });
-  }
-
-  async validate(payload: TJWTRefreshPayload) {
-    this.logger.debug(`Validating refresh token for user with id: ${payload.sub}`);
-
-    // Check if a token has been revoked
-    if (!payload.jti) {
-      this.logger.error('Refresh token payload does not contain JTI');
-      throw new UnauthorizedException('Invalid token payload');
-    }
-
-    const isRevoked = await this.revokedTokensService.isTokenRevoked(payload.jti, payload.sid);
-    if (isRevoked) {
-      this.logger.debug(`Refresh token with JTI ${payload.jti} has already been revoked`);
-      throw new UnauthorizedException('Token has been revoked');
-    } else {
-      // Refresh token is valid, we revoke it to prevent reuse
-      this.logger.debug(`Revoking refresh token with JTI ${payload.jti}`);
-      await this.revokedTokensService.revokeRefreshToken({
-        jti: payload.jti,
-        expiresAt: new Date(
-          payload.exp
-            ? payload.exp * 1000
-            : Date.now() + ms(this.jwtAuthConfigService.config.refreshTokenExpiration)
-        ),
-        sid: payload.sid || null,
-        tokenType: TOKEN_TYPE.REFRESH,
-      });
-    }
-
-    const userId = payload.sub;
-    const user = await this.usersService.findOne({
-      select: ['id', 'email', 'role', 'permissions'],
-      where: { id: userId },
-    });
-
-    if (!user) {
-      throw new UnauthorizedException();
-    }
-
-    return user;
-  }
-}

package/src/jwt-auth/jwt-auth.service.ts

@@ -1,59 +0,0 @@
-import { Injectable } from "@nestjs/common";
-import { JwtService } from "@nestjs/jwt";
-import { TJWTPayload, TJWTRefreshPayload } from "./jwt-auth.srtategy";
-import { RevokedToken, RevokedTokensService, TOKEN_TYPE, TRevokedToken } from '../revoked-tokens';
-import { v4 as uuidv4 } from 'uuid';
-import { JWTAuthConfigService, TJWTAuthConfig } from "./jwt-auth.config";
-import { JwtSignOptions } from "@nestjs/jwt/dist/interfaces";
-import ms from 'ms';
-
-@Injectable()
-export class JWTAuthService {
-  private readonly config: TJWTAuthConfig;
-
-  constructor(
-    private readonly jwtService: JwtService,
-    private revokedTokensService: RevokedTokensService,
-    private readonly jwtAuthConfig: JWTAuthConfigService,
-  ) {
-    this.config = this.jwtAuthConfig.config;
-  }
-
-  public generateJwtId(): string {
-    return uuidv4();
-  }
-
-  public sign<PayloadType extends TJWTPayload | TJWTRefreshPayload>(
-    payload: PayloadType,
-    tokenType: TOKEN_TYPE,
-  ) {
-    const expiresIn = tokenType === TOKEN_TYPE.ACCESS
-      ? this.config.accessTokenExpiration
-      : this.config.refreshTokenExpiration;
-    const options: JwtSignOptions = {
-      expiresIn,
-      jwtid: this.generateJwtId(),
-    }
-    return {
-      token: this.jwtService.sign(payload, options),
-      payload: {
-        ...payload,
-        exp: Math.floor((ms(expiresIn) + Date.now()) / 1000),
-        jti: options.jwtid,
-        sid: payload.sid,
-      } as PayloadType,
-    };
-  }
-
-  public decode<T = TJWTPayload>(token: string): T {
-    return this.jwtService.decode(token) as T;
-  }
-
-  /**
-   * Revoke a JWT token by its JTI
-   * @param token The token to revoke
-   */
-  public async revokeToken(token: TRevokedToken) {
-    return this.revokedTokensService.revokeToken(token, this.config.refreshTokenExpiration);
-  }
-}