@rocksky/cli 0.2.0 → 0.3.0

package/src/schema/genres.ts

@@ -0,0 +1,18 @@
+import { type InferInsertModel, type InferSelectModel, sql } from "drizzle-orm";
+import { integer, sqliteTable, text } from "drizzle-orm/sqlite-core";
+
+const genres = sqliteTable("genres", {
+  id: text("id").primaryKey().notNull(),
+  name: text("name").unique().notNull(),
+  createdAt: integer("created_at", { mode: "timestamp" })
+    .notNull()
+    .default(sql`(unixepoch())`),
+  updatedAt: integer("updated_at", { mode: "timestamp" })
+    .notNull()
+    .default(sql`(unixepoch())`),
+});
+
+export type SelectGenre = InferSelectModel<typeof genres>;
+export type InsertGenre = InferInsertModel<typeof genres>;
+
+export default genres;

package/src/schema/index.ts

@@ -0,0 +1,33 @@
+import albumTracks from "./album-tracks";
+import albums from "./albums";
+import artistAlbums from "./artist-albums";
+import artistGenres from "./artist-genres";
+import artistTracks from "./artist-tracks";
+import artists from "./artists";
+import authSessions from "./auth-session";
+import genres from "./genres";
+import lovedTracks from "./loved-tracks";
+import scrobbles from "./scrobbles";
+import tracks from "./tracks";
+import userAlbums from "./user-albums";
+import userArtists from "./user-artists";
+import userTracks from "./user-tracks";
+import users from "./users";
+
+export default {
+  users,
+  tracks,
+  artists,
+  albums,
+  albumTracks,
+  authSessions,
+  artistAlbums,
+  artistTracks,
+  lovedTracks,
+  scrobbles,
+  userAlbums,
+  userArtists,
+  userTracks,
+  genres,
+  artistGenres,
+};

package/src/schema/loved-tracks.ts

@@ -0,0 +1,27 @@
+import { type InferInsertModel, type InferSelectModel, sql } from "drizzle-orm";
+import { sqliteTable, integer, text, unique } from "drizzle-orm/sqlite-core";
+import tracks from "./tracks";
+import users from "./users";
+
+const lovedTracks = sqliteTable(
+  "loved_tracks",
+  {
+    id: text("id").primaryKey().notNull(),
+    userId: text("user_id")
+      .notNull()
+      .references(() => users.id),
+    trackId: text("track_id")
+      .notNull()
+      .references(() => tracks.id),
+    uri: text("uri").unique(),
+    createdAt: integer("created_at")
+      .notNull()
+      .default(sql`(unixepoch())`),
+  },
+  (t) => [unique("loved_tracks_unique_index").on(t.userId, t.trackId)],
+);
+
+export type SelectLovedTrack = InferSelectModel<typeof lovedTracks>;
+export type InsertLovedTrack = InferInsertModel<typeof lovedTracks>;
+
+export default lovedTracks;

package/src/schema/scrobbles.ts

@@ -0,0 +1,30 @@
+import { type InferInsertModel, type InferSelectModel, sql } from "drizzle-orm";
+import { integer, sqliteTable, text } from "drizzle-orm/sqlite-core";
+import albums from "./albums";
+import artists from "./artists";
+import tracks from "./tracks";
+import users from "./users";
+
+const scrobbles = sqliteTable("scrobbles", {
+  id: text("xata_id").primaryKey().notNull(),
+  userId: text("user_id").references(() => users.id),
+  trackId: text("track_id").references(() => tracks.id),
+  albumId: text("album_id").references(() => albums.id),
+  artistId: text("artist_id").references(() => artists.id),
+  uri: text("uri").unique(),
+  cid: text("cid").unique(),
+  createdAt: integer("created_at", { mode: "timestamp" })
+    .notNull()
+    .default(sql`(unixepoch())`),
+  updatedAt: integer("updated_at", { mode: "timestamp" })
+    .notNull()
+    .default(sql`(unixepoch())`),
+  timestamp: integer("timestamp", { mode: "timestamp" })
+    .notNull()
+    .default(sql`(unixepoch())`),
+});
+
+export type SelectScrobble = InferSelectModel<typeof scrobbles>;
+export type InsertScrobble = InferInsertModel<typeof scrobbles>;
+
+export default scrobbles;

package/src/schema/tracks.ts

@@ -0,0 +1,39 @@
+import { type InferInsertModel, type InferSelectModel, sql } from "drizzle-orm";
+import { integer, sqliteTable, text } from "drizzle-orm/sqlite-core";
+
+const tracks = sqliteTable("tracks", {
+  id: text("id").primaryKey().notNull(),
+  title: text("title").notNull(),
+  artist: text("artist").notNull(),
+  albumArtist: text("album_artist").notNull(),
+  albumArt: text("album_art"),
+  album: text("album").notNull(),
+  trackNumber: integer("track_number"),
+  duration: integer("duration").notNull(),
+  mbId: text("mb_id").unique(),
+  youtubeLink: text("youtube_link").unique(),
+  spotifyLink: text("spotify_link").unique(),
+  appleMusicLink: text("apple_music_link").unique(),
+  tidalLink: text("tidal_link").unique(),
+  discNumber: integer("disc_number"),
+  lyrics: text("lyrics"),
+  composer: text("composer"),
+  genre: text("genre"),
+  label: text("label"),
+  copyrightMessage: text("copyright_message"),
+  uri: text("uri").unique(),
+  cid: text("cid").unique().notNull(),
+  albumUri: text("album_uri"),
+  artistUri: text("artist_uri"),
+  createdAt: integer("created_at", { mode: "timestamp" })
+    .notNull()
+    .default(sql`(unixepoch())`),
+  updatedAt: integer("updated_at", { mode: "timestamp" })
+    .notNull()
+    .default(sql`(unixepoch())`),
+});
+
+export type SelectTrack = InferSelectModel<typeof tracks>;
+export type InsertTrack = InferInsertModel<typeof tracks>;
+
+export default tracks;

package/src/schema/user-albums.ts

@@ -0,0 +1,31 @@
+import { type InferInsertModel, type InferSelectModel, sql } from "drizzle-orm";
+import { integer, sqliteTable, text, unique } from "drizzle-orm/sqlite-core";
+import albums from "./albums";
+import users from "./users";
+
+const userAlbums = sqliteTable(
+  "user_albums",
+  {
+    id: text("id").primaryKey().notNull(),
+    userId: text("user_id")
+      .notNull()
+      .references(() => users.id),
+    albumId: text("album_id")
+      .notNull()
+      .references(() => albums.id),
+    createdAt: integer("created_at", { mode: "timestamp" })
+      .notNull()
+      .default(sql`(unixepoch())`),
+    updatedAt: integer("updated_at", { mode: "timestamp" })
+      .notNull()
+      .default(sql`(unixepoch())`),
+    scrobbles: integer("scrobbles"),
+    uri: text("uri").unique().notNull(),
+  },
+  (t) => [unique("user_albums_unique_index").on(t.userId, t.albumId)],
+);
+
+export type SelectUserAlbum = InferSelectModel<typeof userAlbums>;
+export type InsertUserAlbum = InferInsertModel<typeof userAlbums>;
+
+export default userAlbums;

package/src/schema/user-artists.ts

@@ -0,0 +1,32 @@
+import { type InferInsertModel, type InferSelectModel, sql } from "drizzle-orm";
+import { integer, sqliteTable, text, unique } from "drizzle-orm/sqlite-core";
+import artists from "./artists";
+import users from "./users";
+
+const userArtists = sqliteTable(
+  "user_artists",
+  {
+    id: text("id").primaryKey().notNull(),
+    userId: text("user_id")
+      .notNull()
+      .references(() => users.id),
+    artistId: text("artist_id")
+      .notNull()
+      .references(() => artists.id),
+    createdAt: integer("created_at", { mode: "timestamp" })
+      .notNull()
+      .default(sql`(unixepoch())`),
+    updatedAt: integer("updated_at", { mode: "timestamp" })
+      .notNull()
+      .default(sql`(unixepoch())`),
+    scrobbles: integer("scrobbles"),
+    uri: text("uri").unique().notNull(),
+  },
+
+  (t) => [unique("user_artists_unique_index").on(t.userId, t.artistId)],
+);
+
+export type SelectUserArtist = InferSelectModel<typeof userArtists>;
+export type InsertUserArtist = InferInsertModel<typeof userArtists>;
+
+export default userArtists;

package/src/schema/user-tracks.ts

@@ -0,0 +1,31 @@
+import { type InferInsertModel, type InferSelectModel, sql } from "drizzle-orm";
+import { integer, sqliteTable, text, unique } from "drizzle-orm/sqlite-core";
+import tracks from "./tracks";
+import users from "./users";
+
+const userTracks = sqliteTable(
+  "user_tracks",
+  {
+    id: text("id").primaryKey().notNull(),
+    userId: text("user_id")
+      .notNull()
+      .references(() => users.id),
+    trackId: text("track_id")
+      .notNull()
+      .references(() => tracks.id),
+    createdAt: integer("created_at", { mode: "timestamp" })
+      .notNull()
+      .default(sql`(unixepoch())`),
+    updatedAt: integer("updated_at", { mode: "timestamp" })
+      .notNull()
+      .default(sql`(unixepoch())`),
+    scrobbles: integer("scrobbles"),
+    uri: text("uri").unique().notNull(),
+  },
+  (t) => [unique("user_tracks_unique_index").on(t.userId, t.trackId)],
+);
+
+export type SelectUser = InferSelectModel<typeof userTracks>;
+export type InsertUserTrack = InferInsertModel<typeof userTracks>;
+
+export default userTracks;

package/src/schema/users.ts

@@ -0,0 +1,21 @@
+import { type InferSelectModel, sql } from "drizzle-orm";
+import { integer, sqliteTable, text } from "drizzle-orm/sqlite-core";
+
+const users = sqliteTable("users", {
+  id: text("id").primaryKey().notNull(),
+  did: text("did").unique().notNull(),
+  displayName: text("display_name"),
+  handle: text("handle").unique().notNull(),
+  avatar: text("avatar").notNull(),
+  createdAt: integer("created_at", { mode: "timestamp" })
+    .notNull()
+    .default(sql`(unixepoch())`),
+  updatedAt: integer("updated_at", { mode: "timestamp" })
+    .notNull()
+    .default(sql`(unixepoch())`),
+});
+
+export type SelectUser = InferSelectModel<typeof users>;
+export type InsertUser = InferSelectModel<typeof users>;
+
+export default users;

package/src/scrobble.ts

@@ -0,0 +1,410 @@
+import { MatchTrackResult } from "lib/matchTrack";
+import { logger } from "logger";
+import dayjs from "dayjs";
+import { createAgent } from "lib/agent";
+import { getDidAndHandle } from "lib/getDidAndHandle";
+import { ctx } from "context";
+import schema from "schema";
+import { and, eq, gte, lte, or, sql } from "drizzle-orm";
+import os from "node:os";
+import path from "node:path";
+import fs from "node:fs";
+import chalk from "chalk";
+import * as Album from "lexicon/types/app/rocksky/album";
+import * as Artist from "lexicon/types/app/rocksky/artist";
+import * as Scrobble from "lexicon/types/app/rocksky/scrobble";
+import * as Song from "lexicon/types/app/rocksky/song";
+import { TID } from "@atproto/common";
+import { Agent } from "@atproto/api";
+import { createUser, subscribeToJetstream, sync } from "cmd/sync";
+import _ from "lodash";
+
+export async function publishScrobble(
+  track: MatchTrackResult,
+  timestamp?: number,
+  dryRun?: boolean,
+) {
+  const [did, handle] = await getDidAndHandle();
+  const agent: Agent = await createAgent(did, handle);
+  const recentScrobble = await getRecentScrobble(did, track, timestamp);
+  const user = await createUser(agent, did, handle);
+  await subscribeToJetstream(user);
+
+  const lockFilePath = path.join(os.tmpdir(), `rocksky-${did}.lock`);
+
+  if (fs.existsSync(lockFilePath)) {
+    logger.error(
+      `${chalk.greenBright(handle)} Scrobble publishing failed: lock file exists, maybe rocksky-cli is still syncing?\nPlease wait for rocksky to finish syncing before publishing scrobbles or delete the lock file manually ${chalk.greenBright(lockFilePath)}`,
+    );
+    return false;
+  }
+
+  if (recentScrobble) {
+    logger.info`${handle} Skipping scrobble for ${track.title} by ${track.artist} at ${timestamp ? dayjs.unix(timestamp).format("YYYY-MM-DD HH:mm:ss") : dayjs().format("YYYY-MM-DD HH:mm:ss")} (already scrobbled)`;
+    return true;
+  }
+
+  const totalScrobbles = await countScrobbles(did);
+  if (totalScrobbles === 0) {
+    logger.warn`${handle} No scrobbles found for this user. Are you sure you have successfully synced your scrobbles locally?\nIf not, please run ${"rocksky sync"} to sync your scrobbles before publishing scrobbles.`;
+  }
+
+  logger.info`${handle} Publishing scrobble for ${track.title} by ${track.artist} at ${timestamp ? dayjs.unix(timestamp).format("YYYY-MM-DD HH:mm:ss") : dayjs().format("YYYY-MM-DD HH:mm:ss")}`;
+
+  if (await shouldSync(agent)) {
+    logger.info`${handle} Syncing scrobbles before publishing`;
+    await sync();
+  } else {
+    logger.info`${handle} Local scrobbles are up-to-date, skipping sync`;
+  }
+
+  if (dryRun) {
+    logger.info`${handle} Dry run: Skipping publishing scrobble for ${track.title} by ${track.artist} at ${timestamp ? dayjs.unix(timestamp).format("YYYY-MM-DD HH:mm:ss") : dayjs().format("YYYY-MM-DD HH:mm:ss")}`;
+    return true;
+  }
+
+  const existingTrack = await ctx.db
+    .select()
+    .from(schema.tracks)
+    .where(
+      or(
+        and(
+          sql`LOWER(${schema.tracks.title}) = LOWER(${track.title})`,
+          sql`LOWER(${schema.tracks.artist}) = LOWER(${track.artist})`,
+        ),
+        and(
+          sql`LOWER(${schema.tracks.title}) = LOWER(${track.title})`,
+          sql`LOWER(${schema.tracks.albumArtist}) = LOWER(${track.artist})`,
+        ),
+        and(
+          sql`LOWER(${schema.tracks.title}) = LOWER(${track.title})`,
+          sql`LOWER(${schema.tracks.albumArtist}) = LOWER(${track.albumArtist})`,
+        ),
+      ),
+    )
+    .limit(1)
+    .execute()
+    .then((rows) => rows[0]);
+
+  if (!existingTrack) {
+    await putSongRecord(agent, track);
+  }
+
+  const existingArtist = await ctx.db
+    .select()
+    .from(schema.artists)
+    .where(
+      or(
+        sql`LOWER(${schema.artists.name}) = LOWER(${track.artist})`,
+        sql`LOWER(${schema.artists.name}) = LOWER(${track.albumArtist})`,
+      ),
+    )
+    .limit(1)
+    .execute()
+    .then((rows) => rows[0]);
+
+  if (!existingArtist) {
+    await putArtistRecord(agent, track);
+  }
+
+  const existingAlbum = await ctx.db
+    .select()
+    .from(schema.albums)
+    .where(
+      and(
+        sql`LOWER(${schema.albums.title}) = LOWER(${track.album})`,
+        sql`LOWER(${schema.albums.artist}) = LOWER(${track.albumArtist})`,
+      ),
+    )
+    .limit(1)
+    .execute()
+    .then((rows) => rows[0]);
+
+  if (!existingAlbum) {
+    await putAlbumRecord(agent, track);
+  }
+
+  const scrobbleUri = await putScrobbleRecord(agent, track, timestamp);
+
+  // wait for the scrobble to be published
+  if (scrobbleUri) {
+    const MAX_ATTEMPTS = 40;
+    let attempts = 0;
+    do {
+      const count = await ctx.db
+        .select({
+          count: sql`COUNT(*)`,
+        })
+        .from(schema.scrobbles)
+        .where(eq(schema.scrobbles.uri, scrobbleUri))
+        .execute()
+        .then((rows) => _.get(rows, "[0].count", 0) as number);
+
+      if (count > 0 || attempts >= MAX_ATTEMPTS) {
+        if (attempts == MAX_ATTEMPTS) {
+          logger.error`Failed to detect published scrobble after ${MAX_ATTEMPTS} attempts`;
+        }
+        break;
+      }
+
+      await new Promise((resolve) => setTimeout(resolve, 600));
+      attempts += 1;
+    } while (true);
+  }
+
+  return true;
+}
+
+async function getRecentScrobble(
+  did: string,
+  track: MatchTrackResult,
+  timestamp?: number,
+) {
+  const scrobbleTime = dayjs.unix(timestamp || dayjs().unix());
+  return ctx.db
+    .select({
+      scrobble: schema.scrobbles,
+      user: schema.users,
+      track: schema.tracks,
+    })
+    .from(schema.scrobbles)
+    .innerJoin(schema.users, eq(schema.scrobbles.userId, schema.users.id))
+    .innerJoin(schema.tracks, eq(schema.scrobbles.trackId, schema.tracks.id))
+    .where(
+      and(
+        eq(schema.users.did, did),
+        sql`LOWER(${schema.tracks.title}) = LOWER(${track.title})`,
+        sql`LOWER(${schema.tracks.artist}) = LOWER(${track.artist})`,
+        gte(
+          schema.scrobbles.timestamp,
+          scrobbleTime.subtract(60, "seconds").toDate(),
+        ),
+        lte(
+          schema.scrobbles.timestamp,
+          scrobbleTime.add(60, "seconds").toDate(),
+        ),
+      ),
+    )
+    .limit(1)
+    .then((rows) => rows[0]);
+}
+
+async function countScrobbles(did: string): Promise<number> {
+  return ctx.db
+    .select({ count: sql<number>`count(*)` })
+    .from(schema.scrobbles)
+    .innerJoin(schema.users, eq(schema.scrobbles.userId, schema.users.id))
+    .where(eq(schema.users.did, did))
+    .then((rows) => rows[0].count);
+}
+
+async function putSongRecord(agent: Agent, track: MatchTrackResult) {
+  const rkey = TID.nextStr();
+
+  const record: Song.Record = {
+    $type: "app.rocksky.song",
+    title: track.title,
+    artist: track.artist,
+    artists: track.mbArtists === null ? undefined : track.mbArtists,
+    album: track.album,
+    albumArtist: track.albumArtist,
+    duration: track.duration,
+    releaseDate: track.releaseDate
+      ? new Date(track.releaseDate).toISOString()
+      : undefined,
+    year: track.year === null ? undefined : track.year,
+    albumArtUrl: track.albumArt,
+    composer: track.composer ? track.composer : undefined,
+    lyrics: track.lyrics ? track.lyrics : undefined,
+    trackNumber: track.trackNumber,
+    discNumber: track.discNumber === 0 ? 1 : track.discNumber,
+    copyrightMessage: track.copyrightMessage
+      ? track.copyrightMessage
+      : undefined,
+    createdAt: new Date().toISOString(),
+    spotifyLink: track.spotifyLink ? track.spotifyLink : undefined,
+    tags: track.genres || [],
+    mbid: track.mbId,
+  };
+
+  if (!Song.validateRecord(record).success) {
+    logger.info`${Song.validateRecord(record)}`;
+    logger.info`${record}`;
+    throw new Error("Invalid Song record");
+  }
+
+  try {
+    const res = await agent.com.atproto.repo.putRecord({
+      repo: agent.assertDid,
+      collection: "app.rocksky.song",
+      rkey,
+      record,
+      validate: false,
+    });
+    const uri = res.data.uri;
+    logger.info`Song record created at ${uri}`;
+    return uri;
+  } catch (e) {
+    logger.error`Error creating song record: ${e}`;
+    return null;
+  }
+}
+
+async function putArtistRecord(agent: Agent, track: MatchTrackResult) {
+  const rkey = TID.nextStr();
+  const record: Artist.Record = {
+    $type: "app.rocksky.artist",
+    name: track.albumArtist,
+    createdAt: new Date().toISOString(),
+    pictureUrl: track.artistPicture || undefined,
+    tags: track.genres || [],
+  };
+
+  if (!Artist.validateRecord(record).success) {
+    logger.info`${Artist.validateRecord(record)}`;
+    logger.info`${record}`;
+    throw new Error("Invalid Artist record");
+  }
+
+  try {
+    const res = await agent.com.atproto.repo.putRecord({
+      repo: agent.assertDid,
+      collection: "app.rocksky.artist",
+      rkey,
+      record,
+      validate: false,
+    });
+    const uri = res.data.uri;
+    logger.info`Artist record created at ${uri}`;
+    return uri;
+  } catch (e) {
+    logger.error`Error creating artist record: ${e}`;
+    return null;
+  }
+}
+
+async function putAlbumRecord(agent: Agent, track: MatchTrackResult) {
+  const rkey = TID.nextStr();
+
+  const record = {
+    $type: "app.rocksky.album",
+    title: track.album,
+    artist: track.albumArtist,
+    year: track.year === null ? undefined : track.year,
+    releaseDate: track.releaseDate
+      ? new Date(track.releaseDate).toISOString()
+      : undefined,
+    createdAt: new Date().toISOString(),
+    albumArtUrl: track.albumArt,
+  };
+
+  if (!Album.validateRecord(record).success) {
+    logger.info`${Album.validateRecord(record)}`;
+    logger.info`${record}`;
+    throw new Error("Invalid Album record");
+  }
+
+  try {
+    const res = await agent.com.atproto.repo.putRecord({
+      repo: agent.assertDid,
+      collection: "app.rocksky.album",
+      rkey,
+      record,
+      validate: false,
+    });
+    const uri = res.data.uri;
+    logger.info`Album record created at ${uri}`;
+    return uri;
+  } catch (e) {
+    logger.error`Error creating album record: ${e}`;
+    return null;
+  }
+}
+
+async function putScrobbleRecord(
+  agent: Agent,
+  track: MatchTrackResult,
+  timestamp?: number,
+) {
+  const rkey = TID.nextStr();
+
+  const record: Scrobble.Record = {
+    $type: "app.rocksky.scrobble",
+    title: track.title,
+    albumArtist: track.albumArtist,
+    albumArtUrl: track.albumArt,
+    artist: track.artist,
+    artists: track.mbArtists === null ? undefined : track.mbArtists,
+    album: track.album,
+    duration: track.duration,
+    trackNumber: track.trackNumber,
+    discNumber: track.discNumber === 0 ? 1 : track.discNumber,
+    releaseDate: track.releaseDate
+      ? new Date(track.releaseDate).toISOString()
+      : undefined,
+    year: track.year === null ? undefined : track.year,
+    composer: track.composer ? track.composer : undefined,
+    lyrics: track.lyrics ? track.lyrics : undefined,
+    copyrightMessage: track.copyrightMessage
+      ? track.copyrightMessage
+      : undefined,
+    createdAt: timestamp
+      ? dayjs.unix(timestamp).toISOString()
+      : new Date().toISOString(),
+    spotifyLink: track.spotifyLink ? track.spotifyLink : undefined,
+    tags: track.genres || [],
+    mbid: track.mbId,
+  };
+
+  if (!Scrobble.validateRecord(record).success) {
+    logger.info`${Scrobble.validateRecord(record)}`;
+    logger.info`${record}`;
+    throw new Error("Invalid Scrobble record");
+  }
+
+  try {
+    const res = await agent.com.atproto.repo.putRecord({
+      repo: agent.assertDid,
+      collection: "app.rocksky.scrobble",
+      rkey,
+      record,
+      validate: false,
+    });
+    const uri = res.data.uri;
+    logger.info`Scrobble record created at ${uri}`;
+    return uri;
+  } catch (e) {
+    logger.error`Error creating scrobble record: ${e}`;
+    return null;
+  }
+}
+
+async function shouldSync(agent: Agent): Promise<boolean> {
+  const res = await agent.com.atproto.repo.listRecords({
+    repo: agent.assertDid,
+    collection: "app.rocksky.scrobble",
+    limit: 1,
+  });
+
+  const records = res.data.records as Array<{
+    uri: string;
+    cid: string;
+    value: Scrobble.Record;
+  }>;
+
+  if (!records.length) {
+    logger.info`No scrobble records found`;
+    return true;
+  }
+
+  const { count } = await ctx.db
+    .select({
+      count: sql<number>`count(*)`,
+    })
+    .from(schema.scrobbles)
+    .where(eq(schema.scrobbles.cid, records[0].cid))
+    .execute()
+    .then((result) => result[0]);
+
+  return count === 0;
+}