Something went wrong. Try again.
A decentralized music tracking and discovery platform built on AT Protocol 🎵 forked from rocksky.app/rocksky
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746import type { BlobRef } from "@atproto/lexicon";import { equals } from "@xata.io/client";import { ctx } from "context";import { aliasedTable, asc, count, desc, eq, inArray, or, sql,} from "drizzle-orm";import { Hono } from "hono";import jwt from "jsonwebtoken";import * as Profile from "lexicon/types/app/bsky/actor/profile";import { createAgent } from "lib/agent";import { env } from "lib/env";import _ from "lodash";import { likeTrack, unLikeTrack } from "lovedtracks/lovedtracks.service";import { requestCounter } from "metrics";import * as R from "ramda";import tables from "schema";import { createShout, likeShout, replyShout, unlikeShout,} from "shouts/shouts.service";import { shoutSchema } from "types/shout";import type { Track } from "types/track";import { dedupeTracksKeepLyrics } from "./utils";
const app = new Hono();
app.get("/:did/likes", async (c) => { requestCounter.add(1, { method: "GET", route: "/users/:did/likes" }); const did = c.req.param("did"); const size = +c.req.query("size") || 10; const offset = +c.req.query("offset") || 0;
const lovedTracks = await ctx.client.db.loved_tracks .select(["track_id.*", "user_id.*"]) .filter({ $any: [ { "user_id.did": did, }, { "user_id.handle": did, }, ], }) .sort("xata_createdat", "desc") .getPaginated({ pagination: { size, offset, }, }); return c.json(lovedTracks);});
app.get("/:handle/scrobbles", async (c) => { requestCounter.add(1, { method: "GET", route: "/users/:handle/scrobbles" }); const handle = c.req.param("handle");
const size = +c.req.query("size") || 10; const offset = +c.req.query("offset") || 0;
const { data } = await ctx.analytics.post("library.getScrobbles", { user_did: handle, pagination: { skip: offset, take: size, }, });
return c.json(data);});
app.get("/:did/albums", async (c) => { requestCounter.add(1, { method: "GET", route: "/users/:did/albums" }); const did = c.req.param("did"); const size = +c.req.query("size") || 10; const offset = +c.req.query("offset") || 0;
const { data } = await ctx.analytics.post("library.getTopAlbums", { user_did: did, pagination: { skip: offset, take: size, }, });
return c.json(data.map((item) => ({ ...item, tags: [] })));});
app.get("/:did/artists", async (c) => { requestCounter.add(1, { method: "GET", route: "/users/:did/artists" }); const did = c.req.param("did"); const size = +c.req.query("size") || 10; const offset = +c.req.query("offset") || 0;
const { data } = await ctx.analytics.post("library.getTopArtists", { user_did: did, pagination: { skip: offset, take: size, }, });
return c.json(data.map((item) => ({ ...item, tags: [] })));});
app.get("/:did/tracks", async (c) => { requestCounter.add(1, { method: "GET", route: "/users/:did/tracks" }); const did = c.req.param("did"); const size = +c.req.query("size") || 10; const offset = +c.req.query("offset") || 0;
const { data } = await ctx.analytics.post("library.getTopTracks", { user_did: did, pagination: { skip: offset, take: size, }, });
return c.json( data.map((item) => ({ ...item, tags: [], })), );});
app.get("/:did/playlists", async (c) => { requestCounter.add(1, { method: "GET", route: "/users/:did/playlists" }); const did = c.req.param("did"); const size = +c.req.query("size") || 10; const offset = +c.req.query("offset") || 0;
const results = await ctx.db .select({ playlists: tables.playlists, trackCount: sql<number>` (SELECT COUNT(*) FROM ${tables.playlistTracks} WHERE ${tables.playlistTracks.playlistId} = ${tables.playlists.id} )`.as("trackCount"), }) .from(tables.playlists) .leftJoin(tables.users, eq(tables.playlists.createdBy, tables.users.id)) .where(or(eq(tables.users.did, did), eq(tables.users.handle, did))) .offset(offset) .limit(size) .execute();
return c.json( results.map((x) => ({ ...x.playlists, trackCount: +x.trackCount, })), );});
app.get("/:did/app.rocksky.scrobble/:rkey", async (c) => { requestCounter.add(1, { method: "GET", route: "/users/:did/app.rocksky.scrobble/:rkey", }); const did = c.req.param("did"); const rkey = c.req.param("rkey"); const uri = `at://${did}/app.rocksky.scrobble/${rkey}`;
const scrobble = await ctx.client.db.scrobbles .select(["track_id.*", "user_id.*", "xata_createdat", "uri"]) .filter("uri", equals(uri)) .getFirst();
if (!scrobble) { c.status(404); return c.text("Scrobble not found"); }
const [listeners, scrobbles] = await Promise.all([ ctx.client.db.user_tracks.select(["track_id.*"]).summarize({ filter: { "track_id.xata_id": scrobble.track_id.xata_id, }, columns: ["track_id.*"], summaries: { total: { count: "*", }, }, }), ctx.client.db.scrobbles.select(["track_id.*", "xata_createdat"]).summarize({ filter: { "track_id.xata_id": scrobble.track_id.xata_id, }, columns: ["track_id.*"], summaries: { total: { count: "*", }, }, }), ]);
return c.json({ ...R.omit(["xata_id"], scrobble), id: scrobble.xata_id, listeners: _.get(listeners.summaries, "0.total", 1), scrobbles: _.get(scrobbles.summaries, "0.total", 1), tags: [], });});
app.get("/:did/app.rocksky.artist/:rkey", async (c) => { requestCounter.add(1, { method: "GET", route: "/users/:did/app.rocksky.artist/:rkey", }); const did = c.req.param("did"); const rkey = c.req.param("rkey"); const uri = `at://${did}/app.rocksky.artist/${rkey}`;
const artist = await ctx.client.db.user_artists .select(["artist_id.*"]) .filter({ $any: [{ uri }, { "artist_id.uri": uri }], }) .getFirst();
if (!artist) { c.status(404); return c.text("Artist not found"); }
const [listeners, scrobbles] = await Promise.all([ ctx.client.db.user_artists.select(["artist_id.*"]).summarize({ filter: { "artist_id.xata_id": equals(artist.artist_id.xata_id), }, columns: ["artist_id.*"], summaries: { total: { count: "*", }, }, }), ctx.client.db.scrobbles .select(["artist_id.*", "xata_createdat"]) .summarize({ filter: { "artist_id.xata_id": artist.artist_id.xata_id, }, columns: ["artist_id.*"], summaries: { total: { count: "*", }, }, }), ]);
return c.json({ ...R.omit(["xata_id"], artist.artist_id), id: artist.artist_id.xata_id, listeners: _.get(listeners.summaries, "0.total", 1), scrobbles: _.get(scrobbles.summaries, "0.total", 1), tags: [], });});
app.get("/:did/app.rocksky.album/:rkey", async (c) => { requestCounter.add(1, { method: "GET", route: "/users/:did/app.rocksky.album/:rkey", });
const did = c.req.param("did"); const rkey = c.req.param("rkey"); const uri = `at://${did}/app.rocksky.album/${rkey}`;
const album = await ctx.client.db.user_albums .select(["album_id.*"]) .filter({ $any: [{ uri }, { "album_id.uri": uri }], }) .getFirst();
if (!album) { c.status(404); return c.text("Album not found"); }
const tracks = await ctx.client.db.album_tracks .select(["track_id.*"]) .filter("album_id.xata_id", equals(album.album_id.xata_id)) .sort("track_id.track_number", "asc") .getAll();
const [listeners, scrobbles] = await Promise.all([ ctx.client.db.user_albums.select(["album_id.*"]).summarize({ filter: { "album_id.xata_id": equals(album.album_id.xata_id), }, columns: ["album_id.*"], summaries: { total: { count: "*", }, }, }), ctx.client.db.scrobbles.select(["album_id.*", "xata_createdat"]).summarize({ filter: { "album_id.xata_id": album.album_id.xata_id, }, columns: ["album_id.*"], summaries: { total: { count: "*", }, }, }), ]);
return c.json({ ...R.omit(["xata_id"], album.album_id), id: album.album_id.xata_id, listeners: _.get(listeners.summaries, "0.total", 1), scrobbles: _.get(scrobbles.summaries, "0.total", 1), label: _.get(tracks, "0.track_id.label", ""), tracks: dedupeTracksKeepLyrics(tracks.map((track) => track.track_id)).sort( (a, b) => a.track_number - b.track_number, ), tags: [], });});
app.get("/:did/app.rocksky.song/:rkey", async (c) => { requestCounter.add(1, { method: "GET", route: "/users/:did/app.rocksky.song/:rkey", }); const did = c.req.param("did"); const rkey = c.req.param("rkey"); const uri = `at://${did}/app.rocksky.song/${rkey}`;
const [_track, user_track] = await Promise.all([ ctx.client.db.tracks.filter("uri", equals(uri)).getFirst(), ctx.client.db.user_tracks .select(["track_id.*"]) .filter("uri", equals(uri)) .getFirst(), ]); const track = _track || user_track.track_id;
if (!track) { c.status(404); return c.text("Track not found"); }
const [listeners, scrobbles] = await Promise.all([ ctx.client.db.user_tracks.select(["track_id.*"]).summarize({ filter: { "track_id.xata_id": equals(track.xata_id), }, columns: ["track_id.*"], summaries: { total: { count: "*", }, }, }), ctx.client.db.scrobbles.select(["track_id.*", "xata_createdat"]).summarize({ filter: { "track_id.xata_id": track.xata_id, }, columns: ["track_id.*"], summaries: { total: { count: "*", }, }, }), ]);
return c.json({ ...R.omit(["xata_id"], track), id: track.xata_id, tags: [], listeners: _.get(listeners.summaries, "0.total", 1), scrobbles: _.get(scrobbles.summaries, "0.total", 1), });});
app.get("/:did/app.rocksky.artist/:rkey/tracks", async (c) => { requestCounter.add(1, { method: "GET", route: "/users/:did/app.rocksky.artist/:rkey/tracks", }); const did = c.req.param("did"); const rkey = c.req.param("rkey"); const uri = `at://${did}/app.rocksky.artist/${rkey}`; const size = +c.req.query("size") || 10; const offset = +c.req.query("offset") || 0;
const tracks = await ctx.client.db.artist_tracks .select(["track_id.*", "xata_version"]) .filter({ "artist_id.uri": equals(uri), }) .sort("xata_version", "desc") .getPaginated({ pagination: { size, offset, }, }); return c.json( tracks.records.map((item) => ({ ...R.omit(["xata_id"], item.track_id), id: item.track_id.xata_id, xata_version: item.xata_version, })), );});
app.get("/:did/app.rocksky.artist/:rkey/albums", async (c) => { requestCounter.add(1, { method: "GET", route: "/users/:did/app.rocksky.artist/:rkey/albums", }); const did = c.req.param("did"); const rkey = c.req.param("rkey"); const uri = `at://${did}/app.rocksky.artist/${rkey}`; const size = +c.req.query("size") || 10; const offset = +c.req.query("offset") || 0;
const albums = await ctx.client.db.artist_albums .select(["album_id.*", "xata_version"]) .filter({ "artist_id.uri": equals(uri), }) .sort("xata_version", "desc") .getPaginated({ pagination: { size, offset, }, }); return c.json( R.uniqBy( (item) => item.id, albums.records.map((item) => ({ ...R.omit(["xata_id"], item.album_id), id: item.album_id.xata_id, xata_version: item.xata_version, })), ), );});
app.get("/:did/app.rocksky.playlist/:rkey", async (c) => { requestCounter.add(1, { method: "GET", route: "/users/:did/app.rocksky.playlist/:rkey", }); const did = c.req.param("did"); const rkey = c.req.param("rkey"); const uri = `at://${did}/app.rocksky.playlist/${rkey}`;
const playlist = await ctx.db .select() .from(tables.playlists) .leftJoin(tables.users, eq(tables.playlists.createdBy, tables.users.id)) .where(eq(tables.playlists.uri, uri)) .execute();
if (!playlist.length) { c.status(404); return c.text("Playlist not found"); }
const results = await ctx.db .select() .from(tables.playlistTracks) .leftJoin( tables.playlists, eq(tables.playlistTracks.playlistId, tables.playlists.id), ) .leftJoin( tables.tracks, eq(tables.playlistTracks.trackId, tables.tracks.id), ) .where(eq(tables.playlists.uri, uri)) .groupBy( tables.playlistTracks.id, tables.playlistTracks.playlistId, tables.playlistTracks.trackId, tables.playlistTracks.createdAt, tables.tracks.id, tables.tracks.title, tables.tracks.artist, tables.tracks.albumArtist, tables.tracks.albumArt, tables.tracks.album, tables.tracks.trackNumber, tables.tracks.duration, tables.tracks.mbId, tables.tracks.youtubeLink, tables.tracks.spotifyLink, tables.tracks.appleMusicLink, tables.tracks.tidalLink, tables.tracks.sha256, tables.tracks.discNumber, tables.tracks.lyrics, tables.tracks.composer, tables.tracks.genre, tables.tracks.copyrightMessage, tables.tracks.uri, tables.tracks.albumUri, tables.tracks.artistUri, tables.tracks.createdAt, tables.tracks.updatedAt, tables.tracks.label, tables.tracks.xataVersion, tables.playlists.updatedAt, tables.playlists.id, tables.playlists.createdAt, tables.playlists.name, tables.playlists.description, tables.playlists.uri, tables.playlists.createdBy, tables.playlists.picture, tables.playlists.spotifyLink, tables.playlists.tidalLink, tables.playlists.appleMusicLink, ) .orderBy(asc(tables.playlistTracks.createdAt)) .execute();
return c.json({ ...playlist[0].playlists, curatedBy: playlist[0].users, tracks: results.map((x) => x.tracks), });});
app.get("/:did", async (c) => { requestCounter.add(1, { method: "GET", route: "/users/:did" }); const did = c.req.param("did"); const bearer = (c.req.header("authorization") || "").split(" ")[1]?.trim(); if (bearer && bearer !== "null") { const claims = jwt.verify(bearer, env.JWT_SECRET, { ignoreExpiration: true, }); const agent = await createAgent(ctx.oauthClient, claims.did);
if (agent) { const { data: profileRecord } = await agent.com.atproto.repo.getRecord({ repo: did, collection: "app.bsky.actor.profile", rkey: "self", }); const handle = await ctx.resolver.resolveDidToHandle(did); const profile: { handle?: string; displayName?: string; avatar?: BlobRef; } = Profile.isRecord(profileRecord.value) && Profile.validateRecord(profileRecord.value).success ? { ...profileRecord.value, handle } : {};
if (profile.handle) { await ctx.db .update(tables.users) .set({ handle, displayName: profile.displayName, avatar: `https://cdn.bsky.app/img/avatar/plain/${did}/${profile.avatar.ref.toString()}@jpeg`, }) .where(eq(tables.users.did, did)) .execute();
const user = await ctx.client.db.users .select(["*"]) .filter("did", equals(did)) .getFirst();
ctx.nc.publish("rocksky.user", Buffer.from(JSON.stringify(user))); } } }
const user = await ctx.client.db.users .filter({ $any: [{ did }, { handle: did }], }) .getFirst();
if (!user) { c.status(404); return c.text("User not found"); }
return c.json(user);});
app.post("/:did/app.rocksky.artist/:rkey/shouts", async (c) => { requestCounter.add(1, { method: "POST", route: "/users/:did/app.rocksky.artist/:rkey/shouts", }); const bearer = (c.req.header("authorization") || "").split(" ")[1]?.trim();
if (!bearer || bearer === "null") { c.status(401); return c.text("Unauthorized"); }
const payload = jwt.verify(bearer, env.JWT_SECRET, { ignoreExpiration: true, }); const agent = await createAgent(ctx.oauthClient, payload.did);
const user = await ctx.client.db.users .filter("did", equals(payload.did)) .getFirst(); if (!user) { c.status(401); return c.text("Unauthorized"); }
const did = c.req.param("did"); const rkey = c.req.param("rkey"); const body = await c.req.json(); const parsed = shoutSchema.safeParse(body);
if (parsed.error) { c.status(400); return c.text("Invalid shout data: " + parsed.error.message); }
await createShout( ctx, parsed.data, `at://${did}/app.rocksky.artist/${rkey}`, user, agent, ); return c.json({});});
app.post("/:did/app.rocksky.album/:rkey/shouts", async (c) => { requestCounter.add(1, { method: "POST", route: "/users/:did/app.rocksky.album/:rkey/shouts", }); const bearer = (c.req.header("authorization") || "").split(" ")[1]?.trim();
if (!bearer || bearer === "null") { c.status(401); return c.text("Unauthorized"); }
const payload = jwt.verify(bearer, env.JWT_SECRET, { ignoreExpiration: true, }); const agent = await createAgent(ctx.oauthClient, payload.did);
const user = await ctx.client.db.users .filter("did", equals(payload.did)) .getFirst(); if (!user) { c.status(401); return c.text("Unauthorized"); }
const did = c.req.param("did"); const rkey = c.req.param("rkey"); const body = await c.req.json(); const parsed = shoutSchema.safeParse(body);
if (parsed.error) { c.status(400); return c.text("Invalid shout data: " + parsed.error.message); }
await createShout( ctx, parsed.data, `at://${did}/app.rocksky.album/${rkey}`, user, agent, ); return c.json({});});
app.post("/:did/app.rocksky.song/:rkey/shouts", async (c) => { requestCounter.add(1, { method: "POST", route: "/users/:did/app.rocksky.song/:rkey/shouts", }); const bearer = (c.req.header("authorization") || "").split(" ")[1]?.trim();
if (!bearer || bearer === "null") { c.status(401); return c.text("Unauthorized"); }
const payload = jwt.verify(bearer, env.JWT_SECRET, { ignoreExpiration: true, }); const agent = await createAgent(ctx.oauthClient, payload.did);
const user = await ctx.client.db.users .filter("did", equals(payload.did)) .getFirst(); if (!user) { c.status(401); return c.text("Unauthorized"); }
const did = c.req.param("did"); const rkey = c.req.param("rkey"); const body = await c.req.json();
const parsed = shoutSchema.safeParse(body); if (parsed.error) { c.status(400); return c.text("Invalid shout data: " + parsed.error.message); }
await createShout( ctx, parsed.data, `at://${did}/app.rocksky.song/${rkey}`, user, agent, );
return c.json({});});
app.post("/:did/app.rocksky.scrobble/:rkey/shouts", async (c) => { requestCounter.add(1, { method: "POST", route: "/users/:did/app.rocksky.scrobble/:rkey/shouts", }); const bearer = (c.req.header("authorization") || "").split(" ")[1]?.trim();
if (!bearer || bearer === "null") { c.status(401); return c.text("Unauthorized"); }
const payload = jwt.verify(bearer, env.JWT_SECRET, { ignoreExpiration: true, }); const agent = await createAgent(ctx.oauthClient, payload.did);
const user = await ctx.client.db.users .filter("did", equals(payload.did)) .getFirst(); if (!user) { c.status(401); return c.text("Unauthorized"); }
const did = c.req.param("did"); const rkey = c.req.param("rkey"); const body = await c.req.json();
const parsed = shoutSchema.safeParse(body); if (parsed.error) { c.status(400); return c.text("Invalid shout data: " + parsed.error.message); }
await createShout( ctx, parsed.data, `at://${did}/app.rocksky.scrobble/${rkey}`, user, agent, );
return c.json({});});
app.post("/:did/shouts", async (c) => { requestCounter.add(1, { method: "POST", route: "/users/:did/shouts" }); const bearer = (c.req.header("authorization") || "").split(" ")[1]?.trim();
if (!bearer || bearer === "null") { c.status(401); return c.text("Unauthorized"); }
const payload = jwt.verify(bearer, env.JWT_SECRET, { ignoreExpiration: true, }); const agent = await createAgent(ctx.oauthClient, payload.did);
const user = await ctx.client.db.users .filter("did", equals(payload.did)) .getFirst(); if (!user) { c.status(401); return c.text("Unauthorized"); }
const did = c.req.param("did"); const body = await c.req.json(); const parsed = shoutSchema.safeParse(body); if (parsed.error) { c.status(400); return c.text("Invalid shout data: " + parsed.error.message); }
const _user = await ctx.client.db.users .filter({ $any: [{ did }, { handle: did }], }) .getFirst();
if (!_user) { c.status(404); return c.text("User not found"); }
await createShout(ctx, parsed.data, `at://${_user.did}`, user, agent);
return c.json({});});
app.post("/:did/app.rocksky.shout/:rkey/likes", async (c) => { requestCounter.add(1, { method: "POST", route: "/users/:did/app.rocksky.shout/:rkey/likes", }); const bearer = (c.req.header("authorization") || "").split(" ")[1]?.trim();
if (!bearer || bearer === "null") { c.status(401); return c.text("Unauthorized"); }
const payload = jwt.verify(bearer, env.JWT_SECRET, { ignoreExpiration: true, }); const agent = await createAgent(ctx.oauthClient, payload.did);
const user = await ctx.client.db.users .filter("did", equals(payload.did)) .getFirst(); if (!user) { c.status(401); return c.text("Unauthorized"); }
const did = c.req.param("did"); const rkey = c.req.param("rkey"); await likeShout(ctx, `at://${did}/app.rocksky.shout/${rkey}`, user, agent);
return c.json({});});
app.delete("/:did/app.rocksky.shout/:rkey/likes", async (c) => { requestCounter.add(1, { method: "DELETE", route: "/users/:did/app.rocksky.shout/:rkey/likes", }); const bearer = (c.req.header("authorization") || "").split(" ")[1]?.trim();
if (!bearer || bearer === "null") { c.status(401); return c.text("Unauthorized"); }
const payload = jwt.verify(bearer, env.JWT_SECRET, { ignoreExpiration: true, }); const agent = await createAgent(ctx.oauthClient, payload.did);
const user = await ctx.client.db.users .filter("did", equals(payload.did)) .getFirst(); if (!user) { c.status(401); return c.text("Unauthorized"); }
const did = c.req.param("did"); const rkey = c.req.param("rkey");
await unlikeShout(ctx, `at://${did}/app.rocksky.shout/${rkey}`, user, agent);
return c.json({});});
app.post("/:did/app.rocksky.song/:rkey/likes", async (c) => { requestCounter.add(1, { method: "POST", route: "/users/:did/app.rocksky.song/:rkey/likes", }); const bearer = (c.req.header("authorization") || "").split(" ")[1]?.trim();
if (!bearer || bearer === "null") { c.status(401); return c.text("Unauthorized"); }
const payload = jwt.verify(bearer, env.JWT_SECRET, { ignoreExpiration: true, }); const agent = await createAgent(ctx.oauthClient, payload.did);
const user = await ctx.client.db.users .filter("did", equals(payload.did)) .getFirst(); if (!user) { c.status(401); return c.text("Unauthorized"); }
const did = c.req.param("did"); const rkey = c.req.param("rkey");
const result = await ctx.client.db.tracks .filter("uri", equals(`at://${did}/app.rocksky.song/${rkey}`)) .getFirst();
const track: Track = { title: result.title, artist: result.artist, album: result.album, albumArt: result.album_art, albumArtist: result.album_artist, trackNumber: result.track_number, duration: result.duration, composer: result.composer, lyrics: result.lyrics, discNumber: result.disc_number, }; await likeTrack(ctx, track, user, agent);
return c.json({});});
app.delete("/:did/app.rocksky.song/:rkey/likes", async (c) => { requestCounter.add(1, { method: "DELETE", route: "/users/:did/app.rocksky.song/:rkey/likes", }); const bearer = (c.req.header("authorization") || "").split(" ")[1]?.trim();
if (!bearer || bearer === "null") { c.status(401); return c.text("Unauthorized"); }
const payload = jwt.verify(bearer, env.JWT_SECRET, { ignoreExpiration: true, }); const agent = await createAgent(ctx.oauthClient, payload.did);
const user = await ctx.client.db.users .filter("did", equals(payload.did)) .getFirst(); if (!user) { c.status(401); return c.text("Unauthorized"); }
const did = c.req.param("did"); const rkey = c.req.param("rkey");
const track = await ctx.client.db.tracks .filter("uri", equals(`at://${did}/app.rocksky.song/${rkey}`)) .getFirst();
if (!track) { c.status(404); return c.text("Track not found"); }
await unLikeTrack(ctx, track.sha256, user, agent);
return c.json([]);});
app.post("/:did/app.rocksky.shout/:rkey/replies", async (c) => { requestCounter.add(1, { method: "POST", route: "/users/:did/app.rocksky.shout/:rkey/replies", }); const bearer = (c.req.header("authorization") || "").split(" ")[1]?.trim();
if (!bearer || bearer === "null") { c.status(401); return c.text("Unauthorized"); }
const payload = jwt.verify(bearer, env.JWT_SECRET, { ignoreExpiration: true, }); const agent = await createAgent(ctx.oauthClient, payload.did);
const user = await ctx.client.db.users .filter("did", equals(payload.did)) .getFirst(); if (!user) { c.status(401); return c.text("Unauthorized"); }
const did = c.req.param("did"); const rkey = c.req.param("rkey");
const body = await c.req.json(); const parsed = shoutSchema.safeParse(body);
if (parsed.error) { c.status(400); return c.text("Invalid shout data: " + parsed.error.message); }
await replyShout( ctx, parsed.data, `at://${did}/app.rocksky.shout/${rkey}`, user, agent, ); return c.json({});});
app.get("/:did/app.rocksky.artist/:rkey/shouts", async (c) => { requestCounter.add(1, { method: "GET", route: "/users/:did/app.rocksky.artist/:rkey/shouts", }); const did = c.req.param("did"); const rkey = c.req.param("rkey");
const bearer = (c.req.header("authorization") || "").split(" ")[1]?.trim();
let user; if (bearer && bearer !== "null") { const payload = jwt.verify(bearer, env.JWT_SECRET, { ignoreExpiration: true, });
user = await ctx.client.db.users .filter("did", equals(payload.did)) .getFirst(); }
const shouts = await ctx.db .select({ shouts: user ? { id: tables.shouts.id, content: tables.shouts.content, createdAt: tables.shouts.createdAt, uri: tables.shouts.uri, parent: tables.shouts.parentId, likes: count(tables.shoutLikes.id).as("likes"), liked: sql<boolean>` EXISTS ( SELECT 1 FROM ${tables.shoutLikes} WHERE ${tables.shoutLikes}.shout_id = ${tables.shouts}.xata_id AND ${tables.shoutLikes}.user_id = ${user.xata_id} )`.as("liked"), } : { id: tables.shouts.id, content: tables.shouts.content, createdAt: tables.shouts.createdAt, parent: tables.shouts.parentId, uri: tables.shouts.uri, likes: count(tables.shoutLikes.id).as("likes"), }, users: { id: tables.users.id, did: tables.users.did, handle: tables.users.handle, displayName: tables.users.displayName, avatar: tables.users.avatar, }, }) .from(tables.shouts) .leftJoin(tables.users, eq(tables.shouts.authorId, tables.users.id)) .leftJoin(tables.artists, eq(tables.shouts.artistId, tables.artists.id)) .leftJoin( tables.shoutLikes, eq(tables.shouts.id, tables.shoutLikes.shoutId), ) .where(eq(tables.artists.uri, `at://${did}/app.rocksky.artist/${rkey}`)) .groupBy( tables.shouts.id, tables.shouts.content, tables.shouts.createdAt, tables.shouts.uri, tables.shouts.parentId, tables.users.id, tables.users.did, tables.users.handle, tables.users.displayName, tables.users.avatar, ) .orderBy(desc(tables.shouts.createdAt)) .execute(); return c.json(shouts);});
app.get("/:did/app.rocksky.album/:rkey/shouts", async (c) => { requestCounter.add(1, { method: "GET", route: "/users/:did/app.rocksky.album/:rkey/shouts", });
const did = c.req.param("did"); const rkey = c.req.param("rkey");
const bearer = (c.req.header("authorization") || "").split(" ")[1]?.trim();
let user; if (bearer && bearer !== "null") { const payload = jwt.verify(bearer, env.JWT_SECRET, { ignoreExpiration: true, });
user = await ctx.client.db.users .filter("did", equals(payload.did)) .getFirst(); }
const shouts = await ctx.db .select({ shouts: user ? { id: tables.shouts.id, content: tables.shouts.content, createdAt: tables.shouts.createdAt, parent: tables.shouts.parentId, uri: tables.shouts.uri, likes: count(tables.shoutLikes.id).as("likes"), liked: sql<boolean>` EXISTS ( SELECT 1 FROM ${tables.shoutLikes} WHERE ${tables.shoutLikes}.shout_id = ${tables.shouts}.xata_id AND ${tables.shoutLikes}.user_id = ${user.xata_id} )`.as("liked"), } : { id: tables.shouts.id, content: tables.shouts.content, createdAt: tables.shouts.createdAt, parent: tables.shouts.parentId, uri: tables.shouts.uri, likes: count(tables.shoutLikes.id).as("likes"), }, users: { id: tables.users.id, did: tables.users.did, handle: tables.users.handle, displayName: tables.users.displayName, avatar: tables.users.avatar, }, }) .from(tables.shouts) .leftJoin(tables.users, eq(tables.shouts.authorId, tables.users.id)) .leftJoin(tables.albums, eq(tables.shouts.albumId, tables.albums.id)) .leftJoin( tables.shoutLikes, eq(tables.shouts.id, tables.shoutLikes.shoutId), ) .where(eq(tables.albums.uri, `at://${did}/app.rocksky.album/${rkey}`)) .groupBy( tables.shouts.id, tables.shouts.content, tables.shouts.createdAt, tables.shouts.uri, tables.shouts.parentId, tables.users.id, tables.users.did, tables.users.handle, tables.users.displayName, tables.users.avatar, ) .orderBy(desc(tables.shouts.createdAt)) .execute();
return c.json(shouts);});
app.get("/:did/app.rocksky.song/:rkey/shouts", async (c) => { requestCounter.add(1, { method: "GET", route: "/users/:did/app.rocksky.song/:rkey/shouts", }); const did = c.req.param("did"); const rkey = c.req.param("rkey");
const bearer = (c.req.header("authorization") || "").split(" ")[1]?.trim();
let user; if (bearer && bearer !== "null") { const payload = jwt.verify(bearer, env.JWT_SECRET, { ignoreExpiration: true, });
user = await ctx.client.db.users .filter("did", equals(payload.did)) .getFirst(); }
const shouts = await ctx.db .select({ shouts: user ? { id: tables.shouts.id, content: tables.shouts.content, createdAt: tables.shouts.createdAt, uri: tables.shouts.uri, parent: tables.shouts.parentId, likes: count(tables.shoutLikes.id).as("likes"), liked: sql<boolean>` EXISTS ( SELECT 1 FROM ${tables.shoutLikes} WHERE ${tables.shoutLikes}.shout_id = ${tables.shouts}.xata_id AND ${tables.shoutLikes}.user_id = ${user.xata_id} )`.as("liked"), } : { id: tables.shouts.id, content: tables.shouts.content, createdAt: tables.shouts.createdAt, uri: tables.shouts.uri, parent: tables.shouts.parentId, likes: count(tables.shoutLikes.id).as("likes"), }, users: { id: tables.users.id, did: tables.users.did, handle: tables.users.handle, displayName: tables.users.displayName, avatar: tables.users.avatar, }, }) .from(tables.shouts) .leftJoin(tables.users, eq(tables.shouts.authorId, tables.users.id)) .leftJoin(tables.tracks, eq(tables.shouts.trackId, tables.tracks.id)) .leftJoin( tables.shoutLikes, eq(tables.shouts.id, tables.shoutLikes.shoutId), ) .where(eq(tables.tracks.uri, `at://${did}/app.rocksky.song/${rkey}`)) .groupBy( tables.shouts.id, tables.shouts.content, tables.shouts.createdAt, tables.shouts.uri, tables.shouts.parentId, tables.users.id, tables.users.did, tables.users.handle, tables.users.displayName, tables.users.avatar, ) .orderBy(desc(tables.shouts.createdAt)) .execute();
return c.json(shouts);});
app.get("/:did/app.rocksky.scrobble/:rkey/shouts", async (c) => { requestCounter.add(1, { method: "GET", route: "/users/:did/app.rocksky.scrobble/:rkey/shouts", }); const did = c.req.param("did"); const rkey = c.req.param("rkey");
const bearer = (c.req.header("authorization") || "").split(" ")[1]?.trim();
let user; if (bearer && bearer !== "null") { const payload = jwt.verify(bearer, env.JWT_SECRET, { ignoreExpiration: true, });
user = await ctx.client.db.users .filter("did", equals(payload.did)) .getFirst(); }
const shouts = await ctx.db .select({ shouts: user ? { id: tables.shouts.id, content: tables.shouts.content, createdAt: tables.shouts.createdAt, uri: tables.shouts.uri, parent: tables.shouts.parentId, likes: count(tables.shoutLikes.id).as("likes"), liked: sql<boolean>` EXISTS ( SELECT 1 FROM ${tables.shoutLikes} WHERE ${tables.shoutLikes}.shout_id = ${tables.shouts}.xata_id AND ${tables.shoutLikes}.user_id = ${user.xata_id} )`.as("liked"), } : { id: tables.shouts.id, content: tables.shouts.content, createdAt: tables.shouts.createdAt, uri: tables.shouts.uri, parent: tables.shouts.parentId, likes: count(tables.shoutLikes.id).as("likes"), }, users: { id: tables.users.id, did: tables.users.did, handle: tables.users.handle, displayName: tables.users.displayName, avatar: tables.users.avatar, }, }) .from(tables.shouts) .leftJoin(tables.users, eq(tables.shouts.authorId, tables.users.id)) .leftJoin( tables.scrobbles, eq(tables.shouts.scrobbleId, tables.scrobbles.id), ) .leftJoin( tables.shoutLikes, eq(tables.shouts.id, tables.shoutLikes.shoutId), ) .where(eq(tables.scrobbles.uri, `at://${did}/app.rocksky.scrobble/${rkey}`)) .groupBy( tables.shouts.id, tables.shouts.content, tables.shouts.createdAt, tables.shouts.uri, tables.shouts.parentId, tables.users.id, tables.users.did, tables.users.handle, tables.users.displayName, tables.users.avatar, ) .orderBy(desc(tables.shouts.createdAt)) .execute();
return c.json(shouts);});
app.get("/:did/shouts", async (c) => { requestCounter.add(1, { method: "GET", route: "/users/:did/shouts" }); const did = c.req.param("did");
const bearer = (c.req.header("authorization") || "").split(" ")[1]?.trim();
let user; if (bearer && bearer !== "null") { const payload = jwt.verify(bearer, env.JWT_SECRET, { ignoreExpiration: true, });
user = await ctx.client.db.users .filter("did", equals(payload.did)) .getFirst(); }
const shouts = await ctx.db .select({ profileShouts: { id: tables.profileShouts.id, createdAt: tables.profileShouts.createdAt, }, shouts: user ? { id: tables.shouts.id, content: tables.shouts.content, createdAt: tables.shouts.createdAt, uri: tables.shouts.uri, parent: tables.shouts.parentId, likes: count(tables.shoutLikes.id).as("likes"), liked: sql<boolean>` EXISTS ( SELECT 1 FROM ${tables.shoutLikes} WHERE ${tables.shoutLikes}.shout_id = ${tables.shouts}.xata_id AND ${tables.shoutLikes}.user_id = ${user.xata_id} )`.as("liked"), reported: sql<boolean>` EXISTS ( SELECT 1 FROM ${tables.shoutReports} WHERE ${tables.shoutReports}.shout_id = ${tables.shouts}.xata_id AND ${tables.shoutReports}.user_id = ${user.xata_id} )`.as("reported"), } : { id: tables.shouts.id, content: tables.shouts.content, createdAt: tables.shouts.createdAt, uri: tables.shouts.uri, parent: tables.shouts.parentId, likes: count(tables.shoutLikes.id).as("likes"), }, users: { id: aliasedTable(tables.users, "authors").id, did: aliasedTable(tables.users, "authors").did, handle: aliasedTable(tables.users, "authors").handle, displayName: aliasedTable(tables.users, "authors").displayName, avatar: aliasedTable(tables.users, "authors").avatar, }, }) .from(tables.profileShouts) .where(or(eq(tables.users.did, did), eq(tables.users.handle, did))) .leftJoin(tables.shouts, eq(tables.profileShouts.shoutId, tables.shouts.id)) .leftJoin( aliasedTable(tables.users, "authors"), eq(tables.shouts.authorId, aliasedTable(tables.users, "authors").id), ) .leftJoin(tables.users, eq(tables.profileShouts.userId, tables.users.id)) .leftJoin( tables.shoutLikes, eq(tables.shouts.id, tables.shoutLikes.shoutId), ) .groupBy( tables.profileShouts.id, tables.profileShouts.createdAt, tables.shouts.id, tables.shouts.uri, tables.shouts.content, tables.shouts.createdAt, tables.shouts.parentId, tables.users.id, tables.users.did, tables.users.handle, tables.users.displayName, tables.users.avatar, aliasedTable(tables.users, "authors").id, aliasedTable(tables.users, "authors").did, aliasedTable(tables.users, "authors").handle, aliasedTable(tables.users, "authors").displayName, aliasedTable(tables.users, "authors").avatar, ) .orderBy(desc(tables.profileShouts.createdAt)) .execute();
return c.json(shouts);});
app.get("/:did/app.rocksky.shout/:rkey/likes", async (c) => { requestCounter.add(1, { method: "GET", route: "/users/:did/app.rocksky.shout/:rkey/likes", }); const did = c.req.param("did"); const rkey = c.req.param("rkey"); const likes = await ctx.client.db.shout_likes .select(["user_id.*", "xata_createdat"]) .filter("shout_id.uri", `at://${did}/app.rocksky.shout/${rkey}`) .getAll(); return c.json(likes);});
app.get("/:did/app.rocksky.shout/:rkey/replies", async (c) => { requestCounter.add(1, { method: "GET", route: "/users/:did/app.rocksky.shout/:rkey/replies", }); const did = c.req.param("did"); const rkey = c.req.param("rkey"); const shouts = await ctx.client.db.shouts .select(["author_id.*", "xata_createdat"]) .filter("parent_id.uri", `at://${did}/app.rocksky.shout/${rkey}`) .sort("xata_createdat", "asc") .getAll(); return c.json(shouts);});
app.get("/:did/stats", async (c) => { requestCounter.add(1, { method: "GET", route: "/users/:did/stats" }); const did = c.req.param("did");
const { data } = await ctx.analytics.post("library.getStats", { user_did: did, });
return c.json({ scrobbles: data.scrobbles, artists: data.artists, lovedTracks: data.loved_tracks, albums: data.albums, tracks: data.tracks, });});
app.post("/:did/app.rocksky.shout/:rkey/report", async (c) => { requestCounter.add(1, { method: "POST", route: "/users/:did/app.rocksky.shout/:rkey/report", }); const did = c.req.param("did"); const rkey = c.req.param("rkey");
const bearer = (c.req.header("authorization") || "").split(" ")[1]?.trim();
if (!bearer || bearer === "null") { c.status(401); return c.text("Unauthorized"); }
const payload = jwt.verify(bearer, env.JWT_SECRET, { ignoreExpiration: true, }); const shout = await ctx.client.db.shouts .filter("uri", `at://${did}/app.rocksky.shout/${rkey}`) .getFirst();
const user = await ctx.client.db.users .filter("did", equals(payload.did)) .getFirst();
if (!shout) { c.status(404); return c.text("Shout not found"); }
if (!user) { c.status(401); return c.text("Unauthorized"); }
const existingReport = await ctx.client.db.shout_reports .filter({ user_id: user.xata_id, shout_id: shout.xata_id, }) .getFirst();
if (existingReport) { return c.json(existingReport); }
const report = await ctx.client.db.shout_reports.create({ user_id: user.xata_id, shout_id: shout.xata_id, });
return c.json(report);});
app.delete("/:did/app.rocksky.shout/:rkey/report", async (c) => { requestCounter.add(1, { method: "DELETE", route: "/users/:did/app.rocksky.shout/:rkey/report", }); const did = c.req.param("did"); const rkey = c.req.param("rkey");
const bearer = (c.req.header("authorization") || "").split(" ")[1]?.trim();
if (!bearer || bearer === "null") { c.status(401); return c.text("Unauthorized"); }
const payload = jwt.verify(bearer, env.JWT_SECRET, { ignoreExpiration: true, }); const shout = await ctx.client.db.shouts .filter("uri", `at://${did}/app.rocksky.shout/${rkey}`) .getFirst();
const user = await ctx.client.db.users .filter("did", equals(payload.did)) .getFirst();
if (!shout) { c.status(404); return c.text("Shout not found"); }
if (!user) { c.status(401); return c.text("Unauthorized"); }
const report = await ctx.client.db.shout_reports .select(["user_id.*", "shout_id.*"]) .filter({ user_id: user.xata_id, shout_id: shout.xata_id, }) .getFirst();
if (!report) { c.status(404); return c.text("Report not found"); }
if (report.user_id.xata_id !== user.xata_id) { c.status(403); return c.text("Forbidden"); }
await ctx.client.db.shout_reports.delete(report.xata_id);
return c.json(report);});
app.delete("/:did/app.rocksky.shout/:rkey", async (c) => { requestCounter.add(1, { method: "DELETE", route: "/users/:did/app.rocksky.shout/:rkey", }); const did = c.req.param("did"); const rkey = c.req.param("rkey");
const bearer = (c.req.header("authorization") || "").split(" ")[1]?.trim();
if (!bearer || bearer === "null") { c.status(401); return c.text("Unauthorized"); }
const payload = jwt.verify(bearer, env.JWT_SECRET, { ignoreExpiration: true, }); const agent = await createAgent(ctx.oauthClient, payload.did);
const user = await ctx.client.db.users .filter("did", equals(payload.did)) .getFirst();
if (!user) { c.status(401); return c.text("Unauthorized"); }
const shout = await ctx.client.db.shouts .select([ "author_id.*", "uri", "content", "xata_id", "xata_createdat", "parent_id", ]) .filter("uri", `at://${did}/app.rocksky.shout/${rkey}`) .getFirst();
if (!shout) { c.status(404); return c.text("Shout not found"); }
if (shout.author_id.xata_id !== user.xata_id) { c.status(403); return c.text("Forbidden"); }
const replies = await ctx.db .select({ replies: { id: tables.shouts.id, }, }) .from(tables.shouts) .where(eq(tables.shouts.parentId, shout.xata_id)) .execute();
const replyIds = replies.map(({ replies: r }) => r.id);
// Delete related records in the correct order await ctx.db .delete(tables.shoutLikes) .where(inArray(tables.shoutLikes.shoutId, replyIds)) .execute();
await ctx.db .delete(tables.shoutReports) .where(inArray(tables.shoutReports.shoutId, replyIds)) .execute();
await ctx.db .delete(tables.profileShouts) .where(eq(tables.profileShouts.shoutId, shout.xata_id)) .execute();
await ctx.db .delete(tables.profileShouts) .where(inArray(tables.profileShouts.shoutId, replyIds)) .execute();
await ctx.db .delete(tables.shoutLikes) .where(eq(tables.shoutLikes.shoutId, shout.xata_id)) .execute();
await ctx.db .delete(tables.shoutReports) .where(eq(tables.shoutReports.shoutId, shout.xata_id)) .execute();
await ctx.db .delete(tables.shouts) .where(inArray(tables.shouts.id, replyIds)) .execute();
await ctx.db .delete(tables.shouts) .where(eq(tables.shouts.id, shout.xata_id)) .execute();
await agent.com.atproto.repo.deleteRecord({ repo: agent.assertDid, collection: "app.rocksky.shout", rkey: shout.uri.split("/").pop(), });
return c.json(shout);});
export default app;