feat: add artists property to song and scrobble records for MusicBrainz IDs

apps/api/lexicons/artist/defs.json

···
           "minimum": 1
         }
       }
+    },
+    "artists": {
+      "type": "object",
+      "properties": {
+        "mbid": {
+          "type": "string",
+          "description": "The MusicBrainz Identifier (MBID) of the artist."
+        },
+        "name": {
+          "type": "string",
+          "description": "The name of the artist.",
+          "minLength": 1,
+          "maxLength": 256
+        }
+      }
     }
   }
 }

apps/api/lexicons/scrobble/scrobble.json

···
             "minLength": 1,
             "maxLength": 256
           },
+          "artists": {
+            "type": "array",
+            "description": "The artists of the song with MusicBrainz IDs.",
+            "items": {
+              "type": "ref",
+              "ref": "app.rocksky.artist.defs#artistMbid"
+            }
+          },
           "albumArtist": {
             "type": "string",
             "description": "The album artist of the song.",

apps/api/lexicons/song/song.json

···
             "minLength": 1,
             "maxLength": 256
           },
+          "artists": {
+            "type": "array",
+            "description": "The artists of the song with MusicBrainz IDs.",
+            "items": {
+              "type": "ref",
+              "ref": "app.rocksky.artist.defs#artistMbid"
+            }
+          },
           "albumArtist": {
             "type": "string",
             "description": "The album artist of the song.",

apps/api/pkl/defs/artist/defs.pkl

···
 
     }
   }
+
+  ["artists"] {
+    type = "object"
+    properties {
+      ["mbid"] = new StringType {
+        type = "string"
+        description = "The MusicBrainz Identifier (MBID) of the artist."
+      }
+      ["name"] = new StringType {
+        type = "string"
+        description = "The name of the artist."
+        minLength = 1
+        maxLength = 256
+      }
+    }
+  }
 }

apps/api/pkl/defs/scrobble/scrobble.pkl

···
           maxLength = 256
         }
 
+
+
+        ["artists"] = new Array {
+          type = "array"
+          description = "The artists of the song with MusicBrainz IDs."
+          items = new Ref {
+            ref = "app.rocksky.artist.defs#artistMbid"
+          }
+        }
+
         ["albumArtist"] = new StringType {
           type = "string"
           description = "The album artist of the song."

apps/api/pkl/defs/song/song.pkl

···
           maxLength = 256
         }
 
+        ["artists"] = new Array {
+          type = "array"
+          description = "The artists of the song with MusicBrainz IDs."
+          items = new Ref {
+            ref = "app.rocksky.artist.defs#artistMbid"
+          }
+        }
+
         ["albumArtist"] = new StringType {
           type = "string"
           description = "The album artist of the song."

apps/api/src/lexicon/lexicons.ts

···
           },
         },
       },
+      artists: {
+        type: "object",
+        properties: {
+          mbid: {
+            type: "string",
+            description: "The MusicBrainz Identifier (MBID) of the artist.",
+          },
+          name: {
+            type: "string",
+            description: "The name of the artist.",
+            minLength: 1,
+            maxLength: 256,
+          },
+        },
+      },
     },
   },
   AppRockskyArtistGetArtistAlbums: {
···
               minLength: 1,
               maxLength: 256,
             },
+            artists: {
+              type: "array",
+              description: "The artists of the song with MusicBrainz IDs.",
+              items: {
+                type: "ref",
+                ref: "lex:app.rocksky.artist.defs#artistMbid",
+              },
+            },
             albumArtist: {
               type: "string",
               description: "The album artist of the song.",
···
               description: "The artist of the song.",
               minLength: 1,
               maxLength: 256,
+            },
+            artists: {
+              type: "array",
+              description: "The artists of the song with MusicBrainz IDs.",
+              items: {
+                type: "ref",
+                ref: "lex:app.rocksky.artist.defs#artistMbid",
+              },
             },
             albumArtist: {
               type: "string",

apps/api/src/lexicon/types/app/rocksky/artist/defs.ts

···
 export function validateListenerViewBasic(v: unknown): ValidationResult {
   return lexicons.validate("app.rocksky.artist.defs#listenerViewBasic", v);
 }
+
+export interface Artists {
+  /** The MusicBrainz Identifier (MBID) of the artist. */
+  mbid?: string;
+  /** The name of the artist. */
+  name?: string;
+  [k: string]: unknown;
+}
+
+export function isArtists(v: unknown): v is Artists {
+  return (
+    isObj(v) &&
+    hasProp(v, "$type") &&
+    v.$type === "app.rocksky.artist.defs#artists"
+  );
+}
+
+export function validateArtists(v: unknown): ValidationResult {
+  return lexicons.validate("app.rocksky.artist.defs#artists", v);
+}

apps/api/src/lexicon/types/app/rocksky/scrobble.ts

···
 import { lexicons } from "../../../lexicons";
 import { isObj, hasProp } from "../../../util";
 import { CID } from "multiformats/cid";
+import type * as AppRockskyArtistDefs from "./artist/defs";
 
 export interface Record {
   /** The title of the song. */
   title: string;
   /** The artist of the song. */
   artist: string;
+  /** The artists of the song with MusicBrainz IDs. */
+  artists?: AppRockskyArtistDefs.ArtistMbid[];
   /** The album artist of the song. */
   albumArtist: string;
   /** The album of the song. */

apps/api/src/lexicon/types/app/rocksky/song.ts

···
 import { lexicons } from "../../../lexicons";
 import { isObj, hasProp } from "../../../util";
 import { CID } from "multiformats/cid";
+import type * as AppRockskyArtistDefs from "./artist/defs";
 
 export interface Record {
   /** The title of the song. */
   title: string;
   /** The artist of the song. */
   artist: string;
+  /** The artists of the song with MusicBrainz IDs. */
+  artists?: AppRockskyArtistDefs.ArtistMbid[];
   /** The album artist of the song. */
   albumArtist: string;
   /** The album of the song. */

apps/api/src/nowplaying/nowplaying.service.ts

···
 
 export async function putArtistRecord(
   track: Track,
-  agent: Agent
+  agent: Agent,
 ): Promise<string | null> {
   const rkey = TID.nextStr();
   const record: Artist.Record = {
···
 
 export async function putAlbumRecord(
   track: Track,
-  agent: Agent
+  agent: Agent,
 ): Promise<string | null> {
   const rkey = TID.nextStr();
 
···
 
 export async function putSongRecord(
   track: Track,
-  agent: Agent
+  agent: Agent,
 ): Promise<string | null> {
   const rkey = TID.nextStr();
 
···
     $type: "app.rocksky.song",
     title: track.title,
     artist: track.artist,
+    artists: track.artists === null ? undefined : track.artists,
     album: track.album,
     albumArtist: track.albumArtist,
     duration: track.duration,
···
 
 async function putScrobbleRecord(
   track: Track,
-  agent: Agent
+  agent: Agent,
 ): Promise<string | null> {
   const rkey = TID.nextStr();
 
···
     albumArtist: track.albumArtist,
     albumArtUrl: track.albumArt,
     artist: track.artist,
+    artists: track.artists === null ? undefined : track.artists,
     album: track.album,
     duration: track.duration,
     trackNumber: track.trackNumber,
···
       .where(
         and(
           eq(artistAlbums.albumId, scrobble.album.id),
-          eq(artistAlbums.artistId, scrobble.artist.id)
-        )
+          eq(artistAlbums.artistId, scrobble.artist.id),
+        ),
       )
       .limit(1)
       .then((rows) => rows[0]),
···
       },
     }),
     null,
-    2
+    2,
   );
 
   ctx.nc.publish(
     "rocksky.scrobble",
-    Buffer.from(message.replaceAll("sha_256", "sha256"))
+    Buffer.from(message.replaceAll("sha_256", "sha256")),
   );
 
   const trackMessage = JSON.stringify(
···
         xata_createdat: artist_album.createdAt.toISOString(),
         xata_updatedat: artist_album.updatedAt.toISOString(),
       },
-    })
+    }),
   );
 
   ctx.nc.publish(
     "rocksky.track",
-    Buffer.from(trackMessage.replaceAll("sha_256", "sha256"))
+    Buffer.from(trackMessage.replaceAll("sha_256", "sha256")),
   );
 }
 
···
   ctx: Context,
   track: Track,
   agent: Agent,
-  userDid: string
+  userDid: string,
 ): Promise<void> {
   // check if scrobble already exists (user did + timestamp)
   const scrobbleTime = dayjs.unix(track.timestamp || dayjs().unix());
···
         eq(tracks.title, track.title),
         eq(tracks.artist, track.artist),
         gte(scrobbles.timestamp, scrobbleTime.subtract(5, "seconds").toDate()),
-        lte(scrobbles.timestamp, scrobbleTime.add(5, "seconds").toDate())
-      )
+        lte(scrobbles.timestamp, scrobbleTime.add(5, "seconds").toDate()),
+      ),
     )
     .limit(1)
     .then((rows) => rows[0]);
···
   if (existingScrobble) {
     console.log(
       `Scrobble already exists for ${chalk.cyan(track.title)} at ${chalk.cyan(
-        scrobbleTime.format("YYYY-MM-DD HH:mm:ss")
-      )}`
+        scrobbleTime.format("YYYY-MM-DD HH:mm:ss"),
+      )}`,
     );
     return;
   }
···
         tracks.sha256,
         createHash("sha256")
           .update(
-            `${track.title} - ${track.artist} - ${track.album}`.toLowerCase()
+            `${track.title} - ${track.artist} - ${track.album}`.toLowerCase(),
           )
-          .digest("hex")
-      )
+          .digest("hex"),
+      ),
     )
     .limit(1)
     .then((rows) => rows[0]);
···
           albums.sha256,
           createHash("sha256")
             .update(`${track.album} - ${track.albumArtist}`.toLowerCase())
-            .digest("hex")
-        )
+            .digest("hex"),
+        ),
       )
       .limit(1)
       .then((rows) => rows[0]);
···
           artists.sha256,
           createHash("sha256")
             .update(track.albumArtist.toLowerCase())
-            .digest("hex")
-        )
+            .digest("hex"),
+        ),
       )
       .limit(1)
       .then((rows) => rows[0]);
···
       artist: track.artist.split(",").map((a) => ({ name: a.trim() })),
       name: track.title,
       album: track.album,
-    }
+    },
   );
 
   if (!mbTrack?.trackMBID) {
···
   }
 
   track.mbId = mbTrack?.trackMBID;
+  track.artists = mbTrack?.artist?.map((artist) => ({
+    mbid: artist.mbid,
+    name: artist.name,
+  }));
 
   if (!existingTrack?.uri || !userTrack?.userTrack.uri?.includes(userDid)) {
     await putSongRecord(track, agent);
···
         albums.sha256,
         createHash("sha256")
           .update(`${track.album} - ${track.albumArtist}`.toLowerCase())
-          .digest("hex")
-      )
+          .digest("hex"),
+      ),
     )
     .limit(1)
     .then((rows) => rows[0]);
···
           tracks.sha256,
           createHash("sha256")
             .update(
-              `${track.title} - ${track.artist} - ${track.album}`.toLowerCase()
+              `${track.title} - ${track.artist} - ${track.album}`.toLowerCase(),
             )
-            .digest("hex")
-        )
+            .digest("hex"),
+        ),
       )
       .limit(1)
       .then((rows) => rows[0]);
···
 
   if (existingTrack) {
     console.log(
-      `Song found: ${chalk.cyan(existingTrack.id)} - ${track.title}, after ${chalk.magenta(tries)} tries`
+      `Song found: ${chalk.cyan(existingTrack.id)} - ${track.title}, after ${chalk.magenta(tries)} tries`,
     );
   }
 
···
           artists.sha256,
           createHash("sha256")
             .update(track.albumArtist.toLowerCase())
-            .digest("hex")
+            .digest("hex"),
         ),
         eq(
           artists.sha256,
-          createHash("sha256").update(track.artist.toLowerCase()).digest("hex")
-        )
-      )
+          createHash("sha256").update(track.artist.toLowerCase()).digest("hex"),
+        ),
+      ),
     )
     .limit(1)
     .then((rows) => rows[0]);
···
     .innerJoin(artists, eq(userArtists.artistId, artists.id))
     .innerJoin(users, eq(userArtists.userId, users.id))
     .where(
-      and(eq(artists.id, existingArtist?.id || ""), eq(users.did, userDid))
+      and(eq(artists.id, existingArtist?.id || ""), eq(users.did, userDid)),
     )
     .limit(1)
     .then((rows) => rows[0]);
···
         tracks.sha256,
         createHash("sha256")
           .update(
-            `${track.title} - ${track.artist} - ${track.album}`.toLowerCase()
+            `${track.title} - ${track.artist} - ${track.album}`.toLowerCase(),
           )
-          .digest("hex")
-      )
+          .digest("hex"),
+      ),
     )
     .limit(1)
     .then((rows) => rows[0]);
 
   while (!existingTrack?.artistUri && !existingTrack?.albumUri && tries < 30) {
     console.log(
-      `Artist uri not ready, trying again: ${chalk.magenta(tries + 1)}`
+      `Artist uri not ready, trying again: ${chalk.magenta(tries + 1)}`,
     );
     existingTrack = await ctx.db
       .select()
···
           tracks.sha256,
           createHash("sha256")
             .update(
-              `${track.title} - ${track.artist} - ${track.album}`.toLowerCase()
+              `${track.title} - ${track.artist} - ${track.album}`.toLowerCase(),
             )
-            .digest("hex")
-        )
+            .digest("hex"),
+        ),
       )
       .limit(1)
       .then((rows) => rows[0]);
···
             artists.sha256,
             createHash("sha256")
               .update(track.albumArtist.toLowerCase())
-              .digest("hex")
-          )
+              .digest("hex"),
+          ),
         )
         .limit(1)
         .then((rows) => rows[0]);
···
             albums.sha256,
             createHash("sha256")
               .update(`${track.album} - ${track.albumArtist}`.toLowerCase())
-              .digest("hex")
-          )
+              .digest("hex"),
+          ),
         )
         .limit(1)
         .then((rows) => rows[0]);
···
 
   if (existingTrack?.artistUri) {
     console.log(
-      `Artist uri ready: ${chalk.cyan(existingTrack.id)} - ${track.title}, after ${chalk.magenta(tries)} tries`
+      `Artist uri ready: ${chalk.cyan(existingTrack.id)} - ${track.title}, after ${chalk.magenta(tries)} tries`,
     );
   }
 
···
     await tealfm.publishPlayingNow(
       agent,
       mbTrack,
-      Math.floor(track.duration / 1000)
+      Math.floor(track.duration / 1000),
     );
   }
 

apps/api/src/tealfm/index.ts

···
 async function publishPlayingNow(
   agent: Agent,
   track: MusicbrainzTrack,
-  duration: number
+  duration: number,
 ) {
   try {
     const rkey = TID.nextStr();

apps/api/src/types/track.ts

···
 export const trackSchema = z.object({
   title: z.string().nonempty().trim(),
   artist: z.string().nonempty().trim(),
+  artists: z
+    .array(
+      z.object({
+        mbid: z.string().optional().nullable(),
+        name: z.string().nonempty().trim(),
+      }),
+    )
+    .optional()
+    .nullable(),
   album: z.string().nonempty().trim(),
   albumArtist: z.string().nonempty().trim(),
   duration: z.number(),