Fix file names and preserver folder structure

index.ts

@@ -1,14 +1,15 @@
 import { Command } from 'commander';
 import { checkbox } from '@inquirer/prompts';
-import { getAllPlaylists, getSonglistForPlaylist } from './lib/services/jellyfin.ts';
-import type { Playlist, SongMeta } from './lib/services/jellyfin.ts';
-import { downloadSongs } from './lib/fileDownloader.ts';
+import { getAllPlaylistMetas, getPlaylistSongs } from './lib/services/jellyfin.ts';
+import type { Playlist } from './lib/services/jellyfin.ts';
+import { downloadsFromPlaylists, downloadSongs } from './lib/fileDownloader.ts';
 import { writeM3UFile } from './lib/m3uWriter.ts';
 import 'dotenv/config';
 
 const program = new Command();
 
-const { JF_SERVER, JF_USERNAME, JF_PASSWORD, DEST_FOLDER, PLAYLISTS } = process.env;
+const { JF_SERVER, JF_USERNAME, JF_PASSWORD, DEST_FOLDER, REMOTE_ROOT_PATH } =
+  process.env;
 
 program
   .name('')
@@ -36,43 +37,29 @@ program
       console.error('Missing required env var DEST_FOLDER.  Exiting...');
       process.exit();
     }
+    //TODO: Get this from the library path??
+    if (!REMOTE_ROOT_PATH) {
+      console.error('Missing required env var REMOTE_ROOT_PATH.  Exiting...');
+      process.exit();
+    }
     const creds = {
       server: JF_SERVER,
       user: JF_USERNAME,
       password: JF_PASSWORD,
     };
-    const playlistMetas = await getAllPlaylists(creds);
-    const answer = await checkbox({
+    const playlistMetas = await getAllPlaylistMetas(creds);
+    const answer = await checkbox<string>({
       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<string, SongMeta>,
-    );
-    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);

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<string, SongMeta>,
+    ),
+  );
+
+  return dedupedSongs.map(s => ({
+    id: s.Id,
+    downloadPath: getLocalPath(s.Path),
+    localFileName: getSongLocalFileName(s),
+  }));
+}
+
 const QUEUE: (() => Promise<void>)[] = [];
+
 let downloadCount = 0;
-const DOWNLOAD_LIMIT = 10;
+const DOWNLOAD_CONCURENCY_LIMIT = 10;
+const DOWNLOADED: Record<string, boolean> = {};
 
 export const downloadSongs = async (
   creds: ServerCreds,
-  songs: SongMeta[],
-  path: string,
+  songs: ReturnType<typeof downloadsFromPlaylists>,
+  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<typeof downloadsFromPlaylists>[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 &&

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');
+}

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);
 };

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<Playlist, 'songList'>;
+
+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<AuthInfo> | 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<Playlist[]> => {
+export const getAllPlaylistMetas = async (creds: ServerCreds): Promise<Playlist[]> => {
   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;
+}