Add names filter to artist getArtists

Introduce an optional "names" parameter and propagate it through
lexicon, pkl, TypeScript types, XRPC handler, and analytics types. Also
apply assorted formatting, trailing-comma, and import fixes.

apps/api/lexicons/artist/getArtists.json

···
             "type": "integer",
             "description": "The offset for pagination",
             "minimum": 0
+          },
+          "names": {
+            "type": "string",
+            "description": "The names of the artists to return"
           }
         }
       },

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

···
           description = "The offset for pagination"
           minimum = 0
         }
+        ["names"] = new StringType {
+          type = "string"
+          description = "The names of the artists to return"
+        }
       }
     }
     output {

apps/api/src/auth/client.ts

···
       client_id: publicUrl
         ? `${url}/oauth-client-metadata.json`
         : `http://localhost?redirect_uri=${enc(
-            `${url}/oauth/callback`
+            `${url}/oauth/callback`,
           )}&scope=${enc("atproto transition:generic")}`,
       client_uri: url,
       redirect_uris: [`${url}/oauth/callback`],

apps/api/src/auth/storage.ts

···
       .insertInto("auth_session")
       .values({ key, session, expiresAt: val.tokenSet.expires_at })
       .onConflict((oc) =>
-        oc.doUpdateSet({ session, expiresAt: val.tokenSet.expires_at })
+        oc.doUpdateSet({ session, expiresAt: val.tokenSet.expires_at }),
       )
       .execute();
   }

apps/api/src/bsky/app.ts

···
           ? Math.floor(Date.now() / 1000) + 60 * 60 * 24 * 365 * 1000
           : Math.floor(Date.now() / 1000) + 60 * 60 * 24 * 7,
       },
-      env.JWT_SECRET
+      env.JWT_SECRET,
     );
     ctx.kv.set(did, token);
   } catch (err) {
···
     .select()
     .from(spotifyAccounts)
     .where(
-      and(eq(spotifyAccounts.userId, did), eq(spotifyAccounts.isBetaUser, true))
+      and(
+        eq(spotifyAccounts.userId, did),
+        eq(spotifyAccounts.isBetaUser, true),
+      ),
     )
     .limit(1)
     .execute();
···
 
     ctx.nc.publish(
       "rocksky.user",
-      Buffer.from(JSON.stringify(deepSnakeCaseKeys(user)))
+      Buffer.from(JSON.stringify(deepSnakeCaseKeys(user))),
     );
 
     await ctx.kv.set("lastUser", lastUser[0].id);
···
       .where(
         and(
           eq(spotifyAccounts.userId, did),
-          eq(spotifyAccounts.isBetaUser, true)
-        )
+          eq(spotifyAccounts.isBetaUser, true),
+        ),
       )
       .limit(1)
       .execute(),
···
       .where(
         and(
           eq(googleDriveAccounts.userId, did),
-          eq(googleDriveAccounts.isBetaUser, true)
-        )
+          eq(googleDriveAccounts.isBetaUser, true),
+        ),
       )
       .limit(1)
       .execute(),
···
       .where(
         and(
           eq(dropboxAccounts.userId, did),
-          eq(dropboxAccounts.isBetaUser, true)
-        )
+          eq(dropboxAccounts.isBetaUser, true),
+        ),
       )
       .limit(1)
       .execute(),

apps/api/src/db.ts

···
 
 export const refreshSessionsAboutToExpire = async (
   db: Database,
-  ctx: Context
+  ctx: Context,
 ) => {
   const now = new Date().toISOString();
 
···
     console.log(
       "Session about to expire:",
       chalk.cyan(session.key),
-      session.expiresAt
+      session.expiresAt,
     );
     const agent = await createAgent(ctx.oauthClient, session.key);
     // Trigger a token refresh by fetching preferences
···
   }
 
   console.log(
-    `Found ${chalk.yellowBright(sessions.length)} sessions to refresh`
+    `Found ${chalk.yellowBright(sessions.length)} sessions to refresh`,
   );
 };
 

apps/api/src/index.ts

···
   rateLimiter({
     limit: 1000,
     window: 30, // 👈 30 seconds
-  })
+  }),
 );
 
 app.use("*", async (c, next) => {
···
     ctx.redis.get(`nowplaying:${user.did}:status`),
   ]);
   return c.json(
-    nowPlaying ? { ...JSON.parse(nowPlaying), is_playing: status === "1" } : {}
+    nowPlaying ? { ...JSON.parse(nowPlaying), is_playing: status === "1" } : {},
   );
 });
 
···
       listeners: 1,
       sha256: item.track.sha256,
       id: item.scrobble.id,
-    }))
+    })),
   );
 });
 

apps/api/src/lexicon/index.ts

···
 import type * as AppRockskyActorGetActorSongs from "./types/app/rocksky/actor/getActorSongs";
 import type * as AppRockskyActorGetProfile from "./types/app/rocksky/actor/getProfile";
 import type * as AppRockskyAlbumGetAlbum from "./types/app/rocksky/album/getAlbum";
-import type * as AppRockskyAlbumGetAlbums from "./types/app/rocksky/album/getAlbums";
 import type * as AppRockskyAlbumGetAlbumTracks from "./types/app/rocksky/album/getAlbumTracks";
+import type * as AppRockskyAlbumGetAlbums from "./types/app/rocksky/album/getAlbums";
 import type * as AppRockskyApikeyCreateApikey from "./types/app/rocksky/apikey/createApikey";
 import type * as AppRockskyApikeyGetApikeys from "./types/app/rocksky/apikey/getApikeys";
 import type * as AppRockskyApikeyRemoveApikey from "./types/app/rocksky/apikey/removeApikey";
 import type * as AppRockskyApikeyUpdateApikey from "./types/app/rocksky/apikey/updateApikey";
-import type * as AppRockskyArtistGetArtistAlbums from "./types/app/rocksky/artist/getArtistAlbums";
 import type * as AppRockskyArtistGetArtist from "./types/app/rocksky/artist/getArtist";
+import type * as AppRockskyArtistGetArtistAlbums from "./types/app/rocksky/artist/getArtistAlbums";
 import type * as AppRockskyArtistGetArtistListeners from "./types/app/rocksky/artist/getArtistListeners";
+import type * as AppRockskyArtistGetArtistTracks from "./types/app/rocksky/artist/getArtistTracks";
 import type * as AppRockskyArtistGetArtists from "./types/app/rocksky/artist/getArtists";
-import type * as AppRockskyArtistGetArtistTracks from "./types/app/rocksky/artist/getArtistTracks";
 import type * as AppRockskyChartsGetScrobblesChart from "./types/app/rocksky/charts/getScrobblesChart";
 import type * as AppRockskyDropboxDownloadFile from "./types/app/rocksky/dropbox/downloadFile";
 import type * as AppRockskyDropboxGetFiles from "./types/app/rocksky/dropbox/getFiles";
···
 import type * as AppRockskyPlayerGetPlaybackQueue from "./types/app/rocksky/player/getPlaybackQueue";
 import type * as AppRockskyPlayerNext from "./types/app/rocksky/player/next";
 import type * as AppRockskyPlayerPause from "./types/app/rocksky/player/pause";
+import type * as AppRockskyPlayerPlay from "./types/app/rocksky/player/play";
 import type * as AppRockskyPlayerPlayDirectory from "./types/app/rocksky/player/playDirectory";
 import type * as AppRockskyPlayerPlayFile from "./types/app/rocksky/player/playFile";
-import type * as AppRockskyPlayerPlay from "./types/app/rocksky/player/play";
 import type * as AppRockskyPlayerPrevious from "./types/app/rocksky/player/previous";
 import type * as AppRockskyPlayerSeek from "./types/app/rocksky/player/seek";
 import type * as AppRockskyPlaylistCreatePlaylist from "./types/app/rocksky/playlist/createPlaylist";
···
     return this._server.xrpc.method(nsid, cfg);
   }
 
-  getAlbums<AV extends AuthVerifier>(
+  getAlbumTracks<AV extends AuthVerifier>(
     cfg: ConfigOf<
       AV,
-      AppRockskyAlbumGetAlbums.Handler<ExtractAuth<AV>>,
-      AppRockskyAlbumGetAlbums.HandlerReqCtx<ExtractAuth<AV>>
+      AppRockskyAlbumGetAlbumTracks.Handler<ExtractAuth<AV>>,
+      AppRockskyAlbumGetAlbumTracks.HandlerReqCtx<ExtractAuth<AV>>
     >,
   ) {
-    const nsid = "app.rocksky.album.getAlbums"; // @ts-ignore
+    const nsid = "app.rocksky.album.getAlbumTracks"; // @ts-ignore
     return this._server.xrpc.method(nsid, cfg);
   }
 
-  getAlbumTracks<AV extends AuthVerifier>(
+  getAlbums<AV extends AuthVerifier>(
     cfg: ConfigOf<
       AV,
-      AppRockskyAlbumGetAlbumTracks.Handler<ExtractAuth<AV>>,
-      AppRockskyAlbumGetAlbumTracks.HandlerReqCtx<ExtractAuth<AV>>
+      AppRockskyAlbumGetAlbums.Handler<ExtractAuth<AV>>,
+      AppRockskyAlbumGetAlbums.HandlerReqCtx<ExtractAuth<AV>>
     >,
   ) {
-    const nsid = "app.rocksky.album.getAlbumTracks"; // @ts-ignore
+    const nsid = "app.rocksky.album.getAlbums"; // @ts-ignore
     return this._server.xrpc.method(nsid, cfg);
   }
 }
···
     this._server = server;
   }
 
-  getArtistAlbums<AV extends AuthVerifier>(
+  getArtist<AV extends AuthVerifier>(
     cfg: ConfigOf<
       AV,
-      AppRockskyArtistGetArtistAlbums.Handler<ExtractAuth<AV>>,
-      AppRockskyArtistGetArtistAlbums.HandlerReqCtx<ExtractAuth<AV>>
+      AppRockskyArtistGetArtist.Handler<ExtractAuth<AV>>,
+      AppRockskyArtistGetArtist.HandlerReqCtx<ExtractAuth<AV>>
     >,
   ) {
-    const nsid = "app.rocksky.artist.getArtistAlbums"; // @ts-ignore
+    const nsid = "app.rocksky.artist.getArtist"; // @ts-ignore
     return this._server.xrpc.method(nsid, cfg);
   }
 
-  getArtist<AV extends AuthVerifier>(
+  getArtistAlbums<AV extends AuthVerifier>(
     cfg: ConfigOf<
       AV,
-      AppRockskyArtistGetArtist.Handler<ExtractAuth<AV>>,
-      AppRockskyArtistGetArtist.HandlerReqCtx<ExtractAuth<AV>>
+      AppRockskyArtistGetArtistAlbums.Handler<ExtractAuth<AV>>,
+      AppRockskyArtistGetArtistAlbums.HandlerReqCtx<ExtractAuth<AV>>
     >,
   ) {
-    const nsid = "app.rocksky.artist.getArtist"; // @ts-ignore
+    const nsid = "app.rocksky.artist.getArtistAlbums"; // @ts-ignore
     return this._server.xrpc.method(nsid, cfg);
   }
 
···
     return this._server.xrpc.method(nsid, cfg);
   }
 
-  getArtists<AV extends AuthVerifier>(
+  getArtistTracks<AV extends AuthVerifier>(
     cfg: ConfigOf<
       AV,
-      AppRockskyArtistGetArtists.Handler<ExtractAuth<AV>>,
-      AppRockskyArtistGetArtists.HandlerReqCtx<ExtractAuth<AV>>
+      AppRockskyArtistGetArtistTracks.Handler<ExtractAuth<AV>>,
+      AppRockskyArtistGetArtistTracks.HandlerReqCtx<ExtractAuth<AV>>
     >,
   ) {
-    const nsid = "app.rocksky.artist.getArtists"; // @ts-ignore
+    const nsid = "app.rocksky.artist.getArtistTracks"; // @ts-ignore
     return this._server.xrpc.method(nsid, cfg);
   }
 
-  getArtistTracks<AV extends AuthVerifier>(
+  getArtists<AV extends AuthVerifier>(
     cfg: ConfigOf<
       AV,
-      AppRockskyArtistGetArtistTracks.Handler<ExtractAuth<AV>>,
-      AppRockskyArtistGetArtistTracks.HandlerReqCtx<ExtractAuth<AV>>
+      AppRockskyArtistGetArtists.Handler<ExtractAuth<AV>>,
+      AppRockskyArtistGetArtists.HandlerReqCtx<ExtractAuth<AV>>
     >,
   ) {
-    const nsid = "app.rocksky.artist.getArtistTracks"; // @ts-ignore
+    const nsid = "app.rocksky.artist.getArtists"; // @ts-ignore
     return this._server.xrpc.method(nsid, cfg);
   }
 }
···
     return this._server.xrpc.method(nsid, cfg);
   }
 
+  play<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      AppRockskyPlayerPlay.Handler<ExtractAuth<AV>>,
+      AppRockskyPlayerPlay.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = "app.rocksky.player.play"; // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg);
+  }
+
   playDirectory<AV extends AuthVerifier>(
     cfg: ConfigOf<
       AV,
···
     >,
   ) {
     const nsid = "app.rocksky.player.playFile"; // @ts-ignore
-    return this._server.xrpc.method(nsid, cfg);
-  }
-
-  play<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      AppRockskyPlayerPlay.Handler<ExtractAuth<AV>>,
-      AppRockskyPlayerPlay.HandlerReqCtx<ExtractAuth<AV>>
-    >,
-  ) {
-    const nsid = "app.rocksky.player.play"; // @ts-ignore
     return this._server.xrpc.method(nsid, cfg);
   }
 

apps/api/src/lexicon/lexicons.ts

···
       },
     },
   },
-  AppRockskyAlbumGetAlbums: {
+  AppRockskyAlbumGetAlbumTracks: {
     lexicon: 1,
-    id: "app.rocksky.album.getAlbums",
+    id: "app.rocksky.album.getAlbumTracks",
     defs: {
       main: {
         type: "query",
-        description: "Get albums",
+        description: "Get tracks for an album",
         parameters: {
           type: "params",
+          required: ["uri"],
           properties: {
-            limit: {
-              type: "integer",
-              description: "The maximum number of albums to return",
-              minimum: 1,
-            },
-            offset: {
-              type: "integer",
-              description: "The offset for pagination",
-              minimum: 0,
+            uri: {
+              type: "string",
+              description: "The URI of the album to retrieve tracks from",
+              format: "at-uri",
             },
           },
         },
···
           schema: {
             type: "object",
             properties: {
-              albums: {
+              tracks: {
                 type: "array",
                 items: {
                   type: "ref",
-                  ref: "lex:app.rocksky.album.defs#albumViewBasic",
+                  ref: "lex:app.rocksky.song.defs#songViewBasic",
                 },
               },
             },
···
       },
     },
   },
-  AppRockskyAlbumGetAlbumTracks: {
+  AppRockskyAlbumGetAlbums: {
     lexicon: 1,
-    id: "app.rocksky.album.getAlbumTracks",
+    id: "app.rocksky.album.getAlbums",
     defs: {
       main: {
         type: "query",
-        description: "Get tracks for an album",
+        description: "Get albums",
         parameters: {
           type: "params",
-          required: ["uri"],
           properties: {
-            uri: {
-              type: "string",
-              description: "The URI of the album to retrieve tracks from",
-              format: "at-uri",
+            limit: {
+              type: "integer",
+              description: "The maximum number of albums to return",
+              minimum: 1,
+            },
+            offset: {
+              type: "integer",
+              description: "The offset for pagination",
+              minimum: 0,
             },
           },
         },
···
           schema: {
             type: "object",
             properties: {
-              tracks: {
+              albums: {
                 type: "array",
                 items: {
                   type: "ref",
-                  ref: "lex:app.rocksky.song.defs#songViewBasic",
+                  ref: "lex:app.rocksky.album.defs#albumViewBasic",
                 },
               },
             },
···
       },
     },
   },
+  AppRockskyArtistGetArtist: {
+    lexicon: 1,
+    id: "app.rocksky.artist.getArtist",
+    defs: {
+      main: {
+        type: "query",
+        description: "Get artist details",
+        parameters: {
+          type: "params",
+          required: ["uri"],
+          properties: {
+            uri: {
+              type: "string",
+              description: "The URI of the artist to retrieve details from",
+              format: "at-uri",
+            },
+          },
+        },
+        output: {
+          encoding: "application/json",
+          schema: {
+            type: "ref",
+            ref: "lex:app.rocksky.artist.defs#artistViewDetailed",
+          },
+        },
+      },
+    },
+  },
   AppRockskyArtistGetArtistAlbums: {
     lexicon: 1,
     id: "app.rocksky.artist.getArtistAlbums",
···
                 },
               },
             },
-          },
-        },
-      },
-    },
-  },
-  AppRockskyArtistGetArtist: {
-    lexicon: 1,
-    id: "app.rocksky.artist.getArtist",
-    defs: {
-      main: {
-        type: "query",
-        description: "Get artist details",
-        parameters: {
-          type: "params",
-          required: ["uri"],
-          properties: {
-            uri: {
-              type: "string",
-              description: "The URI of the artist to retrieve details from",
-              format: "at-uri",
-            },
-          },
-        },
-        output: {
-          encoding: "application/json",
-          schema: {
-            type: "ref",
-            ref: "lex:app.rocksky.artist.defs#artistViewDetailed",
           },
         },
       },
···
       },
     },
   },
-  AppRockskyArtistGetArtists: {
+  AppRockskyArtistGetArtistTracks: {
     lexicon: 1,
-    id: "app.rocksky.artist.getArtists",
+    id: "app.rocksky.artist.getArtistTracks",
     defs: {
       main: {
         type: "query",
-        description: "Get artists",
+        description: "Get artist's tracks",
         parameters: {
           type: "params",
           properties: {
+            uri: {
+              type: "string",
+              description: "The URI of the artist to retrieve albums from",
+              format: "at-uri",
+            },
             limit: {
               type: "integer",
-              description: "The maximum number of artists to return",
+              description: "The maximum number of tracks to return",
               minimum: 1,
             },
             offset: {
···
           schema: {
             type: "object",
             properties: {
-              artists: {
+              tracks: {
                 type: "array",
                 items: {
                   type: "ref",
-                  ref: "lex:app.rocksky.artist.defs#artistViewBasic",
+                  ref: "lex:app.rocksky.song.defs#songViewBasic",
                 },
               },
             },
···
       },
     },
   },
-  AppRockskyArtistGetArtistTracks: {
+  AppRockskyArtistGetArtists: {
     lexicon: 1,
-    id: "app.rocksky.artist.getArtistTracks",
+    id: "app.rocksky.artist.getArtists",
     defs: {
       main: {
         type: "query",
-        description: "Get artist's tracks",
+        description: "Get artists",
         parameters: {
           type: "params",
           properties: {
-            uri: {
-              type: "string",
-              description: "The URI of the artist to retrieve albums from",
-              format: "at-uri",
-            },
             limit: {
               type: "integer",
-              description: "The maximum number of tracks to return",
+              description: "The maximum number of artists to return",
               minimum: 1,
             },
             offset: {
               type: "integer",
               description: "The offset for pagination",
               minimum: 0,
+            },
+            names: {
+              type: "string",
+              description: "The names of the artists to return",
             },
           },
         },
···
           schema: {
             type: "object",
             properties: {
-              tracks: {
+              artists: {
                 type: "array",
                 items: {
                   type: "ref",
-                  ref: "lex:app.rocksky.song.defs#songViewBasic",
+                  ref: "lex:app.rocksky.artist.defs#artistViewBasic",
                 },
               },
             },
···
       },
     },
   },
+  AppRockskyPlayerPlay: {
+    lexicon: 1,
+    id: "app.rocksky.player.play",
+    defs: {
+      main: {
+        type: "procedure",
+        description: "Resume playback of the currently paused track",
+        parameters: {
+          type: "params",
+          properties: {
+            playerId: {
+              type: "string",
+            },
+          },
+        },
+      },
+    },
+  },
   AppRockskyPlayerPlayDirectory: {
     lexicon: 1,
     id: "app.rocksky.player.playDirectory",
···
               type: "string",
             },
             fileId: {
-              type: "string",
-            },
-          },
-        },
-      },
-    },
-  },
-  AppRockskyPlayerPlay: {
-    lexicon: 1,
-    id: "app.rocksky.player.play",
-    defs: {
-      main: {
-        type: "procedure",
-        description: "Resume playback of the currently paused track",
-        parameters: {
-          type: "params",
-          properties: {
-            playerId: {
               type: "string",
             },
           },
···
   AppRockskyAlbum: "app.rocksky.album",
   AppRockskyAlbumDefs: "app.rocksky.album.defs",
   AppRockskyAlbumGetAlbum: "app.rocksky.album.getAlbum",
-  AppRockskyAlbumGetAlbums: "app.rocksky.album.getAlbums",
   AppRockskyAlbumGetAlbumTracks: "app.rocksky.album.getAlbumTracks",
+  AppRockskyAlbumGetAlbums: "app.rocksky.album.getAlbums",
   AppRockskyApikeyCreateApikey: "app.rocksky.apikey.createApikey",
   AppRockskyApikeyDefs: "app.rocksky.apikey.defs",
   AppRockskyApikeysDefs: "app.rocksky.apikeys.defs",
···
   AppRockskyApikeyUpdateApikey: "app.rocksky.apikey.updateApikey",
   AppRockskyArtist: "app.rocksky.artist",
   AppRockskyArtistDefs: "app.rocksky.artist.defs",
-  AppRockskyArtistGetArtistAlbums: "app.rocksky.artist.getArtistAlbums",
   AppRockskyArtistGetArtist: "app.rocksky.artist.getArtist",
+  AppRockskyArtistGetArtistAlbums: "app.rocksky.artist.getArtistAlbums",
   AppRockskyArtistGetArtistListeners: "app.rocksky.artist.getArtistListeners",
-  AppRockskyArtistGetArtists: "app.rocksky.artist.getArtists",
   AppRockskyArtistGetArtistTracks: "app.rocksky.artist.getArtistTracks",
+  AppRockskyArtistGetArtists: "app.rocksky.artist.getArtists",
   AppRockskyChartsDefs: "app.rocksky.charts.defs",
   AppRockskyChartsGetScrobblesChart: "app.rocksky.charts.getScrobblesChart",
   AppRockskyDropboxDefs: "app.rocksky.dropbox.defs",
···
   AppRockskyPlayerGetPlaybackQueue: "app.rocksky.player.getPlaybackQueue",
   AppRockskyPlayerNext: "app.rocksky.player.next",
   AppRockskyPlayerPause: "app.rocksky.player.pause",
+  AppRockskyPlayerPlay: "app.rocksky.player.play",
   AppRockskyPlayerPlayDirectory: "app.rocksky.player.playDirectory",
   AppRockskyPlayerPlayFile: "app.rocksky.player.playFile",
-  AppRockskyPlayerPlay: "app.rocksky.player.play",
   AppRockskyPlayerPrevious: "app.rocksky.player.previous",
   AppRockskyPlayerSeek: "app.rocksky.player.seek",
   AppRockskyPlaylistCreatePlaylist: "app.rocksky.playlist.createPlaylist",

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

···
   limit?: number;
   /** The offset for pagination */
   offset?: number;
+  /** The names of the artists to return */
+  names?: string;
 }
 
 export type InputSchema = undefined;

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();
 
···
 
 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(60, "seconds").toDate()),
-        lte(scrobbles.timestamp, scrobbleTime.add(60, "seconds").toDate())
-      )
+        lte(scrobbles.timestamp, scrobbleTime.add(60, "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`,
     );
   }
 

apps/api/src/schema/spotify-accounts.ts

···
 import users from "./users";
 
 const spotifyAccounts = pgTable("spotify_accounts", {
-  id: text("xata_id")
-    .primaryKey()
-    .default(sql`xata_id()`),
+  id: text("xata_id").primaryKey().default(sql`xata_id()`),
   xataVersion: integer("xata_version"),
   email: text("email").notNull(),
   userId: text("user_id")

apps/api/src/schema/spotify-apps.ts

···
 import { integer, pgTable, text, timestamp } from "drizzle-orm/pg-core";
 
 const spotifyApps = pgTable("spotify_apps", {
-  id: text("xata_id")
-    .primaryKey()
-    .default(sql`xata_id()`),
+  id: text("xata_id").primaryKey().default(sql`xata_id()`),
   xataVersion: integer("xata_version"),
   spotifyAppId: text("spotify_app_id").unique().notNull(),
   spotifySecret: text("spotify_secret").notNull(),

apps/api/src/schema/spotify-tokens.ts

···
 import users from "./users";
 
 const spotifyTokens = pgTable("spotify_tokens", {
-  id: text("xata_id")
-    .primaryKey()
-    .default(sql`xata_id()`),
+  id: text("xata_id").primaryKey().default(sql`xata_id()`),
   xataVersion: integer("xata_version"),
   accessToken: text("access_token").notNull(),
   refreshToken: text("refresh_token").notNull(),

apps/api/src/scripts/genres.ts

···
     .from(tables.spotifyTokens)
     .leftJoin(
       tables.spotifyAccounts,
-      eq(tables.spotifyAccounts.userId, tables.spotifyTokens.userId)
+      eq(tables.spotifyAccounts.userId, tables.spotifyTokens.userId),
     )
     .leftJoin(
       tables.spotifyApps,
-      eq(tables.spotifyApps.spotifyAppId, tables.spotifyTokens.spotifyAppId)
+      eq(tables.spotifyApps.spotifyAppId, tables.spotifyTokens.spotifyAppId),
     )
     .where(eq(tables.spotifyAccounts.isBetaUser, true))
     .execute();
···
     spotifyTokens[Math.floor(Math.random() * spotifyTokens.length)];
   const refreshToken = decrypt(
     record.spotify_tokens.refreshToken,
-    env.SPOTIFY_ENCRYPTION_KEY
+    env.SPOTIFY_ENCRYPTION_KEY,
   );
 
   const accessToken = await fetch("https://accounts.spotify.com/api/token", {
···
       client_id: record.spotify_apps.spotifyAppId,
       client_secret: decrypt(
         record.spotify_apps.spotifySecret,
-        env.SPOTIFY_ENCRYPTION_KEY
+        env.SPOTIFY_ENCRYPTION_KEY,
       ),
     }),
   })
···
             headers: {
               Authorization: `Bearer ${token}`,
             },
-          }
+          },
         )
           .then(
             (res) =>
···
                     images: Array<{ url: string }>;
                   }>;
                 };
-              }>
+              }>,
           )
           .then(async (data) => _.get(data, "artists.items.0"));
 

apps/api/src/scripts/spotify.ts

···
 
 if (!clientId || !clientSecret) {
   console.error(
-    "Please provide Spotify Client ID and Client Secret as command line arguments"
+    "Please provide Spotify Client ID and Client Secret as command line arguments",
   );
   console.log(
-    chalk.greenBright("Usage: ts-node spotify.ts <client_id> <client_secret>")
+    chalk.greenBright("Usage: ts-node spotify.ts <client_id> <client_secret>"),
   );
   process.exit(1);
 }

apps/api/src/scripts/sync.ts

···
       } catch (err) {
         console.error(
           `Failed to sync scrobble ${chalk.cyan(scrobble.id)}:`,
-          err
+          err,
         );
       }
     }

apps/api/src/server.ts

···
 
 app.listen(process.env.ROCKSKY_XPRC_PORT || 3004, () => {
   console.log(
-    `Rocksky XRPC API is running on port ${process.env.ROCKSKY_XRPC_PORT || 3004}`
+    `Rocksky XRPC API is running on port ${process.env.ROCKSKY_XRPC_PORT || 3004}`,
   );
 });

apps/api/src/spotify/app.ts

···
     limit: 10, // max Spotify API calls
     window: 15, // per 10 seconds
     keyPrefix: "spotify-ratelimit",
-  })
+  }),
 );
 
 app.get("/login", async (c) => {
···
     .leftJoin(users, eq(spotifyAccounts.userId, users.id))
     .leftJoin(
       spotifyApps,
-      eq(spotifyAccounts.spotifyAppId, spotifyApps.spotifyAppId)
+      eq(spotifyAccounts.spotifyAppId, spotifyApps.spotifyAppId),
     )
     .where(
       and(
         eq(spotifyAccounts.userId, user.id),
-        eq(spotifyAccounts.isBetaUser, true)
-      )
+        eq(spotifyAccounts.isBetaUser, true),
+      ),
     )
     .limit(1)
     .then((rows) => rows[0]);
···
   const redirectUrl = `https://accounts.spotify.com/en/authorize?client_id=${spotifyAccount?.spotify_apps?.spotifyAppId}&response_type=code&redirect_uri=${env.SPOTIFY_REDIRECT_URI}&scope=user-read-private%20user-read-email%20user-read-playback-state%20user-read-currently-playing%20user-modify-playback-state%20playlist-modify-public%20playlist-modify-private%20playlist-read-private%20playlist-read-collaborative&state=${state}`;
   c.header(
     "Set-Cookie",
-    `session-id=${state}; Path=/; HttpOnly; SameSite=Strict; Secure`
+    `session-id=${state}; Path=/; HttpOnly; SameSite=Strict; Secure`,
   );
   return c.json({ redirectUrl });
 });
···
     .from(spotifyAccounts)
     .leftJoin(
       spotifyApps,
-      eq(spotifyAccounts.spotifyAppId, spotifyApps.spotifyAppId)
+      eq(spotifyAccounts.spotifyAppId, spotifyApps.spotifyAppId),
     )
     .where(
       and(
         eq(spotifyAccounts.userId, user.id),
-        eq(spotifyAccounts.isBetaUser, true)
-      )
+        eq(spotifyAccounts.isBetaUser, true),
+      ),
     )
     .limit(1)
     .then((rows) => rows[0]);
···
     .where(
       and(
         eq(spotifyAccounts.userId, user.id),
-        eq(spotifyAccounts.isBetaUser, true)
-      )
+        eq(spotifyAccounts.isBetaUser, true),
+      ),
     )
     .limit(1)
     .then((rows) => rows[0]);
···
       appId: spotifyApps.id,
       spotifyAppId: spotifyApps.spotifyAppId,
       accountCount: sql<number>`COUNT(${spotifyAccounts.id})`.as(
-        "account_count"
+        "account_count",
       ),
     })
     .from(spotifyApps)
···
   }
 
   const cached = await ctx.redis.get(
-    `${spotifyAccount.spotifyAccount.email}:current`
+    `${spotifyAccount.spotifyAccount.email}:current`,
   );
   if (!cached) {
     return c.json({});
···
 
   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");
 
···
     .from(spotifyTokens)
     .leftJoin(
       spotifyApps,
-      eq(spotifyTokens.spotifyAppId, spotifyApps.spotifyAppId)
+      eq(spotifyTokens.spotifyAppId, spotifyApps.spotifyAppId),
     )
     .where(eq(spotifyTokens.userId, user.id))
     .limit(1)
···
 
   const refreshToken = decrypt(
     spotifyToken.spotify_tokens.refreshToken,
-    env.SPOTIFY_ENCRYPTION_KEY
+    env.SPOTIFY_ENCRYPTION_KEY,
   );
 
   // get new access token
···
       client_id: spotifyToken.spotify_apps.spotifyAppId,
       client_secret: decrypt(
         spotifyToken.spotify_apps.spotifySecret,
-        env.SPOTIFY_ENCRYPTION_KEY
+        env.SPOTIFY_ENCRYPTION_KEY,
       ),
     }),
   });
···
     .from(spotifyTokens)
     .leftJoin(
       spotifyApps,
-      eq(spotifyTokens.spotifyAppId, spotifyApps.spotifyAppId)
+      eq(spotifyTokens.spotifyAppId, spotifyApps.spotifyAppId),
     )
     .where(eq(spotifyTokens.userId, user.id))
     .limit(1)
···
 
   const refreshToken = decrypt(
     spotifyToken.spotify_tokens.refreshToken,
-    env.SPOTIFY_ENCRYPTION_KEY
+    env.SPOTIFY_ENCRYPTION_KEY,
   );
 
   // get new access token
···
       client_id: spotifyToken.spotify_apps.spotifyAppId,
       client_secret: decrypt(
         spotifyToken.spotify_apps.spotifySecret,
-        env.SPOTIFY_ENCRYPTION_KEY
+        env.SPOTIFY_ENCRYPTION_KEY,
       ),
     }),
   });
···
     .from(spotifyTokens)
     .leftJoin(
       spotifyApps,
-      eq(spotifyTokens.spotifyAppId, spotifyApps.spotifyAppId)
+      eq(spotifyTokens.spotifyAppId, spotifyApps.spotifyAppId),
     )
     .where(eq(spotifyTokens.userId, user.id))
     .limit(1)
···
 
   const refreshToken = decrypt(
     spotifyToken.spotify_tokens.refreshToken,
-    env.SPOTIFY_ENCRYPTION_KEY
+    env.SPOTIFY_ENCRYPTION_KEY,
   );
 
   // get new access token
···
       client_id: spotifyToken.spotify_apps.spotifyAppId,
       client_secret: decrypt(
         spotifyToken.spotify_apps.spotifySecret,
-        env.SPOTIFY_ENCRYPTION_KEY
+        env.SPOTIFY_ENCRYPTION_KEY,
       ),
     }),
   });
···
     .from(spotifyTokens)
     .leftJoin(
       spotifyApps,
-      eq(spotifyTokens.spotifyAppId, spotifyApps.spotifyAppId)
+      eq(spotifyTokens.spotifyAppId, spotifyApps.spotifyAppId),
     )
     .where(eq(spotifyTokens.userId, user.id))
     .limit(1)
···
 
   const refreshToken = decrypt(
     spotifyToken.spotify_tokens.refreshToken,
-    env.SPOTIFY_ENCRYPTION_KEY
+    env.SPOTIFY_ENCRYPTION_KEY,
   );
 
   // get new access token
···
       client_id: spotifyToken.spotify_apps.spotifyAppId,
       client_secret: decrypt(
         spotifyToken.spotify_apps.spotifySecret,
-        env.SPOTIFY_ENCRYPTION_KEY
+        env.SPOTIFY_ENCRYPTION_KEY,
       ),
     }),
   });
···
       headers: {
         Authorization: `Bearer ${access_token}`,
       },
-    }
+    },
   );
 
   if (response.status === 403) {
···
     .from(spotifyTokens)
     .leftJoin(
       spotifyApps,
-      eq(spotifyTokens.spotifyAppId, spotifyApps.spotifyAppId)
+      eq(spotifyTokens.spotifyAppId, spotifyApps.spotifyAppId),
     )
     .where(eq(spotifyTokens.userId, user.id))
     .limit(1)
···
 
   const refreshToken = decrypt(
     spotifyToken.spotify_tokens.refreshToken,
-    env.SPOTIFY_ENCRYPTION_KEY
+    env.SPOTIFY_ENCRYPTION_KEY,
   );
 
   // get new access token
···
       client_id: spotifyToken.spotify_apps.spotifyAppId,
       client_secret: decrypt(
         spotifyToken.spotify_apps.spotifySecret,
-        env.SPOTIFY_ENCRYPTION_KEY
+        env.SPOTIFY_ENCRYPTION_KEY,
       ),
     }),
   });
···
       headers: {
         Authorization: `Bearer ${access_token}`,
       },
-    }
+    },
   );
 
   if (response.status === 403) {

apps/api/src/tealfm/index.ts

···
             record?.trackName === track.name)) &&
         // diff in seconds less than 60
         Math.abs(
-            new Date(record.playedTime).getTime() -
-              new Date(track.timestamp).getTime(),
-          ) < 60000
+          new Date(record.playedTime).getTime() -
+            new Date(track.timestamp).getTime(),
+        ) < 60000
       );
     });
     if (alreadyPlayed) {
       console.log(
-        `Track ${chalk.cyan(track.name)} by ${
-          chalk.cyan(
-            track.artist.map((a) => a.name).join(", "),
-          )
-        } already played recently. Skipping...`,
+        `Track ${chalk.cyan(track.name)} by ${chalk.cyan(
+          track.artist.map((a) => a.name).join(", "),
+        )} already played recently. Skipping...`,
       );
       return;
     }

apps/api/src/xrpc/app/rocksky/actor/getProfile.ts

···
       Effect.catchAll((err) => {
         console.error(err);
         return Effect.succeed({});
-      })
+      }),
     );
   server.app.rocksky.actor.getProfile({
     auth: ctx.authVerifier,
···
           .from(tables.spotifyAccounts)
           .leftJoin(
             tables.users,
-            eq(tables.spotifyAccounts.userId, tables.users.id)
+            eq(tables.spotifyAccounts.userId, tables.users.id),
           )
           .where(eq(tables.users.did, did))
           .execute()
···
           .from(tables.spotifyTokens)
           .leftJoin(
             tables.users,
-            eq(tables.spotifyTokens.userId, tables.users.id)
+            eq(tables.spotifyTokens.userId, tables.users.id),
           )
           .where(eq(tables.users.did, did))
           .execute()
···
           .from(tables.googleDriveAccounts)
           .leftJoin(
             tables.users,
-            eq(tables.googleDriveAccounts.userId, tables.users.id)
+            eq(tables.googleDriveAccounts.userId, tables.users.id),
           )
           .where(eq(tables.users.did, did))
           .execute()
···
           .from(tables.dropboxAccounts)
           .leftJoin(
             tables.users,
-            eq(tables.dropboxAccounts.userId, tables.users.id)
+            eq(tables.dropboxAccounts.userId, tables.users.id),
           )
           .where(eq(tables.users.did, did))
           .execute()
···
               xata_createdat: profile.user.createdAt.toISOString(),
               xata_updatedat: profile.user.updatedAt.toISOString(),
               xata_version: 1,
-            })
-          )
+            }),
+          ),
         );
       } else {
         // Update existing user in background if handle or avatar or displayName changed
···
                 xata_createdat: profile.user.createdAt.toISOString(),
                 xata_updatedat: new Date().toISOString(),
                 xata_version: (profile.user.xataVersion || 1) + 1,
-              })
-            )
+              }),
+            ),
           );
         }
       }

apps/api/src/xrpc/app/rocksky/artist/getArtists.ts

···
           skip: params.offset || 0,
           take: params.limit || 100,
         },
+        names: params.names,
       });
       return { data: response.data, ctx };
     },

apps/api/src/xrpc/app/rocksky/scrobble/getScrobble.ts

···
 import type { QueryParams } from "lexicon/types/app/rocksky/scrobble/getScrobble";
 import * as R from "ramda";
 import tables from "schema";
-import { SelectAlbum } from "schema/albums";
+import type { SelectAlbum } from "schema/albums";
 import type { SelectScrobble } from "schema/scrobbles";
 import type { SelectTrack } from "schema/tracks";
 import type { SelectUser } from "schema/users";
···
       Effect.catchAll((err) => {
         console.error("Error retrieving scrobble:", err);
         return Effect.succeed({});
-      })
+      }),
     );
   server.app.rocksky.scrobble.getScrobble({
     handler: async ({ params }) => {
···
           .from(tables.scrobbles)
           .leftJoin(
             tables.tracks,
-            eq(tables.tracks.id, tables.scrobbles.trackId)
+            eq(tables.tracks.id, tables.scrobbles.trackId),
           )
           .leftJoin(tables.users, eq(tables.scrobbles.userId, tables.users.id))
           .where(eq(tables.scrobbles.trackId, scrobble?.tracks.id))
···
           .from(tables.scrobbles)
           .leftJoin(
             tables.tracks,
-            eq(tables.scrobbles.trackId, tables.tracks.id)
+            eq(tables.scrobbles.trackId, tables.tracks.id),
           )
           .where(eq(tables.scrobbles.trackId, scrobble?.tracks.id))
           .execute()

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,
···
         .from(tables.spotifyTokens)
         .leftJoin(
           tables.spotifyApps,
-          eq(tables.spotifyTokens.spotifyAppId, tables.spotifyApps.spotifyAppId)
+          eq(
+            tables.spotifyTokens.spotifyAppId,
+            tables.spotifyApps.spotifyAppId,
+          ),
         )
         .where(eq(tables.spotifyTokens.userId, user.id))
         .execute()
         .then(([spotifyToken]) => [
           decrypt(
             spotifyToken.spotify_tokens.refreshToken,
-            env.SPOTIFY_ENCRYPTION_KEY
+            env.SPOTIFY_ENCRYPTION_KEY,
           ),
           decrypt(
             spotifyToken.spotify_apps.spotifySecret,
-            env.SPOTIFY_ENCRYPTION_KEY
+            env.SPOTIFY_ENCRYPTION_KEY,
           ),
           spotifyToken.spotify_apps.spotifyAppId,
         ])

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,
···
         .from(tables.spotifyTokens)
         .leftJoin(
           tables.spotifyApps,
-          eq(tables.spotifyTokens.spotifyAppId, tables.spotifyApps.spotifyAppId)
+          eq(
+            tables.spotifyTokens.spotifyAppId,
+            tables.spotifyApps.spotifyAppId,
+          ),
         )
         .where(eq(tables.spotifyTokens.userId, user.id))
         .execute()
         .then(([spotifyToken]) => [
           decrypt(
             spotifyToken.spotify_tokens.refreshToken,
-            env.SPOTIFY_ENCRYPTION_KEY
+            env.SPOTIFY_ENCRYPTION_KEY,
           ),
           decrypt(
             spotifyToken.spotify_apps.spotifySecret,
-            env.SPOTIFY_ENCRYPTION_KEY
+            env.SPOTIFY_ENCRYPTION_KEY,
           ),
           spotifyToken.spotify_apps.spotifyAppId,
         ])

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,
···
         .from(tables.spotifyTokens)
         .leftJoin(
           tables.spotifyApps,
-          eq(tables.spotifyTokens.spotifyAppId, tables.spotifyApps.spotifyAppId)
+          eq(
+            tables.spotifyTokens.spotifyAppId,
+            tables.spotifyApps.spotifyAppId,
+          ),
         )
         .where(eq(tables.spotifyTokens.userId, user.id))
         .execute()
         .then(([spotifyToken]) => [
           decrypt(
             spotifyToken.spotify_tokens.refreshToken,
-            env.SPOTIFY_ENCRYPTION_KEY
+            env.SPOTIFY_ENCRYPTION_KEY,
           ),
           decrypt(
             spotifyToken.spotify_apps.spotifySecret,
-            env.SPOTIFY_ENCRYPTION_KEY
+            env.SPOTIFY_ENCRYPTION_KEY,
           ),
           spotifyToken.spotify_apps.spotifyAppId,
         ])

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,
···
         .from(tables.spotifyTokens)
         .leftJoin(
           tables.spotifyApps,
-          eq(tables.spotifyTokens.spotifyAppId, tables.spotifyApps.spotifyAppId)
+          eq(
+            tables.spotifyTokens.spotifyAppId,
+            tables.spotifyApps.spotifyAppId,
+          ),
         )
         .where(eq(tables.spotifyTokens.userId, user.id))
         .execute()
         .then(([spotifyToken]) => [
           decrypt(
             spotifyToken.spotify_tokens.refreshToken,
-            env.SPOTIFY_ENCRYPTION_KEY
+            env.SPOTIFY_ENCRYPTION_KEY,
           ),
           decrypt(
             spotifyToken.spotify_apps.spotifySecret,
-            env.SPOTIFY_ENCRYPTION_KEY
+            env.SPOTIFY_ENCRYPTION_KEY,
           ),
           spotifyToken.spotify_apps.spotifyAppId,
         ])

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

···
       Effect.catchAll((err) => {
         console.error(err);
         return Effect.succeed({});
-      })
+      }),
     );
   server.app.rocksky.spotify.seek({
     auth: ctx.authVerifier,
···
         .from(tables.spotifyTokens)
         .leftJoin(
           tables.spotifyApps,
-          eq(tables.spotifyTokens.spotifyAppId, tables.spotifyApps.spotifyAppId)
+          eq(
+            tables.spotifyTokens.spotifyAppId,
+            tables.spotifyApps.spotifyAppId,
+          ),
         )
         .where(eq(tables.spotifyTokens.userId, user.id))
         .execute()
         .then(([spotifyToken]) => [
           decrypt(
             spotifyToken.spotify_tokens.refreshToken,
-            env.SPOTIFY_ENCRYPTION_KEY
+            env.SPOTIFY_ENCRYPTION_KEY,
           ),
           decrypt(
             spotifyToken.spotify_apps.spotifySecret,
-            env.SPOTIFY_ENCRYPTION_KEY
+            env.SPOTIFY_ENCRYPTION_KEY,
           ),
           spotifyToken.spotify_apps.spotifyAppId,
         ])
···
           headers: {
             Authorization: `Bearer ${accessToken}`,
           },
-        }
+        },
       ).then((res) => res.status),
     catch: (error) => new Error(`Failed to handle next action: ${error}`),
   });

crates/analytics/src/handlers/artists.rs

···
 };
 use actix_web::{web, HttpRequest, HttpResponse};
 use anyhow::Error;
-use duckdb::Connection;
+use duckdb::{params_from_iter, Connection};
 use tokio_stream::StreamExt;
 
 use crate::read_payload;
···
     let offset = pagination.skip.unwrap_or(0);
     let limit = pagination.take.unwrap_or(20);
     let did = params.user_did;
+    let names = params.names;
 
     let conn = conn.lock().unwrap();
-    let mut stmt = match did {
-        Some(_) => conn.prepare(
-            r#"
-            SELECT a.*,
-                COUNT(*) AS play_count,
-                COUNT(DISTINCT s.user_id) AS unique_listeners
-             FROM user_artists ua
-            LEFT JOIN artists a ON ua.artist_id = a.id
-            LEFT JOIN users u ON ua.user_id = u.id
-            LEFT JOIN scrobbles s ON s.artist_id = a.id
-            WHERE u.did = ? OR u.handle = ?
-            GROUP BY a.*
-            ORDER BY play_count DESC OFFSET ? LIMIT ?;
-            "#,
-        )?,
-        None => conn.prepare(
-            "SELECT a.*,
-                COUNT(*) AS play_count,
-                COUNT(DISTINCT s.user_id) AS unique_listeners
-             FROM artists a
-             LEFT JOIN scrobbles s ON s.artist_id = a.id
-             GROUP BY a.*
-             ORDER BY play_count DESC OFFSET ? LIMIT ?",
-        )?,
-    };
 
-    match did {
-        Some(did) => {
-            let artists = stmt.query_map(
-                [&did, &did, &limit.to_string(), &offset.to_string()],
-                |row| {
-                    Ok(Artist {
-                        id: row.get(0)?,
-                        name: row.get(1)?,
-                        biography: row.get(2)?,
-                        born: row.get(3)?,
-                        born_in: row.get(4)?,
-                        died: row.get(5)?,
-                        picture: row.get(6)?,
-                        sha256: row.get(7)?,
-                        spotify_link: row.get(8)?,
-                        tidal_link: row.get(9)?,
-                        youtube_link: row.get(10)?,
-                        apple_music_link: row.get(11)?,
-                        uri: row.get(12)?,
-                        play_count: row.get(13)?,
-                        unique_listeners: row.get(14)?,
-                    })
-                },
-            )?;
+    // Build dynamic query and params based on filters
+    let (query, params_vec): (String, Vec<Box<dyn duckdb::ToSql>>) =
+        match (did.as_ref(), names.as_ref()) {
+            // Both did and names provided
+            (Some(d), Some(n)) if !n.is_empty() => {
+                let placeholders = vec!["?"; n.len()].join(", ");
+                let query = format!(
+                    r#"
+                    SELECT a.*,
+                        COUNT(*) AS play_count,
+                        COUNT(DISTINCT s.user_id) AS unique_listeners
+                     FROM user_artists ua
+                    LEFT JOIN artists a ON ua.artist_id = a.id
+                    LEFT JOIN users u ON ua.user_id = u.id
+                    LEFT JOIN scrobbles s ON s.artist_id = a.id
+                    WHERE (u.did = ? OR u.handle = ?)
+                      AND a.name IN ({})
+                    GROUP BY a.*
+                    ORDER BY play_count DESC
+                    LIMIT ? OFFSET ?
+                    "#,
+                    placeholders
+                );
+                let mut params: Vec<Box<dyn duckdb::ToSql>> =
+                    vec![Box::new(d.clone()), Box::new(d.clone())];
+                for name in n {
+                    params.push(Box::new(name.clone()));
+                }
+                params.push(Box::new(limit));
+                params.push(Box::new(offset));
+                (query, params)
+            }
+            // Only did provided
+            (Some(d), _) => {
+                let query = r#"
+                    SELECT a.*,
+                        COUNT(*) AS play_count,
+                        COUNT(DISTINCT s.user_id) AS unique_listeners
+                     FROM user_artists ua
+                    LEFT JOIN artists a ON ua.artist_id = a.id
+                    LEFT JOIN users u ON ua.user_id = u.id
+                    LEFT JOIN scrobbles s ON s.artist_id = a.id
+                    WHERE u.did = ? OR u.handle = ?
+                    GROUP BY a.*
+                    ORDER BY play_count DESC
+                    LIMIT ? OFFSET ?
+                "#
+                .to_string();
+                (
+                    query,
+                    vec![
+                        Box::new(d.clone()),
+                        Box::new(d.clone()),
+                        Box::new(limit),
+                        Box::new(offset),
+                    ],
+                )
+            }
+            // Only names provided
+            (None, Some(n)) if !n.is_empty() => {
+                let placeholders = vec!["?"; n.len()].join(", ");
+                let query = format!(
+                    r#"
+                    SELECT a.*,
+                        COUNT(*) AS play_count,
+                        COUNT(DISTINCT s.user_id) AS unique_listeners
+                     FROM artists a
+                     LEFT JOIN scrobbles s ON s.artist_id = a.id
+                     WHERE a.name IN ({})
+                     GROUP BY a.*
+                     ORDER BY play_count DESC
+                     LIMIT ? OFFSET ?
+                    "#,
+                    placeholders
+                );
+                let mut params: Vec<Box<dyn duckdb::ToSql>> = vec![];
+                for name in n {
+                    params.push(Box::new(name.clone()));
+                }
+                params.push(Box::new(limit));
+                params.push(Box::new(offset));
+                (query, params)
+            }
+            // No filters
+            (None, _) => {
+                let query = r#"
+                    SELECT a.*,
+                        COUNT(*) AS play_count,
+                        COUNT(DISTINCT s.user_id) AS unique_listeners
+                     FROM artists a
+                     LEFT JOIN scrobbles s ON s.artist_id = a.id
+                     GROUP BY a.*
+                     ORDER BY play_count DESC
+                     LIMIT ? OFFSET ?
+                "#
+                .to_string();
+                (query, vec![Box::new(limit), Box::new(offset)])
+            }
+        };
 
-            let artists: Result<Vec<_>, _> = artists.collect();
-            Ok(HttpResponse::Ok().json(artists?))
-        }
-        None => {
-            let artists = stmt.query_map([limit, offset], |row| {
-                Ok(Artist {
-                    id: row.get(0)?,
-                    name: row.get(1)?,
-                    biography: row.get(2)?,
-                    born: row.get(3)?,
-                    born_in: row.get(4)?,
-                    died: row.get(5)?,
-                    picture: row.get(6)?,
-                    sha256: row.get(7)?,
-                    spotify_link: row.get(8)?,
-                    tidal_link: row.get(9)?,
-                    youtube_link: row.get(10)?,
-                    apple_music_link: row.get(11)?,
-                    uri: row.get(12)?,
-                    play_count: row.get(13)?,
-                    unique_listeners: row.get(14)?,
-                })
-            })?;
+    // Prepare and execute query
+    let mut stmt = conn.prepare(&query)?;
+    let artists = stmt.query_map(params_from_iter(params_vec.iter()), |row| {
+        Ok(Artist {
+            id: row.get(0)?,
+            name: row.get(1)?,
+            biography: row.get(2)?,
+            born: row.get(3)?,
+            born_in: row.get(4)?,
+            died: row.get(5)?,
+            picture: row.get(6)?,
+            sha256: row.get(7)?,
+            spotify_link: row.get(8)?,
+            tidal_link: row.get(9)?,
+            youtube_link: row.get(10)?,
+            apple_music_link: row.get(11)?,
+            uri: row.get(12)?,
+            play_count: row.get(14)?,
+            unique_listeners: row.get(15)?,
+        })
+    })?;
 
-            let artists: Result<Vec<_>, _> = artists.collect();
-            Ok(HttpResponse::Ok().json(artists?))
-        }
-    }
+    let artists: Result<Vec<_>, _> = artists.collect();
+    Ok(HttpResponse::Ok().json(artists?))
 }
 
 pub async fn get_top_artists(

crates/analytics/src/types/artist.rs

···
 pub struct GetArtistsParams {
     pub user_did: Option<String>,
     pub pagination: Option<Pagination>,
+    pub names: Option<Vec<String>>,
 }
 
 #[derive(Debug, Serialize, Deserialize, Default)]