@codai/cbd/dist/enterprise/server.js

Codai Better Database - High-Performance Vector Memory System with HPKV-inspired architecture and MCP server

/**
 * CBD Enterprise - gRPC Server
 *
 * TypeScript interface for the Rust-based CBD gRPC server
 * Provides high-performance server capabilities with enterprise features
 */
/**
 * CBD Enterprise Server
 *
 * High-performance gRPC and REST server with enterprise monitoring
 */
export class CBDEnterpriseServer {
    config;
    isRunning = false;
    startTime;
    constructor(config) {
        this.config = config;
    }
    /**
     * Start the enterprise server
     */
    async start() {
        if (this.isRunning) {
            throw new Error('Server is already running');
        }
        console.log('Starting CBD Enterprise Server');
        console.log(`gRPC port: ${this.config.grpcPort}`);
        console.log(`REST port: ${this.config.restPort}`);
        console.log(`Admin port: ${this.config.adminPort}`);
        console.log(`TLS enabled: ${this.config.enableTLS}`);
        // This will call into Rust cbd-server to start the actual server
        this.startTime = new Date();
        this.isRunning = true;
        console.log('CBD Enterprise Server started successfully');
    }
    /**
     * Stop the enterprise server
     */
    async stop() {
        if (!this.isRunning) {
            return;
        }
        console.log('Stopping CBD Enterprise Server');
        // This will call into Rust cbd-server to gracefully shutdown
        this.isRunning = false;
        delete this.startTime;
        console.log('CBD Enterprise Server stopped');
    }
    /**
     * Get server statistics
     */
    async getStats() {
        if (!this.isRunning || !this.startTime) {
            throw new Error('Server is not running');
        }
        const uptime = Math.floor((Date.now() - this.startTime.getTime()) / 1000);
        // This will call into Rust cbd-server for actual metrics
        return {
            uptime,
            totalRequests: Math.floor(Math.random() * 10000), // Mock data
            activeConnections: Math.floor(Math.random() * 100),
            requestsPerSecond: Math.floor(Math.random() * 1000),
            averageResponseTime: Math.floor(Math.random() * 100),
            errorRate: Math.random() * 0.05, // 0-5% error rate
            memoryUsage: Math.floor(Math.random() * 1024 * 1024 * 1024), // Bytes
            cpuUsage: Math.random() * 100 // Percentage
        };
    }
    /**
     * Perform health check
     */
    async healthCheck() {
        const isHealthy = this.isRunning;
        // This will call into Rust cbd-server and other modules for actual health
        return {
            status: isHealthy ? 'healthy' : 'unhealthy',
            timestamp: new Date(),
            checks: {
                database: isHealthy,
                memory: isHealthy,
                cluster: isHealthy,
                security: isHealthy
            },
            details: isHealthy
                ? ['All systems operational']
                : ['Server not running']
        };
    }
    /**
     * Get Prometheus metrics
     */
    async getMetrics() {
        if (!this.config.enableMetrics) {
            throw new Error('Metrics not enabled');
        }
        const stats = await this.getStats();
        // This will call into Rust cbd-server for actual Prometheus metrics
        return `
# HELP cbd_total_requests Total number of requests
# TYPE cbd_total_requests counter
cbd_total_requests ${stats.totalRequests}

# HELP cbd_active_connections Number of active connections
# TYPE cbd_active_connections gauge
cbd_active_connections ${stats.activeConnections}

# HELP cbd_requests_per_second Requests per second
# TYPE cbd_requests_per_second gauge
cbd_requests_per_second ${stats.requestsPerSecond}

# HELP cbd_average_response_time Average response time in milliseconds
# TYPE cbd_average_response_time gauge
cbd_average_response_time ${stats.averageResponseTime}

# HELP cbd_error_rate Error rate percentage
# TYPE cbd_error_rate gauge
cbd_error_rate ${stats.errorRate}

# HELP cbd_memory_usage Memory usage in bytes
# TYPE cbd_memory_usage gauge
cbd_memory_usage ${stats.memoryUsage}

# HELP cbd_cpu_usage CPU usage percentage
# TYPE cbd_cpu_usage gauge
cbd_cpu_usage ${stats.cpuUsage}

# HELP cbd_uptime Server uptime in seconds
# TYPE cbd_uptime counter
cbd_uptime ${stats.uptime}
    `.trim();
    }
    /**
     * Reload server configuration
     */
    async reloadConfig(newConfig) {
        if (!this.isRunning) {
            throw new Error('Server is not running');
        }
        console.log('Reloading server configuration');
        // Update config (only non-port settings can be reloaded)
        if (newConfig.maxConnections !== undefined) {
            this.config.maxConnections = newConfig.maxConnections;
        }
        if (newConfig.enableMetrics !== undefined) {
            this.config.enableMetrics = newConfig.enableMetrics;
        }
        if (newConfig.enableTracing !== undefined) {
            this.config.enableTracing = newConfig.enableTracing;
        }
        // This will call into Rust cbd-server to apply new configuration
        console.log('Configuration reloaded successfully');
    }
    /**
     * Get current server configuration
     */
    getConfig() {
        return { ...this.config };
    }
    /**
     * Check if server is running
     */
    isHealthy() {
        return this.isRunning;
    }
}
export default CBDEnterpriseServer;
//# sourceMappingURL=server.js.map