chore: lint files

apps/api/src/xrpc/app/rocksky/spotify/getCurrentlyPlaying.ts

···
       Effect.catchAll((err) => {
         console.error(err);
         return Effect.succeed({});
-      }),
+      })
     );
   server.app.rocksky.spotify.getCurrentlyPlaying({
     auth: ctx.authVerifier,
···
         .where(
           or(
             eq(tables.users.did, params.actor || did),
-            eq(tables.users.handle, params.actor || did),
-          ),
+            eq(tables.users.handle, params.actor || did)
+          )
         )
         .execute()
         .then((users) => ({ user: users[0], ctx, params, did })),
···
         .from(tables.spotifyAccounts)
         .leftJoin(
           tables.users,
-          eq(tables.users.id, tables.spotifyAccounts.userId),
+          eq(tables.users.id, tables.spotifyAccounts.userId)
         )
         .where(
           or(
             eq(tables.users.did, params.actor || did),
-            eq(tables.users.handle, params.actor || did),
-          ),
+            eq(tables.users.handle, params.actor || did)
+          )
         )
         .execute()
         .then(([results]) => ({
···
           Match.value(cached).pipe(
             Match.when(null, () => ({})),
             Match.when(undefined, () => ({})),
-            Match.orElse(() => JSON.parse(cached)),
-          ),
+            Match.orElse(() => JSON.parse(cached))
+          )
         )
         .then((cached) => [cached, ctx, user]),
     catch: (error) =>
···
     try: async () => {
       const sha256 = createHash("sha256")
         .update(
-          `${track.item.name} - ${track.item.artists.map((x) => x.name).join(", ")} - ${track.item.album.name}`.toLowerCase(),
+          `${track.item.name} - ${track.item.artists.map((x) => x.name).join(", ")} - ${track.item.album.name}`.toLowerCase()
         )
         .digest("hex");
       const [record] = await ctx.db
···
         .from(tables.lovedTracks)
         .leftJoin(
           tables.tracks,
-          eq(tables.lovedTracks.trackId, tables.tracks.id),
+          eq(tables.lovedTracks.trackId, tables.tracks.id)
         )
         .leftJoin(tables.users, eq(tables.lovedTracks.userId, tables.users.id))
         .where(
-          and(eq(tables.tracks.sha256, sha256), eq(tables.users.did, user.did)),
+          and(eq(tables.tracks.sha256, sha256), eq(tables.users.did, user.did))
         )
         .execute()
         .then((results) =>
           Match.value(track).pipe(
             Match.when(
               (t) => !Object.keys(t).length,
-              () => ({}),
+              () => ({})
             ),
             Match.orElse(() => ({
               ...track,
···
               artistUri: record?.artistUri,
               albumUri: record?.albumUri,
               liked: results.length > 0,
-            })),
-          ),
+            }))
+          )
         );
     },
     catch: (error) => new Error(`Failed to retrieve URI and likes: ${error}`),

apps/api/src/xrpc/app/rocksky/spotify/next.ts

···
       Effect.catchAll((err) => {
         console.error(err);
         return Effect.succeed({});
-      }),
+      })
     );
   server.app.rocksky.spotify.next({
     auth: ctx.authVerifier,
···
         .where(eq(tables.spotifyTokens.userId, user.id))
         .execute()
         .then(([spotifyToken]) =>
-          decrypt(spotifyToken.refreshToken, env.SPOTIFY_ENCRYPTION_KEY),
+          decrypt(spotifyToken.refreshToken, env.SPOTIFY_ENCRYPTION_KEY)
         )
         .then((refreshToken) => ({
           user,
···
           client_secret: env.SPOTIFY_CLIENT_SECRET,
         }),
       })
-        .then((res) => res.json())
+        .then((res) => res.json() as Promise<{ access_token: string }>)
         .then((data) => data.access_token),
     catch: (error) => new Error(`Failed to retrieve Spotify token: ${error}`),
   });

apps/api/src/xrpc/app/rocksky/spotify/pause.ts

···
       Effect.catchAll((err) => {
         console.error(err);
         return Effect.succeed({});
-      }),
+      })
     );
   server.app.rocksky.spotify.pause({
     auth: ctx.authVerifier,
···
         .where(eq(tables.spotifyTokens.userId, user.id))
         .execute()
         .then(([spotifyToken]) =>
-          decrypt(spotifyToken.refreshToken, env.SPOTIFY_ENCRYPTION_KEY),
+          decrypt(spotifyToken.refreshToken, env.SPOTIFY_ENCRYPTION_KEY)
         )
         .then((refreshToken) => ({
           user,
···
 
 const withSpotifyToken = ({
   refreshToken,
-  ctx,
 }: {
   refreshToken: string;
   ctx: Context;
···
           client_secret: env.SPOTIFY_CLIENT_SECRET,
         }),
       })
-        .then((res) => res.json())
+        .then((res) => res.json() as Promise<{ access_token: string }>)
         .then((data) => data.access_token),
     catch: (error) => new Error(`Failed to retrieve Spotify token: ${error}`),
   });

apps/api/src/xrpc/app/rocksky/spotify/play.ts

···
       Effect.catchAll((err) => {
         console.error(err);
         return Effect.succeed({});
-      }),
+      })
     );
   server.app.rocksky.spotify.play({
     auth: ctx.authVerifier,
···
         .where(eq(tables.spotifyTokens.userId, user.id))
         .execute()
         .then(([spotifyToken]) =>
-          decrypt(spotifyToken.refreshToken, env.SPOTIFY_ENCRYPTION_KEY),
+          decrypt(spotifyToken.refreshToken, env.SPOTIFY_ENCRYPTION_KEY)
         )
         .then((refreshToken) => ({
           user,
···
           client_secret: env.SPOTIFY_CLIENT_SECRET,
         }),
       })
-        .then((res) => res.json())
+        .then((res) => res.json() as Promise<{ access_token: string }>)
         .then((data) => data.access_token),
     catch: (error) => new Error(`Failed to retrieve Spotify token: ${error}`),
   });

apps/api/src/xrpc/app/rocksky/spotify/previous.ts

···
       Effect.catchAll((err) => {
         console.error(err);
         return Effect.succeed({});
-      }),
+      })
     );
   server.app.rocksky.spotify.previous({
     auth: ctx.authVerifier,
···
         .where(eq(tables.spotifyTokens.userId, user.id))
         .execute()
         .then(([spotifyToken]) =>
-          decrypt(spotifyToken.refreshToken, env.SPOTIFY_ENCRYPTION_KEY),
+          decrypt(spotifyToken.refreshToken, env.SPOTIFY_ENCRYPTION_KEY)
         )
         .then((refreshToken) => ({
           refreshToken,
···
           client_secret: env.SPOTIFY_CLIENT_SECRET,
         }),
       })
-        .then((res) => res.json())
+        .then((res) => res.json() as Promise<{ access_token: string }>)
         .then((data) => data.access_token),
     catch: (error) => new Error(`Failed to retrieve Spotify token: ${error}`),
   });

apps/api/src/xrpc/app/rocksky/spotify/seek.ts

···
           client_secret: env.SPOTIFY_CLIENT_SECRET,
         }),
       })
-        .then((res) => res.json())
+        .then((res) => res.json() as Promise<{ access_token: string }>)
         .then((data) => ({
           accessToken: data.access_token,
           position: params.position,