-11

apps/api/bruno/rocksky/feed/Get Now Playings.bru

··· 1 1 - meta { 2 2 - name: Get Now Playings 3 3 - type: http 4 4 - seq: 1 5 5 - } 6 6 - 7 7 - get { 8 8 - url: {{url}}/xrpc/app.rocksky.feed.getNowPlayings 9 9 - body: none 10 10 - auth: inherit 11 11 - }

-69

apps/api/lexicons/feed/defs.json

··· 32 32 } 33 33 } 34 34 }, 35 35 - "nowPlayingView": { 36 36 - "type": "object", 37 37 - "properties": { 38 38 - "album": { 39 39 - "type": "string" 40 40 - }, 41 41 - "albumArt": { 42 42 - "type": "string", 43 43 - "format": "uri" 44 44 - }, 45 45 - "albumArtist": { 46 46 - "type": "string" 47 47 - }, 48 48 - "albumUri": { 49 49 - "type": "string", 50 50 - "format": "at-uri" 51 51 - }, 52 52 - "artist": { 53 53 - "type": "string" 54 54 - }, 55 55 - "artistUri": { 56 56 - "type": "string", 57 57 - "format": "at-uri" 58 58 - }, 59 59 - "avatar": { 60 60 - "type": "string", 61 61 - "format": "uri" 62 62 - }, 63 63 - "createdAt": { 64 64 - "type": "string" 65 65 - }, 66 66 - "did": { 67 67 - "type": "string", 68 68 - "format": "at-identifier" 69 69 - }, 70 70 - "handle": { 71 71 - "type": "string" 72 72 - }, 73 73 - "id": { 74 74 - "type": "string" 75 75 - }, 76 76 - "title": { 77 77 - "type": "string" 78 78 - }, 79 79 - "trackId": { 80 80 - "type": "string" 81 81 - }, 82 82 - "trackUri": { 83 83 - "type": "string", 84 84 - "format": "at-uri" 85 85 - }, 86 86 - "uri": { 87 87 - "type": "string", 88 88 - "format": "at-uri" 89 89 - } 90 90 - } 91 91 - }, 92 92 - "nowPlayingsView": { 93 93 - "type": "object", 94 94 - "properties": { 95 95 - "nowPlayings": { 96 96 - "type": "array", 97 97 - "items": { 98 98 - "type": "ref", 99 99 - "ref": "app.rocksky.feed.defs#nowPlayingView" 100 100 - } 101 101 - } 102 102 - } 103 103 - }, 104 35 "storyView": { 105 36 "type": "object", 106 37 "properties": {

-27

apps/api/lexicons/feed/getNowPlayings.json

··· 1 1 - { 2 2 - "lexicon": 1, 3 3 - "id": "app.rocksky.feed.getNowPlayings", 4 4 - "defs": { 5 5 - "main": { 6 6 - "type": "query", 7 7 - "description": "Get all currently playing tracks by users", 8 8 - "parameters": { 9 9 - "type": "params", 10 10 - "properties": { 11 11 - "size": { 12 12 - "type": "integer", 13 13 - "description": "The maximum number of now playing tracks to return.", 14 14 - "minimum": 1 15 15 - } 16 16 - } 17 17 - }, 18 18 - "output": { 19 19 - "encoding": "application/json", 20 20 - "schema": { 21 21 - "type": "ref", 22 22 - "ref": "app.rocksky.feed.defs#nowPlayingsView" 23 23 - } 24 24 - } 25 25 - } 26 26 - } 27 27 - }

-69

apps/api/pkl/defs/feed/defs.pkl

··· 34 34 } 35 35 } 36 36 } 37 37 - ["nowPlayingView"] = new ObjectType { 38 38 - type = "object" 39 39 - properties { 40 40 - ["album"] = new StringType { 41 41 - type = "string" 42 42 - } 43 43 - ["albumArt"] = new StringType { 44 44 - type = "string" 45 45 - format = "uri" 46 46 - } 47 47 - ["albumArtist"] = new StringType { 48 48 - type = "string" 49 49 - } 50 50 - ["albumUri"] = new StringType { 51 51 - type = "string" 52 52 - format = "at-uri" 53 53 - } 54 54 - ["artist"] = new StringType { 55 55 - type = "string" 56 56 - } 57 57 - ["artistUri"] = new StringType { 58 58 - type = "string" 59 59 - format = "at-uri" 60 60 - } 61 61 - ["avatar"] = new StringType { 62 62 - type = "string" 63 63 - format = "uri" 64 64 - } 65 65 - ["createdAt"] = new StringType { 66 66 - type = "string" 67 67 - } 68 68 - ["did"] = new StringType { 69 69 - type = "string" 70 70 - format = "at-identifier" 71 71 - } 72 72 - ["handle"] = new StringType { 73 73 - type = "string" 74 74 - } 75 75 - ["id"] = new StringType { 76 76 - type = "string" 77 77 - } 78 78 - ["title"] = new StringType { 79 79 - type = "string" 80 80 - } 81 81 - ["trackId"] = new StringType { 82 82 - type = "string" 83 83 - } 84 84 - ["trackUri"] = new StringType { 85 85 - type = "string" 86 86 - format = "at-uri" 87 87 - } 88 88 - ["uri"] = new StringType { 89 89 - type = "string" 90 90 - format = "at-uri" 91 91 - } 92 92 - } 93 93 - } 94 94 - ["nowPlayingsView"] = new ObjectType { 95 95 - type = "object" 96 96 - properties { 97 97 - ["nowPlayings"] = new Array { 98 98 - type = "array" 99 99 - items = new Ref { 100 100 - type = "ref" 101 101 - ref = "app.rocksky.feed.defs#nowPlayingView" 102 102 - } 103 103 - } 104 104 - } 105 105 - } 106 37 ["storyView"] = new ObjectType { 107 38 type = "object" 108 39 properties {

-27

apps/api/pkl/defs/feed/getNowPlayings.pkl

··· 1 1 - amends "../../schema/lexicon.pkl" 2 2 - 3 3 - lexicon = 1 4 4 - id = "app.rocksky.feed.getNowPlayings" 5 5 - defs = new Mapping<String, Query> { 6 6 - ["main"] { 7 7 - type = "query" 8 8 - description = "Get all currently playing tracks by users" 9 9 - parameters { 10 10 - type = "params" 11 11 - properties { 12 12 - ["size"] = new IntegerType { 13 13 - type = "integer" 14 14 - description = "The maximum number of now playing tracks to return." 15 15 - minimum = 1 16 16 - } 17 17 - } 18 18 - } 19 19 - output { 20 20 - encoding = "application/json" 21 21 - schema = new Ref { 22 22 - type = "ref" 23 23 - ref = "app.rocksky.feed.defs#nowPlayingsView" 24 24 - } 25 25 - } 26 26 - } 27 27 - }

-12

apps/api/src/lexicon/index.ts

··· 47 47 import type * as AppRockskyFeedGetFeedGenerator from "./types/app/rocksky/feed/getFeedGenerator"; 48 48 import type * as AppRockskyFeedGetFeedGenerators from "./types/app/rocksky/feed/getFeedGenerators"; 49 49 import type * as AppRockskyFeedGetFeedSkeleton from "./types/app/rocksky/feed/getFeedSkeleton"; 50 50 - import type * as AppRockskyFeedGetNowPlayings from "./types/app/rocksky/feed/getNowPlayings"; 51 50 import type * as AppRockskyFeedGetStories from "./types/app/rocksky/feed/getStories"; 52 51 import type * as AppRockskyFeedSearch from "./types/app/rocksky/feed/search"; 53 52 import type * as AppRockskyGoogledriveDownloadFile from "./types/app/rocksky/googledrive/downloadFile"; ··· 695 694 >, 696 695 ) { 697 696 const nsid = "app.rocksky.feed.getFeedSkeleton"; // @ts-ignore 698 698 - return this._server.xrpc.method(nsid, cfg); 699 699 - } 700 700 - 701 701 - getNowPlayings<AV extends AuthVerifier>( 702 702 - cfg: ConfigOf< 703 703 - AV, 704 704 - AppRockskyFeedGetNowPlayings.Handler<ExtractAuth<AV>>, 705 705 - AppRockskyFeedGetNowPlayings.HandlerReqCtx<ExtractAuth<AV>> 706 706 - >, 707 707 - ) { 708 708 - const nsid = "app.rocksky.feed.getNowPlayings"; // @ts-ignore 709 697 return this._server.xrpc.method(nsid, cfg); 710 698 } 711 699

-98

apps/api/src/lexicon/lexicons.ts

··· 2548 2548 }, 2549 2549 }, 2550 2550 }, 2551 2551 - nowPlayingView: { 2552 2552 - type: "object", 2553 2553 - properties: { 2554 2554 - album: { 2555 2555 - type: "string", 2556 2556 - }, 2557 2557 - albumArt: { 2558 2558 - type: "string", 2559 2559 - format: "uri", 2560 2560 - }, 2561 2561 - albumArtist: { 2562 2562 - type: "string", 2563 2563 - }, 2564 2564 - albumUri: { 2565 2565 - type: "string", 2566 2566 - format: "at-uri", 2567 2567 - }, 2568 2568 - artist: { 2569 2569 - type: "string", 2570 2570 - }, 2571 2571 - artistUri: { 2572 2572 - type: "string", 2573 2573 - format: "at-uri", 2574 2574 - }, 2575 2575 - avatar: { 2576 2576 - type: "string", 2577 2577 - format: "uri", 2578 2578 - }, 2579 2579 - createdAt: { 2580 2580 - type: "string", 2581 2581 - }, 2582 2582 - did: { 2583 2583 - type: "string", 2584 2584 - format: "at-identifier", 2585 2585 - }, 2586 2586 - handle: { 2587 2587 - type: "string", 2588 2588 - }, 2589 2589 - id: { 2590 2590 - type: "string", 2591 2591 - }, 2592 2592 - title: { 2593 2593 - type: "string", 2594 2594 - }, 2595 2595 - trackId: { 2596 2596 - type: "string", 2597 2597 - }, 2598 2598 - trackUri: { 2599 2599 - type: "string", 2600 2600 - format: "at-uri", 2601 2601 - }, 2602 2602 - uri: { 2603 2603 - type: "string", 2604 2604 - format: "at-uri", 2605 2605 - }, 2606 2606 - }, 2607 2607 - }, 2608 2608 - nowPlayingsView: { 2609 2609 - type: "object", 2610 2610 - properties: { 2611 2611 - nowPlayings: { 2612 2612 - type: "array", 2613 2613 - items: { 2614 2614 - type: "ref", 2615 2615 - ref: "lex:app.rocksky.feed.defs#nowPlayingView", 2616 2616 - }, 2617 2617 - }, 2618 2618 - }, 2619 2619 - }, 2620 2551 storyView: { 2621 2552 type: "object", 2622 2553 properties: { ··· 2985 2916 "The pagination cursor for the next set of results.", 2986 2917 }, 2987 2918 }, 2988 2988 - }, 2989 2989 - }, 2990 2990 - }, 2991 2991 - }, 2992 2992 - }, 2993 2993 - AppRockskyFeedGetNowPlayings: { 2994 2994 - lexicon: 1, 2995 2995 - id: "app.rocksky.feed.getNowPlayings", 2996 2996 - defs: { 2997 2997 - main: { 2998 2998 - type: "query", 2999 2999 - description: "Get all currently playing tracks by users", 3000 3000 - parameters: { 3001 3001 - type: "params", 3002 3002 - properties: { 3003 3003 - size: { 3004 3004 - type: "integer", 3005 3005 - description: 3006 3006 - "The maximum number of now playing tracks to return.", 3007 3007 - minimum: 1, 3008 3008 - }, 3009 3009 - }, 3010 3010 - }, 3011 3011 - output: { 3012 3012 - encoding: "application/json", 3013 3013 - schema: { 3014 3014 - type: "ref", 3015 3015 - ref: "lex:app.rocksky.feed.defs#nowPlayingsView", 3016 2919 }, 3017 2920 }, 3018 2921 }, ··· 6282 6185 AppRockskyFeedGetFeedGenerator: "app.rocksky.feed.getFeedGenerator", 6283 6186 AppRockskyFeedGetFeedGenerators: "app.rocksky.feed.getFeedGenerators", 6284 6187 AppRockskyFeedGetFeedSkeleton: "app.rocksky.feed.getFeedSkeleton", 6285 6285 - AppRockskyFeedGetNowPlayings: "app.rocksky.feed.getNowPlayings", 6286 6188 AppRockskyFeedGetStories: "app.rocksky.feed.getStories", 6287 6189 AppRockskyFeedSearch: "app.rocksky.feed.search", 6288 6190 AppRockskyGoogledriveDefs: "app.rocksky.googledrive.defs",

-48

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

··· 40 40 return lexicons.validate("app.rocksky.feed.defs#searchResultsView", v); 41 41 } 42 42 43 43 - export interface NowPlayingView { 44 44 - album?: string; 45 45 - albumArt?: string; 46 46 - albumArtist?: string; 47 47 - albumUri?: string; 48 48 - artist?: string; 49 49 - artistUri?: string; 50 50 - avatar?: string; 51 51 - createdAt?: string; 52 52 - did?: string; 53 53 - handle?: string; 54 54 - id?: string; 55 55 - title?: string; 56 56 - trackId?: string; 57 57 - trackUri?: string; 58 58 - uri?: string; 59 59 - [k: string]: unknown; 60 60 - } 61 61 - 62 62 - export function isNowPlayingView(v: unknown): v is NowPlayingView { 63 63 - return ( 64 64 - isObj(v) && 65 65 - hasProp(v, "$type") && 66 66 - v.$type === "app.rocksky.feed.defs#nowPlayingView" 67 67 - ); 68 68 - } 69 69 - 70 70 - export function validateNowPlayingView(v: unknown): ValidationResult { 71 71 - return lexicons.validate("app.rocksky.feed.defs#nowPlayingView", v); 72 72 - } 73 73 - 74 74 - export interface NowPlayingsView { 75 75 - nowPlayings?: NowPlayingView[]; 76 76 - [k: string]: unknown; 77 77 - } 78 78 - 79 79 - export function isNowPlayingsView(v: unknown): v is NowPlayingsView { 80 80 - return ( 81 81 - isObj(v) && 82 82 - hasProp(v, "$type") && 83 83 - v.$type === "app.rocksky.feed.defs#nowPlayingsView" 84 84 - ); 85 85 - } 86 86 - 87 87 - export function validateNowPlayingsView(v: unknown): ValidationResult { 88 88 - return lexicons.validate("app.rocksky.feed.defs#nowPlayingsView", v); 89 89 - } 90 90 - 91 43 export interface StoryView { 92 44 album?: string; 93 45 albumArt?: string;

-43

apps/api/src/lexicon/types/app/rocksky/feed/getNowPlayings.ts

··· 1 1 - /** 2 2 - * GENERATED CODE - DO NOT MODIFY 3 3 - */ 4 4 - import type express from "express"; 5 5 - import { ValidationResult, BlobRef } from "@atproto/lexicon"; 6 6 - import { lexicons } from "../../../../lexicons"; 7 7 - import { isObj, hasProp } from "../../../../util"; 8 8 - import { CID } from "multiformats/cid"; 9 9 - import type { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server"; 10 10 - import type * as AppRockskyFeedDefs from "./defs"; 11 11 - 12 12 - export interface QueryParams { 13 13 - /** The maximum number of now playing tracks to return. */ 14 14 - size?: number; 15 15 - } 16 16 - 17 17 - export type InputSchema = undefined; 18 18 - export type OutputSchema = AppRockskyFeedDefs.NowPlayingsView; 19 19 - export type HandlerInput = undefined; 20 20 - 21 21 - export interface HandlerSuccess { 22 22 - encoding: "application/json"; 23 23 - body: OutputSchema; 24 24 - headers?: { [key: string]: string }; 25 25 - } 26 26 - 27 27 - export interface HandlerError { 28 28 - status: number; 29 29 - message?: string; 30 30 - } 31 31 - 32 32 - export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough; 33 33 - export type HandlerReqCtx<HA extends HandlerAuth = never> = { 34 34 - auth: HA; 35 35 - params: QueryParams; 36 36 - input: HandlerInput; 37 37 - req: express.Request; 38 38 - res: express.Response; 39 39 - resetRouteRateLimits: () => Promise<void>; 40 40 - }; 41 41 - export type Handler<HA extends HandlerAuth = never> = ( 42 42 - ctx: HandlerReqCtx<HA>, 43 43 - ) => Promise<HandlerOutput> | HandlerOutput;

-138

apps/api/src/xrpc/app/rocksky/feed/getNowPlayings.ts

··· 1 1 - import type { Context } from "context"; 2 2 - import { consola } from "consola"; 3 3 - import { desc, eq, sql } from "drizzle-orm"; 4 4 - import { Cache, Duration, Effect, pipe } from "effect"; 5 5 - import type { Server } from "lexicon"; 6 6 - import type { NowPlayingView } from "lexicon/types/app/rocksky/feed/defs"; 7 7 - import type { QueryParams } from "lexicon/types/app/rocksky/feed/getNowPlayings"; 8 8 - import albums from "schema/albums"; 9 9 - import artists from "schema/artists"; 10 10 - import scrobbles from "schema/scrobbles"; 11 11 - import tracks from "schema/tracks"; 12 12 - import users from "schema/users"; 13 13 - 14 14 - export default function (server: Server, ctx: Context) { 15 15 - const nowPlayingCache = Cache.make({ 16 16 - capacity: 100, 17 17 - timeToLive: Duration.seconds(30), 18 18 - lookup: (params: QueryParams) => 19 19 - pipe( 20 20 - { params, ctx }, 21 21 - retrieve, 22 22 - Effect.map((data) => ({ data })), 23 23 - Effect.flatMap(presentation), 24 24 - Effect.retry({ times: 3 }), 25 25 - Effect.timeout("120 seconds"), 26 26 - ), 27 27 - }); 28 28 - 29 29 - const getNowPlayings = (params) => 30 30 - pipe( 31 31 - nowPlayingCache, 32 32 - Effect.flatMap((cache) => cache.get(params)), 33 33 - Effect.catchAll((err) => { 34 34 - consola.error(err); 35 35 - return Effect.succeed({}); 36 36 - }), 37 37 - ); 38 38 - server.app.rocksky.feed.getNowPlayings({ 39 39 - handler: async ({ params }) => { 40 40 - const result = await Effect.runPromise(getNowPlayings(params)); 41 41 - return { 42 42 - encoding: "application/json", 43 43 - body: result, 44 44 - }; 45 45 - }, 46 46 - }); 47 47 - } 48 48 - 49 49 - const retrieve = ({ 50 50 - params, 51 51 - ctx, 52 52 - }: { 53 53 - params: QueryParams; 54 54 - ctx: Context; 55 55 - }): Effect.Effect<NowPlayingRecord[], Error, never> => { 56 56 - return Effect.tryPromise({ 57 57 - try: () => 58 58 - ctx.db 59 59 - .select({ 60 60 - xataId: scrobbles.id, 61 61 - trackId: tracks.id, 62 62 - title: tracks.title, 63 63 - artist: tracks.artist, 64 64 - albumArtist: tracks.albumArtist, 65 65 - album: tracks.album, 66 66 - albumArt: tracks.albumArt, 67 67 - handle: users.handle, 68 68 - did: users.did, 69 69 - avatar: users.avatar, 70 70 - uri: scrobbles.uri, 71 71 - trackUri: tracks.uri, 72 72 - artistUri: artists.uri, 73 73 - albumUri: albums.uri, 74 74 - timestamp: scrobbles.timestamp, 75 75 - }) 76 76 - .from(scrobbles) 77 77 - .leftJoin(artists, eq(scrobbles.artistId, artists.id)) 78 78 - .leftJoin(albums, eq(scrobbles.albumId, albums.id)) 79 79 - .leftJoin(tracks, eq(scrobbles.trackId, tracks.id)) 80 80 - .leftJoin(users, eq(scrobbles.userId, users.id)) 81 81 - .where( 82 82 - sql`scrobbles.xata_id IN ( 83 83 - SELECT DISTINCT ON (inner_s.user_id) inner_s.xata_id 84 84 - FROM scrobbles inner_s 85 85 - ORDER BY inner_s.user_id, inner_s.timestamp DESC, inner_s.xata_id DESC 86 86 - )`, 87 87 - ) 88 88 - .orderBy(desc(scrobbles.timestamp)) 89 89 - .limit(params.size || 20) 90 90 - .execute(), 91 91 - catch: (error) => 92 92 - new Error(`Failed to retrieve now playing songs: ${error}`), 93 93 - }); 94 94 - }; 95 95 - 96 96 - const presentation = ({ 97 97 - data, 98 98 - }: { 99 99 - data: NowPlayingRecord[]; 100 100 - }): Effect.Effect<{ nowPlayings: NowPlayingView[] }, never> => { 101 101 - return Effect.sync(() => ({ 102 102 - nowPlayings: data.map((record) => ({ 103 103 - album: record.album, 104 104 - albumArt: record.albumArt, 105 105 - albumArtist: record.albumArtist, 106 106 - albumUri: record.albumUri, 107 107 - artist: record.artist, 108 108 - artistUri: record.artistUri, 109 109 - avatar: record.avatar, 110 110 - createdAt: record.timestamp.toISOString(), 111 111 - did: record.did, 112 112 - handle: record.handle, 113 113 - id: record.trackId, 114 114 - title: record.title, 115 115 - trackId: record.trackId, 116 116 - trackUri: record.trackUri, 117 117 - uri: record.uri, 118 118 - })), 119 119 - })); 120 120 - }; 121 121 - 122 122 - type NowPlayingRecord = { 123 123 - xataId: string; 124 124 - trackId: string; 125 125 - title: string; 126 126 - artist: string; 127 127 - albumArtist: string; 128 128 - album: string; 129 129 - albumArt: string; 130 130 - handle: string; 131 131 - did: string; 132 132 - avatar: string; 133 133 - uri: string; 134 134 - trackUri: string; 135 135 - artistUri: string; 136 136 - albumUri: string; 137 137 - timestamp: Date; 138 138 - };

+2 -2

apps/api/src/xrpc/app/rocksky/feed/getStories.ts

··· 26 26 ), 27 27 }); 28 28 29 29 - const getNowPlayings = (params) => 29 29 + const getStories = (params: QueryParams) => 30 30 pipe( 31 31 storiesCache, 32 32 Effect.flatMap((cache) => cache.get(params)), ··· 37 37 ); 38 38 server.app.rocksky.feed.getStories({ 39 39 handler: async ({ params }) => { 40 40 - const result = await Effect.runPromise(getNowPlayings(params)); 40 40 + const result = await Effect.runPromise(getStories(params)); 41 41 return { 42 42 encoding: "application/json", 43 43 body: result,

-2

apps/api/src/xrpc/index.ts

··· 24 24 import getFilesFromDropbox from "./app/rocksky/dropbox/getFiles"; 25 25 import getMetadataFromDropbox from "./app/rocksky/dropbox/getMetadata"; 26 26 import getTemporaryLinkFromDropbox from "./app/rocksky/dropbox/getTemporaryLink"; 27 27 - import getNowPlayings from "./app/rocksky/feed/getNowPlayings"; 28 27 import search from "./app/rocksky/feed/search"; 29 28 import downloadFileFromGoogleDrive from "./app/rocksky/googledrive/downloadFile"; 30 29 import getFileFromGoogleDrive from "./app/rocksky/googledrive/getFile"; ··· 113 112 getFilesFromDropbox(server, ctx); 114 113 getMetadataFromDropbox(server, ctx); 115 114 getTemporaryLinkFromDropbox(server, ctx); 116 116 - getNowPlayings(server, ctx); 117 115 search(server, ctx); 118 116 downloadFileFromGoogleDrive(server, ctx); 119 117 getFilesFromGoogleDrive(server, ctx);