From 35503b7dfc33e01f3a120743c3dc2ff1948d3b19 Mon Sep 17 00:00:00 2001 From: John Shaver Date: Wed, 5 Mar 2025 16:41:23 -0800 Subject: [PATCH] Fix file names and preserver folder structure --- bun.lockb | Bin 52203 -> 52203 bytes index.ts | 49 +++++++++-------------- lib/fileDownloader.ts | 83 +++++++++++++++++++++++++++++++-------- lib/helpers.ts | 27 +++++++++++++ lib/m3uWriter.ts | 17 +++++--- lib/services/jellyfin.ts | 59 +++++++++++++++++++++++----- 6 files changed, 172 insertions(+), 63 deletions(-) create mode 100644 lib/helpers.ts diff --git a/bun.lockb b/bun.lockb index e80aca4abab31dfc4404d30a19389296eaa94941..2de8fa2230be113e68c37c10b09cc9e7043b8f53 100755 GIT binary patch delta 22 ecmaDoo%!{2<_+u+{{1Wjx_*nS_sAf delta 23 acmaDoo%!{2<_+u({ message: 'Which playlists would you like to download?', choices: playlistMetas.map((pl: Playlist) => ({ name: pl.Name, value: pl.Id })), }); - const playlists = await Promise.all( - answer.map(async id => { - const pl = { - ...playlistMetas.find(p => p.Id === id), - }; - pl.songlist = await getSonglistForPlaylist(creds, id); - return pl; - }), - ); - const allSongs = playlists.reduce( - (songs, pl) => { - console.log('PLAYLIST: ', pl); - pl.songlist?.forEach(song => { - songs[song.Id] = song; - }); - return songs; - }, - {} as Record, - ); - await downloadSongs(creds, Object.values(allSongs), DEST_FOLDER); + const playlists = await getPlaylistSongs(creds, answer, playlistMetas); + console.log('Downloading songs to ', DEST_FOLDER); + const songsToDownload = downloadsFromPlaylists(playlists); - await Promise.all( - playlists.map((pl, i) => - writeM3UFile(DEST_FOLDER, pl.Name || `playlist${i}`, pl.songlist as SongMeta[]), - ), - ); + await downloadSongs(creds, songsToDownload, DEST_FOLDER); + + await Promise.all(playlists.map(pl => writeM3UFile(DEST_FOLDER, pl))); }); await program.parseAsync(process.argv); diff --git a/lib/fileDownloader.ts b/lib/fileDownloader.ts index a5da27f..89457c4 100644 --- a/lib/fileDownloader.ts +++ b/lib/fileDownloader.ts @@ -1,36 +1,85 @@ -import fs from 'fs'; +import fs from 'node:fs'; import nodePath from 'node:path'; import { finished } from 'stream/promises'; -import type { SongMeta, ServerCreds } from './services/jellyfin.ts'; +import { writeFileAndCreateFolders } from './helpers.ts'; + +import type { SongMeta, ServerCreds, Playlist } from './services/jellyfin.ts'; import { getSongFileBuffer } from './services/jellyfin.ts'; +export function getLocalPath(serverPath: string) { + const remoteRoot = process.env.REMOTE_ROOT_PATH as string; + + return nodePath.dirname(nodePath.normalize(serverPath).slice(remoteRoot.length)); +} + +export function getSongLocalFileName({ AlbumArtist, Artists, Name, Path }: SongMeta) { + if (!Name) { + return nodePath.basename(Path); + } + const ext = Path.split('.').pop(); + let artist = AlbumArtist || Artists?.[0]; + if (!artist) { + return `${Name}.${ext}`; + } + return `${artist} - ${Name}.${ext}`; +} + +export function downloadsFromPlaylists(playlists: Playlist[]) { + const dedupedSongs: SongMeta[] = Object.values( + playlists.reduce( + (songs, pl) => { + pl.songList?.forEach(song => { + songs[song.Id] = song; + }); + return songs; + }, + {} as Record, + ), + ); + + return dedupedSongs.map(s => ({ + id: s.Id, + downloadPath: getLocalPath(s.Path), + localFileName: getSongLocalFileName(s), + })); +} + const QUEUE: (() => Promise)[] = []; + let downloadCount = 0; -const DOWNLOAD_LIMIT = 10; +const DOWNLOAD_CONCURENCY_LIMIT = 10; +const DOWNLOADED: Record = {}; export const downloadSongs = async ( creds: ServerCreds, - songs: SongMeta[], - path: string, + songs: ReturnType, + localRootPath: string, ) => { - const promises = songs.map(s => getSongDownloader(creds, s, path)); + const promises = songs.map(s => getSongDownloader(creds, s, localRootPath)); QUEUE.push(...promises); processQueue(); await Promise.all(promises); }; - +//TODO: Now we have the local path and file name. We need to check if the song has already downloaded and of not, start the download and add it to the list of downloaded, otherwise return false const getSongDownloader = - (creds: ServerCreds, song: SongMeta, path: string) => async () => { - const extension = song.Path.split('.').pop(); - const filePath = nodePath.join(path, `${song.Id}.${extension}`); + ( + creds: ServerCreds, + song: ReturnType[number], + localRootPath: string, + ) => + async () => { + const filePath = nodePath.join(localRootPath, song.downloadPath, song.localFileName); + if (DOWNLOADED[filePath]) { + return; + } + DOWNLOADED[filePath] = true; try { - const write = fs.createWriteStream(filePath, { - flags: 'wx', - }); - console.log('Downloading: ', filePath); - const download = await getSongFileBuffer(creds, song.Id); - await finished(download.pipe(write)); + const download = await getSongFileBuffer(creds, song.id); + + console.log('Downloading song: ', song.localFileName); + + await writeFileAndCreateFolders(filePath, download); } catch (err: any) { if (err?.code !== 'EEXIST') { throw err; @@ -40,7 +89,7 @@ const getSongDownloader = }; const processQueue = () => { - if (downloadCount < DOWNLOAD_LIMIT && QUEUE.length) { + if (downloadCount < DOWNLOAD_CONCURENCY_LIMIT && QUEUE.length) { downloadCount++; const next = QUEUE.shift(); next && diff --git a/lib/helpers.ts b/lib/helpers.ts new file mode 100644 index 0000000..f6472c1 --- /dev/null +++ b/lib/helpers.ts @@ -0,0 +1,27 @@ +import fs from 'node:fs'; +import path from 'node:path'; +import { Readable } from 'node:stream'; +import { finished } from 'stream/promises'; + +export async function ensurePathForFile(filePath: string) { + const dirPath = path.dirname(filePath); + await fs.promises.mkdir(dirPath, { recursive: true }); +} + +export async function writeFileAndCreateFolders( + filePath: string, + data: Readable | string | Buffer, +) { + await ensurePathForFile(filePath); + + if (data instanceof Readable) { + const write = fs.createWriteStream(filePath, { + flags: 'wx', + }); + return finished(data.pipe(write)); + } + if (data instanceof Buffer) { + return fs.promises.writeFile(filePath, data); + } + return fs.promises.writeFile(filePath, data, 'utf8'); +} diff --git a/lib/m3uWriter.ts b/lib/m3uWriter.ts index b39fbd4..fe80a7f 100644 --- a/lib/m3uWriter.ts +++ b/lib/m3uWriter.ts @@ -1,18 +1,23 @@ import { writeFile } from 'node:fs/promises'; import nodePath from 'node:path'; import m3u from 'm3u'; -import type { SongMeta } from './services/jellyfin.ts'; +import type { Playlist, SongMeta } from './services/jellyfin.ts'; +import { writeFileAndCreateFolders } from './helpers.ts'; +import { getLocalPath, getSongLocalFileName } from './fileDownloader.ts'; const createM3U = (name: string, songlist: SongMeta[]) => { const m3uWriter = m3u.writer(); for (const song of songlist) { - const extension = song.Path.split('.').pop(); - m3uWriter.file(`${song.Id}.${extension}`); + const path = getLocalPath(song.Path); + const name = getSongLocalFileName(song); + + m3uWriter.file(nodePath.join(path, name)); } return m3uWriter.toString(); }; -export const writeM3UFile = async (path: string, name: string, songlist: SongMeta[]) => { - const contents = createM3U(name, songlist); - return writeFile(nodePath.join(path, `${name}.m3u`), contents, 'utf8'); +export const writeM3UFile = async (path: string, playlist: Playlist) => { + const name = playlist.Name || playlist.Id; + const contents = createM3U(name, playlist.songList); + return writeFileAndCreateFolders(nodePath.join(path, `${name}.m3u`), contents); }; diff --git a/lib/services/jellyfin.ts b/lib/services/jellyfin.ts index 35fdd4c..7327569 100644 --- a/lib/services/jellyfin.ts +++ b/lib/services/jellyfin.ts @@ -18,18 +18,31 @@ interface View { CollectionType: string; } -export interface Playlist { +export type Playlist = { Name: string; Id: string; - MediaType: string; - songlist: SongMeta[]; -} + IsFolder: boolean; + MediaType: 'Audio' | 'Shows' | 'Movies'; //Probably incorrect/incomplete, except for "Audio" + Type: 'Playlist'; + songList: SongMeta[]; +}; -export interface SongMeta { +export type PlaylistMeta = Omit; + +export type SongMeta = { + Name?: string; Id: string; - Name: string; + HasLyrics: boolean; Path: string; -} + IsFolder: boolean; + Type: 'Audio'; + Artists?: string[]; + AlbumId?: string; + AlbumArtist?: string; + AlbumArtists?: string[]; + MediaType: 'Audio'; + NormalizationGain: number; +}; let tokenPromise: Promise | undefined = undefined; @@ -89,7 +102,7 @@ export const getItemsByParent = async (creds: ServerCreds, parentId: string) => return (await response.json()).Items; }; -export const getAllPlaylists = async (creds: ServerCreds): Promise => { +export const getAllPlaylistMetas = async (creds: ServerCreds): Promise => { const auth = await getAuthInfo(creds); const views = await getAllViews(creds); const musicViews = views.filter(c => c.CollectionType === 'music'); @@ -116,5 +129,33 @@ export const getSongFileBuffer = async (creds: ServerCreds, id: string) => { const response = await fetch(`${creds.server}/Items/${id}/File?userId=${auth.userId}`, { headers: { Authorization: auth.authHeaderValue }, }); - return Readable.fromWeb(response.body); + + if (!response.body) { + throw new Error( + `Error, no response body from requesting song file buffer for song: ${id}`, + ); + } + //Weird typing issue... + return Readable.fromWeb(response.body as any); }; + +export async function getPlaylistSongs( + creds: ServerCreds, + playlistIds: string[], + playlistMetas: PlaylistMeta[], +) { + const playLists = await Promise.all( + playlistIds.map(async id => { + const playlistMeta = playlistMetas.find(pl => pl.Id === id); + if (!playlistMeta) { + throw new Error(`Unable to find selected playlist, somehow??? - ${id}`); + } + const playList: Playlist = { + ...playlistMeta, + songList: await getSonglistForPlaylist(creds, id), + }; + return playList; + }), + ); + return playLists; +}