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

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

@@ -1,47 +0,0 @@
-import Joi from "joi";
-import { JoiSchema } from 'nestjs-joi';
-import { LogType, UserRole, LogLevel } from '../entities/event-log.entity';
-
-export class EventLogUpdateDto {
-  @JoiSchema(Joi.string().valid(...Object.values(LogType)).optional())
-  logType?: LogType;
-
-  @JoiSchema(Joi.string().valid(...Object.values(LogLevel)).optional())
-  logLevel?: LogLevel;
-
-  @JoiSchema(Joi.string().optional())
-  action?: string;
-
-  @JoiSchema(Joi.string().optional())
-  method?: string;
-
-  @JoiSchema(Joi.string().uuid().allow(null).optional())
-  userId?: string;
-
-  @JoiSchema(Joi.string().valid(...Object.values(UserRole)).optional())
-  userRole?: string;
-
-  @JoiSchema(Joi.string().optional())
-  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/entities/event-log.entity.ts

@@ -1,140 +0,0 @@
-import { Column, CreateDateColumn, Entity, Index, ManyToOne, PrimaryGeneratedColumn, UpdateDateColumn, } from 'typeorm';
-import { User } from "../../users";
-
-export enum LogType {
-  AUDIT = 'Audit',
-  OPERATIONAL = 'Operational',
-  APPLICATION = 'Application',
-}
-
-export enum UserRole {
-  ADMIN = 'Admin',
-  USER = 'User',
-  GUEST = 'Guest',
-  SYSTEM = 'System',
-}
-
-export enum LogLevel {
-  INFO = 'Info',
-  WARNING = 'Warning',
-  ERROR = 'Error',
-}
-
-@Entity('event_logs')
-export class EventLog {
-  @PrimaryGeneratedColumn('uuid')
-  id: string;
-
-  @Column({
-    type: 'enum',
-    enum: LogType,
-  })
-  logType: LogType;
-
-  @Column({
-    type: 'enum',
-    enum: LogLevel,
-  })
-  logLevel: LogLevel;
-
-  @Column()
-  action: string;
-
-  @Column({
-    type: 'varchar',
-    nullable: true,
-  })
-  method: string | null;
-
-  @Column({
-    type: 'uuid',
-    nullable: true,
-  })
-  userId: string | null;
-
-  @ManyToOne(() => User)
-  user: User | null;
-
-  @Column({
-    type: 'enum',
-    enum: UserRole,
-  })
-  userRole: UserRole;
-
-  @Column({
-    type: 'varchar',
-    nullable: true,
-  })
-  userName: string | null;
-
-  @Column({
-    type: 'varchar',
-    nullable: true,
-  })
-  externalUserId: string | null;
-
-  @Column()
-  entity: string;
-
-  @Column({
-    type: 'varchar',
-    nullable: true,
-  })
-  entityId: string | null;
-
-  @Column('jsonb', { nullable: true })
-  payload: Record<string, any> | null;
-
-  @Column({
-    type: 'varchar',
-    nullable: true,
-  })
-  url: string | null;
-
-  @Column({
-    type: 'varchar',
-    nullable: true,
-  })
-  ipAddress: string | null;
-
-  @Column({
-    type: 'varchar',
-    nullable: true
-  })
-  userAgent: string | null;
-
-  @Column('int', {
-    nullable: true,
-  })
-  duration: number | null;
-
-  @Column('int', {
-    nullable: true,
-  })
-  statusCode: number | null;
-
-  @Index('event_logs_service_index')
-  @Column({
-    default: 'main'
-  })
-  service: string;
-
-  @Column({
-    type: 'varchar',
-    nullable: true,
-    default: null,
-  })
-  serviceId: string | null;
-
-  @CreateDateColumn({
-    type: 'timestamp with time zone',
-    name: 'created_at'
-  })
-  createdAt: Date;
-
-  @UpdateDateColumn({
-    type: 'timestamp with time zone',
-    name: 'updated_at'
-  })
-  updatedAt: Date;
-}

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

@@ -1,2 +0,0 @@
-export const SERVICE_CONFIG_TOKEN = 'SERVICE_CONFIG_TOKEN';
-export const CONFIGURE_EVENTS_MIDDLEWARE = 'CONFIGURE_EVENTS_MIDDLEWARE';

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

@@ -1,80 +0,0 @@
-import { Controller, Get, Query } from '@nestjs/common';
-import { ApiExtraModels, ApiOkResponse, ApiTags, getSchemaPath } from '@nestjs/swagger';
-import { Crud, CrudController } from '@dataui/crud';
-import { EventLogsService } from './event-logs.service';
-import { EventLog } from './entities/event-log.entity';
-import { EventLogCreateDto } from './dto/event-log-create.dto';
-import { EventLogUpdateDto } from "./dto/event-log-update.dto";
-import { ManageEventLogsPolicy } from "./policies/manage-event-logs.policy";
-import { ViewEventLogsPolicy } from "./policies/view-event-logs.policy";
-import { CheckPolicies } from "../casl";
-import { EventLogTimelineDto } from "./dto/event-log-timeline.dto";
-import { EventLogTimelineQueryDto } from "./dto/event-log-timeline-query.dto";
-
-@Crud({
-  model: {
-    type: EventLog,
-  },
-  params: {
-    id: {
-      field: 'id',
-      type: 'uuid',
-      primary: true,
-    },
-  },
-  query: {
-    alwaysPaginate: true,
-    join: {
-      user: {
-        allow: ['id', 'name'],
-      },
-    },
-  },
-  routes: {
-    only: ['getManyBase', 'createOneBase', 'updateOneBase', 'deleteOneBase'],
-    getManyBase: {
-      decorators: [
-        CheckPolicies(new ViewEventLogsPolicy()),
-      ],
-    },
-  },
-  dto: {
-    create: EventLogCreateDto,
-    update: EventLogUpdateDto,
-  },
-})
-@CheckPolicies(new ManageEventLogsPolicy())
-@ApiTags('EventLogs')
-@ApiExtraModels(EventLogTimelineDto, EventLogTimelineQueryDto)
-@Controller('event-logs')
-export class EventLogsController implements CrudController<EventLog>{
-  constructor(
-    readonly service: EventLogsService,
-  ) {}
-
-  @CheckPolicies(new ViewEventLogsPolicy())
-  @Get('timeline')
-  @ApiOkResponse({
-    type: EventLogTimelineDto,
-    isArray: true,
-  })
-  async getTimeline(
-    @Query() query: EventLogTimelineQueryDto,
-  ): Promise<EventLogTimelineDto[]> {
-    const start = query.startTime ? new Date(query.startTime) : undefined;
-    const end = query.endTime ? new Date(query.endTime) : undefined;
-    return this.service.getTimeline(start, end, query.timezone);
-  }
-
-  @CheckPolicies(new ViewEventLogsPolicy())
-  @Get('service-names')
-  @ApiOkResponse({
-    schema: {
-      type: 'array',
-      items: { type: 'string' },
-    },
-  })
-  async getServiceNames(): Promise<string[]> {
-    return this.service.getServiceNames();
-  }
-}

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

@@ -1,75 +0,0 @@
-import {
-  CallHandler,
-  ExecutionContext,
-  Inject,
-  Injectable,
-  Logger,
-  NestInterceptor,
-  SetMetadata
-} from '@nestjs/common';
-import { Observable, throwError } from 'rxjs';
-import { catchError, tap } from 'rxjs/operators';
-import { EventLog, LogLevel } from './entities/event-log.entity';
-import { EventLogsService } from "./event-logs.service";
-import { Request, Response } from 'express';
-import { HttpException } from "@nestjs/common/exceptions/http.exception";
-import { SERVICE_CONFIG_TOKEN } from "./event-logs.constants";
-import type { TEventLogServiceConfig } from "./event-logs.types";
-import { Reflector } from "@nestjs/core";
-
-export type TSkipEventsLogOptions = true | {
-  body?: string[];
-}
-
-export const SKIP_EVENTS_LOG = 'SKIP_EVENTS_LOG';
-export const SkipEventsLog = (skipOptions: TSkipEventsLogOptions = true) => SetMetadata(SKIP_EVENTS_LOG, skipOptions);
-
-@Injectable()
-export class EventLogInterceptor implements NestInterceptor {
-  private readonly logger = new Logger(EventLogInterceptor.name);
-
-  constructor(
-    private readonly reflector: Reflector,
-    private readonly eventLogService: EventLogsService,
-    @Inject(SERVICE_CONFIG_TOKEN) private readonly serviceConfig?: TEventLogServiceConfig,
-  ) {}
-
-  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
-    const request = context.switchToHttp().getRequest() as Request;
-    const response = context.switchToHttp().getResponse() as Response;
-    const handler = context.getHandler();
-    const controller = context.getClass();
-
-    const skipOptions = this.reflector.getAllAndOverride<TSkipEventsLogOptions | undefined>(SKIP_EVENTS_LOG, [handler, controller]);
-    if (skipOptions === true) {
-      return next.handle();
-    }
-
-    const logEntry = new EventLog();
-    logEntry.action = handler.name;
-    logEntry.entity = controller.name;
-
-    if (this.serviceConfig) {
-      logEntry.service = this.serviceConfig.name;
-      logEntry.serviceId = this.serviceConfig.id || null;
-    }
-
-    const now = Date.now();
-
-    return next.handle().pipe(
-      tap(() => {
-        logEntry.duration = Date.now() - now;
-        logEntry.statusCode = response.statusCode;
-        logEntry.logLevel = response.statusCode >= 500 ? LogLevel.ERROR : (response.statusCode >= 400 ? LogLevel.WARNING : LogLevel.INFO);
-        this.eventLogService.audit(logEntry, request, skipOptions);
-      }),
-      catchError((error: HttpException) => {
-        logEntry.duration = Date.now() - now;
-        logEntry.statusCode = error?.getStatus?.() || 500;
-        logEntry.logLevel = logEntry.statusCode >= 500 ? LogLevel.ERROR : LogLevel.WARNING;
-        this.eventLogService.audit(logEntry, request, skipOptions);
-        return throwError(() => error);
-      }),
-    );
-  }
-}

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

@@ -1,48 +0,0 @@
-import { NamedLogger } from "@boarteam/boar-pack-common-backend/src/tools";
-import { EventLogsService } from "./event-logs.service";
-import { Inject } from "@nestjs/common";
-import { SERVICE_CONFIG_TOKEN } from "./event-logs.constants";
-import type { TEventLogServiceConfig } from "./event-logs.types";
-import { LogLevel } from "./entities/event-log.entity";
-
-export class EventLogsLogger extends NamedLogger {
-  constructor(
-    private readonly eventLogsService: EventLogsService,
-    @Inject(SERVICE_CONFIG_TOKEN) private readonly serviceConfig: TEventLogServiceConfig,
-  ) {
-    const { id, name } = serviceConfig || {};
-    const prefix = id ? `${name} (${id})` : name;
-    super(prefix);
-  }
-
-  warn(message: any, ...optionalParams: any[]) {
-    super.warn(message, ...optionalParams);
-    this.eventLogsService.applicationLog({
-      action: 'log',
-      entity: 'EventLogsLogger',
-      service: this.serviceConfig.name,
-      serviceId: this.serviceConfig.id,
-      logLevel: LogLevel.WARNING,
-      payload: {
-        message: String(message),
-        ...optionalParams?.length && { optionalParams },
-      },
-    });
-  }
-
-  error(message: any, stack: any, ...optionalParams: any[]) {
-    super.error(message, stack, ...optionalParams);
-    this.eventLogsService.applicationLog({
-      action: 'log',
-      entity: 'EventLogsLogger',
-      service: this.serviceConfig.name,
-      serviceId: this.serviceConfig.id,
-      logLevel: LogLevel.ERROR,
-      payload: {
-        message: String(message),
-        ...stack && { stack },
-        ...optionalParams?.length && { optionalParams },
-      },
-    });
-  }
-}

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

@@ -1,58 +0,0 @@
-import { Injectable, NestMiddleware, Inject, Logger, HttpException } from '@nestjs/common';
-import { Request, Response, NextFunction } from 'express';
-import { EventLogsService } from './event-logs.service';
-import { EventLog, LogLevel } from './entities/event-log.entity';
-import { SERVICE_CONFIG_TOKEN } from './event-logs.constants';
-import type { TEventLogServiceConfig } from './event-logs.types';
-
-@Injectable()
-export class EventLogMiddleware implements NestMiddleware {
-  private readonly logger = new Logger(EventLogMiddleware.name);
-
-  constructor(
-    private readonly eventLogService: EventLogsService,
-    @Inject(SERVICE_CONFIG_TOKEN) private readonly serviceConfig?: TEventLogServiceConfig,
-  ) {
-  }
-
-  use(req: Request, res: Response, next: NextFunction) {
-    const start = Date.now();
-
-    res.on('finish', () => {
-      if (this.eventLogService.requestAlreadyHandled(req)) {
-        return;
-      }
-
-      if (res.statusCode >= 200 && res.statusCode < 300) {
-        return;
-      }
-
-      const logEntry = new EventLog();
-      logEntry.action = req.method;
-      logEntry.entity = req.url.split('?')[0]
-        .split('/')
-        .filter((part) => part)
-        .map((part) => part[0].toUpperCase() + part.slice(1))
-        .join(' ');
-
-      if (this.serviceConfig) {
-        logEntry.service = this.serviceConfig.name;
-        logEntry.serviceId = this.serviceConfig.id || null;
-      }
-
-
-      logEntry.duration = Date.now() - start;
-      logEntry.statusCode = res.statusCode;
-      logEntry.logLevel =
-        res.statusCode >= 500
-          ? LogLevel.ERROR
-          : res.statusCode >= 400
-            ? LogLevel.WARNING
-            : LogLevel.INFO;
-
-      this.eventLogService.audit(logEntry, req);
-    });
-
-    next();
-  }
-}

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

@@ -1,131 +0,0 @@
-import { Inject, MiddlewareConsumer, Module, NestModule, Optional } from '@nestjs/common';
-import { getDataSourceToken, TypeOrmModule } from '@nestjs/typeorm';
-import { EventLogsService } from './event-logs.service';
-import { EventLogsController } from './event-logs.controller';
-import { EventLog } from './entities/event-log.entity';
-import { EventLogsPermissions } from "./event-logs.permissions";
-import { Action, CaslAbilityFactory, CaslModule } from "../casl";
-import { DataSource } from "typeorm";
-import { APP_INTERCEPTOR } from "@nestjs/core";
-import { EventLogInterceptor } from "./event-logs.interceptor";
-import { CONFIGURE_EVENTS_MIDDLEWARE, SERVICE_CONFIG_TOKEN } from "./event-logs.constants";
-import { TEventLogServiceConfig } from "./event-logs.types";
-import { EventLogsLogger } from "./event-logs.logger";
-import { EventLogMiddleware } from "./event-logs.middleware";
-import { ScheduleModule } from "@boarteam/boar-pack-common-backend";
-
-@Module({})
-export class EventLogsModule implements NestModule {
-  static forRoot(config: { dataSourceName: string }) {
-    return {
-      module: EventLogsModule,
-      imports: [
-        CaslModule.forFeature(),
-        TypeOrmModule.forFeature([EventLog], config.dataSourceName),
-      ],
-      providers: [
-        {
-          provide: EventLogsService,
-          inject: [getDataSourceToken(config.dataSourceName)],
-          useFactory: (dataSource: DataSource) => {
-            return new EventLogsService(dataSource.getRepository(EventLog), dataSource);
-          }
-        },
-      ],
-      exports: [
-        EventLogsService,
-      ],
-      controllers: [
-        EventLogsController,
-      ]
-    }
-  }
-
-  static forInterceptor(config: {
-    dataSourceName: string,
-    service?: TEventLogServiceConfig,
-    eventLogsServiceClass?: new (...args: any[]) => EventLogsService,
-  }) {
-    return {
-      module: EventLogsModule,
-      imports: [
-        CaslModule.forFeature(),
-        ScheduleModule,
-        TypeOrmModule.forFeature([EventLog], config.dataSourceName),
-      ],
-      providers: [
-        {
-          provide: EventLogsService,
-          inject: [getDataSourceToken(config.dataSourceName)],
-          useFactory: (dataSource: DataSource) => {
-            const serviceClass = config.eventLogsServiceClass || EventLogsService;
-            return new serviceClass(dataSource.getRepository(EventLog), dataSource);
-          }
-        },
-        {
-          provide: SERVICE_CONFIG_TOKEN,
-          useValue: config.service,
-        },
-        EventLogsLogger,
-        {
-          provide: APP_INTERCEPTOR,
-          useClass: EventLogInterceptor,
-        },
-        {
-          provide: CONFIGURE_EVENTS_MIDDLEWARE,
-          useValue: true,
-        }
-      ],
-      exports: [
-        EventLogsService,
-        EventLogsLogger,
-        CONFIGURE_EVENTS_MIDDLEWARE,
-        SERVICE_CONFIG_TOKEN,
-      ],
-    }
-  }
-
-  static forFeature(config: { dataSourceName: string }) {
-    return {
-      module: EventLogsModule,
-      imports: [
-        CaslModule,
-        TypeOrmModule.forFeature([EventLog], config.dataSourceName),
-      ],
-      providers: [
-        {
-          provide: EventLogsService,
-          inject: [getDataSourceToken(config.dataSourceName)],
-          useFactory: (dataSource: DataSource) => {
-            return new EventLogsService(dataSource.getRepository(EventLog), dataSource);
-          }
-        },
-      ],
-      exports: [
-        EventLogsService,
-      ],
-    }
-  }
-
-  constructor(
-    @Optional()
-    @Inject(CONFIGURE_EVENTS_MIDDLEWARE) private readonly configureEventsMiddleware: boolean,
-  ) {
-    CaslAbilityFactory.addPermissionToAction({
-      permission: EventLogsPermissions.VIEW,
-      action: Action.Read,
-      subject: EventLog,
-    });
-    CaslAbilityFactory.addPermissionToAction({
-      permission: EventLogsPermissions.MANAGE,
-      action: Action.Manage,
-      subject: EventLog,
-    });
-  }
-
-  configure(consumer: MiddlewareConsumer) {
-    if (this.configureEventsMiddleware) {
-      consumer.apply(EventLogMiddleware).forRoutes('*');
-    }
-  }
-}

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

@@ -1,4 +0,0 @@
-export enum EventLogsPermissions {
-  VIEW = 'event-logs:view',
-  MANAGE = 'event-logs:manage',
-}