newpipe-extractor-js/dist/potoken/PoTokenDirector.js

JavaScript/Node.js port of NewPipeExtractor

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.PoTokenDirector = void 0;
const PoTokenProvider_1 = require("./PoTokenProvider");
const WebPoTokenProvider_1 = require("./WebPoTokenProvider");
// PoToken Director - Manages PO token generation with multiple providers and caching
class PoTokenDirector {
    constructor(options = {}) {
        this.providers = new Map();
        this.options = {
            enableCache: options.enableCache ?? true,
            preferredProvider: options.preferredProvider ?? 'webpo',
            fallbackToAdvanced: options.fallbackToAdvanced ?? true,
            logger: options.logger ?? {
                debug: () => { },
                info: () => { },
                warn: () => { },
                error: () => { }
            }
        };
        this.cache = new PoTokenProvider_1.PoTokenCache();
        this.initializeProviders();
    }
    initializeProviders() {
        // Register default providers
        this.registerProvider(new WebPoTokenProvider_1.WebPoTokenProvider());
        this.registerProvider(new WebPoTokenProvider_1.AdvancedWebPoTokenProvider());
        this.options.logger.debug('Initialized PO token providers');
    }
    registerProvider(provider) {
        this.providers.set(provider.providerName, provider);
        this.options.logger.debug(`Registered PO token provider: ${provider.providerName}`);
    }
    getProvider(name) {
        return this.providers.get(name);
    }
    async getPoToken(request) {
        try {
            // Check cache first (unless bypassed)
            if (this.options.enableCache && !request.bypassCache) {
                const cached = this.cache.get(request);
                if (cached) {
                    this.options.logger.debug('Retrieved PO token from cache');
                    return cached.poToken;
                }
            }
            // Try to get token from providers
            const response = await this.requestTokenFromProviders(request);
            if (!response) {
                this.options.logger.warn('No PO token provider could handle the request');
                return null;
            }
            // Cache the response
            if (this.options.enableCache) {
                this.cache.store(request, response);
                this.options.logger.debug('Stored PO token in cache');
            }
            return response.poToken;
        }
        catch (error) {
            const errorMessage = error instanceof Error ? error.message : String(error);
            this.options.logger.error(`Failed to get PO token: ${errorMessage}`);
            return null;
        }
    }
    async requestTokenFromProviders(request) {
        const providerOrder = this.getProviderOrder();
        for (const providerName of providerOrder) {
            const provider = this.providers.get(providerName);
            if (!provider)
                continue;
            try {
                this.options.logger.debug(`Trying PO token provider: ${providerName}`);
                // Check if provider supports the context
                if (!provider.supportsContext(request.context)) {
                    this.options.logger.debug(`Provider ${providerName} does not support context: ${request.context}`);
                    continue;
                }
                const response = await provider.requestPoToken(request);
                this.options.logger.info(`Successfully generated PO token using provider: ${providerName}`);
                return response;
            }
            catch (error) {
                if (error instanceof PoTokenProvider_1.PoTokenProviderRejectedRequest) {
                    this.options.logger.debug(`Provider ${providerName} rejected request: ${error.message}`);
                }
                else {
                    this.options.logger.warn(`Provider ${providerName} failed: ${error instanceof Error ? error.message : String(error)}`);
                }
            }
        }
        return null;
    }
    getProviderOrder() {
        const order = [];
        // Add preferred provider first
        if (this.providers.has(this.options.preferredProvider)) {
            order.push(this.options.preferredProvider);
        }
        // Add other providers
        for (const [name] of this.providers) {
            if (name !== this.options.preferredProvider) {
                order.push(name);
            }
        }
        // If fallback is enabled, ensure advanced provider is last
        if (this.options.fallbackToAdvanced && this.providers.has('advanced-webpo')) {
            const advancedIndex = order.indexOf('advanced-webpo');
            if (advancedIndex !== -1) {
                order.splice(advancedIndex, 1);
                order.push('advanced-webpo');
            }
        }
        return order;
    }
    // Utility method to create a PoTokenRequest from YouTube context
    createPoTokenRequest(options) {
        return {
            context: options.context,
            innertubeContext: {
                client: {
                    clientName: options.clientName || 'WEB',
                    clientVersion: options.clientVersion || '2.20231201.01.00',
                    clientScreen: 'WATCH',
                    platform: 'DESKTOP',
                    osName: 'Windows',
                    osVersion: '10.0'
                }
            },
            isAuthenticated: options.isAuthenticated || false,
            videoId: options.videoId,
            visitorData: options.visitorData,
            requestCookies: options.cookies || [],
            requestHeaders: options.headers || {},
            requestProxy: options.proxy,
            requestSourceAddress: options.sourceAddress,
            requestVerifyTls: true,
            bypassCache: false
        };
    }
    // Clear the token cache
    clearCache() {
        this.cache.clear();
        this.options.logger.debug('Cleared PO token cache');
    }
    // Get statistics about the director
    getStats() {
        return {
            providersCount: this.providers.size,
            providers: Array.from(this.providers.keys()),
            cacheEnabled: this.options.enableCache,
            preferredProvider: this.options.preferredProvider
        };
    }
}
exports.PoTokenDirector = PoTokenDirector;
//# sourceMappingURL=PoTokenDirector.js.map