database.config.ts•3.73 kB
/**
* Database configuration
*
* This module provides database configuration and connection management
*/
import { logger } from '../utils/logger';
import { PrismaClient } from '@prisma/client';
// Import the Prisma client instance
import prismaClient from '../utils/prisma';
/**
* Database configuration options
*/
export interface DatabaseConfig {
/**
* Maximum number of connections in pool
*/
maxConnections?: number;
/**
* Connection timeout in milliseconds
*/
connectionTimeout?: number;
/**
* Enable query logging
*/
enableLogging?: boolean;
/**
* Database URL
*/
url?: string;
}
/**
* Default database configuration
*/
const defaultConfig: DatabaseConfig = {
maxConnections: 10,
connectionTimeout: 30000,
enableLogging: process.env.NODE_ENV !== 'production',
url: process.env.DATABASE_URL
};
/**
* Database client singleton
*/
export class Database {
private static instance: Database | null = null;
private client: PrismaClient;
private config: DatabaseConfig;
private isConnected: boolean = false;
/**
* Create database instance with configuration
* @param config Database configuration
*/
private constructor(config: DatabaseConfig = {}) {
this.config = { ...defaultConfig, ...config };
// Use the imported Prisma client instance
this.client = prismaClient;
// Log database operations in development
if (this.config.enableLogging) {
logger.info('Database logging enabled');
}
}
/**
* Get singleton database instance
* @param config Database configuration
* @returns Database instance
*/
public static getInstance(config?: DatabaseConfig): Database {
if (!Database.instance) {
Database.instance = new Database(config);
}
return Database.instance!;
}
/**
* Get Prisma client
* @returns Prisma client
*/
public getClient(): PrismaClient {
return this.client;
}
/**
* Connect to database
* @returns Promise resolving when connected
*/
public async connect(): Promise<void> {
if (this.isConnected) {
return;
}
try {
await this.client.$connect();
this.isConnected = true;
logger.info('Connected to database');
} catch (error) {
logger.error('Failed to connect to database:', error);
throw error;
}
}
/**
* Disconnect from database
* @returns Promise resolving when disconnected
*/
public async disconnect(): Promise<void> {
if (!this.isConnected) {
return;
}
try {
await this.client.$disconnect();
this.isConnected = false;
logger.info('Disconnected from database');
} catch (error) {
logger.error('Failed to disconnect from database:', error);
throw error;
}
}
/**
* Execute function within a transaction
* @param fn Function to execute within transaction
* @returns Result of function
*/
public async transaction<T>(fn: (tx: any) => Promise<T>): Promise<T> {
try {
return await this.client.$transaction(async (tx: any) => {
return await fn(tx);
});
} catch (error) {
logger.error('Transaction error:', error);
throw error;
}
}
/**
* Check if connected to database
* @returns True if connected
*/
public isConnectedToDatabase(): boolean {
return this.isConnected;
}
/**
* Get current database configuration
* @returns Database configuration
*/
public getConfig(): DatabaseConfig {
return { ...this.config };
}
}
// Export singleton instance
export const db = Database.getInstance();
// Export Prisma client for direct access
export const prisma = db.getClient();