@cascateer/sterio 1.0.1

package/src/api/servers.ts

@@ -0,0 +1,45 @@
+/**
+ *
+ * Represents the configuration of a server including its
+ * url template and variable configuration based on the url.
+ *
+ */
+export class ServerConfiguration<T extends { [key: string]: string }> {
+    public constructor(private url: string, private variableConfiguration: T, private description: string) {}
+
+    /**
+     * Sets the value of the variables of this server.
+     *
+     * @param variableConfiguration a partial variable configuration for the variables contained in the url
+     */
+    public setVariables(variableConfiguration: Partial<T>) {
+        Object.assign(this.variableConfiguration, variableConfiguration);
+    }
+
+    public getConfiguration(): T {
+        return this.variableConfiguration;
+    }
+
+    public getDescription(): string {
+        return this.description;
+    }
+
+    /**
+     * Constructions the URL this server using the url with variables
+     * replaced with their respective values
+     */
+    public getUrl(): string {
+        let replacedUrl = this.url;
+        for (const key in this.variableConfiguration) {
+            if (this.variableConfiguration.hasOwnProperty(key)) {
+                 const re = new RegExp("{" + key + "}","g");
+                 replacedUrl = replacedUrl.replace(re, this.variableConfiguration[key]);
+            }
+        }
+        return replacedUrl;
+    }
+}
+
+const server1 = new ServerConfiguration<{  }>("http://127.0.0.1:2700", {  }, "");
+
+export const servers = [server1];

package/src/api/tsconfig.json

@@ -0,0 +1,22 @@
+{
+  "compilerOptions": {
+    "declaration": true,
+    "target": "es5",
+    "module": "commonjs",
+    "moduleResolution": "node",
+    "outDir": "dist",
+    "rootDir": ".",
+    "lib": [
+      "es6",
+      "dom",
+      "es2017"
+    ],
+    "typeRoots": [
+      "node_modules/@types"
+    ]
+  },
+  "exclude": [
+    "dist",
+    "node_modules"
+  ]
+}

package/src/app.ts

@@ -0,0 +1,58 @@
+import { nonNullable } from "@cascateer/lib";
+import cors from "cors";
+import express, { ErrorRequestHandler, json } from "express";
+import session from "express-session";
+import { StatusCodes } from "http-status-codes";
+import { resolve } from "path";
+import { RegisterRoutes } from "../build/routes";
+import tsoaConfig from "../tsoa.json";
+import { SpotifyService } from "./Spotify.service";
+import { envConfig } from "./config";
+
+const { SPOTIFY_REDIRECT_URI } = envConfig();
+
+const [APP_HOST, APP_PORT] = tsoaConfig.spec.host.split(":");
+
+const app = express();
+
+app.use(json());
+app.use(
+  cors({
+    credentials: true,
+    origin: true,
+  }),
+);
+app.use(
+  session({
+    resave: false,
+    saveUninitialized: false,
+    secret: "secret secret",
+  }),
+);
+
+app.set("view engine", "ejs");
+app.set("views", resolve(__dirname, "views"));
+
+app.get(new URL(nonNullable(SPOTIFY_REDIRECT_URI)).pathname, (req, res) => {
+  const code = req.query.code?.toString();
+
+  if (code != null) {
+    SpotifyService.codes.next(code);
+  }
+
+  res.render("spotify/auth-callback", { code: req.query.code });
+});
+
+RegisterRoutes(app);
+
+app.use(<ErrorRequestHandler>function (error, req, res, next) {
+  console.error(error);
+
+  res
+    .status(StatusCodes.INTERNAL_SERVER_ERROR)
+    .send(error.stack ?? error.message);
+});
+
+app.listen(+nonNullable(APP_PORT), nonNullable(APP_HOST), () =>
+  console.log(`Server is running on http://${APP_HOST}:${APP_PORT}`),
+);

package/src/config.ts

@@ -0,0 +1,6 @@
+import { configDotenv } from "dotenv";
+
+export const envConfig = () =>
+  configDotenv({
+    path: [".env.local", ".env"],
+  }).parsed ?? {};

package/src/controller.ts

@@ -0,0 +1,148 @@
+import { findDupeBy, property, split } from "@cascateer/lib";
+import { LazyPromise } from "@cascateer/lib/promise";
+import { at, find, get, memoize } from "lodash";
+import { lastValueFrom } from "rxjs";
+import { Body, Controller, Get, Patch, Path, Post, Query, Route } from "tsoa";
+import { SpotifyService } from "./Spotify.service";
+import { SterioService } from "./Sterio.service";
+import {
+  SterioAlbum,
+  SterioAlbumResourcesTable,
+  YoutubePlaylist,
+} from "./types";
+import { YoutubeService } from "./Youtube.service";
+import { YoutubeMusicService } from "./YoutubeMusic.service";
+
+@Route("sterio")
+export class SterioController extends Controller {
+  @Get("album/{id}")
+  async getAlbum(@Path() id: string): Promise<SterioAlbum> {
+    return new SterioService().albums.accessSome([id]).then(property(0));
+  }
+
+  @Patch("album")
+  async updateAlbum(
+    @Body()
+    album: SterioAlbum,
+  ) {
+    return new SterioService().updateAlbum(album.id, album);
+  }
+
+  @Post("album/{id}/resources/table")
+  async getAlbumResourcesTable(
+    @Path() id: string,
+  ): Promise<SterioAlbumResourcesTable> {
+    const [{ resources: { youtubeMusic, youtube, spotify } = {} }] =
+      await new SterioService().albums.accessSome([id]);
+
+    if (youtubeMusic != null && youtube != null && spotify != null) {
+      const [[youtubeMusicAlbum], [youtubePlaylist], [spotifyAlbum]] =
+        await LazyPromise.concatAll([
+          new LazyPromise(() =>
+            new YoutubeMusicService().albums.accessSome([youtubeMusic.id]),
+          ),
+          new LazyPromise(() =>
+            new YoutubeService().playlists.accessSome([youtube.id]),
+          ),
+          new LazyPromise(() =>
+            new SpotifyService().albums.accessSome([spotify.id]),
+          ),
+        ]);
+
+      class KeyGenerator<T> {
+        constructor(
+          public items: T[],
+          public iteratees: {
+            uid?: string;
+            name: string;
+          },
+        ) {}
+
+        keys = memoize((type?: keyof typeof this.iteratees) =>
+          this.items.map((item) =>
+            (type === "name"
+              ? this.iteratees.name
+              : this.iteratees.uid || this.iteratees.name
+            ).replaceAll(
+              /(\$\{([^\/]*)(?:\/([^\/]*)\/(?:([^\/]*)\/(?:([^\/]*))?)?)?\})/g,
+              (_, __, path, pattern, replacement, flags) =>
+                get(item, path).replace(
+                  new RegExp(pattern, flags),
+                  replacement ?? "",
+                ),
+            ),
+          ),
+        );
+
+        at = <U>(mask: KeyGenerator<U>, type?: keyof typeof this.iteratees) =>
+          at(
+            this.keys(type),
+            mask.keys().map((key) => this.keys().indexOf(key)),
+          );
+      }
+
+      const youtubeMusicKeyGenerator = new KeyGenerator(
+        youtubeMusicAlbum.songs,
+        {
+          uid: youtubeMusic.iteratee,
+          name: "${name}",
+        },
+      );
+
+      const youtubeKeyGenerator = new KeyGenerator(youtubePlaylist.items, {
+        uid: youtube?.iteratee,
+        name: "${snippet.title}",
+      });
+
+      const spotifyKeyGenerator = new KeyGenerator(spotifyAlbum.tracks.items, {
+        uid: spotify?.iteratee,
+        name: "${name}",
+      });
+
+      if (
+        findDupeBy(youtubeMusicKeyGenerator.keys()) == null &&
+        findDupeBy(youtubeKeyGenerator.keys()) == null &&
+        findDupeBy(spotifyKeyGenerator.keys()) == null
+      ) {
+        return {
+          youtubeMusic: youtubeMusicKeyGenerator.keys("name"),
+          youtube: youtubeKeyGenerator.at(youtubeMusicKeyGenerator, "name"),
+          spotify: spotifyKeyGenerator.at(youtubeMusicKeyGenerator, "name"),
+        };
+      }
+    }
+
+    return {
+      youtubeMusic: [],
+      youtube: [],
+      spotify: [],
+    };
+  }
+
+  @Get("spotify/albums")
+  async getSpotifyAlbums(
+    @Query("q") query: string,
+  ): Promise<SpotifyApi.AlbumObjectSimplified[]> {
+    return new SpotifyService().searchAlbums(query, 10);
+  }
+
+  @Get("youtube/playlists")
+  async getYoutubePlaylists(@Query() ids: string): Promise<YoutubePlaylist[]> {
+    return new YoutubeService().playlists.accessSome(split(ids));
+  }
+
+  @Get("youtube-music/albums")
+  async getYoutubeMusicAlbums(
+    @Query("q") query: string,
+  ): Promise<{ albumId: string; text: string }[]> {
+    return lastValueFrom(new YoutubeMusicService().searchAlbums(query)).then(
+      (albums) =>
+        new SterioService().albums.accessAll().then((sterioAlbums) =>
+          albums.map(({ albumId, ...album }) => ({
+            albumId,
+            text: `${find(sterioAlbums, { resources: { youtubeMusic: { id: albumId } } }) != null ? "☑" : "☐"} ${album.name} / ${album.artist.name} (${album.year})`,
+          })),
+        ),
+    );
+  }
+}

package/src/lib.ts

@@ -0,0 +1,112 @@
+import {
+  AsyncEndoFunction,
+  keys,
+  MaybePromise,
+  property,
+} from "@cascateer/lib";
+import { reduce } from "@cascateer/lib/observable";
+import {
+  Dictionary,
+  maxBy,
+  pad,
+  padEnd,
+  padStart,
+  truncate,
+  TruncateOptions,
+} from "lodash";
+import {
+  identity,
+  mergeAll,
+  OperatorFunction,
+  startWith,
+  UnaryFunction,
+} from "rxjs";
+
+interface TableColumnOptions<U> extends TruncateOptions {
+  stringify?: UnaryFunction<U, string>;
+  align?: "start" | "end" | "center";
+  fill?: string;
+}
+
+type TableTemplate<T extends Dictionary<unknown>> = {
+  [K in keyof T]: TableColumnOptions<T[K]>;
+};
+
+export class Table<T extends Dictionary<unknown>> {
+  constructor(
+    public rows: T[],
+    public template: TableTemplate<T>,
+  ) {}
+
+  toString(): string {
+    return this.rows
+      .map((row) =>
+        [
+          "",
+          ...keys(this.template).map((key) => {
+            const {
+              stringify = String,
+              align = "start",
+              fill,
+              length = maxBy(
+                this.rows.map(property(key)).map(stringify),
+                property("length"),
+              )?.length,
+              omission,
+              separator,
+            } = this.template[key];
+
+            return { start: padEnd, end: padStart, center: pad }[align](
+              truncate(stringify(row[key]), { length, omission, separator }),
+              length,
+              fill,
+            );
+          }),
+          "",
+        ].join("│"),
+      )
+      .join("\n");
+  }
+
+  filter(predicate: (row: T, index: number) => boolean) {
+    return new Table(this.rows.filter(predicate), this.template);
+  }
+}
+
+export const pageIndex = (x: number, y: number) =>
+  `${new Intl.NumberFormat("en-US", {
+    minimumIntegerDigits: `${y}`.length,
+  }).format(x)}/` + y;
+
+export const secondsToHms = (seconds: number) =>
+  new Date(seconds * 1e3).toISOString().slice(11, 19).replace(/^00:/, "");
+
+export const tapPromise = <T>(
+  input: Promise<T>,
+  on?: Partial<{
+    start: UnaryFunction<void, void>;
+    finish: UnaryFunction<T, void>;
+    error: UnaryFunction<any, void>;
+  }>,
+) =>
+  Promise.resolve(on?.start?.call(null)).then(() =>
+    input
+      .catch((error) => {
+        on?.error?.call(null, error);
+
+        throw error;
+      })
+      .then((value) => (on?.finish?.call(null, value), value)),
+  );
+
+export const chainFunctions =
+  <T>(seed: () => MaybePromise<T>): OperatorFunction<AsyncEndoFunction<T>, T> =>
+  (source) =>
+    source.pipe(
+      startWith(identity),
+      reduce<(() => MaybePromise<T>) | AsyncEndoFunction<T>, Promise<T>>(
+        (state, predicate) => state.then(predicate),
+        async () => seed(),
+      ),
+      mergeAll(),
+    );

package/src/main.ts

@@ -0,0 +1,225 @@
+import { nonNullable } from "@cascateer/lib";
+import filenamify from "filenamify";
+import { existsSync } from "fs";
+import { copyFile, mkdir, rm, writeFile } from "fs/promises";
+import { compact, isString } from "lodash";
+import NodeID3 from "node-id3";
+import { oraPromise } from "ora";
+import { resolve } from "path";
+import { SterioService } from "./Sterio.service";
+import { StreamFileTable } from "./tables";
+import { SterioAlbumFull } from "./types";
+
+const OUT_URL = resolve(__dirname, "../../..", "out");
+const OUT = process.argv.includes("--out");
+
+const run = async () => {
+  console.clear();
+
+  if (OUT && existsSync(OUT_URL)) {
+    await rm(OUT_URL, { recursive: true });
+  }
+
+  const albums = new Array<SterioAlbumFull>();
+
+  for (const sterioAlbum of await new SterioService().albums.accessAll()) {
+    if (sterioAlbum.resources?.youtubeMusic == null) {
+      continue;
+    }
+
+    albums.push(
+      await oraPromise(
+        async (spinner) => {
+          const album = await new SterioService().getAlbumFull(
+            sterioAlbum.id,
+            spinner,
+          );
+
+          const albumPath = resolve(
+            OUT_URL,
+            filenamify([album.artist.name, album.name].join(" - "), {
+              replacement: "",
+            }),
+          );
+
+          if (OUT) {
+            await mkdir(albumPath, { recursive: true });
+          }
+
+          for (const song of album.songs) {
+            if (song.excluded) {
+              continue;
+            }
+
+            if (OUT) {
+              const sourceFile = await new StreamFileTable().getFile(
+                nonNullable(song.tags.audioSourceUrl),
+                spinner,
+              );
+
+              const targetFile = resolve(
+                albumPath,
+                filenamify(
+                  `${compact([song.tags.trackNumber?.split("/")[0], song.tags.title]).join(" ")}${sourceFile.extname}`,
+                  { replacement: "" },
+                ),
+              );
+
+              await copyFile(sourceFile.path, targetFile).then(() =>
+                NodeID3.Promise.write(song.tags, targetFile),
+              );
+            }
+          }
+
+          return album;
+        },
+        {
+          text: `Processing...`,
+          prefixText: `[💿 Album ${sterioAlbum.id}]`,
+          successText: (album) => `Processed (${album.name}).`,
+        },
+      ),
+    );
+  }
+
+  return oraPromise(
+    Promise.resolve(albums).then((albums) =>
+      mkdir(OUT_URL, { recursive: true }).then(async () =>
+        Promise.resolve(resolve(OUT_URL, "index.html")).then((path) =>
+          writeFile(
+            path,
+            `
+                <!doctype html>
+                <html lang="en">
+                <head>
+                    <meta charset="utf-8" />
+                    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+                    <title>STERI📀COLLECTION</title>
+                    <style>
+                        body {
+                            background-color: black;
+                        }
+                        
+                        table, tr, td {
+                          border: 1px solid white;
+                        }
+        
+                        table {
+                          border-collapse: collapse;
+                          white-space: break-spaces;
+                        }
+  
+                        tr[data-row-index="0"] td {
+                          background-color: grey
+                        }
+
+                        tr[data-row-hidden="true"] {
+                          text-decoration: line-through;
+                        }
+  
+                        td {
+                          padding: 0.5em;
+                        }
+                    </style>
+                </head>
+                <body>
+                    <table>
+                        ${albums
+                          .map((album) => ({
+                            index:
+                              albums.findIndex(({ id }) => id === album.id) % 2,
+                            rows: album.songs.map((song, hash) => ({
+                              color: song.patched ? "blue" : "white",
+                              columns: Object.entries({
+                                albumArtwork: {
+                                  content: `<img width="60" src="${song.artwork.album?.path}">`,
+                                  hash: song.artwork.album?.checksum,
+                                },
+                                songArtwork: {
+                                  content: `<figure><img width="60" src="${song.artwork.song?.path}"><figcaption></figcaption>${song.artwork.song?.checksum.slice(-7)}</figure>`,
+                                  hash: song.artwork.song?.checksum,
+                                },
+                                channel: {
+                                  content: song.channel?.title,
+                                  hash: song.channel?.id,
+                                },
+                                trackNumber: song.tags.trackNumber,
+                                title: song.tags.title,
+                                duration: {
+                                  content: song.duration?.toISOString(),
+                                  hash,
+                                },
+                                album: [song.tags.album, album.id].join("\n"),
+                                year: song.tags.year,
+                                audioSourceUrl: {
+                                  content: `<a target="_blank" href="${song.tags.audioSourceUrl}">${song.tags.audioSourceUrl != null ? new URL(song.tags.audioSourceUrl).searchParams.get("v") : ""}</a>`,
+                                  hash: song.tags.audioSourceUrl,
+                                },
+                              }).flatMap(([key, column]) =>
+                                column != null
+                                  ? {
+                                      key,
+                                      ...(isString(column)
+                                        ? {
+                                            content: column,
+                                            hash: column,
+                                          }
+                                        : column),
+                                    }
+                                  : [],
+                              ),
+                              excluded: song.excluded,
+                            })),
+                          }))
+                          .flatMap((album) =>
+                            album.rows.map(
+                              (row, rowIndex, rows) =>
+                                `<tr data-row-index="${album.index}" data-row-hidden="${row.excluded}" style="color: ${row.color};">${row.columns
+                                  .flatMap(({ key, content, hash }) => {
+                                    if (
+                                      rows
+                                        .map((row) =>
+                                          nonNullable(
+                                            row.columns.find(
+                                              (column) => column.key === key,
+                                            ),
+                                          ),
+                                        )
+                                        .every((column) => column.hash === hash)
+                                    ) {
+                                      if (rowIndex > 0) {
+                                        return [];
+                                      }
+
+                                      return {
+                                        rowSpan: rows.length,
+                                        content,
+                                      };
+                                    }
+
+                                    return { rowSpan: 1, content };
+                                  })
+                                  .map(
+                                    ({ rowSpan, content }) =>
+                                      `<td rowspan="${rowSpan}">${content}</td>`,
+                                  )
+                                  .join("\n")}</tr>`,
+                            ),
+                          )
+                          .join("\n")}
+                    </table>
+                </body>
+                </html>`,
+          ).then(() => path),
+        ),
+      ),
+    ),
+    {
+      text: `Compiling...`,
+      prefixText: "[📒 Summary]",
+      successText: (path) => `Written to ${path}.`,
+    },
+  );
+};
+
+run();