dan/itpdp
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Compare commits

base: dan:2d16fb8ecc23e40d43babba8ef6b4b76c743d479
Branches Tags
dan:master
dan:features/Expand-questions-generation
..
compare: dan:7738645a691821b3cbf0f821dcddc168c16e3983
Branches Tags
dan:master
dan:features/Expand-questions-generation

No commits in common. "2d16fb8ecc23e40d43babba8ef6b4b76c743d479" and "7738645a691821b3cbf0f821dcddc168c16e3983" have entirely different histories.
2d16fb8ecc ... 7738645a69

24 changed files with 1690 additions and 2399 deletions
Show stats Expand all files Collapse all files

6
api/AGENTS.md
View file

@ -1,6 +0,0 @@
Run biome and typescript checks after your changes:
```
bun x biome ci
bun x tsc --noEmit
```

20
api/drizzle.config.ts
View file

@ -1,17 +1,11 @@
import { defineConfig } from "drizzle-kit"; import { defineConfig } from "drizzle-kit";
const databaseUrl = process.env.DATABASE_URL;
if (!databaseUrl) {
throw new Error("Missing required env var: DATABASE_URL");
}
export default defineConfig({ export default defineConfig({
out: "./drizzle", out: "./drizzle",
schema: "./src/db/schema.ts", schema: "./src/db/schema.ts",
dialect: "postgresql", dialect: "postgresql",
dbCredentials: { dbCredentials: {
url: databaseUrl, url: process.env.DATABASE_URL!,
}, },
schemaFilter: ["public"], schemaFilter: ["public"],
}); });

43
api/package.json
View file

@ -1,24 +1,23 @@
{ {
"name": "api", "name": "api",
"module": "index.ts", "module": "index.ts",
"type": "module", "type": "module",
"private": true, "private": true,
"main": "src/index.ts", "main": "src/index.ts",
"scripts": { "scripts": {
"dev": "bun run --watch src/index.ts", "dev": "bun run --watch src/index.ts"
"typecheck": "tsc --noEmit" },
}, "devDependencies": {
"devDependencies": { "@types/bun": "latest"
"@types/bun": "latest" },
}, "peerDependencies": {
"peerDependencies": { "typescript": "^5"
"typescript": "^5" },
}, "dependencies": {
"dependencies": { "@dbos-inc/dbos-sdk": "^4.14.6",
"@dbos-inc/dbos-sdk": "^4.14.6", "@spotify/web-api-ts-sdk": "^1.2.0",
"@spotify/web-api-ts-sdk": "^1.2.0", "@statsfm/statsfm.js": "github.com:statsfm/statsfm.js",
"@statsfm/statsfm.js": "github.com:statsfm/statsfm.js", "better-auth": "^1.6.5",
"better-auth": "^1.6.5", "elysia": "catalog:"
"elysia": "catalog:" }
}
} }

94
api/src/auth.ts
View file

@ -1,65 +1,59 @@
import { SpotifyApi } from "@spotify/web-api-ts-sdk";
import { betterAuth } from "better-auth"; import { betterAuth } from "better-auth";
import { drizzleAdapter } from "better-auth/adapters/drizzle"; import { drizzleAdapter } from "better-auth/adapters/drizzle";
import Elysia from "elysia";
import { db } from "./db"; import { db } from "./db";
import Elysia, { status, type Context } from "elysia";
import * as schema from "./db/auth-schema"; import * as schema from "./db/auth-schema";
import { SpotifyApi } from "@spotify/web-api-ts-sdk";
const requireEnv = (name: string): string => { export const SPOTIFY_CLIENT_ID = process.env.SPOTIFY_CLIENT_ID!;
const value = process.env[name]; export const SPOTIFY_CLIENT_SECRET = process.env.SPOTIFY_CLIENT_SECRET!;
if (!value) throw new Error(`Missing required env var: ${name}`);
return value;
};
export const SPOTIFY_CLIENT_ID = requireEnv("SPOTIFY_CLIENT_ID");
export const SPOTIFY_CLIENT_SECRET = requireEnv("SPOTIFY_CLIENT_SECRET");
export const defaultSdk = SpotifyApi.withClientCredentials( export const defaultSdk = SpotifyApi.withClientCredentials(
SPOTIFY_CLIENT_ID, SPOTIFY_CLIENT_ID,
SPOTIFY_CLIENT_SECRET, SPOTIFY_CLIENT_SECRET,
); );
export const auth = betterAuth({ export const auth = betterAuth({
database: drizzleAdapter(db, { database: drizzleAdapter(db, {
provider: "pg", provider: "pg",
schema, schema,
}), }),
socialProviders: { socialProviders: {
spotify: { spotify: {
clientId: SPOTIFY_CLIENT_ID, clientId: SPOTIFY_CLIENT_ID,
clientSecret: SPOTIFY_CLIENT_SECRET, clientSecret: SPOTIFY_CLIENT_SECRET,
scope: [ scope: [
"user-read-playback-state", "user-read-playback-state",
"user-read-currently-playing", "user-read-currently-playing",
"user-modify-playback-state", "user-modify-playback-state",
"playlist-read-private", "playlist-read-private",
"playlist-read-collaborative", "playlist-read-collaborative",
"user-follow-read", "user-follow-read",
"user-top-read", "user-top-read",
"user-read-recently-played", "user-read-recently-played",
"user-library-read", "user-library-read",
// "user-personalized", // "user-personalized",
"user-read-email", "user-read-email",
], ],
}, },
}, },
}); });
export const betterAuthElysia = new Elysia({ name: "better-auth" }) export const betterAuthElysia = new Elysia({ name: "better-auth" })
.mount(auth.handler) .mount(auth.handler)
.macro({ .macro({
auth: { auth: {
async resolve({ status, request: { headers } }) { async resolve({ status, request: { headers } }) {
const session = await auth.api.getSession({ const session = await auth.api.getSession({
headers, headers,
}); });
if (!session) return status(401); if (!session) return status(401);
return { return {
user: session.user, user: session.user,
session: session.session, session: session.session,
}; };
}, },
}, },
}); });

142
api/src/db/auth-schema.ts
View file

@ -1,93 +1,93 @@
import { relations } from "drizzle-orm/_relations"; import { relations } from "drizzle-orm/_relations";
import { boolean, index, pgTable, text, timestamp } from "drizzle-orm/pg-core"; import { pgTable, text, timestamp, boolean, index } from "drizzle-orm/pg-core";
export const user = pgTable("user", { export const user = pgTable("user", {
id: text("id").primaryKey(), id: text("id").primaryKey(),
name: text("name").notNull(), name: text("name").notNull(),
email: text("email").notNull().unique(), email: text("email").notNull().unique(),
emailVerified: boolean("email_verified").default(false).notNull(), emailVerified: boolean("email_verified").default(false).notNull(),
image: text("image"), image: text("image"),
createdAt: timestamp("created_at").defaultNow().notNull(), createdAt: timestamp("created_at").defaultNow().notNull(),
updatedAt: timestamp("updated_at") updatedAt: timestamp("updated_at")
.defaultNow() .defaultNow()
.$onUpdate(() => /* @__PURE__ */ new Date()) .$onUpdate(() => /* @__PURE__ */ new Date())
.notNull(), .notNull(),
}); });
export const session = pgTable( export const session = pgTable(
"session", "session",
{ {
id: text("id").primaryKey(), id: text("id").primaryKey(),
expiresAt: timestamp("expires_at").notNull(), expiresAt: timestamp("expires_at").notNull(),
token: text("token").notNull().unique(), token: text("token").notNull().unique(),
createdAt: timestamp("created_at").defaultNow().notNull(), createdAt: timestamp("created_at").defaultNow().notNull(),
updatedAt: timestamp("updated_at") updatedAt: timestamp("updated_at")
.$onUpdate(() => /* @__PURE__ */ new Date()) .$onUpdate(() => /* @__PURE__ */ new Date())
.notNull(), .notNull(),
ipAddress: text("ip_address"), ipAddress: text("ip_address"),
userAgent: text("user_agent"), userAgent: text("user_agent"),
userId: text("user_id") userId: text("user_id")
.notNull() .notNull()
.references(() => user.id, { onDelete: "cascade" }), .references(() => user.id, { onDelete: "cascade" }),
}, },
(table) => [index("session_userId_idx").on(table.userId)], (table) => [index("session_userId_idx").on(table.userId)],
); );
export const account = pgTable( export const account = pgTable(
"account", "account",
{ {
id: text("id").primaryKey(), id: text("id").primaryKey(),
accountId: text("account_id").notNull(), accountId: text("account_id").notNull(),
providerId: text("provider_id").notNull(), providerId: text("provider_id").notNull(),
userId: text("user_id") userId: text("user_id")
.notNull() .notNull()
.references(() => user.id, { onDelete: "cascade" }), .references(() => user.id, { onDelete: "cascade" }),
accessToken: text("access_token"), accessToken: text("access_token"),
refreshToken: text("refresh_token"), refreshToken: text("refresh_token"),
idToken: text("id_token"), idToken: text("id_token"),
accessTokenExpiresAt: timestamp("access_token_expires_at"), accessTokenExpiresAt: timestamp("access_token_expires_at"),
refreshTokenExpiresAt: timestamp("refresh_token_expires_at"), refreshTokenExpiresAt: timestamp("refresh_token_expires_at"),
scope: text("scope"), scope: text("scope"),
password: text("password"), password: text("password"),
createdAt: timestamp("created_at").defaultNow().notNull(), createdAt: timestamp("created_at").defaultNow().notNull(),
updatedAt: timestamp("updated_at") updatedAt: timestamp("updated_at")
.$onUpdate(() => /* @__PURE__ */ new Date()) .$onUpdate(() => /* @__PURE__ */ new Date())
.notNull(), .notNull(),
}, },
(table) => [index("account_userId_idx").on(table.userId)], (table) => [index("account_userId_idx").on(table.userId)],
); );
export const verification = pgTable( export const verification = pgTable(
"verification", "verification",
{ {
id: text("id").primaryKey(), id: text("id").primaryKey(),
identifier: text("identifier").notNull(), identifier: text("identifier").notNull(),
value: text("value").notNull(), value: text("value").notNull(),
expiresAt: timestamp("expires_at").notNull(), expiresAt: timestamp("expires_at").notNull(),
createdAt: timestamp("created_at").defaultNow().notNull(), createdAt: timestamp("created_at").defaultNow().notNull(),
updatedAt: timestamp("updated_at") updatedAt: timestamp("updated_at")
.defaultNow() .defaultNow()
.$onUpdate(() => /* @__PURE__ */ new Date()) .$onUpdate(() => /* @__PURE__ */ new Date())
.notNull(), .notNull(),
}, },
(table) => [index("verification_identifier_idx").on(table.identifier)], (table) => [index("verification_identifier_idx").on(table.identifier)],
); );
export const userRelations = relations(user, ({ many }) => ({ export const userRelations = relations(user, ({ many }) => ({
sessions: many(session), sessions: many(session),
accounts: many(account), accounts: many(account),
})); }));
export const sessionRelations = relations(session, ({ one }) => ({ export const sessionRelations = relations(session, ({ one }) => ({
user: one(user, { user: one(user, {
fields: [session.userId], fields: [session.userId],
references: [user.id], references: [user.id],
}), }),
})); }));
export const accountRelations = relations(account, ({ one }) => ({ export const accountRelations = relations(account, ({ one }) => ({
user: one(user, { user: one(user, {
fields: [account.userId], fields: [account.userId],
references: [user.id], references: [user.id],
}), }),
})); }));

8
api/src/db/index.ts
View file

@ -1,10 +1,4 @@
import { drizzle } from "drizzle-orm/node-postgres"; import { drizzle } from "drizzle-orm/node-postgres";
import { relations } from "./schema"; import { relations } from "./schema";
const databaseUrl = process.env.DATABASE_URL; export const db = drizzle(process.env.DATABASE_URL!, { relations });
if (!databaseUrl) {
throw new Error("Missing required env var: DATABASE_URL");
}
export const db = drizzle(databaseUrl, { relations });

1027
api/src/db/schema.ts
View file

File diff suppressed because it is too large Load diff

842
api/src/db/spotify.ts
View file

@ -1,504 +1,488 @@
import type { import type {
Album, Album,
Artist, Artist,
Image, Image,
PlayHistory, PlayHistory,
SavedAlbum, SavedAlbum,
SavedTrack, SavedTrack,
SimplifiedAlbum, SimplifiedAlbum,
SimplifiedArtist, SimplifiedArtist,
Track, Track,
} from "@spotify/web-api-ts-sdk"; } from "@spotify/web-api-ts-sdk";
import { and, eq, inArray, sql } from "drizzle-orm";
import { defaultSdk } from "../auth";
import { db } from "."; import { db } from ".";
import { import {
album, album,
albumArtist, albumArtist,
albumGenre, albumGenre,
albumImage, albumImage,
artist, artist,
artistGenre, artistGenre,
artistImage, artistImage,
followedArtist, followedArtist,
genre, genre,
platformImage, playbackHistory,
playbackHistory, platformImage,
savedAlbum, savedAlbum,
savedTrack, savedTrack,
topArtist, topArtist,
topTrack, topTrack,
track, track,
trackArtist, trackArtist,
} from "./schema"; } from "./schema";
import { and, eq, inArray, sql } from "drizzle-orm";
import { defaultSdk } from "../auth";
export const PLATFORM_SPOTIFY = "spotify" as const; export const PLATFORM_SPOTIFY = "spotify" as const;
type DbClient = typeof db; type DbClient = typeof db;
type DbTransaction = Parameters<typeof db.transaction>[0] extends ( type DbTransaction = Parameters<typeof db.transaction>[0] extends (
tx: infer T, tx: infer T,
) => Promise<unknown> ) => Promise<any>
? T ? T
: never; : never;
type DbLike = DbClient | DbTransaction; type DbLike = DbClient | DbTransaction;
const requireMapEntry = <K, V>(map: Map<K, V>, key: K, label: string): V => {
const value = map.get(key);
if (!value) throw new Error(`Missing ${label} for ${String(key)}`);
return value;
};
export async function upsertImages(images: Image[], dbClient: DbLike = db) { export async function upsertImages(images: Image[], dbClient: DbLike = db) {
await dbClient await dbClient
.insert(platformImage) .insert(platformImage)
.values( .values(
images.map(({ url, height, width }) => ({ images.map(({ url, height, width }) => ({
platform: PLATFORM_SPOTIFY, platform: PLATFORM_SPOTIFY,
url, url,
height, height,
width, width,
})), })),
) )
.onConflictDoNothing(); .onConflictDoNothing();
} }
export async function upsertGenres(genres: string[], dbClient: DbLike = db) { export async function upsertGenres(genres: string[], dbClient: DbLike = db) {
const values = genres.filter(Boolean).map((name) => ({ name })); const values = genres.filter(Boolean).map((name) => ({ name }));
if (values.length === 0) return; if (values.length === 0) return;
await dbClient.insert(genre).values(values).onConflictDoNothing(); await dbClient.insert(genre).values(values).onConflictDoNothing();
} }
export async function upsertArtists(artists: Artist[], dbClient: DbLike = db) { export async function upsertArtists(artists: Artist[], dbClient: DbLike = db) {
await dbClient await dbClient
.insert(artist) .insert(artist)
.values( .values(
artists.map(({ id, name, popularity, type }) => ({ artists.map(({ id, name, images, genres, popularity, type }) => ({
platform: PLATFORM_SPOTIFY, platform: PLATFORM_SPOTIFY,
platform_id: id, platform_id: id,
name, name,
popularity, popularity,
type, type,
})), })),
) )
.onConflictDoNothing(); .onConflictDoNothing();
await upsertImages( await upsertImages(
artists.flatMap((a) => a.images), artists.flatMap((a) => a.images),
dbClient, dbClient,
); );
await upsertGenres( await upsertGenres(
artists.flatMap((a) => a.genres), artists.flatMap((a) => a.genres),
dbClient, dbClient,
); );
for (const spotifyArtist of artists) { for (const spotifyArtist of artists) {
await dbClient await dbClient
.insert(artistImage) .insert(artistImage)
.select( .select(
dbClient dbClient
.select({ .select({
artistId: artist.id, artistId: artist.id,
imageId: platformImage.id, imageId: platformImage.id,
}) })
.from(platformImage) .from(platformImage)
.where( .where(
and( and(
eq(platformImage.platform, PLATFORM_SPOTIFY), eq(platformImage.platform, PLATFORM_SPOTIFY),
inArray( inArray(
platformImage.url, platformImage.url,
spotifyArtist.images.map((t) => t.url), spotifyArtist.images.map((t) => t.url),
), ),
), ),
) )
.innerJoin(artist, eq(artist.platform_id, spotifyArtist.id)), .innerJoin(artist, eq(artist.platform_id, spotifyArtist.id)),
) )
.onConflictDoNothing(); .onConflictDoNothing();
await dbClient await dbClient
.insert(artistGenre) .insert(artistGenre)
.select( .select(
dbClient dbClient
.select({ .select({
artistId: artist.id, artistId: artist.id,
genreId: genre.id, genreId: genre.id,
}) })
.from(genre) .from(genre)
.where(inArray(genre.name, spotifyArtist.genres)) .where(inArray(genre.name, spotifyArtist.genres))
.innerJoin(artist, eq(artist.platform_id, spotifyArtist.id)), .innerJoin(artist, eq(artist.platform_id, spotifyArtist.id)),
) )
.onConflictDoNothing(); .onConflictDoNothing();
} }
} }
async function getMissingArtists(artistIds: string[], dbClient: DbLike = db) { async function getMissingArtists(artistIds: string[], dbClient: DbLike = db) {
const existingArtists = await dbClient const existingArtists = await dbClient
.select({ id: artist.id }) .select({ id: artist.id })
.from(artist) .from(artist)
.where(inArray(artist.platform_id, artistIds)); .where(inArray(artist.platform_id, artistIds));
return artistIds.filter((id) => !existingArtists.some((a) => a.id === id)); return artistIds.filter((id) => !existingArtists.some((a) => a.id === id));
} }
async function lookupMissingArtists( async function lookupMissingArtists(
artistIds: string[], artistIds: string[],
dbClient: DbLike = db, dbClient: DbLike = db,
) { ) {
const missingArtistIds = await getMissingArtists(artistIds, dbClient); const missingArtistIds = await getMissingArtists(artistIds, dbClient);
if (missingArtistIds.length === 0) return []; if (missingArtistIds.length === 0) return [];
const missingArtists: Artist[] = []; let missingArtists: Artist[] = [];
for (let i = 0; i < missingArtistIds.length / 50; i++) { for (let i = 0; i < missingArtistIds.length / 50; i++) {
missingArtists.push( missingArtists.push(
...(await defaultSdk.artists.get( ...(await defaultSdk.artists.get(
missingArtistIds.slice(i * 50, (i + 1) * 50), missingArtistIds.slice(i * 50, (i + 1) * 50),
)), )),
); );
} }
await upsertArtists(missingArtists, dbClient); await upsertArtists(missingArtists, dbClient);
return missingArtists; return missingArtists;
} }
function isFullArtistArray( function isFullArtistArray(
artists: Artist[] | SimplifiedArtist[], artists: Artist[] | SimplifiedArtist[],
): artists is Artist[] { ): artists is Artist[] {
const firstArtist = artists[0]; return "images" in artists[0]!;
if (!firstArtist) return false;
return "images" in firstArtist;
} }
async function upsertMissingArtists( async function upsertMissingArtists(
artists: SimplifiedArtist[] | Artist[], artists: SimplifiedArtist[] | Artist[],
dbClient: DbLike = db, dbClient: DbLike = db,
) { ) {
if (artists.length === 0) return; if (artists.length === 0) return;
let missingArtists: Artist[]; let missingArtists: Artist[];
if (isFullArtistArray(artists)) { if (isFullArtistArray(artists)) {
const missingArtistIds = await getMissingArtists( const missingArtistIds = await getMissingArtists(
artists.map((t) => t.id), artists.map((t) => t.id),
dbClient, dbClient,
); );
if (missingArtistIds.length === 0) return; if (missingArtistIds.length === 0) return;
missingArtists = artists.filter((a) => missingArtistIds.includes(a.id)); missingArtists = artists.filter((a) => missingArtistIds.includes(a.id));
} else { } else {
missingArtists = await lookupMissingArtists( missingArtists = await lookupMissingArtists(
artists.map((t) => t.id), artists.map((t) => t.id),
dbClient, dbClient,
); );
} }
if (missingArtists.length === 0) return; if (missingArtists.length === 0) return;
await upsertArtists(missingArtists, dbClient); await upsertArtists(missingArtists, dbClient);
return missingArtists; return missingArtists;
} }
async function getArtistIdMap(artistIds: string[], dbClient: DbLike = db) { async function getArtistIdMap(artistIds: string[], dbClient: DbLike = db) {
if (artistIds.length === 0) return new Map<string, string>(); if (artistIds.length === 0) return new Map<string, string>();
const rows = await dbClient const rows = await dbClient
.select({ id: artist.id, platform_id: artist.platform_id }) .select({ id: artist.id, platform_id: artist.platform_id })
.from(artist) .from(artist)
.where(inArray(artist.platform_id, artistIds)); .where(inArray(artist.platform_id, artistIds));
return new Map(rows.map((row) => [row.platform_id, row.id])); return new Map(rows.map((row) => [row.platform_id, row.id]));
} }
async function getAlbumIdMap(albumIds: string[], dbClient: DbLike = db) { async function getAlbumIdMap(albumIds: string[], dbClient: DbLike = db) {
if (albumIds.length === 0) return new Map<string, string>(); if (albumIds.length === 0) return new Map<string, string>();
const rows = await dbClient const rows = await dbClient
.select({ id: album.id, platform_id: album.platform_id }) .select({ id: album.id, platform_id: album.platform_id })
.from(album) .from(album)
.where(inArray(album.platform_id, albumIds)); .where(inArray(album.platform_id, albumIds));
return new Map( return new Map(rows.map((row) => [row.platform_id ?? "", row.id]));
rows
.filter((row) => row.platform_id)
.map((row) => [row.platform_id as string, row.id]),
);
} }
async function getTrackIdMap(trackIds: string[], dbClient: DbLike = db) { async function getTrackIdMap(trackIds: string[], dbClient: DbLike = db) {
if (trackIds.length === 0) return new Map<string, string>(); if (trackIds.length === 0) return new Map<string, string>();
const rows = await dbClient const rows = await dbClient
.select({ id: track.id, platform_id: track.platform_id }) .select({ id: track.id, platform_id: track.platform_id })
.from(track) .from(track)
.where(inArray(track.platform_id, trackIds)); .where(inArray(track.platform_id, trackIds));
return new Map( return new Map(rows.map((row) => [row.platform_id ?? "", row.id]));
rows
.filter((row) => row.platform_id)
.map((row) => [row.platform_id as string, row.id]),
);
} }
export async function upsertAlbums( export async function upsertAlbums(
albums: Album[] | SimplifiedAlbum[], albums: Album[] | SimplifiedAlbum[],
dbClient: DbLike = db, dbClient: DbLike = db,
) { ) {
await upsertMissingArtists( await upsertMissingArtists(
albums.flatMap((a) => a.artists), albums.flatMap((a) => a.artists),
dbClient, dbClient,
); );
await dbClient await dbClient
.insert(album) .insert(album)
.values( .values(
albums.map(({ id, name, type, popularity, release_date, label }) => ({ albums.map(({ id, name, type, popularity, release_date, label }) => ({
platform: PLATFORM_SPOTIFY, platform: PLATFORM_SPOTIFY,
platform_id: id, platform_id: id,
name, name,
type, type,
popularity, popularity,
release_date: new Date(release_date), release_date: new Date(release_date),
label, label,
})), })),
) )
.onConflictDoNothing(); .onConflictDoNothing();
await upsertImages( await upsertImages(
albums.flatMap((a) => a.images), albums.flatMap((a) => a.images),
dbClient, dbClient,
); );
await upsertGenres( await upsertGenres(
albums.flatMap((a) => a.genres), albums.flatMap((a) => a.genres),
dbClient, dbClient,
); );
for (const spotifyAlbum of albums) { for (const spotifyAlbum of albums) {
await dbClient await dbClient
.insert(albumImage) .insert(albumImage)
.select( .select(
dbClient dbClient
.select({ .select({
albumId: album.id, albumId: album.id,
imageId: platformImage.id, imageId: platformImage.id,
}) })
.from(platformImage) .from(platformImage)
.where( .where(
and( and(
eq(platformImage.platform, PLATFORM_SPOTIFY), eq(platformImage.platform, PLATFORM_SPOTIFY),
inArray( inArray(
platformImage.url, platformImage.url,
spotifyAlbum.images.map((t) => t.url), spotifyAlbum.images.map((t) => t.url),
), ),
), ),
) )
.innerJoin(album, eq(album.platform_id, spotifyAlbum.id)), .innerJoin(album, eq(album.platform_id, spotifyAlbum.id)),
) )
.onConflictDoNothing(); .onConflictDoNothing();
await dbClient await dbClient
.insert(albumArtist) .insert(albumArtist)
.select( .select(
dbClient dbClient
.select({ .select({
albumId: album.id, albumId: album.id,
artistId: artist.id, artistId: artist.id,
}) })
.from(artist) .from(artist)
.where( .where(
inArray( inArray(
artist.platform_id, artist.platform_id,
spotifyAlbum.artists.map((t) => t.id), spotifyAlbum.artists.map((t) => t.id),
), ),
) )
.innerJoin(album, eq(album.platform_id, spotifyAlbum.id)), .innerJoin(album, eq(album.platform_id, spotifyAlbum.id)),
) )
.onConflictDoNothing(); .onConflictDoNothing();
if (spotifyAlbum.genres?.length > 0) if (spotifyAlbum.genres?.length > 0)
await dbClient await dbClient
.insert(albumGenre) .insert(albumGenre)
.select( .select(
dbClient dbClient
.select({ .select({
albumId: album.id, albumId: album.id,
genreId: genre.id, genreId: genre.id,
}) })
.from(genre) .from(genre)
.where(inArray(genre.name, sql`${spotifyAlbum.genres}`)) .where(inArray(genre.name, sql`${spotifyAlbum.genres}`))
.innerJoin(album, eq(album.platform_id, spotifyAlbum.id)), .innerJoin(album, eq(album.platform_id, spotifyAlbum.id)),
) )
.onConflictDoNothing(); .onConflictDoNothing();
} }
} }
export async function upsertTracks(tracks: Track[], dbClient: DbLike = db) { export async function upsertTracks(tracks: Track[], dbClient: DbLike = db) {
if (tracks.length === 0) return; if (tracks.length === 0) return;
await upsertAlbums( await upsertAlbums(
tracks.map((t) => t.album), tracks.map((t) => t.album),
dbClient, dbClient,
); );
await upsertMissingArtists( await upsertMissingArtists(
tracks.flatMap((t) => t.artists), tracks.flatMap((t) => t.artists),
dbClient, dbClient,
); );
const albumIdMap = await getAlbumIdMap( const albumIdMap = await getAlbumIdMap(
tracks.map((t) => t.album.id), tracks.map((t) => t.album.id),
dbClient, dbClient,
); );
await dbClient await dbClient
.insert(track) .insert(track)
.values( .values(
tracks.map((spotifyTrack) => ({ tracks.map((spotifyTrack) => ({
albumId: requireMapEntry(albumIdMap, spotifyTrack.album.id, "albumId"), albumId: albumIdMap.get(spotifyTrack.album.id)!,
name: spotifyTrack.name, name: spotifyTrack.name,
platform: PLATFORM_SPOTIFY, platform: PLATFORM_SPOTIFY,
platform_id: spotifyTrack.id, platform_id: spotifyTrack.id,
popularity: spotifyTrack.popularity, popularity: spotifyTrack.popularity,
duration: spotifyTrack.duration_ms, duration: spotifyTrack.duration_ms,
explicit: spotifyTrack.explicit, explicit: spotifyTrack.explicit,
disc_number: spotifyTrack.disc_number, disc_number: spotifyTrack.disc_number,
track_number: spotifyTrack.track_number, track_number: spotifyTrack.track_number,
})), })),
) )
.onConflictDoNothing(); .onConflictDoNothing();
for (const spotifyTrack of tracks) { for (const spotifyTrack of tracks) {
await dbClient await dbClient
.insert(trackArtist) .insert(trackArtist)
.select( .select(
dbClient dbClient
.select({ .select({
trackId: track.id, trackId: track.id,
artistId: artist.id, artistId: artist.id,
}) })
.from(artist) .from(artist)
.where( .where(
inArray( inArray(
artist.platform_id, artist.platform_id,
spotifyTrack.artists.map((t) => t.id), spotifyTrack.artists.map((t) => t.id),
), ),
) )
.innerJoin(track, eq(track.platform_id, spotifyTrack.id)), .innerJoin(track, eq(track.platform_id, spotifyTrack.id)),
) )
.onConflictDoNothing(); .onConflictDoNothing();
} }
} }
export async function upsertTopArtists( export async function upsertTopArtists(
userId: string, userId: string,
timeline: "short_term" | "medium_term" | "long_term", timeline: "short_term" | "medium_term" | "long_term",
artists: Artist[], artists: Artist[],
dbClient: DbLike = db, dbClient: DbLike = db,
) { ) {
if (artists.length === 0) return; if (artists.length === 0) return;
await upsertArtists(artists, dbClient); await upsertArtists(artists, dbClient);
const artistIdMap = await getArtistIdMap( const artistIdMap = await getArtistIdMap(
artists.map((t) => t.id), artists.map((t) => t.id),
dbClient, dbClient,
); );
await dbClient await dbClient
.insert(topArtist) .insert(topArtist)
.values( .values(
artists.map((spotifyArtist, index) => ({ artists.map((spotifyArtist, index) => ({
artistId: requireMapEntry(artistIdMap, spotifyArtist.id, "artistId"), artistId: artistIdMap.get(spotifyArtist.id)!,
position: index + 1, position: index + 1,
userId, userId,
timeline, timeline,
})), })),
) )
.onConflictDoNothing(); .onConflictDoNothing();
} }
export async function upsertTopTracks( export async function upsertTopTracks(
userId: string, userId: string,
timeline: "short_term" | "medium_term" | "long_term", timeline: "short_term" | "medium_term" | "long_term",
tracks: Track[], tracks: Track[],
dbClient: DbLike = db, dbClient: DbLike = db,
) { ) {
if (tracks.length === 0) return; if (tracks.length === 0) return;
await upsertTracks(tracks, dbClient); await upsertTracks(tracks, dbClient);
const trackIdMap = await getTrackIdMap( const trackIdMap = await getTrackIdMap(
tracks.map((t) => t.id), tracks.map((t) => t.id),
dbClient, dbClient,
); );
await dbClient await dbClient
.insert(topTrack) .insert(topTrack)
.values( .values(
tracks.map((spotifyTrack, index) => ({ tracks.map((spotifyTrack, index) => ({
trackId: requireMapEntry(trackIdMap, spotifyTrack.id, "trackId"), trackId: trackIdMap.get(spotifyTrack.id)!,
position: index + 1, position: index + 1,
userId, userId,
timeline, timeline,
})), })),
) )
.onConflictDoNothing(); .onConflictDoNothing();
} }
export async function upsertSavedAlbums( export async function upsertSavedAlbums(
userId: string, userId: string,
saved: SavedAlbum[], saved: SavedAlbum[],
dbClient: DbLike = db, dbClient: DbLike = db,
) { ) {
if (saved.length === 0) return; if (saved.length === 0) return;
const albums = saved.map((item) => item.album); const albums = saved.map((item) => item.album);
await upsertAlbums(albums, dbClient); await upsertAlbums(albums, dbClient);
const albumIdMap = await getAlbumIdMap( const albumIdMap = await getAlbumIdMap(
albums.map((t) => t.id), albums.map((t) => t.id),
dbClient, dbClient,
); );
await dbClient await dbClient
.insert(savedAlbum) .insert(savedAlbum)
.values( .values(
saved.map((item) => ({ saved.map((item) => ({
albumId: requireMapEntry(albumIdMap, item.album.id, "albumId"), albumId: albumIdMap.get(item.album.id)!,
userId, userId,
saved_at: new Date(item.added_at), saved_at: new Date(item.added_at),
})), })),
) )
.onConflictDoNothing(); .onConflictDoNothing();
} }
export async function upsertSavedTracks( export async function upsertSavedTracks(
userId: string, userId: string,
saved: SavedTrack[], saved: SavedTrack[],
dbClient: DbLike = db, dbClient: DbLike = db,
) { ) {
if (saved.length === 0) return; if (saved.length === 0) return;
const tracks = saved.map((item) => item.track); const tracks = saved.map((item) => item.track);
await upsertTracks(tracks, dbClient); await upsertTracks(tracks, dbClient);
const trackIdMap = await getTrackIdMap( const trackIdMap = await getTrackIdMap(
tracks.map((t) => t.id), tracks.map((t) => t.id),
dbClient, dbClient,
); );
await dbClient await dbClient
.insert(savedTrack) .insert(savedTrack)
.values( .values(
saved.map((item) => ({ saved.map((item) => ({
trackId: requireMapEntry(trackIdMap, item.track.id, "trackId"), trackId: trackIdMap.get(item.track.id)!,
userId, userId,
saved_at: new Date(item.added_at), saved_at: new Date(item.added_at),
})), })),
) )
.onConflictDoNothing(); .onConflictDoNothing();
} }
export async function upsertFollowedArtists( export async function upsertFollowedArtists(
userId: string, userId: string,
artists: Artist[], artists: Artist[],
dbClient: DbLike = db, dbClient: DbLike = db,
) { ) {
if (artists.length === 0) return; if (artists.length === 0) return;
await upsertArtists(artists, dbClient); await upsertArtists(artists, dbClient);
const artistIdMap = await getArtistIdMap( const artistIdMap = await getArtistIdMap(
artists.map((t) => t.id), artists.map((t) => t.id),
dbClient, dbClient,
); );
await dbClient await dbClient
.insert(followedArtist) .insert(followedArtist)
.values( .values(
artists.map((spotifyArtist) => ({ artists.map((spotifyArtist) => ({
artistId: requireMapEntry(artistIdMap, spotifyArtist.id, "artistId"), artistId: artistIdMap.get(spotifyArtist.id)!,
userId, userId,
})), })),
) )
.onConflictDoNothing(); .onConflictDoNothing();
} }
export async function upsertPlaybackHistory( export async function upsertPlaybackHistory(
userId: string, userId: string,
items: PlayHistory[], items: PlayHistory[],
dbClient: DbLike = db, dbClient: DbLike = db,
) { ) {
if (items.length === 0) return; if (items.length === 0) return;
const tracks = items.map((item) => item.track); const tracks = items.map((item) => item.track);
await upsertTracks(tracks, dbClient); await upsertTracks(tracks, dbClient);
const trackIdMap = await getTrackIdMap( const trackIdMap = await getTrackIdMap(
tracks.map((t) => t.id), tracks.map((t) => t.id),
dbClient, dbClient,
); );
await dbClient await dbClient
.insert(playbackHistory) .insert(playbackHistory)
.values( .values(
items.map((item) => ({ items.map((item) => ({
trackId: requireMapEntry(trackIdMap, item.track.id, "trackId"), trackId: trackIdMap.get(item.track.id)!,
userId, userId,
played_at: new Date(item.played_at), played_at: new Date(item.played_at),
})), })),
) )
.onConflictDoNothing(); .onConflictDoNothing();
} }

4
api/src/dbos.ts
View file

@ -2,6 +2,6 @@ import { DBOS } from "@dbos-inc/dbos-sdk";
import "./workflows/sync"; import "./workflows/sync";
DBOS.setConfig({ DBOS.setConfig({
name: "itpdp", name: "itpdp",
systemDatabaseUrl: process.env.DATABASE_URL, systemDatabaseUrl: process.env.DATABASE_URL,
}); });

17
api/src/index.ts
View file

@ -1,22 +1,19 @@
import { DBOS } from "@dbos-inc/dbos-sdk"; import { Elysia, t } from "elysia";
import { Elysia } from "elysia";
import { betterAuthElysia } from "./auth"; import { betterAuthElysia } from "./auth";
import { syncApp } from "./routes/sync"; import { syncApp } from "./routes/sync";
import { DBOS } from "@dbos-inc/dbos-sdk";
import "./workflows/sync"; import "./workflows/sync";
import "./dbos.ts"; import "./dbos.ts";
import { partyApp } from "./routes/party";
import { partySocketApp } from "./routes/party-socket";
import { statsApp } from "./routes/stats.ts"; import { statsApp } from "./routes/stats.ts";
import { partyApp } from "./routes/party";
const app = new Elysia() const app = new Elysia()
.use(betterAuthElysia) .use(betterAuthElysia)
.group("/api", (app) => .group("/api", (app) => app.use(syncApp).use(statsApp).use(partyApp))
app.use(syncApp).use(statsApp).use(partyApp).use(partySocketApp), .listen(4000);
)
.listen(4000);
export type App = typeof app; export type App = typeof app;
await DBOS.launch({ await DBOS.launch({
conductorKey: process.env.DBOS_CONDUCTOR_KEY, conductorKey: process.env.DBOS_CONDUCTOR_KEY,
}); });

106
api/src/party-data.ts
View file

@ -1,106 +0,0 @@
import { eq } from "drizzle-orm";
import { db } from "./db";
import { party, partyMember } from "./db/schema";
type DbClient = typeof db;
type DbTransaction = Parameters<typeof db.transaction>[0] extends (
tx: infer T,
) => Promise<unknown>
? T
: never;
export type DbLike = DbClient | DbTransaction;
export async function getPartyForUser(userId: string) {
const memberships = await db.query.partyMember.findMany({
where: {
userId,
},
with: {
party: true,
},
limit: 1,
});
return memberships[0]?.party ?? null;
}
export async function getMemberRecord(dbClient: DbLike, userId: string) {
return (
(await dbClient.query.partyMember.findFirst({
where: {
userId,
},
})) ?? null
);
}
export async function getPartyStatus(partyId: string) {
const partyRecord = await db.query.party.findFirst({
where: {
id: partyId,
},
});
if (!partyRecord) return null;
const members = await db.query.partyMember.findMany({
where: {
partyId,
},
with: {
user: true,
},
orderBy: {
joinedAt: "asc",
},
});
return {
party: partyRecord,
members,
};
}
export async function cleanupPartyIfEmpty(dbClient: DbLike, partyId: string) {
const members = await dbClient.query.partyMember.findMany({
where: {
partyId,
},
limit: 1,
});
if (members.length > 0) return;
await dbClient.delete(party).where(eq(party.id, partyId));
}
export async function leaveParty(dbClient: DbLike, userId: string) {
const member = await getMemberRecord(dbClient, userId);
if (!member) return null;
await dbClient.delete(partyMember).where(eq(partyMember.id, member.id));
const nextHost = await dbClient.query.partyMember.findFirst({
where: {
partyId: member.partyId,
},
orderBy: {
joinedAt: "asc",
},
});
let newHostId: string | null = null;
if (nextHost) {
const currentParty = await dbClient.query.party.findFirst({
where: {
id: member.partyId,
},
});
if (currentParty?.hostId === userId) {
await dbClient
.update(party)
.set({
hostId: nextHost.userId,
lastUpdated: new Date(),
})
.where(eq(party.id, member.partyId));
newHostId = nextHost.userId;
}
}
await cleanupPartyIfEmpty(dbClient, member.partyId);
return {
partyId: member.partyId,
newHostId,
};
}

159
api/src/party-sockets.ts
View file

@ -1,159 +0,0 @@
type PartySocketEvent = {
type: string;
[key: string]: unknown;
};
type WebSocketLike = {
send: (data: string) => void;
close?: (code?: number, reason?: string) => void;
};
const partySockets = new Map<string, Map<string, Set<WebSocketLike>>>();
const userSockets = new Map<string, Set<WebSocketLike>>();
function getPartyUserSockets(partyId: string, userId: string) {
const partyMap = partySockets.get(partyId);
if (!partyMap) return null;
return partyMap.get(userId) ?? null;
}
export function registerPartySocket(
partyId: string,
userId: string,
ws: WebSocketLike,
) {
let partyMap = partySockets.get(partyId);
if (!partyMap) {
partyMap = new Map();
partySockets.set(partyId, partyMap);
}
let userSockets = partyMap.get(userId);
if (!userSockets) {
userSockets = new Set();
partyMap.set(userId, userSockets);
}
userSockets.add(ws);
}
export function unregisterPartySocket(
partyId: string,
userId: string,
ws: WebSocketLike,
) {
const partyMap = partySockets.get(partyId);
if (!partyMap) return;
const userSockets = partyMap.get(userId);
if (!userSockets) return;
userSockets.delete(ws);
if (userSockets.size === 0) {
partyMap.delete(userId);
}
if (partyMap.size === 0) {
partySockets.delete(partyId);
}
}
export function registerUserSocket(userId: string, ws: WebSocketLike) {
let sockets = userSockets.get(userId);
if (!sockets) {
sockets = new Set();
userSockets.set(userId, sockets);
}
sockets.add(ws);
}
export function unregisterUserSocket(userId: string, ws: WebSocketLike) {
const sockets = userSockets.get(userId);
if (!sockets) return;
sockets.delete(ws);
if (sockets.size === 0) {
userSockets.delete(userId);
}
}
export function unregisterUserSocketFromAllParties(
userId: string,
ws: WebSocketLike,
) {
for (const [partyId, partyMap] of partySockets) {
const userSockets = partyMap.get(userId);
if (!userSockets) continue;
userSockets.delete(ws);
if (userSockets.size === 0) {
partyMap.delete(userId);
}
if (partyMap.size === 0) {
partySockets.delete(partyId);
}
}
}
export function broadcastPartyEvent(partyId: string, event: PartySocketEvent) {
const partyMap = partySockets.get(partyId);
if (!partyMap) return;
const payload = JSON.stringify(event);
for (const userSockets of partyMap.values()) {
for (const ws of userSockets) {
ws.send(payload);
}
}
}
export function sendPartyEventToUser(
partyId: string,
userId: string,
event: PartySocketEvent,
) {
const userSockets = getPartyUserSockets(partyId, userId);
if (!userSockets) return;
const payload = JSON.stringify(event);
for (const ws of userSockets) {
ws.send(payload);
}
}
export function sendDirectEventToUser(userId: string, event: PartySocketEvent) {
const sockets = userSockets.get(userId);
if (!sockets) return;
const payload = JSON.stringify(event);
for (const ws of sockets) {
ws.send(payload);
}
}
export function reassignUserSocketsToParty(
userId: string,
partyId: string | null,
) {
for (const [existingPartyId, partyMap] of partySockets) {
if (!partyMap.has(userId)) continue;
partyMap.delete(userId);
if (partyMap.size === 0) {
partySockets.delete(existingPartyId);
}
}
if (!partyId) return;
const sockets = userSockets.get(userId);
if (!sockets) return;
let partyMap = partySockets.get(partyId);
if (!partyMap) {
partyMap = new Map();
partySockets.set(partyId, partyMap);
}
partyMap.set(userId, new Set(sockets));
}

137
api/src/routes/party-socket.ts
View file

@ -1,137 +0,0 @@
import Elysia, { t } from "elysia";
import { auth, betterAuthElysia } from "../auth";
import { db } from "../db";
import { getMemberRecord, getPartyStatus } from "../party-data";
import {
registerPartySocket,
registerUserSocket,
sendPartyEventToUser,
unregisterPartySocket,
unregisterUserSocket,
unregisterUserSocketFromAllParties,
} from "../party-sockets";
type PartySocketMessage =
| {
type: "member_payload";
payload: unknown;
}
| {
type: "ping";
};
const MAX_MEMBER_PAYLOAD_SIZE = 8_000;
type PartyWsData = {
user?: { id: string };
partyId?: string | null;
};
function getPayloadSize(payload: unknown) {
try {
return JSON.stringify(payload).length;
} catch {
return Infinity;
}
}
export const partySocketApp = new Elysia()
.use(betterAuthElysia)
.group("/party-socket", (app) =>
app.ws("/ws", {
beforeHandle: async ({ request, set }) => {
const session = await auth.api.getSession({
headers: request.headers,
});
if (!session) {
set.status = 401;
return;
}
return {
user: session.user,
session: session.session,
};
},
open: async (ws) => {
const data = ws.data as unknown as PartyWsData;
const user = data.user;
if (!user) return;
registerUserSocket(user.id, ws);
const membership = await getMemberRecord(db, user.id);
if (!membership) {
ws.send(
JSON.stringify({
type: "snapshot",
party: null,
members: [],
}),
);
return;
}
const snapshot = await getPartyStatus(membership.partyId);
data.partyId = membership.partyId;
registerPartySocket(membership.partyId, user.id, ws);
if (snapshot) {
ws.send(
JSON.stringify({
type: "snapshot",
party: snapshot.party,
members: snapshot.members,
}),
);
}
},
message: async (ws, message: PartySocketMessage) => {
const data = ws.data as unknown as PartyWsData;
const user = data.user;
if (!user) return;
if (message.type === "ping") {
ws.send(JSON.stringify({ type: "pong" }));
return;
}
if (message.type !== "member_payload") return;
const membership = await getMemberRecord(db, user.id);
if (!membership) return;
if (getPayloadSize(message.payload) > MAX_MEMBER_PAYLOAD_SIZE) {
ws.send(
JSON.stringify({
type: "error",
message: "Payload too large.",
}),
);
return;
}
const currentParty = await db.query.party.findFirst({
where: { id: membership.partyId },
});
if (!currentParty) return;
sendPartyEventToUser(membership.partyId, currentParty.hostId, {
type: "member_payload",
fromUserId: user.id,
payload: message.payload,
});
},
close: async (ws) => {
const data = ws.data as unknown as PartyWsData;
const user = data.user;
const { partyId } = data;
if (!user) return;
if (!partyId) {
unregisterUserSocketFromAllParties(user.id, ws);
unregisterUserSocket(user.id, ws);
return;
}
unregisterPartySocket(partyId, user.id, ws);
unregisterUserSocket(user.id, ws);
},
body: t.Union([
t.Object({ type: t.Literal("ping") }),
t.Object({ type: t.Literal("member_payload"), payload: t.Any() }),
]),
}),
);

542
api/src/routes/party.ts
View file

@ -1,300 +1,298 @@
import { and, eq } from "drizzle-orm";
import Elysia, { t } from "elysia"; import Elysia, { t } from "elysia";
import { and, eq } from "drizzle-orm";
import { betterAuthElysia } from "../auth"; import { betterAuthElysia } from "../auth";
import { db } from "../db"; import { db } from "../db";
import { party, partyMember } from "../db/schema"; import { party, partyMember } from "../db/schema";
import {
cleanupPartyIfEmpty,
getMemberRecord,
getPartyForUser,
getPartyStatus,
leaveParty,
} from "../party-data";
import {
broadcastPartyEvent,
reassignUserSocketsToParty,
sendDirectEventToUser,
} from "../party-sockets";
const PARTY_STATUS = ["created", "started", "ended"] as const; const PARTY_STATUS = ["created", "started", "ended"] as const;
type PartyStatus = (typeof PARTY_STATUS)[number]; type PartyStatus = (typeof PARTY_STATUS)[number];
type PartySnapshot = NonNullable<Awaited<ReturnType<typeof getPartyStatus>>>; type DbClient = typeof db;
type DbTransaction = Parameters<typeof db.transaction>[0] extends (
tx: infer T,
) => Promise<any>
? T
: never;
type DbLike = DbClient | DbTransaction;
function broadcastSnapshot(partyId: string, snapshot: PartySnapshot | null) { async function getPartyForUser(userId: string) {
if (!snapshot) return; const memberships = await db.query.partyMember.findMany({
broadcastPartyEvent(partyId, { where: {
type: "party_status", userId,
party: snapshot.party, },
members: snapshot.members, with: {
}); party: true,
},
limit: 1,
});
return memberships[0]?.party ?? null;
}
async function getMemberRecord(dbClient: DbLike, userId: string) {
return (
(await dbClient.query.partyMember.findFirst({
where: {
userId,
},
})) ?? null
);
}
async function getPartyStatus(partyId: string) {
const party = await db.query.party.findFirst({
where: {
id: partyId,
},
});
if (!party) return null;
const members = await db.query.partyMember.findMany({
where: {
partyId,
},
with: {
user: true,
},
orderBy: {
joinedAt: "asc",
},
});
return {
party,
members,
};
}
async function cleanupPartyIfEmpty(dbClient: DbLike, partyId: string) {
const members = await dbClient.query.partyMember.findMany({
where: {
partyId,
},
limit: 1,
});
if (members.length > 0) return;
await dbClient.delete(party).where(eq(party.id, partyId));
}
async function leaveParty(dbClient: DbLike, userId: string) {
const member = await getMemberRecord(dbClient, userId);
if (!member) return null;
await dbClient.delete(partyMember).where(eq(partyMember.id, member.id));
const nextHost = await dbClient.query.partyMember.findFirst({
where: {
partyId: member.partyId,
},
orderBy: {
joinedAt: "asc",
},
});
if (nextHost) {
const currentParty = await dbClient.query.party.findFirst({
where: {
id: member.partyId,
},
});
if (currentParty?.hostId === userId) {
await dbClient
.update(party)
.set({
hostId: nextHost.userId,
lastUpdated: new Date(),
})
.where(eq(party.id, member.partyId));
}
}
await cleanupPartyIfEmpty(dbClient, member.partyId);
return member.partyId;
} }
function isValidStatus(status: string): status is PartyStatus { function isValidStatus(status: string): status is PartyStatus {
return PARTY_STATUS.includes(status as PartyStatus); return PARTY_STATUS.includes(status as PartyStatus);
} }
export const partyApp = new Elysia() export const partyApp = new Elysia()
.use(betterAuthElysia) .use(betterAuthElysia)
.group("/party", (app) => .group("/party", (app) =>
app app
.get( .get(
"/status", "/status",
async ({ user }) => { async ({ user }) => {
const currentParty = await getPartyForUser(user.id); const currentParty = await getPartyForUser(user.id);
if (!currentParty) return { party: null, members: [] }; if (!currentParty) return { party: null, members: [] };
const status = await getPartyStatus(currentParty.id); const status = await getPartyStatus(currentParty.id);
return status ?? { party: null, members: [] }; return status ?? { party: null, members: [] };
}, },
{ auth: true }, { auth: true },
) )
.post( .post(
"/join", "/join",
async ({ user, body, set }) => { async ({ user, body, set }) => {
const targetUserId = body.targetUserId; const targetUserId = body.targetUserId;
const targetUser = await db.query.user.findFirst({ const targetUser = await db.query.user.findFirst({
where: { where: {
id: targetUserId, id: targetUserId,
}, },
}); });
if (!targetUser) { if (!targetUser) {
set.status = 404; set.status = 404;
return { error: "Target user not found." }; return { error: "Target user not found." };
} }
const { partyId, hostChanged, leaveResult } = await db.transaction( let partyId: string | null = null;
async (tx) => { await db.transaction(async (tx) => {
const leaveResult = await leaveParty(tx, user.id); await leaveParty(tx, user.id);
let partyId: string | null = null;
let hostChanged = false;
const targetMembership = await getMemberRecord(tx, targetUserId); const targetMembership = await getMemberRecord(tx, targetUserId);
if (targetMembership) { if (targetMembership) {
partyId = targetMembership.partyId; partyId = targetMembership.partyId;
await tx await tx
.update(party) .update(party)
.set({ .set({
hostId: targetUserId, hostId: targetUserId,
lastUpdated: new Date(), lastUpdated: new Date(),
}) })
.where(eq(party.id, partyId)); .where(eq(party.id, partyId));
hostChanged = true; } else {
} else { const created = await tx
const created = await tx .insert(party)
.insert(party) .values({
.values({ status: "created",
status: "created", hostId: targetUserId,
hostId: targetUserId, })
}) .returning({ id: party.id });
.returning({ id: party.id }); partyId = created[0]!.id;
const createdId = created[0]?.id ?? null; await tx.insert(partyMember).values({
if (!createdId) { partyId,
return { userId: targetUserId,
partyId: null, });
hostChanged, }
leaveResult,
};
}
partyId = createdId;
await tx.insert(partyMember).values({
partyId,
userId: targetUserId,
});
}
if (!partyId) { await tx
return { .insert(partyMember)
partyId: null, .values({ partyId, userId: user.id })
hostChanged, .onConflictDoNothing();
leaveResult, });
};
}
await tx if (!partyId) return { party: null, members: [] };
.insert(partyMember) const status = await getPartyStatus(partyId);
.values({ partyId, userId: user.id }) return status ?? { party: null, members: [] };
.onConflictDoNothing(); },
{
auth: true,
body: t.Object({
targetUserId: t.String(),
}),
},
)
.post(
"/leave",
async ({ user }) => {
const partyId = await db.transaction(async (tx) => {
return await leaveParty(tx, user.id);
});
if (!partyId) return { party: null, members: [] };
const status = await getPartyStatus(partyId);
return status ?? { party: null, members: [] };
},
{ auth: true },
)
.post(
"/kick",
async ({ user, body, set }) => {
const currentMembership = await getMemberRecord(db, user.id);
if (!currentMembership) {
set.status = 400;
return { error: "You are not in a party." };
}
return { const currentParty = await db.query.party.findFirst({
partyId, where: {
hostChanged, id: currentMembership.partyId,
leaveResult, },
}; });
}, if (!currentParty || currentParty.hostId !== user.id) {
); set.status = 403;
return { error: "Only the host can kick members." };
}
if (!partyId) return { party: null, members: [] }; if (body.memberUserId === user.id) {
const status = await getPartyStatus(partyId); set.status = 400;
if (leaveResult?.newHostId) { return { error: "Host cannot kick themselves." };
broadcastPartyEvent(leaveResult.partyId, { }
type: "host_changed",
hostId: leaveResult.newHostId,
});
}
if (hostChanged) {
broadcastPartyEvent(partyId, {
type: "host_changed",
hostId: targetUserId,
});
}
broadcastPartyEvent(partyId, {
type: "member_joined",
userId: user.id,
});
broadcastSnapshot(partyId, status);
reassignUserSocketsToParty(user.id, partyId);
reassignUserSocketsToParty(targetUserId, partyId);
if (status) {
sendDirectEventToUser(targetUserId, {
type: "party_status",
party: status.party,
members: status.members,
});
sendDirectEventToUser(user.id, {
type: "party_status",
party: status.party,
members: status.members,
});
}
return status ?? { party: null, members: [] };
},
{
auth: true,
body: t.Object({
targetUserId: t.String(),
}),
},
)
.post(
"/leave",
async ({ user }) => {
const result = await db.transaction(async (tx) => {
return await leaveParty(tx, user.id);
});
if (!result) return { party: null, members: [] };
const status = await getPartyStatus(result.partyId);
broadcastPartyEvent(result.partyId, {
type: "member_left",
userId: user.id,
});
if (result.newHostId) {
broadcastPartyEvent(result.partyId, {
type: "host_changed",
hostId: result.newHostId,
});
}
broadcastSnapshot(result.partyId, status);
reassignUserSocketsToParty(user.id, null);
return status ?? { party: null, members: [] };
},
{ auth: true },
)
.post(
"/kick",
async ({ user, body, set }) => {
const currentMembership = await getMemberRecord(db, user.id);
if (!currentMembership) {
set.status = 400;
return { error: "You are not in a party." };
}
const currentParty = await db.query.party.findFirst({ await db.transaction(async (tx) => {
where: { await tx
id: currentMembership.partyId, .delete(partyMember)
}, .where(
}); and(
if (!currentParty || currentParty.hostId !== user.id) { eq(partyMember.partyId, currentMembership.partyId),
set.status = 403; eq(partyMember.userId, body.memberUserId),
return { error: "Only the host can kick members." }; ),
} );
await cleanupPartyIfEmpty(tx, currentMembership.partyId);
});
const status = await getPartyStatus(currentMembership.partyId);
return status ?? { party: null, members: [] };
},
{
auth: true,
body: t.Object({
memberUserId: t.String(),
}),
},
)
.post(
"/status",
async ({ user, body, set }) => {
const currentMembership = await getMemberRecord(db, user.id);
if (!currentMembership) {
set.status = 400;
return { error: "You are not in a party." };
}
if (body.memberUserId === user.id) { const currentParty = await db.query.party.findFirst({
set.status = 400; where: {
return { error: "Host cannot kick themselves." }; id: currentMembership.partyId,
} },
});
if (!currentParty || currentParty.hostId !== user.id) {
set.status = 403;
return { error: "Only the host can update party status." };
}
await db.transaction(async (tx) => { if (!isValidStatus(body.status)) {
await tx set.status = 400;
.delete(partyMember) return { error: "Invalid party status." };
.where( }
and(
eq(partyMember.partyId, currentMembership.partyId),
eq(partyMember.userId, body.memberUserId),
),
);
await cleanupPartyIfEmpty(tx, currentMembership.partyId);
});
const status = await getPartyStatus(currentMembership.partyId);
broadcastPartyEvent(currentMembership.partyId, {
type: "member_left",
userId: body.memberUserId,
kickedBy: user.id,
});
broadcastSnapshot(currentMembership.partyId, status);
reassignUserSocketsToParty(body.memberUserId, null);
return status ?? { party: null, members: [] };
},
{
auth: true,
body: t.Object({
memberUserId: t.String(),
}),
},
)
.post(
"/status",
async ({ user, body, set }) => {
const currentMembership = await getMemberRecord(db, user.id);
if (!currentMembership) {
set.status = 400;
return { error: "You are not in a party." };
}
const currentParty = await db.query.party.findFirst({ const currentData =
where: { currentParty?.data && typeof currentParty.data === "object"
id: currentMembership.partyId, ? currentParty.data
}, : {};
}); const nextData = body.data
if (!currentParty || currentParty.hostId !== user.id) { ? { ...currentData, ...body.data }
set.status = 403; : currentData;
return { error: "Only the host can update party status." };
}
if (!isValidStatus(body.status)) { await db.transaction(async (tx) => {
set.status = 400; await tx
return { error: "Invalid party status." }; .update(party)
} .set({
status: body.status,
data: nextData,
lastUpdated: new Date(),
})
.where(eq(party.id, currentMembership.partyId));
});
const currentData = const status = await getPartyStatus(currentMembership.partyId);
currentParty?.data && typeof currentParty.data === "object" return status ?? { party: null, members: [] };
? currentParty.data },
: {}; {
const nextData = body.data auth: true,
? { ...currentData, ...body.data } body: t.Object({
: currentData; status: t.Enum({ created: "created", started: "started" }),
data: t.Optional(t.Any()),
await db.transaction(async (tx) => { }),
await tx },
.update(party) ),
.set({ );
status: body.status,
data: nextData,
lastUpdated: new Date(),
})
.where(eq(party.id, currentMembership.partyId));
});
const status = await getPartyStatus(currentMembership.partyId);
broadcastSnapshot(currentMembership.partyId, status);
return status ?? { party: null, members: [] };
},
{
auth: true,
body: t.Object({
status: t.Enum({ created: "created", started: "started" }),
data: t.Optional(t.Any()),
}),
},
),
);

150
api/src/routes/stats.ts
View file

@ -1,79 +1,79 @@
import { sql } from "drizzle-orm";
import Elysia from "elysia"; import Elysia from "elysia";
import { sql } from "drizzle-orm";
import { betterAuthElysia } from "../auth"; import { betterAuthElysia } from "../auth";
import { db } from "../db"; import { db } from "../db";
import { import {
artistGenre, artistGenre,
genre, genre,
savedTrack, savedTrack,
topTrack, topTrack,
trackArtist, trackArtist,
} from "../db/schema"; } from "../db/schema";
export const statsApp = new Elysia().use(betterAuthElysia).get( export const statsApp = new Elysia().use(betterAuthElysia).get(
"/stats", "/stats",
async ({ user }) => { async ({ user }) => {
const topArtists = await db.query.topArtist.findMany({ const topArtists = await db.query.topArtist.findMany({
limit: 10, limit: 10,
with: { with: {
artist: { artist: {
with: { with: {
genres: true, genres: true,
images: true, images: true,
}, },
}, },
}, },
where: { where: {
userId: user.id, userId: user.id,
}, },
}); });
const topTracks = await db.query.topTrack.findMany({ const topTracks = await db.query.topTrack.findMany({
limit: 10, limit: 10,
with: { with: {
track: { track: {
with: { with: {
album: { album: {
with: { with: {
images: true, images: true,
}, },
}, },
artists: { artists: {
with: { with: {
genres: true, genres: true,
}, },
}, },
}, },
}, },
}, },
where: { where: {
userId: user.id, userId: user.id,
timeline: "medium_term", timeline: "medium_term",
}, },
orderBy: { orderBy: {
position: "desc", position: "desc",
}, },
}); });
const recentTracks = await db.query.playbackHistory.findMany({ const recentTracks = await db.query.playbackHistory.findMany({
limit: 10, limit: 10,
with: { with: {
track: { track: {
with: { with: {
album: { album: {
with: { with: {
images: true, images: true,
}, },
}, },
}, },
}, },
}, },
where: { where: {
userId: user.id, userId: user.id,
}, },
}); });
const topGenresResult = await db.execute<{ const topGenresResult = await db.execute<{
name: string; name: string;
count: number; count: number;
}>(sql` }>(sql`
select ${genre.name} as name, count(*)::int as count select ${genre.name} as name, count(*)::int as count
from ( from (
select distinct ${trackArtist.trackId} as track_id, ${artistGenre.genreId} as genre_id select distinct ${trackArtist.trackId} as track_id, ${artistGenre.genreId} as genre_id
@ -95,10 +95,10 @@ export const statsApp = new Elysia().use(betterAuthElysia).get(
order by count desc order by count desc
limit 10 limit 10
`); `);
const topGenres = topGenresResult.rows; const topGenres = topGenresResult.rows;
return { topArtists, topTracks, recentTracks, topGenres }; return { topArtists, topTracks, recentTracks, topGenres };
}, },
{ {
auth: true, auth: true,
}, },
); );

14
api/src/routes/sync.ts
View file

@ -3,11 +3,11 @@ import { betterAuthElysia } from "../auth";
import { spotifySyncWorkflow } from "../workflows/sync"; import { spotifySyncWorkflow } from "../workflows/sync";
export const syncApp = new Elysia().use(betterAuthElysia).post( export const syncApp = new Elysia().use(betterAuthElysia).post(
"/sync", "/sync",
async ({ user }) => { async ({ user }) => {
return await spotifySyncWorkflow.syncUser(user.id); return await spotifySyncWorkflow.syncUser(user.id);
}, },
{ {
auth: true, auth: true,
}, },
); );

427
api/src/workflows/sync.ts
View file

@ -1,247 +1,246 @@
import { ConfiguredInstance, DBOS } from "@dbos-inc/dbos-sdk"; import { DBOS, ConfiguredInstance } from "@dbos-inc/dbos-sdk";
import type {
Artist,
PlayHistory,
SavedAlbum,
SavedTrack,
Track,
} from "@spotify/web-api-ts-sdk";
import { SpotifyApi } from "@spotify/web-api-ts-sdk"; import { SpotifyApi } from "@spotify/web-api-ts-sdk";
import { eq } from "drizzle-orm"; import type {
Artist,
PlayHistory,
SavedAlbum,
SavedTrack,
Track,
} from "@spotify/web-api-ts-sdk";
import { auth, SPOTIFY_CLIENT_ID } from "../auth"; import { auth, SPOTIFY_CLIENT_ID } from "../auth";
import { db } from "../db"; import { db } from "../db";
import { import {
followedArtist, followedArtist,
savedAlbum, savedAlbum,
savedTrack, savedTrack,
topArtist, topArtist,
topTrack, topTrack,
} from "../db/schema"; } from "../db/schema";
import { import {
upsertFollowedArtists, upsertFollowedArtists,
upsertPlaybackHistory, upsertPlaybackHistory,
upsertSavedAlbums, upsertSavedAlbums,
upsertSavedTracks, upsertSavedTracks,
upsertTopArtists, upsertTopArtists,
upsertTopTracks, upsertTopTracks,
} from "../db/spotify"; } from "../db/spotify";
import { eq } from "drizzle-orm";
const timelines = ["short_term", "medium_term", "long_term"] as const; const timelines = ["short_term", "medium_term", "long_term"] as const;
type Timeline = (typeof timelines)[number]; type Timeline = (typeof timelines)[number];
type SyncPayload = { type SyncPayload = {
topArtistsByTimeline: Record<Timeline, Artist[]>; topArtistsByTimeline: Record<Timeline, Artist[]>;
topTracksByTimeline: Record<Timeline, Track[]>; topTracksByTimeline: Record<Timeline, Track[]>;
followedArtists: Artist[]; followedArtists: Artist[];
savedAlbums: SavedAlbum[]; savedAlbums: SavedAlbum[];
savedTracks: SavedTrack[]; savedTracks: SavedTrack[];
recentlyPlayed: PlayHistory[]; recentlyPlayed: PlayHistory[];
}; };
export class SpotifySyncWorkflow extends ConfiguredInstance { export class SpotifySyncWorkflow extends ConfiguredInstance {
@DBOS.workflow() constructor(name: string) {
async syncUser(userId: string) { super(name);
console.log("Sync start"); }
const data = await this.fetchSpotifyData(userId);
console.log("Sync data fetched");
await this.persistSpotifyData(userId, data);
console.log("Synced");
return { ok: true };
}
private async fetchSpotifyData(userId: string): Promise<SyncPayload> { @DBOS.workflow()
const topArtistsByTimeline = await this.fetchTopArtists(userId); async syncUser(userId: string) {
const topTracksByTimeline = await this.fetchTopTracks(userId); console.log("Sync start");
const followedArtists = await this.fetchFollowedArtists(userId); const data = await this.fetchSpotifyData(userId);
const savedAlbums = await this.fetchSavedAlbums(userId); console.log("Sync data fetched");
const savedTracks = await this.fetchSavedTracks(userId); await this.persistSpotifyData(userId, data);
const recentlyPlayed = await this.fetchRecentlyPlayed(userId); console.log("Synced");
return { return { ok: true };
topArtistsByTimeline, }
topTracksByTimeline,
followedArtists,
savedAlbums,
savedTracks,
recentlyPlayed,
};
}
private async persistSpotifyData(userId: string, data: SyncPayload) { private async fetchSpotifyData(userId: string): Promise<SyncPayload> {
await this.persistTopArtists(userId, data.topArtistsByTimeline); const topArtistsByTimeline = await this.fetchTopArtists(userId);
await this.persistTopTracks(userId, data.topTracksByTimeline); const topTracksByTimeline = await this.fetchTopTracks(userId);
await this.persistFollowedArtists(userId, data.followedArtists); const followedArtists = await this.fetchFollowedArtists(userId);
await this.persistSavedAlbums(userId, data.savedAlbums); const savedAlbums = await this.fetchSavedAlbums(userId);
await this.persistSavedTracks(userId, data.savedTracks); const savedTracks = await this.fetchSavedTracks(userId);
await this.persistPlaybackHistory(userId, data.recentlyPlayed); const recentlyPlayed = await this.fetchRecentlyPlayed(userId);
} return {
topArtistsByTimeline,
topTracksByTimeline,
followedArtists,
savedAlbums,
savedTracks,
recentlyPlayed,
};
}
@DBOS.step() private async persistSpotifyData(userId: string, data: SyncPayload) {
private async persistTopArtists( await this.persistTopArtists(userId, data.topArtistsByTimeline);
userId: string, await this.persistTopTracks(userId, data.topTracksByTimeline);
topArtistsByTimeline: Record<Timeline, Artist[]>, await this.persistFollowedArtists(userId, data.followedArtists);
) { await this.persistSavedAlbums(userId, data.savedAlbums);
await db.transaction(async (tx) => { await this.persistSavedTracks(userId, data.savedTracks);
await tx.delete(topArtist).where(eq(topArtist.userId, userId)); await this.persistPlaybackHistory(userId, data.recentlyPlayed);
for (const timeline of timelines) { }
await upsertTopArtists(
userId,
timeline,
topArtistsByTimeline[timeline],
tx,
);
}
});
}
@DBOS.step() @DBOS.step()
private async persistTopTracks( private async persistTopArtists(
userId: string, userId: string,
topTracksByTimeline: Record<Timeline, Track[]>, topArtistsByTimeline: Record<Timeline, Artist[]>,
) { ) {
await db.transaction(async (tx) => { await db.transaction(async (tx) => {
await tx.delete(topTrack).where(eq(topTrack.userId, userId)); await tx.delete(topArtist).where(eq(topArtist.userId, userId));
for (const timeline of timelines) { for (const timeline of timelines) {
await upsertTopTracks( await upsertTopArtists(
userId, userId,
timeline, timeline,
topTracksByTimeline[timeline], topArtistsByTimeline[timeline],
tx, tx,
); );
} }
}); });
} }
@DBOS.step() @DBOS.step()
private async persistFollowedArtists(userId: string, artists: Artist[]) { private async persistTopTracks(
await db.transaction(async (tx) => { userId: string,
await tx.delete(followedArtist).where(eq(followedArtist.userId, userId)); topTracksByTimeline: Record<Timeline, Track[]>,
await upsertFollowedArtists(userId, artists, tx); ) {
}); await db.transaction(async (tx) => {
} await tx.delete(topTrack).where(eq(topTrack.userId, userId));
for (const timeline of timelines) {
await upsertTopTracks(
userId,
timeline,
topTracksByTimeline[timeline],
tx,
);
}
});
}
@DBOS.step() @DBOS.step()
private async persistSavedAlbums(userId: string, albums: SavedAlbum[]) { private async persistFollowedArtists(userId: string, artists: Artist[]) {
await db.transaction(async (tx) => { await db.transaction(async (tx) => {
await tx.delete(savedAlbum).where(eq(savedAlbum.userId, userId)); await tx.delete(followedArtist).where(eq(followedArtist.userId, userId));
await upsertSavedAlbums(userId, albums, tx); await upsertFollowedArtists(userId, artists, tx);
}); });
} }
@DBOS.step() @DBOS.step()
private async persistSavedTracks(userId: string, tracks: SavedTrack[]) { private async persistSavedAlbums(userId: string, albums: SavedAlbum[]) {
await db.transaction(async (tx) => { await db.transaction(async (tx) => {
await tx.delete(savedTrack).where(eq(savedTrack.userId, userId)); await tx.delete(savedAlbum).where(eq(savedAlbum.userId, userId));
await upsertSavedTracks(userId, tracks, tx); await upsertSavedAlbums(userId, albums, tx);
}); });
} }
@DBOS.step() @DBOS.step()
private async persistPlaybackHistory(userId: string, items: PlayHistory[]) { private async persistSavedTracks(userId: string, tracks: SavedTrack[]) {
await db.transaction(async (tx) => { await db.transaction(async (tx) => {
await upsertPlaybackHistory(userId, items, tx); await tx.delete(savedTrack).where(eq(savedTrack.userId, userId));
}); await upsertSavedTracks(userId, tracks, tx);
} });
}
@DBOS.step() @DBOS.step()
private async fetchTopArtists( private async persistPlaybackHistory(userId: string, items: PlayHistory[]) {
userId: string, await db.transaction(async (tx) => {
): Promise<Record<Timeline, Artist[]>> { await upsertPlaybackHistory(userId, items, tx);
const sdk = await this.createSdk(userId); });
const topArtistsByTimeline = {} as Record<Timeline, Artist[]>; }
for (const timeline of timelines) {
const topArtists = await sdk.currentUser.topItems(
"artists",
timeline,
50,
);
topArtistsByTimeline[timeline] = topArtists.items;
}
return topArtistsByTimeline;
}
@DBOS.step() @DBOS.step()
private async fetchTopTracks( private async fetchTopArtists(
userId: string, userId: string,
): Promise<Record<Timeline, Track[]>> { ): Promise<Record<Timeline, Artist[]>> {
const sdk = await this.createSdk(userId); const sdk = await this.createSdk(userId);
const topTracksByTimeline = {} as Record<Timeline, Track[]>; const topArtistsByTimeline = {} as Record<Timeline, Artist[]>;
for (const timeline of timelines) { for (const timeline of timelines) {
const topTracks = await sdk.currentUser.topItems("tracks", timeline, 50); const topArtists = await sdk.currentUser.topItems(
topTracksByTimeline[timeline] = topTracks.items; "artists",
} timeline,
return topTracksByTimeline; 50,
} );
topArtistsByTimeline[timeline] = topArtists.items;
}
return topArtistsByTimeline;
}
@DBOS.step() @DBOS.step()
private async fetchFollowedArtists(userId: string): Promise<Artist[]> { private async fetchTopTracks(
const sdk = await this.createSdk(userId); userId: string,
const followed: Artist[] = []; ): Promise<Record<Timeline, Track[]>> {
let after: string | undefined; const sdk = await this.createSdk(userId);
while (true) { const topTracksByTimeline = {} as Record<Timeline, Track[]>;
const page = await sdk.currentUser.followedArtists(after, 50); for (const timeline of timelines) {
const artists = page.artists; const topTracks = await sdk.currentUser.topItems("tracks", timeline, 50);
followed.push(...artists.items); topTracksByTimeline[timeline] = topTracks.items;
if (!artists.next || artists.items.length === 0) break; }
const lastArtist = artists.items.at(-1); return topTracksByTimeline;
after = lastArtist?.id; }
}
return followed;
}
@DBOS.step() @DBOS.step()
private async fetchSavedAlbums(userId: string): Promise<SavedAlbum[]> { private async fetchFollowedArtists(userId: string): Promise<Artist[]> {
const sdk = await this.createSdk(userId); const sdk = await this.createSdk(userId);
const saved: SavedAlbum[] = []; const followed: Artist[] = [];
let offset = 0; let after: string | undefined;
while (true) { while (true) {
const page = await sdk.currentUser.albums.savedAlbums(50, offset); const page = await sdk.currentUser.followedArtists(after, 50);
saved.push(...page.items); const artists = page.artists;
offset += page.items.length; followed.push(...artists.items);
if (!page.next || offset >= page.total) break; if (!artists.next || artists.items.length === 0) break;
} after = artists.items[artists.items.length - 1]!.id;
return saved; }
} return followed;
}
@DBOS.step() @DBOS.step()
private async fetchSavedTracks(userId: string): Promise<SavedTrack[]> { private async fetchSavedAlbums(userId: string): Promise<SavedAlbum[]> {
const sdk = await this.createSdk(userId); const sdk = await this.createSdk(userId);
const saved: SavedTrack[] = []; const saved: SavedAlbum[] = [];
let offset = 0; let offset = 0;
while (true) { while (true) {
const page = await sdk.currentUser.tracks.savedTracks(50, offset); const page = await sdk.currentUser.albums.savedAlbums(50, offset);
saved.push(...page.items); saved.push(...page.items);
offset += page.items.length; offset += page.items.length;
if (!page.next || offset >= page.total) break; if (!page.next || offset >= page.total) break;
} }
return saved; return saved;
} }
@DBOS.step() @DBOS.step()
private async fetchRecentlyPlayed(userId: string): Promise<PlayHistory[]> { private async fetchSavedTracks(userId: string): Promise<SavedTrack[]> {
const sdk = await this.createSdk(userId); const sdk = await this.createSdk(userId);
const recentlyPlayed = await sdk.player.getRecentlyPlayedTracks(50); const saved: SavedTrack[] = [];
return recentlyPlayed.items; let offset = 0;
} while (true) {
const page = await sdk.currentUser.tracks.savedTracks(50, offset);
saved.push(...page.items);
offset += page.items.length;
if (!page.next || offset >= page.total) break;
}
return saved;
}
private async createSdk(userId: string) { @DBOS.step()
const accessToken = await auth.api.getAccessToken({ private async fetchRecentlyPlayed(userId: string): Promise<PlayHistory[]> {
body: { const sdk = await this.createSdk(userId);
userId, const recentlyPlayed = await sdk.player.getRecentlyPlayedTracks(50);
providerId: "spotify", return recentlyPlayed.items;
}, }
});
return SpotifyApi.withAccessToken(SPOTIFY_CLIENT_ID, { private async createSdk(userId: string) {
access_token: accessToken.accessToken, const accessToken = await auth.api.getAccessToken({
expires_in: accessToken.accessTokenExpiresAt body: {
? Date.now() - Number(accessToken.accessTokenExpiresAt) userId,
: 0, providerId: "spotify",
expires: accessToken.accessTokenExpiresAt },
? Number(accessToken.accessTokenExpiresAt) });
: 0, return SpotifyApi.withAccessToken(SPOTIFY_CLIENT_ID, {
refresh_token: "", access_token: accessToken.accessToken,
token_type: "", expires_in: Date.now() - Number(accessToken.accessTokenExpiresAt!),
}); expires: Number(accessToken.accessTokenExpiresAt),
} refresh_token: "",
token_type: "",
});
}
} }
export const spotifySyncWorkflow = new SpotifySyncWorkflow("spotify-sync"); export const spotifySyncWorkflow = new SpotifySyncWorkflow("spotify-sync");

50
api/tsconfig.json
View file

@ -1,30 +1,30 @@
{ {
"compilerOptions": { "compilerOptions": {
// Environment setup & latest features // Environment setup & latest features
"lib": ["ESNext"], "lib": ["ESNext"],
"target": "ESNext", "target": "ESNext",
"module": "Preserve", "module": "Preserve",
"moduleDetection": "force", "moduleDetection": "force",
"jsx": "react-jsx", "jsx": "react-jsx",
"allowJs": true, "allowJs": true,
"experimentalDecorators": true, "experimentalDecorators": true,
// Bundler mode // Bundler mode
"moduleResolution": "bundler", "moduleResolution": "bundler",
"allowImportingTsExtensions": true, "allowImportingTsExtensions": true,
"verbatimModuleSyntax": true, "verbatimModuleSyntax": true,
"noEmit": true, "noEmit": true,
// Best practices // Best practices
"strict": true, "strict": true,
"skipLibCheck": true, "skipLibCheck": true,
"noFallthroughCasesInSwitch": true, "noFallthroughCasesInSwitch": true,
"noUncheckedIndexedAccess": true, "noUncheckedIndexedAccess": true,
"noImplicitOverride": true, "noImplicitOverride": true,
// Some stricter flags (disabled by default) // Some stricter flags (disabled by default)
"noUnusedLocals": false, "noUnusedLocals": false,
"noUnusedParameters": false, "noUnusedParameters": false,
"noPropertyAccessFromIndexSignature": false "noPropertyAccessFromIndexSignature": false,
} },
} }

77
bun.lock
View file

@ -52,7 +52,6 @@
"embla-carousel-react": "^8.6.0", "embla-carousel-react": "^8.6.0",
"lucide-react": "^1.8.0", "lucide-react": "^1.8.0",
"next-themes": "^0.4.6", "next-themes": "^0.4.6",
"qrcode": "^1.5.4",
"react": "^19.2.0", "react": "^19.2.0",
"react-dom": "^19.2.0", "react-dom": "^19.2.0",
"shadcn": "^4.3.0", "shadcn": "^4.3.0",
@ -725,8 +724,6 @@
"callsites": ["callsites@3.1.0", "", {}, "sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ=="], "callsites": ["callsites@3.1.0", "", {}, "sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ=="],
"camelcase": ["camelcase@5.3.1", "", {}, "sha512-L28STB170nwWS63UjtlEOE3dldQApaJXZkOI1uMFfzf3rRuPegHaHesyee+YxQ+W6SvRDQV6UrdOdRiR153wJg=="],
"caniuse-lite": ["caniuse-lite@1.0.30001788", "", {}, "sha512-6q8HFp+lOQtcf7wBK+uEenxymVWkGKkjFpCvw5W25cmMwEDU45p1xQFBQv8JDlMMry7eNxyBaR+qxgmTUZkIRQ=="], "caniuse-lite": ["caniuse-lite@1.0.30001788", "", {}, "sha512-6q8HFp+lOQtcf7wBK+uEenxymVWkGKkjFpCvw5W25cmMwEDU45p1xQFBQv8JDlMMry7eNxyBaR+qxgmTUZkIRQ=="],
"chai": ["chai@5.3.3", "", { "dependencies": { "assertion-error": "^2.0.1", "check-error": "^2.1.1", "deep-eql": "^5.0.1", "loupe": "^3.1.0", "pathval": "^2.0.0" } }, "sha512-4zNhdJD/iOjSH0A05ea+Ke6MU5mmpQcbQsSOkgdaUMJ9zTlDTD/GYlwohmIE2u0gaxHYiVHEn1Fw9mZ/ktJWgw=="], "chai": ["chai@5.3.3", "", { "dependencies": { "assertion-error": "^2.0.1", "check-error": "^2.1.1", "deep-eql": "^5.0.1", "loupe": "^3.1.0", "pathval": "^2.0.0" } }, "sha512-4zNhdJD/iOjSH0A05ea+Ke6MU5mmpQcbQsSOkgdaUMJ9zTlDTD/GYlwohmIE2u0gaxHYiVHEn1Fw9mZ/ktJWgw=="],
@ -749,7 +746,7 @@
"cli-width": ["cli-width@4.1.0", "", {}, "sha512-ouuZd4/dm2Sw5Gmqy6bGyNNNe1qt9RpmxveLSO7KcgsTnU7RXfsw+/bukWGo1abgBiMAic068rclZsO4IWmmxQ=="], "cli-width": ["cli-width@4.1.0", "", {}, "sha512-ouuZd4/dm2Sw5Gmqy6bGyNNNe1qt9RpmxveLSO7KcgsTnU7RXfsw+/bukWGo1abgBiMAic068rclZsO4IWmmxQ=="],
"cliui": ["cliui@6.0.0", "", { "dependencies": { "string-width": "^4.2.0", "strip-ansi": "^6.0.0", "wrap-ansi": "^6.2.0" } }, "sha512-t6wbgtoCXvAzst7QgXxJYqPt0usEfbgQdftEPbLL/cvv6HPE5VgvqCuAIDR0NgU52ds6rFwqrgakNLrHEjCbrQ=="], "cliui": ["cliui@8.0.1", "", { "dependencies": { "string-width": "^4.2.0", "strip-ansi": "^6.0.1", "wrap-ansi": "^7.0.0" } }, "sha512-BSeNnyus75C4//NQ9gQt1/csTXyo/8Sb+afLAkzAptFuMsod9HFokGNudZpi/oQV73hnVK+sR+5PVRMd+Dr7YQ=="],
"clsx": ["clsx@2.1.1", "", {}, "sha512-eYm0QWBtUrBWZWG0d386OGAw16Z995PiOVo2B7bjWSbHedGl5e0ZWaq65kOGgUSNesEIDkB9ISbTg/JK9dhCZA=="], "clsx": ["clsx@2.1.1", "", {}, "sha512-eYm0QWBtUrBWZWG0d386OGAw16Z995PiOVo2B7bjWSbHedGl5e0ZWaq65kOGgUSNesEIDkB9ISbTg/JK9dhCZA=="],
@ -803,8 +800,6 @@
"debug": ["debug@4.4.3", "", { "dependencies": { "ms": "^2.1.3" } }, "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA=="], "debug": ["debug@4.4.3", "", { "dependencies": { "ms": "^2.1.3" } }, "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA=="],
"decamelize": ["decamelize@1.2.0", "", {}, "sha512-z2S+W9X73hAUUki+N+9Za2lBlun89zigOyGrsax+KUQ6wKW4ZoWpEYBkGhQjwAjjDCkWxhY0VKEhk8wzY7F5cA=="],
"decimal.js": ["decimal.js@10.6.0", "", {}, "sha512-YpgQiITW3JXGntzdUmyUR1V812Hn8T1YVXhCu+wO3OpS4eU9l4YdD3qjyiKdV6mvV29zapkMeD390UVEf2lkUg=="], "decimal.js": ["decimal.js@10.6.0", "", {}, "sha512-YpgQiITW3JXGntzdUmyUR1V812Hn8T1YVXhCu+wO3OpS4eU9l4YdD3qjyiKdV6mvV29zapkMeD390UVEf2lkUg=="],
"dedent": ["dedent@1.7.2", "", { "peerDependencies": { "babel-plugin-macros": "^3.1.0" }, "optionalPeers": ["babel-plugin-macros"] }, "sha512-WzMx3mW98SN+zn3hgemf4OzdmyNhhhKz5Ay0pUfQiMQ3e1g+xmTJWp/pKdwKVXhdSkAEGIIzqeuWrL3mV/AXbA=="], "dedent": ["dedent@1.7.2", "", { "peerDependencies": { "babel-plugin-macros": "^3.1.0" }, "optionalPeers": ["babel-plugin-macros"] }, "sha512-WzMx3mW98SN+zn3hgemf4OzdmyNhhhKz5Ay0pUfQiMQ3e1g+xmTJWp/pKdwKVXhdSkAEGIIzqeuWrL3mV/AXbA=="],
@ -831,8 +826,6 @@
"diff": ["diff@8.0.4", "", {}, "sha512-DPi0FmjiSU5EvQV0++GFDOJ9ASQUVFh5kD+OzOnYdi7n3Wpm9hWWGfB/O2blfHcMVTL5WkQXSnRiK9makhrcnw=="], "diff": ["diff@8.0.4", "", {}, "sha512-DPi0FmjiSU5EvQV0++GFDOJ9ASQUVFh5kD+OzOnYdi7n3Wpm9hWWGfB/O2blfHcMVTL5WkQXSnRiK9makhrcnw=="],
"dijkstrajs": ["dijkstrajs@1.0.3", "", {}, "sha512-qiSlmBq9+BCdCA/L46dw8Uy93mloxsPSbwnm5yrKn2vMPiy8KyAskTF6zuV/j5BMsmOGZDPs7KjU+mjb670kfA=="],
"dom-accessibility-api": ["dom-accessibility-api@0.5.16", "", {}, "sha512-X7BJ2yElsnOJ30pZF4uIIDfBEVgF4XEBxL9Bxhy6dnrm5hkzqmsWHGTiHqRiITNhMyFLyAiWndIJP7Z1NTteDg=="], "dom-accessibility-api": ["dom-accessibility-api@0.5.16", "", {}, "sha512-X7BJ2yElsnOJ30pZF4uIIDfBEVgF4XEBxL9Bxhy6dnrm5hkzqmsWHGTiHqRiITNhMyFLyAiWndIJP7Z1NTteDg=="],
"dom-serializer": ["dom-serializer@2.0.0", "", { "dependencies": { "domelementtype": "^2.3.0", "domhandler": "^5.0.2", "entities": "^4.2.0" } }, "sha512-wIkAryiqt/nV5EQKqQpo3SToSOV9J0DnbJqwK7Wv/Trc92zIAYZ4FlMu+JPFW1DfGFt81ZTCGgDEabffXeLyJg=="], "dom-serializer": ["dom-serializer@2.0.0", "", { "dependencies": { "domelementtype": "^2.3.0", "domhandler": "^5.0.2", "entities": "^4.2.0" } }, "sha512-wIkAryiqt/nV5EQKqQpo3SToSOV9J0DnbJqwK7Wv/Trc92zIAYZ4FlMu+JPFW1DfGFt81ZTCGgDEabffXeLyJg=="],
@ -865,7 +858,7 @@
"embla-carousel-reactive-utils": ["embla-carousel-reactive-utils@8.6.0", "", { "peerDependencies": { "embla-carousel": "8.6.0" } }, "sha512-fMVUDUEx0/uIEDM0Mz3dHznDhfX+znCCDCeIophYb1QGVM7YThSWX+wz11zlYwWFOr74b4QLGg0hrGPJeG2s4A=="], "embla-carousel-reactive-utils": ["embla-carousel-reactive-utils@8.6.0", "", { "peerDependencies": { "embla-carousel": "8.6.0" } }, "sha512-fMVUDUEx0/uIEDM0Mz3dHznDhfX+znCCDCeIophYb1QGVM7YThSWX+wz11zlYwWFOr74b4QLGg0hrGPJeG2s4A=="],
"emoji-regex": ["emoji-regex@8.0.0", "", {}, "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A=="], "emoji-regex": ["emoji-regex@10.6.0", "", {}, "sha512-toUI84YS5YmxW219erniWD0CIVOo46xGKColeNQRgOzDorgBi1v4D71/OFzgD9GO2UGKIv1C3Sp8DAn0+j5w7A=="],
"encodeurl": ["encodeurl@2.0.0", "", {}, "sha512-Q0n9HRi4m6JuGIV1eFlmvJB7ZEVxu93IrMyiMsGC0lrMJMWzRgx6WGquyfQgZVb31vhGgXnfmPNNXmxnOkRBrg=="], "encodeurl": ["encodeurl@2.0.0", "", {}, "sha512-Q0n9HRi4m6JuGIV1eFlmvJB7ZEVxu93IrMyiMsGC0lrMJMWzRgx6WGquyfQgZVb31vhGgXnfmPNNXmxnOkRBrg=="],
@ -947,8 +940,6 @@
"finalhandler": ["finalhandler@2.1.1", "", { "dependencies": { "debug": "^4.4.0", "encodeurl": "^2.0.0", "escape-html": "^1.0.3", "on-finished": "^2.4.1", "parseurl": "^1.3.3", "statuses": "^2.0.1" } }, "sha512-S8KoZgRZN+a5rNwqTxlZZePjT/4cnm0ROV70LedRHZ0p8u9fRID0hJUZQpkKLzro8LfmC8sx23bY6tVNxv8pQA=="], "finalhandler": ["finalhandler@2.1.1", "", { "dependencies": { "debug": "^4.4.0", "encodeurl": "^2.0.0", "escape-html": "^1.0.3", "on-finished": "^2.4.1", "parseurl": "^1.3.3", "statuses": "^2.0.1" } }, "sha512-S8KoZgRZN+a5rNwqTxlZZePjT/4cnm0ROV70LedRHZ0p8u9fRID0hJUZQpkKLzro8LfmC8sx23bY6tVNxv8pQA=="],
"find-up": ["find-up@4.1.0", "", { "dependencies": { "locate-path": "^5.0.0", "path-exists": "^4.0.0" } }, "sha512-PpOwAdQ/YlXQ2vj8a3h8IipDuYRi3wceVQQGYWxNINccq40Anw7BlsEXCMbt1Zt+OLA6Fq9suIpIWD0OsnISlw=="],
"formdata-polyfill": ["formdata-polyfill@4.0.10", "", { "dependencies": { "fetch-blob": "^3.1.2" } }, "sha512-buewHzMvYL29jdeQTVILecSaZKnt/RJWjoZCF5OW60Z67/GmSLBkOFM7qh1PI3zFNtJbaZL5eQu1vLfazOwj4g=="], "formdata-polyfill": ["formdata-polyfill@4.0.10", "", { "dependencies": { "fetch-blob": "^3.1.2" } }, "sha512-buewHzMvYL29jdeQTVILecSaZKnt/RJWjoZCF5OW60Z67/GmSLBkOFM7qh1PI3zFNtJbaZL5eQu1vLfazOwj4g=="],
"forwarded": ["forwarded@0.2.0", "", {}, "sha512-buRG0fpBtRHSTCOASe6hD258tEubFoRLb4ZNA6NxMVHNw2gOcwHo9wyablzMzOA5z9xA9L1KNjk/Nt6MT9aYow=="], "forwarded": ["forwarded@0.2.0", "", {}, "sha512-buRG0fpBtRHSTCOASe6hD258tEubFoRLb4ZNA6NxMVHNw2gOcwHo9wyablzMzOA5z9xA9L1KNjk/Nt6MT9aYow=="],
@ -1129,8 +1120,6 @@
"lines-and-columns": ["lines-and-columns@1.2.4", "", {}, "sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg=="], "lines-and-columns": ["lines-and-columns@1.2.4", "", {}, "sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg=="],
"locate-path": ["locate-path@5.0.0", "", { "dependencies": { "p-locate": "^4.1.0" } }, "sha512-t7hw9pI+WvuwNJXwk5zVHpyhIqzg2qTlklJOf0mVxGSbe3Fp2VieZcduNYjaLDoy6p9uGpQEGWG87WpMKlNq8g=="],
"log-symbols": ["log-symbols@6.0.0", "", { "dependencies": { "chalk": "^5.3.0", "is-unicode-supported": "^1.3.0" } }, "sha512-i24m8rpwhmPIS4zscNzK6MSEhk0DUWa/8iYQWxhffV8jkI4Phvs3F+quL5xvS0gdQR0FyTCMMH33Y78dDTzzIw=="], "log-symbols": ["log-symbols@6.0.0", "", { "dependencies": { "chalk": "^5.3.0", "is-unicode-supported": "^1.3.0" } }, "sha512-i24m8rpwhmPIS4zscNzK6MSEhk0DUWa/8iYQWxhffV8jkI4Phvs3F+quL5xvS0gdQR0FyTCMMH33Y78dDTzzIw=="],
"loupe": ["loupe@3.2.1", "", {}, "sha512-CdzqowRJCeLU72bHvWqwRBBlLcMEtIvGrlvef74kMnV2AolS9Y8xUv1I0U/MNAWMhBlKIoyuEgoJ0t/bbwHbLQ=="], "loupe": ["loupe@3.2.1", "", {}, "sha512-CdzqowRJCeLU72bHvWqwRBBlLcMEtIvGrlvef74kMnV2AolS9Y8xUv1I0U/MNAWMhBlKIoyuEgoJ0t/bbwHbLQ=="],
@ -1217,12 +1206,6 @@
"outvariant": ["outvariant@1.4.3", "", {}, "sha512-+Sl2UErvtsoajRDKCE5/dBz4DIvHXQQnAxtQTF04OJxY0+DyZXSo5P5Bb7XYWOh81syohlYL24hbDwxedPUJCA=="], "outvariant": ["outvariant@1.4.3", "", {}, "sha512-+Sl2UErvtsoajRDKCE5/dBz4DIvHXQQnAxtQTF04OJxY0+DyZXSo5P5Bb7XYWOh81syohlYL24hbDwxedPUJCA=="],
"p-limit": ["p-limit@2.3.0", "", { "dependencies": { "p-try": "^2.0.0" } }, "sha512-//88mFWSJx8lxCzwdAABTJL2MyWB12+eIY7MDL2SqLmAkeKU9qxRvWuSyTjm3FUmpBEMuFfckAIqEaVGUDxb6w=="],
"p-locate": ["p-locate@4.1.0", "", { "dependencies": { "p-limit": "^2.2.0" } }, "sha512-R79ZZ/0wAxKGu3oYMlz8jy/kbhsNrS7SKZ7PxEHBgJ5+F2mtFW2fK2cOtBh1cHYkQsbzFV7I+EoRKe6Yt0oK7A=="],
"p-try": ["p-try@2.2.0", "", {}, "sha512-R4nPAVTAU0B9D35/Gk3uJf/7XYbQcyohSKdvAxIRSNghFl4e71hVoGnBNQz9cWaXxO2I10KTC+3jMdvvoKw6dQ=="],
"packet-reader": ["packet-reader@1.0.0", "", {}, "sha512-HAKu/fG3HpHFO0AA8WE8q2g+gBJaZ9MG7fcKk+IJPLTGAD6Psw4443l+9DGRbOIh3/aXr7Phy0TjilYivJo5XQ=="], "packet-reader": ["packet-reader@1.0.0", "", {}, "sha512-HAKu/fG3HpHFO0AA8WE8q2g+gBJaZ9MG7fcKk+IJPLTGAD6Psw4443l+9DGRbOIh3/aXr7Phy0TjilYivJo5XQ=="],
"parent-module": ["parent-module@1.0.1", "", { "dependencies": { "callsites": "^3.0.0" } }, "sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g=="], "parent-module": ["parent-module@1.0.1", "", { "dependencies": { "callsites": "^3.0.0" } }, "sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g=="],
@ -1241,8 +1224,6 @@
"path-browserify": ["path-browserify@1.0.1", "", {}, "sha512-b7uo2UCUOYZcnF/3ID0lulOJi/bafxa1xPe7ZPsammBSpjSWQkjNxlt635YGS2MiR9GjvuXCtz2emr3jbsz98g=="], "path-browserify": ["path-browserify@1.0.1", "", {}, "sha512-b7uo2UCUOYZcnF/3ID0lulOJi/bafxa1xPe7ZPsammBSpjSWQkjNxlt635YGS2MiR9GjvuXCtz2emr3jbsz98g=="],
"path-exists": ["path-exists@4.0.0", "", {}, "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w=="],
"path-key": ["path-key@3.1.1", "", {}, "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q=="], "path-key": ["path-key@3.1.1", "", {}, "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q=="],
"path-to-regexp": ["path-to-regexp@6.3.0", "", {}, "sha512-Yhpw4T9C6hPpgPeA28us07OJeqZ5EzQTkbfwuhsUg0c237RomFoETJgmp2sa3F/41gfLE6G5cqcYwznmeEeOlQ=="], "path-to-regexp": ["path-to-regexp@6.3.0", "", {}, "sha512-Yhpw4T9C6hPpgPeA28us07OJeqZ5EzQTkbfwuhsUg0c237RomFoETJgmp2sa3F/41gfLE6G5cqcYwznmeEeOlQ=="],
@ -1275,8 +1256,6 @@
"pkce-challenge": ["pkce-challenge@5.0.1", "", {}, "sha512-wQ0b/W4Fr01qtpHlqSqspcj3EhBvimsdh0KlHhH8HRZnMsEa0ea2fTULOXOS9ccQr3om+GcGRk4e+isrZWV8qQ=="], "pkce-challenge": ["pkce-challenge@5.0.1", "", {}, "sha512-wQ0b/W4Fr01qtpHlqSqspcj3EhBvimsdh0KlHhH8HRZnMsEa0ea2fTULOXOS9ccQr3om+GcGRk4e+isrZWV8qQ=="],
"pngjs": ["pngjs@5.0.0", "", {}, "sha512-40QW5YalBNfQo5yRYmiw7Yz6TKKVr3h6970B2YE+3fQpsWcrbj1PzJgxeJ19DRQjhMbKPIuMY8rFaXc8moolVw=="],
"postcss": ["postcss@8.5.10", "", { "dependencies": { "nanoid": "^3.3.11", "picocolors": "^1.1.1", "source-map-js": "^1.2.1" } }, "sha512-pMMHxBOZKFU6HgAZ4eyGnwXF/EvPGGqUr0MnZ5+99485wwW41kW91A4LOGxSHhgugZmSChL5AlElNdwlNgcnLQ=="], "postcss": ["postcss@8.5.10", "", { "dependencies": { "nanoid": "^3.3.11", "picocolors": "^1.1.1", "source-map-js": "^1.2.1" } }, "sha512-pMMHxBOZKFU6HgAZ4eyGnwXF/EvPGGqUr0MnZ5+99485wwW41kW91A4LOGxSHhgugZmSChL5AlElNdwlNgcnLQ=="],
"postcss-selector-parser": ["postcss-selector-parser@6.0.10", "", { "dependencies": { "cssesc": "^3.0.0", "util-deprecate": "^1.0.2" } }, "sha512-IQ7TZdoaqbT+LCpShg46jnZVlhWD2w6iQYAcYXfHARZ7X1t/UGhhceQDs5X0cGqKvYlHNOuv7Oa1xmb0oQuA3w=="], "postcss-selector-parser": ["postcss-selector-parser@6.0.10", "", { "dependencies": { "cssesc": "^3.0.0", "util-deprecate": "^1.0.2" } }, "sha512-IQ7TZdoaqbT+LCpShg46jnZVlhWD2w6iQYAcYXfHARZ7X1t/UGhhceQDs5X0cGqKvYlHNOuv7Oa1xmb0oQuA3w=="],
@ -1305,8 +1284,6 @@
"punycode": ["punycode@2.3.1", "", {}, "sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg=="], "punycode": ["punycode@2.3.1", "", {}, "sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg=="],
"qrcode": ["qrcode@1.5.4", "", { "dependencies": { "dijkstrajs": "^1.0.1", "pngjs": "^5.0.0", "yargs": "^15.3.1" }, "bin": { "qrcode": "bin/qrcode" } }, "sha512-1ca71Zgiu6ORjHqFBDpnSMTR2ReToX4l1Au1VFLyVeBTFavzQnv5JxMFr3ukHVKpSrSA2MCk0lNJSykjUfz7Zg=="],
"qs": ["qs@6.15.1", "", { "dependencies": { "side-channel": "^1.1.0" } }, "sha512-6YHEFRL9mfgcAvql/XhwTvf5jKcOiiupt2FiJxHkiX1z4j7WL8J/jRHYLluORvc1XxB5rV20KoeK00gVJamspg=="], "qs": ["qs@6.15.1", "", { "dependencies": { "side-channel": "^1.1.0" } }, "sha512-6YHEFRL9mfgcAvql/XhwTvf5jKcOiiupt2FiJxHkiX1z4j7WL8J/jRHYLluORvc1XxB5rV20KoeK00gVJamspg=="],
"queue-microtask": ["queue-microtask@1.2.3", "", {}, "sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A=="], "queue-microtask": ["queue-microtask@1.2.3", "", {}, "sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A=="],
@ -1341,8 +1318,6 @@
"require-from-string": ["require-from-string@2.0.2", "", {}, "sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw=="], "require-from-string": ["require-from-string@2.0.2", "", {}, "sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw=="],
"require-main-filename": ["require-main-filename@2.0.0", "", {}, "sha512-NKN5kMDylKuldxYLSUfrbo5Tuzh4hd+2E8NPPX02mZtn1VuREQToYe/ZdlJy+J3uCpfaiGF05e7B8W0iXbQHmg=="],
"reselect": ["reselect@5.1.1", "", {}, "sha512-K/BG6eIky/SBpzfHZv/dd+9JBFiS4SWV7FIujVyJRux6e45+73RaUHXLmIR1f7WOMaQ0U1km6qwklRQxpJJY0w=="], "reselect": ["reselect@5.1.1", "", {}, "sha512-K/BG6eIky/SBpzfHZv/dd+9JBFiS4SWV7FIujVyJRux6e45+73RaUHXLmIR1f7WOMaQ0U1km6qwklRQxpJJY0w=="],
"resolve-from": ["resolve-from@4.0.0", "", {}, "sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g=="], "resolve-from": ["resolve-from@4.0.0", "", {}, "sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g=="],
@ -1387,8 +1362,6 @@
"serve-static": ["serve-static@2.2.1", "", { "dependencies": { "encodeurl": "^2.0.0", "escape-html": "^1.0.3", "parseurl": "^1.3.3", "send": "^1.2.0" } }, "sha512-xRXBn0pPqQTVQiC8wyQrKs2MOlX24zQ0POGaj0kultvoOCstBQM5yvOhAVSUwOMjQtTvsPWoNCHfPGwaaQJhTw=="], "serve-static": ["serve-static@2.2.1", "", { "dependencies": { "encodeurl": "^2.0.0", "escape-html": "^1.0.3", "parseurl": "^1.3.3", "send": "^1.2.0" } }, "sha512-xRXBn0pPqQTVQiC8wyQrKs2MOlX24zQ0POGaj0kultvoOCstBQM5yvOhAVSUwOMjQtTvsPWoNCHfPGwaaQJhTw=="],
"set-blocking": ["set-blocking@2.0.0", "", {}, "sha512-KiKBS8AnWGEyLzofFfmvKwpdPzqiy16LvQfK3yv/fVH7Bj13/wl3JSR1J+rfgRE9q7xUJK4qvgS8raSOeLUehw=="],
"set-cookie-parser": ["set-cookie-parser@3.1.0", "", {}, "sha512-kjnC1DXBHcxaOaOXBHBeRtltsDG2nUiUni+jP92M9gYdW12rsmx92UsfpH7o5tDRs7I1ZZPSQJQGv3UaRfCiuw=="], "set-cookie-parser": ["set-cookie-parser@3.1.0", "", {}, "sha512-kjnC1DXBHcxaOaOXBHBeRtltsDG2nUiUni+jP92M9gYdW12rsmx92UsfpH7o5tDRs7I1ZZPSQJQGv3UaRfCiuw=="],
"setprototypeof": ["setprototypeof@1.2.0", "", {}, "sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw=="], "setprototypeof": ["setprototypeof@1.2.0", "", {}, "sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw=="],
@ -1437,7 +1410,7 @@
"strict-event-emitter": ["strict-event-emitter@0.5.1", "", {}, "sha512-vMgjE/GGEPEFnhFub6pa4FmJBRBVOLpIII2hvCZ8Kzb7K0hlHo7mQv6xYrBvCL2LtAIBwFUK8wvuJgTVSQ5MFQ=="], "strict-event-emitter": ["strict-event-emitter@0.5.1", "", {}, "sha512-vMgjE/GGEPEFnhFub6pa4FmJBRBVOLpIII2hvCZ8Kzb7K0hlHo7mQv6xYrBvCL2LtAIBwFUK8wvuJgTVSQ5MFQ=="],
"string-width": ["string-width@4.2.3", "", { "dependencies": { "emoji-regex": "^8.0.0", "is-fullwidth-code-point": "^3.0.0", "strip-ansi": "^6.0.1" } }, "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g=="], "string-width": ["string-width@7.2.0", "", { "dependencies": { "emoji-regex": "^10.3.0", "get-east-asian-width": "^1.0.0", "strip-ansi": "^7.1.0" } }, "sha512-tsaTIkKW9b4N+AEj+SVA+WhJzV7/zMhcSu78mLKWSk7cXMOSHsBKFWUs0fWwq8QyK3MgJBQRX6Gbi4kYbdvGkQ=="],
"string_decoder": ["string_decoder@1.3.0", "", { "dependencies": { "safe-buffer": "~5.2.0" } }, "sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA=="], "string_decoder": ["string_decoder@1.3.0", "", { "dependencies": { "safe-buffer": "~5.2.0" } }, "sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA=="],
@ -1569,11 +1542,9 @@
"which": ["which@4.0.0", "", { "dependencies": { "isexe": "^3.1.1" }, "bin": { "node-which": "bin/which.js" } }, "sha512-GlaYyEb07DPxYCKhKzplCWBJtvxZcZMrL+4UkrTSJHHPyZU4mYYTv3qaOe77H7EODLSSopAUFAc6W8U4yqvscg=="], "which": ["which@4.0.0", "", { "dependencies": { "isexe": "^3.1.1" }, "bin": { "node-which": "bin/which.js" } }, "sha512-GlaYyEb07DPxYCKhKzplCWBJtvxZcZMrL+4UkrTSJHHPyZU4mYYTv3qaOe77H7EODLSSopAUFAc6W8U4yqvscg=="],
"which-module": ["which-module@2.0.1", "", {}, "sha512-iBdZ57RDvnOR9AGBhML2vFZf7h8vmBjhoaZqODJBFWHVtKkDmKuHai3cx5PgVMrX5YDNp27AofYbAwctSS+vhQ=="],
"why-is-node-running": ["why-is-node-running@2.3.0", "", { "dependencies": { "siginfo": "^2.0.0", "stackback": "0.0.2" }, "bin": { "why-is-node-running": "cli.js" } }, "sha512-hUrmaWBdVDcxvYqnyh09zunKzROWjbZTiNy8dBEjkS7ehEDQibXJ7XvlmtbwuTclUiIyN+CyXQD4Vmko8fNm8w=="], "why-is-node-running": ["why-is-node-running@2.3.0", "", { "dependencies": { "siginfo": "^2.0.0", "stackback": "0.0.2" }, "bin": { "why-is-node-running": "cli.js" } }, "sha512-hUrmaWBdVDcxvYqnyh09zunKzROWjbZTiNy8dBEjkS7ehEDQibXJ7XvlmtbwuTclUiIyN+CyXQD4Vmko8fNm8w=="],
"wrap-ansi": ["wrap-ansi@6.2.0", "", { "dependencies": { "ansi-styles": "^4.0.0", "string-width": "^4.1.0", "strip-ansi": "^6.0.0" } }, "sha512-r6lPcBGxZXlIcymEu7InxDMhdW0KDxpLgoFLcguasxCaJ/SOIZwINatK9KY/tf+ZrlywOKU0UDj3ATXUBfxJXA=="], "wrap-ansi": ["wrap-ansi@7.0.0", "", { "dependencies": { "ansi-styles": "^4.0.0", "string-width": "^4.1.0", "strip-ansi": "^6.0.0" } }, "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q=="],
"wrappy": ["wrappy@1.0.2", "", {}, "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ=="], "wrappy": ["wrappy@1.0.2", "", {}, "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ=="],
@ -1589,15 +1560,15 @@
"xtend": ["xtend@4.0.2", "", {}, "sha512-LKYU1iAXJXUgAXn9URjiu+MWhyUXHsvfp7mcuYm9dSUKK0/CjtrUwFAxD82/mCWbtLsGjFIad0wIsod4zrTAEQ=="], "xtend": ["xtend@4.0.2", "", {}, "sha512-LKYU1iAXJXUgAXn9URjiu+MWhyUXHsvfp7mcuYm9dSUKK0/CjtrUwFAxD82/mCWbtLsGjFIad0wIsod4zrTAEQ=="],
"y18n": ["y18n@4.0.3", "", {}, "sha512-JKhqTOwSrqNA1NY5lSztJ1GrBiUodLMmIZuLiDaMRJ+itFd+ABVE8XBjOvIWL+rSqNDC74LCSFmlb/U4UZ4hJQ=="], "y18n": ["y18n@5.0.8", "", {}, "sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA=="],
"yallist": ["yallist@3.1.1", "", {}, "sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g=="], "yallist": ["yallist@3.1.1", "", {}, "sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g=="],
"yaml": ["yaml@2.8.3", "", { "bin": { "yaml": "bin.mjs" } }, "sha512-AvbaCLOO2Otw/lW5bmh9d/WEdcDFdQp2Z2ZUH3pX9U2ihyUY0nvLv7J6TrWowklRGPYbB/IuIMfYgxaCPg5Bpg=="], "yaml": ["yaml@2.8.3", "", { "bin": { "yaml": "bin.mjs" } }, "sha512-AvbaCLOO2Otw/lW5bmh9d/WEdcDFdQp2Z2ZUH3pX9U2ihyUY0nvLv7J6TrWowklRGPYbB/IuIMfYgxaCPg5Bpg=="],
"yargs": ["yargs@15.4.1", "", { "dependencies": { "cliui": "^6.0.0", "decamelize": "^1.2.0", "find-up": "^4.1.0", "get-caller-file": "^2.0.1", "require-directory": "^2.1.1", "require-main-filename": "^2.0.0", "set-blocking": "^2.0.0", "string-width": "^4.2.0", "which-module": "^2.0.0", "y18n": "^4.0.0", "yargs-parser": "^18.1.2" } }, "sha512-aePbxDmcYW++PaqBsJ+HYUFwCdv4LVvdnhBy78E57PIor8/OVvhMrADFFEDh8DHDFRv/O9i3lPhsENjO7QX0+A=="], "yargs": ["yargs@17.7.2", "", { "dependencies": { "cliui": "^8.0.1", "escalade": "^3.1.1", "get-caller-file": "^2.0.5", "require-directory": "^2.1.1", "string-width": "^4.2.3", "y18n": "^5.0.5", "yargs-parser": "^21.1.1" } }, "sha512-7dSzzRQ++CKnNI/krKnYRV7JKKPUXMEh61soaHKg9mrWEhzFWhFnxPxGl+69cD1Ou63C13NUPCnmIcrvqCuM6w=="],
"yargs-parser": ["yargs-parser@18.1.3", "", { "dependencies": { "camelcase": "^5.0.0", "decamelize": "^1.2.0" } }, "sha512-o50j0JeToy/4K6OZcaQmW6lyXXKhq7csREXcDwk2omFPJEwUNOVtJKvmDr9EI1fAJZUyZcRF7kxGBWmRXudrCQ=="], "yargs-parser": ["yargs-parser@21.1.1", "", {}, "sha512-tVpsJW7DdjecAiFpbIB1e3qxIQsE6NoPc5/eTdrbbIC4h0LVsWhnoa3g+m2HclBIujHzsxZ4VJVA+GUuc2/LBw=="],
"yocto-spinner": ["yocto-spinner@1.1.0", "", { "dependencies": { "yoctocolors": "^2.1.1" } }, "sha512-/BY0AUXnS7IKO354uLLA2eRcWiqDifEbd6unXCsOxkFDAkhgUL3PH9X2bFoaU0YchnDXsF+iKleeTLJGckbXfA=="], "yocto-spinner": ["yocto-spinner@1.1.0", "", { "dependencies": { "yoctocolors": "^2.1.1" } }, "sha512-/BY0AUXnS7IKO354uLLA2eRcWiqDifEbd6unXCsOxkFDAkhgUL3PH9X2bFoaU0YchnDXsF+iKleeTLJGckbXfA=="],
@ -1655,6 +1626,8 @@
"cheerio/whatwg-mimetype": ["whatwg-mimetype@4.0.0", "", {}, "sha512-QaKxh0eNIi2mE9p2vEdzfagOKHCcj1pJ56EEHGQOVxp8r9/iszLUUV7v89x9O1p/T+NlTM5W7jW6+cz4Fq1YVg=="], "cheerio/whatwg-mimetype": ["whatwg-mimetype@4.0.0", "", {}, "sha512-QaKxh0eNIi2mE9p2vEdzfagOKHCcj1pJ56EEHGQOVxp8r9/iszLUUV7v89x9O1p/T+NlTM5W7jW6+cz4Fq1YVg=="],
"cliui/string-width": ["string-width@4.2.3", "", { "dependencies": { "emoji-regex": "^8.0.0", "is-fullwidth-code-point": "^3.0.0", "strip-ansi": "^6.0.1" } }, "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g=="],
"cliui/strip-ansi": ["strip-ansi@6.0.1", "", { "dependencies": { "ansi-regex": "^5.0.1" } }, "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A=="], "cliui/strip-ansi": ["strip-ansi@6.0.1", "", { "dependencies": { "ansi-regex": "^5.0.1" } }, "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A=="],
"cross-spawn/which": ["which@2.0.2", "", { "dependencies": { "isexe": "^2.0.0" }, "bin": { "node-which": "./bin/node-which" } }, "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA=="], "cross-spawn/which": ["which@2.0.2", "", { "dependencies": { "isexe": "^2.0.0" }, "bin": { "node-which": "./bin/node-which" } }, "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA=="],
@ -1681,12 +1654,8 @@
"msw/type-fest": ["type-fest@5.6.0", "", { "dependencies": { "tagged-tag": "^1.0.0" } }, "sha512-8ZiHFm91orbSAe2PSAiSVBVko18pbhbiB3U9GglSzF/zCGkR+rxpHx6sEMCUm4kxY4LjDIUGgCfUMtwfZfjfUA=="], "msw/type-fest": ["type-fest@5.6.0", "", { "dependencies": { "tagged-tag": "^1.0.0" } }, "sha512-8ZiHFm91orbSAe2PSAiSVBVko18pbhbiB3U9GglSzF/zCGkR+rxpHx6sEMCUm4kxY4LjDIUGgCfUMtwfZfjfUA=="],
"msw/yargs": ["yargs@17.7.2", "", { "dependencies": { "cliui": "^8.0.1", "escalade": "^3.1.1", "get-caller-file": "^2.0.5", "require-directory": "^2.1.1", "string-width": "^4.2.3", "y18n": "^5.0.5", "yargs-parser": "^21.1.1" } }, "sha512-7dSzzRQ++CKnNI/krKnYRV7JKKPUXMEh61soaHKg9mrWEhzFWhFnxPxGl+69cD1Ou63C13NUPCnmIcrvqCuM6w=="],
"npm-run-path/path-key": ["path-key@4.0.0", "", {}, "sha512-haREypq7xkM7ErfgIyA0z+Bj4AGKlMSdlQE2jvJo6huWD1EdkKYV+G/T4nq0YEF2vgTT8kqMFKo1uHn950r4SQ=="], "npm-run-path/path-key": ["path-key@4.0.0", "", {}, "sha512-haREypq7xkM7ErfgIyA0z+Bj4AGKlMSdlQE2jvJo6huWD1EdkKYV+G/T4nq0YEF2vgTT8kqMFKo1uHn950r4SQ=="],
"ora/string-width": ["string-width@7.2.0", "", { "dependencies": { "emoji-regex": "^10.3.0", "get-east-asian-width": "^1.0.0", "strip-ansi": "^7.1.0" } }, "sha512-tsaTIkKW9b4N+AEj+SVA+WhJzV7/zMhcSu78mLKWSk7cXMOSHsBKFWUs0fWwq8QyK3MgJBQRX6Gbi4kYbdvGkQ=="],
"parse5-htmlparser2-tree-adapter/parse5": ["parse5@7.3.0", "", { "dependencies": { "entities": "^6.0.0" } }, "sha512-IInvU7fabl34qmi9gY8XOVxhYyMyuH2xUNpb2q8/Y+7552KlejkRvqvD19nMoUW/uQGGbqNpA6Tufu5FL5BZgw=="], "parse5-htmlparser2-tree-adapter/parse5": ["parse5@7.3.0", "", { "dependencies": { "entities": "^6.0.0" } }, "sha512-IInvU7fabl34qmi9gY8XOVxhYyMyuH2xUNpb2q8/Y+7552KlejkRvqvD19nMoUW/uQGGbqNpA6Tufu5FL5BZgw=="],
"parse5-parser-stream/parse5": ["parse5@7.3.0", "", { "dependencies": { "entities": "^6.0.0" } }, "sha512-IInvU7fabl34qmi9gY8XOVxhYyMyuH2xUNpb2q8/Y+7552KlejkRvqvD19nMoUW/uQGGbqNpA6Tufu5FL5BZgw=="], "parse5-parser-stream/parse5": ["parse5@7.3.0", "", { "dependencies": { "entities": "^6.0.0" } }, "sha512-IInvU7fabl34qmi9gY8XOVxhYyMyuH2xUNpb2q8/Y+7552KlejkRvqvD19nMoUW/uQGGbqNpA6Tufu5FL5BZgw=="],
@ -1709,8 +1678,6 @@
"shadcn/zod": ["zod@3.25.76", "", {}, "sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ=="], "shadcn/zod": ["zod@3.25.76", "", {}, "sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ=="],
"string-width/strip-ansi": ["strip-ansi@6.0.1", "", { "dependencies": { "ansi-regex": "^5.0.1" } }, "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A=="],
"strip-ansi/ansi-regex": ["ansi-regex@6.2.2", "", {}, "sha512-Bq3SmSpyFHaWjPk8If9yc6svM8c56dB5BAtW4Qbw5jHTwwXXcTLoRMkpDJp6VL0XzlWaCHTXrkFURMYmD0sLqg=="], "strip-ansi/ansi-regex": ["ansi-regex@6.2.2", "", {}, "sha512-Bq3SmSpyFHaWjPk8If9yc6svM8c56dB5BAtW4Qbw5jHTwwXXcTLoRMkpDJp6VL0XzlWaCHTXrkFURMYmD0sLqg=="],
"strip-literal/js-tokens": ["js-tokens@9.0.1", "", {}, "sha512-mxa9E9ITFOt0ban3j6L5MpjwegGz6lBQmM1IJkWeBZGcMxto50+eWdjC/52xDbS2vy0k7vIMK0Fe2wfL9OQSpQ=="], "strip-literal/js-tokens": ["js-tokens@9.0.1", "", {}, "sha512-mxa9E9ITFOt0ban3j6L5MpjwegGz6lBQmM1IJkWeBZGcMxto50+eWdjC/52xDbS2vy0k7vIMK0Fe2wfL9OQSpQ=="],
@ -1725,8 +1692,12 @@
"wrap-ansi/ansi-styles": ["ansi-styles@4.3.0", "", { "dependencies": { "color-convert": "^2.0.1" } }, "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg=="], "wrap-ansi/ansi-styles": ["ansi-styles@4.3.0", "", { "dependencies": { "color-convert": "^2.0.1" } }, "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg=="],
"wrap-ansi/string-width": ["string-width@4.2.3", "", { "dependencies": { "emoji-regex": "^8.0.0", "is-fullwidth-code-point": "^3.0.0", "strip-ansi": "^6.0.1" } }, "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g=="],
"wrap-ansi/strip-ansi": ["strip-ansi@6.0.1", "", { "dependencies": { "ansi-regex": "^5.0.1" } }, "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A=="], "wrap-ansi/strip-ansi": ["strip-ansi@6.0.1", "", { "dependencies": { "ansi-regex": "^5.0.1" } }, "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A=="],
"yargs/string-width": ["string-width@4.2.3", "", { "dependencies": { "emoji-regex": "^8.0.0", "is-fullwidth-code-point": "^3.0.0", "strip-ansi": "^6.0.1" } }, "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g=="],
"@dotenvx/dotenvx/execa/get-stream": ["get-stream@6.0.1", "", {}, "sha512-ts6Wi+2j3jQjqi70w5AlN8DFnkSwC+MqmxEzdEALB2qXZYV3X/b1CTfgPLGJNMeAWxdPfU8FO1ms3NUfaHCPYg=="], "@dotenvx/dotenvx/execa/get-stream": ["get-stream@6.0.1", "", {}, "sha512-ts6Wi+2j3jQjqi70w5AlN8DFnkSwC+MqmxEzdEALB2qXZYV3X/b1CTfgPLGJNMeAWxdPfU8FO1ms3NUfaHCPYg=="],
"@dotenvx/dotenvx/execa/human-signals": ["human-signals@2.1.0", "", {}, "sha512-B4FFZ6q/T2jhhksgkbEW3HBvWIfDW85snkQgawt07S7J5QXTk6BkNV+0yAeZrM5QpMAdYlocGoljn0sJ/WQkFw=="], "@dotenvx/dotenvx/execa/human-signals": ["human-signals@2.1.0", "", {}, "sha512-B4FFZ6q/T2jhhksgkbEW3HBvWIfDW85snkQgawt07S7J5QXTk6BkNV+0yAeZrM5QpMAdYlocGoljn0sJ/WQkFw=="],
@ -1745,18 +1716,12 @@
"bun-types/@types/node/undici-types": ["undici-types@7.19.2", "", {}, "sha512-qYVnV5OEm2AW8cJMCpdV20CDyaN3g0AjDlOGf1OW4iaDEx8MwdtChUp4zu4H0VP3nDRF/8RKWH+IPp9uW0YGZg=="], "bun-types/@types/node/undici-types": ["undici-types@7.19.2", "", {}, "sha512-qYVnV5OEm2AW8cJMCpdV20CDyaN3g0AjDlOGf1OW4iaDEx8MwdtChUp4zu4H0VP3nDRF/8RKWH+IPp9uW0YGZg=="],
"cliui/string-width/emoji-regex": ["emoji-regex@8.0.0", "", {}, "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A=="],
"cross-spawn/which/isexe": ["isexe@2.0.0", "", {}, "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw=="], "cross-spawn/which/isexe": ["isexe@2.0.0", "", {}, "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw=="],
"isomorphic-unfetch/node-fetch/whatwg-url": ["whatwg-url@5.0.0", "", { "dependencies": { "tr46": "~0.0.3", "webidl-conversions": "^3.0.0" } }, "sha512-saE57nupxk6v3HY35+jzBwYa0rKSy0XR8JSxZPwgLr7ys0IBzhGviA1/TUGJLmSVqs8pb9AnvICXEuOHLprYTw=="], "isomorphic-unfetch/node-fetch/whatwg-url": ["whatwg-url@5.0.0", "", { "dependencies": { "tr46": "~0.0.3", "webidl-conversions": "^3.0.0" } }, "sha512-saE57nupxk6v3HY35+jzBwYa0rKSy0XR8JSxZPwgLr7ys0IBzhGviA1/TUGJLmSVqs8pb9AnvICXEuOHLprYTw=="],
"msw/yargs/cliui": ["cliui@8.0.1", "", { "dependencies": { "string-width": "^4.2.0", "strip-ansi": "^6.0.1", "wrap-ansi": "^7.0.0" } }, "sha512-BSeNnyus75C4//NQ9gQt1/csTXyo/8Sb+afLAkzAptFuMsod9HFokGNudZpi/oQV73hnVK+sR+5PVRMd+Dr7YQ=="],
"msw/yargs/y18n": ["y18n@5.0.8", "", {}, "sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA=="],
"msw/yargs/yargs-parser": ["yargs-parser@21.1.1", "", {}, "sha512-tVpsJW7DdjecAiFpbIB1e3qxIQsE6NoPc5/eTdrbbIC4h0LVsWhnoa3g+m2HclBIujHzsxZ4VJVA+GUuc2/LBw=="],
"ora/string-width/emoji-regex": ["emoji-regex@10.6.0", "", {}, "sha512-toUI84YS5YmxW219erniWD0CIVOo46xGKColeNQRgOzDorgBi1v4D71/OFzgD9GO2UGKIv1C3Sp8DAn0+j5w7A=="],
"tsx/esbuild/@esbuild/aix-ppc64": ["@esbuild/aix-ppc64@0.27.7", "", { "os": "aix", "cpu": "ppc64" }, "sha512-EKX3Qwmhz1eMdEJokhALr0YiD0lhQNwDqkPYyPhiSwKrh7/4KRjQc04sZ8db+5DVVnZ1LmbNDI1uAMPEUBnQPg=="], "tsx/esbuild/@esbuild/aix-ppc64": ["@esbuild/aix-ppc64@0.27.7", "", { "os": "aix", "cpu": "ppc64" }, "sha512-EKX3Qwmhz1eMdEJokhALr0YiD0lhQNwDqkPYyPhiSwKrh7/4KRjQc04sZ8db+5DVVnZ1LmbNDI1uAMPEUBnQPg=="],
"tsx/esbuild/@esbuild/android-arm": ["@esbuild/android-arm@0.27.7", "", { "os": "android", "cpu": "arm" }, "sha512-jbPXvB4Yj2yBV7HUfE2KHe4GJX51QplCN1pGbYjvsyCZbQmies29EoJbkEc+vYuU5o45AfQn37vZlyXy4YJ8RQ=="], "tsx/esbuild/@esbuild/android-arm": ["@esbuild/android-arm@0.27.7", "", { "os": "android", "cpu": "arm" }, "sha512-jbPXvB4Yj2yBV7HUfE2KHe4GJX51QplCN1pGbYjvsyCZbQmies29EoJbkEc+vYuU5o45AfQn37vZlyXy4YJ8RQ=="],
@ -1813,14 +1778,16 @@
"vitest/vite/esbuild": ["esbuild@0.27.7", "", { "optionalDependencies": { "@esbuild/aix-ppc64": "0.27.7", "@esbuild/android-arm": "0.27.7", "@esbuild/android-arm64": "0.27.7", "@esbuild/android-x64": "0.27.7", "@esbuild/darwin-arm64": "0.27.7", "@esbuild/darwin-x64": "0.27.7", "@esbuild/freebsd-arm64": "0.27.7", "@esbuild/freebsd-x64": "0.27.7", "@esbuild/linux-arm": "0.27.7", "@esbuild/linux-arm64": "0.27.7", "@esbuild/linux-ia32": "0.27.7", "@esbuild/linux-loong64": "0.27.7", "@esbuild/linux-mips64el": "0.27.7", "@esbuild/linux-ppc64": "0.27.7", "@esbuild/linux-riscv64": "0.27.7", "@esbuild/linux-s390x": "0.27.7", "@esbuild/linux-x64": "0.27.7", "@esbuild/netbsd-arm64": "0.27.7", "@esbuild/netbsd-x64": "0.27.7", "@esbuild/openbsd-arm64": "0.27.7", "@esbuild/openbsd-x64": "0.27.7", "@esbuild/openharmony-arm64": "0.27.7", "@esbuild/sunos-x64": "0.27.7", "@esbuild/win32-arm64": "0.27.7", "@esbuild/win32-ia32": "0.27.7", "@esbuild/win32-x64": "0.27.7" }, "bin": { "esbuild": "bin/esbuild" } }, "sha512-IxpibTjyVnmrIQo5aqNpCgoACA/dTKLTlhMHihVHhdkxKyPO1uBBthumT0rdHmcsk9uMonIWS0m4FljWzILh3w=="], "vitest/vite/esbuild": ["esbuild@0.27.7", "", { "optionalDependencies": { "@esbuild/aix-ppc64": "0.27.7", "@esbuild/android-arm": "0.27.7", "@esbuild/android-arm64": "0.27.7", "@esbuild/android-x64": "0.27.7", "@esbuild/darwin-arm64": "0.27.7", "@esbuild/darwin-x64": "0.27.7", "@esbuild/freebsd-arm64": "0.27.7", "@esbuild/freebsd-x64": "0.27.7", "@esbuild/linux-arm": "0.27.7", "@esbuild/linux-arm64": "0.27.7", "@esbuild/linux-ia32": "0.27.7", "@esbuild/linux-loong64": "0.27.7", "@esbuild/linux-mips64el": "0.27.7", "@esbuild/linux-ppc64": "0.27.7", "@esbuild/linux-riscv64": "0.27.7", "@esbuild/linux-s390x": "0.27.7", "@esbuild/linux-x64": "0.27.7", "@esbuild/netbsd-arm64": "0.27.7", "@esbuild/netbsd-x64": "0.27.7", "@esbuild/openbsd-arm64": "0.27.7", "@esbuild/openbsd-x64": "0.27.7", "@esbuild/openharmony-arm64": "0.27.7", "@esbuild/sunos-x64": "0.27.7", "@esbuild/win32-arm64": "0.27.7", "@esbuild/win32-ia32": "0.27.7", "@esbuild/win32-x64": "0.27.7" }, "bin": { "esbuild": "bin/esbuild" } }, "sha512-IxpibTjyVnmrIQo5aqNpCgoACA/dTKLTlhMHihVHhdkxKyPO1uBBthumT0rdHmcsk9uMonIWS0m4FljWzILh3w=="],
"wrap-ansi/string-width/emoji-regex": ["emoji-regex@8.0.0", "", {}, "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A=="],
"yargs/string-width/emoji-regex": ["emoji-regex@8.0.0", "", {}, "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A=="],
"yargs/string-width/strip-ansi": ["strip-ansi@6.0.1", "", { "dependencies": { "ansi-regex": "^5.0.1" } }, "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A=="],
"isomorphic-unfetch/node-fetch/whatwg-url/tr46": ["tr46@0.0.3", "", {}, "sha512-N3WMsuqV66lT30CrXNbEjx4GEwlow3v6rr4mCcv6prnfwhS01rkgyFdjPNBYd9br7LpXV1+Emh01fHnq2Gdgrw=="], "isomorphic-unfetch/node-fetch/whatwg-url/tr46": ["tr46@0.0.3", "", {}, "sha512-N3WMsuqV66lT30CrXNbEjx4GEwlow3v6rr4mCcv6prnfwhS01rkgyFdjPNBYd9br7LpXV1+Emh01fHnq2Gdgrw=="],
"isomorphic-unfetch/node-fetch/whatwg-url/webidl-conversions": ["webidl-conversions@3.0.1", "", {}, "sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ=="], "isomorphic-unfetch/node-fetch/whatwg-url/webidl-conversions": ["webidl-conversions@3.0.1", "", {}, "sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ=="],
"msw/yargs/cliui/strip-ansi": ["strip-ansi@6.0.1", "", { "dependencies": { "ansi-regex": "^5.0.1" } }, "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A=="],
"msw/yargs/cliui/wrap-ansi": ["wrap-ansi@7.0.0", "", { "dependencies": { "ansi-styles": "^4.0.0", "string-width": "^4.1.0", "strip-ansi": "^6.0.0" } }, "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q=="],
"vite-node/vite/esbuild/@esbuild/aix-ppc64": ["@esbuild/aix-ppc64@0.27.7", "", { "os": "aix", "cpu": "ppc64" }, "sha512-EKX3Qwmhz1eMdEJokhALr0YiD0lhQNwDqkPYyPhiSwKrh7/4KRjQc04sZ8db+5DVVnZ1LmbNDI1uAMPEUBnQPg=="], "vite-node/vite/esbuild/@esbuild/aix-ppc64": ["@esbuild/aix-ppc64@0.27.7", "", { "os": "aix", "cpu": "ppc64" }, "sha512-EKX3Qwmhz1eMdEJokhALr0YiD0lhQNwDqkPYyPhiSwKrh7/4KRjQc04sZ8db+5DVVnZ1LmbNDI1uAMPEUBnQPg=="],
"vite-node/vite/esbuild/@esbuild/android-arm": ["@esbuild/android-arm@0.27.7", "", { "os": "android", "cpu": "arm" }, "sha512-jbPXvB4Yj2yBV7HUfE2KHe4GJX51QplCN1pGbYjvsyCZbQmies29EoJbkEc+vYuU5o45AfQn37vZlyXy4YJ8RQ=="], "vite-node/vite/esbuild/@esbuild/android-arm": ["@esbuild/android-arm@0.27.7", "", { "os": "android", "cpu": "arm" }, "sha512-jbPXvB4Yj2yBV7HUfE2KHe4GJX51QplCN1pGbYjvsyCZbQmies29EoJbkEc+vYuU5o45AfQn37vZlyXy4YJ8RQ=="],
@ -1924,7 +1891,5 @@
"vitest/vite/esbuild/@esbuild/win32-ia32": ["@esbuild/win32-ia32@0.27.7", "", { "os": "win32", "cpu": "ia32" }, "sha512-SmwKXe6VHIyZYbBLJrhOoCJRB/Z1tckzmgTLfFYOfpMAx63BJEaL9ExI8x7v0oAO3Zh6D/Oi1gVxEYr5oUCFhw=="], "vitest/vite/esbuild/@esbuild/win32-ia32": ["@esbuild/win32-ia32@0.27.7", "", { "os": "win32", "cpu": "ia32" }, "sha512-SmwKXe6VHIyZYbBLJrhOoCJRB/Z1tckzmgTLfFYOfpMAx63BJEaL9ExI8x7v0oAO3Zh6D/Oi1gVxEYr5oUCFhw=="],
"vitest/vite/esbuild/@esbuild/win32-x64": ["@esbuild/win32-x64@0.27.7", "", { "os": "win32", "cpu": "x64" }, "sha512-56hiAJPhwQ1R4i+21FVF7V8kSD5zZTdHcVuRFMW0hn753vVfQN8xlx4uOPT4xoGH0Z/oVATuR82AiqSTDIpaHg=="], "vitest/vite/esbuild/@esbuild/win32-x64": ["@esbuild/win32-x64@0.27.7", "", { "os": "win32", "cpu": "x64" }, "sha512-56hiAJPhwQ1R4i+21FVF7V8kSD5zZTdHcVuRFMW0hn753vVfQN8xlx4uOPT4xoGH0Z/oVATuR82AiqSTDIpaHg=="],
"msw/yargs/cliui/wrap-ansi/ansi-styles": ["ansi-styles@4.3.0", "", { "dependencies": { "color-convert": "^2.0.1" } }, "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg=="],
} }
} }

1
web/package.json
View file

@ -36,7 +36,6 @@
"embla-carousel-react": "^8.6.0", "embla-carousel-react": "^8.6.0",
"lucide-react": "^1.8.0", "lucide-react": "^1.8.0",
"next-themes": "^0.4.6", "next-themes": "^0.4.6",
"qrcode": "^1.5.4",
"react": "^19.2.0", "react": "^19.2.0",
"react-dom": "^19.2.0", "react-dom": "^19.2.0",
"shadcn": "^4.3.0", "shadcn": "^4.3.0",

98
web/src/components/party-qr.tsx
View file

@ -1,98 +0,0 @@
import { useEffect, useMemo, useState } from "react";
import QRCode from "qrcode";
import { Button } from "#/components/ui/button";
import {
Dialog,
DialogClose,
DialogContent,
DialogDescription,
DialogFooter,
DialogHeader,
DialogTitle,
DialogTrigger,
} from "#/components/ui/dialog";
import { Item, ItemActions, ItemDescription } from "#/components/ui/item";
import { useUser } from "#/hooks/user";
const QR_SIZE = 220;
export function PartyQr() {
const { user } = useUser();
const [dataUrl, setDataUrl] = useState<string | null>(null);
const joinUrl = useMemo(() => {
if (typeof window === "undefined" || !user?.id) return null;
const url = new URL(window.location.href);
url.searchParams.delete("redirect");
url.searchParams.set("join", user.id);
return url.toString();
}, [user?.id]);
useEffect(() => {
let isMounted = true;
if (!joinUrl) {
setDataUrl(null);
return undefined;
}
QRCode.toDataURL(joinUrl, { width: QR_SIZE, margin: 1 })
.then((url) => {
if (isMounted) {
setDataUrl(url);
}
})
.catch(() => {
if (isMounted) {
setDataUrl(null);
}
});
return () => {
isMounted = false;
};
}, [joinUrl]);
if (!user?.id) return null;
return (
<Item className="px-0 justify-between">
<ItemDescription>Invite someone to your party</ItemDescription>
<ItemActions>
<Dialog>
<DialogTrigger render={<Button size="sm" variant="outline" />}>Show QR</DialogTrigger>
<DialogContent>
<DialogHeader>
<DialogTitle>Party invite</DialogTitle>
<DialogDescription>
Scan to join your party on another device.
</DialogDescription>
</DialogHeader>
<div className="flex flex-col items-center gap-4">
{dataUrl ? (
<img
alt="Party invite QR code"
src={dataUrl}
width={QR_SIZE}
height={QR_SIZE}
className="rounded-xl border border-border bg-white p-2"
/>
) : (
<div className="flex size-[220px] items-center justify-center rounded-xl border border-dashed border-border text-muted-foreground">
Generating QR...
</div>
)}
{joinUrl ? (
<p className="max-w-[280px] break-all text-xs text-muted-foreground">
{joinUrl}
</p>
) : null}
</div>
<DialogFooter>
<DialogClose render={<Button variant="outline" />}>Close</DialogClose>
</DialogFooter>
</DialogContent>
</Dialog>
</ItemActions>
</Item>
);
}

66
web/src/lib/party-join.ts
View file

@ -1,66 +0,0 @@
const pendingPartyKey = "pendingPartyJoin";
export function readPendingPartyJoin(): string | null {
if (typeof window === "undefined") return null;
return window.localStorage.getItem(pendingPartyKey);
}
export function writePendingPartyJoin(partyHostId: string) {
if (typeof window === "undefined") return;
window.localStorage.setItem(pendingPartyKey, partyHostId);
}
export function clearPendingPartyJoin() {
if (typeof window === "undefined") return;
window.localStorage.removeItem(pendingPartyKey);
}
export function getJoinIdFromLocation(): string | null {
if (typeof window === "undefined") return null;
const params = new URLSearchParams(window.location.search);
const join = params.get("join");
if (join) return join;
const redirect = params.get("redirect");
if (!redirect) return null;
try {
const redirectUrl = new URL(redirect, window.location.origin);
return redirectUrl.searchParams.get("join");
} catch {
return null;
}
}
export function clearJoinIdFromLocation() {
if (typeof window === "undefined") return;
const url = new URL(window.location.href);
const hasJoin = url.searchParams.has("join");
const redirect = url.searchParams.get("redirect");
let updatedRedirect: string | null = null;
if (redirect) {
try {
const redirectUrl = new URL(redirect, window.location.origin);
if (redirectUrl.searchParams.has("join")) {
redirectUrl.searchParams.delete("join");
updatedRedirect =
redirectUrl.pathname + redirectUrl.search + redirectUrl.hash;
}
} catch {
updatedRedirect = null;
}
}
if (!hasJoin && !updatedRedirect) return;
if (hasJoin) {
url.searchParams.delete("join");
}
if (updatedRedirect) {
url.searchParams.set("redirect", updatedRedirect);
}
const nextUrl = url.pathname + url.search + url.hash;
window.history.replaceState({}, "", nextUrl);
}

57
web/src/routes/__root.tsx
View file

@ -12,17 +12,6 @@ import TanStackQueryDevtools from "../integrations/tanstack-query/devtools";
import appCss from "../styles.css?url"; import appCss from "../styles.css?url";
import type { AuthSession } from "#/lib/auth.serverfn"; import type { AuthSession } from "#/lib/auth.serverfn";
import { fetchSession, sessionQueryKey } from "#/lib/auth-client"; import { fetchSession, sessionQueryKey } from "#/lib/auth-client";
import type * as React from "react";
import { useEffect } from "react";
import { client } from "#/lib/eden";
import {
clearPendingPartyJoin,
clearJoinIdFromLocation,
getJoinIdFromLocation,
readPendingPartyJoin,
writePendingPartyJoin,
} from "#/lib/party-join";
import { toast } from "sonner";
interface MyRouterContext { interface MyRouterContext {
queryClient: QueryClient; queryClient: QueryClient;
@ -79,52 +68,6 @@ export const Route = createRootRouteWithContext<MyRouterContext>()({
}); });
function RootDocument({ children }: { children: React.ReactNode }) { function RootDocument({ children }: { children: React.ReactNode }) {
const { user } = Route.useRouteContext();
useEffect(() => {
if (typeof window === "undefined") return;
const joinId = getJoinIdFromLocation();
if (!joinId) return;
const storedId = readPendingPartyJoin();
if (storedId !== joinId) {
writePendingPartyJoin(joinId);
}
clearJoinIdFromLocation();
}, []);
useEffect(() => {
if (!user) return;
const joinId = readPendingPartyJoin();
if (!joinId) return;
let cancelled = false;
const attemptJoin = async () => {
try {
const result = await client.api.party.join.post({
targetUserId: joinId,
});
if (result?.error) {
toast.error(result.error);
clearPendingPartyJoin();
} else {
toast.success("Joined party.");
clearPendingPartyJoin();
}
} catch (error) {
if (!cancelled) {
toast.error("Failed to join party.");
}
}
};
attemptJoin();
return () => {
cancelled = true;
};
}, [user]);
return ( return (
<html lang="en" suppressHydrationWarning> <html lang="en" suppressHydrationWarning>
<head> <head>

2
web/src/routes/index.tsx
View file

@ -1,7 +1,6 @@
import { SyncButton } from "#/components/sync-button"; import { SyncButton } from "#/components/sync-button";
import { MainContent } from "#/components/ui/main-content"; import { MainContent } from "#/components/ui/main-content";
import { UserInfo } from "#/components/user-info"; import { UserInfo } from "#/components/user-info";
import { PartyQr } from "#/components/party-qr";
import { createFileRoute } from "@tanstack/react-router"; import { createFileRoute } from "@tanstack/react-router";
export const Route = createFileRoute("/")({ component: App }); export const Route = createFileRoute("/")({ component: App });
@ -11,7 +10,6 @@ function App() {
<MainContent> <MainContent>
<UserInfo /> <UserInfo />
<SyncButton /> <SyncButton />
<PartyQr />
</MainContent> </MainContent>
); );
} }