Revamp/stats

apps/backend/src/db/repositories/reviews-repository.ts

@@ -150,18 +150,29 @@ export async function selectReviewsCount(userId?: string) {
     .where(userId ? eq(schema.reviews.userId, userId) : undefined)
 }
 
-export async function selectBestReviews(userId: string, limit = 10) {
+export async function selectBestReviews(
+  userId: string,
+  limit = 10,
+  startDate?: Date,
+  endDate?: Date
+) {
+  const whereConditions = [
+    eq(schema.reviews.userId, userId),
+    sql`${schema.reviews.seasonNumber} IS NULL`,
+    sql`${schema.reviews.episodeNumber} IS NULL`,
+  ]
+
+  if (startDate) {
+    whereConditions.push(gte(schema.reviews.createdAt, startDate))
+  }
+  if (endDate) {
+    whereConditions.push(lte(schema.reviews.createdAt, endDate))
+  }
+
   return db
     .select()
     .from(schema.reviews)
-    .where(
-      and(
-        eq(schema.reviews.userId, userId),
-        eq(schema.reviews.rating, 5),
-        sql`${schema.reviews.seasonNumber} IS NULL`,
-        sql`${schema.reviews.episodeNumber} IS NULL`
-      )
-    )
+    .where(and(...whereConditions))
     .orderBy(desc(schema.reviews.rating), desc(schema.reviews.createdAt))
     .limit(limit)
 }

apps/backend/src/db/repositories/user-episode.ts

@@ -1,4 +1,4 @@
-import { and, count, desc, eq, inArray } from 'drizzle-orm'
+import { and, count, desc, eq, gte, inArray, lte } from 'drizzle-orm'
 import type { InsertUserEpisode } from '@/domain/entities/user-episode'
 import type { GetUserEpisodesInput } from '@/domain/services/user-episodes/get-user-episodes'
 import { db } from '..'
@@ -15,16 +15,25 @@ export async function insertUserEpisodes(values: InsertUserEpisode[]) {
 export async function selectUserEpisodes({
   userId,
   tmdbId,
-}: GetUserEpisodesInput) {
+  startDate,
+  endDate,
+}: GetUserEpisodesInput & { startDate?: Date; endDate?: Date }) {
+  const whereConditions = [
+    eq(schema.userEpisodes.userId, userId),
+    tmdbId ? eq(schema.userEpisodes.tmdbId, tmdbId) : undefined,
+  ].filter(Boolean)
+
+  if (startDate) {
+    whereConditions.push(gte(schema.userEpisodes.watchedAt, startDate))
+  }
+  if (endDate) {
+    whereConditions.push(lte(schema.userEpisodes.watchedAt, endDate))
+  }
+
   return db
     .select()
     .from(schema.userEpisodes)
-    .where(
-      and(
-        eq(schema.userEpisodes.userId, userId),
-        tmdbId ? eq(schema.userEpisodes.tmdbId, tmdbId) : undefined
-      )
-    )
+    .where(and(...whereConditions))
     .orderBy(schema.userEpisodes.episodeNumber)
 }
 
@@ -34,11 +43,24 @@ export async function deleteUserEpisodes(ids: string[]) {
     .where(inArray(schema.userEpisodes.id, ids))
 }
 
-export async function selectMostWatched(userId: string) {
+export async function selectMostWatched(
+  userId: string,
+  startDate?: Date,
+  endDate?: Date
+) {
+  const whereConditions = [eq(schema.userEpisodes.userId, userId)]
+
+  if (startDate) {
+    whereConditions.push(gte(schema.userEpisodes.watchedAt, startDate))
+  }
+  if (endDate) {
+    whereConditions.push(lte(schema.userEpisodes.watchedAt, endDate))
+  }
+
   return db
     .select({ count: count(), tmdbId: schema.userEpisodes.tmdbId })
     .from(schema.userEpisodes)
-    .where(and(eq(schema.userEpisodes.userId, userId)))
+    .where(and(...whereConditions))
     .groupBy(schema.userEpisodes.tmdbId)
     .orderBy(desc(count()))
     .limit(3)

apps/backend/src/db/repositories/user-item-repository.ts

@@ -5,6 +5,7 @@ import {
   desc,
   eq,
   getTableColumns,
+  gte,
   inArray,
   isNull,
   lte,
@@ -137,21 +138,36 @@ export async function selectUserItem({
     .limit(1)
 }
 
-export async function selectUserItemStatus(userId: string) {
+export async function selectUserItemStatus(
+  userId: string,
+  startDate?: Date,
+  endDate?: Date
+) {
+  const whereConditions = [eq(schema.userItems.userId, userId)]
+
+  if (startDate) {
+    whereConditions.push(gte(schema.userItems.updatedAt, startDate))
+  }
+  if (endDate) {
+    whereConditions.push(lte(schema.userItems.updatedAt, endDate))
+  }
+
   return db
     .select({
       status: schema.userItems.status,
       count: sql`COUNT(*)::int`,
       percentage: sql`(COUNT(*) * 100.0 / SUM(COUNT(*)) OVER ())::float`,
     })
     .from(schema.userItems)
-    .where(eq(schema.userItems.userId, userId))
+    .where(and(...whereConditions))
     .groupBy(schema.userItems.status)
 }
 
 export async function selectAllUserItemsByStatus({
   status,
   userId,
+  startDate,
+  endDate,
 }: SelectAllUserItems) {
   const { id, tmdbId, mediaType, position, updatedAt } = getTableColumns(schema.userItems)
 
@@ -160,6 +176,12 @@ export async function selectAllUserItemsByStatus({
   if (status !== 'ALL') {
     whereConditions.push(eq(schema.userItems.status, status as UserItemStatus))
   }
+  if (startDate) {
+    whereConditions.push(gte(schema.userItems.updatedAt, startDate))
+  }
+  if (endDate) {
+    whereConditions.push(lte(schema.userItems.updatedAt, endDate))
+  }
   return db
     .select({
       id,

apps/backend/src/domain/entities/user-item.ts

@@ -23,4 +23,6 @@ export type SelectUserItems = {
 export type SelectAllUserItems = {
   status?: UserItemStatus | 'ALL'
   userId: string
+  startDate?: Date
+  endDate?: Date
 }

apps/backend/src/domain/services/user-episodes/get-user-episodes.ts

@@ -1,11 +1,23 @@
 import { selectUserEpisodes } from '@/db/repositories/user-episode'
 
-export type GetUserEpisodesInput = { userId: string; tmdbId?: number }
+export type GetUserEpisodesInput = {
+  userId: string
+  tmdbId?: number
+  startDate?: Date
+  endDate?: Date
+}
 
 export async function getUserEpisodesService({
   userId,
   tmdbId,
+  startDate,
+  endDate,
 }: GetUserEpisodesInput) {
-  const userEpisodes = await selectUserEpisodes({ userId, tmdbId })
+  const userEpisodes = await selectUserEpisodes({
+    userId,
+    tmdbId,
+    startDate,
+    endDate,
+  })
   return { userEpisodes }
 }

apps/backend/src/domain/services/user-stats/cache-utils.ts

@@ -1,8 +1,7 @@
 import type { FastifyRedis } from '@fastify/redis'
 
-// Cache duration for computed statistics (1 hour)
-// Short TTL ensures data freshness while still providing significant performance benefit
 const STATS_CACHE_TTL_SECONDS = 60 * 60
+const STATS_CACHE_SHORT_TTL_SECONDS = 10 * 60
 
 /**
  * Helper to cache computed statistics results
@@ -20,12 +19,17 @@ export async function getCachedStats<T>(
   }
 
   const result = await computeFn()
-  await redis.set(
-    cacheKey,
-    JSON.stringify(result),
-    'EX',
-    STATS_CACHE_TTL_SECONDS
-  )
+
+  const yearMonthPattern = /:\d{4}-\d{2}$/
+  const isPeriodScoped =
+    cacheKey.endsWith(':month') ||
+    cacheKey.endsWith(':last_month') ||
+    yearMonthPattern.test(cacheKey)
+  const ttl = isPeriodScoped
+    ? STATS_CACHE_SHORT_TTL_SECONDS
+    : STATS_CACHE_TTL_SECONDS
+
+  await redis.set(cacheKey, JSON.stringify(result), 'EX', ttl)
 
   return result
 }
@@ -52,10 +56,11 @@ export async function invalidateUserStatsCache(
 export function getUserStatsCacheKey(
   userId: string,
   statType: string,
-  language?: string
+  language?: string,
+  period?: string
 ): string {
-  if (language) {
-    return `user-stats:${userId}:${statType}:${language}`
-  }
-  return `user-stats:${userId}:${statType}`
+  const parts = ['user-stats', userId, statType]
+  if (language) parts.push(language)
+  if (period && period !== 'all') parts.push(period)
+  return parts.join(':')
 }

apps/backend/src/domain/services/user-stats/get-user-best-reviews.ts

@@ -1,5 +1,6 @@
 import type { FastifyRedis } from '@fastify/redis'
 import type { Language } from '@plotwist_app/tmdb'
+import type { StatsPeriod } from '@/http/schemas/common'
 import { selectBestReviews } from '@/db/repositories/reviews-repository'
 import { getTMDBMovieService } from '../tmdb/get-tmdb-movie'
 import { getTMDBTvSeriesService } from '../tmdb/get-tmdb-tv-series'
@@ -10,17 +11,23 @@ type GetUserBestReviewsServiceInput = {
   redis: FastifyRedis
   language: Language
   limit?: number
+  dateRange?: { startDate: Date | undefined; endDate: Date | undefined }
+  period?: StatsPeriod
 }
 
 export async function getUserBestReviewsService({
   userId,
   language,
   redis,
   limit,
+  dateRange,
 }: GetUserBestReviewsServiceInput) {
-  // Note: Not using cache here because createdAt Date serialization
-  // causes issues when retrieved from Redis (Date becomes string)
-  const bestReviews = await selectBestReviews(userId, limit)
+  const bestReviews = await selectBestReviews(
+    userId,
+    limit,
+    dateRange?.startDate,
+    dateRange?.endDate
+  )
 
   const formattedBestReviews = await processInBatches(
     bestReviews,

apps/backend/src/domain/services/user-stats/get-user-items-status.ts

@@ -2,12 +2,18 @@ import { selectUserItemStatus } from '@/db/repositories/user-item-repository'
 
 type GetUserItemsStatusServiceInput = {
   userId: string
+  dateRange?: { startDate: Date | undefined; endDate: Date | undefined }
 }
 
 export async function getUserItemsStatusService({
   userId,
+  dateRange,
 }: GetUserItemsStatusServiceInput) {
-  const userItems = await selectUserItemStatus(userId)
+  const userItems = await selectUserItemStatus(
+    userId,
+    dateRange?.startDate,
+    dateRange?.endDate
+  )
 
   return {
     userItems,

apps/backend/src/domain/services/user-stats/get-user-most-watched-series.ts

@@ -1,5 +1,6 @@
 import type { FastifyRedis } from '@fastify/redis'
 import type { Language } from '@plotwist_app/tmdb'
+import type { StatsPeriod } from '@/http/schemas/common'
 import { selectMostWatched } from '@/db/repositories/user-episode'
 import { getTMDBTvSeriesService } from '../tmdb/get-tmdb-tv-series'
 import { processInBatches } from './batch-utils'
@@ -8,14 +9,21 @@ type GetUserMostWatchedSeriesServiceInput = {
   userId: string
   redis: FastifyRedis
   language: Language
+  dateRange?: { startDate: Date | undefined; endDate: Date | undefined }
+  period?: StatsPeriod
 }
 
 export async function getUserMostWatchedSeriesService({
   userId,
   language,
   redis,
+  dateRange,
 }: GetUserMostWatchedSeriesServiceInput) {
-  const mostWatchedSeries = await selectMostWatched(userId)
+  const mostWatchedSeries = await selectMostWatched(
+    userId,
+    dateRange?.startDate,
+    dateRange?.endDate
+  )
 
   const formattedMostWatchedSeries = await processInBatches(
     mostWatchedSeries,