rhythia-api 226.0.0 → 230.0.0

package/api/getUserScores.ts

@@ -18,11 +18,12 @@ export const Schema = {
           awarded_sp: z.number().nullable(),
           beatmapHash: z.string().nullable(),
           created_at: z.string(),
-          id: z.number(),
-          misses: z.number().nullable(),
-          passed: z.boolean().nullable(),
-          songId: z.string().nullable(),
-          userId: z.number().nullable(),
+          id: z.number(),
+          misses: z.number().nullable(),
+          passed: z.boolean().nullable(),
+          replay_url: z.string().nullable().optional(),
+          songId: z.string().nullable(),
+          userId: z.number().nullable(),
           beatmapDifficulty: z.number().optional().nullable(),
           beatmapNotes: z.number().optional().nullable(),
           beatmapTitle: z.string().optional().nullable(),
@@ -37,11 +38,12 @@ export const Schema = {
           id: z.number(),
           awarded_sp: z.number().nullable(),
           created_at: z.string(),
-          misses: z.number().nullable(),
-          mods: z.record(z.unknown()),
-          passed: z.boolean().nullable(),
-          songId: z.string().nullable(),
-          speed: z.number().nullable(),
+          misses: z.number().nullable(),
+          mods: z.record(z.unknown()),
+          passed: z.boolean().nullable(),
+          replay_url: z.string().nullable().optional(),
+          songId: z.string().nullable(),
+          speed: z.number().nullable(),
           spin: z.boolean(),
           beatmapHash: z.string().nullable(),
           beatmapTitle: z.string().nullable(),
@@ -56,11 +58,12 @@ export const Schema = {
           awarded_sp: z.number().nullable(),
           beatmapHash: z.string().nullable(),
           created_at: z.string(),
-          id: z.number(),
-          misses: z.number().nullable(),
-          passed: z.boolean().nullable(),
-          rank: z.string().nullable(),
-          songId: z.string().nullable(),
+          id: z.number(),
+          misses: z.number().nullable(),
+          passed: z.boolean().nullable(),
+          replay_url: z.string().nullable().optional(),
+          rank: z.string().nullable(),
+          songId: z.string().nullable(),
           userId: z.number().nullable(),
           beatmapDifficulty: z.number().optional().nullable(),
           beatmapNotes: z.number().optional().nullable(),

package/handleApi.ts

@@ -2,20 +2,16 @@ import { z } from "zod";
 let env = "development";
 import { profanity, CensorType } from "@2toad/profanity";
 export function setEnvironment(
-  stage: "development" | "testing" | "production" | "local"
+  stage: "development" | "testing" | "production"
 ) {
   env = stage;
 }
 export function handleApi<
-  T extends { url: string; input: z.ZodObject<any>; output: z.ZodObject<any> },
+  T extends { url: string; input: z.ZodObject<any>; output: z.ZodObject<any> }
 >(apiSchema: T) {
   profanity.whitelist.addWords(["willy"]);
   return async (input: T["input"]["_type"]): Promise<T["output"]["_type"]> => {
-    let url = `https://${env}.rhythia.com${apiSchema.url}`;
-    if (env == "local") {
-      url = `https://localhost:3000${apiSchema.url}`;
-    }
-    const response = await fetch(url, {
+    const response = await fetch(`https://${env}.rhythia.com${apiSchema.url}`, {
       method: "POST",
       body: JSON.stringify(input),
     });

package/index.ts

@@ -1116,11 +1116,12 @@ export const Schema = {
           awarded_sp: z.number().nullable(),
           beatmapHash: z.string().nullable(),
           created_at: z.string(),
-          id: z.number(),
-          misses: z.number().nullable(),
-          passed: z.boolean().nullable(),
-          songId: z.string().nullable(),
-          userId: z.number().nullable(),
+          id: z.number(),
+          misses: z.number().nullable(),
+          passed: z.boolean().nullable(),
+          replay_url: z.string().nullable().optional(),
+          songId: z.string().nullable(),
+          userId: z.number().nullable(),
           beatmapDifficulty: z.number().optional().nullable(),
           beatmapNotes: z.number().optional().nullable(),
           beatmapTitle: z.string().optional().nullable(),
@@ -1135,11 +1136,12 @@ export const Schema = {
           id: z.number(),
           awarded_sp: z.number().nullable(),
           created_at: z.string(),
-          misses: z.number().nullable(),
-          mods: z.record(z.unknown()),
-          passed: z.boolean().nullable(),
-          songId: z.string().nullable(),
-          speed: z.number().nullable(),
+          misses: z.number().nullable(),
+          mods: z.record(z.unknown()),
+          passed: z.boolean().nullable(),
+          replay_url: z.string().nullable().optional(),
+          songId: z.string().nullable(),
+          speed: z.number().nullable(),
           spin: z.boolean(),
           beatmapHash: z.string().nullable(),
           beatmapTitle: z.string().nullable(),
@@ -1154,11 +1156,12 @@ export const Schema = {
           awarded_sp: z.number().nullable(),
           beatmapHash: z.string().nullable(),
           created_at: z.string(),
-          id: z.number(),
-          misses: z.number().nullable(),
-          passed: z.boolean().nullable(),
-          rank: z.string().nullable(),
-          songId: z.string().nullable(),
+          id: z.number(),
+          misses: z.number().nullable(),
+          passed: z.boolean().nullable(),
+          replay_url: z.string().nullable().optional(),
+          rank: z.string().nullable(),
+          songId: z.string().nullable(),
           userId: z.number().nullable(),
           beatmapDifficulty: z.number().optional().nullable(),
           beatmapNotes: z.number().optional().nullable(),

package/package.json

@@ -1,12 +1,17 @@
 {
   "name": "rhythia-api",
-  "version": "226.0.0",
+  "version": "230.0.0",
   "main": "index.ts",
   "author": "online-contributors-cunev",
   "scripts": {
     "update": "bun ./scripts/update.ts",
     "ci-deploy": "tsx ./scripts/ci-deploy.ts",
     "test": "tsx ./scripts/test.ts",
+    "cache:clear-user-scores": "bun run scripts/clear-user-score-cache.ts",
+    "query-pull": "bun run scripts/pull-queries.ts",
+    "query-push": "bun run scripts/deploy-queries.ts",
+    "queries:pull": "bun run scripts/pull-queries.ts",
+    "queries:deploy": "bun run scripts/deploy-queries.ts",
     "sync": "npx supabase gen types typescript --project-id \"pfkajngbllcbdzoylrvp\" --schema public > types/database.ts",
     "pipeline:build-api": "tsx ./scripts/build.ts",
     "pipeline:deploy-testing": "tsx ./scripts/build.ts"
@@ -24,6 +29,7 @@
     "@types/bun": "^1.1.6",
     "@types/lodash": "^4.17.7",
     "@types/node": "^22.2.0",
+    "@types/pg": "^8.15.5",
     "@types/validator": "^13.12.2",
     "@vercel/edge": "^1.1.2",
     "@vercel/node": "^3.2.8",
@@ -40,6 +46,8 @@
     "osu-classes": "^3.1.0",
     "osu-parsers": "^4.1.7",
     "osu-standard-stable": "^5.0.0",
+    "pg": "^8.18.0",
+    "redis": "^5.10.0",
     "remote-cloudflare-kv": "^1.0.1",
     "sharp": "^0.33.5",
     "short-uuid": "^5.2.0",
@@ -53,4 +61,4 @@
     "zod": "^3.24.2"
   },
   "packageManager": "yarn@1.22.22"
-}
+}

package/queries/admin_delete_user.sql

@@ -0,0 +1,39 @@
+CREATE OR REPLACE FUNCTION public.admin_delete_user(user_id integer)
+ RETURNS boolean
+ LANGUAGE plpgsql
+ SECURITY DEFINER
+AS $function$
+DECLARE
+  success BOOLEAN;
+BEGIN
+  -- Delete scores first due to foreign key constraints
+  DELETE FROM public.scores WHERE "userId" = user_id;
+  
+  -- Delete beatmapPageComments
+  DELETE FROM public."beatmapPageComments" WHERE owner = user_id;
+  
+  -- Delete beatmapPages owned by user
+  DELETE FROM public."beatmapPages" WHERE owner = user_id;
+  
+  -- Delete collections owned by user
+  DELETE FROM public."beatmapCollections" WHERE owner = user_id;
+  
+  -- Delete collection relations related to user's collections
+  -- (this is handled by cascade if you have it set up)
+  
+  -- Delete passkeys
+  DELETE FROM public.passkeys WHERE id = user_id;
+  
+  -- Delete profile activity
+  DELETE FROM public."profileActivities" 
+  WHERE uid = (SELECT uid FROM public.profiles WHERE id = user_id);
+  
+  -- Finally, delete the profile
+  DELETE FROM public.profiles WHERE id = user_id;
+  
+  -- Check if deletion was successful
+  success := NOT EXISTS (SELECT 1 FROM public.profiles WHERE id = user_id);
+  
+  RETURN success;
+END;
+$function$

package/queries/admin_exclude_user.sql

@@ -0,0 +1,21 @@
+CREATE OR REPLACE FUNCTION public.admin_exclude_user(user_id integer)
+ RETURNS boolean
+ LANGUAGE plpgsql
+ SECURITY DEFINER
+AS $function$
+DECLARE
+  success BOOLEAN;
+BEGIN
+  UPDATE public.profiles
+  SET ban = 'excluded'::"banTypes",
+      "bannedAt" = EXTRACT(EPOCH FROM NOW())::bigint
+  WHERE id = user_id;
+  
+  success := EXISTS (
+    SELECT 1 FROM public.profiles 
+    WHERE id = user_id AND ban = 'excluded'::"banTypes"
+  );
+  
+  RETURN success;
+END;
+$function$

package/queries/admin_invalidate_ranked_scores.sql

@@ -0,0 +1,18 @@
+CREATE OR REPLACE FUNCTION public.admin_invalidate_ranked_scores(user_id integer)
+ RETURNS integer
+ LANGUAGE plpgsql
+ SECURITY DEFINER
+AS $function$
+DECLARE
+  updated_count INTEGER;
+BEGIN
+  -- Update user stats to reflect score invalidation
+  UPDATE public.profiles
+  SET 
+    skill_points = 0,
+    spin_skill_points = 0
+  WHERE id = user_id;
+  
+  RETURN updated_count;
+END;
+$function$

package/queries/admin_log_action.sql

@@ -0,0 +1,10 @@
+CREATE OR REPLACE FUNCTION public.admin_log_action(admin_id integer, action_type text, target_id integer, details jsonb DEFAULT NULL::jsonb)
+ RETURNS void
+ LANGUAGE plpgsql
+ SECURITY DEFINER
+AS $function$
+BEGIN
+  INSERT INTO public.admin_actions (admin_id, action_type, target_id, details)
+  VALUES (admin_id, action_type, target_id, details);
+END;
+$function$

package/queries/admin_profanity_clear.sql

@@ -0,0 +1,29 @@
+CREATE OR REPLACE FUNCTION public.admin_profanity_clear(user_id integer)
+ RETURNS boolean
+ LANGUAGE plpgsql
+ SECURITY DEFINER
+AS $function$
+DECLARE
+  success BOOLEAN;
+  random_username TEXT;
+BEGIN
+  -- Generate a random username (Player + random number between 10000-99999)
+  random_username := 'Player' || (10000 + floor(random() * 90000)::int)::text;
+  
+  -- Update the profile
+  UPDATE public.profiles
+  SET 
+    username = random_username,
+    "computedUsername" = LOWER(random_username),
+    about_me = NULL
+  WHERE id = user_id;
+  
+  -- Check if update was successful
+  success := EXISTS (
+    SELECT 1 FROM public.profiles 
+    WHERE id = user_id AND username = random_username AND about_me IS NULL
+  );
+    
+  RETURN success;
+END;
+$function$

package/queries/admin_remove_all_scores.sql

@@ -0,0 +1,29 @@
+CREATE OR REPLACE FUNCTION public.admin_remove_all_scores(user_id integer)
+ RETURNS integer
+ LANGUAGE plpgsql
+ SECURITY DEFINER
+AS $function$
+DECLARE
+  deleted_count INTEGER;
+BEGIN
+  -- Delete all scores for this user and count them
+  WITH deleted AS (
+    DELETE FROM public.scores
+    WHERE "userId" = user_id
+    RETURNING *
+  )
+  SELECT COUNT(*) INTO deleted_count FROM deleted;
+  
+  -- Update user stats to reflect score removal
+  UPDATE public.profiles
+  SET 
+    play_count = 0,
+    squares_hit = 0,
+    total_score = 0,
+    skill_points = 0,
+    spin_skill_points = 0
+  WHERE id = user_id;
+  
+  RETURN deleted_count;
+END;
+$function$

package/queries/admin_restrict_user.sql

@@ -0,0 +1,21 @@
+CREATE OR REPLACE FUNCTION public.admin_restrict_user(user_id integer)
+ RETURNS boolean
+ LANGUAGE plpgsql
+ SECURITY DEFINER
+AS $function$
+DECLARE
+  success BOOLEAN;
+BEGIN
+  UPDATE public.profiles
+  SET ban = 'restricted'::"banTypes",
+      "bannedAt" = EXTRACT(EPOCH FROM NOW())::bigint
+  WHERE id = user_id;
+  
+  success := EXISTS (
+    SELECT 1 FROM public.profiles 
+    WHERE id = user_id AND ban = 'restricted'::"banTypes"
+  );
+  
+  RETURN success;
+END;
+$function$

package/queries/admin_search_users.sql

@@ -0,0 +1,24 @@
+CREATE OR REPLACE FUNCTION public.admin_search_users(search_text text)
+ RETURNS SETOF profiles
+ LANGUAGE plpgsql
+ SECURITY DEFINER
+AS $function$
+BEGIN
+  RETURN QUERY
+  SELECT *
+  FROM public.profiles
+  WHERE 
+    username ILIKE '%' || search_text || '%'
+    OR "computedUsername" ILIKE '%' || search_text || '%'
+    OR CAST(uid AS TEXT) ILIKE '%' || search_text || '%'
+    OR CAST(id AS TEXT) = search_text
+    OR about_me ILIKE '%' || search_text || '%'
+    OR flag ILIKE '%' || search_text || '%'
+    OR EXISTS (
+      SELECT 1
+      FROM public.passkeys
+      WHERE passkeys.id = profiles.id AND passkeys.email ILIKE '%' || search_text || '%'
+    )
+  ORDER BY id;
+END;
+$function$

package/queries/admin_silence_user.sql

@@ -0,0 +1,21 @@
+CREATE OR REPLACE FUNCTION public.admin_silence_user(user_id integer)
+ RETURNS boolean
+ LANGUAGE plpgsql
+ SECURITY DEFINER
+AS $function$
+DECLARE
+  success BOOLEAN;
+BEGIN
+  UPDATE public.profiles
+  SET ban = 'silenced'::"banTypes",
+      "bannedAt" = EXTRACT(EPOCH FROM NOW())::bigint
+  WHERE id = user_id;
+  
+  success := EXISTS (
+    SELECT 1 FROM public.profiles 
+    WHERE id = user_id AND ban = 'silenced'::"banTypes"
+  );
+  
+  RETURN success;
+END;
+$function$

package/queries/admin_unban_user.sql

@@ -0,0 +1,21 @@
+CREATE OR REPLACE FUNCTION public.admin_unban_user(user_id integer)
+ RETURNS boolean
+ LANGUAGE plpgsql
+ SECURITY DEFINER
+AS $function$
+DECLARE
+  success BOOLEAN;
+BEGIN
+  UPDATE public.profiles
+  SET ban = 'cool',
+      "bannedAt" = NULL
+  WHERE id = user_id;
+  
+  success := EXISTS (
+    SELECT 1 FROM public.profiles 
+    WHERE id = user_id AND ban IS NULL
+  );
+  
+  RETURN success;
+END;
+$function$

package/queries/get_badge_leaderboard.sql

@@ -0,0 +1,50 @@
+CREATE OR REPLACE FUNCTION public.get_badge_leaderboard(p_limit integer DEFAULT 100)
+ RETURNS TABLE(id integer, display_name text, avatar_url text, special_badge_count integer)
+ LANGUAGE plpgsql
+ SECURITY DEFINER
+AS $function$
+BEGIN
+  RETURN QUERY
+  WITH special_badges AS (
+    SELECT unnest(ARRAY[
+      'The Start of an Era',
+      'New Farm', 
+      'Spinnin',
+      'Old Farm',
+      'Birb',
+      'Flamingos',
+      'Cats!'
+    ]) AS badge_name
+  ),
+  user_badge_data AS (
+    SELECT 
+      p.id::INTEGER as id,
+      p.username,
+      p.avatar_url,
+      p."computedUsername",
+      json_array_elements_text(COALESCE(p.badges, '[]'::json)) as user_badge
+    FROM profiles p
+    WHERE p.username IS NOT NULL 
+      AND (p.ban IS NULL OR p.ban != 'excluded')
+  ),
+  user_special_badge_counts AS (
+    SELECT 
+      ubd.id,
+      ubd.username,
+      ubd.avatar_url,
+      ubd."computedUsername",
+      COUNT(DISTINCT sb.badge_name)::INTEGER as special_badge_count
+    FROM user_badge_data ubd
+    INNER JOIN special_badges sb ON ubd.user_badge = sb.badge_name
+    GROUP BY ubd.id, ubd.username, ubd.avatar_url, ubd."computedUsername"
+  )
+  SELECT 
+    usbc.id,
+    COALESCE(usbc."computedUsername", usbc.username) as display_name,
+    usbc.avatar_url,
+    usbc.special_badge_count
+  FROM user_special_badge_counts usbc
+  ORDER BY usbc.special_badge_count DESC, display_name ASC
+  LIMIT p_limit;
+END;
+$function$

package/queries/get_clan_leaderboard.sql

@@ -0,0 +1,68 @@
+CREATE OR REPLACE FUNCTION public.get_clan_leaderboard(page_number integer DEFAULT 1, items_per_page integer DEFAULT 10)
+ RETURNS TABLE(id integer, name text, acronym text, avatar_url text, description text, member_count bigint, total_skill_points numeric, total_pages integer)
+ LANGUAGE plpgsql
+ SECURITY DEFINER
+ SET search_path TO 'public'
+AS $function$
+DECLARE
+  total_clan_pages integer;
+  total_clan_count integer;
+BEGIN
+  -- Calculate total clans
+  SELECT COUNT(*) INTO total_clan_count FROM clans;
+  
+  -- Calculate total pages, ensuring at least 1 page even if no clans exist
+  SELECT GREATEST(1, CEIL(total_clan_count::numeric / items_per_page)) INTO total_clan_pages;
+  
+  -- Set page_number to 1 if it's out of bounds
+  IF page_number <= 0 OR page_number > total_clan_pages THEN
+    page_number := 1;
+  END IF;
+  
+  RETURN QUERY
+    WITH clan_stats AS (
+      SELECT
+        c.id,
+        c.name,
+        c.acronym,
+        c.avatar_url,
+        c.description,
+        COUNT(p.id) FILTER (WHERE p.ban != 'excluded' OR p.ban IS NULL) AS member_count,
+        COALESCE(SUM(p.skill_points) FILTER (WHERE p.ban != 'excluded' OR p.ban IS NULL), 0)::numeric AS total_skill_points
+      FROM
+        clans c
+      LEFT JOIN
+        profiles p ON p.clan = c.id
+      GROUP BY
+        c.id, c.name, c.acronym, c.avatar_url, c.description
+    ),
+    clan_ranking AS (
+      SELECT
+        cs.id::integer,
+        cs.name,
+        cs.acronym,
+        cs.avatar_url,
+        cs.description,
+        cs.member_count,
+        cs.total_skill_points,
+        ROW_NUMBER() OVER (ORDER BY cs.total_skill_points DESC, cs.member_count DESC, cs.name ASC) AS rank
+      FROM
+        clan_stats cs
+    )
+    SELECT
+      cr.id,
+      cr.name,
+      cr.acronym,
+      cr.avatar_url,
+      cr.description,
+      cr.member_count,
+      cr.total_skill_points,
+      total_clan_pages
+    FROM
+      clan_ranking cr
+    WHERE
+      (total_clan_count = 0 OR (cr.rank > (page_number - 1) * items_per_page AND cr.rank <= page_number * items_per_page))
+    ORDER BY
+      cr.total_skill_points DESC, cr.member_count DESC, cr.name ASC;
+END;
+$function$

package/queries/get_collections_v4.sql

@@ -0,0 +1,109 @@
+CREATE OR REPLACE FUNCTION public.get_collections_v4(page_number integer DEFAULT 1, items_per_page integer DEFAULT 10, owner_filter bigint DEFAULT NULL::bigint, search_query text DEFAULT NULL::text, author_filter text DEFAULT NULL::text, min_beatmaps integer DEFAULT NULL::integer)
+ RETURNS TABLE(id bigint, title text, description text, created_at timestamp with time zone, owner bigint, owner_username text, owner_avatar_url text, beatmap_count bigint, star1 bigint, star2 bigint, star3 bigint, star4 bigint, star5 bigint, star6 bigint, star7 bigint, star8 bigint, star9 bigint, star10 bigint, star11 bigint, star12 bigint, star13 bigint, star14 bigint, star15 bigint, star16 bigint, star17 bigint, star18 bigint, total_pages bigint)
+ LANGUAGE plpgsql
+AS $function$
+DECLARE
+  total_count bigint;
+BEGIN
+  -- Get total count with beatmap count filter
+  WITH collection_counts AS (
+    SELECT 
+      bc.id,
+      COUNT(DISTINCT cr.id) as map_count
+    FROM "beatmapCollections" bc
+    LEFT JOIN "collectionRelations" cr ON cr.collection = bc.id
+    LEFT JOIN "profiles" p ON p."id" = bc."owner"
+    WHERE (owner_filter IS NULL OR bc.owner = owner_filter)
+    AND (author_filter IS NULL OR p.username ILIKE '%' || author_filter || '%')
+    AND (
+      search_query IS NULL 
+      OR bc.title ILIKE '%' || search_query || '%' 
+      OR bc.description ILIKE '%' || search_query || '%'
+      OR p.username ILIKE '%' || search_query || '%'
+    )
+    GROUP BY bc.id
+  )
+  SELECT COUNT(*) 
+  INTO total_count 
+  FROM collection_counts
+  WHERE (min_beatmaps IS NULL OR map_count >= min_beatmaps);
+
+  RETURN QUERY
+  WITH collection_counts AS (
+    SELECT 
+      bc.id,
+      bc.title,
+      bc.description,
+      bc.created_at,
+      bc.owner,
+      p.username,
+      p."avatar_url",
+      COUNT(DISTINCT cr.id) as map_count,
+      COUNT(*) FILTER (WHERE round(b."starRating") = 1) as star1,
+      COUNT(*) FILTER (WHERE round(b."starRating") = 2) as star2,
+      COUNT(*) FILTER (WHERE round(b."starRating") = 3) as star3,
+      COUNT(*) FILTER (WHERE round(b."starRating") = 4) as star4,
+      COUNT(*) FILTER (WHERE round(b."starRating") = 5) as star5,
+      COUNT(*) FILTER (WHERE round(b."starRating") = 6) as star6,
+      COUNT(*) FILTER (WHERE round(b."starRating") = 7) as star7,
+      COUNT(*) FILTER (WHERE round(b."starRating") = 8) as star8,
+      COUNT(*) FILTER (WHERE round(b."starRating") = 9) as star9,
+      COUNT(*) FILTER (WHERE round(b."starRating") = 10) as star10,
+      COUNT(*) FILTER (WHERE round(b."starRating") = 11) as star11,
+      COUNT(*) FILTER (WHERE round(b."starRating") = 12) as star12,
+      COUNT(*) FILTER (WHERE round(b."starRating") = 13) as star13,
+      COUNT(*) FILTER (WHERE round(b."starRating") = 14) as star14,
+      COUNT(*) FILTER (WHERE round(b."starRating") = 15) as star15,
+      COUNT(*) FILTER (WHERE round(b."starRating") = 16) as star16,
+      COUNT(*) FILTER (WHERE round(b."starRating") = 17) as star17,
+      COUNT(*) FILTER (WHERE round(b."starRating") = 18) as star18
+    FROM "beatmapCollections" bc
+    LEFT JOIN "collectionRelations" cr ON cr.collection = bc.id
+    LEFT JOIN "beatmapPages" bp ON bp.id = cr."beatmapPage"
+    LEFT JOIN "beatmaps" b ON b."beatmapHash" = bp."latestBeatmapHash"
+    LEFT JOIN "profiles" p ON p."id" = bc."owner"
+    WHERE (owner_filter IS NULL OR bc.owner = owner_filter)
+    AND (author_filter IS NULL OR p.username ILIKE '%' || author_filter || '%')
+    AND (
+      search_query IS NULL 
+      OR bc.title ILIKE '%' || search_query || '%' 
+      OR bc.description ILIKE '%' || search_query || '%'
+      OR p.username ILIKE '%' || search_query || '%'
+    )
+    GROUP BY bc.id, bc.title, bc.description, bc.created_at, bc.owner, p.username, p."avatar_url"
+    HAVING (min_beatmaps IS NULL OR COUNT(DISTINCT cr.id) >= min_beatmaps)
+  )
+  SELECT 
+    cc.id,
+    cc.title,
+    cc.description,
+    cc.created_at,
+    cc.owner,
+    cc.username as owner_username,
+    cc."avatar_url" as owner_avatar_url,
+    cc.map_count as beatmap_count,
+    cc.star1,
+    cc.star2,
+    cc.star3,
+    cc.star4,
+    cc.star5,
+    cc.star6,
+    cc.star7,
+    cc.star8,
+    cc.star9,
+    cc.star10,
+    cc.star11,
+    cc.star12,
+    cc.star13,
+    cc.star14,
+    cc.star15,
+    cc.star16,
+    cc.star17,
+    cc.star18,
+    CEILING(total_count::numeric / items_per_page)::bigint as total_pages
+  FROM collection_counts cc
+  ORDER BY cc.created_at DESC
+  LIMIT items_per_page
+  OFFSET ((page_number - 1) * items_per_page);
+END;
+$function$

package/queries/get_top_scores_for_beatmap.sql

@@ -0,0 +1,44 @@
+CREATE OR REPLACE FUNCTION public.get_top_scores_for_beatmap(beatmap_hash text)
+ RETURNS TABLE(id bigint, awarded_sp numeric, created_at timestamp with time zone, misses numeric, mods json, passed boolean, replayhwid text, songid text, speed numeric, spin boolean, userid bigint, username text, avatar_url text, accuracy numeric)
+ LANGUAGE plpgsql
+AS $function$
+BEGIN
+    RETURN QUERY
+    WITH user_top_scores AS (
+        SELECT DISTINCT ON (s."userId")
+            s.id,
+            s.awarded_sp,
+            s.created_at,
+            s.misses,
+            s.mods,
+            s.passed,
+            s."replayHwid",
+            s."songId",
+            s.speed,
+            s.spin,
+            s."userId",
+            p.username,
+            p.avatar_url,
+            CASE 
+                WHEN b."noteCount" > 0 THEN 
+                    ROUND(((b."noteCount" - s.misses) / b."noteCount" * 100)::numeric, 2)
+                ELSE 0
+            END AS accuracy
+        FROM 
+            scores s
+        JOIN 
+            profiles p ON s."userId" = p.id
+        JOIN
+            beatmaps b ON s."beatmapHash" = b."beatmapHash"
+        WHERE 
+            s."beatmapHash" = beatmap_hash
+            AND p.ban <> 'excluded'
+        ORDER BY 
+            s."userId", s.awarded_sp DESC
+    )
+    SELECT *
+    FROM user_top_scores
+    ORDER BY awarded_sp DESC
+    LIMIT 10;
+END;
+$function$

package/queries/get_user_by_email.sql

@@ -0,0 +1,32 @@
+CREATE OR REPLACE FUNCTION public.get_user_by_email(email_address text)
+ RETURNS json
+ LANGUAGE plpgsql
+ SECURITY DEFINER
+ SET search_path TO 'public'
+AS $function$
+DECLARE
+  user_data json;
+BEGIN
+  -- Check that the executing user has permission to access user data
+  -- You can add more permission checks here as needed
+  
+  -- Query the auth.users table to find the user with the matching email
+  SELECT json_build_object(
+    'id', id,
+    'email', email,
+    'created_at', created_at,
+    'last_sign_in_at', last_sign_in_at,
+    'user_metadata', raw_user_meta_data
+    -- Add or remove fields as needed
+  ) INTO user_data
+  FROM auth.users
+  WHERE email = email_address;
+  
+  -- Return NULL if no user was found
+  IF user_data IS NULL THEN
+    RETURN NULL;
+  END IF;
+  
+  RETURN user_data;
+END;
+$function$

package/queries/get_user_scores_lastday.sql

@@ -0,0 +1,36 @@
+CREATE OR REPLACE FUNCTION public.get_user_scores_lastday(userid integer, limit_param integer)
+ RETURNS jsonb
+ LANGUAGE sql
+AS $function$
+  with s as (
+    select *
+    from public.scores
+    where "userId" = userid
+      and passed = true
+    order by created_at desc
+    limit least(limit_param, 100)
+  )
+  select coalesce(
+           jsonb_agg(
+             jsonb_build_object(
+               'created_at',        s.created_at,
+               'id',                s.id,
+               'passed',            s.passed,
+               'userId',            s."userId",
+               'awarded_sp',        s.awarded_sp,
+               'beatmapHash',       s."beatmapHash",
+               'misses',            s.misses,
+               'replay_url',        s.replay_url,
+               'songId',            s."songId",
+               'beatmapDifficulty', b.difficulty,
+               'beatmapNotes',      b."noteCount",
+               'beatmapTitle',      b.title,
+               'speed',             s.speed,
+               'spin',              s.spin
+             )
+           ),
+           '[]'::jsonb
+         )
+  from s
+  left join public.beatmaps b on b."beatmapHash" = s."beatmapHash";
+$function$

package/queries/get_user_scores_reign.sql

@@ -0,0 +1,31 @@
+CREATE OR REPLACE FUNCTION public.get_user_scores_reign(userid integer)
+ RETURNS jsonb
+ LANGUAGE sql
+AS $function$
+  with r as (
+    select * from public.get_user_reigning_scores(userid, 10)
+  )
+  select coalesce(
+           jsonb_agg(
+             jsonb_build_object(
+               'id',            r.id,
+               'awarded_sp',    r.awarded_sp,
+               'created_at',    r.created_at,
+               'misses',        r.misses,
+               'mods',          r.mods,
+               'passed',        r.passed,
+               'replay_url',    s.replay_url,
+               'songId',        r.songid,
+               'speed',         r.speed,
+               'spin',          r.spin,
+               'beatmapHash',   r.beatmaphash,
+               'beatmapTitle',  r.beatmaptitle,
+               'beatmapNotes',  r.notes,
+               'difficulty',    r.difficulty
+             )
+           ),
+           '[]'::jsonb
+         )
+  from r
+  left join public.scores s on s.id = r.id;
+$function$

package/queries/get_user_scores_top_and_stats.sql

@@ -0,0 +1,84 @@
+CREATE OR REPLACE FUNCTION public.get_user_scores_top_and_stats(userid integer, limit_param integer)
+ RETURNS jsonb
+ LANGUAGE plpgsql
+AS $function$
+declare
+  top_json     jsonb := '[]'::jsonb;
+  total_scores int := 0;
+  spin_scores  int := 0;
+begin
+  -- stats
+  select
+    count(*)::int,
+    count(*) filter (where spin = true)::int
+  into total_scores, spin_scores
+  from public.scores s
+  where s."userId" = userid
+    and s.passed = true
+    and s.awarded_sp is not null and s.awarded_sp <> 0;
+
+  -- top
+  with base as (
+    select
+      s.created_at,
+      s.id,
+      s.passed,
+      s."userId",
+      s.awarded_sp,
+      s."beatmapHash",
+      s.misses,
+      s.replay_url,
+      s."songId",
+      s.speed,
+      s.spin
+    from public.scores s
+    where s."userId" = userid
+      and s.passed = true
+      and s.awarded_sp is not null and s.awarded_sp <> 0
+  ),
+  best_per_hash as (
+    select distinct on ("beatmapHash") *
+    from base
+    order by "beatmapHash", awarded_sp desc
+  ),
+  top_rows as (
+    select *
+    from best_per_hash
+    order by awarded_sp desc
+    limit least(limit_param, 100)
+  )
+  select coalesce(
+           jsonb_agg(
+             jsonb_build_object(
+               'created_at',        t.created_at,
+               'id',                t.id,
+               'passed',            t.passed,
+               'userId',            t."userId",
+               'awarded_sp',        t.awarded_sp,
+               'beatmapHash',       t."beatmapHash",
+               'misses',            t.misses,
+               'replay_url',        t.replay_url,
+               'rank',              null, -- keep key for Zod compatibility
+               'songId',            t."songId",
+               'beatmapDifficulty', b.difficulty,
+               'beatmapNotes',      b."noteCount",
+               'beatmapTitle',      b.title,
+               'speed',             t.speed,
+               'spin',              t.spin
+             )
+           ),
+           '[]'::jsonb
+         )
+  into top_json
+  from top_rows t
+  left join public.beatmaps b on b."beatmapHash" = t."beatmapHash";
+
+  return jsonb_build_object(
+    'top',   top_json,
+    'stats', jsonb_build_object(
+               'totalScores', total_scores,
+               'spinScores',  spin_scores
+             )
+  );
+end;
+$function$

package/queries/grant_special_badges.sql

@@ -0,0 +1,69 @@
+CREATE OR REPLACE FUNCTION public.grant_special_badges(p_user_id integer, p_beatmap_id integer, p_spin boolean DEFAULT false, p_passed boolean DEFAULT true)
+ RETURNS json
+ LANGUAGE plpgsql
+ SECURITY DEFINER
+AS $function$
+DECLARE
+  badge_granted JSON := '{"granted": false, "badge": null}';
+  current_badges JSONB;
+  new_badge_name TEXT := NULL;
+BEGIN
+  -- Only proceed if the score was a pass
+  IF NOT p_passed THEN
+    RETURN badge_granted;
+  END IF;
+
+  -- Get current badges from user profile (cast to JSONB)
+  SELECT COALESCE(badges::jsonb, '[]'::jsonb) INTO current_badges
+  FROM profiles 
+  WHERE id = p_user_id;
+
+  -- Check each special map and determine badge to grant
+  CASE p_beatmap_id
+    WHEN 5368 THEN
+      new_badge_name := 'The Start of an Era';
+    WHEN 6178 THEN
+      new_badge_name := 'New Farm';
+    WHEN 4701 THEN
+      -- Spinnin (only if using spin gamestyle)
+      IF p_spin THEN
+        new_badge_name := 'Spinnin';
+      END IF;
+    WHEN 5216 THEN
+      new_badge_name := 'Old Farm';
+    WHEN 4305 THEN
+      new_badge_name := 'Birb';
+    WHEN 5094 THEN
+      new_badge_name := 'Flamingos';
+    WHEN 4285 THEN
+      new_badge_name := 'Cats!';
+    ELSE
+      -- No special badge for this beatmap
+      RETURN badge_granted;
+  END CASE;
+
+  -- If no badge should be granted (e.g., spin condition not met), return
+  IF new_badge_name IS NULL THEN
+    RETURN badge_granted;
+  END IF;
+
+  -- Check if user already has this badge
+  IF current_badges ? new_badge_name THEN
+    -- Badge already exists (using JSONB containment operator)
+    RETURN badge_granted;
+  END IF;
+
+  -- Append new badge to the existing array (both operands are JSONB now)
+  UPDATE profiles 
+  SET badges = (badges::jsonb || jsonb_build_array(new_badge_name))::json
+  WHERE id = p_user_id;
+
+  -- Return success response
+  badge_granted := json_build_object(
+    'granted', true, 
+    'badge', new_badge_name
+  );
+  
+  RETURN badge_granted;
+END;
+$function$