@0xobelisk/graphql-server/dist/config/subscription-config.js

Tookit for interacting with dubhe graphql server

"use strict";
// Subscription configuration manager - supports dynamic configuration for three subscription modes
Object.defineProperty(exports, "__esModule", { value: true });
exports.subscriptionConfig = exports.SubscriptionConfigManager = void 0;
class SubscriptionConfigManager {
    config;
    constructor(configInput) {
        this.config = this.parseConfigInput(configInput);
    }
    // Parse configuration from input parameters
    parseConfigInput(input) {
        const enableSubscriptions = input.enableSubscriptions;
        // Auto-detect WAL level (in actual applications, query through database)
        const walLevel = this.detectWalLevel(input.databaseUrl);
        // Determine capabilities based on input parameters - default enable all features when subscriptions are enabled
        const capabilities = {
            liveQueries: enableSubscriptions && input.enableLiveQueries !== false && walLevel === 'logical',
            pgSubscriptions: enableSubscriptions && input.enablePgSubscriptions !== false,
            nativeWebSocket: enableSubscriptions && input.enableNativeWebSocket !== false
        };
        return {
            enableSubscriptions,
            capabilities,
            walLevel,
            graphqlPort: parseInt(input.port),
            websocketPort: input.realtimePort ? parseInt(input.realtimePort) : undefined,
            maxConnections: parseInt(input.maxConnections || '1000'),
            heartbeatInterval: parseInt(input.heartbeatInterval || '30000'),
            enableNotificationLogging: input.debugNotifications === true,
            enablePerformanceMetrics: input.enableMetrics === true
        };
    }
    // Detect database WAL level
    detectWalLevel(_databaseUrl) {
        // In actual applications should query database
        // SELECT setting FROM pg_settings WHERE name = 'wal_level';
        // Currently return default value
        return 'replica';
    }
    // Get current configuration
    getConfig() {
        return { ...this.config };
    }
    // Get recommended subscription method
    getRecommendedSubscriptionMethod() {
        if (this.config.capabilities.liveQueries) {
            return 'live-queries';
        }
        else if (this.config.capabilities.pgSubscriptions) {
            return 'pg-subscriptions';
        }
        else if (this.config.capabilities.nativeWebSocket) {
            return 'native-websocket';
        }
        else {
            return 'none';
        }
    }
    // Generate client configuration
    generateClientConfig() {
        const baseUrl = `http://localhost:${this.config.graphqlPort}`;
        return {
            graphqlEndpoint: `${baseUrl}/graphql`,
            subscriptionEndpoint: this.config.capabilities.pgSubscriptions || this.config.capabilities.liveQueries
                ? `ws://localhost:${this.config.graphqlPort}/graphql`
                : undefined,
            nativeWebSocketEndpoint: this.config.capabilities.nativeWebSocket
                ? `ws://localhost:${this.config.websocketPort || this.config.graphqlPort}`
                : undefined,
            capabilities: this.config.capabilities,
            recommendedMethod: this.getRecommendedSubscriptionMethod()
        };
    }
    // Generate PostGraphile configuration - simplified version, only keep listen subscriptions
    generatePostGraphileConfig() {
        return {
            subscriptions: this.config.enableSubscriptions,
            live: false, // Disable live queries, only use listen subscriptions
            simpleSubscriptions: this.config.capabilities.pgSubscriptions,
            // Performance configuration - optimized for listen subscriptions
            pgSettings: {
                statement_timeout: '30s',
                default_transaction_isolation: 'read committed'
            },
            // Monitoring configuration
            allowExplain: this.config.enablePerformanceMetrics,
            disableQueryLog: !this.config.enableNotificationLogging
        };
    }
    // Generate environment variable documentation
    generateDocumentation() {
        return `
# 📡 Subscription System Configuration Guide

## Basic Configuration
enableSubscriptions=${this.config.enableSubscriptions}         # Enable/disable subscription features

## Capability Configuration (optional, auto-detect by default)
enableLiveQueries=${this.config.capabilities.liveQueries}           # Enable @live directive (requires wal_level=logical)
enablePgSubscriptions=${this.config.capabilities.pgSubscriptions}       # Enable PostgreSQL subscriptions 
enableNativeWebSocket=${this.config.capabilities.nativeWebSocket}       # Enable native WebSocket

## Port Configuration
port=${this.config.graphqlPort}                          # GraphQL port
realtimePort=${this.config.websocketPort || 'undefined'}                 # Native WebSocket port (optional)

## Performance Configuration
maxConnections=${this.config.maxConnections}  # Maximum connections
heartbeatInterval=${this.config.heartbeatInterval}  # Heartbeat interval (ms)

## Debug Configuration
debugNotifications=${this.config.enableNotificationLogging}         # Notification logging
enableMetrics=${this.config.enablePerformanceMetrics} # Performance metrics

## Current Configuration Status:
- Subscription Features: ${this.config.enableSubscriptions ? '✅ Enabled' : '❌ Disabled'}
- Live Queries: ${this.config.capabilities.liveQueries ? '✅ Available' : '❌ Not Available'}
- PG Subscriptions: ${this.config.capabilities.pgSubscriptions ? '✅ Available' : '❌ Not Available'}  
- Native WebSocket: ${this.config.capabilities.nativeWebSocket ? '✅ Available' : '❌ Not Available'}
- WAL Level: ${this.config.walLevel}
- Recommended Method: ${this.getRecommendedSubscriptionMethod()}
		`;
    }
}
exports.SubscriptionConfigManager = SubscriptionConfigManager;
// Export singleton instance - lazy initialization
let _subscriptionConfigInstance = null;
exports.subscriptionConfig = {
    getConfig() {
        if (!_subscriptionConfigInstance) {
            throw new Error('Subscription config not initialized. Call refresh() first with configuration.');
        }
        return _subscriptionConfigInstance.getConfig();
    },
    generateClientConfig() {
        if (!_subscriptionConfigInstance) {
            throw new Error('Subscription config not initialized. Call refresh() first with configuration.');
        }
        return _subscriptionConfigInstance.generateClientConfig();
    },
    generatePostGraphileConfig() {
        if (!_subscriptionConfigInstance) {
            throw new Error('Subscription config not initialized. Call refresh() first with configuration.');
        }
        return _subscriptionConfigInstance.generatePostGraphileConfig();
    },
    generateDocumentation() {
        if (!_subscriptionConfigInstance) {
            throw new Error('Subscription config not initialized. Call refresh() first with configuration.');
        }
        return _subscriptionConfigInstance.generateDocumentation();
    },
    // Initialize/refresh configuration with input parameters
    refresh(configInput) {
        _subscriptionConfigInstance = new SubscriptionConfigManager(configInput);
    }
};
//# sourceMappingURL=subscription-config.js.map