@eventista/ticketing-common 1.0.2 → 1.0.4

package/src/cluster/services/cluster.service.ts

@@ -1,76 +0,0 @@
-import { Injectable } from '@nestjs/common';
-import { CustomLogger } from 'src/logger';
-
-
-// Import node:cluster và node:os
-const cluster = require('node:cluster');
-const { cpus } = require('node:os');
-
-@Injectable()
-export class ClusterService {
-  private logger: CustomLogger;
-
-  constructor() {
-    this.logger = new CustomLogger('ClusterService');
-  }
-
-  /**
-   * Khởi động ứng dụng với chế độ cluster hoặc đơn luồng dựa trên cấu hình
-   * @param bootstrapFunction Hàm khởi động ứng dụng
-   */
-  public startApplication(bootstrapFunction: () => Promise<void>): void {
-    // Lấy giá trị ENABLE_CLUSTER từ biến môi trường, mặc định là 'false'
-    const enableCluster = process.env.ENABLE_CLUSTER?.toLowerCase() === 'true';
-
-    if (enableCluster && cluster.isPrimary) {
-      this.startClusterMode();
-    } else {
-      this.startSingleProcessMode(bootstrapFunction, enableCluster);
-    }
-  }
-
-  /**
-   * Khởi động ứng dụng trong chế độ cluster
-   */
-  private startClusterMode(): void {
-    this.logger.log(`Cluster mode enabled. Primary ${process.pid} is running`);
-
-    // Fork workers for each CPU
-    const numCPUs = cpus().length;
-
-    // Có thể giới hạn số lượng worker thông qua biến môi trường
-    const maxWorkers = parseInt(process.env.MAX_WORKERS || String(numCPUs), 10);
-    const workerCount = Math.min(numCPUs, maxWorkers);
-
-    this.logger.log(`Starting ${workerCount} workers out of ${numCPUs} available CPUs`);
-
-    for (let i = 0; i < workerCount; i++) {
-      cluster.fork();
-    }
-
-    cluster.on('exit', (worker, code, signal) => {
-      this.logger.warn(`Worker ${worker.process.pid} died with code ${code} and signal ${signal}`);
-      // Thay thế worker đã chết
-      this.logger.log('Forking a new worker...');
-      cluster.fork();
-    });
-  }
-
-  /**
-   * Khởi động ứng dụng trong chế độ đơn luồng hoặc như một worker
-   * @param bootstrapFunction Hàm khởi động ứng dụng
-   * @param isWorker Có phải là worker trong chế độ cluster không
-   */
-  private startSingleProcessMode(bootstrapFunction: () => Promise<void>, isWorker: boolean): void {
-    bootstrapFunction().catch(err => {
-      this.logger.error('Failed to start application', err);
-      process.exit(1);
-    });
-
-    if (isWorker) {
-      this.logger.log(`Worker ${process.pid} started`);
-    } else {
-      this.logger.log(`Running in single process mode. Process ${process.pid} started`);
-    }
-  }
-}

package/src/database/index.ts

@@ -1,2 +0,0 @@
-export * from './mongodb';
-export * from './redis';

package/src/database/mongodb/index.ts

@@ -1,2 +0,0 @@
-export * from './mongodb.module';
-export * from './mongodb.service';

package/src/database/mongodb/mongodb.module.ts

@@ -1,42 +0,0 @@
-import { Module, Global } from '@nestjs/common';
-import { MongooseModule } from '@nestjs/mongoose';
-import { ConfigModule, ConfigService } from '@nestjs/config';
-import { MongodbService } from './mongodb.service';
-
-@Global()
-@Module({
-  imports: [
-    MongooseModule.forRootAsync({
-      imports: [ConfigModule],
-      inject: [ConfigService],
-      useFactory: async (configService: ConfigService) => {
-        const uri = configService.get<string>('MONGODB_URI');
-        return {
-          uri,
-          // Cấu hình connection pool tối ưu cho production
-          maxPoolSize: configService.get<number>('MONGODB_MAX_POOL_SIZE', 100),
-          minPoolSize: configService.get<number>('MONGODB_MIN_POOL_SIZE', 5),
-          maxConnecting: configService.get<number>('MONGODB_MAX_CONNECTING', 5),
-          maxIdleTimeMS: configService.get<number>('MONGODB_MAX_IDLE_TIME_MS', 60000),
-          waitQueueTimeoutMS: 5000,
-          // Cấu hình timeout và retry tối ưu
-          connectTimeoutMS: 30000,
-          socketTimeoutMS: 45000,
-          heartbeatFrequencyMS: 10000,
-          serverSelectionTimeoutMS: 30000,
-          retryWrites: true,
-          retryReads: true,
-          // Cấu hình bảo mật và hiệu suất
-          compressors: 'zlib',
-          zlibCompressionLevel: 6,
-          // Cấu hình monitoring
-          monitorCommands: true,
-
-        };
-      },
-    }),
-  ],
-  providers: [MongodbService],
-  exports: [MongodbService, MongooseModule],
-})
-export class MongodbModule {}

package/src/database/mongodb/mongodb.service.ts

@@ -1,111 +0,0 @@
-import { Injectable, Logger, OnModuleInit } from '@nestjs/common';
-import { InjectConnection } from '@nestjs/mongoose';
-import { Connection } from 'mongoose';
-
-@Injectable()
-export class MongodbService implements OnModuleInit {
-  private readonly logger = new Logger(MongodbService.name);
-
-  constructor(
-    @InjectConnection()
-    private readonly connection: Connection,
-  ) {}
-
-  async onModuleInit() {
-    try {
-      // Kiểm tra kết nối khi khởi động
-      if (this.connection.readyState === 1) {
-        this.logger.log('MongoDB connected successfully');
-        
-        // Log thông tin về connection pool
-        const poolInfo = this.getConnectionPoolInfo();
-        this.logger.log(`MongoDB connection pool initialized: ${JSON.stringify(poolInfo)}`);
-      } else {
-        this.logger.warn(`MongoDB connection state: ${this.getReadyStateText(this.connection.readyState)}`);
-      }
-
-      // Thiết lập event listeners
-      this.setupConnectionListeners();
-    } catch (error) {
-      this.logger.error('Failed to initialize MongoDB connection', error.stack);
-    }
-  }
-
-  private setupConnectionListeners() {
-    this.connection.on('connected', () => {
-      this.logger.log('MongoDB connected');
-    });
-
-    this.connection.on('disconnected', () => {
-      this.logger.warn('MongoDB disconnected');
-    });
-
-    this.connection.on('reconnected', () => {
-      this.logger.log('MongoDB reconnected');
-    });
-
-    this.connection.on('error', (error) => {
-      this.logger.error('MongoDB connection error', error.stack);
-    });
-  }
-
-  getConnection(): Connection {
-    return this.connection;
-  }
-
-  getConnectionStatus(): string {
-    return this.getReadyStateText(this.connection.readyState);
-  }
-
-  async ping(): Promise<boolean> {
-    try {
-      await this.connection.db.admin().ping();
-      return true;
-    } catch (error) {
-      this.logger.error('MongoDB ping failed', error.stack);
-      return false;
-    }
-  }
-
-  getConnectionPoolInfo() {
-    // Sửa lại cách truy cập thông tin connection pool
-    try {
-      // Cách 1: Truy cập thông qua mongoose driver
-      if (this.connection.getClient) {
-        const client = this.connection.getClient();
-        return {
-          maxPoolSize: client.options?.maxPoolSize || 'default',
-          minPoolSize: client.options?.minPoolSize || 'default',
-          readyState: this.getReadyStateText(this.connection.readyState),
-        };
-      }
-      
-      // Cách 2: Nếu không có getClient, sử dụng cách khác
-      return {
-        readyState: this.getReadyStateText(this.connection.readyState),
-        // Thêm các thông tin khác nếu có thể truy cập
-      };
-    } catch (error) {
-      this.logger.warn('Could not retrieve connection pool info', error.message);
-      return {
-        readyState: this.getReadyStateText(this.connection.readyState),
-        error: 'Could not retrieve pool information',
-      };
-    }
-  }
-
-  private getReadyStateText(state: number): string {
-    switch (state) {
-      case 0:
-        return 'disconnected';
-      case 1:
-        return 'connected';
-      case 2:
-        return 'connecting';
-      case 3:
-        return 'disconnecting';
-      default:
-        return 'unknown';
-    }
-  }
-}

package/src/database/redis/index.ts

@@ -1,2 +0,0 @@
-export * from './redis.module';
-export * from './redis.service';

package/src/database/redis/redis.module.ts

@@ -1,45 +0,0 @@
-import { Module, Global } from '@nestjs/common';
-import { ConfigModule, ConfigService } from '@nestjs/config';
-import { RedisService } from './redis.service';
-
-
-@Global()
-@Module({
-  imports: [ConfigModule],
-  providers: [
-    {
-      provide: 'REDIS_CLIENT',
-      useFactory: (configService: ConfigService) => {
-        const Redis = require('ioredis');
-        return new Redis({
-          host: configService.get('REDIS_HOST', 'localhost'),
-          port: configService.get('REDIS_PORT', 6379),
-          password: configService.get('REDIS_PASSWORD', 'StrongRedisPassword123'),
-          db: configService.get('REDIS_DB', 0),
-          // Tối ưu connection pool
-          maxRetriesPerRequest: 3,
-          connectTimeout: 10000,
-          // Tăng số lượng kết nối trong pool
-          connectionName: 'ticket-service',
-          // Tối ưu hóa retry strategy
-          retryStrategy: (times) => {
-            if (times > 3) {
-              return null; // stop retrying
-            }
-            return Math.min(times * 50, 1000);
-          },
-          // Tối ưu hóa các tùy chọn khác
-          enableReadyCheck: false,
-          enableOfflineQueue: true,
-          // Tối ưu hóa TCP keepalive
-          keepAlive: 10000,
-          noDelay: true,
-        });
-      },
-      inject: [ConfigService],
-    },
-    RedisService,
-  ],
-  exports: [RedisService],
-})
-export class RedisModule {}

package/src/database/redis/redis.service.ts

@@ -1,142 +0,0 @@
-import { Injectable, Inject, OnModuleDestroy } from '@nestjs/common';
-import { Redis } from 'ioredis';
-
-@Injectable()
-export class RedisService implements OnModuleDestroy {
-  constructor(
-    @Inject('REDIS_CLIENT')
-    private readonly redis: Redis,
-  ) {}
-
-  getClient(): Redis {
-    return this.redis;
-  }
-
-  async get(key: string): Promise<string | null> {
-    return this.redis.get(key);
-  }
-
-  async set(key: string, value: string, ttl?: number): Promise<'OK'> {
-    if (ttl) {
-      return this.redis.set(key, value, 'EX', ttl);
-    }
-    return this.redis.set(key, value);
-  }
-
-  async del(key: string): Promise<number> {
-    return this.redis.del(key);
-  }
-
-  async incr(key: string): Promise<number> {
-    return this.redis.incr(key);
-  }
-
-  async decr(key: string): Promise<number> {
-    return this.redis.decr(key);
-  }
-
-  async incrby(key: string, increment: number): Promise<number> {
-    return this.redis.incrby(key, increment);
-  }
-
-  async decrby(key: string, decrement: number): Promise<number> {
-    return this.redis.decrby(key, decrement);
-  }
-
-  // Thêm phương thức để thực hiện nhiều lệnh Redis trong một pipeline
-  async pipeline(commands: Array<[string, ...any[]]>): Promise<any[]> {
-    const pipeline = this.redis.pipeline();
-    
-    for (const [command, ...args] of commands) {
-      pipeline[command](...args);
-    }
-    
-    return pipeline.exec();
-  }
-
-  // Tối ưu phương thức executeScript
-  async executeScript(script: string, keys: string[], args: string[]): Promise<any> {
-    // Sử dụng defineCommand để tối ưu hiệu suất cho các script được sử dụng nhiều lần
-    const scriptHash = require('crypto').createHash('sha1').update(script).digest('hex');
-    
-    // Kiểm tra xem script đã được cache chưa
-    try {
-      return await this.redis.evalsha(scriptHash, keys.length, ...keys, ...args);
-    } catch (err) {
-      if (err.message.includes('NOSCRIPT')) {
-        // Script chưa được cache, thực thi và cache
-        return this.redis.eval(script, keys.length, ...keys, ...args);
-      }
-      throw err;
-    }
-  }
-
-  async releaseLock(lockKey: string, value: string): Promise<boolean> {
-    const script = `
-      if redis.call("get", KEYS[1]) == ARGV[1] then
-        return redis.call("del", KEYS[1])
-      else
-        return 0
-      end
-    `;
-    const result = await this.redis.eval(script, 1, lockKey, value);
-    return result === 1;
-  }
-
-  // Thêm phương thức zadd để hỗ trợ sorted sets
-  async zadd(key: string, ...args: string[]): Promise<number> {
-    return this.redis.zadd(key, ...args);
-  }
-
-  // Thêm các phương thức khác cho sorted sets
-  async zrevrange(key: string, start: number, stop: number, withScores?: boolean): Promise<string[]> {
-    if (withScores) {
-      return this.redis.zrevrange(key, start, stop, 'WITHSCORES');
-    }
-    return this.redis.zrevrange(key, start, stop);
-  }
-
-  async zrange(key: string, start: number, stop: number, withScores?: boolean): Promise<string[]> {
-    if (withScores) {
-      return this.redis.zrange(key, start, stop, 'WITHSCORES');
-    }
-    return this.redis.zrange(key, start, stop);
-  }
-
-  async zrem(key: string, ...members: string[]): Promise<number> {
-    return this.redis.zrem(key, ...members);
-  }
-
-  async zscore(key: string, member: string): Promise<string | null> {
-    return this.redis.zscore(key, member);
-  }
-
-  // Thêm phương thức hỗ trợ hash maps
-  async hmset(key: string, hash: Record<string, string>): Promise<'OK'> {
-    return this.redis.hmset(key, hash);
-  }
-
-  async hgetall(key: string): Promise<Record<string, string>> {
-    return this.redis.hgetall(key);
-  }
-
-  /**
-   * Lấy nhiều giá trị từ Redis
-   * @param keys Danh sách các key cần lấy
-   * @returns Danh sách các giá trị tương ứng
-   */
-  async mget(...keys: string[]): Promise<(string | null)[]> {
-    try {
-      const client = this.getClient();
-      const values = await client.mget(keys);
-      return values;
-    } catch (error) {
-      // Trả về mảng null với độ dài bằng số lượng key
-      return Array(keys.length).fill(null);
-    }
-  }
-
-  onModuleDestroy() {
-    this.redis.disconnect();
-  }
-}

package/src/exception/exception.filter.ts

@@ -1,36 +0,0 @@
-import {
-  ArgumentsHost,
-  Catch,
-  ExceptionFilter,
-  HttpException,
-  HttpStatus,
-} from '@nestjs/common';
-
-@Catch()
-export class GlobalExceptionFilter implements ExceptionFilter {
-  catch(exception: any, host: ArgumentsHost) {
-    const ctx = host.switchToHttp();
-    const response = ctx.getResponse();
-    const request = ctx.getRequest();
-    // Lấy mã trạng thái
-    const status =
-      exception instanceof HttpException
-        ? exception.getStatus()
-        : HttpStatus.INTERNAL_SERVER_ERROR;
-
-    const errorResponse = {
-      errorCode:
-        exception instanceof HttpException
-          ? exception.getResponse()['code']
-          : status,
-      message: exception.message || 'Internal Server Error',
-      data: exception instanceof HttpException ? exception.getResponse()['data'] : null,
-
-      path: request.url,
-      timestamp: new Date().toISOString(),
-    };
-
-    // Sử dụng phương thức Fastify để trả về phản hồi
-    response.status(status).send(errorResponse); // Fastify sử dụng `send` để trả về JSON
-  }
-}

package/src/generic-repository/index.ts

@@ -1,7 +0,0 @@
-// Export repositories
-export * from './repositories/base.repository.interface';
-export * from './repositories/base.repository';
-
-// Export services
-export * from './services/base.service.interface';
-export * from './services/base.service';

package/src/generic-repository/repositories/base.repository.interface.ts

@@ -1,78 +0,0 @@
-import { Document, FilterQuery, UpdateQuery, QueryOptions, PipelineStage } from 'mongoose';
-
-export interface IBaseRepository<T extends Document> {
-  findOne(
-    filterQuery: FilterQuery<T>,
-    projection?: Record<string, unknown>,
-    options?: QueryOptions,
-  ): Promise<T | null>;
-  
-  findOneOrFail(
-    filterQuery: FilterQuery<T>,
-    projection?: Record<string, unknown>,
-    options?: QueryOptions,
-  ): Promise<T>;
-  
-  find(
-    filterQuery: FilterQuery<T>,
-    projection?: Record<string, unknown>,
-    options?: QueryOptions,
-  ): Promise<T[]>;
-  
-  create(createDto: Partial<T>): Promise<T>;
-  
-  createMany(createDtos: Partial<T>[]): Promise<T[]>;
-  
-  findOneAndUpdate(
-    filterQuery: FilterQuery<T>,
-    updateQuery: UpdateQuery<T>,
-    options?: QueryOptions,
-  ): Promise<T | null>;
-  
-  findOneAndUpdateOrFail(
-    filterQuery: FilterQuery<T>,
-    updateQuery: UpdateQuery<T>,
-    options?: QueryOptions,
-  ): Promise<T>;
-  
-  updateMany(
-    filterQuery: FilterQuery<T>,
-    updateQuery: UpdateQuery<T>,
-  ): Promise<{ matchedCount: number; modifiedCount: number }>;
-  
-  findOneAndDelete(
-    filterQuery: FilterQuery<T>,
-    options?: QueryOptions,
-  ): Promise<T | null>;
-  
-  findOneAndDeleteOrFail(
-    filterQuery: FilterQuery<T>,
-    options?: QueryOptions,
-  ): Promise<T>;
-  
-  deleteMany(filterQuery: FilterQuery<T>): Promise<{ deletedCount: number }>;
-  
-  count(filterQuery: FilterQuery<T>): Promise<number>;
-  
-  exists(filterQuery: FilterQuery<T>): Promise<boolean>;
-  
-  aggregate(pipeline: PipelineStage[]): Promise<any[]>;
-  
-  paginate(
-    filterQuery: FilterQuery<T>,
-    options?: {
-      page?: number;
-      limit?: number;
-      sort?: Record<string, 1 | -1>;
-      projection?: Record<string, unknown>;
-    },
-  ): Promise<{
-    data: T[];
-    pagination: {
-      total: number;
-      page: number;
-      limit: number;
-      pages: number;
-    };
-  }>;
-}