rhythia-api 231.0.0 → 233.0.0

package/api/checkQualified.ts

@@ -2,6 +2,7 @@ import { NextResponse } from "next/server";
 import z from "zod";
 import { protectedApi } from "../utils/requestUtils";
 import { supabase } from "../utils/supabase";
+import { postMapLifecycleWebhook } from "../utils/mapLifecycleWebhook";
 
 const INTERNAL_SECRET = "testing-1";
 const THREE_DAYS_MS = 3 * 24 * 60 * 60 * 1000;
@@ -79,5 +80,14 @@ export async function handler({
     return NextResponse.json({ error: updateError.message, updated: 0 });
   }
 
+  await Promise.allSettled(
+    mapsToRank.map((mapData) =>
+      postMapLifecycleWebhook({
+        mapId: mapData.id,
+        event: "ranked",
+      })
+    )
+  );
+
   return NextResponse.json({ updated: mapsToRank.length });
 }

package/api/enhancedSearch.ts

@@ -0,0 +1,113 @@
+import { NextResponse } from "next/server";
+import z from "zod";
+import { Database } from "../types/database";
+import { protectedApi } from "../utils/requestUtils";
+import { supabase } from "../utils/supabase";
+
+type EnhancedSearchRow =
+  Database["public"]["Functions"]["enhanced_search"]["Returns"][number];
+
+export const Schema = {
+  input: z.strictObject({
+    text: z.string().trim().min(1),
+    limit: z.number().int().min(1).max(25).default(10),
+  }),
+  output: z.object({
+    error: z.string().optional(),
+    users: z.array(
+      z.object({
+        id: z.number(),
+        username: z.string().nullable(),
+        avatar_url: z.string().nullable(),
+        about_me: z.string().nullable(),
+        flag: z.string().nullable(),
+      })
+    ),
+    beatmaps: z.array(
+      z.object({
+        id: z.number(),
+        mapId: z.string().nullable(),
+        title: z.string().nullable(),
+        description: z.string().nullable(),
+        image: z.string().nullable(),
+        starRating: z.number().nullable(),
+        length: z.number().nullable(),
+        status: z.string().nullable(),
+        tags: z.string().nullable(),
+        owner: z.number().nullable(),
+        ownerUsername: z.string().nullable(),
+        ownerAvatar: z.string().nullable(),
+      })
+    ),
+  }),
+};
+
+export async function POST(request: Request): Promise<NextResponse> {
+  return protectedApi({
+    request,
+    schema: Schema,
+    authorization: () => {},
+    activity: handler,
+  });
+}
+
+export async function handler(
+  data: (typeof Schema)["input"]["_type"]
+): Promise<NextResponse<(typeof Schema)["output"]["_type"]>> {
+  const { data: results, error } = await supabase.rpc("enhanced_search", {
+    search_text: data.text,
+    result_limit: data.limit,
+  });
+
+  if (error) {
+    return NextResponse.json(
+      {
+        error: JSON.stringify(error),
+        users: [],
+        beatmaps: [],
+      },
+      { status: 500 }
+    );
+  }
+
+  const users: (typeof Schema)["output"]["_type"]["users"] = [];
+  const beatmaps: (typeof Schema)["output"]["_type"]["beatmaps"] = [];
+
+  for (const result of (results || []) as EnhancedSearchRow[]) {
+    if (result.result_type === "user" && result.user_id !== null) {
+      users.push({
+        id: result.user_id,
+        username: result.user_username,
+        avatar_url: result.user_avatar_url,
+        about_me: result.user_about_me,
+        flag: result.user_flag,
+      });
+      continue;
+    }
+
+    if (
+      result.result_type === "beatmap" &&
+      result.beatmap_page_id !== null
+    ) {
+      beatmaps.push({
+        id: result.beatmap_page_id,
+        mapId: result.beatmap_map_id,
+        title: result.beatmap_title,
+        description: result.beatmap_description,
+        image: result.beatmap_image,
+        starRating: result.beatmap_star_rating,
+        length: result.beatmap_length,
+        status: result.beatmap_status,
+        tags: result.beatmap_tags,
+        owner: result.beatmap_owner,
+        ownerUsername: result.beatmap_owner_username,
+        ownerAvatar: result.beatmap_owner_avatar,
+      });
+    }
+  }
+
+  return NextResponse.json({
+    users,
+    beatmaps,
+  });
+}

package/api/qualifyMap.ts

@@ -4,6 +4,7 @@ import { protectedApi, validUser } from "../utils/requestUtils";
 import { supabase } from "../utils/supabase";
 import { getUserBySession } from "../utils/getUserBySession";
 import { User } from "@supabase/supabase-js";
+import { postMapLifecycleWebhook } from "../utils/mapLifecycleWebhook";
 
 const QUALIFY_BADGES = ["Team Ranked"];
 
@@ -82,5 +83,10 @@ export async function handler(data: (typeof Schema)["input"]["_type"]) {
     return NextResponse.json({ error: updateError.message });
   }
 
+  await postMapLifecycleWebhook({
+    mapId: data.mapId,
+    event: "qualified",
+  });
+
   return NextResponse.json({ qualifiedAt });
 }

package/api/rankMapsArchive.ts

@@ -1,9 +1,10 @@
 import { NextResponse } from "next/server";
 import z from "zod";
-import { protectedApi, validUser } from "../utils/requestUtils";
-import { supabase } from "../utils/supabase";
-import { getUserBySession } from "../utils/getUserBySession";
-import { User } from "@supabase/supabase-js";
+import { protectedApi, validUser } from "../utils/requestUtils";
+import { supabase } from "../utils/supabase";
+import { getUserBySession } from "../utils/getUserBySession";
+import { User } from "@supabase/supabase-js";
+import { postMapLifecycleWebhook } from "../utils/mapLifecycleWebhook";
 
 export const Schema = {
   input: z.strictObject({
@@ -58,14 +59,20 @@ export async function handler(data: (typeof Schema)["input"]["_type"]) {
     return NextResponse.json({ error: "Bad map" });
   }
 
-  for (const element of mapData) {
-    await supabase.from("beatmapPages").upsert({
-      id: element.id,
-      nominations: [queryUserData.id, queryUserData.id],
-      status: "RANKED",
-      ranked_at: Date.now(),
-    });
-  }
+  for (const element of mapData) {
+    await supabase.from("beatmapPages").upsert({
+      id: element.id,
+      nominations: [queryUserData.id, queryUserData.id],
+      status: "RANKED",
+      ranked_at: Date.now(),
+      qualified: false,
+      qualifiedAt: null,
+    });
+    await postMapLifecycleWebhook({
+      mapId: element.id,
+      event: "ranked",
+    });
+  }
 
   return NextResponse.json({});
 }

package/api/vetoMap.ts

@@ -4,6 +4,7 @@ import { protectedApi, validUser } from "../utils/requestUtils";
 import { supabase } from "../utils/supabase";
 import { getUserBySession } from "../utils/getUserBySession";
 import { User } from "@supabase/supabase-js";
+import { postMapLifecycleWebhook } from "../utils/mapLifecycleWebhook";
 
 const VETO_BADGES = ["Team Ranked"];
 
@@ -90,5 +91,11 @@ export async function handler(data: (typeof Schema)["input"]["_type"]) {
     return NextResponse.json({ error: updateError.message });
   }
 
+  await postMapLifecycleWebhook({
+    mapId: data.mapId,
+    event: "vetoed",
+    vetoReason: data.reason,
+  });
+
   return NextResponse.json({});
 }

package/index.ts

@@ -308,6 +308,47 @@ import { Schema as EditProfile } from "./api/editProfile"
 export { Schema as SchemaEditProfile } from "./api/editProfile"
 export const editProfile = handleApi({url:"/api/editProfile",...EditProfile})
 
+// ./api/enhancedSearch.ts API
+
+/*
+export const Schema = {
+  input: z.strictObject({
+    text: z.string().trim().min(1),
+    limit: z.number().int().min(1).max(25).default(10),
+  }),
+  output: z.object({
+    error: z.string().optional(),
+    users: z.array(
+      z.object({
+        id: z.number(),
+        username: z.string().nullable(),
+        avatar_url: z.string().nullable(),
+        about_me: z.string().nullable(),
+        flag: z.string().nullable(),
+      })
+    ),
+    beatmaps: z.array(
+      z.object({
+        id: z.number(),
+        mapId: z.string().nullable(),
+        title: z.string().nullable(),
+        description: z.string().nullable(),
+        image: z.string().nullable(),
+        starRating: z.number().nullable(),
+        length: z.number().nullable(),
+        status: z.string().nullable(),
+        tags: z.string().nullable(),
+        owner: z.number().nullable(),
+        ownerUsername: z.string().nullable(),
+        ownerAvatar: z.string().nullable(),
+      })
+    ),
+  }),
+};*/
+import { Schema as EnhancedSearch } from "./api/enhancedSearch"
+export { Schema as SchemaEnhancedSearch } from "./api/enhancedSearch"
+export const enhancedSearch = handleApi({url:"/api/enhancedSearch",...EnhancedSearch})
+
 // ./api/executeAdminOperation.ts API
 
 /*

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rhythia-api",
-  "version": "231.0.0",
+  "version": "233.0.0",
   "main": "index.ts",
   "author": "online-contributors-cunev",
   "scripts": {

package/queries/enhanced_search.sql

@@ -0,0 +1,217 @@
+CREATE OR REPLACE FUNCTION public.enhanced_search(search_text text, result_limit integer DEFAULT 10)
+ RETURNS TABLE(result_type text, relevance double precision, user_id integer, user_username text, user_avatar_url text, user_about_me text, user_flag text, beatmap_page_id integer, beatmap_map_id text, beatmap_title text, beatmap_description text, beatmap_image text, beatmap_star_rating double precision, beatmap_length double precision, beatmap_status text, beatmap_tags text, beatmap_owner integer, beatmap_owner_username text, beatmap_owner_avatar text)
+ LANGUAGE sql
+ STABLE
+AS $function$
+  WITH raw_params AS (
+    SELECT
+      NULLIF(BTRIM(search_text), '') AS raw_search,
+      GREATEST(COALESCE(result_limit, 10), 1) AS limited_result_count
+  ),
+  params AS (
+    SELECT
+      raw_search,
+      LOWER(raw_search) AS lower_search,
+      raw_search || '%' AS prefix_search,
+      '%' || raw_search || '%' AS contains_search,
+      CASE
+        WHEN raw_search IS NULL THEN NULL
+        ELSE plainto_tsquery('simple', raw_search)
+      END AS ts_query,
+      limited_result_count
+    FROM raw_params
+  ),
+  user_base AS (
+    SELECT
+      p.id,
+      p.username,
+      p."computedUsername" AS computed_username,
+      p.avatar_url,
+      p.about_me,
+      p.flag,
+      COALESCE(p.badges::text, '') AS badges_text,
+      setweight(to_tsvector('simple', COALESCE(p.username, '')), 'A') ||
+      setweight(to_tsvector('simple', COALESCE(p."computedUsername", '')), 'A') ||
+      setweight(to_tsvector('simple', COALESCE(p.about_me, '')), 'B') ||
+      setweight(to_tsvector('simple', COALESCE(p.flag, '')), 'C') ||
+      setweight(to_tsvector('simple', COALESCE(p.badges::text, '')), 'C') AS search_vector
+    FROM public.profiles p
+    WHERE p.ban IS DISTINCT FROM 'excluded'
+  ),
+  user_scored AS (
+    SELECT
+      'user'::text AS result_type,
+      (
+        CASE WHEN u.id::text = params.raw_search THEN 250 ELSE 0 END +
+        CASE WHEN COALESCE(u.username, '') = params.raw_search THEN 220 ELSE 0 END +
+        CASE WHEN COALESCE(u.computed_username, '') = params.lower_search THEN 215 ELSE 0 END +
+        CASE WHEN LOWER(COALESCE(u.username, '')) = params.lower_search THEN 210 ELSE 0 END +
+        CASE WHEN COALESCE(u.username, '') ILIKE params.prefix_search THEN 160 ELSE 0 END +
+        CASE WHEN COALESCE(u.computed_username, '') ILIKE params.prefix_search THEN 150 ELSE 0 END +
+        CASE WHEN COALESCE(u.username, '') ILIKE params.contains_search THEN 90 ELSE 0 END +
+        CASE WHEN COALESCE(u.computed_username, '') ILIKE params.contains_search THEN 85 ELSE 0 END +
+        CASE WHEN COALESCE(u.about_me, '') ILIKE params.contains_search THEN 25 ELSE 0 END +
+        CASE WHEN COALESCE(u.flag, '') ILIKE params.prefix_search THEN 20 ELSE 0 END +
+        CASE WHEN u.badges_text ILIKE params.contains_search THEN 15 ELSE 0 END +
+        CASE
+          WHEN params.ts_query IS NULL THEN 0
+          ELSE ts_rank_cd(u.search_vector, params.ts_query) * 100
+        END
+      )::double precision AS relevance,
+      u.id AS user_id,
+      u.username AS user_username,
+      u.avatar_url AS user_avatar_url,
+      u.about_me AS user_about_me,
+      u.flag AS user_flag,
+      NULL::integer AS beatmap_page_id,
+      NULL::text AS beatmap_map_id,
+      NULL::text AS beatmap_title,
+      NULL::text AS beatmap_description,
+      NULL::text AS beatmap_image,
+      NULL::double precision AS beatmap_star_rating,
+      NULL::double precision AS beatmap_length,
+      NULL::text AS beatmap_status,
+      NULL::text AS beatmap_tags,
+      NULL::integer AS beatmap_owner,
+      NULL::text AS beatmap_owner_username,
+      NULL::text AS beatmap_owner_avatar
+    FROM user_base u
+    CROSS JOIN params
+    WHERE params.raw_search IS NOT NULL
+      AND (
+        u.id::text = params.raw_search
+        OR COALESCE(u.username, '') ILIKE params.contains_search
+        OR COALESCE(u.computed_username, '') ILIKE params.contains_search
+        OR COALESCE(u.about_me, '') ILIKE params.contains_search
+        OR COALESCE(u.flag, '') ILIKE params.contains_search
+        OR u.badges_text ILIKE params.contains_search
+        OR (params.ts_query IS NOT NULL AND u.search_vector @@ params.ts_query)
+      )
+  ),
+  limited_users AS (
+    SELECT *
+    FROM user_scored
+    WHERE relevance > 0
+    ORDER BY relevance DESC, user_username NULLS LAST, user_id
+    LIMIT (SELECT limited_result_count FROM params)
+  ),
+  beatmap_base AS (
+    SELECT
+      bp.id,
+      bp."latestBeatmapHash" AS map_id,
+      COALESCE(b.title, bp.title) AS display_title,
+      bp.description,
+      bp.tags,
+      bp.genre,
+      bp.status,
+      bp.owner,
+      p.username AS owner_username,
+      p.avatar_url AS owner_avatar_url,
+      b.image,
+      b."starRating"::double precision AS star_rating,
+      b.length::double precision AS beatmap_length,
+      COALESCE(b."beatmapFile", '') AS beatmap_file,
+      COALESCE(b."beatmapHash", '') AS beatmap_hash,
+      COALESCE(b.difficulty::text, '') AS difficulty_text,
+      COALESCE(b."noteCount"::text, '') AS note_count_text,
+      COALESCE(b.playcount::text, '') AS playcount_text,
+      setweight(to_tsvector('simple', COALESCE(COALESCE(b.title, bp.title), '')), 'A') ||
+      setweight(to_tsvector('simple', COALESCE(bp.title, '')), 'A') ||
+      setweight(to_tsvector('simple', COALESCE(p.username, '')), 'A') ||
+      setweight(to_tsvector('simple', COALESCE(bp.description, '')), 'B') ||
+      setweight(to_tsvector('simple', COALESCE(bp.tags, '')), 'B') ||
+      setweight(to_tsvector('simple', COALESCE(bp.genre, '')), 'C') ||
+      setweight(to_tsvector('simple', COALESCE(bp.status, '')), 'C') ||
+      setweight(to_tsvector('simple', COALESCE(b."beatmapFile", '')), 'C') ||
+      setweight(to_tsvector('simple', COALESCE(b."beatmapHash", '')), 'A') AS search_vector
+    FROM public."beatmapPages" bp
+    LEFT JOIN public.beatmaps b ON b."beatmapHash" = bp."latestBeatmapHash"
+    LEFT JOIN public.profiles p ON p.id = bp.owner
+  ),
+  beatmap_scored AS (
+    SELECT
+      'beatmap'::text AS result_type,
+      (
+        CASE WHEN bb.id::text = params.raw_search THEN 260 ELSE 0 END +
+        CASE WHEN COALESCE(bb.map_id, '') = params.raw_search THEN 240 ELSE 0 END +
+        CASE WHEN COALESCE(bb.display_title, '') = params.raw_search THEN 220 ELSE 0 END +
+        CASE WHEN LOWER(COALESCE(bb.display_title, '')) = params.lower_search THEN 215 ELSE 0 END +
+        CASE WHEN COALESCE(bb.display_title, '') ILIKE params.prefix_search THEN 160 ELSE 0 END +
+        CASE WHEN COALESCE(bb.display_title, '') ILIKE params.contains_search THEN 90 ELSE 0 END +
+        CASE WHEN COALESCE(bb.owner_username, '') = params.raw_search THEN 80 ELSE 0 END +
+        CASE WHEN COALESCE(bb.owner_username, '') ILIKE params.prefix_search THEN 70 ELSE 0 END +
+        CASE WHEN COALESCE(bb.owner_username, '') ILIKE params.contains_search THEN 50 ELSE 0 END +
+        CASE WHEN COALESCE(bb.tags, '') ILIKE params.contains_search THEN 35 ELSE 0 END +
+        CASE WHEN COALESCE(bb.description, '') ILIKE params.contains_search THEN 25 ELSE 0 END +
+        CASE WHEN COALESCE(bb.genre, '') ILIKE params.contains_search THEN 15 ELSE 0 END +
+        CASE WHEN COALESCE(bb.status, '') ILIKE params.contains_search THEN 15 ELSE 0 END +
+        CASE WHEN COALESCE(bb.beatmap_file, '') ILIKE params.contains_search THEN 15 ELSE 0 END +
+        CASE WHEN COALESCE(bb.beatmap_hash, '') ILIKE params.contains_search THEN 30 ELSE 0 END +
+        CASE WHEN COALESCE(bb.owner::text, '') = params.raw_search THEN 40 ELSE 0 END +
+        CASE WHEN COALESCE(bb.star_rating::text, '') = params.raw_search THEN 20 ELSE 0 END +
+        CASE WHEN COALESCE(bb.beatmap_length::text, '') = params.raw_search THEN 15 ELSE 0 END +
+        CASE WHEN COALESCE(bb.difficulty_text, '') = params.raw_search THEN 10 ELSE 0 END +
+        CASE WHEN COALESCE(bb.note_count_text, '') = params.raw_search THEN 10 ELSE 0 END +
+        CASE WHEN COALESCE(bb.playcount_text, '') = params.raw_search THEN 10 ELSE 0 END +
+        CASE
+          WHEN params.ts_query IS NULL THEN 0
+          ELSE ts_rank_cd(bb.search_vector, params.ts_query) * 110
+        END
+      )::double precision AS relevance,
+      NULL::integer AS user_id,
+      NULL::text AS user_username,
+      NULL::text AS user_avatar_url,
+      NULL::text AS user_about_me,
+      NULL::text AS user_flag,
+      bb.id AS beatmap_page_id,
+      bb.map_id AS beatmap_map_id,
+      bb.display_title AS beatmap_title,
+      bb.description AS beatmap_description,
+      bb.image AS beatmap_image,
+      bb.star_rating AS beatmap_star_rating,
+      bb.beatmap_length AS beatmap_length,
+      bb.status AS beatmap_status,
+      bb.tags AS beatmap_tags,
+      bb.owner AS beatmap_owner,
+      bb.owner_username AS beatmap_owner_username,
+      bb.owner_avatar_url AS beatmap_owner_avatar
+    FROM beatmap_base bb
+    CROSS JOIN params
+    WHERE params.raw_search IS NOT NULL
+      AND (
+        bb.id::text = params.raw_search
+        OR COALESCE(bb.map_id, '') ILIKE params.contains_search
+        OR COALESCE(bb.display_title, '') ILIKE params.contains_search
+        OR COALESCE(bb.description, '') ILIKE params.contains_search
+        OR COALESCE(bb.tags, '') ILIKE params.contains_search
+        OR COALESCE(bb.genre, '') ILIKE params.contains_search
+        OR COALESCE(bb.status, '') ILIKE params.contains_search
+        OR COALESCE(bb.owner_username, '') ILIKE params.contains_search
+        OR COALESCE(bb.beatmap_file, '') ILIKE params.contains_search
+        OR COALESCE(bb.beatmap_hash, '') ILIKE params.contains_search
+        OR COALESCE(bb.owner::text, '') = params.raw_search
+        OR COALESCE(bb.star_rating::text, '') = params.raw_search
+        OR COALESCE(bb.beatmap_length::text, '') = params.raw_search
+        OR COALESCE(bb.difficulty_text, '') = params.raw_search
+        OR COALESCE(bb.note_count_text, '') = params.raw_search
+        OR COALESCE(bb.playcount_text, '') = params.raw_search
+        OR (params.ts_query IS NOT NULL AND bb.search_vector @@ params.ts_query)
+      )
+  ),
+  limited_beatmaps AS (
+    SELECT *
+    FROM beatmap_scored
+    WHERE relevance > 0
+    ORDER BY relevance DESC, beatmap_title NULLS LAST, beatmap_page_id
+    LIMIT (SELECT limited_result_count FROM params)
+  )
+  SELECT *
+  FROM (
+    SELECT *
+    FROM limited_users
+    UNION ALL
+    SELECT *
+    FROM limited_beatmaps
+  ) AS combined_results
+  ORDER BY result_type DESC, relevance DESC, COALESCE(user_username, beatmap_title) NULLS LAST, COALESCE(user_id, beatmap_page_id);
+$function$;

package/types/database.ts

@@ -785,6 +785,30 @@ export type Database = {
       }
       admin_silence_user: { Args: { user_id: number }; Returns: boolean }
       admin_unban_user: { Args: { user_id: number }; Returns: boolean }
+      enhanced_search: {
+        Args: { result_limit?: number; search_text: string }
+        Returns: {
+          beatmap_description: string | null
+          beatmap_image: string | null
+          beatmap_length: number | null
+          beatmap_map_id: string | null
+          beatmap_owner: number | null
+          beatmap_owner_avatar: string | null
+          beatmap_owner_username: string | null
+          beatmap_page_id: number | null
+          beatmap_star_rating: number | null
+          beatmap_status: string | null
+          beatmap_tags: string | null
+          beatmap_title: string | null
+          relevance: number | null
+          result_type: string | null
+          user_about_me: string | null
+          user_avatar_url: string | null
+          user_flag: string | null
+          user_id: number | null
+          user_username: string | null
+        }[]
+      }
       get_badge_leaderboard: {
         Args: { p_limit?: number }
         Returns: {

package/utils/mapLifecycleWebhook.ts

@@ -0,0 +1,277 @@
+import { supabase } from "./supabase";
+
+type MapLifecycleEvent = "qualified" | "ranked" | "vetoed";
+
+const WEBHOOK_COLORS: Record<MapLifecycleEvent, number> = {
+  qualified: 0x3498db,
+  ranked: 0x2ecc71,
+  vetoed: 0xe74c3c,
+};
+
+const WEBHOOK_TITLES: Record<MapLifecycleEvent, string> = {
+  qualified: "Map Qualified",
+  ranked: "Map Ranked",
+  vetoed: "Map Vetoed",
+};
+
+const WEBHOOK_MESSAGES: Record<MapLifecycleEvent, string> = {
+  qualified: "A fresh map just reached qualification.",
+  ranked: "This map cleared qualification and is now ranked.",
+  vetoed: "This map was vetoed and sent back for improvements.",
+};
+
+function clampText(value: string, maxLength: number) {
+  const sanitized = value.replace(/[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F]/g, "");
+
+  if (sanitized.length <= maxLength) {
+    return sanitized;
+  }
+
+  if (maxLength <= 3) {
+    return sanitized.slice(0, maxLength);
+  }
+
+  return `${sanitized.slice(0, maxLength - 3)}...`;
+}
+
+function getSafeHttpUrl(value: string | null | undefined) {
+  if (!value) {
+    return null;
+  }
+
+  try {
+    const parsed = new URL(value.trim());
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+      return null;
+    }
+    const serialized = parsed.toString();
+    if (serialized.length > 2048) {
+      return null;
+    }
+    return serialized;
+  } catch {
+    return null;
+  }
+}
+
+function formatLength(milliseconds: number | null | undefined) {
+  if (!milliseconds || milliseconds < 0) {
+    return "-";
+  }
+
+  const totalSeconds = Math.floor(milliseconds / 1000);
+  const minutes = Math.floor(totalSeconds / 60);
+  const seconds = totalSeconds % 60;
+  return `${minutes.toString().padStart(2, "0")}:${seconds
+    .toString()
+    .padStart(2, "0")}`;
+}
+
+export async function postMapLifecycleWebhook({
+  mapId,
+  event,
+  vetoReason,
+}: {
+  mapId: number;
+  event: MapLifecycleEvent;
+  vetoReason?: string;
+}) {
+  const webhookUrl = process.env.WEBHOOK_MSG_DISCORD;
+  if (!webhookUrl) {
+    return;
+  }
+
+  try {
+    const { data: beatmapPage } = await supabase
+      .from("beatmapPages")
+      .select(
+        `
+        id,
+        owner,
+        title,
+        tags,
+        status,
+        qualified,
+        qualifiedAt,
+        beatmaps (
+          title,
+          starRating,
+          length,
+          difficulty,
+          noteCount,
+          image,
+          imageLarge
+        ),
+        profiles (
+          id,
+          username,
+          avatar_url
+        )
+      `
+      )
+      .eq("id", mapId)
+      .single();
+
+    if (!beatmapPage) {
+      return;
+    }
+
+    const beatmapData = (beatmapPage as any).beatmaps;
+    const profileData = (beatmapPage as any).profiles;
+    const mapTitle =
+      beatmapData?.title || beatmapPage.title || `Beatmap Page #${mapId}`;
+    const creatorName = profileData?.username || "Unknown";
+    const creatorId = beatmapPage.owner || profileData?.id || 0;
+    const rawImage =
+      beatmapData?.imageLarge || beatmapData?.image || "https://www.rhythia.com/unkimg.png";
+    const mapImage = rawImage.includes("backfill")
+      ? "https://www.rhythia.com/unkimg.png"
+      : rawImage;
+    const safeMapImageUrl = getSafeHttpUrl(mapImage);
+    const safeAvatarUrl = getSafeHttpUrl(profileData?.avatar_url);
+
+    const fields: Array<{ name: string; value: string; inline?: boolean }> = [
+      {
+        name: "Map ID",
+        value: clampText(`${beatmapPage.id}`, 1024),
+        inline: true,
+      },
+      {
+        name: "Creator",
+        value: clampText(creatorName, 1024),
+        inline: true,
+      },
+      {
+        name: "Stars",
+        value: clampText(
+          beatmapData?.starRating !== null && beatmapData?.starRating !== undefined
+            ? `${Math.round(beatmapData.starRating * 100) / 100}*`
+            : "-",
+          1024
+        ),
+        inline: true,
+      },
+      {
+        name: "Length",
+        value: clampText(formatLength(beatmapData?.length), 1024),
+        inline: true,
+      },
+      {
+        name: "Notes",
+        value: clampText(
+          beatmapData?.noteCount !== null && beatmapData?.noteCount !== undefined
+            ? `${beatmapData.noteCount}`
+            : "-",
+          1024
+        ),
+        inline: true,
+      },
+      {
+        name: "Tags",
+        value: clampText(beatmapPage.tags || "-", 1024),
+        inline: false,
+      },
+    ];
+
+    if (event === "vetoed") {
+      fields.push({
+        name: "Veto Reason",
+        value: clampText(vetoReason || "No reason provided", 1024),
+        inline: false,
+      });
+    }
+
+    const embed: Record<string, any> = {
+      title: clampText(`${WEBHOOK_TITLES[event]}: ${mapTitle}`, 256),
+      url: `https://www.rhythia.com/maps/${beatmapPage.id}`,
+      description: clampText(WEBHOOK_MESSAGES[event], 4096),
+      color: WEBHOOK_COLORS[event],
+      fields: fields.map((field) => ({
+        ...field,
+        name: clampText(field.name || "-", 256),
+        value: clampText(field.value || "-", 1024),
+      })),
+      author: {
+        name: clampText(creatorName, 256),
+        url: `https://www.rhythia.com/player/${creatorId}`,
+        icon_url: safeAvatarUrl || "https://www.rhythia.com/unkimg.png",
+      },
+      footer: {
+        text: clampText(
+          `Status: ${beatmapPage.status || "-"} | ${new Date().toUTCString()}`,
+          2048
+        ),
+      },
+    };
+
+    if (safeMapImageUrl) {
+      embed.thumbnail = {
+        url: safeMapImageUrl,
+      };
+    }
+
+    const payload = {
+      content: clampText(WEBHOOK_MESSAGES[event], 2000),
+      embeds: [embed],
+    };
+
+    let response = await fetch(webhookUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify(payload),
+    });
+
+    if (
+      !response.ok &&
+      response.status === 400 &&
+      (payload.embeds?.[0]?.image?.url || payload.embeds?.[0]?.thumbnail?.url)
+    ) {
+      // Most common Discord embed 400 here is a bad media URL. Retry without media.
+      const retryPayload = {
+        ...payload,
+        embeds: payload.embeds.map((embed: any) => {
+          const clone = { ...embed };
+          delete clone.image;
+          delete clone.thumbnail;
+          return clone;
+        }),
+      };
+
+      response = await fetch(webhookUrl, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify(retryPayload),
+      });
+    }
+
+    if (!response.ok) {
+      const responseBody = await response.text();
+      console.log("Discord webhook failed", {
+        event,
+        mapId,
+        status: response.status,
+        statusText: response.statusText,
+        responseBody: clampText(responseBody || "-", 4000),
+        payloadPreview: {
+          content: payload.content,
+          title: payload.embeds?.[0]?.title,
+          fields: payload.embeds?.[0]?.fields?.map((field: any) => ({
+            name: field.name,
+            value: clampText(field.value || "-", 120),
+          })),
+          imageUrl: payload.embeds?.[0]?.image?.url || null,
+          thumbnailUrl: payload.embeds?.[0]?.thumbnail?.url || null,
+          authorIconUrl: payload.embeds?.[0]?.author?.icon_url || null,
+          hasImage: Boolean(payload.embeds?.[0]?.image?.url),
+          hasThumbnail: Boolean(payload.embeds?.[0]?.thumbnail?.url),
+        },
+      });
+    }
+  } catch (error) {
+    console.log("Failed to post map lifecycle webhook", error);
+  }
+}