@eventista/ticketing-common 1.0.0

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

@@ -0,0 +1,111 @@
+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

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

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

@@ -0,0 +1,45 @@
+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

@@ -0,0 +1,142 @@
+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

@@ -0,0 +1,36 @@
+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

@@ -0,0 +1,7 @@
+// 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

@@ -0,0 +1,78 @@
+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;
+    };
+  }>;
+}

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

@@ -0,0 +1,199 @@
+import { Document, FilterQuery, Model, UpdateQuery, QueryOptions, PipelineStage } from 'mongoose';
+import { NotFoundException } from '@nestjs/common';
+import { IBaseRepository } from './base.repository.interface';
+
+export class BaseRepository<T extends Document> implements IBaseRepository<T> {
+  constructor(protected readonly model: Model<T>) {}
+
+  /**
+   * Tìm một document theo điều kiện
+   */
+  async findOne(
+    filterQuery: FilterQuery<T>,
+    projection?: Record<string, unknown>,
+    options?: QueryOptions,
+  ): Promise<T | null> {
+    return this.model.findOne(filterQuery, projection, options).exec();
+  }
+
+  /**
+   * Tìm một document theo điều kiện hoặc throw exception nếu không tìm thấy
+   */
+  async findOneOrFail(
+    filterQuery: FilterQuery<T>,
+    projection?: Record<string, unknown>,
+    options?: QueryOptions,
+  ): Promise<T> {
+    const document = await this.findOne(filterQuery, projection, options);
+    if (!document) {
+      throw new NotFoundException(`${this.model.modelName} not found`);
+    }
+    return document;
+  }
+
+  /**
+   * Tìm nhiều documents theo điều kiện
+   */
+  async find(
+    filterQuery: FilterQuery<T>,
+    projection?: Record<string, unknown>,
+    options?: QueryOptions,
+  ): Promise<T[]> {
+    return this.model.find(filterQuery, projection, options).exec();
+  }
+
+  /**
+   * Tạo một document mới
+   */
+  async create(createDto: Partial<T>): Promise<T> {
+    const newDocument = new this.model(createDto);
+    return newDocument.save();
+  }
+
+  /**
+   * Tạo nhiều documents
+   */
+  async createMany(createDtos: Partial<T>[]): Promise<T[]> {
+    const result = await this.model.insertMany(createDtos);
+    return result as unknown as T[];
+  }
+
+  /**
+   * Cập nhật một document theo điều kiện
+   */
+  async findOneAndUpdate(
+    filterQuery: FilterQuery<T>,
+    updateQuery: UpdateQuery<T>,
+    options: QueryOptions = { new: true },
+  ): Promise<T | null> {
+    return this.model.findOneAndUpdate(filterQuery, updateQuery, options).exec();
+  }
+
+  /**
+   * Cập nhật một document theo điều kiện hoặc throw exception nếu không tìm thấy
+   */
+  async findOneAndUpdateOrFail(
+    filterQuery: FilterQuery<T>,
+    updateQuery: UpdateQuery<T>,
+    options: QueryOptions = { new: true },
+  ): Promise<T> {
+    const document = await this.findOneAndUpdate(filterQuery, updateQuery, options);
+    if (!document) {
+      throw new NotFoundException(`${this.model.modelName} not found`);
+    }
+    return document;
+  }
+
+  /**
+   * Cập nhật nhiều documents theo điều kiện
+   */
+  async updateMany(
+    filterQuery: FilterQuery<T>,
+    updateQuery: UpdateQuery<T>,
+  ): Promise<{ matchedCount: number; modifiedCount: number }> {
+    const result = await this.model.updateMany(filterQuery, updateQuery).exec();
+    return {
+      matchedCount: result.matchedCount,
+      modifiedCount: result.modifiedCount,
+    };
+  }
+
+  /**
+   * Xóa một document theo điều kiện
+   */
+  async findOneAndDelete(
+    filterQuery: FilterQuery<T>,
+    options?: QueryOptions,
+  ): Promise<T | null> {
+    return this.model.findOneAndDelete(filterQuery, options).exec();
+  }
+
+  /**
+   * Xóa một document theo điều kiện hoặc throw exception nếu không tìm thấy
+   */
+  async findOneAndDeleteOrFail(
+    filterQuery: FilterQuery<T>,
+    options?: QueryOptions,
+  ): Promise<T> {
+    const document = await this.findOneAndDelete(filterQuery, options);
+    if (!document) {
+      throw new NotFoundException(`${this.model.modelName} not found`);
+    }
+    return document;
+  }
+
+  /**
+   * Xóa nhiều documents theo điều kiện
+   */
+  async deleteMany(filterQuery: FilterQuery<T>): Promise<{ deletedCount: number }> {
+    const result = await this.model.deleteMany(filterQuery).exec();
+    return { deletedCount: result.deletedCount || 0 };
+  }
+
+  /**
+   * Đếm số lượng documents theo điều kiện
+   */
+  async count(filterQuery: FilterQuery<T>): Promise<number> {
+    return this.model.countDocuments(filterQuery).exec();
+  }
+
+  /**
+   * Kiểm tra document có tồn tại không
+   */
+  async exists(filterQuery: FilterQuery<T>): Promise<boolean> {
+    const count = await this.count(filterQuery);
+    return count > 0;
+  }
+
+  /**
+   * Thực hiện aggregation pipeline
+   */
+  async aggregate(pipeline: PipelineStage[]): Promise<any[]> {
+    return this.model.aggregate(pipeline).exec();
+  }
+
+  /**
+   * Phân trang
+   */
+  async 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;
+    };
+  }> {
+    const page = options.page || 1;
+    const limit = options.limit || 10;
+    const skip = (page - 1) * limit;
+
+    const [data, total] = await Promise.all([
+      this.model
+        .find(filterQuery, options.projection)
+        .sort(options.sort)
+        .skip(skip)
+        .limit(limit)
+        .exec(),
+      this.count(filterQuery),
+    ]);
+
+    return {
+      data,
+      pagination: {
+        total,
+        page,
+        limit,
+        pages: Math.ceil(total / limit),
+      },
+    };
+  }
+}

package/src/generic-repository/services/base.service.interface.ts

@@ -0,0 +1,78 @@
+import { Document, FilterQuery, UpdateQuery, QueryOptions, PipelineStage } from 'mongoose';
+
+export interface IBaseService<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[]>;
+  
+  update(
+    filterQuery: FilterQuery<T>,
+    updateQuery: UpdateQuery<T>,
+    options?: QueryOptions,
+  ): Promise<T | null>;
+  
+  updateOrFail(
+    filterQuery: FilterQuery<T>,
+    updateQuery: UpdateQuery<T>,
+    options?: QueryOptions,
+  ): Promise<T>;
+  
+  updateMany(
+    filterQuery: FilterQuery<T>,
+    updateQuery: UpdateQuery<T>,
+  ): Promise<{ matchedCount: number; modifiedCount: number }>;
+  
+  delete(
+    filterQuery: FilterQuery<T>,
+    options?: QueryOptions,
+  ): Promise<T | null>;
+  
+  deleteOrFail(
+    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;
+    };
+  }>;
+}