@cascateer/sterio 1.0.1

package/openapitools.json

@@ -0,0 +1,14 @@
+{
+  "$schema": "./node_modules/@openapitools/openapi-generator-cli/config.schema.json",
+  "spaces": 2,
+  "generator-cli": {
+    "version": "7.8.0",
+    "generators": {
+      "v1.0": {
+        "generatorName": "typescript-rxjs",
+        "output": "./src/api",
+        "inputSpec": "./build/swagger.json"
+      }
+    }
+  }
+}

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@cascateer/sterio",
+  "version": "1.0.1",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/cascateer/sterio.git"
+  },
+  "scripts": {
+    "semver-patch": "npm version patch && git push origin main --tags",
+    "update": "npm cache clean --force && npx npm-check-updates -u && npm i",
+    "start": "tsx src/main.ts",
+    "cli": "tsx src/client.ts",
+    "serve": "tsx src/app.ts",
+    "tsoa": "tsoa spec-and-routes && npx openapi-generator-cli generate"
+  },
+  "exports": {
+    "./api": "./src/api/index.ts"
+  },
+  "dependencies": {
+    "@cascateer/database": "^0.0.9",
+    "@cascateer/lib": "^1.0.53",
+    "@inquirer/prompts": "^8.5.2",
+    "cors": "^2.8.6",
+    "deepmerge": "^4.3.1",
+    "dotenv": "^17.4.2",
+    "ejs": "^6.0.1",
+    "express": "^5.2.1",
+    "express-session": "^1.19.0",
+    "filenamify": "^7.0.2",
+    "googleapis": "^173.0.0",
+    "http-status-codes": "^2.3.0",
+    "lodash": "^4.18.1",
+    "mime-types": "^3.0.2",
+    "node-id3": "^0.2.9",
+    "object-hash": "^3.0.0",
+    "ora": "^9.4.1",
+    "rxjs": "^7.8.2",
+    "spotify-web-api-node": "^5.0.2",
+    "tsoa": "^7.0.0-alpha.0",
+    "uuid": "^14.0.1",
+    "ytdlp-nodejs": "^3.4.4",
+    "ytmusic-api": "^5.3.1"
+  },
+  "devDependencies": {
+    "@openapitools/openapi-generator-cli": "^2.39.1",
+    "@types/cors": "^2.8.19",
+    "@types/express": "^5.0.6",
+    "@types/express-session": "^1.19.0",
+    "@types/lodash": "^4.17.24",
+    "@types/mime-types": "^3.0.1",
+    "@types/node": "^26.0.1",
+    "@types/object-hash": "^3.0.6",
+    "@types/spotify-web-api-node": "^5.0.11",
+    "typescript": "^6.0.3"
+  }
+}

package/src/Spotify.service.ts

@@ -0,0 +1,202 @@
+import { AsyncEndoFunction, nonNullable } from "@cascateer/lib";
+import { LazyPromise } from "@cascateer/lib/promise";
+import { exec } from "child_process";
+import { readFile, writeFile } from "fs/promises";
+import { StatusCodes } from "http-status-codes";
+import { thru } from "lodash";
+import { firstValueFrom, Subject, timeout, UnaryFunction } from "rxjs";
+import SpotifyWebApi from "spotify-web-api-node";
+import { v4 } from "uuid";
+import { envConfig } from "./config";
+import { chainFunctions, tapPromise } from "./lib";
+import { SpotifyAlbumTable } from "./tables";
+import { SpotifyAlbum, SpotifyGrant } from "./types";
+
+const {
+  SPOTIFY_CLIENT_ID,
+  SPOTIFY_CLIENT_SECRET,
+  SPOTIFY_REDIRECT_URI,
+  SPOTIFY_GRANT_PATH,
+} = envConfig();
+
+export class SpotifyService {
+  public static codes = new Subject<string>();
+
+  private static readonly readGrant = () =>
+    readFile(
+      nonNullable(SPOTIFY_GRANT_PATH),
+      "utf-8",
+    ).then<SpotifyGrant | null>(JSON.parse);
+
+  private static readonly writeGrant = (grant: SpotifyGrant) =>
+    writeFile(
+      nonNullable(SPOTIFY_GRANT_PATH),
+      JSON.stringify(grant, null, "\t"),
+    ).then(() => grant);
+
+  private static lock = new Subject<AsyncEndoFunction<SpotifyWebApi>>();
+
+  static {
+    this.lock
+      .pipe(
+        chainFunctions(() =>
+          this.readGrant().then(
+            (grant) =>
+              new SpotifyWebApi({
+                clientId: SPOTIFY_CLIENT_ID,
+                clientSecret: SPOTIFY_CLIENT_SECRET,
+                redirectUri: SPOTIFY_REDIRECT_URI,
+                accessToken: grant?.access_token,
+                refreshToken: grant?.refresh_token,
+              }),
+          ),
+        ),
+      )
+      .subscribe();
+  }
+
+  private async chain(
+    predicate: AsyncEndoFunction<SpotifyWebApi>,
+  ): Promise<SpotifyWebApi> {
+    return new Promise<SpotifyWebApi>((finish) =>
+      SpotifyService.lock.next((api) =>
+        tapPromise(Promise.resolve(predicate(api)), { finish }),
+      ),
+    );
+  }
+
+  private async refreshAccessToken(): Promise<SpotifyWebApi> {
+    return new Promise((callback) =>
+      this.chain((api) =>
+        api
+          .refreshAccessToken()
+          .then(async ({ body: grant }) => {
+            await SpotifyService.writeGrant(grant);
+
+            api.setAccessToken(grant.access_token);
+
+            if (grant.refresh_token != null) {
+              api.setRefreshToken(grant.refresh_token);
+            }
+
+            return api;
+          })
+          .catch((error) => {
+            console.log(error);
+
+            this.codeGrantAuthorization(callback);
+
+            return api;
+          }),
+      ),
+    );
+  }
+
+  private async codeGrantAuthorization(
+    callback?: UnaryFunction<SpotifyWebApi, void>,
+  ): Promise<SpotifyWebApi> {
+    return tapPromise(
+      this.chain((api) =>
+        tapPromise(
+          firstValueFrom(SpotifyService.codes.pipe(timeout(20 * 60e3))),
+          {
+            start: () =>
+              exec(
+                `start chrome --new-window "${api.createAuthorizeURL(
+                  /**
+                   * https://developer.spotify.com/documentation/web-api/concepts/scopes
+                   */
+                  ["user-library-read", "user-read-email", "user-read-private"],
+                  v4(),
+                )}"`,
+              ),
+          },
+        ).then((code) =>
+          api.authorizationCodeGrant(code).then(async ({ body: grant }) => {
+            await SpotifyService.writeGrant(grant);
+
+            api.setAccessToken(grant.access_token);
+            api.setRefreshToken(grant.refresh_token);
+
+            return api;
+          }),
+        ),
+      ),
+      { finish: callback },
+    );
+  }
+
+  async request<T>(
+    predicate: UnaryFunction<SpotifyWebApi, Promise<T>>,
+    callback?: UnaryFunction<T, void>,
+  ): Promise<T> {
+    return tapPromise(
+      new Promise<T>((resolve) =>
+        this.chain((api) =>
+          predicate(api)
+            .then(resolve)
+            .catch((error) => {
+              if (error.statusCode === StatusCodes.UNAUTHORIZED) {
+                (api.getRefreshToken() != null
+                  ? this.refreshAccessToken()
+                  : this.codeGrantAuthorization()
+                ).then(() => this.request(predicate, resolve));
+
+                return;
+              }
+
+              throw error;
+            })
+            .then(() => api),
+        ),
+      ),
+      { finish: callback },
+    );
+  }
+
+  async getAlbums(ids: string[]): Promise<SpotifyAlbum[]> {
+    return this.request((api) =>
+      LazyPromise.concatAll(
+        ids.map(
+          (id) =>
+            new LazyPromise(() => api.getAlbum(id).then(({ body }) => body)),
+        ),
+      ),
+    );
+  }
+
+  get albums() {
+    return new SpotifyAlbumTable();
+  }
+
+  public async searchAlbums(
+    query: string,
+    maxResults = Infinity,
+  ): Promise<SpotifyApi.AlbumObjectSimplified[]> {
+    return query
+      ? this.request((api) => {
+          const searchAlbums = (
+            query: string,
+            offset?: number,
+          ): Promise<SpotifyApi.AlbumObjectSimplified[]> =>
+            api
+              .searchAlbums(query, { limit: 10, offset })
+              .then(async ({ body }) => {
+                const nextOffset = thru(body.albums?.next, (next) => {
+                  if (next != null) {
+                    return new URL(next).searchParams.get("offset");
+                  }
+                });
+
+                return (body.albums?.items ?? []).concat(
+                  nextOffset != null && +nextOffset < maxResults
+                    ? await searchAlbums(query, +nextOffset)
+                    : [],
+                );
+              });
+
+          return searchAlbums(query);
+        })
+      : [];
+  }
+}

package/src/Sterio.service.ts

@@ -0,0 +1,208 @@
+import { nonNullable, property } from "@cascateer/lib";
+import { LazyPromise } from "@cascateer/lib/promise";
+import deepmerge from "deepmerge";
+import { cloneDeep, compact, isEqual, maxBy, thru } from "lodash";
+import { Ora } from "ora";
+import { pageIndex } from "./lib";
+import { DocumentFileTable, SterioAlbumTable } from "./tables";
+import {
+  SterioAlbum,
+  SterioAlbumFull,
+  SterioDuration,
+  SterioSongFull,
+} from "./types";
+import { YoutubeService } from "./Youtube.service";
+import { YoutubeMusicService } from "./YoutubeMusic.service";
+
+export class SterioService {
+  get albums() {
+    return new SterioAlbumTable();
+  }
+
+  async getAlbumFull(id: string, spinner?: Ora): Promise<SterioAlbumFull> {
+    return this.albums.accessSome([id], spinner).then(([sterioAlbum]) =>
+      new YoutubeMusicService().albums
+        .accessSome(
+          [nonNullable(nonNullable(sterioAlbum.resources).youtubeMusic).id],
+          spinner,
+        )
+        .then(([youtubeMusicAlbum]) => {
+          const album = cloneDeep(youtubeMusicAlbum);
+
+          for (const { index, expectedValue, newValue } of sterioAlbum.songs
+            ?.videoIds ?? []) {
+            try {
+              const song = nonNullable(album.songs[index]);
+              const value = song.videoId;
+
+              if (value !== expectedValue) {
+                throw new Error(
+                  `expected song[${index}].videoId = ${value} to equal ${expectedValue}`,
+                );
+              }
+
+              song.videoId = newValue;
+            } catch (error) {
+              console.error(`🐞 [Album ${id} patcher]: ${error} 🐞`);
+            }
+          }
+
+          return { album, youtubeMusicAlbum };
+        })
+        .then(
+          ({
+            album: { artist, name, songs, thumbnails, year },
+            youtubeMusicAlbum,
+          }) =>
+            new YoutubeService().videos
+              .accessSome(songs.map(property("videoId")), spinner)
+              .then((videos) =>
+                Promise.resolve(
+                  thru(
+                    maxBy(thumbnails, (thumbnail) => thumbnail.height)?.url,
+                    (url) =>
+                      url != null
+                        ? new DocumentFileTable().getFile(url, spinner)
+                        : void 0,
+                  ),
+                ).then((albumArtworkFile) =>
+                  LazyPromise.concatAll(
+                    songs
+                      .map((song) => ({
+                        song,
+                        video: videos.find(
+                          (video) => video.id === song.videoId,
+                        ),
+                      }))
+                      .map(
+                        ({ song, video }, songIndex, { length }) =>
+                          new LazyPromise(async (): Promise<SterioSongFull> => {
+                            const patched = !isEqual(
+                              song,
+                              youtubeMusicAlbum.songs[songIndex],
+                            );
+
+                            const excluded = !thru(
+                              sterioAlbum?.songs ?? {},
+                              ({ include, exclude }) =>
+                                (include == null ||
+                                  include.includes(songIndex)) &&
+                                !exclude?.includes(songIndex),
+                            );
+
+                            const songArtworkFile = await thru(
+                              maxBy(
+                                compact(
+                                  [
+                                    "default" as const,
+                                    "high" as const,
+                                    "maxres" as const,
+                                    "medium" as const,
+                                    "standard" as const,
+                                  ].map(
+                                    (key) => video?.snippet?.thumbnails?.[key],
+                                  ),
+                                ),
+                                (thumbnail) => thumbnail.height,
+                              )?.url,
+                              (url) =>
+                                url != null
+                                  ? new DocumentFileTable().getFile(
+                                      url,
+                                      spinner,
+                                    )
+                                  : void 0,
+                            );
+
+                            const duration = SterioDuration.fromPeriodOfTime(
+                              video?.contentDetails?.duration,
+                            );
+
+                            return {
+                              videoId: song.videoId,
+                              patched,
+                              excluded,
+                              channel:
+                                video?.snippet?.channelId != null ||
+                                video?.snippet?.channelTitle != null
+                                  ? {
+                                      id: video?.snippet?.channelId ?? void 0,
+                                      title:
+                                        video?.snippet?.channelTitle ?? void 0,
+                                    }
+                                  : void 0,
+                              artwork: await [
+                                {
+                                  key: "album" as const,
+                                  file: albumArtworkFile,
+                                },
+                                {
+                                  key: "song" as const,
+                                  file: songArtworkFile,
+                                },
+                              ].reduce(
+                                (artwork, { key, file }) =>
+                                  artwork.then(async (artwork) => {
+                                    if (file != null) {
+                                      artwork[key] = {
+                                        path: `file://${file.path.replace(/\\/g, "/")}`,
+                                        checksum: await file.hash(),
+                                      };
+                                    }
+
+                                    return artwork;
+                                  }),
+                                Promise.resolve<SterioSongFull["artwork"]>({}),
+                              ),
+                              duration,
+                              tags: {
+                                title: song.name,
+                                artist: artist.name,
+                                performerInfo: artist.name,
+                                album: name,
+                                trackNumber: pageIndex(songIndex + 1, length),
+                                year: year?.toString() ?? void 0,
+                                image: albumArtworkFile?.toString(),
+                                audioSourceUrl: `https://youtube.com/watch?v=${song.videoId}`,
+                                length:
+                                  duration != null
+                                    ? `${(duration.minutes * 60 + duration.seconds) * 1e3}`
+                                    : void 0,
+                              },
+                            };
+                          }),
+                      ),
+                  ),
+                ),
+              )
+
+              .then((songs) => ({
+                id: sterioAlbum.id,
+                artist,
+                name,
+                songs,
+                thumbnails,
+                year,
+              })),
+        ),
+    );
+  }
+
+  async getAlbumsFull(spinner?: Ora): Promise<SterioAlbumFull[]> {
+    return this.albums
+      .accessAll()
+      .then((albums) =>
+        Promise.all(albums.map(({ id }) => this.getAlbumFull(id, spinner))),
+      );
+  }
+
+  async updateAlbum(id: string, partialAlbum: SterioAlbum) {
+    if (partialAlbum.id != null && partialAlbum.id !== id) {
+      throw new Error();
+    }
+
+    return this.albums.dispatch("update", id, (album: SterioAlbum) =>
+      deepmerge(album, partialAlbum),
+    );
+  }
+}

package/src/Youtube.service.ts

@@ -0,0 +1,112 @@
+import { nonNullable } from "@cascateer/lib";
+import { google, youtube_v3 } from "googleapis";
+import { intersectionWith, uniq } from "lodash";
+import { envConfig } from "./config";
+import { YoutubePlaylistTable, YoutubeVideoTable } from "./tables";
+import { YoutubePlaylist, YoutubeVideo } from "./types";
+
+const { YOUTUBE_DATA_API_KEY } = envConfig();
+
+export class YoutubeService {
+  private api = google.youtube("v3");
+
+  async getPlaylist(id: string): Promise<YoutubePlaylist> {
+    const getPlaylistItems = (
+      playlistId: string,
+      pageToken?: string,
+    ): Promise<youtube_v3.Schema$PlaylistItem[]> =>
+      this.api.playlistItems
+        .list({
+          auth: YOUTUBE_DATA_API_KEY,
+          playlistId,
+          part: ["contentDetails", "snippet"],
+          fields:
+            "items(id,contentDetails(videoId),snippet(title,position)),nextPageToken",
+          pageToken,
+          maxResults: 50,
+        })
+        .then(async ({ data: { items, nextPageToken } }) =>
+          (items ?? []).concat(
+            nextPageToken != null
+              ? await getPlaylistItems(playlistId, nextPageToken)
+              : [],
+          ),
+        );
+
+    return this.api.playlists
+      .list({
+        auth: YOUTUBE_DATA_API_KEY,
+        id: [id],
+        part: ["snippet"],
+        fields: "items(id,snippet(title))",
+      })
+      .then(({ data }) => nonNullable(data.items?.[0]))
+      .then((playlist) => ({
+        id: nonNullable(playlist.id),
+        title: playlist.snippet?.title ?? void 0,
+      }))
+      .then(({ id, title }) =>
+        getPlaylistItems(id).then((items) => ({
+          id,
+          title,
+          items,
+        })),
+      );
+  }
+
+  async getVideos(ids: string[], pageToken?: string): Promise<YoutubeVideo[]> {
+    if (ids.length === 0) {
+      return [];
+    }
+
+    return this.api.videos
+      .list({
+        auth: YOUTUBE_DATA_API_KEY,
+        id: uniq(ids),
+        part: ["contentDetails", "snippet"],
+        fields: "items(id,contentDetails,snippet),nextPageToken",
+        pageToken,
+        maxResults: 50,
+      })
+      .then(async ({ data: { items, nextPageToken } }) =>
+        intersectionWith(
+          (items ?? []).concat(
+            nextPageToken != null
+              ? await this.getVideos(ids, nextPageToken)
+              : [],
+          ),
+          ids,
+          (video, id) => video.id === id,
+        ),
+      );
+  }
+
+  get videos() {
+    return new YoutubeVideoTable();
+  }
+
+  get playlists() {
+    return new YoutubePlaylistTable();
+  }
+
+  async search(
+    query: { q?: string; channelId?: string },
+    pageToken?: string,
+  ): Promise<youtube_v3.Schema$SearchResult[]> {
+    return this.api.search
+      .list({
+        auth: YOUTUBE_DATA_API_KEY,
+        q: query.q,
+        channelId: query.channelId,
+        part: ["snippet"],
+        fields: "items(id,snippet),nextPageToken",
+        pageToken,
+        maxResults: 50,
+      })
+      .then(async ({ data: { items, nextPageToken } }) =>
+        (items ?? []).concat(
+          nextPageToken != null ? await this.search(query, nextPageToken) : [],
+        ),
+      );
+  }
+}

package/src/YoutubeMusic.service.ts

@@ -0,0 +1,52 @@
+import { nonNullable, property } from "@cascateer/lib";
+import { groupBy, mapValues, once, pickBy } from "lodash";
+import { defer, Observable, of, UnaryFunction } from "rxjs";
+import YTMusic, { AlbumDetailed, SongDetailed } from "ytmusic-api";
+import { YoutubeMusicAlbumTable } from "./tables";
+
+export class YoutubeMusicService {
+  private static initialize = once(
+    async (): Promise<YTMusic> => new YTMusic().initialize().then(nonNullable),
+  );
+
+  initialize = YoutubeMusicService.initialize;
+
+  get albums() {
+    return new YoutubeMusicAlbumTable();
+  }
+
+  async getAlbum(albumId: string) {
+    return this.initialize().then((api) =>
+      api.getAlbum(albumId).then((album) => {
+        if (
+          new Set(album.songs.map(property("videoId"))).size !==
+          album.songs.length
+        ) {
+          console.warn(
+            `Duplicate videoIds in album ${JSON.stringify(album.albumId)}:\n${Object.entries(
+              mapValues(
+                pickBy(
+                  groupBy(album.songs, property("videoId")),
+                  (group) => group.length > 1,
+                ),
+                (songs) => songs.map(property("name")).join(", "),
+              ),
+            ).map(([videoId, songs]) => ["", videoId, songs].join("\t"))}`,
+          );
+        }
+
+        return album;
+      }),
+    );
+  }
+
+  searchAlbums: UnaryFunction<string, Observable<AlbumDetailed[]>> = (query) =>
+    query
+      ? defer(() => this.initialize().then((api) => api.searchAlbums(query)))
+      : of([]);
+
+  searchSongs: UnaryFunction<string, Observable<SongDetailed[]>> = (query) =>
+    query
+      ? defer(() => this.initialize().then((api) => api.searchSongs(query)))
+      : of([]);
+}

package/src/api/.openapi-generator/FILES

@@ -0,0 +1,29 @@
+.gitignore
+.openapi-generator-ignore
+apis/DefaultApi.ts
+apis/index.ts
+index.ts
+models/GetYoutubeMusicAlbums200ResponseInner.ts
+models/PartialSterioAlbumResourcesFull.ts
+models/SpotifyApiAlbumObjectSimplified.ts
+models/SpotifyApiArtistObjectSimplified.ts
+models/SpotifyApiExternalUrlObject.ts
+models/SpotifyApiImageObject.ts
+models/SpotifyApiRestrictionsObject.ts
+models/SterioAlbum.ts
+models/SterioAlbumResource.ts
+models/SterioAlbumResourcesTable.ts
+models/SterioAlbumSongs.ts
+models/SterioAlbumSongsVideoIdsInner.ts
+models/YoutubePlaylist.ts
+models/YoutubeV3Schema36PlaylistItem.ts
+models/YoutubeV3Schema36PlaylistItemContentDetails.ts
+models/YoutubeV3Schema36PlaylistItemSnippet.ts
+models/YoutubeV3Schema36PlaylistItemStatus.ts
+models/YoutubeV3Schema36ResourceId.ts
+models/YoutubeV3Schema36Thumbnail.ts
+models/YoutubeV3Schema36ThumbnailDetails.ts
+models/index.ts
+runtime.ts
+servers.ts
+tsconfig.json

package/src/api/.openapi-generator/VERSION

@@ -0,0 +1 @@
+7.8.0