@eventista/ticketing-common 1.0.3 → 1.0.5

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

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

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

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

@@ -1,165 +0,0 @@
-import { Document, FilterQuery, UpdateQuery, QueryOptions, PipelineStage } from 'mongoose';
-import { IBaseRepository } from '../repositories/base.repository.interface';
-import { Logger } from '@nestjs/common';
-import { IBaseService } from './base.service.interface';
-
-export class BaseService<T extends Document> implements IBaseService<T> {
-  protected readonly logger: Logger;
-
-  constructor(
-    protected readonly repository: IBaseRepository<T>,
-    context?: string,
-  ) {
-    this.logger = new Logger(context || this.constructor.name);
-  }
-
-  /**
-   * 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.repository.findOne(filterQuery, projection, options);
-  }
-
-  /**
-   * 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> {
-    return this.repository.findOneOrFail(filterQuery, projection, options);
-  }
-
-  /**
-   * 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.repository.find(filterQuery, projection, options);
-  }
-
-  /**
-   * Tạo một document mới
-   */
-  async create(createDto: Partial<T>): Promise<T> {
-    return this.repository.create(createDto);
-  }
-
-  /**
-   * Tạo nhiều documents
-   */
-  async createMany(createDtos: Partial<T>[]): Promise<T[]> {
-    return this.repository.createMany(createDtos);
-  }
-
-  /**
-   * Cập nhật một document theo điều kiện
-   */
-  async update(
-    filterQuery: FilterQuery<T>,
-    updateQuery: UpdateQuery<T>,
-    options: QueryOptions = { new: true },
-  ): Promise<T | null> {
-    return this.repository.findOneAndUpdate(filterQuery, updateQuery, options);
-  }
-
-  /**
-   * 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 updateOrFail(
-    filterQuery: FilterQuery<T>,
-    updateQuery: UpdateQuery<T>,
-    options: QueryOptions = { new: true },
-  ): Promise<T> {
-    return this.repository.findOneAndUpdateOrFail(filterQuery, updateQuery, options);
-  }
-
-  /**
-   * 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 }> {
-    return this.repository.updateMany(filterQuery, updateQuery);
-  }
-
-  /**
-   * Xóa một document theo điều kiện
-   */
-  async delete(
-    filterQuery: FilterQuery<T>,
-    options?: QueryOptions,
-  ): Promise<T | null> {
-    return this.repository.findOneAndDelete(filterQuery, options);
-  }
-
-  /**
-   * Xóa một document theo điều kiện hoặc throw exception nếu không tìm thấy
-   */
-  async deleteOrFail(
-    filterQuery: FilterQuery<T>,
-    options?: QueryOptions,
-  ): Promise<T> {
-    return this.repository.findOneAndDeleteOrFail(filterQuery, options);
-  }
-
-  /**
-   * Xóa nhiều documents theo điều kiện
-   */
-  async deleteMany(filterQuery: FilterQuery<T>): Promise<{ deletedCount: number }> {
-    return this.repository.deleteMany(filterQuery);
-  }
-
-  /**
-   * Đếm số lượng documents theo điều kiện
-   */
-  async count(filterQuery: FilterQuery<T>): Promise<number> {
-    return this.repository.count(filterQuery);
-  }
-
-  /**
-   * Kiểm tra document có tồn tại không
-   */
-  async exists(filterQuery: FilterQuery<T>): Promise<boolean> {
-    return this.repository.exists(filterQuery);
-  }
-
-  /**
-   * Thực hiện aggregation pipeline
-   */
-  async aggregate(pipeline: PipelineStage[]): Promise<any[]> {
-    return this.repository.aggregate(pipeline);
-  }
-
-  /**
-   * 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;
-    };
-  }> {
-    return this.repository.paginate(filterQuery, options);
-  }
-}

package/src/index.ts

@@ -1,13 +0,0 @@
-
-export * from './database';
-export * from './exception/exception.filter';
-export * from './generic-repository';
-
-export * from './logger';
-
-export * from './pipes/custom-validation.pipe';
-export * from './response/response.interceptor'
-
-export * from './schemas';
-
-export * from './cluster/index';

package/src/logger/custom.logger.ts

@@ -1,83 +0,0 @@
-import { LoggerService } from '@nestjs/common';
-import { blue, cyan, gray, green, red, yellow } from 'colorette';
-
-export class CustomLogger implements LoggerService {
-  private readonly isProduction: boolean;
-
-  constructor(private readonly context?: string) {
-    this.isProduction = process.env.NODE_ENV === 'production';
-  }
-
-
-  private getTimestamp(): string {
-    const localeStringOptions = {
-      year: 'numeric',
-      hour: 'numeric',
-      minute: 'numeric',
-      second: 'numeric',
-      day: '2-digit',
-      month: '2-digit',
-    };
-    return new Date().toLocaleString(undefined, localeStringOptions as Intl.DateTimeFormatOptions);
-  }
-
-  private formatMessage(level: string, message: string, context?: string): string {
-    if (this.isProduction) {
-      return JSON.stringify({
-        timestamp: this.getTimestamp(),
-        pid: process.pid,
-        level,
-        context: context || this.context,
-        message
-      });
-    }
-
-    const timestamp = gray(`[Nest] ${process.pid}  - ${this.getTimestamp()}`);
-    const formattedLevel = this.colorize(level);
-    const contextStr = yellow(`[${context || this.context}] `);
-    return `${timestamp}   ${formattedLevel} ${contextStr}${message}`;
-  }
-
-  private colorize(level: string): string {
-    switch (level) {
-      case 'LOG':
-        return green(`${level} `);
-      case 'ERROR':
-        return red(`${level}`);
-      case 'WARN':
-        return yellow(`${level} `);
-      case 'DEBUG':
-        return blue(`${level}`);
-      case 'VERBOSE':
-        return cyan(`${level}`);
-      default:
-        return level;
-    }
-  }
-
-  log(message: string, context?: string) {
-    console.log(this.formatMessage('LOG', message, context));
-  }
-
-  error(message: string, metadata?: any) {
-    const baseLog = this.formatMessage('ERROR', message);
-    if (metadata) {
-      console.error(baseLog);
-      console.error(red('Details:'), metadata);
-    } else {
-      console.error(baseLog);
-    }
-  }
-
-  warn(message: string, context?: string) {
-    console.warn(this.formatMessage('WARN', message, context));
-  }
-
-  debug(message: string, context?: string) {
-    console.debug(this.formatMessage('DEBUG', message, context));
-  }
-
-  verbose(message: string, context?: string) {
-    console.log(this.formatMessage('VERBOSE', message, context));
-  }
-}

package/src/logger/index.ts

@@ -1,2 +0,0 @@
-export * from './logger.module';
-export * from './custom.logger';

package/src/logger/logger.module.ts

@@ -1,14 +0,0 @@
-import { Global, Module } from '@nestjs/common';
-import { CustomLogger } from './custom.logger';
-
-@Global()
-@Module({
-  providers: [
-    {
-      provide: 'Logger',
-      useValue: new CustomLogger(), // Initialize with no context
-    },
-  ],
-  exports: ['Logger'],
-})
-export class LoggerModule {}

package/src/pipes/custom-validation.pipe.ts

@@ -1,61 +0,0 @@
-import {
-  ArgumentMetadata,
-  BadRequestException,
-  Injectable,
-  ValidationPipe,
-  ValidationPipeOptions,
-} from '@nestjs/common';
-
-@Injectable()
-export class CustomValidationPipe extends ValidationPipe {
-  constructor(options?: ValidationPipeOptions) {
-    super({
-      whitelist: true, // Loại bỏ các trường không có trong DTO
-      transform: true, // Tự động chuyển đổi dữ liệu đầu vào thành class instance của DTO
-      ...options, // Cho phép truyền thêm tùy chọn nếu cần
-    });
-  }
-  public async transform(value, metadata: ArgumentMetadata) {
-    try {
-      return await super.transform(value, metadata);
-    } catch (e) {
-      if (e instanceof BadRequestException) {
-        const errors: any = [];
-        for (const err of e.getResponse()['message']) {
-          errors.push({
-            field: err.property,
-            constraints: this.getConstraints(err),
-          });
-        }
-
-        throw new BadRequestException({
-          errorCode: 400,
-          message: 'Validation failed',
-          errors,
-        });
-      }
-    }
-  }
-
-  getConstraints(err) {
-    if (typeof err == 'string') {
-      return err;
-    }
-    if (typeof err == 'object' && err.constraints) {
-      return err.constraints;
-    }
-    return this.deepReduce(err.children);
-  }
-
-  deepReduce(array) {
-    return array.reduce((accumulator, currentValue) => {
-      if (currentValue.children && currentValue.children.length > 0) {
-        return this.deepReduce(currentValue.children);
-      }
-      if (currentValue.constraints) {
-        return currentValue.constraints;
-      }
-      return accumulator;
-    }, {});
-  }
-}

package/src/response/response.interceptor.ts

@@ -1,26 +0,0 @@
-import {
-  CallHandler,
-  ExecutionContext,
-  Injectable,
-  NestInterceptor,
-} from '@nestjs/common';
-import { Observable } from 'rxjs';
-import { map } from 'rxjs/operators';
-
-@Injectable()
-export class ResponseInterceptor implements NestInterceptor {
-  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
-    // Chỉ áp dụng cho HTTP hoặc HTTPS requests
-    if (context.getType() !== 'http') {
-      return next.handle();
-    }
-    return next.handle().pipe(
-      map((data) => ({
-        errorCode: 0,
-        message: 'Success',
-        data,
-        timestamp: new Date().toISOString(),
-      })),
-    );
-  }
-}

package/src/schemas/base.schema.ts

@@ -1,19 +0,0 @@
-import { Prop, Schema } from '@nestjs/mongoose';
-import { Document } from 'mongoose';
-
-export interface BaseDocument extends Document {
-  createdAt: Date;
-  updatedAt: Date;
-  isDeleted: boolean;
-}
-
-export class BaseSchema {
-  @Prop({ type: Date, default: Date.now })
-  createdAt: Date;
-
-  @Prop({ type: Date, default: Date.now })
-  updatedAt: Date;
-
-  @Prop({ type: Boolean, default: false })
-  isDeleted: boolean;
-}