Add gauntlet race and pantheon day-one fields for placement badges

open-api/openapi.json

@@ -316,7 +316,7 @@
           },
           "isDayOne": {
             "type": "boolean",
-            "description": "If the instance was completed before the day one end date"
+            "description": "If the instance was completed within 24 hours of release. For pantheon modes, uses the version release date (release_date_override when set); otherwise uses the activity day_one_end."
           },
           "isContest": {
             "type": "boolean",
@@ -326,6 +326,10 @@
             "type": "boolean",
             "description": "If the instance was completed before the week one end date"
           },
+          "isPantheon": {
+            "type": "boolean",
+            "description": "If the instance is a pantheon activity mode"
+          },
           "isBlacklisted": {
             "type": "boolean",
             "description": "If the instance is blacklisted from leaderboards"
@@ -351,6 +355,7 @@
           "isDayOne",
           "isContest",
           "isWeekOne",
+          "isPantheon",
           "isBlacklisted"
         ],
         "additionalProperties": false
@@ -1727,6 +1732,9 @@
           },
           "isChallengeMode": {
             "type": "boolean"
+          },
+          "isGauntletRace": {
+            "type": "boolean"
           }
         },
         "required": [
@@ -1740,6 +1748,49 @@
           "isChallengeMode"
         ]
       },
+      "GauntletRaceEntry": {
+        "type": "object",
+        "properties": {
+          "instanceId": {
+            "type": "string",
+            "format": "int64"
+          },
+          "rank": {
+            "type": "integer",
+            "minimum": 0,
+            "exclusiveMinimum": true
+          },
+          "versionId": {
+            "type": "integer",
+            "minimum": 0,
+            "exclusiveMinimum": true
+          }
+        },
+        "required": ["instanceId", "rank", "versionId"]
+      },
+      "PantheonVersionFirstEntry": {
+        "type": "object",
+        "properties": {
+          "versionId": {
+            "type": "integer",
+            "minimum": 0,
+            "exclusiveMinimum": true
+          },
+          "instanceId": {
+            "type": "string",
+            "format": "int64"
+          },
+          "rank": {
+            "type": "integer",
+            "minimum": 0,
+            "exclusiveMinimum": true
+          },
+          "isDayOne": {
+            "type": "boolean"
+          }
+        },
+        "required": ["versionId", "instanceId", "rank", "isDayOne"]
+      },
       "Teammate": {
         "type": "object",
         "properties": {
@@ -2546,9 +2597,26 @@
               "nullable": true,
               "$ref": "#/components/schemas/WorldFirstEntry"
             }
+          },
+          "gauntletRaceEntry": {
+            "nullable": true,
+            "$ref": "#/components/schemas/GauntletRaceEntry"
+          },
+          "pantheonVersionFirstEntries": {
+            "type": "object",
+            "additionalProperties": {
+              "nullable": true,
+              "$ref": "#/components/schemas/PantheonVersionFirstEntry"
+            }
           }
         },
-        "required": ["playerInfo", "stats", "worldFirstEntries"]
+        "required": [
+          "playerInfo",
+          "stats",
+          "worldFirstEntries",
+          "gauntletRaceEntry",
+          "pantheonVersionFirstEntries"
+        ]
       },
       "PlayerTeammatesResponse": {
         "type": "array",
@@ -2606,6 +2674,9 @@
                 "minimum": 0,
                 "exclusiveMinimum": true
               },
+              "isGauntletRace": {
+                "type": "boolean"
+              },
               "metadata": {
                 "$ref": "#/components/schemas/InstanceMetadata"
               },
@@ -2616,7 +2687,12 @@
                 }
               }
             },
-            "required": ["leaderboardRank", "metadata", "players"],
+            "required": [
+              "leaderboardRank",
+              "isGauntletRace",
+              "metadata",
+              "players"
+            ],
             "additionalProperties": false
           }
         ]

src/routes/player/membershipId/profile.ts

@@ -7,6 +7,8 @@
 import { zBigIntString } from "@/schema/input"
 import { zInt64 } from "@/schema/output"
 import {
+    getGauntletRaceEntry,
+    getPantheonVersionFirstEntries,
     getPlayer,
     getPlayerActivityStats,
     getPlayerGlobalStats,
@@ -52,7 +54,9 @@
         const statsPromises = Promise.all([
             getPlayerActivityStats(membershipId),
             getPlayerGlobalStats(membershipId),
-            getWorldFirstEntries(membershipId)
+            getWorldFirstEntries(membershipId),
+            getGauntletRaceEntry(membershipId),
+            getPantheonVersionFirstEntries(membershipId)
         ])
 
         const player = await getPlayer(membershipId)
@@ -70,10 +74,16 @@
             return RaidHubRoute.fail(ErrorCode.PlayerPrivateProfileError, { membershipId })
         }
 
-        const [activityStats, globalStats, worldFirstEntries] = await statsPromises
+        const [
+            activityStats,
+            globalStats,
+            worldFirstEntries,
+            gauntletRaceEntry,
+            pantheonVersionFirstEntries
+        ] = await statsPromises
 
         if (!globalStats) {
             throw new Error(`Unexpected error: global stats for player ${membershipId} not found`)
         }
 
         return RaidHubRoute.ok({
@@ -84,12 +94,16 @@
             },
             worldFirstEntries: Object.fromEntries(
                 worldFirstEntries.map(
                     entry =>
                         [entry.activityId, entry.rank === null ? null : entry] as [
                             number,
                             WorldFirstEntry | null
                         ]
                 )
+            ),
+            gauntletRaceEntry,
+            pantheonVersionFirstEntries: Object.fromEntries(
+                pantheonVersionFirstEntries.map(entry => [entry.versionId, entry])
             )
         })
     }

src/schema/components/Instance.ts

@@ -38,7 +38,8 @@ export const zInstance = registry.register(
             activityId: zNaturalNumber(),
             versionId: zNaturalNumber(),
             isDayOne: z.boolean().openapi({
-                description: "If the instance was completed before the day one end date"
+                description:
+                    "If the instance was completed within 24 hours of release. For pantheon modes, uses the version release date (release_date_override when set); otherwise uses the activity day_one_end."
             }),
             isContest: z.boolean().openapi({
                 description:
@@ -47,6 +48,9 @@ export const zInstance = registry.register(
             isWeekOne: z.boolean().openapi({
                 description: "If the instance was completed before the week one end date"
             }),
+            isPantheon: z.boolean().openapi({
+                description: "If the instance is a pantheon activity mode"
+            }),
             isBlacklisted: z.boolean().openapi({
                 description: "If the instance is blacklisted from leaderboards"
             })

src/schema/components/InstanceExtended.ts

@@ -9,6 +9,7 @@ export type InstanceExtended = z.input<typeof zInstanceExtended>
 export const zInstanceExtended = zInstance
     .extend({
         leaderboardRank: zNaturalNumber().nullable(),
+        isGauntletRace: z.boolean(),
         metadata: zInstanceMetadata,
         players: z.array(zInstancePlayerExtended)
     })

src/schema/components/PlayerProfile.ts

@@ -49,7 +49,29 @@ export const zWorldFirstEntry = registry.register(
         isDayOne: z.boolean(),
         isContest: z.boolean(),
         isWeekOne: z.boolean(),
-        isChallengeMode: z.boolean()
+        isChallengeMode: z.boolean(),
+        isGauntletRace: z.boolean().optional()
+    })
+)
+
+export type GauntletRaceEntry = z.input<typeof zGauntletRaceEntry>
+export const zGauntletRaceEntry = registry.register(
+    "GauntletRaceEntry",
+    z.object({
+        instanceId: zInt64(),
+        rank: zNaturalNumber(),
+        versionId: zNaturalNumber()
+    })
+)
+
+export type PantheonVersionFirstEntry = z.input<typeof zPantheonVersionFirstEntry>
+export const zPantheonVersionFirstEntry = registry.register(
+    "PantheonVersionFirstEntry",
+    z.object({
+        versionId: zNaturalNumber(),
+        instanceId: zInt64(),
+        rank: zNaturalNumber(),
+        isDayOne: z.boolean()
     })
 )
 
@@ -61,5 +83,10 @@ export const zPlayerProfile = z.object({
         global: zPlayerProfileGlobalStats,
         activity: z.record(zNumericalRecordKey(), zPlayerProfileActivityStats)
     }),
-    worldFirstEntries: z.record(zNumericalRecordKey(), zWorldFirstEntry.nullable())
+    worldFirstEntries: z.record(zNumericalRecordKey(), zWorldFirstEntry.nullable()),
+    gauntletRaceEntry: zGauntletRaceEntry.nullable(),
+    pantheonVersionFirstEntries: z.record(
+        zNumericalRecordKey(),
+        zPantheonVersionFirstEntry.nullable()
+    )
 })

src/services/instance/instance.test.ts

@@ -197,7 +197,8 @@ describe("getLeaderboardEntryForInstance", () => {
 
         const parsed = z
             .object({
-                rank: z.number().int()
+                rank: z.number().int(),
+                isGauntletRace: z.boolean()
             })
             .nullable()
             .safeParse(data)

src/services/instance/instance.ts

@@ -10,6 +10,7 @@
 import { InstancePlayerExtended } from "@/schema/components/InstancePlayerExtended"
 import { PlayerInfo } from "@/schema/components/PlayerInfo"
 import { attachDifficultyTier, resolveDifficultyTier } from "@/services/difficulty-tier/resolve"
+import { SQL_IS_DAY_ONE, SQL_IS_PANTHEON } from "@/services/instance/is-day-one"
 
 type InstanceRow = Omit<Instance, "difficultyTier">
 
@@ -31,7 +32,7 @@
             instance.season_id::int AS "season",
             instance.duration::int AS "duration",
             instance.platform_type AS "platformType",
-            instance.date_completed < COALESCE(activity_definition.day_one_end, TIMESTAMP 'epoch') AS "isDayOne",
+            ${SQL_IS_DAY_ONE} AS "isDayOne",
             (
                 CASE
                     WHEN ig_cact.activity_id IS NOT NULL THEN (
@@ -42,7 +43,8 @@
                 END
             ) AS "isContest",
             instance.date_completed < COALESCE(activity_definition.week_one_end, TIMESTAMP 'epoch') AS "isWeekOne",
-            (b.instance_id IS NOT NULL AND NOT COALESCE(instance.is_whitelisted, false)) AS "isBlacklisted"
+            (b.instance_id IS NOT NULL AND NOT COALESCE(instance.is_whitelisted, false)) AS "isBlacklisted",
+            ${SQL_IS_PANTHEON} AS "isPantheon"
         FROM instance
         INNER JOIN activity_version av USING (hash)
         INNER JOIN activity_definition ON activity_definition.id = av.activity_id
@@ -162,9 +164,12 @@
         }
         const instanceMetadataPromise = getInstanceMetadataByHash(instance.hash)
 
+        const leaderboardEntry = await leaderboardEntryPromise
+
         return {
             ...instance,
-            leaderboardRank: await leaderboardEntryPromise.then(entry => entry?.rank || null),
+            leaderboardRank: leaderboardEntry?.rank ?? null,
+            isGauntletRace: leaderboardEntry?.isGauntletRace ?? false,
             metadata: await instanceMetadataPromise,
             players: await instancePlayersPromise
         }
@@ -187,7 +192,7 @@
         { params: [hash.toString()] }
     )
     if (!metaData) {
         throw new Error("Metadata not found")
     }
     return metaData
 }
@@ -216,27 +221,28 @@
             LIMIT 1;`,
             { params: [instanceId] }
         )
     } catch (error) {
         if (
             !(
                 typeof error === "object" &&
                 error !== null &&
                 "code" in error &&
                 error.code === "42P01"
             )
         ) {
             throw error
         }
     }
 
-    if (!versionEntry) {
-        return customRaceEntry
+    if (customRaceEntry) {
+        return { rank: customRaceEntry.rank, isGauntletRace: true }
     }
-    if (!customRaceEntry) {
-        return versionEntry
+
+    if (versionEntry) {
+        return { rank: versionEntry.rank, isGauntletRace: false }
     }
 
-    return versionEntry.rank <= customRaceEntry.rank ? versionEntry : customRaceEntry
+    return null
 }
 
 type InstanceBasicRow = Omit<InstanceBasic, "difficultyTier"> & { activityId: number }

src/services/instance/is-day-one.test.ts

@@ -0,0 +1,13 @@
+import { sqlIsDayOne } from "@/services/instance/is-day-one"
+import { describe, expect, test } from "bun:test"
+
+describe("sqlIsDayOne", () => {
+    test("uses version release date for pantheon activities", () => {
+        expect(sqlIsDayOne("instance")).toContain("activity_definition.path = 'pantheon'")
+        expect(sqlIsDayOne("instance")).toContain("av.release_date_override")
+    })
+
+    test("uses activity day_one_end for non-pantheon activities", () => {
+        expect(sqlIsDayOne("fastest")).toContain("activity_definition.day_one_end")
+    })
+})

src/services/instance/is-day-one.ts

@@ -0,0 +1,14 @@
+/** SQL expression for isDayOne; requires `activity_definition` and `av` (activity_version) aliases. */
+export const sqlIsDayOne = (instanceAlias = "instance") => `(CASE
+    WHEN activity_definition.path = 'pantheon' THEN
+        ${instanceAlias}.date_completed < (
+            COALESCE(av.release_date_override, activity_definition.release_date) + INTERVAL '1 day'
+        )
+    ELSE
+        ${instanceAlias}.date_completed < COALESCE(activity_definition.day_one_end, TIMESTAMP 'epoch')
+END)`
+
+export const SQL_IS_PANTHEON = `(activity_definition.path = 'pantheon')`
+
+/** @deprecated Use sqlIsDayOne() */
+export const SQL_IS_DAY_ONE = sqlIsDayOne()

src/services/player-instances/history.ts

@@ -4,6 +4,7 @@ import { activityHistoryQueryTimer } from "@/integrations/prometheus/metrics"
 import { withHistogramTimer } from "@/integrations/prometheus/util"
 import { InstanceForPlayer } from "@/schema/components/InstanceForPlayer"
 import { attachDifficultyTiers } from "@/services/difficulty-tier/resolve"
+import { SQL_IS_DAY_ONE, SQL_IS_PANTHEON } from "@/services/instance/is-day-one"
 
 export const getActivities = async (
     membershipId: bigint | string,
@@ -53,7 +54,7 @@ export const getActivities = async (
                     instance.season_id::int AS "season",
                     instance.duration::int AS "duration",
                     instance.platform_type AS "platformType",
-                    instance.date_completed < COALESCE(activity_definition.day_one_end, TIMESTAMP 'epoch') AS "isDayOne",
+                    ${SQL_IS_DAY_ONE} AS "isDayOne",
                     (
                         CASE
                             WHEN ph_cact.activity_id IS NOT NULL THEN (
@@ -65,6 +66,7 @@ export const getActivities = async (
                     ) AS "isContest",
                     instance.date_completed < COALESCE(activity_definition.week_one_end, TIMESTAMP 'epoch') AS "isWeekOne",
                     (bi.instance_id IS NOT NULL AND NOT COALESCE(instance.is_whitelisted, false)) AS "isBlacklisted",
+                    ${SQL_IS_PANTHEON} AS "isPantheon",
                     JSONB_BUILD_OBJECT(
                         'completed', instance_player.completed,
                         'sherpas', instance_player.sherpas::int,