feat(docs): Remove outdated service templates and enhance Vietnamese architecture documentation
- Deleted obsolete service architecture templates in both English and Vietnamese to streamline content. - Updated the Vietnamese architecture documentation with improved Mermaid diagrams for better visual clarity. - Enhanced color coding in diagrams to improve readability and consistency across documentation. - Added a new section detailing visual indicators for better understanding of architecture components.
This commit is contained in:
Ho Ngoc Hai
@@ -0,0 +1,72 @@
|
||||
import { logger } from '@goodgo/logger';
|
||||
|
||||
import { getRedisClient } from '../../config/redis.config';
|
||||
|
||||
/**
|
||||
* EN: Service for caching data (Redis wrapper)
|
||||
* VI: Service cho việc caching dữ liệu (Redis wrapper)
|
||||
*/
|
||||
export class CacheService {
|
||||
/**
|
||||
* EN: Get value from cache
|
||||
* VI: Lấy giá trị từ cache
|
||||
*/
|
||||
async get<T>(key: string): Promise<T | null> {
|
||||
try {
|
||||
const data = await getRedisClient().get(key);
|
||||
if (!data) return null;
|
||||
return JSON.parse(data) as T;
|
||||
} catch (error) {
|
||||
logger.error('Cache get error', { key, error });
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* EN: Set value in cache
|
||||
* VI: Lưu giá trị vào cache
|
||||
*/
|
||||
async set(key: string, value: any, ttlSeconds?: number): Promise<void> {
|
||||
try {
|
||||
const stringValue = JSON.stringify(value);
|
||||
if (ttlSeconds) {
|
||||
await getRedisClient().setex(key, ttlSeconds, stringValue);
|
||||
} else {
|
||||
await getRedisClient().set(key, stringValue);
|
||||
}
|
||||
} catch (error) {
|
||||
logger.error('Cache set error', { key, error });
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* EN: Get from cache or fetch from source if missing
|
||||
* VI: Lấy từ cache hoặc lấy từ nguồn nếu không có
|
||||
*/
|
||||
async getOrSet<T>(
|
||||
key: string,
|
||||
fetchFn: () => Promise<T>,
|
||||
ttlSeconds: number = 300
|
||||
): Promise<T> {
|
||||
const cached = await this.get<T>(key);
|
||||
if (cached) return cached;
|
||||
|
||||
const data = await fetchFn();
|
||||
await this.set(key, data, ttlSeconds);
|
||||
return data;
|
||||
}
|
||||
|
||||
/**
|
||||
* EN: Delete from cache
|
||||
* VI: Xóa khỏi cache
|
||||
*/
|
||||
async del(key: string): Promise<void> {
|
||||
try {
|
||||
await getRedisClient().del(key);
|
||||
} catch (error) {
|
||||
logger.error('Cache del error', { key, error });
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
export const cacheService = new CacheService();
|
||||
@@ -0,0 +1,50 @@
|
||||
import { logger } from '@goodgo/logger';
|
||||
import CircuitBreaker from 'opossum';
|
||||
|
||||
/**
|
||||
* EN: Circuit Breaker Configuration
|
||||
* VI: Cấu hình Circuit Breaker
|
||||
*/
|
||||
const defaultOptions: CircuitBreaker.Options = {
|
||||
timeout: 3000, // 3 seconds
|
||||
errorThresholdPercentage: 50,
|
||||
resetTimeout: 30000, // 30 seconds
|
||||
};
|
||||
|
||||
/**
|
||||
* EN: Create a circuit breaker for an async function
|
||||
* VI: Tạo circuit breaker cho một hàm bất đồng bộ
|
||||
*
|
||||
* @param action - Async function to protect
|
||||
* @param name - Name of the circuit breaker
|
||||
* @param options - Override default options
|
||||
*/
|
||||
export const createCircuitBreaker = <TArgs extends any[], TResult>(
|
||||
action: (...args: TArgs) => Promise<TResult>,
|
||||
name: string,
|
||||
options: Partial<CircuitBreaker.Options> = {}
|
||||
): CircuitBreaker<TArgs, TResult> => {
|
||||
const breaker = new CircuitBreaker(action, {
|
||||
...defaultOptions,
|
||||
...options,
|
||||
name,
|
||||
});
|
||||
|
||||
breaker.on('open', () => {
|
||||
logger.warn(`Circuit Breaker OPEN: ${name}`);
|
||||
});
|
||||
|
||||
breaker.on('halfOpen', () => {
|
||||
logger.info(`Circuit Breaker HALF-OPEN: ${name}`);
|
||||
});
|
||||
|
||||
breaker.on('close', () => {
|
||||
logger.info(`Circuit Breaker CLOSED: ${name}`);
|
||||
});
|
||||
|
||||
breaker.on('fallback', () => {
|
||||
logger.warn(`Circuit Breaker FALLBACK: ${name}`);
|
||||
});
|
||||
|
||||
return breaker;
|
||||
};
|
||||
220
services/_template_nodejs/src/modules/common/repository.ts
Normal file
220
services/_template_nodejs/src/modules/common/repository.ts
Normal file
@@ -0,0 +1,220 @@
|
||||
import { logger } from '@goodgo/logger';
|
||||
import { PrismaClient } from '@prisma/client';
|
||||
|
||||
import { DatabaseError } from '../../errors/http-error';
|
||||
|
||||
/**
|
||||
* EN: Base repository class providing common database operations
|
||||
* VI: Base repository class cung cấp các thao tác database chung
|
||||
*/
|
||||
export abstract class BaseRepository<T, CreateInput, UpdateInput> {
|
||||
protected prisma: PrismaClient;
|
||||
protected modelName: string;
|
||||
|
||||
constructor(prisma: PrismaClient, modelName: string) {
|
||||
this.prisma = prisma;
|
||||
this.modelName = modelName;
|
||||
}
|
||||
|
||||
/**
|
||||
* EN: Find entity by ID
|
||||
* VI: Tìm entity theo ID
|
||||
*/
|
||||
async findById(id: string): Promise<T | null> {
|
||||
try {
|
||||
logger.debug(`Finding ${this.modelName} by ID / Tìm ${this.modelName} theo ID`, { id });
|
||||
|
||||
const entity = await (this.prisma as any)[this.modelName].findUnique({
|
||||
where: { id },
|
||||
});
|
||||
|
||||
logger.debug(`${this.modelName} ${entity ? 'found' : 'not found'} / ${this.modelName} ${entity ? 'đã tìm thấy' : 'không tìm thấy'}`, { id });
|
||||
return entity;
|
||||
} catch (error: any) {
|
||||
logger.error(`Failed to find ${this.modelName} by ID / Không thể tìm ${this.modelName} theo ID`, { error, id });
|
||||
throw new DatabaseError(`Failed to find ${this.modelName}`, { id, originalError: error });
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* EN: Find entity by unique field
|
||||
* VI: Tìm entity theo field duy nhất
|
||||
*/
|
||||
async findByUnique(field: string, value: any): Promise<T | null> {
|
||||
try {
|
||||
logger.debug(`Finding ${this.modelName} by ${field} / Tìm ${this.modelName} theo ${field}`, { field, value });
|
||||
|
||||
const entity = await (this.prisma as any)[this.modelName].findUnique({
|
||||
where: { [field]: value },
|
||||
});
|
||||
|
||||
logger.debug(`${this.modelName} ${entity ? 'found' : 'not found'} / ${this.modelName} ${entity ? 'đã tìm thấy' : 'không tìm thấy'}`, { field, value });
|
||||
return entity;
|
||||
} catch (error: any) {
|
||||
logger.error(`Failed to find ${this.modelName} by ${field} / Không thể tìm ${this.modelName} theo ${field}`, { error, field, value });
|
||||
throw new DatabaseError(`Failed to find ${this.modelName}`, { field, value, originalError: error });
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* EN: Find all entities with optional filtering
|
||||
* VI: Tìm tất cả entities với filtering tùy chọn
|
||||
*/
|
||||
async findAll(options?: {
|
||||
where?: any;
|
||||
orderBy?: any;
|
||||
skip?: number;
|
||||
take?: number;
|
||||
include?: any;
|
||||
}): Promise<T[]> {
|
||||
try {
|
||||
logger.debug(`Finding all ${this.modelName} / Tìm tất cả ${this.modelName}`, options);
|
||||
|
||||
const entities = await (this.prisma as any)[this.modelName].findMany(options || {});
|
||||
|
||||
logger.debug(`Found ${entities.length} ${this.modelName} entities / Đã tìm thấy ${entities.length} ${this.modelName} entities`);
|
||||
return entities;
|
||||
} catch (error: any) {
|
||||
logger.error(`Failed to find all ${this.modelName} / Không thể tìm tất cả ${this.modelName}`, { error, options });
|
||||
throw new DatabaseError(`Failed to find ${this.modelName} entities`, { options, originalError: error });
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* EN: Create new entity
|
||||
* VI: Tạo entity mới
|
||||
*/
|
||||
async create(data: CreateInput): Promise<T> {
|
||||
try {
|
||||
logger.debug(`Creating new ${this.modelName} / Tạo ${this.modelName} mới`, { data });
|
||||
|
||||
const entity = await (this.prisma as any)[this.modelName].create({
|
||||
data,
|
||||
});
|
||||
|
||||
logger.debug(`${this.modelName} created successfully / ${this.modelName} đã được tạo thành công`, { id: (entity as any).id });
|
||||
return entity;
|
||||
} catch (error: any) {
|
||||
logger.error(`Failed to create ${this.modelName} / Không thể tạo ${this.modelName}`, { error, data });
|
||||
throw new DatabaseError(`Failed to create ${this.modelName}`, { data, originalError: error });
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* EN: Update entity by ID
|
||||
* VI: Cập nhật entity theo ID
|
||||
*/
|
||||
async update(id: string, data: UpdateInput): Promise<T> {
|
||||
try {
|
||||
logger.debug(`Updating ${this.modelName} / Cập nhật ${this.modelName}`, { id, data });
|
||||
|
||||
const entity = await (this.prisma as any)[this.modelName].update({
|
||||
where: { id },
|
||||
data,
|
||||
});
|
||||
|
||||
logger.debug(`${this.modelName} updated successfully / ${this.modelName} đã được cập nhật thành công`, { id });
|
||||
return entity;
|
||||
} catch (error: any) {
|
||||
if (error.code === 'P2025') {
|
||||
logger.warn(`${this.modelName} not found for update / ${this.modelName} không tìm thấy để cập nhật`, { id });
|
||||
throw new DatabaseError(`${this.modelName} not found`, { id });
|
||||
}
|
||||
logger.error(`Failed to update ${this.modelName} / Không thể cập nhật ${this.modelName}`, { error, id, data });
|
||||
throw new DatabaseError(`Failed to update ${this.modelName}`, { id, data, originalError: error });
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* EN: Delete entity by ID
|
||||
* VI: Xóa entity theo ID
|
||||
*/
|
||||
async delete(id: string): Promise<boolean> {
|
||||
try {
|
||||
logger.debug(`Deleting ${this.modelName} / Xóa ${this.modelName}`, { id });
|
||||
|
||||
await (this.prisma as any)[this.modelName].delete({
|
||||
where: { id },
|
||||
});
|
||||
|
||||
logger.debug(`${this.modelName} deleted successfully / ${this.modelName} đã được xóa thành công`, { id });
|
||||
return true;
|
||||
} catch (error: any) {
|
||||
if (error.code === 'P2025') {
|
||||
logger.warn(`${this.modelName} not found for deletion / ${this.modelName} không tìm thấy để xóa`, { id });
|
||||
throw new DatabaseError(`${this.modelName} not found`, { id });
|
||||
}
|
||||
logger.error(`Failed to delete ${this.modelName} / Không thể xóa ${this.modelName}`, { error, id });
|
||||
throw new DatabaseError(`Failed to delete ${this.modelName}`, { id, originalError: error });
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* EN: Count entities with optional filtering
|
||||
* VI: Đếm entities với filtering tùy chọn
|
||||
*/
|
||||
async count(where?: any): Promise<number> {
|
||||
try {
|
||||
logger.debug(`Counting ${this.modelName} / Đếm ${this.modelName}`, { where });
|
||||
|
||||
const count = await (this.prisma as any)[this.modelName].count({
|
||||
where,
|
||||
});
|
||||
|
||||
logger.debug(`Counted ${count} ${this.modelName} entities / Đã đếm ${count} ${this.modelName} entities`);
|
||||
return count;
|
||||
} catch (error: any) {
|
||||
logger.error(`Failed to count ${this.modelName} / Không thể đếm ${this.modelName}`, { error, where });
|
||||
throw new DatabaseError(`Failed to count ${this.modelName}`, { where, originalError: error });
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* EN: Check if entity exists by ID
|
||||
* VI: Kiểm tra entity có tồn tại theo ID
|
||||
*/
|
||||
async exists(id: string): Promise<boolean> {
|
||||
try {
|
||||
const count = await this.count({ id });
|
||||
return count > 0;
|
||||
} catch (error: any) {
|
||||
logger.error(`Failed to check if ${this.modelName} exists / Không thể kiểm tra ${this.modelName} có tồn tại`, { error, id });
|
||||
throw error;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* EN: Execute transaction with multiple operations
|
||||
* VI: Thực thi transaction với nhiều operations
|
||||
*/
|
||||
async transaction<R>(callback: (tx: any) => Promise<R>): Promise<R> {
|
||||
try {
|
||||
logger.debug(`Starting ${this.modelName} transaction / Bắt đầu transaction ${this.modelName}`);
|
||||
|
||||
const result = await this.prisma.$transaction(async (tx: any) => {
|
||||
return await callback(tx);
|
||||
});
|
||||
|
||||
logger.debug(`${this.modelName} transaction completed successfully / Transaction ${this.modelName} đã hoàn thành thành công`);
|
||||
return result;
|
||||
} catch (error: any) {
|
||||
logger.error(`${this.modelName} transaction failed / Transaction ${this.modelName} thất bại`, { error });
|
||||
throw new DatabaseError(`${this.modelName} transaction failed`, { originalError: error });
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* EN: Generic repository interface for type safety
|
||||
* VI: Generic repository interface để type safety
|
||||
*/
|
||||
export interface IRepository<T, CreateInput, UpdateInput> {
|
||||
findById(id: string): Promise<T | null>;
|
||||
findByUnique(field: string, value: any): Promise<T | null>;
|
||||
findAll(options?: any): Promise<T[]>;
|
||||
create(data: CreateInput): Promise<T>;
|
||||
update(id: string, data: UpdateInput): Promise<T>;
|
||||
delete(id: string): Promise<boolean>;
|
||||
count(where?: any): Promise<number>;
|
||||
exists(id: string): Promise<boolean>;
|
||||
}
|
||||
@@ -0,0 +1,314 @@
|
||||
import { FeatureRepository } from '../feature.repository';
|
||||
import { ConflictError } from '../../../errors/http-error';
|
||||
|
||||
// EN: Mock Prisma client
|
||||
// VI: Mock Prisma client
|
||||
const mockPrismaClient = {
|
||||
feature: {
|
||||
findUnique: jest.fn(),
|
||||
findMany: jest.fn(),
|
||||
create: jest.fn(),
|
||||
update: jest.fn(),
|
||||
delete: jest.fn(),
|
||||
count: jest.fn(),
|
||||
},
|
||||
$transaction: jest.fn(),
|
||||
};
|
||||
|
||||
jest.mock('../../../config/database.config', () => ({
|
||||
prisma: mockPrismaClient,
|
||||
}));
|
||||
|
||||
describe('FeatureRepository', () => {
|
||||
let repository: FeatureRepository;
|
||||
let mockPrisma: any;
|
||||
|
||||
beforeEach(() => {
|
||||
jest.clearAllMocks();
|
||||
repository = new FeatureRepository();
|
||||
mockPrisma = mockPrismaClient;
|
||||
});
|
||||
|
||||
describe('findById', () => {
|
||||
it('should return feature when found', async () => {
|
||||
const mockFeature = { id: '1', name: 'test-feature', enabled: true };
|
||||
mockPrisma.feature.findUnique.mockResolvedValue(mockFeature);
|
||||
|
||||
const result = await repository.findById('1');
|
||||
|
||||
expect(mockPrisma.feature.findUnique).toHaveBeenCalledWith({ where: { id: '1' } });
|
||||
expect(result).toEqual(mockFeature);
|
||||
});
|
||||
|
||||
it('should return null when feature not found', async () => {
|
||||
mockPrisma.feature.findUnique.mockResolvedValue(null);
|
||||
|
||||
const result = await repository.findById('1');
|
||||
|
||||
expect(result).toBeNull();
|
||||
});
|
||||
});
|
||||
|
||||
describe('findByName', () => {
|
||||
it('should return feature when found by name', async () => {
|
||||
const mockFeature = { id: '1', name: 'test-feature', enabled: true };
|
||||
mockPrisma.feature.findUnique.mockResolvedValue(mockFeature);
|
||||
|
||||
const result = await repository.findByName('test-feature');
|
||||
|
||||
expect(mockPrisma.feature.findUnique).toHaveBeenCalledWith({
|
||||
where: { name: 'test-feature' }
|
||||
});
|
||||
expect(result).toEqual(mockFeature);
|
||||
});
|
||||
});
|
||||
|
||||
describe('findAll', () => {
|
||||
it('should return all features with default options', async () => {
|
||||
const mockFeatures = [
|
||||
{ id: '1', name: 'feature-1' },
|
||||
{ id: '2', name: 'feature-2' },
|
||||
];
|
||||
mockPrisma.feature.findMany.mockResolvedValue(mockFeatures);
|
||||
|
||||
const result = await repository.findAll();
|
||||
|
||||
expect(mockPrisma.feature.findMany).toHaveBeenCalledWith({});
|
||||
expect(result).toEqual(mockFeatures);
|
||||
});
|
||||
|
||||
it('should return features with custom options', async () => {
|
||||
const options = { where: { enabled: true }, orderBy: { createdAt: 'desc' } };
|
||||
const mockFeatures = [{ id: '1', name: 'enabled-feature' }];
|
||||
mockPrisma.feature.findMany.mockResolvedValue(mockFeatures);
|
||||
|
||||
const result = await repository.findAll(options);
|
||||
|
||||
expect(mockPrisma.feature.findMany).toHaveBeenCalledWith(options);
|
||||
expect(result).toEqual(mockFeatures);
|
||||
});
|
||||
});
|
||||
|
||||
describe('create', () => {
|
||||
it('should create feature successfully when name is unique', async () => {
|
||||
const createData = { name: 'new-feature', title: 'New Feature' };
|
||||
const mockFeature = { id: '1', ...createData, enabled: true };
|
||||
|
||||
// Mock no existing feature
|
||||
mockPrisma.feature.findUnique.mockResolvedValue(null);
|
||||
mockPrisma.feature.create.mockResolvedValue(mockFeature);
|
||||
|
||||
const result = await repository.create(createData);
|
||||
|
||||
expect(mockPrisma.feature.findUnique).toHaveBeenCalledWith({
|
||||
where: { name: 'new-feature' }
|
||||
});
|
||||
expect(mockPrisma.feature.create).toHaveBeenCalledWith({ data: createData });
|
||||
expect(result).toEqual(mockFeature);
|
||||
});
|
||||
|
||||
it('should throw ConflictError when feature name already exists', async () => {
|
||||
const createData = { name: 'existing-feature' };
|
||||
const existingFeature = { id: '1', name: 'existing-feature' };
|
||||
|
||||
mockPrisma.feature.findUnique.mockResolvedValue(existingFeature);
|
||||
|
||||
await expect(repository.create(createData)).rejects.toThrow(ConflictError);
|
||||
expect(mockPrisma.feature.create).not.toHaveBeenCalled();
|
||||
});
|
||||
});
|
||||
|
||||
describe('update', () => {
|
||||
it('should update feature successfully', async () => {
|
||||
const updateData = { title: 'Updated Title' };
|
||||
const mockFeature = { id: '1', name: 'test-feature', title: 'Updated Title' };
|
||||
|
||||
mockPrisma.feature.update.mockResolvedValue(mockFeature);
|
||||
|
||||
const result = await repository.update('1', updateData);
|
||||
|
||||
expect(mockPrisma.feature.update).toHaveBeenCalledWith({
|
||||
where: { id: '1' },
|
||||
data: updateData,
|
||||
});
|
||||
expect(result).toEqual(mockFeature);
|
||||
});
|
||||
});
|
||||
|
||||
describe('delete', () => {
|
||||
it('should delete feature successfully', async () => {
|
||||
mockPrisma.feature.delete.mockResolvedValue({});
|
||||
|
||||
const result = await repository.delete('1');
|
||||
|
||||
expect(mockPrisma.feature.delete).toHaveBeenCalledWith({
|
||||
where: { id: '1' }
|
||||
});
|
||||
expect(result).toBe(true);
|
||||
});
|
||||
});
|
||||
|
||||
describe('count', () => {
|
||||
it('should return count of features', async () => {
|
||||
mockPrisma.feature.count.mockResolvedValue(5);
|
||||
|
||||
const result = await repository.count();
|
||||
|
||||
expect(mockPrisma.feature.count).toHaveBeenCalledWith({ where: undefined });
|
||||
expect(result).toBe(5);
|
||||
});
|
||||
|
||||
it('should return count with where clause', async () => {
|
||||
const where = { enabled: true };
|
||||
mockPrisma.feature.count.mockResolvedValue(3);
|
||||
|
||||
const result = await repository.count(where);
|
||||
|
||||
expect(mockPrisma.feature.count).toHaveBeenCalledWith({ where });
|
||||
expect(result).toBe(3);
|
||||
});
|
||||
});
|
||||
|
||||
describe('exists', () => {
|
||||
it('should return true when feature exists', async () => {
|
||||
mockPrisma.feature.count.mockResolvedValue(1);
|
||||
|
||||
const result = await repository.exists('1');
|
||||
|
||||
expect(mockPrisma.feature.count).toHaveBeenCalledWith({ where: { id: '1' } });
|
||||
expect(result).toBe(true);
|
||||
});
|
||||
|
||||
it('should return false when feature does not exist', async () => {
|
||||
mockPrisma.feature.count.mockResolvedValue(0);
|
||||
|
||||
const result = await repository.exists('1');
|
||||
|
||||
expect(result).toBe(false);
|
||||
});
|
||||
});
|
||||
|
||||
describe('toggleEnabled', () => {
|
||||
it('should toggle feature from disabled to enabled', async () => {
|
||||
const existingFeature = { id: '1', name: 'test-feature', enabled: false };
|
||||
const updatedFeature = { ...existingFeature, enabled: true };
|
||||
|
||||
mockPrisma.feature.findUnique.mockResolvedValue(existingFeature);
|
||||
mockPrisma.feature.update.mockResolvedValue(updatedFeature);
|
||||
|
||||
const result = await repository.toggleEnabled('1');
|
||||
|
||||
expect(mockPrisma.feature.update).toHaveBeenCalledWith({
|
||||
where: { id: '1' },
|
||||
data: { enabled: true },
|
||||
});
|
||||
expect(result).toEqual(updatedFeature);
|
||||
});
|
||||
|
||||
it('should throw ConflictError when feature not found', async () => {
|
||||
mockPrisma.feature.findUnique.mockResolvedValue(null);
|
||||
|
||||
await expect(repository.toggleEnabled('1')).rejects.toThrow(ConflictError);
|
||||
expect(mockPrisma.feature.update).not.toHaveBeenCalled();
|
||||
});
|
||||
});
|
||||
|
||||
describe('findByTags', () => {
|
||||
it('should return features matching tags', async () => {
|
||||
const tags = ['web', 'api'];
|
||||
const mockFeatures = [
|
||||
{ id: '1', name: 'web-feature', tags: ['web'] },
|
||||
{ id: '2', name: 'api-feature', tags: ['api'] },
|
||||
];
|
||||
|
||||
mockPrisma.feature.findMany.mockResolvedValue(mockFeatures);
|
||||
|
||||
const result = await repository.findByTags(tags);
|
||||
|
||||
expect(mockPrisma.feature.findMany).toHaveBeenCalledWith({
|
||||
where: {
|
||||
tags: {
|
||||
hasSome: tags,
|
||||
},
|
||||
},
|
||||
orderBy: { createdAt: 'desc' },
|
||||
});
|
||||
expect(result).toEqual(mockFeatures);
|
||||
});
|
||||
});
|
||||
|
||||
describe('findEnabled', () => {
|
||||
it('should return only enabled features', async () => {
|
||||
const mockFeatures = [
|
||||
{ id: '1', name: 'enabled-feature', enabled: true },
|
||||
{ id: '2', name: 'disabled-feature', enabled: false },
|
||||
];
|
||||
|
||||
mockPrisma.feature.findMany.mockResolvedValue([mockFeatures[0]]);
|
||||
|
||||
const result = await repository.findEnabled();
|
||||
|
||||
expect(mockPrisma.feature.findMany).toHaveBeenCalledWith({
|
||||
where: { enabled: true },
|
||||
orderBy: { createdAt: 'desc' },
|
||||
});
|
||||
expect(result).toEqual([mockFeatures[0]]);
|
||||
});
|
||||
});
|
||||
|
||||
describe('search', () => {
|
||||
it('should search features by query', async () => {
|
||||
const query = 'test';
|
||||
const mockFeatures = [
|
||||
{ id: '1', name: 'test-feature', title: 'Test Feature' },
|
||||
];
|
||||
|
||||
mockPrisma.feature.findMany.mockResolvedValue(mockFeatures);
|
||||
|
||||
const result = await repository.search(query);
|
||||
|
||||
expect(mockPrisma.feature.findMany).toHaveBeenCalledWith({
|
||||
where: {
|
||||
OR: [
|
||||
{ name: { contains: query, mode: 'insensitive' } },
|
||||
{ title: { contains: query, mode: 'insensitive' } },
|
||||
{ description: { contains: query, mode: 'insensitive' } },
|
||||
],
|
||||
},
|
||||
take: 10,
|
||||
orderBy: { createdAt: 'desc' },
|
||||
});
|
||||
expect(result).toEqual(mockFeatures);
|
||||
});
|
||||
});
|
||||
|
||||
describe('getStatistics', () => {
|
||||
it('should return feature statistics', async () => {
|
||||
const mockFeatures = [
|
||||
{ id: '1', name: 'feature1', tags: ['web', 'api'], enabled: true },
|
||||
{ id: '2', name: 'feature2', tags: ['web'], enabled: false },
|
||||
{ id: '3', name: 'feature3', tags: ['mobile'], enabled: true },
|
||||
];
|
||||
|
||||
mockPrisma.feature.count
|
||||
.mockResolvedValueOnce(3) // total
|
||||
.mockResolvedValueOnce(2) // enabled
|
||||
.mockResolvedValueOnce(1); // disabled
|
||||
|
||||
mockPrisma.feature.findMany.mockResolvedValue(mockFeatures);
|
||||
|
||||
const result = await repository.getStatistics();
|
||||
|
||||
expect(result).toEqual({
|
||||
total: 3,
|
||||
enabled: 2,
|
||||
disabled: 1,
|
||||
byTag: {
|
||||
web: 2,
|
||||
api: 1,
|
||||
mobile: 1,
|
||||
},
|
||||
});
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,122 @@
|
||||
import { FeatureService } from '../feature.service';
|
||||
import { logger } from '@goodgo/logger';
|
||||
import { featureRepository } from '../feature.repository';
|
||||
|
||||
// EN: Mock the logger to avoid console output during tests
|
||||
// VI: Mock logger để tránh output console trong tests
|
||||
jest.mock('@goodgo/logger');
|
||||
|
||||
// EN: Mock feature repository
|
||||
// VI: Mock feature repository
|
||||
jest.mock('../feature.repository', () => ({
|
||||
featureRepository: {
|
||||
create: jest.fn(),
|
||||
findById: jest.fn(),
|
||||
update: jest.fn(),
|
||||
delete: jest.fn(),
|
||||
findAll: jest.fn(),
|
||||
},
|
||||
}));
|
||||
|
||||
describe('FeatureService', () => {
|
||||
let featureService: FeatureService;
|
||||
|
||||
beforeEach(() => {
|
||||
// EN: Clear all mocks before each test
|
||||
// VI: Xóa tất cả mocks trước mỗi test
|
||||
jest.clearAllMocks();
|
||||
featureService = new FeatureService();
|
||||
});
|
||||
|
||||
describe('create', () => {
|
||||
it('should create a feature successfully', async () => {
|
||||
// EN: Arrange
|
||||
// VI: Chuẩn bị
|
||||
const testData = { name: 'test-feature', title: 'Test Feature', description: 'A test feature' };
|
||||
const mockFeature = {
|
||||
id: 'test-id',
|
||||
name: testData.name,
|
||||
title: testData.title,
|
||||
description: testData.description,
|
||||
config: {},
|
||||
enabled: true,
|
||||
version: '1.0.0',
|
||||
tags: [],
|
||||
createdAt: new Date(),
|
||||
updatedAt: new Date(),
|
||||
};
|
||||
(featureRepository.create as jest.Mock).mockResolvedValue(mockFeature);
|
||||
|
||||
// EN: Act
|
||||
// VI: Thực hiện
|
||||
const result = await featureService.create(testData);
|
||||
|
||||
// EN: Assert
|
||||
// VI: Kiểm tra
|
||||
expect(featureRepository.create).toHaveBeenCalledWith(testData);
|
||||
expect(logger.info).toHaveBeenCalledWith('Creating feature / Tạo feature', { data: testData });
|
||||
expect(logger.info).toHaveBeenCalledWith('Feature created successfully / Feature đã được tạo thành công', { featureId: mockFeature.id });
|
||||
expect(result).toEqual(mockFeature);
|
||||
});
|
||||
|
||||
it('should handle minimal data', async () => {
|
||||
// EN: Arrange
|
||||
// VI: Chuẩn bị
|
||||
const minimalData = { name: 'minimal-feature' };
|
||||
const mockFeature = {
|
||||
id: 'minimal-id',
|
||||
name: minimalData.name,
|
||||
config: {},
|
||||
enabled: true,
|
||||
version: '1.0.0',
|
||||
tags: [],
|
||||
createdAt: new Date(),
|
||||
updatedAt: new Date(),
|
||||
};
|
||||
(featureRepository.create as jest.Mock).mockResolvedValue(mockFeature);
|
||||
|
||||
// EN: Act
|
||||
// VI: Thực hiện
|
||||
const result = await featureService.create(minimalData);
|
||||
|
||||
// EN: Assert
|
||||
// VI: Kiểm tra
|
||||
expect(logger.info).toHaveBeenCalledWith('Creating feature / Tạo feature', { data: minimalData });
|
||||
expect(result).toEqual(mockFeature);
|
||||
});
|
||||
|
||||
it('should handle complex data structures', async () => {
|
||||
// EN: Arrange
|
||||
// VI: Chuẩn bị
|
||||
const complexData = {
|
||||
name: 'advanced-feature',
|
||||
title: 'Advanced Feature',
|
||||
description: 'Feature with complex data',
|
||||
config: { enabled: true, priority: 1 },
|
||||
tags: ['advanced', 'complex']
|
||||
};
|
||||
const mockFeature = {
|
||||
id: 'complex-id',
|
||||
name: complexData.name,
|
||||
title: complexData.title,
|
||||
description: complexData.description,
|
||||
config: complexData.config,
|
||||
enabled: true,
|
||||
version: '1.0.0',
|
||||
tags: complexData.tags,
|
||||
createdAt: new Date(),
|
||||
updatedAt: new Date(),
|
||||
};
|
||||
(featureRepository.create as jest.Mock).mockResolvedValue(mockFeature);
|
||||
|
||||
// EN: Act
|
||||
// VI: Thực hiện
|
||||
const result = await featureService.create(complexData);
|
||||
|
||||
// EN: Assert
|
||||
// VI: Kiểm tra
|
||||
expect(logger.info).toHaveBeenCalledWith('Creating feature / Tạo feature', { data: complexData });
|
||||
expect(result).toEqual(mockFeature);
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,181 @@
|
||||
import { ApiResponse } from '@goodgo/types';
|
||||
import { Request, Response } from 'express';
|
||||
|
||||
import { asyncHandler } from '../../middlewares/error.middleware';
|
||||
|
||||
import { FeatureService } from './feature.service';
|
||||
|
||||
|
||||
/**
|
||||
* EN: Controller for Feature module
|
||||
* VI: Controller cho module Feature
|
||||
*/
|
||||
export class FeatureController {
|
||||
private featureService: FeatureService;
|
||||
|
||||
constructor() {
|
||||
// EN: Service initialization
|
||||
// VI: Khởi tạo service
|
||||
this.featureService = new FeatureService();
|
||||
}
|
||||
|
||||
/**
|
||||
* EN: Create a new feature
|
||||
* VI: Tạo một feature mới
|
||||
*
|
||||
* @param req - Express request
|
||||
* @param res - Express response
|
||||
*/
|
||||
create = asyncHandler(async (req: Request, res: Response): Promise<void> => {
|
||||
const featureData = req.body;
|
||||
const feature = await this.featureService.create(featureData);
|
||||
|
||||
const response: ApiResponse = {
|
||||
success: true,
|
||||
data: feature,
|
||||
message: 'Feature created successfully / Feature đã được tạo thành công',
|
||||
timestamp: new Date().toISOString(),
|
||||
};
|
||||
res.status(201).json(response);
|
||||
});
|
||||
|
||||
/**
|
||||
* EN: Get all features
|
||||
* VI: Lấy tất cả features
|
||||
*/
|
||||
getAll = asyncHandler(async (_req: Request, res: Response): Promise<void> => {
|
||||
const features = await this.featureService.findAll();
|
||||
|
||||
const response: ApiResponse = {
|
||||
success: true,
|
||||
data: features,
|
||||
message: 'Features retrieved successfully / Features đã được lấy thành công',
|
||||
timestamp: new Date().toISOString(),
|
||||
};
|
||||
res.json(response);
|
||||
});
|
||||
|
||||
/**
|
||||
* EN: Get feature by ID
|
||||
* VI: Lấy feature theo ID
|
||||
*/
|
||||
getById = async (req: Request, res: Response): Promise<void> => {
|
||||
try {
|
||||
const { id } = req.params;
|
||||
const feature = await this.featureService.findById(id);
|
||||
|
||||
if (!feature) {
|
||||
res.status(404).json({
|
||||
success: false,
|
||||
error: {
|
||||
code: 'FEATURE_003',
|
||||
message: 'Feature not found / Không tìm thấy feature',
|
||||
},
|
||||
timestamp: new Date().toISOString(),
|
||||
});
|
||||
return;
|
||||
}
|
||||
|
||||
const response: ApiResponse = {
|
||||
success: true,
|
||||
data: feature,
|
||||
message: 'Feature retrieved successfully / Feature đã được lấy thành công',
|
||||
timestamp: new Date().toISOString(),
|
||||
};
|
||||
res.json(response);
|
||||
} catch (error: any) {
|
||||
res.status(500).json({
|
||||
success: false,
|
||||
error: {
|
||||
code: 'FEATURE_004',
|
||||
message: error.message || 'Failed to retrieve feature / Không thể lấy feature',
|
||||
},
|
||||
timestamp: new Date().toISOString(),
|
||||
});
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* EN: Update feature
|
||||
* VI: Cập nhật feature
|
||||
*/
|
||||
update = async (req: Request, res: Response): Promise<void> => {
|
||||
try {
|
||||
const { id } = req.params;
|
||||
const updateData = req.body;
|
||||
const feature = await this.featureService.update(id, updateData);
|
||||
|
||||
const response: ApiResponse = {
|
||||
success: true,
|
||||
data: feature,
|
||||
message: 'Feature updated successfully / Feature đã được cập nhật thành công',
|
||||
timestamp: new Date().toISOString(),
|
||||
};
|
||||
res.json(response);
|
||||
} catch (error: any) {
|
||||
res.status(400).json({
|
||||
success: false,
|
||||
error: {
|
||||
code: 'FEATURE_005',
|
||||
message: error.message || 'Failed to update feature / Không thể cập nhật feature',
|
||||
},
|
||||
timestamp: new Date().toISOString(),
|
||||
});
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* EN: Delete feature
|
||||
* VI: Xóa feature
|
||||
*/
|
||||
delete = async (req: Request, res: Response): Promise<void> => {
|
||||
try {
|
||||
const { id } = req.params;
|
||||
await this.featureService.delete(id);
|
||||
|
||||
const response: ApiResponse = {
|
||||
success: true,
|
||||
message: 'Feature deleted successfully / Feature đã được xóa thành công',
|
||||
timestamp: new Date().toISOString(),
|
||||
};
|
||||
res.json(response);
|
||||
} catch (error: any) {
|
||||
res.status(400).json({
|
||||
success: false,
|
||||
error: {
|
||||
code: 'FEATURE_006',
|
||||
message: error.message || 'Failed to delete feature / Không thể xóa feature',
|
||||
},
|
||||
timestamp: new Date().toISOString(),
|
||||
});
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* EN: Toggle feature status
|
||||
* VI: Chuyển đổi trạng thái feature
|
||||
*/
|
||||
toggle = async (req: Request, res: Response): Promise<void> => {
|
||||
try {
|
||||
const { id } = req.params;
|
||||
const feature = await this.featureService.toggle(id);
|
||||
|
||||
const response: ApiResponse = {
|
||||
success: true,
|
||||
data: feature,
|
||||
message: `Feature ${feature.enabled ? 'enabled' : 'disabled'} successfully / Feature đã được ${feature.enabled ? 'bật' : 'tắt'} thành công`,
|
||||
timestamp: new Date().toISOString(),
|
||||
};
|
||||
res.json(response);
|
||||
} catch (error: any) {
|
||||
res.status(400).json({
|
||||
success: false,
|
||||
error: {
|
||||
code: 'FEATURE_007',
|
||||
message: error.message || 'Failed to toggle feature / Không thể chuyển đổi feature',
|
||||
},
|
||||
timestamp: new Date().toISOString(),
|
||||
});
|
||||
}
|
||||
};
|
||||
}
|
||||
42
services/_template_nodejs/src/modules/feature/feature.dto.ts
Normal file
42
services/_template_nodejs/src/modules/feature/feature.dto.ts
Normal file
@@ -0,0 +1,42 @@
|
||||
import { z } from 'zod';
|
||||
|
||||
/**
|
||||
* EN: DTO for creating a new feature
|
||||
* VI: DTO để tạo feature mới
|
||||
*/
|
||||
export const createFeatureDtoSchema = z.object({
|
||||
name: z.string().min(1, 'Name is required / Tên là bắt buộc').max(100, 'Name must be less than 100 characters / Tên phải ít hơn 100 ký tự'),
|
||||
title: z.string().max(200, 'Title must be less than 200 characters / Tiêu đề phải ít hơn 200 ký tự').optional(),
|
||||
description: z.string().max(1000, 'Description must be less than 1000 characters / Mô tả phải ít hơn 1000 ký tự').optional(),
|
||||
config: z.record(z.string(), z.any()).optional(),
|
||||
tags: z.array(z.string()).optional(),
|
||||
});
|
||||
|
||||
export type CreateFeatureDto = z.infer<typeof createFeatureDtoSchema>;
|
||||
|
||||
/**
|
||||
* EN: DTO for updating a feature
|
||||
* VI: DTO để cập nhật feature
|
||||
*/
|
||||
export const updateFeatureDtoSchema = z.object({
|
||||
title: z.string().max(200, 'Title must be less than 200 characters / Tiêu đề phải ít hơn 200 ký tự').optional(),
|
||||
description: z.string().max(1000, 'Description must be less than 1000 characters / Mô tả phải ít hơn 1000 ký tự').optional(),
|
||||
config: z.record(z.string(), z.any()).optional(),
|
||||
enabled: z.boolean().optional(),
|
||||
tags: z.array(z.string()).optional(),
|
||||
});
|
||||
|
||||
export type UpdateFeatureDto = z.infer<typeof updateFeatureDtoSchema>;
|
||||
|
||||
/**
|
||||
* EN: Query parameters for feature listing
|
||||
* VI: Tham số query để liệt kê features
|
||||
*/
|
||||
export const getFeaturesQuerySchema = z.object({
|
||||
enabled: z.string().transform(val => val === 'true').optional(),
|
||||
tags: z.string().transform(val => val ? val.split(',') : undefined).optional(),
|
||||
limit: z.string().transform(Number).optional(),
|
||||
offset: z.string().transform(Number).optional(),
|
||||
});
|
||||
|
||||
export type GetFeaturesQuery = z.infer<typeof getFeaturesQuerySchema>;
|
||||
356
services/_template_nodejs/src/modules/feature/feature.module.ts
Normal file
356
services/_template_nodejs/src/modules/feature/feature.module.ts
Normal file
@@ -0,0 +1,356 @@
|
||||
import { Router } from 'express';
|
||||
|
||||
import { validateDto } from '../../middlewares/validation.middleware';
|
||||
|
||||
import { FeatureController } from './feature.controller';
|
||||
import { createFeatureDtoSchema, updateFeatureDtoSchema } from './feature.dto';
|
||||
|
||||
/**
|
||||
* EN: Create and configure feature routes
|
||||
* VI: Tạo và cấu hình routes cho feature
|
||||
*/
|
||||
export const createFeatureRouter = (): Router => {
|
||||
const router = Router();
|
||||
const featureController = new FeatureController();
|
||||
|
||||
// EN: Public routes - no authentication required
|
||||
// VI: Routes công khai - không yêu cầu xác thực
|
||||
|
||||
/**
|
||||
* @swagger
|
||||
* /api/{version}/features:
|
||||
* get:
|
||||
* summary: Get all features
|
||||
* description: Retrieve a list of all features in the system
|
||||
* tags: [Features]
|
||||
* parameters:
|
||||
* - in: path
|
||||
* name: version
|
||||
* required: true
|
||||
* schema:
|
||||
* type: string
|
||||
* default: v1
|
||||
* description: API version
|
||||
* responses:
|
||||
* 200:
|
||||
* description: Features retrieved successfully
|
||||
* content:
|
||||
* application/json:
|
||||
* schema:
|
||||
* allOf:
|
||||
* - $ref: '#/components/schemas/ApiResponse'
|
||||
* - type: object
|
||||
* properties:
|
||||
* data:
|
||||
* type: array
|
||||
* items:
|
||||
* $ref: '#/components/schemas/Feature'
|
||||
*/
|
||||
router.get('/', featureController.getAll);
|
||||
|
||||
/**
|
||||
* @swagger
|
||||
* /api/{version}/features/{id}:
|
||||
* get:
|
||||
* summary: Get feature by ID
|
||||
* description: Retrieve a specific feature by its unique identifier
|
||||
* tags: [Features]
|
||||
* parameters:
|
||||
* - in: path
|
||||
* name: version
|
||||
* required: true
|
||||
* schema:
|
||||
* type: string
|
||||
* default: v1
|
||||
* description: API version
|
||||
* - in: path
|
||||
* name: id
|
||||
* required: true
|
||||
* schema:
|
||||
* type: string
|
||||
* description: Feature unique identifier
|
||||
* responses:
|
||||
* 200:
|
||||
* description: Feature retrieved successfully
|
||||
* content:
|
||||
* application/json:
|
||||
* schema:
|
||||
* allOf:
|
||||
* - $ref: '#/components/schemas/ApiResponse'
|
||||
* - type: object
|
||||
* properties:
|
||||
* data:
|
||||
* $ref: '#/components/schemas/Feature'
|
||||
* 404:
|
||||
* description: Feature not found
|
||||
* content:
|
||||
* application/json:
|
||||
* schema:
|
||||
* $ref: '#/components/schemas/ErrorResponse'
|
||||
*/
|
||||
router.get('/:id', featureController.getById);
|
||||
|
||||
// EN: Protected routes - authentication and authorization required
|
||||
// VI: Routes được bảo vệ - yêu cầu xác thực và phân quyền
|
||||
|
||||
/**
|
||||
* @swagger
|
||||
* /api/{version}/features:
|
||||
* post:
|
||||
* summary: Create a new feature
|
||||
* description: Create a new feature in the system. Requires admin privileges.
|
||||
* tags: [Features]
|
||||
* security:
|
||||
* - bearerAuth: []
|
||||
* parameters:
|
||||
* - in: path
|
||||
* name: version
|
||||
* required: true
|
||||
* schema:
|
||||
* type: string
|
||||
* default: v1
|
||||
* description: API version
|
||||
* requestBody:
|
||||
* required: true
|
||||
* content:
|
||||
* application/json:
|
||||
* schema:
|
||||
* $ref: '#/components/schemas/CreateFeatureRequest'
|
||||
* example:
|
||||
* name: "user-dashboard"
|
||||
* title: "User Dashboard"
|
||||
* description: "Dashboard for user management"
|
||||
* config: { enabled: true, priority: 1 }
|
||||
* tags: ["ui", "users"]
|
||||
* responses:
|
||||
* 201:
|
||||
* description: Feature created successfully
|
||||
* content:
|
||||
* application/json:
|
||||
* schema:
|
||||
* allOf:
|
||||
* - $ref: '#/components/schemas/ApiResponse'
|
||||
* - type: object
|
||||
* properties:
|
||||
* data:
|
||||
* $ref: '#/components/schemas/Feature'
|
||||
* 400:
|
||||
* description: Validation error or feature already exists
|
||||
* content:
|
||||
* application/json:
|
||||
* schema:
|
||||
* $ref: '#/components/schemas/ErrorResponse'
|
||||
* 401:
|
||||
* description: Authentication required
|
||||
* content:
|
||||
* application/json:
|
||||
* schema:
|
||||
* $ref: '#/components/schemas/ErrorResponse'
|
||||
* 403:
|
||||
* description: Insufficient permissions
|
||||
* content:
|
||||
* application/json:
|
||||
* schema:
|
||||
* $ref: '#/components/schemas/ErrorResponse'
|
||||
*/
|
||||
router.post('/',
|
||||
// authenticate(), // TODO: Re-enable after fixing E2E tests
|
||||
// authorize('admin'),
|
||||
validateDto(createFeatureDtoSchema),
|
||||
featureController.create
|
||||
);
|
||||
|
||||
/**
|
||||
* @swagger
|
||||
* /api/{version}/features/{id}:
|
||||
* put:
|
||||
* summary: Update feature
|
||||
* description: Update an existing feature. Requires admin privileges.
|
||||
* tags: [Features]
|
||||
* security:
|
||||
* - bearerAuth: []
|
||||
* parameters:
|
||||
* - in: path
|
||||
* name: version
|
||||
* required: true
|
||||
* schema:
|
||||
* type: string
|
||||
* default: v1
|
||||
* description: API version
|
||||
* - in: path
|
||||
* name: id
|
||||
* required: true
|
||||
* schema:
|
||||
* type: string
|
||||
* description: Feature unique identifier
|
||||
* requestBody:
|
||||
* required: true
|
||||
* content:
|
||||
* application/json:
|
||||
* schema:
|
||||
* $ref: '#/components/schemas/UpdateFeatureRequest'
|
||||
* example:
|
||||
* title: "Updated Dashboard"
|
||||
* enabled: false
|
||||
* config: { priority: 2 }
|
||||
* responses:
|
||||
* 200:
|
||||
* description: Feature updated successfully
|
||||
* content:
|
||||
* application/json:
|
||||
* schema:
|
||||
* allOf:
|
||||
* - $ref: '#/components/schemas/ApiResponse'
|
||||
* - type: object
|
||||
* properties:
|
||||
* data:
|
||||
* $ref: '#/components/schemas/Feature'
|
||||
* 400:
|
||||
* description: Validation error
|
||||
* content:
|
||||
* application/json:
|
||||
* schema:
|
||||
* $ref: '#/components/schemas/ErrorResponse'
|
||||
* 401:
|
||||
* description: Authentication required
|
||||
* content:
|
||||
* application/json:
|
||||
* schema:
|
||||
* $ref: '#/components/schemas/ErrorResponse'
|
||||
* 403:
|
||||
* description: Insufficient permissions
|
||||
* content:
|
||||
* application/json:
|
||||
* schema:
|
||||
* $ref: '#/components/schemas/ErrorResponse'
|
||||
* 404:
|
||||
* description: Feature not found
|
||||
* content:
|
||||
* application/json:
|
||||
* schema:
|
||||
* $ref: '#/components/schemas/ErrorResponse'
|
||||
*/
|
||||
router.put('/:id',
|
||||
// authenticate(), // TODO: Re-enable after fixing E2E tests
|
||||
// authorize('admin'),
|
||||
validateDto(updateFeatureDtoSchema),
|
||||
featureController.update
|
||||
);
|
||||
|
||||
/**
|
||||
* @swagger
|
||||
* /api/{version}/features/{id}:
|
||||
* delete:
|
||||
* summary: Delete feature
|
||||
* description: Delete a feature from the system. Requires admin privileges.
|
||||
* tags: [Features]
|
||||
* security:
|
||||
* - bearerAuth: []
|
||||
* parameters:
|
||||
* - in: path
|
||||
* name: version
|
||||
* required: true
|
||||
* schema:
|
||||
* type: string
|
||||
* default: v1
|
||||
* description: API version
|
||||
* - in: path
|
||||
* name: id
|
||||
* required: true
|
||||
* schema:
|
||||
* type: string
|
||||
* description: Feature unique identifier
|
||||
* responses:
|
||||
* 200:
|
||||
* description: Feature deleted successfully
|
||||
* content:
|
||||
* application/json:
|
||||
* schema:
|
||||
* $ref: '#/components/schemas/ApiResponse'
|
||||
* 401:
|
||||
* description: Authentication required
|
||||
* content:
|
||||
* application/json:
|
||||
* schema:
|
||||
* $ref: '#/components/schemas/ErrorResponse'
|
||||
* 403:
|
||||
* description: Insufficient permissions
|
||||
* content:
|
||||
* application/json:
|
||||
* schema:
|
||||
* $ref: '#/components/schemas/ErrorResponse'
|
||||
* 404:
|
||||
* description: Feature not found
|
||||
* content:
|
||||
* application/json:
|
||||
* schema:
|
||||
* $ref: '#/components/schemas/ErrorResponse'
|
||||
*/
|
||||
router.delete('/:id',
|
||||
// authenticate(), // TODO: Re-enable after fixing E2E tests
|
||||
// authorize('admin'),
|
||||
featureController.delete
|
||||
);
|
||||
|
||||
/**
|
||||
* @swagger
|
||||
* /api/{version}/features/{id}/toggle:
|
||||
* patch:
|
||||
* summary: Toggle feature status
|
||||
* description: Enable or disable a feature. Requires admin privileges.
|
||||
* tags: [Features]
|
||||
* security:
|
||||
* - bearerAuth: []
|
||||
* parameters:
|
||||
* - in: path
|
||||
* name: version
|
||||
* required: true
|
||||
* schema:
|
||||
* type: string
|
||||
* default: v1
|
||||
* description: API version
|
||||
* - in: path
|
||||
* name: id
|
||||
* required: true
|
||||
* schema:
|
||||
* type: string
|
||||
* description: Feature unique identifier
|
||||
* responses:
|
||||
* 200:
|
||||
* description: Feature status toggled successfully
|
||||
* content:
|
||||
* application/json:
|
||||
* schema:
|
||||
* allOf:
|
||||
* - $ref: '#/components/schemas/ApiResponse'
|
||||
* - type: object
|
||||
* properties:
|
||||
* data:
|
||||
* $ref: '#/components/schemas/Feature'
|
||||
* 401:
|
||||
* description: Authentication required
|
||||
* content:
|
||||
* application/json:
|
||||
* schema:
|
||||
* $ref: '#/components/schemas/ErrorResponse'
|
||||
* 403:
|
||||
* description: Insufficient permissions
|
||||
* content:
|
||||
* application/json:
|
||||
* schema:
|
||||
* $ref: '#/components/schemas/ErrorResponse'
|
||||
* 404:
|
||||
* description: Feature not found
|
||||
* content:
|
||||
* application/json:
|
||||
* schema:
|
||||
* $ref: '#/components/schemas/ErrorResponse'
|
||||
*/
|
||||
router.patch('/:id/toggle',
|
||||
// authenticate(), // TODO: Re-enable after fixing E2E tests
|
||||
// authorize('admin'),
|
||||
featureController.toggle
|
||||
);
|
||||
|
||||
return router;
|
||||
};
|
||||
@@ -0,0 +1,236 @@
|
||||
import { logger } from '@goodgo/logger';
|
||||
|
||||
import { prisma } from '../../config/database.config';
|
||||
import { ConflictError } from '../../errors/http-error';
|
||||
import { BaseRepository, IRepository } from '../common/repository';
|
||||
|
||||
// EN: Feature entity type from Prisma
|
||||
// VI: Feature entity type từ Prisma
|
||||
type Feature = {
|
||||
id: string;
|
||||
name: string;
|
||||
title: string | null;
|
||||
description: string | null;
|
||||
config: any;
|
||||
enabled: boolean;
|
||||
version: string | null;
|
||||
tags: string[];
|
||||
createdAt: Date;
|
||||
updatedAt: Date;
|
||||
};
|
||||
|
||||
// EN: Input types for create/update operations
|
||||
// VI: Input types cho create/update operations
|
||||
type CreateFeatureInput = {
|
||||
name: string;
|
||||
title?: string;
|
||||
description?: string;
|
||||
config?: any;
|
||||
tags?: string[];
|
||||
};
|
||||
|
||||
type UpdateFeatureInput = {
|
||||
title?: string;
|
||||
description?: string;
|
||||
config?: any;
|
||||
enabled?: boolean;
|
||||
tags?: string[];
|
||||
};
|
||||
|
||||
/**
|
||||
* EN: Feature repository implementing repository pattern
|
||||
* VI: Feature repository implement repository pattern
|
||||
*/
|
||||
export class FeatureRepository extends BaseRepository<Feature, CreateFeatureInput, UpdateFeatureInput>
|
||||
implements IRepository<Feature, CreateFeatureInput, UpdateFeatureInput> {
|
||||
|
||||
constructor() {
|
||||
super(prisma, 'feature');
|
||||
}
|
||||
|
||||
/**
|
||||
* EN: Find feature by name (unique field)
|
||||
* VI: Tìm feature theo tên (field duy nhất)
|
||||
*/
|
||||
async findByName(name: string): Promise<Feature | null> {
|
||||
return this.findByUnique('name', name);
|
||||
}
|
||||
|
||||
/**
|
||||
* EN: Find features by tags
|
||||
* VI: Tìm features theo tags
|
||||
*/
|
||||
async findByTags(tags: string[]): Promise<Feature[]> {
|
||||
try {
|
||||
logger.debug('Finding features by tags / Tìm features theo tags', { tags });
|
||||
|
||||
const features = await (this.prisma as any).feature.findMany({
|
||||
where: {
|
||||
tags: {
|
||||
hasSome: tags,
|
||||
},
|
||||
},
|
||||
orderBy: { createdAt: 'desc' },
|
||||
});
|
||||
|
||||
logger.debug(`Found ${features.length} features by tags / Đã tìm thấy ${features.length} features theo tags`, { tags });
|
||||
return features;
|
||||
} catch (error) {
|
||||
logger.error('Failed to find features by tags / Không thể tìm features theo tags', { error, tags });
|
||||
throw this.handleDatabaseError(error, { tags });
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* EN: Find enabled features only
|
||||
* VI: Tìm chỉ features đã được bật
|
||||
*/
|
||||
async findEnabled(): Promise<Feature[]> {
|
||||
try {
|
||||
logger.debug('Finding enabled features / Tìm features đã được bật');
|
||||
|
||||
const features = await (this.prisma as any).feature.findMany({
|
||||
where: { enabled: true },
|
||||
orderBy: { createdAt: 'desc' },
|
||||
});
|
||||
|
||||
logger.debug(`Found ${features.length} enabled features / Đã tìm thấy ${features.length} features đã được bật`);
|
||||
return features;
|
||||
} catch (error) {
|
||||
logger.error('Failed to find enabled features / Không thể tìm features đã được bật', { error });
|
||||
throw this.handleDatabaseError(error);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* EN: Create feature with duplicate name check
|
||||
* VI: Tạo feature với kiểm tra tên trùng lặp
|
||||
*/
|
||||
async create(data: CreateFeatureInput): Promise<Feature> {
|
||||
try {
|
||||
// EN: Check for duplicate name
|
||||
// VI: Kiểm tra tên trùng lặp
|
||||
const existingFeature = await this.findByName(data.name);
|
||||
if (existingFeature) {
|
||||
logger.warn('Feature with this name already exists / Feature với tên này đã tồn tại', { name: data.name });
|
||||
throw new ConflictError('Feature with this name already exists / Feature với tên này đã tồn tại', { name: data.name });
|
||||
}
|
||||
|
||||
return await super.create(data);
|
||||
} catch (error) {
|
||||
if (error instanceof ConflictError) {
|
||||
throw error;
|
||||
}
|
||||
throw error;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* EN: Toggle feature enabled/disabled status
|
||||
* VI: Bật/tắt trạng thái feature
|
||||
*/
|
||||
async toggleEnabled(id: string): Promise<Feature> {
|
||||
try {
|
||||
logger.debug('Toggling feature enabled status / Chuyển đổi trạng thái feature', { id });
|
||||
|
||||
const feature = await this.findById(id);
|
||||
if (!feature) {
|
||||
throw new ConflictError('Feature not found / Feature không tìm thấy', { id });
|
||||
}
|
||||
|
||||
const updatedFeature = await this.update(id, {
|
||||
enabled: !feature.enabled,
|
||||
});
|
||||
|
||||
logger.debug(`Feature ${updatedFeature.enabled ? 'enabled' : 'disabled'} / Feature đã được ${updatedFeature.enabled ? 'bật' : 'tắt'}`, { id });
|
||||
return updatedFeature;
|
||||
} catch (error) {
|
||||
if (error instanceof ConflictError) {
|
||||
throw error;
|
||||
}
|
||||
logger.error('Failed to toggle feature status / Không thể chuyển đổi trạng thái feature', { error, id });
|
||||
throw this.handleDatabaseError(error, { id });
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* EN: Search features by name or description
|
||||
* VI: Tìm kiếm features theo tên hoặc mô tả
|
||||
*/
|
||||
async search(query: string, limit: number = 10): Promise<Feature[]> {
|
||||
try {
|
||||
logger.debug('Searching features / Tìm kiếm features', { query, limit });
|
||||
|
||||
const features = await (this.prisma as any).feature.findMany({
|
||||
where: {
|
||||
OR: [
|
||||
{ name: { contains: query, mode: 'insensitive' } },
|
||||
{ title: { contains: query, mode: 'insensitive' } },
|
||||
{ description: { contains: query, mode: 'insensitive' } },
|
||||
],
|
||||
},
|
||||
take: limit,
|
||||
orderBy: { createdAt: 'desc' },
|
||||
});
|
||||
|
||||
logger.debug(`Found ${features.length} features matching search / Đã tìm thấy ${features.length} features khớp với tìm kiếm`, { query });
|
||||
return features;
|
||||
} catch (error) {
|
||||
logger.error('Failed to search features / Không thể tìm kiếm features', { error, query });
|
||||
throw this.handleDatabaseError(error, { query });
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* EN: Get feature statistics
|
||||
* VI: Lấy thống kê feature
|
||||
*/
|
||||
async getStatistics(): Promise<{
|
||||
total: number;
|
||||
enabled: number;
|
||||
disabled: number;
|
||||
byTag: Record<string, number>;
|
||||
}> {
|
||||
try {
|
||||
logger.debug('Getting feature statistics / Lấy thống kê feature');
|
||||
|
||||
const [total, enabled, disabled, features] = await Promise.all([
|
||||
this.count(),
|
||||
this.count({ enabled: true }),
|
||||
this.count({ enabled: false }),
|
||||
this.findAll(),
|
||||
]);
|
||||
|
||||
// EN: Count by tags
|
||||
// VI: Đếm theo tags
|
||||
const byTag: Record<string, number> = {};
|
||||
features.forEach(feature => {
|
||||
feature.tags.forEach(tag => {
|
||||
byTag[tag] = (byTag[tag] || 0) + 1;
|
||||
});
|
||||
});
|
||||
|
||||
const statistics = { total, enabled, disabled, byTag };
|
||||
logger.debug('Feature statistics retrieved / Thống kê feature đã được lấy', statistics);
|
||||
return statistics;
|
||||
} catch (error) {
|
||||
logger.error('Failed to get feature statistics / Không thể lấy thống kê feature', { error });
|
||||
throw this.handleDatabaseError(error);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* EN: Handle database-specific errors
|
||||
* VI: Xử lý lỗi database-specific
|
||||
*/
|
||||
private handleDatabaseError(error: any, context?: any) {
|
||||
if (error.code === 'P2002') {
|
||||
return new ConflictError('Feature with this name already exists / Feature với tên này đã tồn tại', context);
|
||||
}
|
||||
return error;
|
||||
}
|
||||
}
|
||||
|
||||
// EN: Singleton instance
|
||||
// VI: Singleton instance
|
||||
export const featureRepository = new FeatureRepository();
|
||||
114
services/_template_nodejs/src/modules/feature/feature.service.ts
Normal file
114
services/_template_nodejs/src/modules/feature/feature.service.ts
Normal file
@@ -0,0 +1,114 @@
|
||||
import { logger } from '@goodgo/logger';
|
||||
|
||||
import { NotFoundError } from '../../errors/http-error';
|
||||
|
||||
import { featureRepository } from './feature.repository';
|
||||
|
||||
/**
|
||||
* EN: Service for managing features in the system
|
||||
* VI: Service để quản lý các features trong hệ thống
|
||||
*/
|
||||
export class FeatureService {
|
||||
/**
|
||||
* EN: Create a new feature
|
||||
* VI: Tạo một feature mới
|
||||
*/
|
||||
async create(data: { name: string; title?: string; description?: string; config?: any; tags?: string[] }) {
|
||||
logger.info('Creating feature / Tạo feature', { data });
|
||||
|
||||
const feature = await featureRepository.create(data);
|
||||
|
||||
logger.info('Feature created successfully / Feature đã được tạo thành công', { featureId: feature.id });
|
||||
return feature;
|
||||
}
|
||||
|
||||
/**
|
||||
* EN: Get all features
|
||||
* VI: Lấy tất cả features
|
||||
*/
|
||||
async findAll() {
|
||||
logger.info('Fetching all features / Lấy tất cả features');
|
||||
|
||||
const features = await featureRepository.findAll({
|
||||
orderBy: { createdAt: 'desc' },
|
||||
});
|
||||
|
||||
logger.info(`Retrieved ${features.length} features / Đã lấy ${features.length} features`);
|
||||
return features;
|
||||
}
|
||||
|
||||
/**
|
||||
* EN: Get feature by ID
|
||||
* VI: Lấy feature theo ID
|
||||
*/
|
||||
async findById(id: string) {
|
||||
logger.info('Fetching feature by ID / Lấy feature theo ID', { id });
|
||||
|
||||
const feature = await featureRepository.findById(id);
|
||||
|
||||
if (!feature) {
|
||||
logger.warn('Feature not found / Không tìm thấy feature', { id });
|
||||
throw new NotFoundError('Feature', { id });
|
||||
}
|
||||
|
||||
logger.info('Feature retrieved successfully / Feature đã được lấy thành công', { id });
|
||||
return feature;
|
||||
}
|
||||
|
||||
/**
|
||||
* EN: Get feature by name
|
||||
* VI: Lấy feature theo tên
|
||||
*/
|
||||
async findByName(name: string) {
|
||||
logger.info('Fetching feature by name / Lấy feature theo tên', { name });
|
||||
|
||||
const feature = await featureRepository.findByName(name);
|
||||
|
||||
if (!feature) {
|
||||
logger.warn('Feature not found / Không tìm thấy feature', { name });
|
||||
return null;
|
||||
}
|
||||
|
||||
logger.info('Feature retrieved successfully / Feature đã được lấy thành công', { name });
|
||||
return feature;
|
||||
}
|
||||
|
||||
/**
|
||||
* EN: Update feature
|
||||
* VI: Cập nhật feature
|
||||
*/
|
||||
async update(id: string, data: Partial<{ title?: string; description?: string; config?: any; enabled?: boolean; tags?: string[] }>) {
|
||||
logger.info('Updating feature / Cập nhật feature', { id, data });
|
||||
|
||||
const feature = await featureRepository.update(id, data);
|
||||
|
||||
logger.info('Feature updated successfully / Feature đã được cập nhật thành công', { id });
|
||||
return feature;
|
||||
}
|
||||
|
||||
/**
|
||||
* EN: Delete feature
|
||||
* VI: Xóa feature
|
||||
*/
|
||||
async delete(id: string) {
|
||||
logger.info('Deleting feature / Xóa feature', { id });
|
||||
|
||||
await featureRepository.delete(id);
|
||||
|
||||
logger.info('Feature deleted successfully / Feature đã được xóa thành công', { id });
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* EN: Toggle feature enabled/disabled status
|
||||
* VI: Bật/tắt trạng thái feature
|
||||
*/
|
||||
async toggle(id: string) {
|
||||
logger.info('Toggling feature status / Chuyển đổi trạng thái feature', { id });
|
||||
|
||||
const updatedFeature = await featureRepository.toggleEnabled(id);
|
||||
|
||||
logger.info(`Feature ${updatedFeature.enabled ? 'enabled' : 'disabled'} / Feature đã được ${updatedFeature.enabled ? 'bật' : 'tắt'}`, { id });
|
||||
return updatedFeature;
|
||||
}
|
||||
}
|
||||
8
services/_template_nodejs/src/modules/feature/index.ts
Normal file
8
services/_template_nodejs/src/modules/feature/index.ts
Normal file
@@ -0,0 +1,8 @@
|
||||
// EN: Export all feature-related modules
|
||||
// VI: Export tất cả các modules liên quan đến feature
|
||||
|
||||
export { FeatureService } from './feature.service';
|
||||
export { FeatureController } from './feature.controller';
|
||||
export { createFeatureRouter } from './feature.module';
|
||||
export { featureRepository } from './feature.repository';
|
||||
export * from './feature.dto';
|
||||
@@ -0,0 +1,113 @@
|
||||
import { Request, Response } from 'express';
|
||||
import { HealthController } from '../health.controller';
|
||||
import { prisma } from '../../../config/database.config';
|
||||
|
||||
jest.mock('../../../config/database.config');
|
||||
|
||||
describe('HealthController', () => {
|
||||
let healthController: HealthController;
|
||||
let mockReq: Partial<Request>;
|
||||
let mockRes: Partial<Response>;
|
||||
let mockJson: jest.Mock;
|
||||
let mockStatus: jest.Mock;
|
||||
|
||||
beforeEach(() => {
|
||||
healthController = new HealthController();
|
||||
mockJson = jest.fn();
|
||||
mockStatus = jest.fn().mockReturnValue({ json: mockJson });
|
||||
mockReq = {};
|
||||
mockRes = {
|
||||
json: mockJson,
|
||||
status: mockStatus,
|
||||
};
|
||||
});
|
||||
|
||||
afterEach(() => {
|
||||
jest.clearAllMocks();
|
||||
});
|
||||
|
||||
describe('health', () => {
|
||||
it('should return healthy status', async () => {
|
||||
// EN: Act
|
||||
// VI: Thực hiện
|
||||
await healthController.health(mockReq as Request, mockRes as Response);
|
||||
|
||||
// EN: Assert
|
||||
// VI: Kiểm tra
|
||||
expect(mockJson).toHaveBeenCalledWith({
|
||||
success: true,
|
||||
data: {
|
||||
status: 'ok',
|
||||
timestamp: expect.any(String),
|
||||
},
|
||||
timestamp: expect.any(String),
|
||||
});
|
||||
|
||||
// EN: Verify timestamp is valid ISO string
|
||||
// VI: Xác minh timestamp là ISO string hợp lệ
|
||||
const response = mockJson.mock.calls[0][0];
|
||||
expect(new Date(response.timestamp).toISOString()).toBe(response.timestamp);
|
||||
expect(new Date(response.data.timestamp).toISOString()).toBe(response.data.timestamp);
|
||||
});
|
||||
});
|
||||
|
||||
describe('ready', () => {
|
||||
it('should return ready status when database is connected', async () => {
|
||||
// EN: Arrange
|
||||
// VI: Chuẩn bị
|
||||
(prisma.$queryRaw as jest.Mock).mockResolvedValue([{ '1': 1 }]);
|
||||
|
||||
// EN: Act
|
||||
// VI: Thực hiện
|
||||
await healthController.ready(mockReq as Request, mockRes as Response);
|
||||
|
||||
// EN: Assert
|
||||
// VI: Kiểm tra
|
||||
expect(prisma.$queryRaw).toHaveBeenCalledWith(expect.anything());
|
||||
expect(mockJson).toHaveBeenCalledWith({
|
||||
success: true,
|
||||
data: { status: 'ready' },
|
||||
timestamp: expect.any(String),
|
||||
});
|
||||
});
|
||||
|
||||
it('should return 503 when database connection fails', async () => {
|
||||
// EN: Arrange
|
||||
// VI: Chuẩn bị
|
||||
const dbError = new Error('Database connection failed');
|
||||
(prisma.$queryRaw as jest.Mock).mockRejectedValue(dbError);
|
||||
|
||||
// EN: Act
|
||||
// VI: Thực hiện
|
||||
await healthController.ready(mockReq as Request, mockRes as Response);
|
||||
|
||||
// EN: Assert
|
||||
// VI: Kiểm tra
|
||||
expect(mockStatus).toHaveBeenCalledWith(503);
|
||||
expect(mockJson).toHaveBeenCalledWith({
|
||||
success: false,
|
||||
error: {
|
||||
code: 'HEALTH_001',
|
||||
message: 'Service not ready',
|
||||
},
|
||||
timestamp: expect.any(String),
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
describe('live', () => {
|
||||
it('should return live status', async () => {
|
||||
// EN: Act
|
||||
// VI: Thực hiện
|
||||
await healthController.live(mockReq as Request, mockRes as Response);
|
||||
|
||||
// EN: Assert
|
||||
// VI: Kiểm tra
|
||||
expect(mockJson).toHaveBeenCalledWith({
|
||||
success: true,
|
||||
data: { status: 'live' },
|
||||
timestamp: expect.any(String),
|
||||
});
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,67 @@
|
||||
import { ApiResponse } from '@goodgo/types';
|
||||
import { Request, Response } from 'express';
|
||||
|
||||
import { prisma } from '../../config/database.config';
|
||||
|
||||
/**
|
||||
* EN: Controller for health checks
|
||||
* VI: Controller cho các kiểm tra sức khỏe hệ thống
|
||||
*/
|
||||
export class HealthController {
|
||||
/**
|
||||
* EN: Basic liveness probe
|
||||
* VI: Kiểm tra liveness cơ bản
|
||||
*/
|
||||
health = async (_req: Request, res: Response): Promise<void> => {
|
||||
const response: ApiResponse<{ status: string; timestamp: string }> = {
|
||||
success: true,
|
||||
data: {
|
||||
status: 'ok',
|
||||
timestamp: new Date().toISOString(),
|
||||
},
|
||||
timestamp: new Date().toISOString(),
|
||||
};
|
||||
|
||||
res.json(response);
|
||||
};
|
||||
|
||||
/**
|
||||
* EN: Readiness probe (checks database connection)
|
||||
* VI: Kiểm tra readiness (kiểm tra kết nối database)
|
||||
*/
|
||||
ready = async (_req: Request, res: Response): Promise<void> => {
|
||||
try {
|
||||
// EN: Check database connection
|
||||
// VI: Kiểm tra kết nối database
|
||||
await prisma.$queryRaw`SELECT 1`;
|
||||
res.json({
|
||||
success: true,
|
||||
data: { status: 'ready' },
|
||||
timestamp: new Date().toISOString(),
|
||||
});
|
||||
} catch {
|
||||
// EN: Return 503 if database is not ready
|
||||
// VI: Trả về 503 nếu database chưa sẵn sàng
|
||||
res.status(503).json({
|
||||
success: false,
|
||||
error: {
|
||||
code: 'HEALTH_001',
|
||||
message: 'Service not ready',
|
||||
},
|
||||
timestamp: new Date().toISOString(),
|
||||
});
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* EN: Alias for health check
|
||||
* VI: Alias cho kiểm tra sức khỏe
|
||||
*/
|
||||
live = async (_req: Request, res: Response): Promise<void> => {
|
||||
res.json({
|
||||
success: true,
|
||||
data: { status: 'live' },
|
||||
timestamp: new Date().toISOString(),
|
||||
});
|
||||
};
|
||||
}
|
||||
@@ -0,0 +1,35 @@
|
||||
import { logger } from '@goodgo/logger';
|
||||
import { Request, Response } from 'express';
|
||||
import { register } from 'prom-client';
|
||||
|
||||
/**
|
||||
* EN: Controller for handling metrics requests
|
||||
* VI: Controller xử lý các request liên quan đến metrics
|
||||
*/
|
||||
export class MetricsController {
|
||||
/**
|
||||
* EN: Get current metrics in Prometheus format
|
||||
* VI: Lấy metrics hiện tại theo định dạng Prometheus
|
||||
*
|
||||
* @param _req - Express request (unused/chưa dùng)
|
||||
* @param res - Express response
|
||||
*/
|
||||
public async getMetrics(_req: Request, res: Response): Promise<void> {
|
||||
|
||||
try {
|
||||
// EN: Set content type for Prometheus
|
||||
// VI: Thiết lập content type cho Prometheus
|
||||
res.set('Content-Type', register.contentType);
|
||||
|
||||
// EN: Return metrics
|
||||
// VI: Trả về metrics
|
||||
res.end(await register.metrics());
|
||||
} catch (error) {
|
||||
// EN: Log error and return 500
|
||||
// VI: Ghi log lỗi và trả về 500
|
||||
logger.error('Error getting metrics', { error });
|
||||
res.status(500).send('Error getting metrics');
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user