feat: add lightweight /reading/top endpoint and optimize /reading/rank

- Add GET /activity/reading/top with Redis cache (300s TTL)
- Support top/days query params for flexible top readings
- Add limit param to /reading/rank, select only payload field
- Sort and slice before querying ref documents for better performance

Author: Innei

apps/core/src/constants/cache.constant.ts

@@ -33,6 +33,8 @@ export enum RedisKeys {
   AnalyzeAggregate = 'analyze_aggregate',
   AnalyzeTrafficSource = 'analyze_traffic_source',
   AnalyzeDeviceDistribution = 'analyze_device_distribution',
+
+  ActivityTopReading = 'activity_top_reading',
 }
 export const API_CACHE_PREFIX = 'mx-api-cache:'
 export enum CacheKeys {

apps/core/src/modules/activity/activity.controller.ts

@@ -4,9 +4,12 @@ import { Auth } from '~/common/decorators/auth.decorator'
 import { HTTPDecorators } from '~/common/decorators/http.decorator'
 import { IpLocation } from '~/common/decorators/ip.decorator'
 import type { IpRecord } from '~/common/decorators/ip.decorator'
+import { RedisKeys } from '~/constants/cache.constant'
 import { CollectionRefTypes } from '~/constants/db.constant'
+import { RedisService } from '~/processors/redis/redis.service'
 import { PagerDto } from '~/shared/dto/pager.dto'
 import { snakecaseKeysWithCompat } from '~/utils/case.util'
+import { getRedisKey } from '~/utils/redis.util'
 import { keyBy, pick } from 'es-toolkit/compat'
 import { ReaderService } from '../reader/reader.service'
 import { Activity } from './activity.constant'
@@ -15,6 +18,7 @@ import {
   ActivityNotificationDto,
   ActivityQueryDto,
   ActivityRangeDto,
+  ActivityTopReadingsDto,
   ActivityTypeParamsDto,
   GetPresenceQueryDto,
   LikeBodyDto,
@@ -27,8 +31,24 @@ export class ActivityController {
   constructor(
     private readonly service: ActivityService,
     private readonly readerService: ReaderService,
+    private readonly redisService: RedisService,
   ) {}
 
+  private async getOrSetCache<T>(
+    key: string,
+    ttlSeconds: number,
+    getValue: () => Promise<T>,
+  ): Promise<T> {
+    const client = this.redisService.getClient()
+    const cached = await client.get(key)
+    if (cached) {
+      return JSON.parse(cached)
+    }
+    const value = await getValue()
+    await client.set(key, JSON.stringify(value), 'EX', ttlSeconds)
+    return value
+  }
+
   @Post('/like')
   async thumbsUpArticle(
     @Body() body: LikeBodyDto,
@@ -164,38 +184,59 @@ export class ActivityController {
     }
   }
 
+  @Auth()
+  @Get('/reading/top')
+  async getTopReadings(@Query() query: ActivityTopReadingsDto) {
+    const top = query.top ?? 5
+    const days = query.days ?? 14
+    const cacheKey = getRedisKey(
+      RedisKeys.ActivityTopReading,
+      String(top),
+      String(days),
+    )
+    return this.getOrSetCache(cacheKey, 300, async () => {
+      const result = await this.service.getTopReadings(top, days)
+      return result.map((item) => ({
+        ...item,
+        ref: pick(item.ref, [
+          'title',
+          'slug',
+          'cover',
+          'created',
+          'category',
+          'categoryId',
+          'id',
+          'nid',
+        ]),
+      }))
+    })
+  }
+
   @Auth()
   @Get('/reading/rank')
   async getReadingRangeRank(@Query() query: ActivityRangeDto) {
     const startAt = query.start ? new Date(query.start) : undefined
     const endAt = query.end ? new Date(query.end) : undefined
+    const limit = query.limit ?? 50
 
-    return this.service
-      .getDateRangeOfReadings(startAt, endAt)
-      .then((arr) => {
-        return arr.sort((a, b) => {
-          return b.count - a.count
-        })
-      })
-      .then((arr) => {
-        // omit ref fields
-
-        return arr.map((item) => {
-          return {
-            ...item,
-            ref: pick(item.ref, [
-              'title',
-              'slug',
-              'cover',
-              'created',
-              'category',
-              'categoryId',
-              'id',
-              'nid',
-            ]),
-          }
-        })
-      })
+    const result = await this.service.getDateRangeOfReadings(
+      startAt,
+      endAt,
+      limit,
+    )
+    return result.map((item) => ({
+      ...item,
+      ref: pick(item.ref, [
+        'title',
+        'slug',
+        'cover',
+        'created',
+        'category',
+        'categoryId',
+        'id',
+        'nid',
+      ]),
+    }))
   }
 
   @Get('/recent')

apps/core/src/modules/activity/activity.schema.ts

@@ -43,10 +43,23 @@ export class ActivityQueryDto extends createZodDto(ActivityQuerySchema) {}
 export const ActivityRangeSchema = z.object({
   start: zCoerceInt.optional(),
   end: zCoerceInt.optional(),
+  limit: zCoerceInt.min(1).max(200).default(50).optional(),
 })
 
 export class ActivityRangeDto extends createZodDto(ActivityRangeSchema) {}
 
+/**
+ * Activity top readings schema
+ */
+export const ActivityTopReadingsSchema = z.object({
+  top: zCoerceInt.min(1).max(50).default(5).optional(),
+  days: zCoerceInt.min(1).max(365).default(14).optional(),
+})
+
+export class ActivityTopReadingsDto extends createZodDto(
+  ActivityTopReadingsSchema,
+) {}
+
 /**
  * Activity notification schema
  */
@@ -105,6 +118,7 @@ export type ActivityRangeInput = z.infer<typeof ActivityRangeSchema>
 export type ActivityNotificationInput = z.infer<
   typeof ActivityNotificationSchema
 >
+export type ActivityTopReadingsInput = z.infer<typeof ActivityTopReadingsSchema>
 export type LikeBodyInput = z.infer<typeof LikeBodySchema>
 export type UpdatePresenceInput = z.infer<typeof UpdatePresenceSchema>
 export type GetPresenceQueryInput = z.infer<typeof GetPresenceQuerySchema>

apps/core/src/modules/activity/activity.service.ts

@@ -30,12 +30,10 @@ import { CommentService } from '../comment/comment.service'
 import { ConfigsService } from '../configs/configs.service'
 import type { NoteModel } from '../note/note.model'
 import { NoteService } from '../note/note.service'
-import type { PageModel } from '../page/page.model'
 import type { PostModel } from '../post/post.model'
 import type { PostService } from '../post/post.service'
 import { ReaderModel } from '../reader/reader.model'
 import { ReaderService } from '../reader/reader.service'
-import type { RecentlyModel } from '../recently/recently.model'
 import { Activity } from './activity.constant'
 import type {
   ActivityLikePayload,
@@ -503,7 +501,7 @@ export class ActivityService implements OnModuleInit, OnModuleDestroy {
     return { objects }
   }
 
-  async getDateRangeOfReadings(startAt?: Date, endAt?: Date) {
+  async getDateRangeOfReadings(startAt?: Date, endAt?: Date, limit = 50) {
     startAt = startAt ?? new Date('2020-01-01')
     endAt = endAt ?? new Date()
 
@@ -515,52 +513,38 @@ export class ActivityService implements OnModuleInit, OnModuleDestroy {
         },
         type: Activity.ReadDuration,
       })
+      .select('payload')
       .lean({
         getters: true,
       })
 
-    const refIds = new Set<string>()
+    const countMap = new Map<string, number>()
     for (const item of activities) {
-      const parsed = item.payload
-      const refId = extractArticleIdFromRoomName(parsed.roomName)
+      const refId = extractArticleIdFromRoomName(item.payload.roomName)
       if (!refId) continue
-      refIds.add(refId)
+      countMap.set(refId, (countMap.get(refId) || 0) + 1)
     }
 
-    const activityCountingMap = activities.reduce(
-      (acc, item) => {
-        const refId = extractArticleIdFromRoomName(item.payload.roomName)
-        if (!refId) return acc
-        if (!acc[refId]) {
-          acc[refId] = 0
-        }
-        acc[refId]++
-
-        return acc
-      },
-      {} as Record<string, number>,
-    )
+    const sorted = [...countMap.entries()]
+      .sort((a, b) => b[1] - a[1])
+      .slice(0, limit)
 
-    const result = [] as {
-      refId: string
-      count: number
-      ref: PostModel | NoteModel | PageModel | RecentlyModel
-    }[]
+    const topRefIds = sorted.map(([id]) => id)
+    const idsCollections = await this.databaseService.findGlobalByIds(topRefIds)
+    const mapping = this.databaseService.flatCollectionToMap(idsCollections)
 
-    const idsCollections = await this.databaseService.findGlobalByIds(
-      Array.from(refIds),
-    )
+    return sorted.map(([refId, count]) => ({
+      refId,
+      count,
+      ref: mapping[refId],
+    }))
+  }
 
-    const mapping = this.databaseService.flatCollectionToMap(idsCollections)
-    for (const refId of refIds) {
-      result.push({
-        refId,
-        count: activityCountingMap[refId] ?? 0,
-        ref: mapping[refId],
-      })
-    }
+  async getTopReadings(limit = 5, days = 14) {
+    const endAt = new Date()
+    const startAt = new Date(Date.now() - days * 24 * 60 * 60 * 1000)
 
-    return result
+    return this.getDateRangeOfReadings(startAt, endAt, limit)
   }
 
   async getRecentComment() {