API overall history endpoint

Author: robotzurg

src/api/routers/commands/stats.router.ts

@@ -101,6 +101,216 @@ statsRouter.openapi(
   },
 )
 
+statsRouter.openapi(
+  createRoute({
+    method: 'get',
+    path: '/overall-history/{queue_id}',
+    description: 'Get overall match history for a queue.',
+    request: {
+      params: z.object({
+        queue_id: z
+          .string()
+          .regex(/^\d+$/)
+          .transform(Number)
+          .openapi({
+            param: {
+              name: 'queue_id',
+              in: 'path',
+            },
+            example: '1',
+          }),
+      }),
+      query: z.object({
+        limit: z
+          .string()
+          .regex(/^\d+$/)
+          .transform(Number)
+          .optional()
+          .openapi({
+            param: {
+              name: 'limit',
+              in: 'query',
+            },
+            example: '50',
+          }),
+      }),
+    },
+    responses: {
+      200: {
+        content: {
+          'application/json': {
+            schema: z.object({
+              matches: z.array(
+                z.object({
+                  match_id: z.number(),
+                  winning_team: z.number().nullable(),
+                  deck: z.string().nullable(),
+                  stake: z.string().nullable(),
+                  best_of_3: z.boolean(),
+                  best_of_5: z.boolean(),
+                  created_at: z.string(),
+                  players: z.array(
+                    z.object({
+                      user_id: z.string(),
+                      team: z.number().nullable(),
+                      elo_change: z.number().nullable(),
+                    }),
+                  ),
+                }),
+              ),
+            }),
+          },
+        },
+        description: 'Overall match history retrieved successfully.',
+      },
+      500: {
+        content: {
+          'application/json': {
+            schema: z.object({
+              error: z.string(),
+            }),
+          },
+        },
+        description: 'Internal server error.',
+      },
+    },
+  }),
+  async (c) => {
+    const { queue_id } = c.req.valid('param')
+    const { limit } = c.req.valid('query')
+    const finalLimit = limit || 50
+
+    try {
+      const matches = await COMMAND_HANDLERS.STATS.GET_OVERALL_HISTORY(
+        queue_id,
+        finalLimit,
+      )
+
+      return c.json(
+        {
+          matches,
+        },
+        200,
+      )
+    } catch (error) {
+      console.error('Error fetching overall match history:', error)
+      return c.json(
+        {
+          error: 'Internal server error',
+        },
+        500,
+      )
+    }
+  },
+)
+
+statsRouter.openapi(
+  createRoute({
+    method: 'get',
+    path: '/history/{user_id}/{queue_id}',
+    description: 'Get match history for a player in a specific queue.',
+    request: {
+      params: z.object({
+        user_id: z.string().openapi({
+          param: {
+            name: 'user_id',
+            in: 'path',
+          },
+          example: '123456789012345678',
+        }),
+        queue_id: z
+          .string()
+          .regex(/^\d+$/)
+          .transform(Number)
+          .openapi({
+            param: {
+              name: 'queue_id',
+              in: 'path',
+            },
+            example: '1',
+          }),
+      }),
+      query: z.object({
+        limit: z
+          .string()
+          .regex(/^\d+$/)
+          .transform(Number)
+          .optional()
+          .openapi({
+            param: {
+              name: 'limit',
+              in: 'query',
+            },
+            example: '10',
+          }),
+      }),
+    },
+    responses: {
+      200: {
+        content: {
+          'application/json': {
+            schema: z.object({
+              matches: z.array(
+                z.object({
+                  match_id: z.number(),
+                  won: z.boolean(),
+                  elo_change: z.number().nullable(),
+                  team: z.number().nullable(),
+                  deck: z.string().nullable(),
+                  stake: z.string().nullable(),
+                  best_of_3: z.boolean(),
+                  best_of_5: z.boolean(),
+                  created_at: z.string(),
+                  winning_team: z.number().nullable(),
+                }),
+              ),
+            }),
+          },
+        },
+        description: 'Match history retrieved successfully.',
+      },
+      500: {
+        content: {
+          'application/json': {
+            schema: z.object({
+              error: z.string(),
+            }),
+          },
+        },
+        description: 'Internal server error.',
+      },
+    },
+  }),
+  async (c) => {
+    const { user_id, queue_id } = c.req.valid('param')
+    const { limit } = c.req.valid('query')
+    const finalLimit = limit || 50
+
+    try {
+      const matches = await COMMAND_HANDLERS.STATS.GET_MATCH_HISTORY(
+        user_id,
+        queue_id,
+        finalLimit,
+      )
+
+      return c.json(
+        {
+          matches,
+        },
+        200,
+      )
+    } catch (error) {
+      console.error('Error fetching match history:', error)
+      return c.json(
+        {
+          error: 'Internal server error',
+        },
+        500,
+      )
+    }
+  },
+)
+
 statsRouter.openapi(
   createRoute({
     method: 'get',

src/command-handlers/stats/getOverallHistory.ts

@@ -0,0 +1,84 @@
+import { pool } from '../../db'
+
+export type OverallHistoryEntry = {
+  match_id: number
+  winning_team: number | null
+  deck: string | null
+  stake: string | null
+  best_of_3: boolean
+  best_of_5: boolean
+  created_at: string
+  players: {
+    user_id: string
+    team: number | null
+    elo_change: number | null
+  }[]
+}
+
+/**
+ * Gets overall match history for a queue.
+ *
+ * @param {number} queueId - The queue ID to fetch match history for.
+ * @param {number} limit - Maximum number of matches to return (default: 50).
+ * @return {Promise<OverallHistoryEntry[]>} A promise that resolves to an array of match history entries.
+ */
+export async function getOverallHistory(
+  queueId: number,
+  limit: number = 50,
+): Promise<OverallHistoryEntry[]> {
+  try {
+    // Get overall match history for the queue
+    const historyRes = await pool.query(
+      `
+      SELECT
+        m.id as match_id,
+        m.winning_team,
+        m.deck,
+        m.stake,
+        m.best_of_3,
+        m.best_of_5,
+        m.created_at
+      FROM matches m
+      WHERE m.queue_id = $1 AND m.winning_team IS NOT NULL
+      ORDER BY m.created_at DESC
+      LIMIT $2
+      `,
+      [queueId, limit],
+    )
+
+    // For each match, get the players
+    const matches = await Promise.all(
+      historyRes.rows.map(async (row) => {
+        const playersRes = await pool.query(
+          `
+          SELECT user_id, team, elo_change
+          FROM match_users
+          WHERE match_id = $1
+          ORDER BY team, user_id
+          `,
+          [row.match_id],
+        )
+
+        return {
+          match_id: row.match_id,
+          winning_team: row.winning_team,
+          deck: row.deck,
+          stake: row.stake,
+          best_of_3: row.best_of_3,
+          best_of_5: row.best_of_5,
+          created_at: row.created_at.toISOString(),
+          players: playersRes.rows.map((player) => ({
+            user_id: player.user_id,
+            team: player.team,
+            elo_change: player.elo_change,
+          })),
+        }
+      }),
+    )
+
+    return matches
+  } catch (error) {
+    console.error('Error fetching overall match history:', error)
+    throw error
+  }
+}

src/command-handlers/stats/index.ts

@@ -1,9 +1,11 @@
 import { getPlayerStats } from './getPlayerStats'
 import { getMatchHistory } from './getMatchHistory'
 import { getLeaderboard } from './getLeaderboard'
+import { getOverallHistory } from './getOverallHistory'
 
 export const STATS_COMMAND_HANDLERS = {
   GET_PLAYER_STATS: getPlayerStats,
   GET_MATCH_HISTORY: getMatchHistory,
   GET_LEADERBOARD: getLeaderboard,
+  GET_OVERALL_HISTORY: getOverallHistory,
 }