ziplayer 0.2.7-dev.1 → 0.2.7-dev.2

package/src/structures/Player.ts

@@ -94,6 +94,7 @@ export class Player extends EventEmitter {
 	public pluginManager: PluginManager;
 	public extensionManager: ExtensionManager;
 	public userdata?: Record<string, any>;
+	public _lastActivity: number = Date.now();
 	private manager: PlayerManager;
 	private leaveTimeout: NodeJS.Timeout | null = null;
 	private currentResource: AudioResource | null = null;
@@ -1495,6 +1496,11 @@ export class Player extends EventEmitter {
 	 */
 	destroy(): void {
 		this.debug(`[Player] destroy called`);
+
+		if (this.manager.getPersistence()) {
+			this.manager.getPersistence()?.markPlayerDestroyed(this.guildId, "player_destroy_called");
+		}
+
 		if (this.leaveTimeout) {
 			clearTimeout(this.leaveTimeout);
 			this.leaveTimeout = null;

package/src/structures/PlayerManager.ts

@@ -9,6 +9,7 @@ import {
 	ManagerEvents,
 	PlayerStats,
 	PersistenceOptions,
+	DestroyedRecord,
 } from "../types";
 import type { BaseExtension } from "../extensions";
 import { withTimeout } from "../utils/timeout";
@@ -367,36 +368,51 @@ export class PlayerManager extends EventEmitter {
 	}
 
 	private setupEventForwarding(player: Player, guildId: string): void {
-		player.on("willPlay", (track, tracks) => this.emit("willPlay", player, track as Track, tracks as Track[]));
-		player.on("trackStart", (track) => {
-			(player as any)._lastActivity = Date.now();
-			this.emit("trackStart", player, track as Track);
-		});
-		player.on("trackEnd", (track) => this.emit("trackEnd", player, track as Track));
-		player.on("queueEnd", () => this.emit("queueEnd", player));
-		player.on("playerError", (error, track) => this.emit("playerError", player, error, track as Track));
-		player.on("connectionError", (error) => this.emit("connectionError", player, error));
-		player.on("volumeChange", (oldVol, newVol) => this.emit("volumeChange", player, oldVol as number, newVol as number));
-		player.on("queueAdd", (track) => this.emit("queueAdd", player, track as Track));
-		player.on("queueAddList", (tracks) => this.emit("queueAddList", player, tracks as Track[]));
-		player.on("queueRemove", (track, index) => this.emit("queueRemove", player, track as Track, index as number));
-		player.on("playerPause", (track) => this.emit("playerPause", player, track as Track));
-		player.on("playerResume", (track) => this.emit("playerResume", player, track as Track));
-		player.on("playerStop", () => this.emit("playerStop", player));
+		const forwardEvents = {
+			willPlay: "willPlay",
+			trackStart: "trackStart",
+			trackEnd: "trackEnd",
+			queueEnd: "queueEnd",
+			playerError: "playerError",
+			connectionError: "connectionError",
+			volumeChange: "volumeChange",
+			queueAdd: "queueAdd",
+			queueAddList: "queueAddList",
+			queueRemove: "queueRemove",
+			playerPause: "playerPause",
+			playerResume: "playerResume",
+			playerStop: "playerStop",
+			ttsStart: "ttsStart",
+			ttsEnd: "ttsEnd",
+		} as const satisfies Record<string, keyof ManagerEvents>;
+
+		for (const [sourceEvent, targetEvent] of Object.entries(forwardEvents) as [
+			keyof typeof forwardEvents,
+			keyof ManagerEvents,
+		][]) {
+			player.on(sourceEvent, (...args: any[]) => {
+				if (sourceEvent === "trackStart") {
+					player._lastActivity = Date.now();
+				}
+
+				(this.emit as any)(targetEvent, player, ...args);
+			});
+		}
+
 		player.on("playerDestroy", () => {
 			this.emit("playerDestroy", player);
+
 			this.players.delete(guildId);
+
 			this.debug(`Player destroyed for guildId: ${guildId}`);
 		});
-		player.on("ttsStart", (payload) => this.emit("ttsStart", player, payload));
-		player.on("ttsEnd", () => this.emit("ttsEnd", player));
+
 		player.on("debug", (...args) => {
 			if (this.listenerCount("debug") > 0) {
 				this.emit("debug", ...args);
 			}
 		});
 	}
-
 	/**
 	 * Get an existing player for a guild
 	 *
@@ -715,26 +731,44 @@ export class PlayerManager extends EventEmitter {
 	private initPersistence(persistenceOptions: PersistenceOptions): void {
 		this.persistenceManager = new PersistenceManager(this, persistenceOptions);
 
-		// Forward persistence events
-		this.persistenceManager.on("playerSaved", (guildId) => {
-			this.emit("playerSaved", guildId);
-		});
+		const forwardEvents = {
+			playerSaved: "playerSaved",
+			playerLoaded: "playerLoaded",
 
-		this.persistenceManager.on("playerLoaded", (guildId, data) => {
-			this.emit("playerLoaded", guildId, data);
-		});
+			playerSkipped: "RTSkipped",
+			playerMarkedDestroyed: "RTMarkedDestroyed",
+			playerDestroyedCleared: "RTDestroyedCleared",
 
-		this.persistenceManager.on("savedAll", (results) => {
-			this.emit("savedAll", results);
-		});
+			savedAll: "savedAll",
+			loadedAll: "loadedAll",
 
-		this.persistenceManager.on("loadedAll", (results) => {
-			this.emit("loadedAll", results);
-		});
+			backupsCleaned: "backupsCleaned",
+			allBackupsCleaned: "allBackupsCleaned",
+
+			backupStats: "backupStats",
+			backupCleanupDone: "backupCleanupDone",
+		} as const satisfies Record<string, keyof ManagerEvents>;
+
+		for (const [sourceEvent, targetEvent] of Object.entries(forwardEvents) as [
+			keyof typeof forwardEvents,
+			keyof ManagerEvents,
+		][]) {
+			this.persistenceManager.on(sourceEvent, (...args: any[]) => {
+				this.emit(targetEvent, ...(args as ManagerEvents[typeof targetEvent]));
+			});
+		}
 
 		this.debug("Persistence manager initialized");
 	}
 
+	isAutoRestoreEnabled(): boolean {
+		return this.persistenceManager?.isAutoRestoreEnabled() ?? false;
+	}
+
+	getDestroyedPlayers(): DestroyedRecord[] {
+		return this.persistenceManager?.getDestroyedPlayers() ?? [];
+	}
+
 	/**
 	 * Get persistence manager
 	 */

package/src/types/index.ts

@@ -363,11 +363,20 @@ export interface ManagerEvents {
 	lyricsCreate: [player: Player, track: Track, lyrics: any];
 	lyricsChange: [player: Player, track: Track, lyrics: any];
 	voiceCreate: [player: Player, evt: any];
+	
+	// Persistence events
 	stats: [stats: PlayerStats];
 	playerSaved: [guildId: string];
 	playerLoaded: [guildId: string, data: any];
 	savedAll: [results: Map<string, boolean>];
 	loadedAll: [results: Map<string, boolean>];
+	RTSkipped: [guildId: string, reason: string];
+	RTMarkedDestroyed: [guildId: string];
+	RTDestroyedCleared: [guildId: string];
+	backupsCleaned: [guildId: string, count: number];
+	allBackupsCleaned: [count: number];
+	backupStats: [stats: any];
+	backupCleanupDone: [];
 }
 export interface PlayerEvents {
 	debug: [message: string, ...args: any[]];

package/src/types/persistence.ts

@@ -1,4 +1,4 @@
-import type { Track, LoopMode, PlayerOptions } from ".";
+import type { Track, LoopMode, PlayerOptions } from "../types";
 
 export interface SerializedTrack {
 	id: string;
@@ -11,7 +11,7 @@ export interface SerializedTrack {
 	requestedBy?: string;
 	isLive?: boolean;
 	artwork?: string;
-	[key: string]: any; // For additional metadata
+	[key: string]: any;
 }
 
 export interface SerializedQueue {
@@ -20,7 +20,7 @@ export interface SerializedQueue {
 	history: SerializedTrack[];
 	loopMode: LoopMode;
 	autoPlay: boolean;
-	position?: number; // Current playback position in ms
+	position?: number;
 }
 
 export interface SerializedPlayer {
@@ -32,34 +32,52 @@ export interface SerializedPlayer {
 	options: PlayerOptions;
 	filters?: string[];
 	lastUpdate: number;
-	version: string; // For backward compatibility
+	version: string;
+	wasDestroyed?: boolean; // Track if player was destroyed
+	destroyedAt?: number; // When it was destroyed
 }
 
 export interface PersistenceOptions {
 	enabled: boolean;
 	provider?: "file" | "redis" | "database";
-	saveInterval?: number; // Auto-save interval (ms)
-	autoLoad?: boolean; // Auto-load on start
-	maxBackups?: number; // Number of backups to keep
-	compress?: boolean; // Compress saved data
-
-	// File provider options
+	saveInterval?: number;
+	autoLoad?: boolean;
+	autoRestoreOnRestart?: boolean; //  Auto restore after restart
+	restoreDelay?: number; // Delay before restoring (ms)
+	maxBackups?: number; // Max backups per player (default: 5)
+	maxTotalBackups?: number; // Max total backups across all players
+	autoCleanupBackupsOnStart?: boolean; // Auto delete old backups on restart
+	backupRetentionDays?: number; // Delete backups older than N days
+	compress?: boolean;
 	filePath?: string;
-
-	// Redis provider options
 	redisUrl?: string;
 	redisPrefix?: string;
 
-	// Database options (for custom provider)
-	save?: (data: Map<string, SerializedPlayer>) => Promise<void>;
-	load?: () => Promise<Map<string, SerializedPlayer>>;
-	delete?: (guildId: string) => Promise<void>;
+	// Database provider functions (different signatures)
+	save?: ((key: string, data: any) => Promise<void>) | ((data: any) => Promise<void>);
+	load?: ((key: string) => Promise<any>) | (() => Promise<any>);
+	delete?: (key: string) => Promise<void>;
 	list?: () => Promise<string[]>;
 }
 
 export interface PersistenceProvider {
-	save(key: string, data: any, compress?: boolean): Promise<void>;
+	save(key: string, data: any): Promise<void>;
 	load(key: string): Promise<any>;
 	delete(key: string): Promise<void>;
 	list(): Promise<string[]>;
 }
+
+// Track destroyed players for restart detection
+export interface DestroyedRecord {
+	guildId: string;
+	destroyedAt: number;
+	reason?: string;
+}
+
+export interface BackupInfo {
+	key: string;
+	path: string;
+	timestamp: number;
+	size: number;
+	isCompressed: boolean;
+}