streamify-audio 2.1.7 → 2.1.9

package/index.js

@@ -249,14 +249,4 @@ Streamify.Manager = Manager;
 Streamify.Player = Manager ? require('./src/discord/Player') : null;
 Streamify.Queue = Manager ? require('./src/discord/Queue') : null;
 
-const persistence = require('./src/persistence');
-Streamify.PersistenceAdapter = persistence.PersistenceAdapter;
-Streamify.MemoryAdapter = persistence.MemoryAdapter;
-Streamify.MongoAdapter = persistence.MongoAdapter;
-
-const presets = require('./src/filters/presets');
-Streamify.EffectPresets = presets;
-Streamify.getEffectPresetNames = presets.getPresetNames;
-Streamify.getEffectPresetsInfo = presets.getAllPresetsInfo;
-
 module.exports = Streamify;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "streamify-audio",
-  "version": "2.1.7",
+  "version": "2.1.9",
   "description": "Dual-mode audio library: HTTP streaming proxy + Discord player (Lavalink alternative). Supports YouTube, Spotify, SoundCloud with audio filters.",
   "main": "index.js",
   "types": "index.d.ts",
@@ -29,8 +29,7 @@
   "author": "Lucas",
   "license": "MIT",
   "dependencies": {
-    "express": "^4.18.2",
-    "streamify-audio": "^2.1.4"
+    "express": "^4.18.2"
   },
   "optionalDependencies": {
     "@discordjs/opus": "^0.9.0",

package/src/discord/Manager.js

@@ -5,7 +5,6 @@ const spotify = require('../providers/spotify');
 const soundcloud = require('../providers/soundcloud');
 const log = require('../utils/logger');
 const { loadConfig } = require('../config');
-const { MemoryAdapter, MongoAdapter, serializeTrack, deserializeTrack } = require('../persistence');
 
 function checkDependencies() {
     const missing = [];
@@ -74,182 +73,11 @@ class Manager extends EventEmitter {
             maxTracks: options.autoplay?.maxTracks ?? 5
         };
 
-        this.fallback = {
-            enabled: options.fallback?.enabled ?? false,
-            order: options.fallback?.order || ['youtube', 'soundcloud']
-        };
-
-        this.persistence = null;
-        this._persistenceInterval = null;
-        this._persistenceIntervalMs = options.persistence?.interval || 30000;
-
         this._setupVoiceStateListener();
 
         log.info('MANAGER', 'Streamify Manager initialized');
     }
 
-    async enablePersistence(options = {}) {
-        if (options.adapter) {
-            this.persistence = options.adapter;
-        } else if (options.type === 'mongodb') {
-            this.persistence = new MongoAdapter({
-                client: options.client,
-                uri: options.uri,
-                db: options.db,
-                collection: options.collection
-            });
-        } else {
-            this.persistence = new MemoryAdapter();
-        }
-
-        if (options.autoSave !== false) {
-            this._persistenceInterval = setInterval(() => {
-                this._saveAllSessions();
-            }, this._persistenceIntervalMs);
-        }
-
-        log.info('MANAGER', `Persistence enabled (type: ${options.type || 'memory'})`);
-        return this;
-    }
-
-    async _saveAllSessions() {
-        if (!this.persistence) return;
-
-        for (const [guildId, player] of this.players) {
-            if (player.connected) {
-                await this.saveSession(guildId);
-            }
-        }
-    }
-
-    async saveSession(guildId) {
-        if (!this.persistence) return false;
-
-        const player = this.players.get(guildId);
-        if (!player || !player.connected) return false;
-
-        const current = player.queue.current;
-        if (!current && player.queue.tracks.length === 0) {
-            await this.persistence.delete(guildId);
-            return true;
-        }
-
-        const sessionData = {
-            guildId,
-            voiceChannelId: player.voiceChannelId,
-            textChannelId: player.textChannelId,
-            currentTrack: serializeTrack(current),
-            positionMs: player.position || 0,
-            queue: player.queue.tracks.map(serializeTrack),
-            volume: player.volume,
-            loop: player.queue.repeatMode || 'off',
-            filters: player.filters || {}
-        };
-
-        await this.persistence.save(guildId, sessionData);
-        log.info('PERSISTENCE', `Session saved: ${guildId} (track: ${sessionData.currentTrack?.title || 'none'}, queue: ${sessionData.queue?.length || 0})`);
-        return true;
-    }
-
-    async restoreSession(guildId, options = {}) {
-        if (!this.persistence) return null;
-
-        const session = await this.persistence.load(guildId);
-        if (!session) return null;
-
-        const guild = this.client.guilds.cache.get(guildId);
-        if (!guild) {
-            log.debug('MANAGER', `Guild ${guildId} not found, skipping restore`);
-            return null;
-        }
-
-        const voiceChannel = this.client.channels.cache.get(session.voiceChannelId);
-        if (!voiceChannel) {
-            log.debug('MANAGER', `Voice channel ${session.voiceChannelId} not found, skipping restore`);
-            await this.persistence.delete(guildId);
-            return null;
-        }
-
-        log.info('MANAGER', `Restoring session for guild ${guildId}`);
-
-        const player = await this.create(guildId, session.voiceChannelId, session.textChannelId);
-
-        if (session.volume !== undefined) player.setVolume(session.volume);
-        if (session.loop && session.loop !== 'off') player.setLoop(session.loop);
-
-        if (session.currentTrack) {
-            const track = deserializeTrack(session.currentTrack);
-            log.info('MANAGER', `[RESTORE] Playing track: ${track.title}`);
-            try {
-                await player.play(track);
-            } catch (playErr) {
-                log.error('MANAGER', `[RESTORE] Play error: ${playErr.message}`);
-            }
-            log.info('MANAGER', `[RESTORE] Track play() returned`);
-
-            if (session.positionMs > 0 && !track.isLive && options.seekToPosition !== false) {
-                try {
-                    await player.seek(session.positionMs);
-                } catch (e) {
-                    log.debug('MANAGER', `Could not seek to position: ${e.message}`);
-                }
-            }
-        }
-
-        if (session.queue && session.queue.length > 0) {
-            const tracks = session.queue.map(deserializeTrack);
-            player.queue.addMany(tracks);
-        }
-
-        log.info('MANAGER', `[RESTORE] Checking voice channel members`);
-        let memberCount = 0;
-        try {
-            const members = voiceChannel.members;
-            if (members) {
-                memberCount = members.filter(m => !m.user.bot).size;
-            }
-        } catch (e) {
-            log.info('MANAGER', `[RESTORE] Error getting members: ${e.message}`);
-        }
-
-        if (memberCount === 0 && player.autoPause.enabled) {
-            player.pause();
-            player._autoPaused = true;
-            log.info('MANAGER', `Session restored but auto-paused (empty channel)`);
-        }
-
-        log.info('MANAGER', `[RESTORE] Emitting sessionRestored event`);
-        this.emit('sessionRestored', { guildId, voiceChannelId: player.voiceChannelId });
-        log.info('MANAGER', `[RESTORE] Returning true`);
-        return true;
-    }
-
-    async restoreAllSessions(options = {}) {
-        if (!this.persistence) return [];
-
-        const sessions = await this.persistence.loadAll();
-        const restored = [];
-
-        for (const session of sessions) {
-            try {
-                const success = await this.restoreSession(session.guildId, options);
-                if (success) {
-                    restored.push({ guildId: session.guildId });
-                }
-            } catch (error) {
-                log.error('MANAGER', `Failed to restore session ${session.guildId}: ${error.message}`);
-            }
-        }
-
-        log.info('MANAGER', `Restored ${restored.length}/${sessions.length} sessions`);
-        return restored;
-    }
-
-    async deleteSession(guildId) {
-        if (!this.persistence) return false;
-        return this.persistence.delete(guildId);
-    }
-
     _setupVoiceStateListener() {
         this.client.on('voiceStateUpdate', (oldState, newState) => {
             const player = this.players.get(oldState.guild.id) || this.players.get(newState.guild.id);
@@ -646,84 +474,7 @@ class Manager extends EventEmitter {
         }
     }
 
-    async searchWithFallback(query, options = {}) {
-        if (!this.fallback.enabled) {
-            return this.search(query, options);
-        }
-
-        const sources = options.sources || this.fallback.order;
-        let lastError = null;
-
-        for (const source of sources) {
-            try {
-                const result = await this.search(query, { ...options, source });
-                if (result.loadType !== 'error' && result.tracks.length > 0) {
-                    return result;
-                }
-            } catch (error) {
-                lastError = error;
-                log.debug('MANAGER', `Fallback: ${source} failed, trying next...`);
-            }
-        }
-
-        return {
-            loadType: 'error',
-            tracks: [],
-            error: lastError?.message || 'All sources failed'
-        };
-    }
-
-    async resolveWithFallback(query) {
-        if (!this.fallback.enabled) {
-            return this.resolve(query);
-        }
-
-        const result = await this.resolve(query);
-        if (result.loadType !== 'error' && result.tracks.length > 0) {
-            return result;
-        }
-
-        const detected = this._detectSource(query);
-        if (detected === 'spotify') {
-            const match = this._extractId(query, detected);
-            if (match) {
-                try {
-                    const track = await this.getInfo(match.id, 'spotify');
-                    const searchQuery = `${track.author} - ${track.title}`;
-
-                    for (const source of this.fallback.order) {
-                        if (source === 'spotify') continue;
-                        try {
-                            const fallbackResult = await this.search(searchQuery, { source, limit: 1 });
-                            if (fallbackResult.tracks.length > 0) {
-                                const fallbackTrack = fallbackResult.tracks[0];
-                                fallbackTrack._originalSpotifyTrack = track;
-                                log.info('MANAGER', `Spotify fallback: resolved via ${source}`);
-                                return {
-                                    loadType: 'track',
-                                    tracks: [fallbackTrack],
-                                    fallbackUsed: source
-                                };
-                            }
-                        } catch (e) {
-                            continue;
-                        }
-                    }
-                } catch (e) {
-                    log.debug('MANAGER', `Spotify info fetch failed: ${e.message}`);
-                }
-            }
-        }
-
-        return result;
-    }
-
     destroyAll() {
-        if (this._persistenceInterval) {
-            clearInterval(this._persistenceInterval);
-            this._persistenceInterval = null;
-        }
-
         for (const [guildId, player] of this.players) {
             player.destroy();
         }

package/src/discord/Player.js

@@ -2,7 +2,6 @@ const { EventEmitter } = require('events');
 const Queue = require('./Queue');
 const { createStream } = require('./Stream');
 const log = require('../utils/logger');
-const { buildPresetFilters, getPresetNames, getAllPresetsInfo } = require('../filters/presets');
 
 let voiceModule;
 try {
@@ -588,70 +587,6 @@ class Player extends EventEmitter {
         return this.setFilter('preset', presetName);
     }
 
-    async setEffectPreset(presetName, intensity = 0.5) {
-        const filters = buildPresetFilters(presetName, intensity);
-
-        for (const [key, value] of Object.entries(filters)) {
-            if (key === '_intensityFactor') continue;
-            this._filters[key] = value;
-        }
-
-        this._activePresets = this._activePresets || new Map();
-        this._activePresets.set(presetName, intensity);
-
-        if (this._playing && this.queue.current) {
-            return this.setFilter('_trigger', null);
-        }
-        return true;
-    }
-
-    async setEffectPresets(presets) {
-        this._activePresets = new Map();
-
-        for (const { name, intensity = 0.5 } of presets) {
-            const filters = buildPresetFilters(name, intensity);
-            for (const [key, value] of Object.entries(filters)) {
-                if (key === '_intensityFactor') continue;
-                this._filters[key] = value;
-            }
-            this._activePresets.set(name, intensity);
-        }
-
-        if (this._playing && this.queue.current) {
-            return this.setFilter('_trigger', null);
-        }
-        return true;
-    }
-
-    async clearEffectPresets() {
-        const presetsToRemove = ['bass', 'treble', 'speed', 'pitch', 'rotation', 'karaoke',
-            'lowpass', 'highpass', 'bandpass', 'vibrato', 'tremolo', 'chorus',
-            'compressor', 'normalizer', 'nightcore', 'vaporwave', 'bassboost', '8d'];
-
-        for (const key of presetsToRemove) {
-            delete this._filters[key];
-        }
-
-        this._activePresets = new Map();
-
-        if (this._playing && this.queue.current) {
-            return this.setFilter('_trigger', null);
-        }
-        return true;
-    }
-
-    getActiveEffectPresets() {
-        return this._activePresets ? Array.from(this._activePresets.entries()).map(([name, intensity]) => ({ name, intensity })) : [];
-    }
-
-    getAvailableEffectPresets() {
-        return getAllPresetsInfo();
-    }
-
-    static getEffectPresetNames() {
-        return getPresetNames();
-    }
-
     async clearEQ() {
         delete this._filters.equalizer;
         delete this._filters.preset;

package/src/filters/presets.js

@@ -1,227 +0,0 @@
-const EFFECT_PRESETS = {
-    bassboost: {
-        description: 'Boost bass frequencies',
-        build: (intensity = 0.5) => {
-            const gain = 5 + (intensity * 15);
-            return { bass: gain };
-        }
-    },
-
-    nightcore: {
-        description: 'Speed up with higher pitch (anime style)',
-        build: (intensity = 0.5) => {
-            const speedBoost = 0.15 + (intensity * 0.2);
-            return {
-                speed: 1 + speedBoost,
-                pitch: 1 + speedBoost
-            };
-        }
-    },
-
-    vaporwave: {
-        description: 'Slow down with lower pitch (aesthetic)',
-        build: (intensity = 0.5) => {
-            const slowdown = 0.1 + (intensity * 0.2);
-            return {
-                speed: 1 - slowdown,
-                pitch: 1 - slowdown
-            };
-        }
-    },
-
-    '8d': {
-        description: 'Rotating 8D audio effect',
-        build: (intensity = 0.5) => {
-            const speed = 0.05 + (intensity * 0.2);
-            return { rotation: { speed } };
-        }
-    },
-
-    karaoke: {
-        description: 'Reduce vocals (center channel removal)',
-        build: () => ({ karaoke: true })
-    },
-
-    trebleboost: {
-        description: 'Boost high frequencies',
-        build: (intensity = 0.5) => {
-            const gain = 5 + (intensity * 15);
-            return { treble: gain };
-        }
-    },
-
-    deep: {
-        description: 'Deep bass with reduced highs',
-        build: (intensity = 0.5) => {
-            const bassGain = 8 + (intensity * 12);
-            const trebleCut = -3 - (intensity * 7);
-            return { bass: bassGain, treble: trebleCut };
-        }
-    },
-
-    pop: {
-        description: 'Enhanced clarity for pop music',
-        build: (intensity = 0.5) => {
-            const factor = 0.5 + (intensity * 0.5);
-            return {
-                preset: 'pop',
-                _intensityFactor: factor
-            };
-        }
-    },
-
-    rock: {
-        description: 'Punchy mids and lows for rock',
-        build: (intensity = 0.5) => {
-            const factor = 0.5 + (intensity * 0.5);
-            return {
-                preset: 'rock',
-                _intensityFactor: factor
-            };
-        }
-    },
-
-    electronic: {
-        description: 'Enhanced bass and highs for EDM',
-        build: (intensity = 0.5) => {
-            const factor = 0.5 + (intensity * 0.5);
-            return {
-                preset: 'electronic',
-                _intensityFactor: factor
-            };
-        }
-    },
-
-    lofi: {
-        description: 'Lo-fi aesthetic with warmth',
-        build: (intensity = 0.5) => ({
-            lowpass: 8000 - (intensity * 4000),
-            bass: 3 + (intensity * 5)
-        })
-    },
-
-    radio: {
-        description: 'AM radio effect',
-        build: (intensity = 0.5) => ({
-            lowpass: 5000 - (intensity * 2000),
-            highpass: 300 + (intensity * 200)
-        })
-    },
-
-    telephone: {
-        description: 'Telephone/walkie-talkie effect',
-        build: () => ({
-            bandpass: { frequency: 1500, width: 1000 }
-        })
-    },
-
-    soft: {
-        description: 'Soft, gentle sound',
-        build: (intensity = 0.5) => ({
-            lowpass: 12000 - (intensity * 4000),
-            compressor: true
-        })
-    },
-
-    loud: {
-        description: 'Louder, more compressed',
-        build: (intensity = 0.5) => ({
-            preset: 'loudness',
-            compressor: true,
-            normalizer: true
-        })
-    },
-
-    chipmunk: {
-        description: 'High-pitched chipmunk voice',
-        build: (intensity = 0.5) => ({
-            pitch: 1.3 + (intensity * 0.5),
-            speed: 1.2 + (intensity * 0.3)
-        })
-    },
-
-    darth: {
-        description: 'Deep Darth Vader-like voice',
-        build: (intensity = 0.5) => ({
-            pitch: 0.7 - (intensity * 0.2),
-            speed: 0.9 - (intensity * 0.1)
-        })
-    },
-
-    echo: {
-        description: 'Echo/reverb effect',
-        build: () => ({
-            chorus: true
-        })
-    },
-
-    vibrato: {
-        description: 'Vibrating pitch effect',
-        build: (intensity = 0.5) => ({
-            vibrato: {
-                frequency: 4 + (intensity * 6),
-                depth: 0.3 + (intensity * 0.4)
-            }
-        })
-    },
-
-    tremolo: {
-        description: 'Trembling volume effect',
-        build: (intensity = 0.5) => ({
-            tremolo: {
-                frequency: 4 + (intensity * 8),
-                depth: 0.4 + (intensity * 0.4)
-            }
-        })
-    }
-};
-
-function getPresetNames() {
-    return Object.keys(EFFECT_PRESETS);
-}
-
-function getPresetInfo(name) {
-    const preset = EFFECT_PRESETS[name];
-    if (!preset) return null;
-    return {
-        name,
-        description: preset.description
-    };
-}
-
-function getAllPresetsInfo() {
-    return Object.entries(EFFECT_PRESETS).map(([name, preset]) => ({
-        name,
-        description: preset.description
-    }));
-}
-
-function buildPresetFilters(name, intensity = 0.5) {
-    const preset = EFFECT_PRESETS[name];
-    if (!preset) {
-        throw new Error(`Unknown preset: ${name}. Available: ${getPresetNames().join(', ')}`);
-    }
-
-    const clampedIntensity = Math.max(0, Math.min(1, intensity));
-    return preset.build(clampedIntensity);
-}
-
-function combinePresets(presetNames, intensity = 0.5) {
-    const combined = {};
-
-    for (const name of presetNames) {
-        const filters = buildPresetFilters(name, intensity);
-        Object.assign(combined, filters);
-    }
-
-    return combined;
-}
-
-module.exports = {
-    EFFECT_PRESETS,
-    getPresetNames,
-    getPresetInfo,
-    getAllPresetsInfo,
-    buildPresetFilters,
-    combinePresets
-};

package/src/persistence/index.js

@@ -1,166 +0,0 @@
-const log = require('../utils/logger');
-
-class PersistenceAdapter {
-    async save(guildId, sessionData) {
-        throw new Error('save() must be implemented by adapter');
-    }
-
-    async load(guildId) {
-        throw new Error('load() must be implemented by adapter');
-    }
-
-    async delete(guildId) {
-        throw new Error('delete() must be implemented by adapter');
-    }
-
-    async loadAll() {
-        throw new Error('loadAll() must be implemented by adapter');
-    }
-}
-
-class MemoryAdapter extends PersistenceAdapter {
-    constructor() {
-        super();
-        this.sessions = new Map();
-    }
-
-    async save(guildId, sessionData) {
-        this.sessions.set(guildId, {
-            ...sessionData,
-            updatedAt: Date.now()
-        });
-        return true;
-    }
-
-    async load(guildId) {
-        return this.sessions.get(guildId) || null;
-    }
-
-    async delete(guildId) {
-        return this.sessions.delete(guildId);
-    }
-
-    async loadAll() {
-        return Array.from(this.sessions.entries()).map(([guildId, data]) => ({
-            guildId,
-            ...data
-        }));
-    }
-}
-
-class MongoAdapter extends PersistenceAdapter {
-    constructor(options = {}) {
-        super();
-        this.collection = null;
-        this.collectionName = options.collection || 'streamify_sessions';
-        this.mongoClient = options.client || null;
-        this.mongoUri = options.uri || null;
-        this.db = options.db || null;
-    }
-
-    async connect() {
-        if (this.collection) return;
-
-        if (this.mongoClient) {
-            const dbName = this.db || 'streamify';
-            this.collection = this.mongoClient.db(dbName).collection(this.collectionName);
-        } else if (this.mongoUri) {
-            const { MongoClient } = require('mongodb');
-            const client = new MongoClient(this.mongoUri);
-            await client.connect();
-            const dbName = this.db || 'streamify';
-            this.collection = client.db(dbName).collection(this.collectionName);
-        } else {
-            throw new Error('MongoAdapter requires either client or uri option');
-        }
-
-        log.info('PERSISTENCE', `Connected to MongoDB collection: ${this.collectionName}`);
-    }
-
-    async save(guildId, sessionData) {
-        await this.connect();
-        await this.collection.updateOne(
-            { _id: guildId },
-            { $set: { ...sessionData, updatedAt: new Date() } },
-            { upsert: true }
-        );
-        return true;
-    }
-
-    async load(guildId) {
-        await this.connect();
-        const doc = await this.collection.findOne({ _id: guildId });
-        return doc || null;
-    }
-
-    async delete(guildId) {
-        await this.connect();
-        const result = await this.collection.deleteOne({ _id: guildId });
-        return result.deletedCount > 0;
-    }
-
-    async loadAll() {
-        await this.connect();
-        const docs = await this.collection.find({}).toArray();
-        return docs.map(doc => ({
-            guildId: doc._id,
-            ...doc
-        }));
-    }
-}
-
-function serializeTrack(track) {
-    if (!track) return null;
-
-    let requestedBy = null;
-    if (track.requestedBy) {
-        if (typeof track.requestedBy === 'string') {
-            requestedBy = { username: track.requestedBy };
-        } else if (typeof track.requestedBy === 'object') {
-            requestedBy = {
-                id: track.requestedBy.id || null,
-                username: track.requestedBy.username || track.requestedBy.tag || String(track.requestedBy),
-                avatarUrl: track.requestedBy.avatarUrl || null
-            };
-        }
-    }
-
-    return {
-        id: track.id,
-        title: track.title,
-        author: track.author,
-        duration: track.duration,
-        thumbnail: track.thumbnail,
-        uri: track.uri,
-        source: track.source,
-        isLive: track.isLive || false,
-        _resolvedId: track._resolvedId,
-        requestedBy,
-        artistUrl: track.artistUrl || null
-    };
-}
-
-function deserializeTrack(data) {
-    if (!data) return null;
-    return {
-        id: data.id,
-        title: data.title,
-        author: data.author,
-        duration: data.duration,
-        thumbnail: data.thumbnail,
-        uri: data.uri,
-        source: data.source,
-        isLive: data.isLive || false,
-        _resolvedId: data._resolvedId,
-        requestedBy: data.requestedBy,
-        artistUrl: data.artistUrl
-    };
-}
-
-module.exports = {
-    PersistenceAdapter,
-    MemoryAdapter,
-    MongoAdapter,
-    serializeTrack,
-    deserializeTrack
-};