aqualink 2.7.3 → 2.8.0

package/build/handlers/fetchImage.js

@@ -1,50 +1,148 @@
 const https = require('https');
-const sourceHandlers = new Map([
-    ['spotify', uri => fetchThumbnail(`https://open.spotify.com/oembed?url=${uri}`)],
-    ['youtube', identifier => fetchYouTubeThumbnail(identifier)]
-]);
-const YOUTUBE_URL_TEMPLATE = (quality) => (id) => `https://img.youtube.com/vi/${id}/${quality}.jpg`;
-const YOUTUBE_QUALITIES = ['maxresdefault', 'hqdefault', 'mqdefault', 'default'].map(YOUTUBE_URL_TEMPLATE);
+
+const sourceHandlers = {
+    spotify: fetchSpotifyThumbnail,
+    youtube: fetchYouTubeThumbnail
+};
+
+const YOUTUBE_QUALITIES = ['maxresdefault', 'hqdefault', 'mqdefault', 'default'];
+
+const YOUTUBE_ID_REGEX = /^[a-zA-Z0-9_-]{11}$/;
+const SPOTIFY_URI_REGEX = /^https:\/\/open\.spotify\.com\/(track|album|playlist)\/[a-zA-Z0-9]+/;
 
 async function getImageUrl(info) {
     if (!info?.sourceName || !info?.uri) return null;
-    const handler = sourceHandlers.get(info.sourceName.toLowerCase());
+    
+    const sourceName = info.sourceName.toLowerCase();
+    const handler = sourceHandlers[sourceName];
+    
     if (!handler) return null;
+    
     try {
-        return await handler(info.uri);
+        const param = sourceName === 'spotify' ? info.uri : 
+                     sourceName === 'youtube' ? extractYouTubeId(info.uri) : info.uri;
+        
+        if (!param) return null;
+        
+        return await handler(param);
     } catch (error) {
-        console.error('Error fetching image URL:', error);
+        console.error(`Error fetching ${sourceName} thumbnail:`, error.message);
         return null;
     }
 }
 
-function fetchThumbnail(url) {
+function extractYouTubeId(uri) {
+    if (!uri) return null;
+    
+    let id = null;
+    
+    if (uri.includes('youtube.com/watch?v=')) {
+        id = uri.split('v=')[1]?.split('&')[0];
+    } else if (uri.includes('youtu.be/')) {
+        id = uri.split('youtu.be/')[1]?.split('?')[0];
+    } else if (uri.includes('youtube.com/embed/')) {
+        id = uri.split('embed/')[1]?.split('?')[0];
+    } else if (YOUTUBE_ID_REGEX.test(uri)) {
+        id = uri;
+    }
+    
+    return id && YOUTUBE_ID_REGEX.test(id) ? id : null;
+}
+
+async function fetchSpotifyThumbnail(uri) {
+    if (!SPOTIFY_URI_REGEX.test(uri)) {
+        throw new Error('Invalid Spotify URI format');
+    }
+    
+    const url = `https://open.spotify.com/oembed?url=${encodeURIComponent(uri)}`;
+    
+    try {
+        const data = await fetchJson(url);
+        return data?.thumbnail_url || null;
+    } catch (error) {
+        throw new Error(`Spotify fetch failed: ${error.message}`);
+    }
+}
+
+async function fetchYouTubeThumbnail(identifier) {
+    if (!identifier || !YOUTUBE_ID_REGEX.test(identifier)) {
+        throw new Error('Invalid YouTube identifier');
+    }
+    
+    for (const quality of YOUTUBE_QUALITIES) {
+        const url = `https://img.youtube.com/vi/${identifier}/${quality}.jpg`;
+        
+        try {
+            const exists = await checkImageExists(url);
+            if (exists) return url;
+        } catch (error) {
+            continue;
+        }
+    }
+    
+    return null;
+}
+
+function fetchJson(url) {
     return new Promise((resolve, reject) => {
-        https.get(url, (res) => {
+        const request = https.get(url, (res) => {
             if (res.statusCode !== 200) {
                 res.resume();
-                return reject(`Failed to fetch: ${res.statusCode}`);
+                return reject(new Error(`HTTP ${res.statusCode}`));
             }
-            let data = '';
-            res.on('data', chunk => data += chunk);
+            
+            const chunks = [];
+            let totalLength = 0;
+            
+            res.on('data', chunk => {
+                chunks.push(chunk);
+                totalLength += chunk.length;
+                
+                if (totalLength > 1024 * 1024) {
+                    res.destroy();
+                    reject(new Error('Response too large'));
+                }
+            });
+            
             res.on('end', () => {
                 try {
+                    const data = Buffer.concat(chunks, totalLength).toString('utf8');
                     const json = JSON.parse(data);
-                    resolve(json.thumbnail_url || null);
+                    resolve(json);
                 } catch (error) {
-                    reject(`JSON parse error: ${error.message}`);
+                    reject(new Error(`JSON parse error: ${error.message}`));
                 }
             });
-        }).on('error', (error) => {
-            reject(`Request error: ${error.message}`);
+        });
+        
+        request.setTimeout(5000, () => {
+            request.destroy();
+            reject(new Error('Request timeout'));
+        });
+        
+        request.on('error', (error) => {
+            reject(new Error(`Request error: ${error.message}`));
         });
     });
 }
 
-async function fetchYouTubeThumbnail(identifier) {
-    const promises = YOUTUBE_QUALITIES.map(urlFunc => fetchThumbnail(urlFunc(identifier)));
-    const firstResult = await Promise.race(promises);
-    return firstResult || null;
+function checkImageExists(url) {
+    return new Promise((resolve) => {
+        const request = https.request(url, { method: 'HEAD' }, (res) => {
+            resolve(res.statusCode === 200);
+        });
+        
+        request.setTimeout(3000, () => {
+            request.destroy();
+            resolve(false);
+        });
+        
+        request.on('error', () => resolve(false));
+        request.end();
+    });
 }
 
-module.exports = { getImageUrl };
+
+module.exports = { 
+    getImageUrl,
+};

package/build/index.d.ts

@@ -19,6 +19,7 @@ declare module "aqualink" {
         autoResume: boolean;
         infiniteReconnects: boolean;
         options: AquaOptions;
+        failoverOptions: FailoverOptions;
         _leastUsedCache: { nodes: Node[], timestamp: number };
 
         defaultSendFunction(payload: any): void;
@@ -39,8 +40,13 @@ declare module "aqualink" {
         handleNoMatches(rest: Rest, query: string): Promise<any>;
         constructResponse(response: any, requester: any, requestNode: Node): ResolveResponse;
         get(guildId: string): Player;
-        search(query: string, requester: any, source?: string): Promise<Track[] | null>;
+        search(query: string, requester: any, source?: SearchSource): Promise<Track[] | null>;
+        searchSuggestions(query: string, source?: SearchSource): Promise<SearchSuggestion[]>;
+        autocomplete(query: string, source?: SearchSource): Promise<AutocompleteResult>;
         cleanupPlayer(player: Player): Promise<void>;
+        handleFailover(player: Player, error: Error): Promise<boolean>;
+        getHealthyNodes(): Node[];
+        isNodeHealthy(node: Node): boolean;
     }
 
     export class Node {
@@ -66,11 +72,17 @@ declare module "aqualink" {
         reconnectAttempted: number;
         reconnectTimeoutId: NodeJS.Timeout | null;
         stats: NodeStats;
+        lastFailure: number;
+        health: NodeHealth;
 
         initializeStats(): void;
         connect(): Promise<void>;
         destroy(clean?: boolean): void;
         getStats(): Promise<NodeStats>;
+        isHealthy(): boolean;
+        markFailure(): void;
+        markSuccess(): void;
+        getHealth(): NodeHealth;
     }
 
     export class Player extends EventEmitter {
@@ -83,7 +95,7 @@ declare module "aqualink" {
         connection: Connection;
         filters: Filters;
         volume: number;
-        loop: string;
+        loop: LoopMode;
         queue: Queue;
         previousTracks: Track[];
         previousTracksIndex: number;
@@ -100,6 +112,8 @@ declare module "aqualink" {
         nowPlayingMessage: any;
         isAutoplayEnabled: boolean;
         isAutoplay: boolean;
+        failoverAttempts: number;
+        lastFailoverTime: number;
 
         play(): Promise<void>;
         connect(options: ConnectionOptions): Player;
@@ -108,7 +122,7 @@ declare module "aqualink" {
         seek(position: number): Player;
         stop(): Player;
         setVolume(volume: number): Player;
-        setLoop(mode: string): Player;
+        setLoop(mode: LoopMode): Player;
         setTextChannel(channel: string): Player;
         setVoiceChannel(channel: string): Player;
         disconnect(): Player;
@@ -119,6 +133,8 @@ declare module "aqualink" {
         searchLyrics(query: string): Promise<any>;
         lyrics(): Promise<any>;
         updatePlayer(data: any): Promise<void>;
+        switchNode(newNode: Node, preserveState?: boolean): Promise<boolean>;
+        canFailover(): boolean;
     }
 
     export class Track {
@@ -157,6 +173,8 @@ declare module "aqualink" {
         getRoutePlannerStatus(): Promise<any>;
         getRoutePlannerAddress(address: string): Promise<any>;
         getLyrics(options: { track: Track }): Promise<any>;
+        getSearchSuggestions(query: string, source?: SearchSource): Promise<SearchSuggestion[]>;
+        getAutocompleteSuggestions(query: string, source?: SearchSource): Promise<AutocompleteResult>;
     }
 
     export class Queue extends Array<any> {
@@ -240,15 +258,30 @@ declare module "aqualink" {
         setStateUpdate(data: any): void;
     }
 
+    // Enhanced interfaces with autocomplete and failover support
     interface AquaOptions {
         shouldDeleteMessage?: boolean;
-        defaultSearchPlatform?: string;
+        defaultSearchPlatform?: SearchSource;
         leaveOnEnd?: boolean;
-        restVersion?: string;
+        restVersion?: RestVersion;
         plugins?: Plugin[];
         send?: (payload: any) => void;
         autoResume?: boolean;
         infiniteReconnects?: boolean;
+        failoverOptions?: FailoverOptions;
+    }
+
+    interface FailoverOptions {
+        enabled?: boolean;
+        maxRetries?: number;
+        retryDelay?: number;
+        preservePosition?: boolean;
+        resumePlayback?: boolean;
+        cooldownTime?: number;
+        maxFailoverAttempts?: number;
+        healthCheckInterval?: number;
+        unhealthyThreshold?: number;
+        recoveryCooldown?: number;
     }
 
     interface NodeOptions {
@@ -259,6 +292,9 @@ declare module "aqualink" {
         secure?: boolean;
         sessionId?: string;
         regions?: string[];
+        priority?: number;
+        retryAmount?: number;
+        retryDelay?: number;
     }
 
     interface NodeAdditionalOptions {
@@ -274,9 +310,11 @@ declare module "aqualink" {
         textChannel: string;
         voiceChannel: string;
         defaultVolume?: number;
-        loop?: string;
+        loop?: LoopMode;
         shouldDeleteMessage?: boolean;
         leaveOnEnd?: boolean;
+        autoplay?: boolean;
+        enableFailover?: boolean;
     }
 
     interface ConnectionOptions {
@@ -288,15 +326,15 @@ declare module "aqualink" {
 
     interface ResolveOptions {
         query: string;
-        source?: string;
+        source?: SearchSource;
         requester: any;
         nodes?: string | Node;
     }
 
     interface ResolveResponse {
-        loadType: string;
-        exception: any | null;
-        playlistInfo: any | null;
+        loadType: LoadType;
+        exception: LavalinkException | null;
+        playlistInfo: PlaylistInfo | null;
         pluginInfo: any;
         tracks: Track[];
     }
@@ -346,6 +384,7 @@ declare module "aqualink" {
         uri: string;
         sourceName: string;
         artworkUrl: string;
+        position?: number;
     }
 
     interface FilterOptions {
@@ -365,4 +404,124 @@ declare module "aqualink" {
         vaporwave?: any;
         _8d?: any;
     }
+
+    interface SearchSuggestion {
+        text: string;
+        highlighted: string;
+        type: SuggestionType;
+        source: SearchSource;
+    }
+
+    interface AutocompleteResult {
+        query: string;
+        suggestions: SearchSuggestion[];
+        hasMore: boolean;
+        timestamp: number;
+    }
+
+    interface PlaylistInfo {
+        name: string;
+        selectedTrack: number;
+    }
+
+    interface LavalinkException {
+        message: string;
+        severity: ExceptionSeverity;
+        cause: string;
+    }
+
+    interface NodeHealth {
+        healthy: boolean;
+        consecutiveFailures: number;
+        lastCheck: number;
+        responseTime: number;
+        uptime: number;
+    }
+
+    type SearchSource = 
+        | 'ytsearch'
+        | 'ytmsearch' 
+        | 'scsearch'
+        | 'spsearch'
+        | 'amsearch'
+        | 'dzsearch'
+        | 'yandexsearch'
+        | 'soundcloud'
+        | 'youtube'
+        | 'spotify'
+        | 'applemusic'
+        | 'deezer'
+        | 'bandcamp'
+        | 'vimeo'
+        | 'twitch'
+        | 'http';
+
+    type LoopMode = 'none' | 'track' | 'queue';
+
+    type LoadType = 
+        | 'track'
+        | 'playlist' 
+        | 'search'
+        | 'empty'
+        | 'error';
+
+    type RestVersion = 'v3' | 'v4';
+
+    type SuggestionType = 
+        | 'track'
+        | 'artist'
+        | 'album'
+        | 'playlist'
+        | 'query';
+
+    type ExceptionSeverity = 
+        | 'common'
+        | 'suspicious'
+        | 'fault';
+
+    interface AquaEvents {
+        'nodeConnect': (node: Node) => void;
+        'nodeDisconnect': (node: Node, code: number, reason: string) => void;
+        'nodeError': (node: Node, error: Error) => void;
+        'nodeReconnect': (node: Node) => void;
+        'playerCreate': (player: Player) => void;
+        'playerDestroy': (player: Player) => void;
+        'trackStart': (player: Player, track: Track) => void;
+        'trackEnd': (player: Player, track: Track) => void;
+        'trackError': (player: Player, track: Track, error: Error) => void;
+        'trackStuck': (player: Player, track: Track, thresholdMs: number) => void;
+        'queueEnd': (player: Player) => void;
+        'playerMove': (player: Player, oldChannel: string, newChannel: string) => void;
+        'playerDisconnect': (player: Player, oldChannel: string) => void;
+        'failover': (player: Player, oldNode: Node, newNode: Node) => void;
+        'failoverFailed': (player: Player, error: Error) => void;
+    }
+
+    interface PlayerEvents {
+        'trackStart': (track: Track) => void;
+        'trackEnd': (track: Track) => void;
+        'trackError': (track: Track, error: Error) => void;
+        'trackStuck': (track: Track, thresholdMs: number) => void;
+        'playerUpdate': (state: any) => void;
+        'queueEnd': () => void;
+        'socketClosed': (code: number, reason: string, byRemote: boolean) => void;
+        'failover': (oldNode: Node, newNode: Node) => void;
+        'failoverFailed': (error: Error) => void;
+    }
+
+    export const DEFAULT_OPTIONS: Required<AquaOptions>;
+}
+
+declare module "aqualink" {
+    interface Aqua {
+        on<K extends keyof AquaEvents>(event: K, listener: AquaEvents[K]): this;
+        once<K extends keyof AquaEvents>(event: K, listener: AquaEvents[K]): this;
+        emit<K extends keyof AquaEvents>(event: K, ...args: Parameters<AquaEvents[K]>): boolean;
+    }
+
+    interface Player {
+        on<K extends keyof PlayerEvents>(event: K, listener: PlayerEvents[K]): this;
+        once<K extends keyof PlayerEvents>(event: K, listener: PlayerEvents[K]): this;
+        emit<K extends keyof PlayerEvents>(event: K, ...args: Parameters<PlayerEvents[K]>): boolean;
+    }
 }