Queue & Persistence

import type { Player, Track } from 'hoshimi';

declare const player: Player;
declare const track: Track;

const queue = player.queue;

await queue.add(track);
const next = await queue.shift();

console.log(`Queue size: ${queue.size}`);
console.log(`Total size (incl. current): ${queue.totalSize}`);
console.log(`Current: ${queue.current?.info.title}`);
console.log(`History: ${queue.history.length} tracks`);

await queue.shuffle();
await queue.splice(0, 1);
await queue.clear();

import { PlayerMemoryStorage, QueueMemoryStorage } from 'hoshimi';

// The player storage is scoped to a guild.
const playerStorage = new PlayerMemoryStorage('123456789012345678');
const queueStorage = new QueueMemoryStorage();

playerStorage.namespace = 'hoshimiplayer';
queueStorage.namespace = 'hoshimiqueue';

import type { QueueJSON, RestOrArray } from 'hoshimi';
import { QueueStorageAdapter } from 'hoshimi';

interface RedisClient {
  get(key: string): Promise<string | null>;
  set(key: string, value: string): Promise<void>;
  del(key: string): Promise<number>;
  exists(key: string): Promise<number>;
}

class RedisQueueStorage extends QueueStorageAdapter<QueueJSON> {
  constructor(private readonly redis: RedisClient) {
    super();
  }

  override async get(key: string): Promise<QueueJSON | undefined> {
    const value = await this.redis.get(this.buildKey(this.namespace, key));
    return value ? this.parse(value) : undefined;
  }

  override async set(key: string, value: QueueJSON): Promise<void> {
    await this.redis.set(this.buildKey(this.namespace, key), this.stringify(value));
  }

  override async delete(key: string): Promise<boolean> {
    return (await this.redis.del(this.buildKey(this.namespace, key))) > 0;
  }

  override async has(key: string): Promise<boolean> {
    return (await this.redis.exists(this.buildKey(this.namespace, key))) > 0;
  }

  override async clear(): Promise<void> {
    // Implement according to your redis strategy
  }

  override parse(value: unknown): QueueJSON {
    return typeof value === "string" ? JSON.parse(value) : (value as QueueJSON);
  }

  override stringify<R = string>(value: unknown): R {
    return (typeof value === "object" ? JSON.stringify(value) : value) as R;
  }

  override buildKey(...parts: RestOrArray<string>): string {
    return parts.flat().join(":");
  }
}