From ea8be061229891508f9e5aaa3e4dbd886665301d Mon Sep 17 00:00:00 2001 From: Ayberk Alcan Date: Sat, 7 Nov 2026 21:58:39 +0300 Subject: [PATCH 01/11] Give servers their players' personal bests on a map in one request A server skips submitting runs that aren't faster than the player's SourceJump PB (docs/domain.md), but reading those meant one leaderboard request per player, style and track on every map change. GET /v1/maps/{map}/personal-bests?players= takes up to 64 SteamID64s and answers every style and track at once, with each best's rank, under the same ETag as the map's records. docs/api.md drops three sentences that repeat other docs, to stay within its size budget. --- ...877fd56c32b625c17faa483739ead4c3c3a1b.json | 91 ++++++++ api/contract/maps-personal-bests.json | 28 +++ api/crates/api/src/contract.rs | 10 +- api/crates/api/src/records.rs | 8 +- api/crates/api/src/records/personal_bests.rs | 214 ++++++++++++++++++ api/openapi.json | 113 +++++++++ docs/api.md | 11 +- web/src/api/schema.ts | 86 +++++++ 8 files changed, 552 insertions(+), 9 deletions(-) create mode 100644 api/.sqlx/query-d50668dfc10a377af5ec4507105877fd56c32b625c17faa483739ead4c3c3a1b.json create mode 100644 api/contract/maps-personal-bests.json create mode 100644 api/crates/api/src/records/personal_bests.rs diff --git a/api/.sqlx/query-d50668dfc10a377af5ec4507105877fd56c32b625c17faa483739ead4c3c3a1b.json b/api/.sqlx/query-d50668dfc10a377af5ec4507105877fd56c32b625c17faa483739ead4c3c3a1b.json new file mode 100644 index 0000000..4c70ab6 --- /dev/null +++ b/api/.sqlx/query-d50668dfc10a377af5ec4507105877fd56c32b625c17faa483739ead4c3c3a1b.json @@ -0,0 +1,91 @@ +{ + "db_name": "PostgreSQL", + "query": "\n SELECT pb.player_steamid64::text AS \"steamid64!\", pb.style, pb.track, pb.time, pb.run_id,\n pb.finished_at,\n 1 + (SELECT count(*) FROM personal_bests faster\n WHERE faster.map_id = pb.map_id AND faster.style = pb.style AND faster.track = pb.track\n AND faster.time < pb.time) AS \"rank!\"\n FROM personal_bests pb\n JOIN maps m ON m.id = pb.map_id\n WHERE m.name = $1 AND pb.player_steamid64 = ANY($2)\n ORDER BY pb.player_steamid64, pb.style, pb.track\n ", + "describe": { + "columns": [ + { + "ordinal": 0, + "name": "steamid64!", + "type_info": "Text", + "origin": "Expression" + }, + { + "ordinal": 1, + "name": "style", + "type_info": "Text", + "origin": { + "Table": { + "table": "personal_bests", + "name": "style" + } + } + }, + { + "ordinal": 2, + "name": "track", + "type_info": "Int2", + "origin": { + "Table": { + "table": "personal_bests", + "name": "track" + } + } + }, + { + "ordinal": 3, + "name": "time", + "type_info": "Float8", + "origin": { + "Table": { + "table": "personal_bests", + "name": "time" + } + } + }, + { + "ordinal": 4, + "name": "run_id", + "type_info": "Int8", + "origin": { + "Table": { + "table": "personal_bests", + "name": "run_id" + } + } + }, + { + "ordinal": 5, + "name": "finished_at", + "type_info": "Timestamptz", + "origin": { + "Table": { + "table": "personal_bests", + "name": "finished_at" + } + } + }, + { + "ordinal": 6, + "name": "rank!", + "type_info": "Int8", + "origin": "Expression" + } + ], + "parameters": { + "Left": [ + "Text", + "Int8Array" + ] + }, + "nullable": [ + null, + false, + false, + false, + false, + false, + null + ] + }, + "hash": "d50668dfc10a377af5ec4507105877fd56c32b625c17faa483739ead4c3c3a1b" +} diff --git a/api/contract/maps-personal-bests.json b/api/contract/maps-personal-bests.json new file mode 100644 index 0000000..7b05fda --- /dev/null +++ b/api/contract/maps-personal-bests.json @@ -0,0 +1,28 @@ +{ + "method": "GET", + "path": "/v1/maps/bhop_badges/personal-bests?players=76561197960287930,76561197960287931", + "status": 200, + "response": { + "map": "bhop_badges", + "personal_bests": [ + { + "steamid64": "76561197960287930", + "style": "normal", + "track": 0, + "time": 42.42, + "rank": 1, + "run_id": 1, + "finished_at": "2026-10-19T08:53:20Z" + }, + { + "steamid64": "76561197960287930", + "style": "normal", + "track": 1, + "time": 12.5, + "rank": 3, + "run_id": 2, + "finished_at": "2026-10-19T08:55:00Z" + } + ] + } +} diff --git a/api/crates/api/src/contract.rs b/api/crates/api/src/contract.rs index a64446c..0e7697c 100644 --- a/api/crates/api/src/contract.rs +++ b/api/crates/api/src/contract.rs @@ -9,13 +9,14 @@ use sqlx::PgPool; use crate::{ anticheat::DetectionAccepted, error::ErrorBody, plugin_releases::PluginRelease, - record_events::RecordEvents, records::MapRecords, ruleset::Ruleset, runs::RunAccepted, + record_events::RecordEvents, records::MapRecords, + records::personal_bests::PlayersPersonalBests, ruleset::Ruleset, runs::RunAccepted, servers::heartbeat::HeartbeatResponse, servers::keys, test_client, zones::Zone, }; type ResponseCheck = fn(&str, &Value); -const EXAMPLES: [(&str, &str, ResponseCheck); 9] = [ +const EXAMPLES: [(&str, &str, ResponseCheck); 10] = [ ( "ruleset", include_str!("../../../contract/ruleset.json"), @@ -41,6 +42,11 @@ const EXAMPLES: [(&str, &str, ResponseCheck); 9] = [ include_str!("../../../contract/maps-records.json"), round_trips::, ), + ( + "maps-personal-bests", + include_str!("../../../contract/maps-personal-bests.json"), + round_trips::, + ), ( "records-events", include_str!("../../../contract/records-events.json"), diff --git a/api/crates/api/src/records.rs b/api/crates/api/src/records.rs index 166f0bb..f738e8f 100644 --- a/api/crates/api/src/records.rs +++ b/api/crates/api/src/records.rs @@ -1,5 +1,7 @@ //! A map's records, `GET /v1/maps/{map}/records`: the top personal bests per style and track, for the -//! plugin's in-game records display. +//! plugin's in-game records display. Connected players' own bests on the map are in `records/personal_bests.rs`. + +pub mod personal_bests; use axum::{ Json, @@ -54,9 +56,11 @@ pub struct Record { } pub fn routes() -> OpenApiRouter { - // Servers check a map's records on every map change; most of the time nothing's new. + // Servers check a map's records and their players' personal bests on every map change; most of the time + // nothing's new. OpenApiRouter::new() .routes(routes!(map_records)) + .routes(routes!(personal_bests::players_personal_bests)) .layer(axum::middleware::from_fn(crate::etag::conditional)) } diff --git a/api/crates/api/src/records/personal_bests.rs b/api/crates/api/src/records/personal_bests.rs new file mode 100644 index 0000000..6013c87 --- /dev/null +++ b/api/crates/api/src/records/personal_bests.rs @@ -0,0 +1,214 @@ +//! Players' personal bests on one map, `GET /v1/maps/{map}/personal-bests?players=`: what a game server reads +//! on map change for everyone connected, so it skips submitting runs that aren't faster than the player's +//! SourceJump PB (`docs/domain.md`). One request covers every player, style and track, instead of one per +//! leaderboard. + +use axum::{ + Json, + extract::{Path, Query, State}, +}; +use chrono::{DateTime, Utc}; +use serde::{Deserialize, Serialize}; +use utoipa::{IntoParams, ToSchema}; + +use crate::{ + app::AppState, + error::{ApiError, ErrorBody}, + maps::MapName, + players::SteamId64, +}; + +/// A server holds at most 64 players, so one request covers everyone on it. +const MAX_PLAYERS: usize = 64; + +#[derive(Debug, Deserialize, IntoParams)] +pub struct PersonalBestsQuery { + /// Players by SteamID64, comma-separated: 1 to 64 of them. Repeats count once. + players: String, +} + +#[derive(Debug, Serialize, Deserialize, ToSchema)] +pub struct PlayersPersonalBests { + pub map: String, + /// Sorted by player, style and track. A player with no personal best on the map has no entries. One flat + /// list keeps it simple to read in SourcePawn. + pub personal_bests: Vec, +} + +#[derive(Debug, Serialize, Deserialize, ToSchema)] +pub struct PlayerPersonalBest { + /// SteamID64, as a string. + pub steamid64: String, + pub style: String, + /// 0 is the main track, 1 and up are bonuses. + pub track: i16, + /// Seconds. + pub time: f64, + /// Place on the leaderboard; equal times share a place, as in `…/records`. + pub rank: i64, + pub run_id: i64, + pub finished_at: DateTime, +} + +/// These players' SourceJump personal bests on the map, every style and track. An unknown map, or players +/// without runs on it, give an empty list. +#[utoipa::path( + get, + path = "/v1/maps/{map}/personal-bests", + tag = "maps", + params(("map" = String, Path, description = "Map name"), PersonalBestsQuery), + responses( + (status = OK, body = PlayersPersonalBests), + (status = UNPROCESSABLE_ENTITY, description = "Not a valid map name, or `players` isn't 1 to 64 SteamID64s", body = ErrorBody), + ), +)] +pub async fn players_personal_bests( + State(state): State, + Path(map): Path, + Query(query): Query, +) -> Result, ApiError> { + let map = MapName::try_from(map).map_err(ApiError::Invalid)?; + let players = parse_players(&query.players).map_err(ApiError::Invalid)?; + + // A place is one more than the faster personal bests on the board, read from its index; a slow player on a + // big board counts more entries, but never more than the board holds. + let personal_bests = sqlx::query_as!( + PlayerPersonalBest, + r#" + SELECT pb.player_steamid64::text AS "steamid64!", pb.style, pb.track, pb.time, pb.run_id, + pb.finished_at, + 1 + (SELECT count(*) FROM personal_bests faster + WHERE faster.map_id = pb.map_id AND faster.style = pb.style AND faster.track = pb.track + AND faster.time < pb.time) AS "rank!" + FROM personal_bests pb + JOIN maps m ON m.id = pb.map_id + WHERE m.name = $1 AND pb.player_steamid64 = ANY($2) + ORDER BY pb.player_steamid64, pb.style, pb.track + "#, + map.as_str(), + &players + ) + .fetch_all(&state.db) + .await?; + + Ok(Json(PlayersPersonalBests { + map: map.into(), + personal_bests, + })) +} + +/// Each player named in `players`, once. +fn parse_players(players: &str) -> Result, String> { + let mut parsed = Vec::new(); + for text in players.split(',') { + let steamid64 = SteamId64::try_from(text.trim().to_owned())?.get(); + if !parsed.contains(&steamid64) { + parsed.push(steamid64); + } + } + if parsed.len() > MAX_PLAYERS { + return Err(format!("players takes at most {MAX_PLAYERS} SteamID64s")); + } + Ok(parsed) +} + +#[cfg(test)] +mod tests { + use serde_json::json; + use sqlx::PgPool; + + use super::{MAX_PLAYERS, PlayersPersonalBests, parse_players}; + use crate::{ + error::ErrorBody, + runs::tests::{run, setup}, + test_client, + }; + + const GABE: &str = "76561197960287930"; + const SECOND: &str = "76561197960287931"; + const THIRD: &str = "76561197960287932"; + + #[sqlx::test] + async fn lists_each_players_bests_with_their_place(db: PgPool) { + let key = setup(&db).await; + let mut second = run("b", 29.0); + second["player"] = json!({ "steamid64": SECOND, "name": "second" }); + let mut third = run("c", 29.0); + third["player"] = json!({ "steamid64": THIRD, "name": "third" }); + let mut bonus = run("d", 50.0); + bonus["track"] = json!(1); + let mut elsewhere = run("e", 10.0); + elsewhere["map"] = json!("bhop_other"); + for body in [run("a", 30.0), second, third, bonus, elsewhere] { + let status = test_client::post(&db, "/v1/runs", Some(&key), &body) + .await + .status; + assert_eq!(status, 201); + } + + let answer: PlayersPersonalBests = test_client::get( + &db, + &format!("/v1/maps/bhop_badges/personal-bests?players={GABE},{THIRD},{GABE}"), + ) + .await + .json(); + + assert_eq!(answer.map, "bhop_badges"); + let summary: Vec<_> = answer + .personal_bests + .iter() + .map(|pb| (pb.steamid64.as_str(), pb.track, pb.time, pb.rank)) + .collect(); + // The two 29s share first place; the 30 is third. The run on another map isn't listed. + assert_eq!( + summary, + [(GABE, 0, 30.0, 3), (GABE, 1, 50.0, 1), (THIRD, 0, 29.0, 1)] + ); + } + + #[sqlx::test] + async fn an_unknown_map_or_a_player_without_runs_gives_an_empty_list(db: PgPool) { + let key = setup(&db).await; + test_client::post(&db, "/v1/runs", Some(&key), &run("a", 30.0)).await; + + for path in [ + format!("/v1/maps/bhop_none/personal-bests?players={GABE}"), + format!("/v1/maps/bhop_badges/personal-bests?players={SECOND}"), + ] { + let answer: PlayersPersonalBests = test_client::get(&db, &path).await.json(); + assert!(answer.personal_bests.is_empty(), "{path}"); + } + } + + #[sqlx::test] + async fn refuses_anything_but_1_to_64_steamid64s(db: PgPool) { + let too_many = (0..=MAX_PLAYERS as u64) + .map(|n| (76_561_197_960_287_930 + n).to_string()) + .collect::>() + .join(","); + for players in ["", "STEAM_0:0:1", "76561197960287930,,", too_many.as_str()] { + let response = test_client::get( + &db, + &format!("/v1/maps/bhop_badges/personal-bests?players={players}"), + ) + .await; + assert_eq!(response.status, 422, "{players}"); + let _: ErrorBody = response.json(); + } + assert_eq!( + test_client::get(&db, "/v1/maps/bhop_badges/personal-bests") + .await + .status, + 400, + "players is required" + ); + } + + #[test] + fn repeats_count_once() { + assert_eq!( + parse_players("76561197960287930, 76561197960287930").unwrap(), + [76_561_197_960_287_930] + ); + } +} diff --git a/api/openapi.json b/api/openapi.json index 91d277d..08f66a9 100644 --- a/api/openapi.json +++ b/api/openapi.json @@ -861,6 +861,56 @@ } } }, + "/v1/maps/{map}/personal-bests": { + "get": { + "tags": [ + "maps" + ], + "summary": "These players' SourceJump personal bests on the map, every style and track. An unknown map, or players\nwithout runs on it, give an empty list.", + "operationId": "players_personal_bests", + "parameters": [ + { + "name": "map", + "in": "path", + "description": "Map name", + "required": true, + "schema": { + "type": "string" + } + }, + { + "name": "players", + "in": "query", + "description": "Players by SteamID64, comma-separated: 1 to 64 of them. Repeats count once.", + "required": true, + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/PlayersPersonalBests" + } + } + } + }, + "422": { + "description": "Not a valid map name, or `players` isn't 1 to 64 SteamID64s", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/ErrorBody" + } + } + } + } + } + } + }, "/v1/maps/{map}/records": { "get": { "tags": [ @@ -8094,6 +8144,50 @@ } } }, + "PlayerPersonalBest": { + "type": "object", + "required": [ + "steamid64", + "style", + "track", + "time", + "rank", + "run_id", + "finished_at" + ], + "properties": { + "finished_at": { + "type": "string", + "format": "date-time" + }, + "rank": { + "type": "integer", + "format": "int64", + "description": "Place on the leaderboard; equal times share a place, as in `…/records`." + }, + "run_id": { + "type": "integer", + "format": "int64" + }, + "steamid64": { + "type": "string", + "description": "SteamID64, as a string." + }, + "style": { + "type": "string" + }, + "time": { + "type": "number", + "format": "double", + "description": "Seconds." + }, + "track": { + "type": "integer", + "format": "int32", + "description": "0 is the main track, 1 and up are bonuses." + } + } + }, "PlayerPrivileges": { "type": "object", "required": [ @@ -8383,6 +8477,25 @@ } } }, + "PlayersPersonalBests": { + "type": "object", + "required": [ + "map", + "personal_bests" + ], + "properties": { + "map": { + "type": "string" + }, + "personal_bests": { + "type": "array", + "items": { + "$ref": "#/components/schemas/PlayerPersonalBest" + }, + "description": "Sorted by player, style and track. A player with no personal best on the map has no entries. One flat\nlist keeps it simple to read in SourcePawn." + } + } + }, "PluginRelease": { "type": "object", "description": "A published `sourcejump.smx` build.", diff --git a/docs/api.md b/docs/api.md index 4153656..9bbf370 100644 --- a/docs/api.md +++ b/docs/api.md @@ -6,7 +6,7 @@ How the `/v1/` API behaves for game servers, and rules every client can rely on. |---|---|---| | `GET /v1/ruleset` | no | `ruleset.rs` | | `GET /v1/maps/{map}/zones` | no | `zones.rs` | -| `GET /v1/maps/{map}/records` | no | `records.rs` | +| `GET /v1/maps/{map}/records`, `…/personal-bests` | no | `records.rs`, `records/` | | `GET /v1/records/events`, `GET /v1/records/stream` | no | `record_events.rs`, `record_events/stream.rs` | | `GET /v1/maps`, `GET /v1/maps/{map}`, `…/leaderboard`, `…/wr-history` | no | `maps/` | | `GET /v1/runs/{id}` | no | `runs/detail.rs` | @@ -43,20 +43,21 @@ How the `/v1/` API behaves for game servers, and rules every client can rely on. - Over 64 KB gets `413`. Hostnames lose control characters, cut to 64. An IP (IPv6: /64) may send 120 at once, then 30 a minute; more get `429`, before any key check (`heartbeat_limit.rs`). ## Runs -- Accepted only if the run's ruleset version exists, its style is ranked in that version, its tickrate matches the ruleset's `tickrate` if set, and the plugin reports the server as compliant. Field ranges are checked once, at the boundary. +- Accepted only if the run's ruleset version exists, its style is ranked in that version, its tickrate matches the ruleset's `tickrate` if set, and the plugin reports the server as compliant. - `personal_bests` holds each player's fastest run per map, style and track, updated in the same transaction. A tie keeps the earlier run. - Any keyed server can add a map by submitting a run on it. Which maps are ranked is a separate decision. ## Replays - The `replays` policy decides which replays are wanted (`request`: `new_personal_best`, the lead's call on 2026-10-19; `every_run` or `nothing`) and which styles' replays are public (`public_styles`: every ranked style, lead 2026-11-03). A missing policy asks for nothing and makes nothing public. -- A wanted replay gets a presigned `PUT` link, valid for an hour, to `uploads/replays/-.replay` in a private bucket. The server uploads there directly. A resend of the run returns a fresh link, with `last_refusal` (reason, time) if the last upload was refused, or no link once the replay is stored (delete the local copy). +- A wanted replay gets a presigned `PUT` link, valid for an hour, to `uploads/replays/-.replay` in a private bucket. A resend of the run returns a fresh link, with `last_refusal` (reason, time) if the last upload was refused, or no link once the replay is stored (delete the local copy). - Every 30 s a job (`replays/processing.rs`) lists the uploads and checks each against its run: shavit format 12 only, frames fill the file exactly, same map (any case), track, player and tickrate, and the time within half a tick. Over 128 MB is refused. A good file is stored as SJR (`replays/sjr.rs`, a fifth the size) at `replays/-.sjr`; the upload is deleted. A bad one is deleted, its reason kept on the `replays` row, and the server may upload again. A stored replay never changes; a failing upload is retried. - The bucket is public; random keys mean only the API reveals files. `GET /v1/runs/{id}` gives the SJR link (`replay.sjr_url`; invalidated runs too, lead 2026-11-03), its route from above (`replay.route`, `replay-viewer.md`), and `GET /v1/replays/{run_id}` the shavit file, rebuilt byte for byte at its first download and kept (own random key), only while the run is valid and its style is public. - `GET /v1/maps/{map}/records` marks each record `has_replay` by the same rule, so a server only asks for files it will get. ## Map records for `/wr` - `GET /v1/maps/{map}/leaderboard?style=&track=` pages one board (`total`, `next_cursor`); `player=` (any SteamID) adds their best and rank as `player_entry`. Opaque cursors name where a page ended, so paging survives that player improving; old run-ID ones work while the run is a PB. Its rows and `…/records`' carry `points` and `has_replay`. -- Both send an `ETag` (`etag.rs`, a body hash); `If-None-Match` with it gets a bodiless `304` until the answer changes. So do `/v1/ruleset`, `…/zones` and `/v1/plugin/latest`. +- `…/personal-bests?players=` (1–64 SteamID64s): their bests in every style and track, with `rank`. +- All three send an `ETag` (`etag.rs`, a body hash); `If-None-Match` with it gets a bodiless `304` until the answer changes. So do `/v1/ruleset`, `…/zones` and `/v1/plugin/latest`. ## Record events - `GET /v1/records/events` lists what happened to records, for servers announcing them or playing them on their bot: `run` (a new personal best, or a restored run that is one again), `replay` (its replay stored) and `invalidated` (staff took a run off a board; read the map's records again). Events are written with their change and kept a week. `previous_time` is the player's best on the board before that run, as it stood then (null: none; migration 0043). The same events feed the Discord posts of records and personal bests (`record_events/discord.rs`). @@ -66,7 +67,7 @@ How the `/v1/` API behaves for game servers, and rules every client can rely on. - The ruleset's `features.record_events` and `features.record_stream` tell the plugin to follow them (migration 0035). ## Policies and versioned data -Rulesets, zone sets and `policies` (community policy the plugin doesn't need: `servers`, `replays`, `tiers`, typed in `policies.rs`) are append-only: database triggers refuse updates and deletes. A change is a new version, and the newest version is in force. Runs record the ruleset version they were played under. A new version ships as a migration (lead, 2026-10-21); a test checks every ruleset they publish (`RulesetDocument::check`). The CLI's `tiers count` publishes the tier count, logged. +Rulesets, zone sets and `policies` (community policy the plugin doesn't need: `servers`, `replays`, `tiers`, typed in `policies.rs`) are append-only: database triggers refuse updates and deletes. A change is a new version, and the newest version is in force. Runs record the ruleset version they were played under. A new version ships as a migration (lead, 2026-10-21); a test checks every ruleset they publish (`RulesetDocument::check`). - Ranked styles carry shavit `settings` and `flags`; `RankedStyle` (`ruleset.rs`) says how they match. Provisional values: migrations 0041–0042 (lead, 2026-11-04). ## Zones diff --git a/web/src/api/schema.ts b/web/src/api/schema.ts index 239e647..65ed060 100644 --- a/web/src/api/schema.ts +++ b/web/src/api/schema.ts @@ -245,6 +245,26 @@ export interface paths { patch?: never; trace?: never; }; + "/v1/maps/{map}/personal-bests": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** + * These players' SourceJump personal bests on the map, every style and track. An unknown map, or players + * without runs on it, give an empty list. + */ + get: operations["players_personal_bests"]; + put?: never; + post?: never; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; "/v1/maps/{map}/records": { parameters: { query?: never; @@ -2324,6 +2344,30 @@ export interface components { PlayerList: { players: components["schemas"]["PlayerSummary"][]; }; + PlayerPersonalBest: { + /** Format: date-time */ + finished_at: string; + /** + * Format: int64 + * @description Place on the leaderboard; equal times share a place, as in `…/records`. + */ + rank: number; + /** Format: int64 */ + run_id: number; + /** @description SteamID64, as a string. */ + steamid64: string; + style: string; + /** + * Format: double + * @description Seconds. + */ + time: number; + /** + * Format: int32 + * @description 0 is the main track, 1 and up are bonuses. + */ + track: number; + }; PlayerPrivileges: { /** @description What the player holds after the change. */ privileges: components["schemas"]["Privilege"][]; @@ -2444,6 +2488,14 @@ export interface components { */ players: number; }; + PlayersPersonalBests: { + map: string; + /** + * @description Sorted by player, style and track. A player with no personal best on the map has no entries. One flat + * list keeps it simple to read in SourcePawn. + */ + personal_bests: components["schemas"]["PlayerPersonalBest"][]; + }; /** @description A published `sourcejump.smx` build. */ PluginRelease: { download_url: string; @@ -3918,6 +3970,40 @@ export interface operations { }; }; }; + players_personal_bests: { + parameters: { + query: { + /** @description Players by SteamID64, comma-separated: 1 to 64 of them. Repeats count once. */ + players: string; + }; + header?: never; + path: { + /** @description Map name */ + map: string; + }; + cookie?: never; + }; + requestBody?: never; + responses: { + 200: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": components["schemas"]["PlayersPersonalBests"]; + }; + }; + /** @description Not a valid map name, or `players` isn't 1 to 64 SteamID64s */ + 422: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": components["schemas"]["ErrorBody"]; + }; + }; + }; + }; map_records: { parameters: { query?: { From 1cdb44f658c907d99bbc1e4f04ad4acf393fb7dc Mon Sep 17 00:00:00 2001 From: Ayberk Alcan Date: Sat, 7 Nov 2026 22:20:25 +0300 Subject: [PATCH 02/11] Show signed-in players their own place on a map's leaderboard The board's top 25 comes with the map, so a player further down had to page with "Show more" to find themselves. The board now asks for their entry (the leaderboard's existing `player=`) and pins it under the top, set apart, until "Show more" reaches it. Only on the 2.0 board, which is the one that ranks them, and only when they aren't already in the top. TableRow gets `separated` for a row that starts a group apart. --- docs/design-system.md | 2 +- web/src/features/maps/Leaderboard.tsx | 188 ++++++++++++++++++-------- web/src/ui/Table.tsx | 8 +- 3 files changed, 136 insertions(+), 62 deletions(-) diff --git a/docs/design-system.md b/docs/design-system.md index ad898a2..4293cc8 100644 --- a/docs/design-system.md +++ b/docs/design-system.md @@ -30,7 +30,7 @@ One visual language that every page is built from, so pages can't drift apart. S | `TierBadge` | `tier` and `tierCount` from the API | | `Avatar` | Steam avatar or initials; `sm` to `xl` | | `Flag` | Country flag from an ISO code, a grey placeholder without one; `hint` replaces its tooltip | -| `Table` + `TableHead`/`TableBody`/`TableRow`/`TableHeaderCell`/`TableCell` | Leaderboards and staff lists; `numeric` cells right-align, `wrap` cells let long names wrap. Scrolls sideways inside its frame when too wide | +| `Table` + `TableHead`/`TableBody`/`TableRow`/`TableHeaderCell`/`TableCell` | Leaderboards and staff lists; `numeric` cells right-align, `wrap` cells let long names wrap, a `separated` row starts a group apart. Scrolls sideways inside its frame when too wide | | `Tabs` | Panels on one page; `underline` or `segmented` | | `LinkTabs` | Looks like `Tabs`, but each tab is a link: a view the server renders, such as the Maps page's sort | | `Segmented` | Looks like segmented `Tabs`, for a choice that changes the view in place (a server's activity range, a post's kind). The chosen option is in the accent | diff --git a/web/src/features/maps/Leaderboard.tsx b/web/src/features/maps/Leaderboard.tsx index aea520d..d719ab2 100644 --- a/web/src/features/maps/Leaderboard.tsx +++ b/web/src/features/maps/Leaderboard.tsx @@ -1,7 +1,8 @@ "use client"; // A map's leaderboard for one style, track and view: the 2.0 top comes with the page, other views load their // first page when chosen, and "Show more" loads the rest a page at a time. The signed-in player's row stands -// out, and legacy runs carry the Pre-2.0 badge. +// out; on the 2.0 board, when it isn't among the rows shown, it's pinned below them. Legacy runs carry the +// Pre-2.0 badge. import { useEffect, useState } from "react"; import { api, type Schemas } from "@/api/client"; import { LegacyBadge } from "@/features/legacy/LegacyBadge"; @@ -32,6 +33,8 @@ export type BoardPage = Pick< "entries" | "next_cursor" | "total" | "world_record_time" | "fastest_time" >; +type Entry = Schemas["LeaderboardEntry"]; + /** Give it a `key` per style, track and view, so switching boards starts again from the top. */ export function Leaderboard({ map, @@ -55,6 +58,8 @@ export function Leaderboard({ const [cursor, setCursor] = useState(first?.next_cursor); const [loading, setLoading] = useState(false); const [failed, setFailed] = useState(false); + // The signed-in player's own entry, wherever on the board it is. Only the 2.0 board ranks them. + const [mine, setMine] = useState(); // A refreshed page (after a staff change, say) brings a new first page; start again from it. const [shownFrom, setShownFrom] = useState(first); if (first && shownFrom !== first) { @@ -103,6 +108,23 @@ export function Leaderboard({ // eslint-disable-next-line react-hooks/exhaustive-deps -- the key remounts this for another board }, []); + // The top that comes with the map doesn't carry the player's own place; one row is asked for here, unless + // they're already in that top. + useEffect(() => { + if (!me || view !== "current") return; + if (first?.entries.some((entry) => entry.player.steamid64 === me)) return; + void api + .GET("/v1/maps/{map}/leaderboard", { + params: { + path: { map }, + query: { style, track, limit: 1, player: me }, + }, + }) + .then((result) => setMine(result.data?.player_entry ?? undefined)) + .catch(() => undefined); + // eslint-disable-next-line react-hooks/exhaustive-deps -- the key remounts this for another board + }, []); + if (!page) { return failed ? (

@@ -112,6 +134,12 @@ export function Leaderboard({ } const fastest = page.fastest_time; const record = page.world_record_time; + // Once "Show more" reaches them, their row is in the list and isn't pinned twice. + const pinned = + mine && + !entries.some((entry) => entry.run_id === mine.run_id && !entry.legacy) + ? mine + : undefined; return (

@@ -130,68 +158,29 @@ export function Leaderboard({ {entries.map((entry) => ( - - - {/* Medals mark 2.0 standings; the other views are lists by time. */} - - - - - - - {entry.player.name} - - - {entry.legacy && } - - - - - {formatTime(entry.time)} - - - - {!entry.legacy && entry.time === record ? ( - WR - ) : entry.time === fastest || fastest == null ? null : ( - formatGap(entry.time - fastest) - )} - - - {entry.jumps} - - - {entry.strafes} - - - {sync.format(entry.sync)}% - - - {entry.finished_at ? ( - - ) : ( - "–" - )} - - + entry={entry} + view={view} + mine={entry.player.steamid64 === me} + record={record} + fastest={fastest} + /> ))} + {pinned && ( + // Its own body, so the line above it reads as a gap in the list rather than the next place. + + + + )}
@@ -217,3 +206,82 @@ export function Leaderboard({
); } + +/** One player's row: place, player, time, gap to the fastest, stats and date. */ +function EntryRow({ + entry, + view, + mine, + record, + fastest, + separated = false, +}: { + entry: Entry; + view: View; + /** The signed-in player's own row, which stands out. */ + mine: boolean; + record: number | null | undefined; + fastest: number | null | undefined; + /** Set apart from the rows above it. */ + separated?: boolean; +}) { + return ( + + + {/* Medals mark 2.0 standings; the other views are lists by time. */} + + + + + + + {entry.player.name} + + + {entry.legacy && } + + + + + {formatTime(entry.time)} + + + + {!entry.legacy && entry.time === record ? ( + WR + ) : entry.time === fastest || fastest == null ? null : ( + formatGap(entry.time - fastest) + )} + + + {entry.jumps} + + + {entry.strafes} + + + {sync.format(entry.sync)}% + + + {entry.finished_at ? ( + + ) : ( + "–" + )} + + + ); +} diff --git a/web/src/ui/Table.tsx b/web/src/ui/Table.tsx index 0c219b4..d5855a0 100644 --- a/web/src/ui/Table.tsx +++ b/web/src/ui/Table.tsx @@ -39,14 +39,20 @@ export function TableBody(props: ComponentProps<"tbody">) { export function TableRow({ highlight = false, + separated = false, className, ...props -}: { highlight?: boolean } & ComponentProps<"tr">) { +}: { + highlight?: boolean; + /** Starts a group apart from the rows above, such as a player's own place pinned under a board's top. */ + separated?: boolean; +} & ComponentProps<"tr">) { return ( td]:border-border [&>td]:border-t-2", className, )} {...props} From d5aace990ebd78dd1d65cf2253c98970882f8eec Mon Sep 17 00:00:00 2001 From: Ayberk Alcan Date: Sat, 7 Nov 2026 22:40:50 +0300 Subject: [PATCH 03/11] Read the tier in force from one view instead of 14 copies Every query that needed a track's current tier repeated "newest assignment first, take one" against map_tiers, in 14 places across 8 files. The current_map_tiers view (migration 0052) says it once. Conditions on map_id and track still reach the primary key through it, so a single lookup reads the same index rows as before. Behavior is unchanged; whether tiers are in force (the tiers policy) is still each caller's call. --- ...4146e2c7bc8d6c35edad46bb4a32514d6caf.json} | 4 ++-- ...ca571d81156888fd6095e31ce97381600e2df.json | 14 ----------- ...343ca18be82be0ae291192fb51553d169faa.json} | 4 ++-- ...854a1e1811b463d3d3ffbb52e4f17372a3ed.json} | 4 ++-- ...0efd337e92717d9581aaa6ffab06b750704d.json} | 4 ++-- ...985b427e314cb7eed714a3fbbdd6023ef7d9c.json | 21 ----------------- ...2fe6c613d590d86aa3db45c32f258ce69752.json} | 8 +++---- ...933c1fdf51108b8b45030fae0d9a3195d941.json} | 4 ++-- ...f0f915f4a4e28b9956a6498e4818632ace6b5.json | 23 +++++++++++++++++++ ...e391bbbcadf1e56576c65f8d24b88330aa5b.json} | 4 ++-- ...e3a3dbcd335a1cedf1f478478b2f750be1ac8.json | 21 +++++++++++++++++ ...c670dc4b504cea6a119b2f98bb5bfb3dea670.json | 23 ------------------- ...52dec58960f3fbd47a69728e4e020db12a66.json} | 8 +++---- ...b396a9950973f74105558d979c8dabb664333.json | 14 +++++++++++ ...315b7ba5f4c8c40779dde663ee8272e27ebe.json} | 4 ++-- ...e4b4440593c64f0391a05a9a99191b169bed.json} | 10 ++++---- ...cb41391bbe8710c67fe523098acc3af22b33.json} | 8 +++---- .../api/migrations/0052_current_map_tiers.sql | 8 +++++++ api/crates/api/src/leaderboards/standings.rs | 10 +++----- api/crates/api/src/maps/detail.rs | 3 +-- api/crates/api/src/maps/list.rs | 15 ++++-------- .../api/src/record_events/discord/post.rs | 3 +-- api/crates/api/src/runs/detail.rs | 3 +-- api/crates/api/src/runs/recent.rs | 3 +-- api/crates/api/src/staff/maps.rs | 5 ++-- api/crates/api/src/staff/policies.rs | 4 +--- 26 files changed, 112 insertions(+), 120 deletions(-) rename api/.sqlx/{query-6d5c79bf0a98fc5ae3f16b32f513e467a9d8d869254ded27b29f11a124efe852.json => query-01f7dd297b27ffd70d058c7c02094146e2c7bc8d6c35edad46bb4a32514d6caf.json} (69%) delete mode 100644 api/.sqlx/query-07cad333640d67941225c6a4460ca571d81156888fd6095e31ce97381600e2df.json rename api/.sqlx/{query-2ace85f3e3bdc6a6def3f8f678ec0cb744b8109b774c914cd1b9b9119b346316.json => query-0b0d82934ef77f36365f54641adb343ca18be82be0ae291192fb51553d169faa.json} (76%) rename api/.sqlx/{query-5908cb42b04e7bac898e44cbf0794b37074219d331b5867e24d08c3a7309093d.json => query-1a0e27664607e0670e544ee08057854a1e1811b463d3d3ffbb52e4f17372a3ed.json} (86%) rename api/.sqlx/{query-1ecf840d0bc2ceee01d3d972ba891b00d083add43c10351eed6e9b01523375c6.json => query-2a38093fec6e9d0acd79a5b259840efd337e92717d9581aaa6ffab06b750704d.json} (89%) delete mode 100644 api/.sqlx/query-2a8a5bfced30494d8986461a6f1985b427e314cb7eed714a3fbbdd6023ef7d9c.json rename api/.sqlx/{query-d9981b3f571b8329c85152b64c076f7bc368ed7c6fd70dd425eb876c6964e236.json => query-59705d13fd2ea053c2f4777f701f2fe6c613d590d86aa3db45c32f258ce69752.json} (57%) rename api/.sqlx/{query-0eba6af91c197b4a7c14d17531e8c815bfb0fed762575ba2069fee0dfe790f9c.json => query-5b3ad4aac7217ba3a603adcf938d933c1fdf51108b8b45030fae0d9a3195d941.json} (84%) create mode 100644 api/.sqlx/query-5b96b09bc4c70d599055c6375d2f0f915f4a4e28b9956a6498e4818632ace6b5.json rename api/.sqlx/{query-8154635f139165e32da730d724f8884f499df1fa7fbf249e5bce5a8d99d8c7c4.json => query-724fdf8d089f3e5c7c055d7d2840e391bbbcadf1e56576c65f8d24b88330aa5b.json} (76%) create mode 100644 api/.sqlx/query-b34a02fb7fd0b0e3d9de88721cce3a3dbcd335a1cedf1f478478b2f750be1ac8.json delete mode 100644 api/.sqlx/query-bb9da91e5dd31ed43150f400c10c670dc4b504cea6a119b2f98bb5bfb3dea670.json rename api/.sqlx/{query-79f8a533b9ffccdb99dad6b682bac3b451a29743fab3da841bd22e572864ff19.json => query-cd24562230febd3f5cbef6bd3b0f52dec58960f3fbd47a69728e4e020db12a66.json} (59%) create mode 100644 api/.sqlx/query-cd642019090b4cdad7393d73198b396a9950973f74105558d979c8dabb664333.json rename api/.sqlx/{query-f59c5bfdd8ebefa4312bf431ce8f63aedc42365c6b6809b13146ec436ca8f7c2.json => query-d26414df0abf398bda09dccdafcd315b7ba5f4c8c40779dde663ee8272e27ebe.json} (57%) rename api/.sqlx/{query-193e0dc6d22809860b4dea9586b0edf496fe92c72a15be5c2b8948824a3d8b8f.json => query-e3f2da6a4f3a50d27266595df7bae4b4440593c64f0391a05a9a99191b169bed.json} (57%) rename api/.sqlx/{query-74493942786aa14a6e95ebe6198c28ffd2d175e76f4408e7706e54aedb353845.json => query-e9f09b3277fa13f62738502dad4dcb41391bbe8710c67fe523098acc3af22b33.json} (66%) create mode 100644 api/crates/api/migrations/0052_current_map_tiers.sql diff --git a/api/.sqlx/query-6d5c79bf0a98fc5ae3f16b32f513e467a9d8d869254ded27b29f11a124efe852.json b/api/.sqlx/query-01f7dd297b27ffd70d058c7c02094146e2c7bc8d6c35edad46bb4a32514d6caf.json similarity index 69% rename from api/.sqlx/query-6d5c79bf0a98fc5ae3f16b32f513e467a9d8d869254ded27b29f11a124efe852.json rename to api/.sqlx/query-01f7dd297b27ffd70d058c7c02094146e2c7bc8d6c35edad46bb4a32514d6caf.json index 0a1eb8e..8186b14 100644 --- a/api/.sqlx/query-6d5c79bf0a98fc5ae3f16b32f513e467a9d8d869254ded27b29f11a124efe852.json +++ b/api/.sqlx/query-01f7dd297b27ffd70d058c7c02094146e2c7bc8d6c35edad46bb4a32514d6caf.json @@ -1,6 +1,6 @@ { "db_name": "PostgreSQL", - "query": "SELECT m.name, m.listed_at AS \"listed_at!\",\n (SELECT tier FROM map_tiers WHERE map_id = m.id AND track = 0 ORDER BY assigned_at DESC LIMIT 1)\n AS tier\n FROM maps m WHERE m.last_run_at IS NOT NULL AND m.listed_at IS NOT NULL\n ORDER BY m.listed_at DESC, m.name LIMIT $1", + "query": "SELECT m.name, m.listed_at AS \"listed_at!\",\n (SELECT tier FROM current_map_tiers WHERE map_id = m.id AND track = 0) AS tier\n FROM maps m WHERE m.last_run_at IS NOT NULL AND m.listed_at IS NOT NULL\n ORDER BY m.listed_at DESC, m.name LIMIT $1", "describe": { "columns": [ { @@ -43,5 +43,5 @@ null ] }, - "hash": "6d5c79bf0a98fc5ae3f16b32f513e467a9d8d869254ded27b29f11a124efe852" + "hash": "01f7dd297b27ffd70d058c7c02094146e2c7bc8d6c35edad46bb4a32514d6caf" } diff --git a/api/.sqlx/query-07cad333640d67941225c6a4460ca571d81156888fd6095e31ce97381600e2df.json b/api/.sqlx/query-07cad333640d67941225c6a4460ca571d81156888fd6095e31ce97381600e2df.json deleted file mode 100644 index 5f3a590..0000000 --- a/api/.sqlx/query-07cad333640d67941225c6a4460ca571d81156888fd6095e31ce97381600e2df.json +++ /dev/null @@ -1,14 +0,0 @@ -{ - "db_name": "PostgreSQL", - "query": "\n WITH tiers AS (\n SELECT DISTINCT ON (map_id, track) map_id, track, tier FROM map_tiers\n WHERE $1 ORDER BY map_id, track, assigned_at DESC\n )\n INSERT INTO standings_boards (map_id, style, track, best, tier)\n SELECT b.map_id, b.style, b.track, b.best, t.tier\n FROM (SELECT map_id, style, track, min(time) AS best FROM personal_bests GROUP BY 1, 2, 3) b\n LEFT JOIN tiers t ON t.map_id = b.map_id AND t.track = b.track\n ", - "describe": { - "columns": [], - "parameters": { - "Left": [ - "Bool" - ] - }, - "nullable": [] - }, - "hash": "07cad333640d67941225c6a4460ca571d81156888fd6095e31ce97381600e2df" -} diff --git a/api/.sqlx/query-2ace85f3e3bdc6a6def3f8f678ec0cb744b8109b774c914cd1b9b9119b346316.json b/api/.sqlx/query-0b0d82934ef77f36365f54641adb343ca18be82be0ae291192fb51553d169faa.json similarity index 76% rename from api/.sqlx/query-2ace85f3e3bdc6a6def3f8f678ec0cb744b8109b774c914cd1b9b9119b346316.json rename to api/.sqlx/query-0b0d82934ef77f36365f54641adb343ca18be82be0ae291192fb51553d169faa.json index 551cd91..b22cab5 100644 --- a/api/.sqlx/query-2ace85f3e3bdc6a6def3f8f678ec0cb744b8109b774c914cd1b9b9119b346316.json +++ b/api/.sqlx/query-0b0d82934ef77f36365f54641adb343ca18be82be0ae291192fb51553d169faa.json @@ -1,6 +1,6 @@ { "db_name": "PostgreSQL", - "query": "SELECT count(*) AS \"count!\" FROM maps m\n WHERE last_run_at IS NOT NULL AND ($1::text IS NULL OR name ILIKE $1 ESCAPE '\\' OR $2 <% name)\n AND ($3::bigint IS NULL OR $4 = EXISTS (\n SELECT 1 FROM personal_bests WHERE player_steamid64 = $3 AND map_id = m.id AND style = $5 AND track = 0))\n AND ($6::smallint IS NULL OR $6 = (SELECT tier FROM map_tiers WHERE map_id = m.id AND track = 0\n ORDER BY assigned_at DESC LIMIT 1))", + "query": "SELECT count(*) AS \"count!\" FROM maps m\n WHERE last_run_at IS NOT NULL AND ($1::text IS NULL OR name ILIKE $1 ESCAPE '\\' OR $2 <% name)\n AND ($3::bigint IS NULL OR $4 = EXISTS (\n SELECT 1 FROM personal_bests WHERE player_steamid64 = $3 AND map_id = m.id AND style = $5 AND track = 0))\n AND ($6::smallint IS NULL OR $6 = (SELECT tier FROM current_map_tiers WHERE map_id = m.id AND track = 0))", "describe": { "columns": [ { @@ -24,5 +24,5 @@ null ] }, - "hash": "2ace85f3e3bdc6a6def3f8f678ec0cb744b8109b774c914cd1b9b9119b346316" + "hash": "0b0d82934ef77f36365f54641adb343ca18be82be0ae291192fb51553d169faa" } diff --git a/api/.sqlx/query-5908cb42b04e7bac898e44cbf0794b37074219d331b5867e24d08c3a7309093d.json b/api/.sqlx/query-1a0e27664607e0670e544ee08057854a1e1811b463d3d3ffbb52e4f17372a3ed.json similarity index 86% rename from api/.sqlx/query-5908cb42b04e7bac898e44cbf0794b37074219d331b5867e24d08c3a7309093d.json rename to api/.sqlx/query-1a0e27664607e0670e544ee08057854a1e1811b463d3d3ffbb52e4f17372a3ed.json index baccabe..3cb673f 100644 --- a/api/.sqlx/query-5908cb42b04e7bac898e44cbf0794b37074219d331b5867e24d08c3a7309093d.json +++ b/api/.sqlx/query-1a0e27664607e0670e544ee08057854a1e1811b463d3d3ffbb52e4f17372a3ed.json @@ -1,6 +1,6 @@ { "db_name": "PostgreSQL", - "query": "\n SELECT DISTINCT ON (pb.track, pb.style)\n pb.track, pb.style, pb.time, pb.run_id, r.finished_at,\n count(*) OVER (PARTITION BY pb.track, pb.style) AS \"players!\",\n p.steamid64::text AS \"steamid64!\", p.name, p.avatar_url, p.country_code,\n (SELECT tier FROM map_tiers WHERE map_id = pb.map_id AND track = pb.track\n ORDER BY assigned_at DESC LIMIT 1) AS tier\n FROM personal_bests pb\n JOIN runs r ON r.id = pb.run_id\n JOIN players p ON p.steamid64 = pb.player_steamid64\n WHERE pb.map_id = $1\n ORDER BY pb.track, pb.style, pb.time, r.finished_at\n ", + "query": "\n SELECT DISTINCT ON (pb.track, pb.style)\n pb.track, pb.style, pb.time, pb.run_id, r.finished_at,\n count(*) OVER (PARTITION BY pb.track, pb.style) AS \"players!\",\n p.steamid64::text AS \"steamid64!\", p.name, p.avatar_url, p.country_code,\n (SELECT tier FROM current_map_tiers WHERE map_id = pb.map_id AND track = pb.track) AS tier\n FROM personal_bests pb\n JOIN runs r ON r.id = pb.run_id\n JOIN players p ON p.steamid64 = pb.player_steamid64\n WHERE pb.map_id = $1\n ORDER BY pb.track, pb.style, pb.time, r.finished_at\n ", "describe": { "columns": [ { @@ -129,5 +129,5 @@ null ] }, - "hash": "5908cb42b04e7bac898e44cbf0794b37074219d331b5867e24d08c3a7309093d" + "hash": "1a0e27664607e0670e544ee08057854a1e1811b463d3d3ffbb52e4f17372a3ed" } diff --git a/api/.sqlx/query-1ecf840d0bc2ceee01d3d972ba891b00d083add43c10351eed6e9b01523375c6.json b/api/.sqlx/query-2a38093fec6e9d0acd79a5b259840efd337e92717d9581aaa6ffab06b750704d.json similarity index 89% rename from api/.sqlx/query-1ecf840d0bc2ceee01d3d972ba891b00d083add43c10351eed6e9b01523375c6.json rename to api/.sqlx/query-2a38093fec6e9d0acd79a5b259840efd337e92717d9581aaa6ffab06b750704d.json index b3e15ca..4d323ac 100644 --- a/api/.sqlx/query-1ecf840d0bc2ceee01d3d972ba891b00d083add43c10351eed6e9b01523375c6.json +++ b/api/.sqlx/query-2a38093fec6e9d0acd79a5b259840efd337e92717d9581aaa6ffab06b750704d.json @@ -1,6 +1,6 @@ { "db_name": "PostgreSQL", - "query": "\n SELECT r.id, r.map_id, m.name AS map, r.style, r.track, r.time, r.jumps, r.strafes, r.sync, r.perfs,\n r.avg_velocity, r.max_velocity, r.tickrate, r.finished_at, r.ruleset_version,\n r.invalidated_at IS NOT NULL AS \"invalidated!\", s.id AS server_id, s.name AS server_name,\n p.steamid64::text AS \"steamid64!\", p.name, p.avatar_url, p.country_code,\n EXISTS (SELECT 1 FROM personal_bests WHERE run_id = r.id) AS \"personal_best!\",\n (SELECT min(time) FROM personal_bests\n WHERE map_id = r.map_id AND style = r.style AND track = r.track) AS world_record_time,\n (SELECT tier FROM map_tiers WHERE map_id = r.map_id AND track = r.track\n ORDER BY assigned_at DESC LIMIT 1) AS tier,\n ci.id AS \"image_id?\", ci.key AS \"image_key?\", ci.focus AS \"image_focus?\",\n (SELECT host(h.ip) || ':' || h.port FROM server_heartbeats h\n JOIN server_listings l ON l.ip = h.ip AND l.port = h.port\n WHERE h.server_id = s.id ORDER BY h.received_at DESC LIMIT 1) AS server_address\n FROM runs r\n JOIN maps m ON m.id = r.map_id\n LEFT JOIN map_images ci ON ci.map_id = m.id AND ci.position = 0\n JOIN servers s ON s.id = r.server_id\n JOIN players p ON p.steamid64 = r.player_steamid64\n WHERE r.id = $1\n ", + "query": "\n SELECT r.id, r.map_id, m.name AS map, r.style, r.track, r.time, r.jumps, r.strafes, r.sync, r.perfs,\n r.avg_velocity, r.max_velocity, r.tickrate, r.finished_at, r.ruleset_version,\n r.invalidated_at IS NOT NULL AS \"invalidated!\", s.id AS server_id, s.name AS server_name,\n p.steamid64::text AS \"steamid64!\", p.name, p.avatar_url, p.country_code,\n EXISTS (SELECT 1 FROM personal_bests WHERE run_id = r.id) AS \"personal_best!\",\n (SELECT min(time) FROM personal_bests\n WHERE map_id = r.map_id AND style = r.style AND track = r.track) AS world_record_time,\n (SELECT tier FROM current_map_tiers WHERE map_id = r.map_id AND track = r.track) AS tier,\n ci.id AS \"image_id?\", ci.key AS \"image_key?\", ci.focus AS \"image_focus?\",\n (SELECT host(h.ip) || ':' || h.port FROM server_heartbeats h\n JOIN server_listings l ON l.ip = h.ip AND l.port = h.port\n WHERE h.server_id = s.id ORDER BY h.received_at DESC LIMIT 1) AS server_address\n FROM runs r\n JOIN maps m ON m.id = r.map_id\n LEFT JOIN map_images ci ON ci.map_id = m.id AND ci.position = 0\n JOIN servers s ON s.id = r.server_id\n JOIN players p ON p.steamid64 = r.player_steamid64\n WHERE r.id = $1\n ", "describe": { "columns": [ { @@ -330,5 +330,5 @@ null ] }, - "hash": "1ecf840d0bc2ceee01d3d972ba891b00d083add43c10351eed6e9b01523375c6" + "hash": "2a38093fec6e9d0acd79a5b259840efd337e92717d9581aaa6ffab06b750704d" } diff --git a/api/.sqlx/query-2a8a5bfced30494d8986461a6f1985b427e314cb7eed714a3fbbdd6023ef7d9c.json b/api/.sqlx/query-2a8a5bfced30494d8986461a6f1985b427e314cb7eed714a3fbbdd6023ef7d9c.json deleted file mode 100644 index 1186ab4..0000000 --- a/api/.sqlx/query-2a8a5bfced30494d8986461a6f1985b427e314cb7eed714a3fbbdd6023ef7d9c.json +++ /dev/null @@ -1,21 +0,0 @@ -{ - "db_name": "PostgreSQL", - "query": "\n SELECT max(tier) FROM (\n SELECT DISTINCT ON (map_id, track) tier FROM map_tiers ORDER BY map_id, track, assigned_at DESC\n ) in_force\n ", - "describe": { - "columns": [ - { - "ordinal": 0, - "name": "max", - "type_info": "Int2", - "origin": "Expression" - } - ], - "parameters": { - "Left": [] - }, - "nullable": [ - null - ] - }, - "hash": "2a8a5bfced30494d8986461a6f1985b427e314cb7eed714a3fbbdd6023ef7d9c" -} diff --git a/api/.sqlx/query-d9981b3f571b8329c85152b64c076f7bc368ed7c6fd70dd425eb876c6964e236.json b/api/.sqlx/query-59705d13fd2ea053c2f4777f701f2fe6c613d590d86aa3db45c32f258ce69752.json similarity index 57% rename from api/.sqlx/query-d9981b3f571b8329c85152b64c076f7bc368ed7c6fd70dd425eb876c6964e236.json rename to api/.sqlx/query-59705d13fd2ea053c2f4777f701f2fe6c613d590d86aa3db45c32f258ce69752.json index d5c0a59..135dfe0 100644 --- a/api/.sqlx/query-d9981b3f571b8329c85152b64c076f7bc368ed7c6fd70dd425eb876c6964e236.json +++ b/api/.sqlx/query-59705d13fd2ea053c2f4777f701f2fe6c613d590d86aa3db45c32f258ce69752.json @@ -1,6 +1,6 @@ { "db_name": "PostgreSQL", - "query": "SELECT tier.tier AS \"tier?\", count(*) AS \"maps!\" FROM maps m\n LEFT JOIN LATERAL (SELECT tier FROM map_tiers WHERE map_id = m.id AND track = 0\n ORDER BY assigned_at DESC LIMIT 1) tier ON true\n WHERE m.last_run_at IS NOT NULL\n GROUP BY tier.tier", + "query": "SELECT tier.tier AS \"tier?\", count(*) AS \"maps!\" FROM maps m\n LEFT JOIN current_map_tiers tier ON tier.map_id = m.id AND tier.track = 0\n WHERE m.last_run_at IS NOT NULL\n GROUP BY tier.tier", "describe": { "columns": [ { @@ -9,7 +9,7 @@ "type_info": "Int2", "origin": { "Table": { - "table": "map_tiers", + "table": "current_map_tiers", "name": "tier" } } @@ -25,9 +25,9 @@ "Left": [] }, "nullable": [ - false, + true, null ] }, - "hash": "d9981b3f571b8329c85152b64c076f7bc368ed7c6fd70dd425eb876c6964e236" + "hash": "59705d13fd2ea053c2f4777f701f2fe6c613d590d86aa3db45c32f258ce69752" } diff --git a/api/.sqlx/query-0eba6af91c197b4a7c14d17531e8c815bfb0fed762575ba2069fee0dfe790f9c.json b/api/.sqlx/query-5b3ad4aac7217ba3a603adcf938d933c1fdf51108b8b45030fae0d9a3195d941.json similarity index 84% rename from api/.sqlx/query-0eba6af91c197b4a7c14d17531e8c815bfb0fed762575ba2069fee0dfe790f9c.json rename to api/.sqlx/query-5b3ad4aac7217ba3a603adcf938d933c1fdf51108b8b45030fae0d9a3195d941.json index 362f45f..53a71f4 100644 --- a/api/.sqlx/query-0eba6af91c197b4a7c14d17531e8c815bfb0fed762575ba2069fee0dfe790f9c.json +++ b/api/.sqlx/query-5b3ad4aac7217ba3a603adcf938d933c1fdf51108b8b45030fae0d9a3195d941.json @@ -1,6 +1,6 @@ { "db_name": "PostgreSQL", - "query": "\n SELECT r.id, m.name AS map, r.style, r.track, r.time, r.sync, r.strafes, r.jumps, r.finished_at, r.was_record,\n r.player_steamid64::text AS \"steamid64!\", p.name AS player, s.name AS server_name,\n (SELECT st->>'name' FROM rulesets, jsonb_array_elements(document->'styles') st\n WHERE st->>'key' = r.style ORDER BY version DESC LIMIT 1) AS style_name,\n (SELECT min(o.time) FROM runs o\n WHERE o.map_id = r.map_id AND o.style = r.style AND o.track = r.track\n AND o.invalidated_at IS NULL AND (o.finished_at, o.id) < (r.finished_at, r.id))\n AS previous_record,\n (SELECT min(o.time) FROM runs o\n WHERE o.map_id = r.map_id AND o.style = r.style AND o.track = r.track\n AND o.player_steamid64 = r.player_steamid64\n AND o.invalidated_at IS NULL AND (o.finished_at, o.id) < (r.finished_at, r.id))\n AS previous_personal_best,\n (SELECT tier FROM map_tiers WHERE map_id = r.map_id AND track = r.track\n ORDER BY assigned_at DESC LIMIT 1) AS tier,\n (SELECT key FROM map_images WHERE map_id = r.map_id AND position = 0) AS image_key,\n (SELECT host(h.ip) || ':' || h.port FROM server_heartbeats h\n JOIN server_listings l ON l.ip = h.ip AND l.port = h.port\n WHERE h.server_id = s.id ORDER BY h.received_at DESC LIMIT 1) AS server_address\n FROM unnest($1::bigint[]) WITH ORDINALITY AS wanted (run_id, place)\n JOIN runs r ON r.id = wanted.run_id\n JOIN maps m ON m.id = r.map_id\n JOIN players p ON p.steamid64 = r.player_steamid64\n JOIN servers s ON s.id = r.server_id\n ORDER BY wanted.place\n ", + "query": "\n SELECT r.id, m.name AS map, r.style, r.track, r.time, r.sync, r.strafes, r.jumps, r.finished_at, r.was_record,\n r.player_steamid64::text AS \"steamid64!\", p.name AS player, s.name AS server_name,\n (SELECT st->>'name' FROM rulesets, jsonb_array_elements(document->'styles') st\n WHERE st->>'key' = r.style ORDER BY version DESC LIMIT 1) AS style_name,\n (SELECT min(o.time) FROM runs o\n WHERE o.map_id = r.map_id AND o.style = r.style AND o.track = r.track\n AND o.invalidated_at IS NULL AND (o.finished_at, o.id) < (r.finished_at, r.id))\n AS previous_record,\n (SELECT min(o.time) FROM runs o\n WHERE o.map_id = r.map_id AND o.style = r.style AND o.track = r.track\n AND o.player_steamid64 = r.player_steamid64\n AND o.invalidated_at IS NULL AND (o.finished_at, o.id) < (r.finished_at, r.id))\n AS previous_personal_best,\n (SELECT tier FROM current_map_tiers WHERE map_id = r.map_id AND track = r.track) AS tier,\n (SELECT key FROM map_images WHERE map_id = r.map_id AND position = 0) AS image_key,\n (SELECT host(h.ip) || ':' || h.port FROM server_heartbeats h\n JOIN server_listings l ON l.ip = h.ip AND l.port = h.port\n WHERE h.server_id = s.id ORDER BY h.received_at DESC LIMIT 1) AS server_address\n FROM unnest($1::bigint[]) WITH ORDINALITY AS wanted (run_id, place)\n JOIN runs r ON r.id = wanted.run_id\n JOIN maps m ON m.id = r.map_id\n JOIN players p ON p.steamid64 = r.player_steamid64\n JOIN servers s ON s.id = r.server_id\n ORDER BY wanted.place\n ", "describe": { "columns": [ { @@ -205,5 +205,5 @@ null ] }, - "hash": "0eba6af91c197b4a7c14d17531e8c815bfb0fed762575ba2069fee0dfe790f9c" + "hash": "5b3ad4aac7217ba3a603adcf938d933c1fdf51108b8b45030fae0d9a3195d941" } diff --git a/api/.sqlx/query-5b96b09bc4c70d599055c6375d2f0f915f4a4e28b9956a6498e4818632ace6b5.json b/api/.sqlx/query-5b96b09bc4c70d599055c6375d2f0f915f4a4e28b9956a6498e4818632ace6b5.json new file mode 100644 index 0000000..4b5be87 --- /dev/null +++ b/api/.sqlx/query-5b96b09bc4c70d599055c6375d2f0f915f4a4e28b9956a6498e4818632ace6b5.json @@ -0,0 +1,23 @@ +{ + "db_name": "PostgreSQL", + "query": "\n WITH now AS MATERIALIZED (\n SELECT b.map_id, b.style, b.track,\n (SELECT min(pb.time) FROM personal_bests pb\n WHERE pb.map_id = b.map_id AND pb.style = b.style AND pb.track = b.track) AS best,\n CASE WHEN $5 THEN (SELECT t.tier FROM current_map_tiers t\n WHERE t.map_id = b.map_id AND t.track = b.track) END AS tier\n FROM unnest($1::int8[], $2::text[], $3::int2[]) AS b (map_id, style, track)\n ), runners AS MATERIALIZED (\n SELECT DISTINCT player_steamid64, style, track > 0 AS bonus FROM runs WHERE id = ANY($4)\n ), moved AS (\n SELECT now.*, stored.best AS stored_best, stored.tier AS stored_tier\n FROM now JOIN standings_boards stored USING (map_id, style, track)\n WHERE now.best IS NOT NULL AND (now.best, now.tier) IS DISTINCT FROM (stored.best, stored.tier)\n ), changes AS (\n SELECT pb.style, pb.track > 0 AS bonus, pb.player_steamid64,\n sum(coalesce(points_for(m.tier, pb.time, m.best, pb.track > 0, $6, $7, $8, $9, $10), 0)\n - coalesce(points_for(m.stored_tier, pb.time, m.stored_best, pb.track > 0,\n $6, $7, $8, $9, $10), 0)) AS change\n FROM moved m\n JOIN personal_bests pb ON pb.map_id = m.map_id AND pb.style = m.style AND pb.track = m.track\n -- The runs' players are summed again below.\n WHERE NOT EXISTS (\n SELECT 1 FROM runners r\n WHERE r.player_steamid64 = pb.player_steamid64 AND r.style = pb.style AND r.bonus = (pb.track > 0)\n )\n GROUP BY 1, 2, 3\n ), moved_totals AS (\n UPDATE standings s SET points = s.points + c.change FROM changes c\n WHERE s.style = c.style AND s.bonus = c.bonus AND s.player_steamid64 = c.player_steamid64\n AND c.change <> 0\n ), emptied AS (\n DELETE FROM standings_boards stored USING now\n WHERE stored.map_id = now.map_id AND stored.style = now.style AND stored.track = now.track\n AND now.best IS NULL\n )\n INSERT INTO standings_boards (map_id, style, track, best, tier)\n SELECT map_id, style, track, best, tier FROM now WHERE best IS NOT NULL\n ON CONFLICT (map_id, style, track) DO UPDATE SET best = excluded.best, tier = excluded.tier\n ", + "describe": { + "columns": [], + "parameters": { + "Left": [ + "Int8Array", + "TextArray", + "Int2Array", + "Int8Array", + "Bool", + "Float8", + "Float8", + "Float8", + "Float8", + "Float8" + ] + }, + "nullable": [] + }, + "hash": "5b96b09bc4c70d599055c6375d2f0f915f4a4e28b9956a6498e4818632ace6b5" +} diff --git a/api/.sqlx/query-8154635f139165e32da730d724f8884f499df1fa7fbf249e5bce5a8d99d8c7c4.json b/api/.sqlx/query-724fdf8d089f3e5c7c055d7d2840e391bbbcadf1e56576c65f8d24b88330aa5b.json similarity index 76% rename from api/.sqlx/query-8154635f139165e32da730d724f8884f499df1fa7fbf249e5bce5a8d99d8c7c4.json rename to api/.sqlx/query-724fdf8d089f3e5c7c055d7d2840e391bbbcadf1e56576c65f8d24b88330aa5b.json index dcda92c..9854c93 100644 --- a/api/.sqlx/query-8154635f139165e32da730d724f8884f499df1fa7fbf249e5bce5a8d99d8c7c4.json +++ b/api/.sqlx/query-724fdf8d089f3e5c7c055d7d2840e391bbbcadf1e56576c65f8d24b88330aa5b.json @@ -1,6 +1,6 @@ { "db_name": "PostgreSQL", - "query": "\n SELECT m.name, ci.id AS \"image_id?\", ci.key AS \"image_key?\", ci.focus AS \"image_focus?\", m.last_run_at,\n (SELECT tier FROM map_tiers t WHERE t.map_id = m.id AND t.track = 0\n ORDER BY assigned_at DESC LIMIT 1) AS tier,\n (SELECT max(version) FROM map_zones z WHERE z.map_id = m.id) AS zone_version\n FROM maps m\n LEFT JOIN map_images ci ON ci.map_id = m.id AND ci.position = 0\n WHERE m.name ILIKE $1 ESCAPE '\\' AND (NOT $4 OR m.last_run_at IS NULL)\n ORDER BY m.name\n LIMIT $2 OFFSET $3\n ", + "query": "\n SELECT m.name, ci.id AS \"image_id?\", ci.key AS \"image_key?\", ci.focus AS \"image_focus?\", m.last_run_at,\n (SELECT tier FROM current_map_tiers t WHERE t.map_id = m.id AND t.track = 0) AS tier,\n (SELECT max(version) FROM map_zones z WHERE z.map_id = m.id) AS zone_version\n FROM maps m\n LEFT JOIN map_images ci ON ci.map_id = m.id AND ci.position = 0\n WHERE m.name ILIKE $1 ESCAPE '\\' AND (NOT $4 OR m.last_run_at IS NULL)\n ORDER BY m.name\n LIMIT $2 OFFSET $3\n ", "describe": { "columns": [ { @@ -89,5 +89,5 @@ null ] }, - "hash": "8154635f139165e32da730d724f8884f499df1fa7fbf249e5bce5a8d99d8c7c4" + "hash": "724fdf8d089f3e5c7c055d7d2840e391bbbcadf1e56576c65f8d24b88330aa5b" } diff --git a/api/.sqlx/query-b34a02fb7fd0b0e3d9de88721cce3a3dbcd335a1cedf1f478478b2f750be1ac8.json b/api/.sqlx/query-b34a02fb7fd0b0e3d9de88721cce3a3dbcd335a1cedf1f478478b2f750be1ac8.json new file mode 100644 index 0000000..10e8bf2 --- /dev/null +++ b/api/.sqlx/query-b34a02fb7fd0b0e3d9de88721cce3a3dbcd335a1cedf1f478478b2f750be1ac8.json @@ -0,0 +1,21 @@ +{ + "db_name": "PostgreSQL", + "query": "\n SELECT max(tier) FROM current_map_tiers\n ", + "describe": { + "columns": [ + { + "ordinal": 0, + "name": "max", + "type_info": "Int2", + "origin": "Expression" + } + ], + "parameters": { + "Left": [] + }, + "nullable": [ + null + ] + }, + "hash": "b34a02fb7fd0b0e3d9de88721cce3a3dbcd335a1cedf1f478478b2f750be1ac8" +} diff --git a/api/.sqlx/query-bb9da91e5dd31ed43150f400c10c670dc4b504cea6a119b2f98bb5bfb3dea670.json b/api/.sqlx/query-bb9da91e5dd31ed43150f400c10c670dc4b504cea6a119b2f98bb5bfb3dea670.json deleted file mode 100644 index ecdd558..0000000 --- a/api/.sqlx/query-bb9da91e5dd31ed43150f400c10c670dc4b504cea6a119b2f98bb5bfb3dea670.json +++ /dev/null @@ -1,23 +0,0 @@ -{ - "db_name": "PostgreSQL", - "query": "\n WITH now AS MATERIALIZED (\n SELECT b.map_id, b.style, b.track,\n (SELECT min(pb.time) FROM personal_bests pb\n WHERE pb.map_id = b.map_id AND pb.style = b.style AND pb.track = b.track) AS best,\n CASE WHEN $5 THEN (SELECT t.tier FROM map_tiers t WHERE t.map_id = b.map_id AND t.track = b.track\n ORDER BY t.assigned_at DESC LIMIT 1) END AS tier\n FROM unnest($1::int8[], $2::text[], $3::int2[]) AS b (map_id, style, track)\n ), runners AS MATERIALIZED (\n SELECT DISTINCT player_steamid64, style, track > 0 AS bonus FROM runs WHERE id = ANY($4)\n ), moved AS (\n SELECT now.*, stored.best AS stored_best, stored.tier AS stored_tier\n FROM now JOIN standings_boards stored USING (map_id, style, track)\n WHERE now.best IS NOT NULL AND (now.best, now.tier) IS DISTINCT FROM (stored.best, stored.tier)\n ), changes AS (\n SELECT pb.style, pb.track > 0 AS bonus, pb.player_steamid64,\n sum(coalesce(points_for(m.tier, pb.time, m.best, pb.track > 0, $6, $7, $8, $9, $10), 0)\n - coalesce(points_for(m.stored_tier, pb.time, m.stored_best, pb.track > 0,\n $6, $7, $8, $9, $10), 0)) AS change\n FROM moved m\n JOIN personal_bests pb ON pb.map_id = m.map_id AND pb.style = m.style AND pb.track = m.track\n -- The runs' players are summed again below.\n WHERE NOT EXISTS (\n SELECT 1 FROM runners r\n WHERE r.player_steamid64 = pb.player_steamid64 AND r.style = pb.style AND r.bonus = (pb.track > 0)\n )\n GROUP BY 1, 2, 3\n ), moved_totals AS (\n UPDATE standings s SET points = s.points + c.change FROM changes c\n WHERE s.style = c.style AND s.bonus = c.bonus AND s.player_steamid64 = c.player_steamid64\n AND c.change <> 0\n ), emptied AS (\n DELETE FROM standings_boards stored USING now\n WHERE stored.map_id = now.map_id AND stored.style = now.style AND stored.track = now.track\n AND now.best IS NULL\n )\n INSERT INTO standings_boards (map_id, style, track, best, tier)\n SELECT map_id, style, track, best, tier FROM now WHERE best IS NOT NULL\n ON CONFLICT (map_id, style, track) DO UPDATE SET best = excluded.best, tier = excluded.tier\n ", - "describe": { - "columns": [], - "parameters": { - "Left": [ - "Int8Array", - "TextArray", - "Int2Array", - "Int8Array", - "Bool", - "Float8", - "Float8", - "Float8", - "Float8", - "Float8" - ] - }, - "nullable": [] - }, - "hash": "bb9da91e5dd31ed43150f400c10c670dc4b504cea6a119b2f98bb5bfb3dea670" -} diff --git a/api/.sqlx/query-79f8a533b9ffccdb99dad6b682bac3b451a29743fab3da841bd22e572864ff19.json b/api/.sqlx/query-cd24562230febd3f5cbef6bd3b0f52dec58960f3fbd47a69728e4e020db12a66.json similarity index 59% rename from api/.sqlx/query-79f8a533b9ffccdb99dad6b682bac3b451a29743fab3da841bd22e572864ff19.json rename to api/.sqlx/query-cd24562230febd3f5cbef6bd3b0f52dec58960f3fbd47a69728e4e020db12a66.json index 186b6c9..bc5c891 100644 --- a/api/.sqlx/query-79f8a533b9ffccdb99dad6b682bac3b451a29743fab3da841bd22e572864ff19.json +++ b/api/.sqlx/query-cd24562230febd3f5cbef6bd3b0f52dec58960f3fbd47a69728e4e020db12a66.json @@ -1,6 +1,6 @@ { "db_name": "PostgreSQL", - "query": "\n WITH listed AS (\n SELECT r.id, r.map_id, r.style, r.track, r.player_steamid64, r.time, r.finished_at, r.was_record,\n tier.tier\n FROM runs r\n LEFT JOIN LATERAL (SELECT tier FROM map_tiers WHERE map_id = r.map_id AND track = r.track\n ORDER BY assigned_at DESC LIMIT 1) tier ON $7\n WHERE r.invalidated_at IS NULL\n AND (NOT $4 OR r.was_record)\n AND ($1::text IS NULL OR r.style = $1)\n AND ($2::text IS NULL OR ($2 = 'main') = (r.track = 0))\n AND ($3::smallint IS NULL OR tier.tier >= $3)\n AND ($5::timestamptz IS NULL OR (r.finished_at, r.id) < ($5, $6::bigint))\n ORDER BY r.finished_at DESC, r.id DESC\n LIMIT $8\n )\n SELECT l.id, l.style, l.track, l.time, l.finished_at, l.was_record, l.tier AS \"tier?\", prior.best AS \"best?\",\n m.name AS map, place.placement AS \"placement?\",\n p.steamid64::text AS \"steamid64!\", p.name, p.avatar_url, p.country_code\n FROM listed l\n CROSS JOIN LATERAL (\n SELECT min(e.time) AS best FROM runs e\n WHERE e.map_id = l.map_id AND e.style = l.style AND e.track = l.track\n AND e.invalidated_at IS NULL AND (e.finished_at, e.id) < (l.finished_at, l.id)\n ) prior\n JOIN maps m ON m.id = l.map_id\n JOIN players p ON p.steamid64 = l.player_steamid64\n LEFT JOIN LATERAL (\n SELECT 1 + count(*) AS placement FROM (\n SELECT 1 FROM runs e\n WHERE e.map_id = l.map_id AND e.style = l.style AND e.track = l.track\n AND e.invalidated_at IS NULL AND (e.finished_at, e.id) < (l.finished_at, l.id)\n AND e.player_steamid64 <> l.player_steamid64\n GROUP BY e.player_steamid64\n HAVING min(e.time) < l.time\n ) faster\n ) place ON NOT EXISTS (\n SELECT 1 FROM runs e\n WHERE e.map_id = l.map_id AND e.style = l.style AND e.track = l.track\n AND e.invalidated_at IS NULL AND (e.finished_at, e.id) < (l.finished_at, l.id)\n AND e.player_steamid64 = l.player_steamid64 AND e.time <= l.time\n )\n ORDER BY l.finished_at DESC, l.id DESC\n ", + "query": "\n WITH listed AS (\n SELECT r.id, r.map_id, r.style, r.track, r.player_steamid64, r.time, r.finished_at, r.was_record,\n tier.tier\n FROM runs r\n LEFT JOIN current_map_tiers tier ON $7 AND tier.map_id = r.map_id AND tier.track = r.track\n WHERE r.invalidated_at IS NULL\n AND (NOT $4 OR r.was_record)\n AND ($1::text IS NULL OR r.style = $1)\n AND ($2::text IS NULL OR ($2 = 'main') = (r.track = 0))\n AND ($3::smallint IS NULL OR tier.tier >= $3)\n AND ($5::timestamptz IS NULL OR (r.finished_at, r.id) < ($5, $6::bigint))\n ORDER BY r.finished_at DESC, r.id DESC\n LIMIT $8\n )\n SELECT l.id, l.style, l.track, l.time, l.finished_at, l.was_record, l.tier AS \"tier?\", prior.best AS \"best?\",\n m.name AS map, place.placement AS \"placement?\",\n p.steamid64::text AS \"steamid64!\", p.name, p.avatar_url, p.country_code\n FROM listed l\n CROSS JOIN LATERAL (\n SELECT min(e.time) AS best FROM runs e\n WHERE e.map_id = l.map_id AND e.style = l.style AND e.track = l.track\n AND e.invalidated_at IS NULL AND (e.finished_at, e.id) < (l.finished_at, l.id)\n ) prior\n JOIN maps m ON m.id = l.map_id\n JOIN players p ON p.steamid64 = l.player_steamid64\n LEFT JOIN LATERAL (\n SELECT 1 + count(*) AS placement FROM (\n SELECT 1 FROM runs e\n WHERE e.map_id = l.map_id AND e.style = l.style AND e.track = l.track\n AND e.invalidated_at IS NULL AND (e.finished_at, e.id) < (l.finished_at, l.id)\n AND e.player_steamid64 <> l.player_steamid64\n GROUP BY e.player_steamid64\n HAVING min(e.time) < l.time\n ) faster\n ) place ON NOT EXISTS (\n SELECT 1 FROM runs e\n WHERE e.map_id = l.map_id AND e.style = l.style AND e.track = l.track\n AND e.invalidated_at IS NULL AND (e.finished_at, e.id) < (l.finished_at, l.id)\n AND e.player_steamid64 = l.player_steamid64 AND e.time <= l.time\n )\n ORDER BY l.finished_at DESC, l.id DESC\n ", "describe": { "columns": [ { @@ -75,7 +75,7 @@ "type_info": "Int2", "origin": { "Table": { - "table": "map_tiers", + "table": "current_map_tiers", "name": "tier" } } @@ -162,7 +162,7 @@ false, false, false, - false, + true, null, false, null, @@ -172,5 +172,5 @@ true ] }, - "hash": "79f8a533b9ffccdb99dad6b682bac3b451a29743fab3da841bd22e572864ff19" + "hash": "cd24562230febd3f5cbef6bd3b0f52dec58960f3fbd47a69728e4e020db12a66" } diff --git a/api/.sqlx/query-cd642019090b4cdad7393d73198b396a9950973f74105558d979c8dabb664333.json b/api/.sqlx/query-cd642019090b4cdad7393d73198b396a9950973f74105558d979c8dabb664333.json new file mode 100644 index 0000000..5a8cd7c --- /dev/null +++ b/api/.sqlx/query-cd642019090b4cdad7393d73198b396a9950973f74105558d979c8dabb664333.json @@ -0,0 +1,14 @@ +{ + "db_name": "PostgreSQL", + "query": "\n INSERT INTO standings_boards (map_id, style, track, best, tier)\n SELECT b.map_id, b.style, b.track, b.best, t.tier\n FROM (SELECT map_id, style, track, min(time) AS best FROM personal_bests GROUP BY 1, 2, 3) b\n LEFT JOIN current_map_tiers t ON $1 AND t.map_id = b.map_id AND t.track = b.track\n ", + "describe": { + "columns": [], + "parameters": { + "Left": [ + "Bool" + ] + }, + "nullable": [] + }, + "hash": "cd642019090b4cdad7393d73198b396a9950973f74105558d979c8dabb664333" +} diff --git a/api/.sqlx/query-f59c5bfdd8ebefa4312bf431ce8f63aedc42365c6b6809b13146ec436ca8f7c2.json b/api/.sqlx/query-d26414df0abf398bda09dccdafcd315b7ba5f4c8c40779dde663ee8272e27ebe.json similarity index 57% rename from api/.sqlx/query-f59c5bfdd8ebefa4312bf431ce8f63aedc42365c6b6809b13146ec436ca8f7c2.json rename to api/.sqlx/query-d26414df0abf398bda09dccdafcd315b7ba5f4c8c40779dde663ee8272e27ebe.json index 4efb421..eedb98e 100644 --- a/api/.sqlx/query-f59c5bfdd8ebefa4312bf431ce8f63aedc42365c6b6809b13146ec436ca8f7c2.json +++ b/api/.sqlx/query-d26414df0abf398bda09dccdafcd315b7ba5f4c8c40779dde663ee8272e27ebe.json @@ -1,6 +1,6 @@ { "db_name": "PostgreSQL", - "query": "SELECT m.name, week.players AS \"players!\",\n (SELECT tier FROM map_tiers WHERE map_id = m.id AND track = 0 ORDER BY assigned_at DESC LIMIT 1)\n AS tier\n FROM (SELECT map_id, count(DISTINCT player_steamid64) AS players FROM runs\n WHERE invalidated_at IS NULL AND finished_at > now() - interval '7 days'\n GROUP BY map_id) week\n JOIN maps m ON m.id = week.map_id\n ORDER BY week.players DESC, m.name LIMIT $1", + "query": "SELECT m.name, week.players AS \"players!\",\n (SELECT tier FROM current_map_tiers WHERE map_id = m.id AND track = 0) AS tier\n FROM (SELECT map_id, count(DISTINCT player_steamid64) AS players FROM runs\n WHERE invalidated_at IS NULL AND finished_at > now() - interval '7 days'\n GROUP BY map_id) week\n JOIN maps m ON m.id = week.map_id\n ORDER BY week.players DESC, m.name LIMIT $1", "describe": { "columns": [ { @@ -38,5 +38,5 @@ null ] }, - "hash": "f59c5bfdd8ebefa4312bf431ce8f63aedc42365c6b6809b13146ec436ca8f7c2" + "hash": "d26414df0abf398bda09dccdafcd315b7ba5f4c8c40779dde663ee8272e27ebe" } diff --git a/api/.sqlx/query-193e0dc6d22809860b4dea9586b0edf496fe92c72a15be5c2b8948824a3d8b8f.json b/api/.sqlx/query-e3f2da6a4f3a50d27266595df7bae4b4440593c64f0391a05a9a99191b169bed.json similarity index 57% rename from api/.sqlx/query-193e0dc6d22809860b4dea9586b0edf496fe92c72a15be5c2b8948824a3d8b8f.json rename to api/.sqlx/query-e3f2da6a4f3a50d27266595df7bae4b4440593c64f0391a05a9a99191b169bed.json index 9c9760e..36105bc 100644 --- a/api/.sqlx/query-193e0dc6d22809860b4dea9586b0edf496fe92c72a15be5c2b8948824a3d8b8f.json +++ b/api/.sqlx/query-e3f2da6a4f3a50d27266595df7bae4b4440593c64f0391a05a9a99191b169bed.json @@ -1,15 +1,15 @@ { "db_name": "PostgreSQL", - "query": "SELECT tier FROM map_tiers WHERE map_id = $1 AND track = $2 ORDER BY assigned_at DESC LIMIT 1", + "query": "SELECT tier AS \"tier!\" FROM current_map_tiers WHERE map_id = $1 AND track = $2", "describe": { "columns": [ { "ordinal": 0, - "name": "tier", + "name": "tier!", "type_info": "Int2", "origin": { "Table": { - "table": "map_tiers", + "table": "current_map_tiers", "name": "tier" } } @@ -22,8 +22,8 @@ ] }, "nullable": [ - false + true ] }, - "hash": "193e0dc6d22809860b4dea9586b0edf496fe92c72a15be5c2b8948824a3d8b8f" + "hash": "e3f2da6a4f3a50d27266595df7bae4b4440593c64f0391a05a9a99191b169bed" } diff --git a/api/.sqlx/query-74493942786aa14a6e95ebe6198c28ffd2d175e76f4408e7706e54aedb353845.json b/api/.sqlx/query-e9f09b3277fa13f62738502dad4dcb41391bbe8710c67fe523098acc3af22b33.json similarity index 66% rename from api/.sqlx/query-74493942786aa14a6e95ebe6198c28ffd2d175e76f4408e7706e54aedb353845.json rename to api/.sqlx/query-e9f09b3277fa13f62738502dad4dcb41391bbe8710c67fe523098acc3af22b33.json index 2f81701..e61c244 100644 --- a/api/.sqlx/query-74493942786aa14a6e95ebe6198c28ffd2d175e76f4408e7706e54aedb353845.json +++ b/api/.sqlx/query-e9f09b3277fa13f62738502dad4dcb41391bbe8710c67fe523098acc3af22b33.json @@ -1,6 +1,6 @@ { "db_name": "PostgreSQL", - "query": "\n WITH listed AS (\n SELECT m.id, m.name, m.last_run_at, m.players, tier.tier,\n row_number() OVER (ORDER BY\n -- How well the name matches: exactly, by a word's start (\"candy\" in bhop_candy), or within.\n CASE WHEN $6::text IS NULL OR m.name = $6 THEN 0\n WHEN starts_with(m.name, $6) OR strpos(m.name, '_' || $6) > 0 THEN 1\n WHEN m.name ILIKE $1 ESCAPE '\\' THEN 2 ELSE 3 END,\n CASE WHEN m.name NOT ILIKE $1 ESCAPE '\\' THEN word_similarity($7, m.name) END DESC NULLS LAST,\n CASE WHEN $2 = 'recent' THEN m.last_run_at END DESC,\n CASE WHEN $2 = 'newest' THEN m.listed_at END DESC NULLS LAST,\n CASE $2 WHEN 'popular' THEN -m.players WHEN 'least_popular' THEN m.players END,\n CASE $2 WHEN 'hardest' THEN -tier.tier WHEN 'easiest' THEN tier.tier END NULLS LAST,\n CASE $2 WHEN 'longest_record' THEN -record.time WHEN 'shortest_record' THEN record.time END\n NULLS LAST,\n CASE WHEN $2 = 'newest_record' THEN record.finished_at END DESC NULLS LAST,\n CASE WHEN $2 = 'oldest_record' THEN record.finished_at END NULLS LAST,\n CASE WHEN $2 = 'name_desc' THEN m.name END DESC,\n m.name\n ) AS position\n FROM maps m\n LEFT JOIN LATERAL (SELECT tier FROM map_tiers WHERE map_id = m.id AND track = 0\n ORDER BY assigned_at DESC LIMIT 1) tier ON true\n -- Every map's record, read only for the sorts that need it: the page below reads the page's own.\n LEFT JOIN LATERAL (\n SELECT pb.time, r.finished_at\n FROM personal_bests pb JOIN runs r ON r.id = pb.run_id\n WHERE $2 IN ('longest_record', 'shortest_record', 'newest_record', 'oldest_record') AND pb.map_id = m.id AND pb.style = $5 AND pb.track = 0\n ORDER BY pb.time, r.finished_at\n LIMIT 1\n ) record ON true\n WHERE m.last_run_at IS NOT NULL AND ($1::text IS NULL OR m.name ILIKE $1 ESCAPE '\\' OR $7 <% m.name)\n AND ($8::bigint IS NULL OR $9 = EXISTS (\n SELECT 1 FROM personal_bests WHERE player_steamid64 = $8 AND map_id = m.id AND style = $5 AND track = 0))\n AND ($10::smallint IS NULL OR tier.tier = $10)\n ), page AS (\n SELECT * FROM listed WHERE position > $4 ORDER BY position LIMIT $3\n )\n SELECT page.name, ci.id AS \"image_id?\", ci.key AS \"image_key?\", ci.focus AS \"image_focus?\", page.last_run_at AS \"last_run_at!\", page.players::int8 AS \"players!\",\n counts.bonuses AS \"bonuses!\", page.tier AS \"tier?\",\n wr.time AS \"wr_time?\", wr.run_id AS \"wr_run_id?\", wr.finished_at AS \"wr_finished_at?\",\n p.steamid64::text AS \"wr_steamid64?\", p.name AS \"wr_name?\", p.avatar_url AS \"wr_avatar_url?\",\n p.country_code AS \"wr_country_code?\"\n FROM page\n LEFT JOIN map_images ci ON ci.map_id = page.id AND ci.position = 0\n CROSS JOIN LATERAL (\n SELECT count(DISTINCT track) FILTER (WHERE track > 0) AS bonuses\n FROM personal_bests WHERE map_id = page.id\n ) counts\n LEFT JOIN LATERAL (\n SELECT pb.player_steamid64, pb.time, pb.run_id, r.finished_at\n FROM personal_bests pb JOIN runs r ON r.id = pb.run_id\n WHERE pb.map_id = page.id AND pb.style = $5 AND pb.track = 0\n ORDER BY pb.time, r.finished_at\n LIMIT 1\n ) wr ON true\n LEFT JOIN players p ON p.steamid64 = wr.player_steamid64\n ORDER BY page.position\n ", + "query": "\n WITH listed AS (\n SELECT m.id, m.name, m.last_run_at, m.players, tier.tier,\n row_number() OVER (ORDER BY\n -- How well the name matches: exactly, by a word's start (\"candy\" in bhop_candy), or within.\n CASE WHEN $6::text IS NULL OR m.name = $6 THEN 0\n WHEN starts_with(m.name, $6) OR strpos(m.name, '_' || $6) > 0 THEN 1\n WHEN m.name ILIKE $1 ESCAPE '\\' THEN 2 ELSE 3 END,\n CASE WHEN m.name NOT ILIKE $1 ESCAPE '\\' THEN word_similarity($7, m.name) END DESC NULLS LAST,\n CASE WHEN $2 = 'recent' THEN m.last_run_at END DESC,\n CASE WHEN $2 = 'newest' THEN m.listed_at END DESC NULLS LAST,\n CASE $2 WHEN 'popular' THEN -m.players WHEN 'least_popular' THEN m.players END,\n CASE $2 WHEN 'hardest' THEN -tier.tier WHEN 'easiest' THEN tier.tier END NULLS LAST,\n CASE $2 WHEN 'longest_record' THEN -record.time WHEN 'shortest_record' THEN record.time END\n NULLS LAST,\n CASE WHEN $2 = 'newest_record' THEN record.finished_at END DESC NULLS LAST,\n CASE WHEN $2 = 'oldest_record' THEN record.finished_at END NULLS LAST,\n CASE WHEN $2 = 'name_desc' THEN m.name END DESC,\n m.name\n ) AS position\n FROM maps m\n LEFT JOIN current_map_tiers tier ON tier.map_id = m.id AND tier.track = 0\n -- Every map's record, read only for the sorts that need it: the page below reads the page's own.\n LEFT JOIN LATERAL (\n SELECT pb.time, r.finished_at\n FROM personal_bests pb JOIN runs r ON r.id = pb.run_id\n WHERE $2 IN ('longest_record', 'shortest_record', 'newest_record', 'oldest_record') AND pb.map_id = m.id AND pb.style = $5 AND pb.track = 0\n ORDER BY pb.time, r.finished_at\n LIMIT 1\n ) record ON true\n WHERE m.last_run_at IS NOT NULL AND ($1::text IS NULL OR m.name ILIKE $1 ESCAPE '\\' OR $7 <% m.name)\n AND ($8::bigint IS NULL OR $9 = EXISTS (\n SELECT 1 FROM personal_bests WHERE player_steamid64 = $8 AND map_id = m.id AND style = $5 AND track = 0))\n AND ($10::smallint IS NULL OR tier.tier = $10)\n ), page AS (\n SELECT * FROM listed WHERE position > $4 ORDER BY position LIMIT $3\n )\n SELECT page.name, ci.id AS \"image_id?\", ci.key AS \"image_key?\", ci.focus AS \"image_focus?\", page.last_run_at AS \"last_run_at!\", page.players::int8 AS \"players!\",\n counts.bonuses AS \"bonuses!\", page.tier AS \"tier?\",\n wr.time AS \"wr_time?\", wr.run_id AS \"wr_run_id?\", wr.finished_at AS \"wr_finished_at?\",\n p.steamid64::text AS \"wr_steamid64?\", p.name AS \"wr_name?\", p.avatar_url AS \"wr_avatar_url?\",\n p.country_code AS \"wr_country_code?\"\n FROM page\n LEFT JOIN map_images ci ON ci.map_id = page.id AND ci.position = 0\n CROSS JOIN LATERAL (\n SELECT count(DISTINCT track) FILTER (WHERE track > 0) AS bonuses\n FROM personal_bests WHERE map_id = page.id\n ) counts\n LEFT JOIN LATERAL (\n SELECT pb.player_steamid64, pb.time, pb.run_id, r.finished_at\n FROM personal_bests pb JOIN runs r ON r.id = pb.run_id\n WHERE pb.map_id = page.id AND pb.style = $5 AND pb.track = 0\n ORDER BY pb.time, r.finished_at\n LIMIT 1\n ) wr ON true\n LEFT JOIN players p ON p.steamid64 = wr.player_steamid64\n ORDER BY page.position\n ", "describe": { "columns": [ { @@ -76,7 +76,7 @@ "type_info": "Int2", "origin": { "Table": { - "table": "map_tiers", + "table": "current_map_tiers", "name": "tier" } } @@ -176,7 +176,7 @@ true, null, null, - false, + true, true, true, true, @@ -186,5 +186,5 @@ true ] }, - "hash": "74493942786aa14a6e95ebe6198c28ffd2d175e76f4408e7706e54aedb353845" + "hash": "e9f09b3277fa13f62738502dad4dcb41391bbe8710c67fe523098acc3af22b33" } diff --git a/api/crates/api/migrations/0052_current_map_tiers.sql b/api/crates/api/migrations/0052_current_map_tiers.sql new file mode 100644 index 0000000..e7b613d --- /dev/null +++ b/api/crates/api/migrations/0052_current_map_tiers.sql @@ -0,0 +1,8 @@ +-- The tier in force per map and track: the newest assignment in `map_tiers`, which is append-only history. +-- Queries read this instead of each repeating "newest first, take one" (14 copies before it). Conditions on +-- map_id and track reach the primary key through the view, so one map's or track's lookup still reads only its +-- own rows. It says nothing of whether tiers are in force yet (the `tiers` policy); callers still decide that. +CREATE VIEW current_map_tiers AS +SELECT DISTINCT ON (map_id, track) map_id, track, tier, assigned_at, assigned_by +FROM map_tiers +ORDER BY map_id, track, assigned_at DESC; diff --git a/api/crates/api/src/leaderboards/standings.rs b/api/crates/api/src/leaderboards/standings.rs index ae609f5..92e2d72 100644 --- a/api/crates/api/src/leaderboards/standings.rs +++ b/api/crates/api/src/leaderboards/standings.rs @@ -150,8 +150,8 @@ async fn refresh( SELECT b.map_id, b.style, b.track, (SELECT min(pb.time) FROM personal_bests pb WHERE pb.map_id = b.map_id AND pb.style = b.style AND pb.track = b.track) AS best, - CASE WHEN $5 THEN (SELECT t.tier FROM map_tiers t WHERE t.map_id = b.map_id AND t.track = b.track - ORDER BY t.assigned_at DESC LIMIT 1) END AS tier + CASE WHEN $5 THEN (SELECT t.tier FROM current_map_tiers t + WHERE t.map_id = b.map_id AND t.track = b.track) END AS tier FROM unnest($1::int8[], $2::text[], $3::int2[]) AS b (map_id, style, track) ), runners AS MATERIALIZED ( SELECT DISTINCT player_steamid64, style, track > 0 AS bonus FROM runs WHERE id = ANY($4) @@ -262,14 +262,10 @@ pub async fn refresh_all(conn: &mut PgConnection) -> Result<(), sqlx::Error> { .await?; sqlx::query!( r#" - WITH tiers AS ( - SELECT DISTINCT ON (map_id, track) map_id, track, tier FROM map_tiers - WHERE $1 ORDER BY map_id, track, assigned_at DESC - ) INSERT INTO standings_boards (map_id, style, track, best, tier) SELECT b.map_id, b.style, b.track, b.best, t.tier FROM (SELECT map_id, style, track, min(time) AS best FROM personal_bests GROUP BY 1, 2, 3) b - LEFT JOIN tiers t ON t.map_id = b.map_id AND t.track = b.track + LEFT JOIN current_map_tiers t ON $1 AND t.map_id = b.map_id AND t.track = b.track "#, formula.tiers ) diff --git a/api/crates/api/src/maps/detail.rs b/api/crates/api/src/maps/detail.rs index 9b638ae..6e3f3ae 100644 --- a/api/crates/api/src/maps/detail.rs +++ b/api/crates/api/src/maps/detail.rs @@ -178,8 +178,7 @@ async fn tracks( pb.track, pb.style, pb.time, pb.run_id, r.finished_at, count(*) OVER (PARTITION BY pb.track, pb.style) AS "players!", p.steamid64::text AS "steamid64!", p.name, p.avatar_url, p.country_code, - (SELECT tier FROM map_tiers WHERE map_id = pb.map_id AND track = pb.track - ORDER BY assigned_at DESC LIMIT 1) AS tier + (SELECT tier FROM current_map_tiers WHERE map_id = pb.map_id AND track = pb.track) AS tier FROM personal_bests pb JOIN runs r ON r.id = pb.run_id JOIN players p ON p.steamid64 = pb.player_steamid64 diff --git a/api/crates/api/src/maps/list.rs b/api/crates/api/src/maps/list.rs index ad52592..601869b 100644 --- a/api/crates/api/src/maps/list.rs +++ b/api/crates/api/src/maps/list.rs @@ -247,8 +247,7 @@ pub async fn list_maps( async fn map_stats(db: &sqlx::PgPool, tier_count: Option) -> Result { let rows = sqlx::query!( r#"SELECT tier.tier AS "tier?", count(*) AS "maps!" FROM maps m - LEFT JOIN LATERAL (SELECT tier FROM map_tiers WHERE map_id = m.id AND track = 0 - ORDER BY assigned_at DESC LIMIT 1) tier ON true + LEFT JOIN current_map_tiers tier ON tier.map_id = m.id AND tier.track = 0 WHERE m.last_run_at IS NOT NULL GROUP BY tier.tier"# ) @@ -266,8 +265,7 @@ async fn map_stats(db: &sqlx::PgPool, tier_count: Option) -> Result) -> Result now() - interval '7 days' GROUP BY map_id) week @@ -395,8 +392,7 @@ async fn listed_page( m.name ) AS position FROM maps m - LEFT JOIN LATERAL (SELECT tier FROM map_tiers WHERE map_id = m.id AND track = 0 - ORDER BY assigned_at DESC LIMIT 1) tier ON true + LEFT JOIN current_map_tiers tier ON tier.map_id = m.id AND tier.track = 0 -- Every map's record, read only for the sorts that need it: the page below reads the page's own. LEFT JOIN LATERAL ( SELECT pb.time, r.finished_at @@ -516,8 +512,7 @@ async fn count_maps(tx: &mut sqlx::PgConnection, filter: &Filter<'_>) -> Result< WHERE last_run_at IS NOT NULL AND ($1::text IS NULL OR name ILIKE $1 ESCAPE '\' OR $2 <% name) AND ($3::bigint IS NULL OR $4 = EXISTS ( SELECT 1 FROM personal_bests WHERE player_steamid64 = $3 AND map_id = m.id AND style = $5 AND track = 0)) - AND ($6::smallint IS NULL OR $6 = (SELECT tier FROM map_tiers WHERE map_id = m.id AND track = 0 - ORDER BY assigned_at DESC LIMIT 1))"#, + AND ($6::smallint IS NULL OR $6 = (SELECT tier FROM current_map_tiers WHERE map_id = m.id AND track = 0))"#, filter.pattern, filter.near, filter.completed_by, diff --git a/api/crates/api/src/record_events/discord/post.rs b/api/crates/api/src/record_events/discord/post.rs index fb56fc9..7d66f27 100644 --- a/api/crates/api/src/record_events/discord/post.rs +++ b/api/crates/api/src/record_events/discord/post.rs @@ -133,8 +133,7 @@ async fn records( AND o.player_steamid64 = r.player_steamid64 AND o.invalidated_at IS NULL AND (o.finished_at, o.id) < (r.finished_at, r.id)) AS previous_personal_best, - (SELECT tier FROM map_tiers WHERE map_id = r.map_id AND track = r.track - ORDER BY assigned_at DESC LIMIT 1) AS tier, + (SELECT tier FROM current_map_tiers WHERE map_id = r.map_id AND track = r.track) AS tier, (SELECT key FROM map_images WHERE map_id = r.map_id AND position = 0) AS image_key, (SELECT host(h.ip) || ':' || h.port FROM server_heartbeats h JOIN server_listings l ON l.ip = h.ip AND l.port = h.port diff --git a/api/crates/api/src/runs/detail.rs b/api/crates/api/src/runs/detail.rs index 138ce95..ae70313 100644 --- a/api/crates/api/src/runs/detail.rs +++ b/api/crates/api/src/runs/detail.rs @@ -93,8 +93,7 @@ pub async fn run_detail( EXISTS (SELECT 1 FROM personal_bests WHERE run_id = r.id) AS "personal_best!", (SELECT min(time) FROM personal_bests WHERE map_id = r.map_id AND style = r.style AND track = r.track) AS world_record_time, - (SELECT tier FROM map_tiers WHERE map_id = r.map_id AND track = r.track - ORDER BY assigned_at DESC LIMIT 1) AS tier, + (SELECT tier FROM current_map_tiers WHERE map_id = r.map_id AND track = r.track) AS tier, ci.id AS "image_id?", ci.key AS "image_key?", ci.focus AS "image_focus?", (SELECT host(h.ip) || ':' || h.port FROM server_heartbeats h JOIN server_listings l ON l.ip = h.ip AND l.port = h.port diff --git a/api/crates/api/src/runs/recent.rs b/api/crates/api/src/runs/recent.rs index 00d0416..5b576f3 100644 --- a/api/crates/api/src/runs/recent.rs +++ b/api/crates/api/src/runs/recent.rs @@ -162,8 +162,7 @@ async fn page( SELECT r.id, r.map_id, r.style, r.track, r.player_steamid64, r.time, r.finished_at, r.was_record, tier.tier FROM runs r - LEFT JOIN LATERAL (SELECT tier FROM map_tiers WHERE map_id = r.map_id AND track = r.track - ORDER BY assigned_at DESC LIMIT 1) tier ON $7 + LEFT JOIN current_map_tiers tier ON $7 AND tier.map_id = r.map_id AND tier.track = r.track WHERE r.invalidated_at IS NULL AND (NOT $4 OR r.was_record) AND ($1::text IS NULL OR r.style = $1) diff --git a/api/crates/api/src/staff/maps.rs b/api/crates/api/src/staff/maps.rs index d8beadf..b6ac38d 100644 --- a/api/crates/api/src/staff/maps.rs +++ b/api/crates/api/src/staff/maps.rs @@ -69,7 +69,7 @@ pub async fn set_tier( .await? .ok_or(NO_MAP)?; let in_force = sqlx::query_scalar!( - "SELECT tier FROM map_tiers WHERE map_id = $1 AND track = $2 ORDER BY assigned_at DESC LIMIT 1", + r#"SELECT tier AS "tier!" FROM current_map_tiers WHERE map_id = $1 AND track = $2"#, map_id, track ) @@ -309,8 +309,7 @@ pub async fn list_staff_maps( let rows = sqlx::query!( r#" SELECT m.name, ci.id AS "image_id?", ci.key AS "image_key?", ci.focus AS "image_focus?", m.last_run_at, - (SELECT tier FROM map_tiers t WHERE t.map_id = m.id AND t.track = 0 - ORDER BY assigned_at DESC LIMIT 1) AS tier, + (SELECT tier FROM current_map_tiers t WHERE t.map_id = m.id AND t.track = 0) AS tier, (SELECT max(version) FROM map_zones z WHERE z.map_id = m.id) AS zone_version FROM maps m LEFT JOIN map_images ci ON ci.map_id = m.id AND ci.position = 0 diff --git a/api/crates/api/src/staff/policies.rs b/api/crates/api/src/staff/policies.rs index 1699991..1a7ae60 100644 --- a/api/crates/api/src/staff/policies.rs +++ b/api/crates/api/src/staff/policies.rs @@ -43,9 +43,7 @@ pub async fn publish_policy( // A smaller count would leave maps rated above it; staff move those first. let highest = sqlx::query_scalar!( r#" - SELECT max(tier) FROM ( - SELECT DISTINCT ON (map_id, track) tier FROM map_tiers ORDER BY map_id, track, assigned_at DESC - ) in_force + SELECT max(tier) FROM current_map_tiers "# ) .fetch_one(&mut *tx) From a27de7966a6f632868ce3cc2e661c7b43a35a330 Mon Sep 17 00:00:00 2001 From: Ayberk Alcan Date: Sat, 7 Nov 2026 23:13:00 +0300 Subject: [PATCH 04/11] Build the API on Windows: listen for SIGTERM only on Unix tokio's Unix signals don't exist on other systems, so the API didn't compile on Windows at all, which kept contributors there from running its tests or the API itself. On Unix nothing changes: systemd still stops it with SIGTERM and in-flight requests finish. Elsewhere it stops with Ctrl+C. --- api/crates/api/src/main.rs | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/api/crates/api/src/main.rs b/api/crates/api/src/main.rs index 0d66454..7a069bf 100644 --- a/api/crates/api/src/main.rs +++ b/api/crates/api/src/main.rs @@ -477,6 +477,8 @@ async fn shutdown_signal() { let ctrl_c = async { tokio::signal::ctrl_c().await.ok(); }; + // SIGTERM exists only on Unix; elsewhere (a contributor's Windows machine) Ctrl+C is the only way to stop. + #[cfg(unix)] let terminate = async { if let Ok(mut sig) = tokio::signal::unix::signal(tokio::signal::unix::SignalKind::terminate()) @@ -484,6 +486,8 @@ async fn shutdown_signal() { sig.recv().await; } }; + #[cfg(not(unix))] + let terminate = std::future::pending::<()>(); tokio::select! { () = ctrl_c => {}, () = terminate => {}, From 662ec46e37bb35373655ebb6278f3a7866951488 Mon Sep 17 00:00:00 2001 From: Ayberk Alcan Date: Sat, 7 Nov 2026 23:23:49 +0300 Subject: [PATCH 05/11] Let players sign out everywhere A session lasts 30 days from its last use, and signing out ended only the browser it came from, so a session left on someone else's computer stayed signed in with no way to end it. POST /v1/auth/sign-out-everywhere ends every session of the signed-in player and clears this browser's cookie; like sign-out, it needs our Origin, and without a live session it only clears the cookie. The account menu has "Sign out everywhere" under "Sign out", as a plain form post like it. docs/site-api.md drops where the auth endpoints are served from (Caddy or Next.js), which docs/deploy.md has, to stay within its size budget. --- ...006af20e5491663e23e7d4dc6416ebee0a020.json | 14 ++++ api/crates/api/src/auth.rs | 74 +++++++++++++++++++ api/crates/api/src/auth/sessions.rs | 11 +++ api/openapi.json | 38 ++++++++++ docs/site-api.md | 4 +- web/src/api/schema.ts | 50 +++++++++++++ web/src/features/site/AccountMenu.tsx | 16 +++- 7 files changed, 203 insertions(+), 4 deletions(-) create mode 100644 api/.sqlx/query-75a9b88f71b7718e03b201065fb006af20e5491663e23e7d4dc6416ebee0a020.json diff --git a/api/.sqlx/query-75a9b88f71b7718e03b201065fb006af20e5491663e23e7d4dc6416ebee0a020.json b/api/.sqlx/query-75a9b88f71b7718e03b201065fb006af20e5491663e23e7d4dc6416ebee0a020.json new file mode 100644 index 0000000..1d2e98d --- /dev/null +++ b/api/.sqlx/query-75a9b88f71b7718e03b201065fb006af20e5491663e23e7d4dc6416ebee0a020.json @@ -0,0 +1,14 @@ +{ + "db_name": "PostgreSQL", + "query": "DELETE FROM sessions WHERE player_steamid64 = $1", + "describe": { + "columns": [], + "parameters": { + "Left": [ + "Int8" + ] + }, + "nullable": [] + }, + "hash": "75a9b88f71b7718e03b201065fb006af20e5491663e23e7d4dc6416ebee0a020" +} diff --git a/api/crates/api/src/auth.rs b/api/crates/api/src/auth.rs index cda6ca2..8bfa556 100644 --- a/api/crates/api/src/auth.rs +++ b/api/crates/api/src/auth.rs @@ -75,6 +75,7 @@ pub fn routes() -> OpenApiRouter { .routes(routes!(start)) .routes(routes!(callback)) .routes(routes!(sign_out)) + .routes(routes!(sign_out_everywhere)) .routes(routes!(me)) } @@ -189,6 +190,37 @@ async fn sign_out( )) } +/// Ends every session of the signed-in player, in every browser, and signs this one out. A form on the +/// website posts here. Without a live session it only clears this browser's cookie, as signing out does. +#[utoipa::path( + post, + path = "/v1/auth/sign-out-everywhere", + tag = "auth", + params(ReturnQuery), + responses( + (status = SEE_OTHER, description = "Back to the page the player came from, signed out everywhere"), + (status = FORBIDDEN, description = "Not sent from SourceJump's own pages", body = ErrorBody), + ), +)] +async fn sign_out_everywhere( + State(state): State, + headers: HeaderMap, + jar: CookieJar, + signed_in: Option, + Query(query): Query, +) -> Result<(CookieJar, Redirect), ApiError> { + sessions::require_same_origin(&headers, &state.public_url)?; + if let Some(signed_in) = signed_in { + sessions::end_all(&state.db, signed_in.steamid64).await?; + tracing::info!(steamid64 = %signed_in.steamid64, "signed out everywhere"); + } + let return_to = ReturnTo::new(query.return_to.as_deref()); + Ok(( + jar.remove(sessions::removal_cookie()), + Redirect::to(return_to.as_str()), + )) +} + /// The signed-in player, from the session cookie. #[utoipa::path( get, @@ -405,6 +437,48 @@ mod tests { assert_eq!(me_with(&state, &token).await.status, 401); } + #[sqlx::test] + async fn signing_out_everywhere_ends_every_session_of_the_player_only(db: PgPool) { + let state = state(&db, fake_steam(true).await); + let token = session_from(&sign_in(&state).await); + let player = players::SteamId64::try_from(openid::tests::PLAYER.to_owned()).unwrap(); + // The same player signed in on another computer, and someone else signed in. + let elsewhere = sessions::create(&db, player).await.unwrap(); + let other = players::SteamId64::try_from("76561197960287931".to_owned()).unwrap(); + players::ensure_exists(&db, other).await.unwrap(); + let someone_else = sessions::create(&db, other).await.unwrap(); + let sign_out_everywhere = |origin: &'static str| { + test_client::send_to( + state.clone(), + Request::post("/v1/auth/sign-out-everywhere?return_to=/maps") + .header(header::COOKIE, format!("sj_session={token}")) + .header(header::ORIGIN, origin) + .body(Body::empty()) + .unwrap(), + ) + }; + + assert_eq!( + sign_out_everywhere("https://evil.example").await.status, + 403 + ); + assert_eq!(me_with(&state, &elsewhere).await.status, 200); + + let response = sign_out_everywhere("https://sourcejump.test").await; + assert_eq!(response.status, 303); + assert_eq!(response.headers[header::LOCATION], "/maps"); + let removed = set_cookie(&response, "sj_session").expect("the session cookie is removed"); + assert!(removed.starts_with("sj_session=;"), "{removed}"); + assert_eq!(me_with(&state, &token).await.status, 401); + assert_eq!(me_with(&state, &elsewhere).await.status, 401); + assert_eq!(me_with(&state, &someone_else).await.status, 200); + + // Again without a live session: nothing to end, and the same way back. + let again = sign_out_everywhere("https://sourcejump.test").await; + assert_eq!(again.status, 303); + assert_eq!(again.headers[header::LOCATION], "/maps"); + } + #[sqlx::test] async fn start_sends_the_browser_to_steam(db: PgPool) { let response = test_client::get(&db, "/v1/auth/steam?return_to=//evil.example").await; diff --git a/api/crates/api/src/auth/sessions.rs b/api/crates/api/src/auth/sessions.rs index f7e99f2..cc5b484 100644 --- a/api/crates/api/src/auth/sessions.rs +++ b/api/crates/api/src/auth/sessions.rs @@ -40,6 +40,17 @@ pub async fn create(db: &PgPool, steamid64: SteamId64) -> Result Result<(), sqlx::Error> { + sqlx::query!( + "DELETE FROM sessions WHERE player_steamid64 = $1", + steamid64.get() + ) + .execute(db) + .await?; + Ok(()) +} + pub async fn end(db: &PgPool, token: &str) -> Result<(), sqlx::Error> { sqlx::query!("DELETE FROM sessions WHERE hash = $1", &hash(token)[..]) .execute(db) diff --git a/api/openapi.json b/api/openapi.json index 91d277d..61953b4 100644 --- a/api/openapi.json +++ b/api/openapi.json @@ -134,6 +134,44 @@ } } }, + "/v1/auth/sign-out-everywhere": { + "post": { + "tags": [ + "auth" + ], + "summary": "Ends every session of the signed-in player, in every browser, and signs this one out. A form on the\nwebsite posts here. Without a live session it only clears this browser's cookie, as signing out does.", + "operationId": "sign_out_everywhere", + "parameters": [ + { + "name": "return_to", + "in": "query", + "description": "The page to come back to: a path on this site, such as `/maps`. Anything else means `/`.", + "required": false, + "schema": { + "type": [ + "string", + "null" + ] + } + } + ], + "responses": { + "303": { + "description": "Back to the page the player came from, signed out everywhere" + }, + "403": { + "description": "Not sent from SourceJump's own pages", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/ErrorBody" + } + } + } + } + } + } + }, "/v1/auth/steam": { "get": { "tags": [ diff --git a/docs/site-api.md b/docs/site-api.md index 36ecdcd..3465927 100644 --- a/docs/site-api.md +++ b/docs/site-api.md @@ -2,11 +2,11 @@ What the endpoints behind the website do: sign-in, players, maps, the server list and community posts; the staff tools are in `staff-api.md`. Rules for every client (errors, retries, SteamIDs) and game servers' endpoints: `api.md`. ## Sign-in and sessions -Players sign in with Steam (OpenID 2.0); the endpoints answer browsers (redirects, cookies) via the site's origin (Caddy in production, Next.js locally). +Players sign in with Steam (OpenID 2.0); the endpoints answer browsers (redirects, cookies) via the site's origin. - Steam must confirm its answer (`check_authentication`). Only signed fields are read, the return URL must be our callback, a nonce works once, under 5 minutes old (`openid_nonces`). The callback URL must carry the value `/v1/auth/steam` put in the `sj_sign_in` cookie, tying sign-in to its browser. Refused: `/sign-in/failed`; cancelled: back where they were. - `return_to` must be a path on our site; anything else becomes `/`. - A session is 32 random bytes in the `sj_session` cookie (`HttpOnly; Secure; SameSite=Lax`). Only the SHA-256 is stored. It lasts 30 days from last use (expiry moves at most daily). -- Sign-out also requires our `Origin` header. A missing session answers `401` without `WWW-Authenticate`. +- Sign-out, and `…/sign-out-everywhere` (all their sessions), need our `Origin` header. A missing session answers `401` without `WWW-Authenticate`. - `SJ_PUBLIC_URL` is where players reach the site; redirects and the origin check use it. ## Players and privileges diff --git a/web/src/api/schema.ts b/web/src/api/schema.ts index 239e647..6492e9b 100644 --- a/web/src/api/schema.ts +++ b/web/src/api/schema.ts @@ -55,6 +55,26 @@ export interface paths { patch?: never; trace?: never; }; + "/v1/auth/sign-out-everywhere": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + get?: never; + put?: never; + /** + * Ends every session of the signed-in player, in every browser, and signs this one out. A form on the + * website posts here. Without a live session it only clears this browser's cookie, as signing out does. + */ + post: operations["sign_out_everywhere"]; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; "/v1/auth/steam": { parameters: { query?: never; @@ -3559,6 +3579,36 @@ export interface operations { }; }; }; + sign_out_everywhere: { + parameters: { + query?: { + /** @description The page to come back to: a path on this site, such as `/maps`. Anything else means `/`. */ + return_to?: string | null; + }; + header?: never; + path?: never; + cookie?: never; + }; + requestBody?: never; + responses: { + /** @description Back to the page the player came from, signed out everywhere */ + 303: { + headers: { + [name: string]: unknown; + }; + content?: never; + }; + /** @description Not sent from SourceJump's own pages */ + 403: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": components["schemas"]["ErrorBody"]; + }; + }; + }; + }; start: { parameters: { query?: { diff --git a/web/src/features/site/AccountMenu.tsx b/web/src/features/site/AccountMenu.tsx index 4ef1ddc..ffcb117 100644 --- a/web/src/features/site/AccountMenu.tsx +++ b/web/src/features/site/AccountMenu.tsx @@ -1,6 +1,6 @@ "use client"; -// The signed-in player's menu: their profile, the staff area for staff, and signing out. -import { LogOut, ShieldCheck, User } from "lucide-react"; +// The signed-in player's menu: their profile, the staff area for staff, and signing out, here or everywhere. +import { LogOut, MonitorX, ShieldCheck, User } from "lucide-react"; import type { Schemas } from "@/api/client"; import { isStaff } from "@/features/staff/sections"; import { Avatar } from "@/ui/Avatar"; @@ -8,6 +8,7 @@ import { Menu, MenuItem, MenuLink, MenuSeparator } from "@/ui/Menu"; import { useReturnTo } from "./useReturnTo"; const SIGN_OUT_FORM = "sign-out"; +const SIGN_OUT_EVERYWHERE_FORM = "sign-out-everywhere"; export function AccountMenu({ me }: { me: Schemas["Me"] }) { const returnTo = useReturnTo(); @@ -20,6 +21,13 @@ export function AccountMenu({ me }: { me: Schemas["Me"] }) { action={`/v1/auth/sign-out?return_to=${encodeURIComponent(returnTo)}`} hidden /> + {/* Ends the player's sessions in every browser, such as one left signed in on someone else's computer. */} +