@cascateer/sterio 1.0.1

package/src/tables.ts

@@ -0,0 +1,178 @@
+import {
+  createFileTable,
+  createTable,
+  defaults,
+  File,
+} from "@cascateer/database";
+import { nonNullable, nonNullableAsync } from "@cascateer/lib";
+import { LazyPromise } from "@cascateer/lib/promise";
+import { writeFile } from "fs/promises";
+import { compact, truncate, uniq } from "lodash";
+import { extension } from "mime-types";
+import objectHash from "object-hash";
+import { resolve } from "path";
+import { helpers, YtDlp } from "ytdlp-nodejs";
+import { tapPromise } from "./lib";
+import { SpotifyService } from "./Spotify.service";
+import {
+  SpotifyAlbum,
+  SterioAlbum,
+  YoutubeMusicAlbum,
+  YoutubePlaylist,
+  YoutubeVideo,
+} from "./types";
+import { YoutubeService } from "./Youtube.service";
+import { YoutubeMusicService } from "./YoutubeMusic.service";
+
+defaults.FILE_BASE_URL = resolve(__dirname, "../../..", "files");
+
+const SpotifyAlbumTable = createTable<SpotifyAlbum, "id">(
+  "spotify-albums",
+  "id",
+  (ids) => new SpotifyService().getAlbums(ids),
+);
+
+const SterioAlbumTable = createTable<SterioAlbum, "id">(
+  "sterio-albums",
+  "id",
+  (ids) => ids.map((id) => ({ id })),
+);
+
+const YoutubePlaylistTable = createTable<YoutubePlaylist, "id">(
+  "youtube-playlists",
+  "id",
+  (ids) =>
+    LazyPromise.concatAll(
+      ids.map(
+        (id) => new LazyPromise(() => new YoutubeService().getPlaylist(id)),
+      ),
+    ),
+);
+
+const YoutubeVideoTable = createTable<YoutubeVideo, "id">(
+  "youtube-videos",
+  "id",
+  (ids) => new YoutubeService().getVideos(compact(ids)),
+);
+
+const YoutubeMusicAlbumTable = createTable<YoutubeMusicAlbum, "albumId">(
+  "youtube-music-albums",
+  "albumId",
+  (albumIds) =>
+    Promise.all(
+      uniq(albumIds).map((albumId) =>
+        new YoutubeMusicService().getAlbum(albumId),
+      ),
+    ),
+);
+
+const DocumentFileTable = createFileTable("document-files", (urls, spinner) =>
+  LazyPromise.concatAll(
+    uniq(urls).map(
+      (url) =>
+        new LazyPromise(() =>
+          tapPromise(
+            fetch(url).then((response) =>
+              response.arrayBuffer().then((buffer) =>
+                Promise.resolve(
+                  new File(
+                    [
+                      objectHash(url),
+                      extension(
+                        nonNullable(response.headers.get("content-type")),
+                      ),
+                    ].join("."),
+                  ),
+                ).then((file) =>
+                  writeFile(
+                    file.path,
+                    Buffer.from(buffer).toString("base64"),
+                    "base64",
+                  )
+                    .then(() => file.hash())
+                    .then((checksum) => ({
+                      url,
+                      name: file.name,
+                      checksum,
+                    })),
+                ),
+              ),
+            ),
+            {
+              start: () => {
+                if (spinner != null) {
+                  spinner.text = truncate(`Loading document from ${url}.`, {
+                    length: 50,
+                  });
+                }
+              },
+              finish: ({ name }) => {
+                if (spinner != null) {
+                  spinner.text = `Document written to ${new File(name)}.`;
+                }
+              },
+            },
+          ),
+        ),
+    ),
+  ),
+);
+
+const StreamFileTable = createFileTable("stream-files", (urls, spinner) =>
+  LazyPromise.concatAll(
+    uniq(urls).map(
+      (url) =>
+        new LazyPromise(() =>
+          tapPromise(
+            helpers.downloadFFmpeg().then(() =>
+              new YtDlp()
+                .download(url, {
+                  format: {
+                    filter: "audioonly",
+                    type: "mp3",
+                  },
+                  output: resolve(File.BASE_URL, "%(id)s.%(ext)s"),
+                })
+                .on("progress", ({ percentage }) => {
+                  if (spinner != null && percentage != null) {
+                    spinner.text = `Streaming from ${url} (${percentage.toFixed()}% completed).`;
+                  }
+                })
+                .then(({ filePaths: [path] }) =>
+                  nonNullableAsync(path).then(File.fromPath),
+                )
+                .then((file) =>
+                  file.hash().then((checksum) => ({
+                    url,
+                    name: file.name,
+                    checksum,
+                  })),
+                ),
+            ),
+            {
+              start: () => {
+                if (spinner != null) {
+                  spinner.text = `Streaming from ${url}.`;
+                }
+              },
+              finish: ({ name }) => {
+                if (spinner != null) {
+                  spinner.text = `Stream written to ${new File(name)}.`;
+                }
+              },
+            },
+          ),
+        ),
+    ),
+  ),
+);
+
+export {
+  DocumentFileTable,
+  SpotifyAlbumTable,
+  SterioAlbumTable,
+  StreamFileTable,
+  YoutubeMusicAlbumTable,
+  YoutubePlaylistTable,
+  YoutubeVideoTable,
+};

package/src/types.ts

@@ -0,0 +1,113 @@
+import { youtube_v3 } from "googleapis";
+import { Tags } from "node-id3";
+import SpotifyWebApi from "spotify-web-api-node";
+import { AlbumFull } from "ytmusic-api";
+
+export type SpotifyGrant = Partial<
+  Awaited<ReturnType<SpotifyWebApi["authorizationCodeGrant"]>>["body"]
+>;
+
+export type SpotifyAlbum = SpotifyApi.AlbumObjectFull;
+
+export class SterioDuration {
+  constructor(
+    public minutes: number,
+    public seconds: number,
+  ) {}
+
+  get totalSeconds(): number {
+    return this.minutes * 60 + this.seconds;
+  }
+
+  get totalMilliseconds(): number {
+    return this.totalSeconds * 1e3;
+  }
+
+  toISOString() {
+    return [this.minutes, this.seconds]
+      .map((t) => t.toString().padStart(2, "0"))
+      .join(":");
+  }
+
+  static fromPeriodOfTime(duration?: string | null) {
+    const { minutes, seconds } =
+      duration?.match(/^PT(?:(?<minutes>\d+)M)?(?:(?<seconds>\d+)S)?$/)
+        ?.groups ?? {};
+
+    if (minutes != null || seconds != null) {
+      return new SterioDuration(+(minutes ?? 0), +(seconds ?? 0));
+    }
+  }
+}
+
+export interface SterioAlbumResource {
+  id: string;
+  iteratee?: string;
+}
+
+export interface SterioAlbumResourcesFull extends Record<
+  "youtubeMusic" | "youtube" | "spotify",
+  SterioAlbumResource
+> {}
+
+export type SterioAlbumResources = Partial<SterioAlbumResourcesFull>;
+
+export interface SterioAlbumResourcesTable extends Record<
+  keyof SterioAlbumResourcesFull,
+  string[]
+> {}
+
+export interface SterioAlbum {
+  id: string;
+  resources?: SterioAlbumResources;
+  songs?: {
+    videoIds?: {
+      index: number;
+      expectedValue: string;
+      newValue: string;
+    }[];
+    include?: number[];
+    exclude?: number[];
+  };
+}
+
+export interface SterioAlbumFull
+  extends
+    Omit<SterioAlbum, "resources" | "songs">,
+    Omit<YoutubeMusicAlbum, "albumId" | "songs"> {
+  songs: SterioSongFull[];
+}
+
+export interface SterioSongFull {
+  videoId: string;
+  patched?: boolean;
+  excluded?: boolean;
+  channel?: {
+    id?: string;
+    title?: string;
+  };
+  artwork: Partial<
+    Record<
+      "album" | "song",
+      {
+        path: string;
+        checksum: string;
+      }
+    >
+  >;
+  duration?: SterioDuration;
+  tags: Tags;
+}
+
+export type YoutubeMusicAlbum = Pick<
+  AlbumFull,
+  "albumId" | "artist" | "name" | "songs" | "thumbnails" | "year"
+>;
+
+export interface YoutubePlaylist {
+  id: string;
+  title?: string;
+  items: youtube_v3.Schema$PlaylistItem[];
+}
+
+export type YoutubeVideo = youtube_v3.Schema$Video;

package/src/views/spotify/auth-callback.ejs

@@ -0,0 +1,22 @@
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>Page Title</title>
+  <link rel="stylesheet" href="main.css" />
+</head>
+
+<body>
+  <% if (code) { %>
+  Received grant code
+  <pre><%= code %></pre>
+  <% } else { %>
+  Could not obtain grant code.
+  <pre>:-(</pre>
+  <% } %>
+  You can now close this page.
+</body>
+
+</html>