+4

apps/api/lexicons/artist/getArtists.json

··· 17 17 "type": "integer", 18 18 "description": "The offset for pagination", 19 19 "minimum": 0 20 20 + }, 21 21 + "names": { 22 22 + "type": "string", 23 23 + "description": "The names of the artists to return" 20 24 } 21 25 } 22 26 },

+4

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

··· 18 18 description = "The offset for pagination" 19 19 minimum = 0 20 20 } 21 21 + ["names"] = new StringType { 22 22 + type = "string" 23 23 + description = "The names of the artists to return" 24 24 + } 21 25 } 22 26 } 23 27 output {

+1 -1

apps/api/src/auth/client.ts

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

+1 -1

apps/api/src/auth/storage.ts

··· 47 47 .insertInto("auth_session") 48 48 .values({ key, session, expiresAt: val.tokenSet.expires_at }) 49 49 .onConflict((oc) => 50 50 - oc.doUpdateSet({ session, expiresAt: val.tokenSet.expires_at }) 50 50 + oc.doUpdateSet({ session, expiresAt: val.tokenSet.expires_at }), 51 51 ) 52 52 .execute(); 53 53 }

+12 -9

apps/api/src/bsky/app.ts

··· 81 81 ? Math.floor(Date.now() / 1000) + 60 * 60 * 24 * 365 * 1000 82 82 : Math.floor(Date.now() / 1000) + 60 * 60 * 24 * 7, 83 83 }, 84 84 - env.JWT_SECRET 84 84 + env.JWT_SECRET, 85 85 ); 86 86 ctx.kv.set(did, token); 87 87 } catch (err) { ··· 93 93 .select() 94 94 .from(spotifyAccounts) 95 95 .where( 96 96 - and(eq(spotifyAccounts.userId, did), eq(spotifyAccounts.isBetaUser, true)) 96 96 + and( 97 97 + eq(spotifyAccounts.userId, did), 98 98 + eq(spotifyAccounts.isBetaUser, true), 99 99 + ), 97 100 ) 98 101 .limit(1) 99 102 .execute(); ··· 179 182 180 183 ctx.nc.publish( 181 184 "rocksky.user", 182 182 - Buffer.from(JSON.stringify(deepSnakeCaseKeys(user))) 185 185 + Buffer.from(JSON.stringify(deepSnakeCaseKeys(user))), 183 186 ); 184 187 185 188 await ctx.kv.set("lastUser", lastUser[0].id); ··· 192 195 .where( 193 196 and( 194 197 eq(spotifyAccounts.userId, did), 195 195 - eq(spotifyAccounts.isBetaUser, true) 196 196 - ) 198 198 + eq(spotifyAccounts.isBetaUser, true), 199 199 + ), 197 200 ) 198 201 .limit(1) 199 202 .execute(), ··· 209 212 .where( 210 213 and( 211 214 eq(googleDriveAccounts.userId, did), 212 212 - eq(googleDriveAccounts.isBetaUser, true) 213 213 - ) 215 215 + eq(googleDriveAccounts.isBetaUser, true), 216 216 + ), 214 217 ) 215 218 .limit(1) 216 219 .execute(), ··· 220 223 .where( 221 224 and( 222 225 eq(dropboxAccounts.userId, did), 223 223 - eq(dropboxAccounts.isBetaUser, true) 224 224 - ) 226 226 + eq(dropboxAccounts.isBetaUser, true), 227 227 + ), 225 228 ) 226 229 .limit(1) 227 230 .execute(),

+3 -3

apps/api/src/db.ts

··· 131 131 132 132 export const refreshSessionsAboutToExpire = async ( 133 133 db: Database, 134 134 - ctx: Context 134 134 + ctx: Context, 135 135 ) => { 136 136 const now = new Date().toISOString(); 137 137 ··· 147 147 console.log( 148 148 "Session about to expire:", 149 149 chalk.cyan(session.key), 150 150 - session.expiresAt 150 150 + session.expiresAt, 151 151 ); 152 152 const agent = await createAgent(ctx.oauthClient, session.key); 153 153 // Trigger a token refresh by fetching preferences ··· 156 156 } 157 157 158 158 console.log( 159 159 - `Found ${chalk.yellowBright(sessions.length)} sessions to refresh` 159 159 + `Found ${chalk.yellowBright(sessions.length)} sessions to refresh`, 160 160 ); 161 161 }; 162 162

+3 -3

apps/api/src/index.ts

··· 50 50 rateLimiter({ 51 51 limit: 1000, 52 52 window: 30, // 👈 30 seconds 53 53 - }) 53 53 + }), 54 54 ); 55 55 56 56 app.use("*", async (c, next) => { ··· 165 165 ctx.redis.get(`nowplaying:${user.did}:status`), 166 166 ]); 167 167 return c.json( 168 168 - nowPlaying ? { ...JSON.parse(nowPlaying), is_playing: status === "1" } : {} 168 168 + nowPlaying ? { ...JSON.parse(nowPlaying), is_playing: status === "1" } : {}, 169 169 ); 170 170 }); 171 171 ··· 317 317 listeners: 1, 318 318 sha256: item.track.sha256, 319 319 id: item.scrobble.id, 320 320 - })) 320 320 + })), 321 321 ); 322 322 }); 323 323

+39 -39

apps/api/src/lexicon/index.ts

··· 22 22 import type * as AppRockskyActorGetActorSongs from "./types/app/rocksky/actor/getActorSongs"; 23 23 import type * as AppRockskyActorGetProfile from "./types/app/rocksky/actor/getProfile"; 24 24 import type * as AppRockskyAlbumGetAlbum from "./types/app/rocksky/album/getAlbum"; 25 25 - import type * as AppRockskyAlbumGetAlbums from "./types/app/rocksky/album/getAlbums"; 26 25 import type * as AppRockskyAlbumGetAlbumTracks from "./types/app/rocksky/album/getAlbumTracks"; 26 26 + import type * as AppRockskyAlbumGetAlbums from "./types/app/rocksky/album/getAlbums"; 27 27 import type * as AppRockskyApikeyCreateApikey from "./types/app/rocksky/apikey/createApikey"; 28 28 import type * as AppRockskyApikeyGetApikeys from "./types/app/rocksky/apikey/getApikeys"; 29 29 import type * as AppRockskyApikeyRemoveApikey from "./types/app/rocksky/apikey/removeApikey"; 30 30 import type * as AppRockskyApikeyUpdateApikey from "./types/app/rocksky/apikey/updateApikey"; 31 31 - import type * as AppRockskyArtistGetArtistAlbums from "./types/app/rocksky/artist/getArtistAlbums"; 32 31 import type * as AppRockskyArtistGetArtist from "./types/app/rocksky/artist/getArtist"; 32 32 + import type * as AppRockskyArtistGetArtistAlbums from "./types/app/rocksky/artist/getArtistAlbums"; 33 33 import type * as AppRockskyArtistGetArtistListeners from "./types/app/rocksky/artist/getArtistListeners"; 34 34 + import type * as AppRockskyArtistGetArtistTracks from "./types/app/rocksky/artist/getArtistTracks"; 34 35 import type * as AppRockskyArtistGetArtists from "./types/app/rocksky/artist/getArtists"; 35 35 - import type * as AppRockskyArtistGetArtistTracks from "./types/app/rocksky/artist/getArtistTracks"; 36 36 import type * as AppRockskyChartsGetScrobblesChart from "./types/app/rocksky/charts/getScrobblesChart"; 37 37 import type * as AppRockskyDropboxDownloadFile from "./types/app/rocksky/dropbox/downloadFile"; 38 38 import type * as AppRockskyDropboxGetFiles from "./types/app/rocksky/dropbox/getFiles"; ··· 53 53 import type * as AppRockskyPlayerGetPlaybackQueue from "./types/app/rocksky/player/getPlaybackQueue"; 54 54 import type * as AppRockskyPlayerNext from "./types/app/rocksky/player/next"; 55 55 import type * as AppRockskyPlayerPause from "./types/app/rocksky/player/pause"; 56 56 + import type * as AppRockskyPlayerPlay from "./types/app/rocksky/player/play"; 56 57 import type * as AppRockskyPlayerPlayDirectory from "./types/app/rocksky/player/playDirectory"; 57 58 import type * as AppRockskyPlayerPlayFile from "./types/app/rocksky/player/playFile"; 58 58 - import type * as AppRockskyPlayerPlay from "./types/app/rocksky/player/play"; 59 59 import type * as AppRockskyPlayerPrevious from "./types/app/rocksky/player/previous"; 60 60 import type * as AppRockskyPlayerSeek from "./types/app/rocksky/player/seek"; 61 61 import type * as AppRockskyPlaylistCreatePlaylist from "./types/app/rocksky/playlist/createPlaylist"; ··· 365 365 return this._server.xrpc.method(nsid, cfg); 366 366 } 367 367 368 368 - getAlbums<AV extends AuthVerifier>( 368 368 + getAlbumTracks<AV extends AuthVerifier>( 369 369 cfg: ConfigOf< 370 370 AV, 371 371 - AppRockskyAlbumGetAlbums.Handler<ExtractAuth<AV>>, 372 372 - AppRockskyAlbumGetAlbums.HandlerReqCtx<ExtractAuth<AV>> 371 371 + AppRockskyAlbumGetAlbumTracks.Handler<ExtractAuth<AV>>, 372 372 + AppRockskyAlbumGetAlbumTracks.HandlerReqCtx<ExtractAuth<AV>> 373 373 >, 374 374 ) { 375 375 - const nsid = "app.rocksky.album.getAlbums"; // @ts-ignore 375 375 + const nsid = "app.rocksky.album.getAlbumTracks"; // @ts-ignore 376 376 return this._server.xrpc.method(nsid, cfg); 377 377 } 378 378 379 379 - getAlbumTracks<AV extends AuthVerifier>( 379 379 + getAlbums<AV extends AuthVerifier>( 380 380 cfg: ConfigOf< 381 381 AV, 382 382 - AppRockskyAlbumGetAlbumTracks.Handler<ExtractAuth<AV>>, 383 383 - AppRockskyAlbumGetAlbumTracks.HandlerReqCtx<ExtractAuth<AV>> 382 382 + AppRockskyAlbumGetAlbums.Handler<ExtractAuth<AV>>, 383 383 + AppRockskyAlbumGetAlbums.HandlerReqCtx<ExtractAuth<AV>> 384 384 >, 385 385 ) { 386 386 - const nsid = "app.rocksky.album.getAlbumTracks"; // @ts-ignore 386 386 + const nsid = "app.rocksky.album.getAlbums"; // @ts-ignore 387 387 return this._server.xrpc.method(nsid, cfg); 388 388 } 389 389 } ··· 447 447 this._server = server; 448 448 } 449 449 450 450 - getArtistAlbums<AV extends AuthVerifier>( 450 450 + getArtist<AV extends AuthVerifier>( 451 451 cfg: ConfigOf< 452 452 AV, 453 453 - AppRockskyArtistGetArtistAlbums.Handler<ExtractAuth<AV>>, 454 454 - AppRockskyArtistGetArtistAlbums.HandlerReqCtx<ExtractAuth<AV>> 453 453 + AppRockskyArtistGetArtist.Handler<ExtractAuth<AV>>, 454 454 + AppRockskyArtistGetArtist.HandlerReqCtx<ExtractAuth<AV>> 455 455 >, 456 456 ) { 457 457 - const nsid = "app.rocksky.artist.getArtistAlbums"; // @ts-ignore 457 457 + const nsid = "app.rocksky.artist.getArtist"; // @ts-ignore 458 458 return this._server.xrpc.method(nsid, cfg); 459 459 } 460 460 461 461 - getArtist<AV extends AuthVerifier>( 461 461 + getArtistAlbums<AV extends AuthVerifier>( 462 462 cfg: ConfigOf< 463 463 AV, 464 464 - AppRockskyArtistGetArtist.Handler<ExtractAuth<AV>>, 465 465 - AppRockskyArtistGetArtist.HandlerReqCtx<ExtractAuth<AV>> 464 464 + AppRockskyArtistGetArtistAlbums.Handler<ExtractAuth<AV>>, 465 465 + AppRockskyArtistGetArtistAlbums.HandlerReqCtx<ExtractAuth<AV>> 466 466 >, 467 467 ) { 468 468 - const nsid = "app.rocksky.artist.getArtist"; // @ts-ignore 468 468 + const nsid = "app.rocksky.artist.getArtistAlbums"; // @ts-ignore 469 469 return this._server.xrpc.method(nsid, cfg); 470 470 } 471 471 ··· 480 480 return this._server.xrpc.method(nsid, cfg); 481 481 } 482 482 483 483 - getArtists<AV extends AuthVerifier>( 483 483 + getArtistTracks<AV extends AuthVerifier>( 484 484 cfg: ConfigOf< 485 485 AV, 486 486 - AppRockskyArtistGetArtists.Handler<ExtractAuth<AV>>, 487 487 - AppRockskyArtistGetArtists.HandlerReqCtx<ExtractAuth<AV>> 486 486 + AppRockskyArtistGetArtistTracks.Handler<ExtractAuth<AV>>, 487 487 + AppRockskyArtistGetArtistTracks.HandlerReqCtx<ExtractAuth<AV>> 488 488 >, 489 489 ) { 490 490 - const nsid = "app.rocksky.artist.getArtists"; // @ts-ignore 490 490 + const nsid = "app.rocksky.artist.getArtistTracks"; // @ts-ignore 491 491 return this._server.xrpc.method(nsid, cfg); 492 492 } 493 493 494 494 - getArtistTracks<AV extends AuthVerifier>( 494 494 + getArtists<AV extends AuthVerifier>( 495 495 cfg: ConfigOf< 496 496 AV, 497 497 - AppRockskyArtistGetArtistTracks.Handler<ExtractAuth<AV>>, 498 498 - AppRockskyArtistGetArtistTracks.HandlerReqCtx<ExtractAuth<AV>> 497 497 + AppRockskyArtistGetArtists.Handler<ExtractAuth<AV>>, 498 498 + AppRockskyArtistGetArtists.HandlerReqCtx<ExtractAuth<AV>> 499 499 >, 500 500 ) { 501 501 - const nsid = "app.rocksky.artist.getArtistTracks"; // @ts-ignore 501 501 + const nsid = "app.rocksky.artist.getArtists"; // @ts-ignore 502 502 return this._server.xrpc.method(nsid, cfg); 503 503 } 504 504 } ··· 770 770 return this._server.xrpc.method(nsid, cfg); 771 771 } 772 772 773 773 + play<AV extends AuthVerifier>( 774 774 + cfg: ConfigOf< 775 775 + AV, 776 776 + AppRockskyPlayerPlay.Handler<ExtractAuth<AV>>, 777 777 + AppRockskyPlayerPlay.HandlerReqCtx<ExtractAuth<AV>> 778 778 + >, 779 779 + ) { 780 780 + const nsid = "app.rocksky.player.play"; // @ts-ignore 781 781 + return this._server.xrpc.method(nsid, cfg); 782 782 + } 783 783 + 773 784 playDirectory<AV extends AuthVerifier>( 774 785 cfg: ConfigOf< 775 786 AV, ··· 789 800 >, 790 801 ) { 791 802 const nsid = "app.rocksky.player.playFile"; // @ts-ignore 792 792 - return this._server.xrpc.method(nsid, cfg); 793 793 - } 794 794 - 795 795 - play<AV extends AuthVerifier>( 796 796 - cfg: ConfigOf< 797 797 - AV, 798 798 - AppRockskyPlayerPlay.Handler<ExtractAuth<AV>>, 799 799 - AppRockskyPlayerPlay.HandlerReqCtx<ExtractAuth<AV>> 800 800 - >, 801 801 - ) { 802 802 - const nsid = "app.rocksky.player.play"; // @ts-ignore 803 803 return this._server.xrpc.method(nsid, cfg); 804 804 } 805 805

+95 -91

apps/api/src/lexicon/lexicons.ts

··· 1267 1267 }, 1268 1268 }, 1269 1269 }, 1270 1270 - AppRockskyAlbumGetAlbums: { 1270 1270 + AppRockskyAlbumGetAlbumTracks: { 1271 1271 lexicon: 1, 1272 1272 - id: "app.rocksky.album.getAlbums", 1272 1272 + id: "app.rocksky.album.getAlbumTracks", 1273 1273 defs: { 1274 1274 main: { 1275 1275 type: "query", 1276 1276 - description: "Get albums", 1276 1276 + description: "Get tracks for an album", 1277 1277 parameters: { 1278 1278 type: "params", 1279 1279 + required: ["uri"], 1279 1280 properties: { 1280 1280 - limit: { 1281 1281 - type: "integer", 1282 1282 - description: "The maximum number of albums to return", 1283 1283 - minimum: 1, 1284 1284 - }, 1285 1285 - offset: { 1286 1286 - type: "integer", 1287 1287 - description: "The offset for pagination", 1288 1288 - minimum: 0, 1281 1281 + uri: { 1282 1282 + type: "string", 1283 1283 + description: "The URI of the album to retrieve tracks from", 1284 1284 + format: "at-uri", 1289 1285 }, 1290 1286 }, 1291 1287 }, ··· 1294 1290 schema: { 1295 1291 type: "object", 1296 1292 properties: { 1297 1297 - albums: { 1293 1293 + tracks: { 1298 1294 type: "array", 1299 1295 items: { 1300 1296 type: "ref", 1301 1301 - ref: "lex:app.rocksky.album.defs#albumViewBasic", 1297 1297 + ref: "lex:app.rocksky.song.defs#songViewBasic", 1302 1298 }, 1303 1299 }, 1304 1300 }, ··· 1307 1303 }, 1308 1304 }, 1309 1305 }, 1310 1310 - AppRockskyAlbumGetAlbumTracks: { 1306 1306 + AppRockskyAlbumGetAlbums: { 1311 1307 lexicon: 1, 1312 1312 - id: "app.rocksky.album.getAlbumTracks", 1308 1308 + id: "app.rocksky.album.getAlbums", 1313 1309 defs: { 1314 1310 main: { 1315 1311 type: "query", 1316 1316 - description: "Get tracks for an album", 1312 1312 + description: "Get albums", 1317 1313 parameters: { 1318 1314 type: "params", 1319 1319 - required: ["uri"], 1320 1315 properties: { 1321 1321 - uri: { 1322 1322 - type: "string", 1323 1323 - description: "The URI of the album to retrieve tracks from", 1324 1324 - format: "at-uri", 1316 1316 + limit: { 1317 1317 + type: "integer", 1318 1318 + description: "The maximum number of albums to return", 1319 1319 + minimum: 1, 1320 1320 + }, 1321 1321 + offset: { 1322 1322 + type: "integer", 1323 1323 + description: "The offset for pagination", 1324 1324 + minimum: 0, 1325 1325 }, 1326 1326 }, 1327 1327 }, ··· 1330 1330 schema: { 1331 1331 type: "object", 1332 1332 properties: { 1333 1333 - tracks: { 1333 1333 + albums: { 1334 1334 type: "array", 1335 1335 items: { 1336 1336 type: "ref", 1337 1337 - ref: "lex:app.rocksky.song.defs#songViewBasic", 1337 1337 + ref: "lex:app.rocksky.album.defs#albumViewBasic", 1338 1338 }, 1339 1339 }, 1340 1340 }, ··· 1737 1737 }, 1738 1738 }, 1739 1739 }, 1740 1740 + AppRockskyArtistGetArtist: { 1741 1741 + lexicon: 1, 1742 1742 + id: "app.rocksky.artist.getArtist", 1743 1743 + defs: { 1744 1744 + main: { 1745 1745 + type: "query", 1746 1746 + description: "Get artist details", 1747 1747 + parameters: { 1748 1748 + type: "params", 1749 1749 + required: ["uri"], 1750 1750 + properties: { 1751 1751 + uri: { 1752 1752 + type: "string", 1753 1753 + description: "The URI of the artist to retrieve details from", 1754 1754 + format: "at-uri", 1755 1755 + }, 1756 1756 + }, 1757 1757 + }, 1758 1758 + output: { 1759 1759 + encoding: "application/json", 1760 1760 + schema: { 1761 1761 + type: "ref", 1762 1762 + ref: "lex:app.rocksky.artist.defs#artistViewDetailed", 1763 1763 + }, 1764 1764 + }, 1765 1765 + }, 1766 1766 + }, 1767 1767 + }, 1740 1768 AppRockskyArtistGetArtistAlbums: { 1741 1769 lexicon: 1, 1742 1770 id: "app.rocksky.artist.getArtistAlbums", ··· 1768 1796 }, 1769 1797 }, 1770 1798 }, 1771 1771 - }, 1772 1772 - }, 1773 1773 - }, 1774 1774 - }, 1775 1775 - }, 1776 1776 - AppRockskyArtistGetArtist: { 1777 1777 - lexicon: 1, 1778 1778 - id: "app.rocksky.artist.getArtist", 1779 1779 - defs: { 1780 1780 - main: { 1781 1781 - type: "query", 1782 1782 - description: "Get artist details", 1783 1783 - parameters: { 1784 1784 - type: "params", 1785 1785 - required: ["uri"], 1786 1786 - properties: { 1787 1787 - uri: { 1788 1788 - type: "string", 1789 1789 - description: "The URI of the artist to retrieve details from", 1790 1790 - format: "at-uri", 1791 1791 - }, 1792 1792 - }, 1793 1793 - }, 1794 1794 - output: { 1795 1795 - encoding: "application/json", 1796 1796 - schema: { 1797 1797 - type: "ref", 1798 1798 - ref: "lex:app.rocksky.artist.defs#artistViewDetailed", 1799 1799 }, 1800 1800 }, 1801 1801 }, ··· 1845 1844 }, 1846 1845 }, 1847 1846 }, 1848 1848 - AppRockskyArtistGetArtists: { 1847 1847 + AppRockskyArtistGetArtistTracks: { 1849 1848 lexicon: 1, 1850 1850 - id: "app.rocksky.artist.getArtists", 1849 1849 + id: "app.rocksky.artist.getArtistTracks", 1851 1850 defs: { 1852 1851 main: { 1853 1852 type: "query", 1854 1854 - description: "Get artists", 1853 1853 + description: "Get artist's tracks", 1855 1854 parameters: { 1856 1855 type: "params", 1857 1856 properties: { 1857 1857 + uri: { 1858 1858 + type: "string", 1859 1859 + description: "The URI of the artist to retrieve albums from", 1860 1860 + format: "at-uri", 1861 1861 + }, 1858 1862 limit: { 1859 1863 type: "integer", 1860 1860 - description: "The maximum number of artists to return", 1864 1864 + description: "The maximum number of tracks to return", 1861 1865 minimum: 1, 1862 1866 }, 1863 1867 offset: { ··· 1872 1876 schema: { 1873 1877 type: "object", 1874 1878 properties: { 1875 1875 - artists: { 1879 1879 + tracks: { 1876 1880 type: "array", 1877 1881 items: { 1878 1882 type: "ref", 1879 1879 - ref: "lex:app.rocksky.artist.defs#artistViewBasic", 1883 1883 + ref: "lex:app.rocksky.song.defs#songViewBasic", 1880 1884 }, 1881 1885 }, 1882 1886 }, ··· 1885 1889 }, 1886 1890 }, 1887 1891 }, 1888 1888 - AppRockskyArtistGetArtistTracks: { 1892 1892 + AppRockskyArtistGetArtists: { 1889 1893 lexicon: 1, 1890 1890 - id: "app.rocksky.artist.getArtistTracks", 1894 1894 + id: "app.rocksky.artist.getArtists", 1891 1895 defs: { 1892 1896 main: { 1893 1897 type: "query", 1894 1894 - description: "Get artist's tracks", 1898 1898 + description: "Get artists", 1895 1899 parameters: { 1896 1900 type: "params", 1897 1901 properties: { 1898 1898 - uri: { 1899 1899 - type: "string", 1900 1900 - description: "The URI of the artist to retrieve albums from", 1901 1901 - format: "at-uri", 1902 1902 - }, 1903 1902 limit: { 1904 1903 type: "integer", 1905 1905 - description: "The maximum number of tracks to return", 1904 1904 + description: "The maximum number of artists to return", 1906 1905 minimum: 1, 1907 1906 }, 1908 1907 offset: { 1909 1908 type: "integer", 1910 1909 description: "The offset for pagination", 1911 1910 minimum: 0, 1911 1911 + }, 1912 1912 + names: { 1913 1913 + type: "string", 1914 1914 + description: "The names of the artists to return", 1912 1915 }, 1913 1916 }, 1914 1917 }, ··· 1917 1920 schema: { 1918 1921 type: "object", 1919 1922 properties: { 1920 1920 - tracks: { 1923 1923 + artists: { 1921 1924 type: "array", 1922 1925 items: { 1923 1926 type: "ref", 1924 1924 - ref: "lex:app.rocksky.song.defs#songViewBasic", 1927 1927 + ref: "lex:app.rocksky.artist.defs#artistViewBasic", 1925 1928 }, 1926 1929 }, 1927 1930 }, ··· 2807 2810 }, 2808 2811 }, 2809 2812 }, 2813 2813 + AppRockskyPlayerPlay: { 2814 2814 + lexicon: 1, 2815 2815 + id: "app.rocksky.player.play", 2816 2816 + defs: { 2817 2817 + main: { 2818 2818 + type: "procedure", 2819 2819 + description: "Resume playback of the currently paused track", 2820 2820 + parameters: { 2821 2821 + type: "params", 2822 2822 + properties: { 2823 2823 + playerId: { 2824 2824 + type: "string", 2825 2825 + }, 2826 2826 + }, 2827 2827 + }, 2828 2828 + }, 2829 2829 + }, 2830 2830 + }, 2810 2831 AppRockskyPlayerPlayDirectory: { 2811 2832 lexicon: 1, 2812 2833 id: "app.rocksky.player.playDirectory", ··· 2853 2874 type: "string", 2854 2875 }, 2855 2876 fileId: { 2856 2856 - type: "string", 2857 2857 - }, 2858 2858 - }, 2859 2859 - }, 2860 2860 - }, 2861 2861 - }, 2862 2862 - }, 2863 2863 - AppRockskyPlayerPlay: { 2864 2864 - lexicon: 1, 2865 2865 - id: "app.rocksky.player.play", 2866 2866 - defs: { 2867 2867 - main: { 2868 2868 - type: "procedure", 2869 2869 - description: "Resume playback of the currently paused track", 2870 2870 - parameters: { 2871 2871 - type: "params", 2872 2872 - properties: { 2873 2873 - playerId: { 2874 2877 type: "string", 2875 2878 }, 2876 2879 }, ··· 5099 5102 AppRockskyAlbum: "app.rocksky.album", 5100 5103 AppRockskyAlbumDefs: "app.rocksky.album.defs", 5101 5104 AppRockskyAlbumGetAlbum: "app.rocksky.album.getAlbum", 5102 5102 - AppRockskyAlbumGetAlbums: "app.rocksky.album.getAlbums", 5103 5105 AppRockskyAlbumGetAlbumTracks: "app.rocksky.album.getAlbumTracks", 5106 5106 + AppRockskyAlbumGetAlbums: "app.rocksky.album.getAlbums", 5104 5107 AppRockskyApikeyCreateApikey: "app.rocksky.apikey.createApikey", 5105 5108 AppRockskyApikeyDefs: "app.rocksky.apikey.defs", 5106 5109 AppRockskyApikeysDefs: "app.rocksky.apikeys.defs", ··· 5109 5112 AppRockskyApikeyUpdateApikey: "app.rocksky.apikey.updateApikey", 5110 5113 AppRockskyArtist: "app.rocksky.artist", 5111 5114 AppRockskyArtistDefs: "app.rocksky.artist.defs", 5112 5112 - AppRockskyArtistGetArtistAlbums: "app.rocksky.artist.getArtistAlbums", 5113 5115 AppRockskyArtistGetArtist: "app.rocksky.artist.getArtist", 5116 5116 + AppRockskyArtistGetArtistAlbums: "app.rocksky.artist.getArtistAlbums", 5114 5117 AppRockskyArtistGetArtistListeners: "app.rocksky.artist.getArtistListeners", 5115 5115 - AppRockskyArtistGetArtists: "app.rocksky.artist.getArtists", 5116 5118 AppRockskyArtistGetArtistTracks: "app.rocksky.artist.getArtistTracks", 5119 5119 + AppRockskyArtistGetArtists: "app.rocksky.artist.getArtists", 5117 5120 AppRockskyChartsDefs: "app.rocksky.charts.defs", 5118 5121 AppRockskyChartsGetScrobblesChart: "app.rocksky.charts.getScrobblesChart", 5119 5122 AppRockskyDropboxDefs: "app.rocksky.dropbox.defs", ··· 5141 5144 AppRockskyPlayerGetPlaybackQueue: "app.rocksky.player.getPlaybackQueue", 5142 5145 AppRockskyPlayerNext: "app.rocksky.player.next", 5143 5146 AppRockskyPlayerPause: "app.rocksky.player.pause", 5147 5147 + AppRockskyPlayerPlay: "app.rocksky.player.play", 5144 5148 AppRockskyPlayerPlayDirectory: "app.rocksky.player.playDirectory", 5145 5149 AppRockskyPlayerPlayFile: "app.rocksky.player.playFile", 5146 5146 - AppRockskyPlayerPlay: "app.rocksky.player.play", 5147 5150 AppRockskyPlayerPrevious: "app.rocksky.player.previous", 5148 5151 AppRockskyPlayerSeek: "app.rocksky.player.seek", 5149 5152 AppRockskyPlaylistCreatePlaylist: "app.rocksky.playlist.createPlaylist",

+2

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

··· 14 14 limit?: number; 15 15 /** The offset for pagination */ 16 16 offset?: number; 17 17 + /** The names of the artists to return */ 18 18 + names?: string; 17 19 } 18 20 19 21 export type InputSchema = undefined;

+46 -46

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

··· 26 26 27 27 export async function putArtistRecord( 28 28 track: Track, 29 29 - agent: Agent 29 29 + agent: Agent, 30 30 ): Promise<string | null> { 31 31 const rkey = TID.nextStr(); 32 32 const record: Artist.Record = { ··· 62 62 63 63 export async function putAlbumRecord( 64 64 track: Track, 65 65 - agent: Agent 65 65 + agent: Agent, 66 66 ): Promise<string | null> { 67 67 const rkey = TID.nextStr(); 68 68 ··· 103 103 104 104 export async function putSongRecord( 105 105 track: Track, 106 106 - agent: Agent 106 106 + agent: Agent, 107 107 ): Promise<string | null> { 108 108 const rkey = TID.nextStr(); 109 109 ··· 158 158 159 159 async function putScrobbleRecord( 160 160 track: Track, 161 161 - agent: Agent 161 161 + agent: Agent, 162 162 ): Promise<string | null> { 163 163 const rkey = TID.nextStr(); 164 164 ··· 276 276 .where( 277 277 and( 278 278 eq(artistAlbums.albumId, scrobble.album.id), 279 279 - eq(artistAlbums.artistId, scrobble.artist.id) 280 280 - ) 279 279 + eq(artistAlbums.artistId, scrobble.artist.id), 280 280 + ), 281 281 ) 282 282 .limit(1) 283 283 .then((rows) => rows[0]), ··· 440 440 }, 441 441 }), 442 442 null, 443 443 - 2 443 443 + 2, 444 444 ); 445 445 446 446 ctx.nc.publish( 447 447 "rocksky.scrobble", 448 448 - Buffer.from(message.replaceAll("sha_256", "sha256")) 448 448 + Buffer.from(message.replaceAll("sha_256", "sha256")), 449 449 ); 450 450 451 451 const trackMessage = JSON.stringify( ··· 492 492 xata_createdat: artist_album.createdAt.toISOString(), 493 493 xata_updatedat: artist_album.updatedAt.toISOString(), 494 494 }, 495 495 - }) 495 495 + }), 496 496 ); 497 497 498 498 ctx.nc.publish( 499 499 "rocksky.track", 500 500 - Buffer.from(trackMessage.replaceAll("sha_256", "sha256")) 500 500 + Buffer.from(trackMessage.replaceAll("sha_256", "sha256")), 501 501 ); 502 502 } 503 503 ··· 505 505 ctx: Context, 506 506 track: Track, 507 507 agent: Agent, 508 508 - userDid: string 508 508 + userDid: string, 509 509 ): Promise<void> { 510 510 // check if scrobble already exists (user did + timestamp) 511 511 const scrobbleTime = dayjs.unix(track.timestamp || dayjs().unix()); ··· 524 524 eq(tracks.title, track.title), 525 525 eq(tracks.artist, track.artist), 526 526 gte(scrobbles.timestamp, scrobbleTime.subtract(60, "seconds").toDate()), 527 527 - lte(scrobbles.timestamp, scrobbleTime.add(60, "seconds").toDate()) 528 528 - ) 527 527 + lte(scrobbles.timestamp, scrobbleTime.add(60, "seconds").toDate()), 528 528 + ), 529 529 ) 530 530 .limit(1) 531 531 .then((rows) => rows[0]); ··· 533 533 if (existingScrobble) { 534 534 console.log( 535 535 `Scrobble already exists for ${chalk.cyan(track.title)} at ${chalk.cyan( 536 536 - scrobbleTime.format("YYYY-MM-DD HH:mm:ss") 537 537 - )}` 536 536 + scrobbleTime.format("YYYY-MM-DD HH:mm:ss"), 537 537 + )}`, 538 538 ); 539 539 return; 540 540 } ··· 547 547 tracks.sha256, 548 548 createHash("sha256") 549 549 .update( 550 550 - `${track.title} - ${track.artist} - ${track.album}`.toLowerCase() 550 550 + `${track.title} - ${track.artist} - ${track.album}`.toLowerCase(), 551 551 ) 552 552 - .digest("hex") 553 553 - ) 552 552 + .digest("hex"), 553 553 + ), 554 554 ) 555 555 .limit(1) 556 556 .then((rows) => rows[0]); ··· 564 564 albums.sha256, 565 565 createHash("sha256") 566 566 .update(`${track.album} - ${track.albumArtist}`.toLowerCase()) 567 567 - .digest("hex") 568 568 - ) 567 567 + .digest("hex"), 568 568 + ), 569 569 ) 570 570 .limit(1) 571 571 .then((rows) => rows[0]); ··· 586 586 artists.sha256, 587 587 createHash("sha256") 588 588 .update(track.albumArtist.toLowerCase()) 589 589 - .digest("hex") 590 590 - ) 589 589 + .digest("hex"), 590 590 + ), 591 591 ) 592 592 .limit(1) 593 593 .then((rows) => rows[0]); ··· 621 621 .map((a) => ({ name: a.trim() })), 622 622 name: track.title, 623 623 album: track.album, 624 624 - } 624 624 + }, 625 625 ); 626 626 627 627 if (!mbTrack?.trackMBID) { ··· 650 650 albums.sha256, 651 651 createHash("sha256") 652 652 .update(`${track.album} - ${track.albumArtist}`.toLowerCase()) 653 653 - .digest("hex") 654 654 - ) 653 653 + .digest("hex"), 654 654 + ), 655 655 ) 656 656 .limit(1) 657 657 .then((rows) => rows[0]); ··· 667 667 tracks.sha256, 668 668 createHash("sha256") 669 669 .update( 670 670 - `${track.title} - ${track.artist} - ${track.album}`.toLowerCase() 670 670 + `${track.title} - ${track.artist} - ${track.album}`.toLowerCase(), 671 671 ) 672 672 - .digest("hex") 673 673 - ) 672 672 + .digest("hex"), 673 673 + ), 674 674 ) 675 675 .limit(1) 676 676 .then((rows) => rows[0]); ··· 684 684 685 685 if (existingTrack) { 686 686 console.log( 687 687 - `Song found: ${chalk.cyan(existingTrack.id)} - ${track.title}, after ${chalk.magenta(tries)} tries` 687 687 + `Song found: ${chalk.cyan(existingTrack.id)} - ${track.title}, after ${chalk.magenta(tries)} tries`, 688 688 ); 689 689 } 690 690 ··· 697 697 artists.sha256, 698 698 createHash("sha256") 699 699 .update(track.albumArtist.toLowerCase()) 700 700 - .digest("hex") 700 700 + .digest("hex"), 701 701 ), 702 702 eq( 703 703 artists.sha256, 704 704 - createHash("sha256").update(track.artist.toLowerCase()).digest("hex") 705 705 - ) 706 706 - ) 704 704 + createHash("sha256").update(track.artist.toLowerCase()).digest("hex"), 705 705 + ), 706 706 + ), 707 707 ) 708 708 .limit(1) 709 709 .then((rows) => rows[0]); ··· 718 718 .innerJoin(artists, eq(userArtists.artistId, artists.id)) 719 719 .innerJoin(users, eq(userArtists.userId, users.id)) 720 720 .where( 721 721 - and(eq(artists.id, existingArtist?.id || ""), eq(users.did, userDid)) 721 721 + and(eq(artists.id, existingArtist?.id || ""), eq(users.did, userDid)), 722 722 ) 723 723 .limit(1) 724 724 .then((rows) => rows[0]); ··· 753 753 tracks.sha256, 754 754 createHash("sha256") 755 755 .update( 756 756 - `${track.title} - ${track.artist} - ${track.album}`.toLowerCase() 756 756 + `${track.title} - ${track.artist} - ${track.album}`.toLowerCase(), 757 757 ) 758 758 - .digest("hex") 759 759 - ) 758 758 + .digest("hex"), 759 759 + ), 760 760 ) 761 761 .limit(1) 762 762 .then((rows) => rows[0]); 763 763 764 764 while (!existingTrack?.artistUri && !existingTrack?.albumUri && tries < 30) { 765 765 console.log( 766 766 - `Artist uri not ready, trying again: ${chalk.magenta(tries + 1)}` 766 766 + `Artist uri not ready, trying again: ${chalk.magenta(tries + 1)}`, 767 767 ); 768 768 existingTrack = await ctx.db 769 769 .select() ··· 773 773 tracks.sha256, 774 774 createHash("sha256") 775 775 .update( 776 776 - `${track.title} - ${track.artist} - ${track.album}`.toLowerCase() 776 776 + `${track.title} - ${track.artist} - ${track.album}`.toLowerCase(), 777 777 ) 778 778 - .digest("hex") 779 779 - ) 778 778 + .digest("hex"), 779 779 + ), 780 780 ) 781 781 .limit(1) 782 782 .then((rows) => rows[0]); ··· 791 791 artists.sha256, 792 792 createHash("sha256") 793 793 .update(track.albumArtist.toLowerCase()) 794 794 - .digest("hex") 795 795 - ) 794 794 + .digest("hex"), 795 795 + ), 796 796 ) 797 797 .limit(1) 798 798 .then((rows) => rows[0]); ··· 815 815 albums.sha256, 816 816 createHash("sha256") 817 817 .update(`${track.album} - ${track.albumArtist}`.toLowerCase()) 818 818 - .digest("hex") 819 819 - ) 818 818 + .digest("hex"), 819 819 + ), 820 820 ) 821 821 .limit(1) 822 822 .then((rows) => rows[0]); ··· 846 846 847 847 if (existingTrack?.artistUri) { 848 848 console.log( 849 849 - `Artist uri ready: ${chalk.cyan(existingTrack.id)} - ${track.title}, after ${chalk.magenta(tries)} tries` 849 849 + `Artist uri ready: ${chalk.cyan(existingTrack.id)} - ${track.title}, after ${chalk.magenta(tries)} tries`, 850 850 ); 851 851 } 852 852

+1 -3

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

··· 9 9 import users from "./users"; 10 10 11 11 const spotifyAccounts = pgTable("spotify_accounts", { 12 12 - id: text("xata_id") 13 13 - .primaryKey() 14 14 - .default(sql`xata_id()`), 12 12 + id: text("xata_id").primaryKey().default(sql`xata_id()`), 15 13 xataVersion: integer("xata_version"), 16 14 email: text("email").notNull(), 17 15 userId: text("user_id")

+1 -3

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

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

+1 -3

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

··· 3 3 import users from "./users"; 4 4 5 5 const spotifyTokens = pgTable("spotify_tokens", { 6 6 - id: text("xata_id") 7 7 - .primaryKey() 8 8 - .default(sql`xata_id()`), 6 6 + id: text("xata_id").primaryKey().default(sql`xata_id()`), 9 7 xataVersion: integer("xata_version"), 10 8 accessToken: text("access_token").notNull(), 11 9 refreshToken: text("refresh_token").notNull(),

+6 -6

apps/api/src/scripts/genres.ts

··· 11 11 .from(tables.spotifyTokens) 12 12 .leftJoin( 13 13 tables.spotifyAccounts, 14 14 - eq(tables.spotifyAccounts.userId, tables.spotifyTokens.userId) 14 14 + eq(tables.spotifyAccounts.userId, tables.spotifyTokens.userId), 15 15 ) 16 16 .leftJoin( 17 17 tables.spotifyApps, 18 18 - eq(tables.spotifyApps.spotifyAppId, tables.spotifyTokens.spotifyAppId) 18 18 + eq(tables.spotifyApps.spotifyAppId, tables.spotifyTokens.spotifyAppId), 19 19 ) 20 20 .where(eq(tables.spotifyAccounts.isBetaUser, true)) 21 21 .execute(); ··· 24 24 spotifyTokens[Math.floor(Math.random() * spotifyTokens.length)]; 25 25 const refreshToken = decrypt( 26 26 record.spotify_tokens.refreshToken, 27 27 - env.SPOTIFY_ENCRYPTION_KEY 27 27 + env.SPOTIFY_ENCRYPTION_KEY, 28 28 ); 29 29 30 30 const accessToken = await fetch("https://accounts.spotify.com/api/token", { ··· 38 38 client_id: record.spotify_apps.spotifyAppId, 39 39 client_secret: decrypt( 40 40 record.spotify_apps.spotifySecret, 41 41 - env.SPOTIFY_ENCRYPTION_KEY 41 41 + env.SPOTIFY_ENCRYPTION_KEY, 42 42 ), 43 43 }), 44 44 }) ··· 60 60 headers: { 61 61 Authorization: `Bearer ${token}`, 62 62 }, 63 63 - } 63 63 + }, 64 64 ) 65 65 .then( 66 66 (res) => ··· 73 73 images: Array<{ url: string }>; 74 74 }>; 75 75 }; 76 76 - }> 76 76 + }>, 77 77 ) 78 78 .then(async (data) => _.get(data, "artists.items.0")); 79 79

+2 -2

apps/api/src/scripts/spotify.ts

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

+1 -1

apps/api/src/scripts/sync.ts

··· 143 143 } catch (err) { 144 144 console.error( 145 145 `Failed to sync scrobble ${chalk.cyan(scrobble.id)}:`, 146 146 - err 146 146 + err, 147 147 ); 148 148 } 149 149 }

+1 -1

apps/api/src/server.ts

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

+30 -30

apps/api/src/spotify/app.ts

··· 24 24 limit: 10, // max Spotify API calls 25 25 window: 15, // per 10 seconds 26 26 keyPrefix: "spotify-ratelimit", 27 27 - }) 27 27 + }), 28 28 ); 29 29 30 30 app.get("/login", async (c) => { ··· 58 58 .leftJoin(users, eq(spotifyAccounts.userId, users.id)) 59 59 .leftJoin( 60 60 spotifyApps, 61 61 - eq(spotifyAccounts.spotifyAppId, spotifyApps.spotifyAppId) 61 61 + eq(spotifyAccounts.spotifyAppId, spotifyApps.spotifyAppId), 62 62 ) 63 63 .where( 64 64 and( 65 65 eq(spotifyAccounts.userId, user.id), 66 66 - eq(spotifyAccounts.isBetaUser, true) 67 67 - ) 66 66 + eq(spotifyAccounts.isBetaUser, true), 67 67 + ), 68 68 ) 69 69 .limit(1) 70 70 .then((rows) => rows[0]); ··· 74 74 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}`; 75 75 c.header( 76 76 "Set-Cookie", 77 77 - `session-id=${state}; Path=/; HttpOnly; SameSite=Strict; Secure` 77 77 + `session-id=${state}; Path=/; HttpOnly; SameSite=Strict; Secure`, 78 78 ); 79 79 return c.json({ redirectUrl }); 80 80 }); ··· 110 110 .from(spotifyAccounts) 111 111 .leftJoin( 112 112 spotifyApps, 113 113 - eq(spotifyAccounts.spotifyAppId, spotifyApps.spotifyAppId) 113 113 + eq(spotifyAccounts.spotifyAppId, spotifyApps.spotifyAppId), 114 114 ) 115 115 .where( 116 116 and( 117 117 eq(spotifyAccounts.userId, user.id), 118 118 - eq(spotifyAccounts.isBetaUser, true) 119 119 - ) 118 118 + eq(spotifyAccounts.isBetaUser, true), 119 119 + ), 120 120 ) 121 121 .limit(1) 122 122 .then((rows) => rows[0]); ··· 179 179 .where( 180 180 and( 181 181 eq(spotifyAccounts.userId, user.id), 182 182 - eq(spotifyAccounts.isBetaUser, true) 183 183 - ) 182 182 + eq(spotifyAccounts.isBetaUser, true), 183 183 + ), 184 184 ) 185 185 .limit(1) 186 186 .then((rows) => rows[0]); ··· 230 230 appId: spotifyApps.id, 231 231 spotifyAppId: spotifyApps.spotifyAppId, 232 232 accountCount: sql<number>`COUNT(${spotifyAccounts.id})`.as( 233 233 - "account_count" 233 233 + "account_count", 234 234 ), 235 235 }) 236 236 .from(spotifyApps) ··· 311 311 } 312 312 313 313 const cached = await ctx.redis.get( 314 314 - `${spotifyAccount.spotifyAccount.email}:current` 314 314 + `${spotifyAccount.spotifyAccount.email}:current`, 315 315 ); 316 316 if (!cached) { 317 317 return c.json({}); ··· 321 321 322 322 const sha256 = createHash("sha256") 323 323 .update( 324 324 - `${track.item.name} - ${track.item.artists.map((x) => x.name).join(", ")} - ${track.item.album.name}`.toLowerCase() 324 324 + `${track.item.name} - ${track.item.artists.map((x) => x.name).join(", ")} - ${track.item.album.name}`.toLowerCase(), 325 325 ) 326 326 .digest("hex"); 327 327 ··· 385 385 .from(spotifyTokens) 386 386 .leftJoin( 387 387 spotifyApps, 388 388 - eq(spotifyTokens.spotifyAppId, spotifyApps.spotifyAppId) 388 388 + eq(spotifyTokens.spotifyAppId, spotifyApps.spotifyAppId), 389 389 ) 390 390 .where(eq(spotifyTokens.userId, user.id)) 391 391 .limit(1) ··· 398 398 399 399 const refreshToken = decrypt( 400 400 spotifyToken.spotify_tokens.refreshToken, 401 401 - env.SPOTIFY_ENCRYPTION_KEY 401 401 + env.SPOTIFY_ENCRYPTION_KEY, 402 402 ); 403 403 404 404 // get new access token ··· 413 413 client_id: spotifyToken.spotify_apps.spotifyAppId, 414 414 client_secret: decrypt( 415 415 spotifyToken.spotify_apps.spotifySecret, 416 416 - env.SPOTIFY_ENCRYPTION_KEY 416 416 + env.SPOTIFY_ENCRYPTION_KEY, 417 417 ), 418 418 }), 419 419 }); ··· 468 468 .from(spotifyTokens) 469 469 .leftJoin( 470 470 spotifyApps, 471 471 - eq(spotifyTokens.spotifyAppId, spotifyApps.spotifyAppId) 471 471 + eq(spotifyTokens.spotifyAppId, spotifyApps.spotifyAppId), 472 472 ) 473 473 .where(eq(spotifyTokens.userId, user.id)) 474 474 .limit(1) ··· 481 481 482 482 const refreshToken = decrypt( 483 483 spotifyToken.spotify_tokens.refreshToken, 484 484 - env.SPOTIFY_ENCRYPTION_KEY 484 484 + env.SPOTIFY_ENCRYPTION_KEY, 485 485 ); 486 486 487 487 // get new access token ··· 496 496 client_id: spotifyToken.spotify_apps.spotifyAppId, 497 497 client_secret: decrypt( 498 498 spotifyToken.spotify_apps.spotifySecret, 499 499 - env.SPOTIFY_ENCRYPTION_KEY 499 499 + env.SPOTIFY_ENCRYPTION_KEY, 500 500 ), 501 501 }), 502 502 }); ··· 551 551 .from(spotifyTokens) 552 552 .leftJoin( 553 553 spotifyApps, 554 554 - eq(spotifyTokens.spotifyAppId, spotifyApps.spotifyAppId) 554 554 + eq(spotifyTokens.spotifyAppId, spotifyApps.spotifyAppId), 555 555 ) 556 556 .where(eq(spotifyTokens.userId, user.id)) 557 557 .limit(1) ··· 564 564 565 565 const refreshToken = decrypt( 566 566 spotifyToken.spotify_tokens.refreshToken, 567 567 - env.SPOTIFY_ENCRYPTION_KEY 567 567 + env.SPOTIFY_ENCRYPTION_KEY, 568 568 ); 569 569 570 570 // get new access token ··· 579 579 client_id: spotifyToken.spotify_apps.spotifyAppId, 580 580 client_secret: decrypt( 581 581 spotifyToken.spotify_apps.spotifySecret, 582 582 - env.SPOTIFY_ENCRYPTION_KEY 582 582 + env.SPOTIFY_ENCRYPTION_KEY, 583 583 ), 584 584 }), 585 585 }); ··· 634 634 .from(spotifyTokens) 635 635 .leftJoin( 636 636 spotifyApps, 637 637 - eq(spotifyTokens.spotifyAppId, spotifyApps.spotifyAppId) 637 637 + eq(spotifyTokens.spotifyAppId, spotifyApps.spotifyAppId), 638 638 ) 639 639 .where(eq(spotifyTokens.userId, user.id)) 640 640 .limit(1) ··· 647 647 648 648 const refreshToken = decrypt( 649 649 spotifyToken.spotify_tokens.refreshToken, 650 650 - env.SPOTIFY_ENCRYPTION_KEY 650 650 + env.SPOTIFY_ENCRYPTION_KEY, 651 651 ); 652 652 653 653 // get new access token ··· 662 662 client_id: spotifyToken.spotify_apps.spotifyAppId, 663 663 client_secret: decrypt( 664 664 spotifyToken.spotify_apps.spotifySecret, 665 665 - env.SPOTIFY_ENCRYPTION_KEY 665 665 + env.SPOTIFY_ENCRYPTION_KEY, 666 666 ), 667 667 }), 668 668 }); ··· 678 678 headers: { 679 679 Authorization: `Bearer ${access_token}`, 680 680 }, 681 681 - } 681 681 + }, 682 682 ); 683 683 684 684 if (response.status === 403) { ··· 720 720 .from(spotifyTokens) 721 721 .leftJoin( 722 722 spotifyApps, 723 723 - eq(spotifyTokens.spotifyAppId, spotifyApps.spotifyAppId) 723 723 + eq(spotifyTokens.spotifyAppId, spotifyApps.spotifyAppId), 724 724 ) 725 725 .where(eq(spotifyTokens.userId, user.id)) 726 726 .limit(1) ··· 733 733 734 734 const refreshToken = decrypt( 735 735 spotifyToken.spotify_tokens.refreshToken, 736 736 - env.SPOTIFY_ENCRYPTION_KEY 736 736 + env.SPOTIFY_ENCRYPTION_KEY, 737 737 ); 738 738 739 739 // get new access token ··· 748 748 client_id: spotifyToken.spotify_apps.spotifyAppId, 749 749 client_secret: decrypt( 750 750 spotifyToken.spotify_apps.spotifySecret, 751 751 - env.SPOTIFY_ENCRYPTION_KEY 751 751 + env.SPOTIFY_ENCRYPTION_KEY, 752 752 ), 753 753 }), 754 754 }); ··· 765 765 headers: { 766 766 Authorization: `Bearer ${access_token}`, 767 767 }, 768 768 - } 768 768 + }, 769 769 ); 770 770 771 771 if (response.status === 403) {

+6 -8

apps/api/src/tealfm/index.ts

··· 35 35 record?.trackName === track.name)) && 36 36 // diff in seconds less than 60 seconds 37 37 Math.abs( 38 38 - new Date(record.playedTime).getTime() - 39 39 - new Date(track.timestamp).getTime(), 40 40 - ) < 60000 38 38 + new Date(record.playedTime).getTime() - 39 39 + new Date(track.timestamp).getTime(), 40 40 + ) < 60000 41 41 ); 42 42 }); 43 43 if (alreadyPlayed) { 44 44 console.log( 45 45 - `Track ${chalk.cyan(track.name)} by ${ 46 46 - chalk.cyan( 47 47 - track.artist.map((a) => a.name).join(", "), 48 48 - ) 49 49 - } already played recently. Skipping...`, 45 45 + `Track ${chalk.cyan(track.name)} by ${chalk.cyan( 46 46 + track.artist.map((a) => a.name).join(", "), 47 47 + )} already played recently. Skipping...`, 50 48 ); 51 49 return; 52 50 }

+9 -9

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

··· 33 33 Effect.catchAll((err) => { 34 34 console.error(err); 35 35 return Effect.succeed({}); 36 36 - }) 36 36 + }), 37 37 ); 38 38 server.app.rocksky.actor.getProfile({ 39 39 auth: ctx.authVerifier, ··· 194 194 .from(tables.spotifyAccounts) 195 195 .leftJoin( 196 196 tables.users, 197 197 - eq(tables.spotifyAccounts.userId, tables.users.id) 197 197 + eq(tables.spotifyAccounts.userId, tables.users.id), 198 198 ) 199 199 .where(eq(tables.users.did, did)) 200 200 .execute() ··· 204 204 .from(tables.spotifyTokens) 205 205 .leftJoin( 206 206 tables.users, 207 207 - eq(tables.spotifyTokens.userId, tables.users.id) 207 207 + eq(tables.spotifyTokens.userId, tables.users.id), 208 208 ) 209 209 .where(eq(tables.users.did, did)) 210 210 .execute() ··· 214 214 .from(tables.googleDriveAccounts) 215 215 .leftJoin( 216 216 tables.users, 217 217 - eq(tables.googleDriveAccounts.userId, tables.users.id) 217 217 + eq(tables.googleDriveAccounts.userId, tables.users.id), 218 218 ) 219 219 .where(eq(tables.users.did, did)) 220 220 .execute() ··· 224 224 .from(tables.dropboxAccounts) 225 225 .leftJoin( 226 226 tables.users, 227 227 - eq(tables.dropboxAccounts.userId, tables.users.id) 227 227 + eq(tables.dropboxAccounts.userId, tables.users.id), 228 228 ) 229 229 .where(eq(tables.users.did, did)) 230 230 .execute() ··· 280 280 xata_createdat: profile.user.createdAt.toISOString(), 281 281 xata_updatedat: profile.user.updatedAt.toISOString(), 282 282 xata_version: 1, 283 283 - }) 284 284 - ) 283 283 + }), 284 284 + ), 285 285 ); 286 286 } else { 287 287 // Update existing user in background if handle or avatar or displayName changed ··· 314 314 xata_createdat: profile.user.createdAt.toISOString(), 315 315 xata_updatedat: new Date().toISOString(), 316 316 xata_version: (profile.user.xataVersion || 1) + 1, 317 317 - }) 318 318 - ) 317 317 + }), 318 318 + ), 319 319 ); 320 320 } 321 321 }

+1

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

··· 46 46 skip: params.offset || 0, 47 47 take: params.limit || 100, 48 48 }, 49 49 + names: params.names, 49 50 }); 50 51 return { data: response.data, ctx }; 51 52 },

+4 -4

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

··· 6 6 import type { QueryParams } from "lexicon/types/app/rocksky/scrobble/getScrobble"; 7 7 import * as R from "ramda"; 8 8 import tables from "schema"; 9 9 - import { SelectAlbum } from "schema/albums"; 9 9 + import type { SelectAlbum } from "schema/albums"; 10 10 import type { SelectScrobble } from "schema/scrobbles"; 11 11 import type { SelectTrack } from "schema/tracks"; 12 12 import type { SelectUser } from "schema/users"; ··· 22 22 Effect.catchAll((err) => { 23 23 console.error("Error retrieving scrobble:", err); 24 24 return Effect.succeed({}); 25 25 - }) 25 25 + }), 26 26 ); 27 27 server.app.rocksky.scrobble.getScrobble({ 28 28 handler: async ({ params }) => { ··· 63 63 .from(tables.scrobbles) 64 64 .leftJoin( 65 65 tables.tracks, 66 66 - eq(tables.tracks.id, tables.scrobbles.trackId) 66 66 + eq(tables.tracks.id, tables.scrobbles.trackId), 67 67 ) 68 68 .leftJoin(tables.users, eq(tables.scrobbles.userId, tables.users.id)) 69 69 .where(eq(tables.scrobbles.trackId, scrobble?.tracks.id)) ··· 75 75 .from(tables.scrobbles) 76 76 .leftJoin( 77 77 tables.tracks, 78 78 - eq(tables.scrobbles.trackId, tables.tracks.id) 78 78 + eq(tables.scrobbles.trackId, tables.tracks.id), 79 79 ) 80 80 .where(eq(tables.scrobbles.trackId, scrobble?.tracks.id)) 81 81 .execute()

+7 -4

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

··· 23 23 Effect.catchAll((err) => { 24 24 console.error(err); 25 25 return Effect.succeed({}); 26 26 - }) 26 26 + }), 27 27 ); 28 28 server.app.rocksky.spotify.next({ 29 29 auth: ctx.authVerifier, ··· 71 71 .from(tables.spotifyTokens) 72 72 .leftJoin( 73 73 tables.spotifyApps, 74 74 - eq(tables.spotifyTokens.spotifyAppId, tables.spotifyApps.spotifyAppId) 74 74 + eq( 75 75 + tables.spotifyTokens.spotifyAppId, 76 76 + tables.spotifyApps.spotifyAppId, 77 77 + ), 75 78 ) 76 79 .where(eq(tables.spotifyTokens.userId, user.id)) 77 80 .execute() 78 81 .then(([spotifyToken]) => [ 79 82 decrypt( 80 83 spotifyToken.spotify_tokens.refreshToken, 81 81 - env.SPOTIFY_ENCRYPTION_KEY 84 84 + env.SPOTIFY_ENCRYPTION_KEY, 82 85 ), 83 86 decrypt( 84 87 spotifyToken.spotify_apps.spotifySecret, 85 85 - env.SPOTIFY_ENCRYPTION_KEY 88 88 + env.SPOTIFY_ENCRYPTION_KEY, 86 89 ), 87 90 spotifyToken.spotify_apps.spotifyAppId, 88 91 ])

+7 -4

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

··· 23 23 Effect.catchAll((err) => { 24 24 console.error(err); 25 25 return Effect.succeed({}); 26 26 - }) 26 26 + }), 27 27 ); 28 28 server.app.rocksky.spotify.pause({ 29 29 auth: ctx.authVerifier, ··· 71 71 .from(tables.spotifyTokens) 72 72 .leftJoin( 73 73 tables.spotifyApps, 74 74 - eq(tables.spotifyTokens.spotifyAppId, tables.spotifyApps.spotifyAppId) 74 74 + eq( 75 75 + tables.spotifyTokens.spotifyAppId, 76 76 + tables.spotifyApps.spotifyAppId, 77 77 + ), 75 78 ) 76 79 .where(eq(tables.spotifyTokens.userId, user.id)) 77 80 .execute() 78 81 .then(([spotifyToken]) => [ 79 82 decrypt( 80 83 spotifyToken.spotify_tokens.refreshToken, 81 81 - env.SPOTIFY_ENCRYPTION_KEY 84 84 + env.SPOTIFY_ENCRYPTION_KEY, 82 85 ), 83 86 decrypt( 84 87 spotifyToken.spotify_apps.spotifySecret, 85 85 - env.SPOTIFY_ENCRYPTION_KEY 88 88 + env.SPOTIFY_ENCRYPTION_KEY, 86 89 ), 87 90 spotifyToken.spotify_apps.spotifyAppId, 88 91 ])

+7 -4

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

··· 23 23 Effect.catchAll((err) => { 24 24 console.error(err); 25 25 return Effect.succeed({}); 26 26 - }) 26 26 + }), 27 27 ); 28 28 server.app.rocksky.spotify.play({ 29 29 auth: ctx.authVerifier, ··· 71 71 .from(tables.spotifyTokens) 72 72 .leftJoin( 73 73 tables.spotifyApps, 74 74 - eq(tables.spotifyTokens.spotifyAppId, tables.spotifyApps.spotifyAppId) 74 74 + eq( 75 75 + tables.spotifyTokens.spotifyAppId, 76 76 + tables.spotifyApps.spotifyAppId, 77 77 + ), 75 78 ) 76 79 .where(eq(tables.spotifyTokens.userId, user.id)) 77 80 .execute() 78 81 .then(([spotifyToken]) => [ 79 82 decrypt( 80 83 spotifyToken.spotify_tokens.refreshToken, 81 81 - env.SPOTIFY_ENCRYPTION_KEY 84 84 + env.SPOTIFY_ENCRYPTION_KEY, 82 85 ), 83 86 decrypt( 84 87 spotifyToken.spotify_apps.spotifySecret, 85 85 - env.SPOTIFY_ENCRYPTION_KEY 88 88 + env.SPOTIFY_ENCRYPTION_KEY, 86 89 ), 87 90 spotifyToken.spotify_apps.spotifyAppId, 88 91 ])

+7 -4

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

··· 23 23 Effect.catchAll((err) => { 24 24 console.error(err); 25 25 return Effect.succeed({}); 26 26 - }) 26 26 + }), 27 27 ); 28 28 server.app.rocksky.spotify.previous({ 29 29 auth: ctx.authVerifier, ··· 71 71 .from(tables.spotifyTokens) 72 72 .leftJoin( 73 73 tables.spotifyApps, 74 74 - eq(tables.spotifyTokens.spotifyAppId, tables.spotifyApps.spotifyAppId) 74 74 + eq( 75 75 + tables.spotifyTokens.spotifyAppId, 76 76 + tables.spotifyApps.spotifyAppId, 77 77 + ), 75 78 ) 76 79 .where(eq(tables.spotifyTokens.userId, user.id)) 77 80 .execute() 78 81 .then(([spotifyToken]) => [ 79 82 decrypt( 80 83 spotifyToken.spotify_tokens.refreshToken, 81 81 - env.SPOTIFY_ENCRYPTION_KEY 84 84 + env.SPOTIFY_ENCRYPTION_KEY, 82 85 ), 83 86 decrypt( 84 87 spotifyToken.spotify_apps.spotifySecret, 85 85 - env.SPOTIFY_ENCRYPTION_KEY 88 88 + env.SPOTIFY_ENCRYPTION_KEY, 86 89 ), 87 90 spotifyToken.spotify_apps.spotifyAppId, 88 91 ])

+8 -5

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

··· 23 23 Effect.catchAll((err) => { 24 24 console.error(err); 25 25 return Effect.succeed({}); 26 26 - }) 26 26 + }), 27 27 ); 28 28 server.app.rocksky.spotify.seek({ 29 29 auth: ctx.authVerifier, ··· 74 74 .from(tables.spotifyTokens) 75 75 .leftJoin( 76 76 tables.spotifyApps, 77 77 - eq(tables.spotifyTokens.spotifyAppId, tables.spotifyApps.spotifyAppId) 77 77 + eq( 78 78 + tables.spotifyTokens.spotifyAppId, 79 79 + tables.spotifyApps.spotifyAppId, 80 80 + ), 78 81 ) 79 82 .where(eq(tables.spotifyTokens.userId, user.id)) 80 83 .execute() 81 84 .then(([spotifyToken]) => [ 82 85 decrypt( 83 86 spotifyToken.spotify_tokens.refreshToken, 84 84 - env.SPOTIFY_ENCRYPTION_KEY 87 87 + env.SPOTIFY_ENCRYPTION_KEY, 85 88 ), 86 89 decrypt( 87 90 spotifyToken.spotify_apps.spotifySecret, 88 88 - env.SPOTIFY_ENCRYPTION_KEY 91 91 + env.SPOTIFY_ENCRYPTION_KEY, 89 92 ), 90 93 spotifyToken.spotify_apps.spotifyAppId, 91 94 ]) ··· 150 153 headers: { 151 154 Authorization: `Bearer ${accessToken}`, 152 155 }, 153 153 - } 156 156 + }, 154 157 ).then((res) => res.status), 155 158 catch: (error) => new Error(`Failed to handle next action: ${error}`), 156 159 });

+125 -81

crates/analytics/src/handlers/artists.rs

··· 10 10 }; 11 11 use actix_web::{web, HttpRequest, HttpResponse}; 12 12 use anyhow::Error; 13 13 - use duckdb::{types::Value, Connection}; 13 13 + use duckdb::{params_from_iter, Connection}; 14 14 use tokio_stream::StreamExt; 15 15 16 16 use crate::read_payload; ··· 26 26 let offset = pagination.skip.unwrap_or(0); 27 27 let limit = pagination.take.unwrap_or(20); 28 28 let did = params.user_did; 29 29 + let names = params.names; 29 30 30 31 let conn = conn.lock().unwrap(); 31 31 - let mut stmt = match did { 32 32 - Some(_) => conn.prepare( 33 33 - r#" 34 34 - SELECT a.*, 35 35 - COUNT(*) AS play_count, 36 36 - COUNT(DISTINCT s.user_id) AS unique_listeners 37 37 - FROM user_artists ua 38 38 - LEFT JOIN artists a ON ua.artist_id = a.id 39 39 - LEFT JOIN users u ON ua.user_id = u.id 40 40 - LEFT JOIN scrobbles s ON s.artist_id = a.id 41 41 - WHERE u.did = ? OR u.handle = ? 42 42 - GROUP BY a.* 43 43 - ORDER BY play_count DESC OFFSET ? LIMIT ?; 44 44 - "#, 45 45 - )?, 46 46 - None => conn.prepare( 47 47 - "SELECT a.*, 48 48 - COUNT(*) AS play_count, 49 49 - COUNT(DISTINCT s.user_id) AS unique_listeners 50 50 - FROM artists a 51 51 - LEFT JOIN scrobbles s ON s.artist_id = a.id 52 52 - GROUP BY a.* 53 53 - ORDER BY play_count DESC OFFSET ? LIMIT ?", 54 54 - )?, 55 55 - }; 56 32 57 57 - match did { 58 58 - Some(did) => { 59 59 - let artists = stmt.query_map( 60 60 - [&did, &did, &limit.to_string(), &offset.to_string()], 61 61 - |row| { 62 62 - let genres = extract_genres_from_value(row.get(13)?); 63 63 - Ok(Artist { 64 64 - id: row.get(0)?, 65 65 - name: row.get(1)?, 66 66 - biography: row.get(2)?, 67 67 - born: row.get(3)?, 68 68 - born_in: row.get(4)?, 69 69 - died: row.get(5)?, 70 70 - picture: row.get(6)?, 71 71 - sha256: row.get(7)?, 72 72 - spotify_link: row.get(8)?, 73 73 - tidal_link: row.get(9)?, 74 74 - youtube_link: row.get(10)?, 75 75 - apple_music_link: row.get(11)?, 76 76 - uri: row.get(12)?, 77 77 - genres, 78 78 - play_count: row.get(14)?, 79 79 - unique_listeners: row.get(15)?, 80 80 - }) 81 81 - }, 82 82 - )?; 33 33 + // Build dynamic query and params based on filters 34 34 + let (query, params_vec): (String, Vec<Box<dyn duckdb::ToSql>>) = 35 35 + match (did.as_ref(), names.as_ref()) { 36 36 + // Both did and names provided 37 37 + (Some(d), Some(n)) if !n.is_empty() => { 38 38 + let placeholders = vec!["?"; n.len()].join(", "); 39 39 + let query = format!( 40 40 + r#" 41 41 + SELECT a.*, 42 42 + COUNT(*) AS play_count, 43 43 + COUNT(DISTINCT s.user_id) AS unique_listeners 44 44 + FROM user_artists ua 45 45 + LEFT JOIN artists a ON ua.artist_id = a.id 46 46 + LEFT JOIN users u ON ua.user_id = u.id 47 47 + LEFT JOIN scrobbles s ON s.artist_id = a.id 48 48 + WHERE (u.did = ? OR u.handle = ?) 49 49 + AND a.name IN ({}) 50 50 + GROUP BY a.* 51 51 + ORDER BY play_count DESC 52 52 + LIMIT ? OFFSET ? 53 53 + "#, 54 54 + placeholders 55 55 + ); 56 56 + let mut params: Vec<Box<dyn duckdb::ToSql>> = 57 57 + vec![Box::new(d.clone()), Box::new(d.clone())]; 58 58 + for name in n { 59 59 + params.push(Box::new(name.clone())); 60 60 + } 61 61 + params.push(Box::new(limit)); 62 62 + params.push(Box::new(offset)); 63 63 + (query, params) 64 64 + } 65 65 + // Only did provided 66 66 + (Some(d), _) => { 67 67 + let query = r#" 68 68 + SELECT a.*, 69 69 + COUNT(*) AS play_count, 70 70 + COUNT(DISTINCT s.user_id) AS unique_listeners 71 71 + FROM user_artists ua 72 72 + LEFT JOIN artists a ON ua.artist_id = a.id 73 73 + LEFT JOIN users u ON ua.user_id = u.id 74 74 + LEFT JOIN scrobbles s ON s.artist_id = a.id 75 75 + WHERE u.did = ? OR u.handle = ? 76 76 + GROUP BY a.* 77 77 + ORDER BY play_count DESC 78 78 + LIMIT ? OFFSET ? 79 79 + "# 80 80 + .to_string(); 81 81 + ( 82 82 + query, 83 83 + vec![ 84 84 + Box::new(d.clone()), 85 85 + Box::new(d.clone()), 86 86 + Box::new(limit), 87 87 + Box::new(offset), 88 88 + ], 89 89 + ) 90 90 + } 91 91 + // Only names provided 92 92 + (None, Some(n)) if !n.is_empty() => { 93 93 + let placeholders = vec!["?"; n.len()].join(", "); 94 94 + let query = format!( 95 95 + r#" 96 96 + SELECT a.*, 97 97 + COUNT(*) AS play_count, 98 98 + COUNT(DISTINCT s.user_id) AS unique_listeners 99 99 + FROM artists a 100 100 + LEFT JOIN scrobbles s ON s.artist_id = a.id 101 101 + WHERE a.name IN ({}) 102 102 + GROUP BY a.* 103 103 + ORDER BY play_count DESC 104 104 + LIMIT ? OFFSET ? 105 105 + "#, 106 106 + placeholders 107 107 + ); 108 108 + let mut params: Vec<Box<dyn duckdb::ToSql>> = vec![]; 109 109 + for name in n { 110 110 + params.push(Box::new(name.clone())); 111 111 + } 112 112 + params.push(Box::new(limit)); 113 113 + params.push(Box::new(offset)); 114 114 + (query, params) 115 115 + } 116 116 + // No filters 117 117 + (None, _) => { 118 118 + let query = r#" 119 119 + SELECT a.*, 120 120 + COUNT(*) AS play_count, 121 121 + COUNT(DISTINCT s.user_id) AS unique_listeners 122 122 + FROM artists a 123 123 + LEFT JOIN scrobbles s ON s.artist_id = a.id 124 124 + GROUP BY a.* 125 125 + ORDER BY play_count DESC 126 126 + LIMIT ? OFFSET ? 127 127 + "# 128 128 + .to_string(); 129 129 + (query, vec![Box::new(limit), Box::new(offset)]) 130 130 + } 131 131 + }; 83 132 84 84 - let artists: Result<Vec<_>, _> = artists.collect(); 85 85 - Ok(HttpResponse::Ok().json(artists?)) 86 86 - } 87 87 - None => { 88 88 - let artists = stmt.query_map([limit, offset], |row| { 89 89 - let genres = extract_genres_from_value(row.get(13)?); 90 90 - Ok(Artist { 91 91 - id: row.get(0)?, 92 92 - name: row.get(1)?, 93 93 - biography: row.get(2)?, 94 94 - born: row.get(3)?, 95 95 - born_in: row.get(4)?, 96 96 - died: row.get(5)?, 97 97 - picture: row.get(6)?, 98 98 - sha256: row.get(7)?, 99 99 - spotify_link: row.get(8)?, 100 100 - tidal_link: row.get(9)?, 101 101 - youtube_link: row.get(10)?, 102 102 - apple_music_link: row.get(11)?, 103 103 - uri: row.get(12)?, 104 104 - genres, 105 105 - play_count: row.get(14)?, 106 106 - unique_listeners: row.get(15)?, 107 107 - }) 108 108 - })?; 133 133 + // Prepare and execute query 134 134 + let mut stmt = conn.prepare(&query)?; 135 135 + let artists = stmt.query_map(params_from_iter(params_vec.iter()), |row| { 136 136 + Ok(Artist { 137 137 + id: row.get(0)?, 138 138 + name: row.get(1)?, 139 139 + biography: row.get(2)?, 140 140 + born: row.get(3)?, 141 141 + born_in: row.get(4)?, 142 142 + died: row.get(5)?, 143 143 + picture: row.get(6)?, 144 144 + sha256: row.get(7)?, 145 145 + spotify_link: row.get(8)?, 146 146 + tidal_link: row.get(9)?, 147 147 + youtube_link: row.get(10)?, 148 148 + apple_music_link: row.get(11)?, 149 149 + uri: row.get(12)?, 150 150 + genres: row.get(13)?, 151 151 + play_count: row.get(14)?, 152 152 + unique_listeners: row.get(15)?, 153 153 + }) 154 154 + })?; 109 155 110 110 - let artists: Result<Vec<_>, _> = artists.collect(); 111 111 - Ok(HttpResponse::Ok().json(artists?)) 112 112 - } 113 113 - } 156 156 + let artists: Result<Vec<_>, _> = artists.collect(); 157 157 + Ok(HttpResponse::Ok().json(artists?)) 114 158 } 115 159 116 160 pub async fn get_top_artists(

+1

crates/analytics/src/types/artist.rs

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