fix: ensure optional parameters are handled correctly in record functions

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 = {
     $type: "app.rocksky.artist",
     name: track.albumArtist,
     createdAt: new Date().toISOString(),
-    pictureUrl: track.artistPicture,
+    pictureUrl: track.artistPicture || undefined,
     tags: track.genres || [],
   };
 
···
 
 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();
 
···
 
 async function putScrobbleRecord(
   track: Track,
-  agent: Agent,
+  agent: Agent
 ): Promise<string | null> {
   const rkey = TID.nextStr();
 
···
       .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) {
···
         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)
     );
   }