Merge pull request #777 from TaloDev/migrate-headlines-routes

Migrate headlines routes to new router

Author: tudddorrr

CLAUDE.md

@@ -290,7 +290,7 @@ Route configurations support:
 
 #### File Organization
 
-**One route per file** for clarity:
+**One route per file** unless the router only has one route, in which case it can be inlined in `index.ts`:
 
 ```
 src/routes/

src/config/protected-routes.ts

@@ -9,7 +9,7 @@ import LeaderboardService from '../services/leaderboard.service'
 import DataExportService from '../services/data-export.service'
 import APIKeyService from '../services/api-key.service'
 import EventService from '../services/event.service'
-import HeadlineService from '../services/headline.service'
+import { headlineRouter } from '../routes/protected/headline'
 import PlayerService from '../services/player.service'
 import { billingRouter } from '../routes/protected/billing'
 import IntegrationService from '../services/integration.service'
@@ -57,7 +57,6 @@ export default function protectedRoutes(app: Koa) {
   app.use(service('/games/:gameId/api-keys', new APIKeyService(), serviceOpts))
   app.use(service('/games/:gameId/events', new EventService(), serviceOpts))
   app.use(service('/games/:gameId/players', new PlayerService(), serviceOpts))
-  app.use(service('/games/:gameId/headlines', new HeadlineService(), serviceOpts))
   app.use(service('/games/:gameId/integrations', new IntegrationService(), serviceOpts))
   app.use(service('/games/:gameId/player-groups', new PlayerGroupService(), serviceOpts))
   app.use(service('/games/:gameId/game-feedback', new GameFeedbackService(), serviceOpts))
@@ -67,6 +66,7 @@ export default function protectedRoutes(app: Koa) {
   app.use(billingRouter().routes())
   app.use(gameActivityRouter().routes())
   app.use(gameRouter().routes())
+  app.use(headlineRouter().routes())
   app.use(inviteRouter().routes())
   app.use(organisationRouter().routes())
   app.use(userRouter().routes())

src/lib/routing/state.ts

@@ -11,11 +11,13 @@ export type ProtectedRouteState = {
     api?: boolean
   }
   authenticatedUser: User
+  includeDevData: boolean
 }
 
 export type APIRouteState = {
   key: APIKey
   game: Game
+  includeDevData: boolean
 }
 
 export type RouteState = PublicRouteState | ProtectedRouteState | APIRouteState

src/lib/validation/dateRangeSchema.ts

@@ -0,0 +1,18 @@
+import { isBefore, isSameDay, isValid } from 'date-fns'
+import { z } from 'zod'
+
+export const dateRangeSchema = z.object({
+  startDate: z.string().refine((val) => isValid(new Date(val)), {
+    message: 'Invalid start date, please use YYYY-MM-DD or a timestamp'
+  }),
+  endDate: z.string().refine((val) => isValid(new Date(val)), {
+    message: 'Invalid end date, please use YYYY-MM-DD or a timestamp'
+  })
+}).refine((data) => {
+  const start = new Date(data.startDate)
+  const end = new Date(data.endDate)
+  return isBefore(start, end) || isSameDay(start, end)
+}, {
+  message: 'Invalid start date, it should be before the end date',
+  path: ['startDate']
+})

src/policies/headline.policy.ts

@@ -0,0 +1,58 @@
+import { protectedRoute, withMiddleware } from '../../../lib/routing/router'
+import { loadGame } from '../../../middleware/game-middleware'
+import { endOfDay, startOfDay } from 'date-fns'
+import { formatDateForClickHouse } from '../../../lib/clickhouse/formatDateTime'
+import { withResponseCache } from '../../../lib/perf/responseCache'
+import { HEADLINES_CACHE_TTL_MS } from './common'
+import { dateRangeSchema } from '../../../lib/validation/dateRangeSchema'
+
+export const averageSessionDurationRoute = protectedRoute({
+  method: 'get',
+  path: '/average_session_duration',
+  schema: () => ({
+    query: dateRangeSchema
+  }),
+  middleware: withMiddleware(loadGame),
+  handler: async (ctx) => {
+    const { startDate: startDateQuery, endDate: endDateQuery } = ctx.state.validated.query
+    const game = ctx.state.game
+    const includeDevData = ctx.state.includeDevData
+    const clickhouse = ctx.clickhouse
+
+    return withResponseCache({
+      key: `average-session-duration-${game.id}-${includeDevData}-${startDateQuery}-${endDateQuery}`,
+      ttl: HEADLINES_CACHE_TTL_MS / 1000
+    }, async () => {
+      const startDate = formatDateForClickHouse(startOfDay(new Date(startDateQuery)))
+      const endDate = formatDateForClickHouse(endOfDay(new Date(endDateQuery)))
+
+      let query = `
+        SELECT avg(dateDiff('seconds', started_at, ended_at)) AS averageDuration
+        FROM player_sessions
+        WHERE started_at BETWEEN '${startDate}' AND '${endDate}'
+          AND ended_at IS NOT NULL
+          AND game_id = ${game.id}
+      `
+
+      if (!includeDevData) {
+        query += ' AND dev_build = false'
+      }
+
+      const result = await clickhouse.query({
+        query,
+        format: 'JSONEachRow'
+      }).then((res) => res.json<{ averageDuration: number }>())
+
+      const seconds = result[0].averageDuration
+
+      return {
+        status: 200,
+        body: {
+          hours: Math.floor(seconds / 3600),
+          minutes: Math.floor((seconds % 3600) / 60),
+          seconds: seconds % 60
+        }
+      }
+    })
+  }
+})

src/routes/protected/headline/average-session-duration.ts

@@ -0,0 +1,2 @@
+export const HEADLINES_CACHE_TTL_MS = 300_000
+export const ONLINE_PLAYERS_CACHE_TTL_MS = 30_000

src/routes/protected/headline/common.ts

@@ -0,0 +1,53 @@
+import { protectedRoute, withMiddleware } from '../../../lib/routing/router'
+import { loadGame } from '../../../middleware/game-middleware'
+import { endOfDay, startOfDay } from 'date-fns'
+import { formatDateForClickHouse } from '../../../lib/clickhouse/formatDateTime'
+import { withResponseCache } from '../../../lib/perf/responseCache'
+import { HEADLINES_CACHE_TTL_MS } from './common'
+import { dateRangeSchema } from '../../../lib/validation/dateRangeSchema'
+
+export const eventsRoute = protectedRoute({
+  method: 'get',
+  path: '/events',
+  schema: () => ({
+    query: dateRangeSchema
+  }),
+  middleware: withMiddleware(loadGame),
+  handler: async (ctx) => {
+    const { startDate: startDateQuery, endDate: endDateQuery } = ctx.state.validated.query
+    const game = ctx.state.game
+    const includeDevData = ctx.state.includeDevData
+    const clickhouse = ctx.clickhouse
+
+    return withResponseCache({
+      key: `events-${game.id}-${includeDevData}-${startDateQuery}-${endDateQuery}`,
+      ttl: HEADLINES_CACHE_TTL_MS / 1000
+    }, async () => {
+      const startDate = formatDateForClickHouse(startOfDay(new Date(startDateQuery)))
+      const endDate = formatDateForClickHouse(endOfDay(new Date(endDateQuery)))
+
+      let query = `
+        SELECT count() AS count
+        FROM events
+        WHERE created_at BETWEEN '${startDate}' AND '${endDate}'
+          AND game_id = ${game.id}
+      `
+
+      if (!includeDevData) {
+        query += 'AND dev_build = false'
+      }
+
+      const result = await clickhouse.query({
+        query,
+        format: 'JSONEachRow'
+      }).then((res) => res.json<{ count: string }>())
+
+      return {
+        status: 200,
+        body: {
+          count: Number(result[0].count)
+        }
+      }
+    })
+  }
+})

src/routes/protected/headline/events.ts

@@ -0,0 +1,22 @@
+import { protectedRouter } from '../../../lib/routing/router'
+import { newPlayersRoute } from './new-players'
+import { returningPlayersRoute } from './returning-players'
+import { eventsRoute } from './events'
+import { uniqueEventSubmittersRoute } from './unique-event-submitters'
+import { totalPlayersRoute } from './total-players'
+import { onlinePlayersRoute } from './online-players'
+import { totalSessionsRoute } from './total-sessions'
+import { averageSessionDurationRoute } from './average-session-duration'
+
+export function headlineRouter() {
+  return protectedRouter('/games/:gameId/headlines', ({ route }) => {
+    route(newPlayersRoute)
+    route(returningPlayersRoute)
+    route(eventsRoute)
+    route(uniqueEventSubmittersRoute)
+    route(totalPlayersRoute)
+    route(onlinePlayersRoute)
+    route(totalSessionsRoute)
+    route(averageSessionDurationRoute)
+  })
+}

src/routes/protected/headline/index.ts

@@ -0,0 +1,38 @@
+import { protectedRoute, withMiddleware } from '../../../lib/routing/router'
+import { loadGame } from '../../../middleware/game-middleware'
+import { endOfDay, startOfDay } from 'date-fns'
+import Player from '../../../entities/player'
+import { getResultCacheOptions } from '../../../lib/perf/getResultCacheOptions'
+import { HEADLINES_CACHE_TTL_MS } from './common'
+import { dateRangeSchema } from '../../../lib/validation/dateRangeSchema'
+
+export const newPlayersRoute = protectedRoute({
+  method: 'get',
+  path: '/new_players',
+  schema: () => ({
+    query: dateRangeSchema
+  }),
+  middleware: withMiddleware(loadGame),
+  handler: async (ctx) => {
+    const { startDate, endDate } = ctx.state.validated.query
+    const em = ctx.em
+
+    const game = ctx.state.game
+    const includeDevData = ctx.state.includeDevData
+    const count = await em.repo(Player).count({
+      game,
+      ...(includeDevData ? {} : { devBuild: false }),
+      createdAt: {
+        $gte: startOfDay(new Date(startDate)),
+        $lte: endOfDay(new Date(endDate))
+      }
+    }, getResultCacheOptions(`new-players-${game.id}-${includeDevData}-${startDate}-${endDate}`, HEADLINES_CACHE_TTL_MS))
+
+    return {
+      status: 200,
+      body: {
+        count
+      }
+    }
+  }
+})