Removed forced limits from api calls

Author: robotzurg

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

@@ -75,12 +75,11 @@ statsRouter.openapi(
   async (c) => {
     const { queue_id } = c.req.valid('param')
     const { limit } = c.req.valid('query')
-    const finalLimit = limit || 100
 
     try {
       const leaderboard = await COMMAND_HANDLERS.STATS.GET_LEADERBOARD(
         queue_id,
-        finalLimit,
+        limit,
       )
 
       return c.json(
@@ -178,12 +177,11 @@ statsRouter.openapi(
   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,
+        limit,
       )
 
       return c.json(
@@ -284,120 +282,12 @@ statsRouter.openapi(
   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',
-    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,
+        limit,
       )
 
       return c.json(

src/command-handlers/stats/getLeaderboard.ts

@@ -16,12 +16,12 @@ export type LeaderboardEntry = {
  * Gets leaderboard data for a specific queue.
  *
  * @param {number} queueId - The queue ID to fetch leaderboard for.
- * @param {number} limit - Maximum number of entries to return.
+ * @param {number} limit - Optional maximum number of entries to return. If not provided, returns all entries.
  * @return {Promise<LeaderboardEntry[]>} A promise that resolves to the leaderboard data.
  */
 export async function getLeaderboard(
   queueId: number,
-  limit: number = 100,
+  limit?: number,
 ): Promise<LeaderboardEntry[]> {
   try {
     return await getQueueLeaderboard(queueId, limit)

src/command-handlers/stats/getMatchHistory.ts

@@ -18,18 +18,17 @@ export type MatchHistoryEntry = {
  *
  * @param {string} userId - The Discord user ID of the player.
  * @param {number} queueId - The queue ID to fetch match history for.
- * @param {number} limit - Maximum number of matches to return (default: 50).
+ * @param {number} limit - Optional maximum number of matches to return. If not provided, returns all matches.
  * @return {Promise<MatchHistoryEntry[]>} A promise that resolves to an array of match history entries.
  */
 export async function getMatchHistory(
   userId: string,
   queueId: number,
-  limit: number = 50,
+  limit?: number,
 ): Promise<MatchHistoryEntry[]> {
   try {
     // Get match history for the player
-    const historyRes = await pool.query(
-      `
+    let query = `
       SELECT
         m.id as match_id,
         m.winning_team,
@@ -44,10 +43,15 @@ export async function getMatchHistory(
       JOIN matches m ON m.id = mu.match_id
       WHERE mu.user_id = $1 AND m.queue_id = $2 AND m.winning_team IS NOT NULL
       ORDER BY m.created_at DESC
-      LIMIT $3
-      `,
-      [userId, queueId, limit],
-    )
+    `
+
+    const params: any[] = [userId, queueId]
+    if (limit) {
+      query += ` LIMIT $${params.length + 1}`
+      params.push(limit)
+    }
+
+    const historyRes = await pool.query(query, params)
 
     return historyRes.rows.map((row) => ({
       match_id: row.match_id,

src/command-handlers/stats/getOverallHistory.ts

@@ -19,17 +19,16 @@ export type OverallHistoryEntry = {
  * 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).
+ * @param {number} limit - Optional maximum number of matches to return. If not provided, returns all matches.
  * @return {Promise<OverallHistoryEntry[]>} A promise that resolves to an array of match history entries.
  */
 export async function getOverallHistory(
   queueId: number,
-  limit: number = 50,
+  limit?: number,
 ): Promise<OverallHistoryEntry[]> {
   try {
     // Get overall match history for the queue
-    const historyRes = await pool.query(
-      `
+    let query = `
       SELECT
         m.id as match_id,
         m.winning_team,
@@ -41,10 +40,15 @@ export async function getOverallHistory(
       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],
-    )
+    `
+
+    const params: any[] = [queueId]
+    if (limit) {
+      query += ` LIMIT $${params.length + 1}`
+      params.push(limit)
+    }
+
+    const historyRes = await pool.query(query, params)
 
     // For each match, get the players
     const matches = await Promise.all(

src/utils/queryDB.ts

@@ -2093,7 +2093,7 @@ export async function getAllOpenRooms(): Promise<UserRoom[]> {
 // Get leaderboard data for a queue
 export async function getQueueLeaderboard(
   queueId: number,
-  limit: number = 100,
+  limit?: number,
 ): Promise<
   Array<{
     rank: number
@@ -2107,27 +2107,32 @@ export async function getQueueLeaderboard(
     peak_streak: number
   }>
 > {
-  const res = await pool.query(
-    `
-      SELECT
-        qu.user_id,
-        u.display_name,
-        qu.elo,
-        qu.peak_elo,
-        qu.win_streak,
-        qu.peak_win_streak,
-        COUNT(CASE WHEN m.winning_team = mu.team THEN 1 END)::integer as wins,
-        COUNT(CASE WHEN m.winning_team IS NOT NULL AND m.winning_team != mu.team THEN 1 END)::integer as losses
-      FROM queue_users qu
-      LEFT JOIN users u ON u.user_id = qu.user_id
-      LEFT JOIN match_users mu ON mu.user_id = qu.user_id
-      LEFT JOIN matches m ON m.id = mu.match_id AND m.queue_id = $1
-      WHERE qu.queue_id = $1
-      GROUP BY qu.user_id, u.display_name, qu.elo, qu.peak_elo, qu.win_streak, qu.peak_win_streak
-      ORDER BY qu.elo DESC
-      LIMIT $2`,
-    [queueId, limit],
-  )
+  let query = `
+    SELECT
+      qu.user_id,
+      u.display_name,
+      qu.elo,
+      qu.peak_elo,
+      qu.win_streak,
+      qu.peak_win_streak,
+      COUNT(CASE WHEN m.winning_team = mu.team THEN 1 END)::integer as wins,
+      COUNT(CASE WHEN m.winning_team IS NOT NULL AND m.winning_team != mu.team THEN 1 END)::integer as losses
+    FROM queue_users qu
+    LEFT JOIN users u ON u.user_id = qu.user_id
+    LEFT JOIN match_users mu ON mu.user_id = qu.user_id
+    LEFT JOIN matches m ON m.id = mu.match_id AND m.queue_id = $1
+    WHERE qu.queue_id = $1
+    GROUP BY qu.user_id, u.display_name, qu.elo, qu.peak_elo, qu.win_streak, qu.peak_win_streak
+    ORDER BY qu.elo DESC
+  `
+
+  const params: any[] = [queueId]
+  if (limit) {
+    query += ` LIMIT $${params.length + 1}`
+    params.push(limit)
+  }
+
+  const res = await pool.query(query, params)
 
   return res.rows.map((row, index) => ({
     rank: index + 1,