- © {new Date().getFullYear()} EmuReady. All rights reserved.
+ © {copyrightYear ? `${copyrightYear} ` : ''}EmuReady. All rights reserved.
diff --git a/src/lib/api.tsx b/src/lib/api.tsx
index b754ad23c..1ec06dded 100644
--- a/src/lib/api.tsx
+++ b/src/lib/api.tsx
@@ -5,6 +5,7 @@ import { httpBatchLink } from '@trpc/client'
import { createTRPCReact } from '@trpc/react-query'
import { useState, type PropsWithChildren } from 'react'
import superjson from 'superjson'
+import { shouldRetryTRPCQuery } from '@/lib/trpc-client-errors'
import { ms } from '@/utils/time'
import type { AppRouter } from '@/types/trpc'
@@ -16,12 +17,11 @@ export function TRPCProvider(props: PropsWithChildren) {
new QueryClient({
defaultOptions: {
queries: {
- // Default settings for all queries
staleTime: ms.seconds(30),
gcTime: ms.minutes(5),
refetchOnWindowFocus: true,
refetchOnReconnect: true,
- retry: 3,
+ retry: shouldRetryTRPCQuery,
retryDelay: (attemptIndex) => Math.min(1000 * 2 ** attemptIndex, 30000),
},
mutations: { retry: 1 },
diff --git a/src/lib/cache/seo-cache.ts b/src/lib/cache/seo-cache.ts
deleted file mode 100644
index 4efd8e61f..000000000
--- a/src/lib/cache/seo-cache.ts
+++ /dev/null
@@ -1,234 +0,0 @@
-import { LRUCache } from 'lru-cache'
-import { ms } from '@/utils/time'
-
-/**
- * caching solution for SEO data
- * Uses in-memory LRU cache with Redis support when available
- * TODO: implement Redis support for distributed caching
- */
-
-interface CacheOptions {
- ttl?: number // Time to live in milliseconds
- staleWhileRevalidate?: number // Serve stale content while revalidating
-}
-
-interface CachedItem
{
- data: T
- timestamp: number
- ttl: number
- staleWhileRevalidate: number
-}
-
-// In-memory LRU cache configuration
-const DEFAULT_TTL = ms.hours(1)
-const DEFAULT_STALE_WHILE_REVALIDATE = ms.days(1)
-const MAX_CACHE_SIZE = 500 // Maximum number of items
-const MAX_CACHE_AGE = ms.days(1)
-
-// Initialize LRU cache
-export const cache = new LRUCache>({
- max: MAX_CACHE_SIZE,
- ttl: MAX_CACHE_AGE,
- // Update age on get to keep hot items in cache
- updateAgeOnGet: true,
- // Track performance metrics
- fetchMethod: async (key: string) => {
- console.log(`[SEO Cache] Cache miss for key: ${key}`)
- return undefined
- },
-})
-
-// Performance metrics
-let cacheHits = 0
-let cacheMisses = 0
-let cacheStaleHits = 0
-let deduplicatedRequests = 0
-
-// Request deduplication - tracks in-flight requests
-const inFlightRequests = new Map>()
-
-export function getCacheMetrics() {
- const hitRate = cacheHits / (cacheHits + cacheMisses) || 0
- return {
- hits: cacheHits,
- misses: cacheMisses,
- staleHits: cacheStaleHits,
- deduplicatedRequests,
- hitRate: `${(hitRate * 100).toFixed(2)}%`,
- size: cache.size,
- maxSize: MAX_CACHE_SIZE,
- inFlightRequests: inFlightRequests.size,
- }
-}
-
-/**
- * Get item from cache with stale-while-revalidate support
- */
-export async function getFromCache(
- key: string,
- fetchFn: () => Promise,
- options: CacheOptions = {},
-): Promise {
- const ttl = options.ttl ?? DEFAULT_TTL
- const staleWhileRevalidate = options.staleWhileRevalidate ?? DEFAULT_STALE_WHILE_REVALIDATE
-
- try {
- const cached = cache.get(key)
- const now = Date.now()
-
- if (cached) {
- const age = now - cached.timestamp
- const isStale = age > cached.ttl
- const isExpired = age > cached.ttl + cached.staleWhileRevalidate
-
- if (!isExpired) {
- if (isStale) {
- // Serve stale content and revalidate in background
- cacheStaleHits++
- console.log(`[SEO Cache] Serving stale content for: ${key}`)
-
- // Revalidate in background without blocking
- revalidateInBackground(key, fetchFn, ttl, staleWhileRevalidate)
- } else {
- // Fresh cache hit
- cacheHits++
- }
- return cached.data as T
- }
- }
-
- // Check if there's already an in-flight request for this key
- const existingRequest = inFlightRequests.get(key)
- if (existingRequest) {
- console.log(`[SEO Cache] Deduplicating request for key: ${key}`)
- deduplicatedRequests++
- return existingRequest as Promise
- }
-
- // Cache miss or expired - create new request
- cacheMisses++
-
- // Create promise and store it for deduplication
- const requestPromise = (async () => {
- try {
- const data = await fetchFn()
-
- if (data !== null) {
- setCacheItem(key, data, ttl, staleWhileRevalidate)
- }
-
- return data
- } finally {
- // Remove from in-flight map when done
- inFlightRequests.delete(key)
- }
- })()
-
- // Store the promise for deduplication
- inFlightRequests.set(key, requestPromise)
-
- return requestPromise
- } catch (error) {
- console.error(`[SEO Cache] Error for key ${key}:`, error)
- // On error, try to return stale data if available
- const cached = cache.get(key)
- return (cached?.data as T) ?? null
- }
-}
-
-/**
- * Set item in cache
- */
-function setCacheItem(key: string, data: T, ttl: number, staleWhileRevalidate: number): void {
- cache.set(key, {
- data,
- timestamp: Date.now(),
- ttl,
- staleWhileRevalidate,
- })
-}
-
-/**
- * Revalidate cache in background
- */
-async function revalidateInBackground(
- key: string,
- fetchFn: () => Promise,
- ttl: number,
- staleWhileRevalidate: number,
-): Promise {
- // Check if there's already an in-flight request for this key
- if (inFlightRequests.has(key)) {
- console.log(
- `[SEO Cache] Skipping background revalidation, request already in-flight for: ${key}`,
- )
- return
- }
-
- // Use setImmediate to ensure this doesn't block
- setImmediate(async () => {
- // Double-check in case another request started
- if (inFlightRequests.has(key)) {
- return
- }
-
- const requestPromise = (async () => {
- try {
- console.log(`[SEO Cache] Revalidating in background: ${key}`)
- const data = await fetchFn()
- if (data !== null) {
- setCacheItem(key, data, ttl, staleWhileRevalidate)
- }
- } catch (error) {
- console.error(`[SEO Cache] Background revalidation failed for ${key}:`, error)
- } finally {
- inFlightRequests.delete(key)
- }
- })()
-
- // Store the promise for deduplication
- inFlightRequests.set(key, requestPromise)
- })
-}
-
-/**
- * Invalidate cache entries by pattern
- */
-export function invalidateCache(pattern: string | RegExp): number {
- let invalidated = 0
-
- for (const key of cache.keys()) {
- if (typeof pattern === 'string' ? key.includes(pattern) : pattern.test(key)) {
- cache.delete(key)
- invalidated++
- }
- }
-
- console.log(`[SEO Cache] Invalidated ${invalidated} entries matching pattern`)
- return invalidated
-}
-
-/**
- * Clear entire cache
- */
-export function clearCache(): void {
- cache.clear()
- console.log('[SEO Cache] Cache cleared')
-}
-
-/**
- * Warm cache with popular content
- */
-export async function warmCache(
- items: { key: string; fetchFn: () => Promise }[],
- options: CacheOptions = {},
-): Promise {
- console.log(`[SEO Cache] Warming cache with ${items.length} items`)
-
- // Process in batches to avoid overloading
- const batchSize = 10
- for (let i = 0; i < items.length; i += batchSize) {
- const batch = items.slice(i, i + batchSize)
- await Promise.all(batch.map(({ key, fetchFn }) => getFromCache(key, fetchFn, options)))
- }
-}
diff --git a/src/lib/captcha/config.ts b/src/lib/captcha/config.ts
index 039ad5081..90c833031 100644
--- a/src/lib/captcha/config.ts
+++ b/src/lib/captcha/config.ts
@@ -1,10 +1,7 @@
export const RECAPTCHA_CONFIG = {
siteKey: process.env.NEXT_PUBLIC_RECAPTCHA_SITE_KEY ?? '',
secretKey: process.env.RECAPTCHA_SECRET_KEY ?? '',
- // Score threshold (0.0 = likely bot, 1.0 = likely human)
- // reCAPTCHA v3 recommends 0.5 as a starting point
scoreThreshold: 0.5,
- // Actions for different parts of the application
actions: {
CREATE_LISTING: 'create_listing',
VOTE: 'vote',
@@ -14,23 +11,32 @@ export const RECAPTCHA_CONFIG = {
},
} as const
-// Validate configuration
if (
process.env.NODE_ENV !== 'test' &&
typeof window === 'undefined' &&
+ !isCaptchaDisabled() &&
!RECAPTCHA_CONFIG.secretKey
) {
console.warn('RECAPTCHA_SECRET_KEY is not set. CAPTCHA verification will be disabled.')
}
-if (process.env.NODE_ENV !== 'test' && typeof window !== 'undefined' && !RECAPTCHA_CONFIG.siteKey) {
+if (
+ process.env.NODE_ENV !== 'test' &&
+ typeof window !== 'undefined' &&
+ !isCaptchaDisabled() &&
+ !RECAPTCHA_CONFIG.siteKey
+) {
console.warn('NEXT_PUBLIC_RECAPTCHA_SITE_KEY is not set. CAPTCHA will be disabled.')
}
+export function isCaptchaDisabled(): boolean {
+ return process.env.NEXT_PUBLIC_DISABLE_RECAPTCHA === 'true'
+}
+
export function isCaptchaClientEnabled(): boolean {
- return Boolean(RECAPTCHA_CONFIG.siteKey)
+ return !isCaptchaDisabled() && Boolean(RECAPTCHA_CONFIG.siteKey)
}
export function isCaptchaVerificationEnabled(): boolean {
- return Boolean(RECAPTCHA_CONFIG.secretKey)
+ return !isCaptchaDisabled() && Boolean(RECAPTCHA_CONFIG.secretKey)
}
diff --git a/src/lib/captcha/verify.test.ts b/src/lib/captcha/verify.test.ts
index 8b1d67af4..5fbf869e5 100644
--- a/src/lib/captcha/verify.test.ts
+++ b/src/lib/captcha/verify.test.ts
@@ -18,6 +18,18 @@ describe('captcha config', () => {
expect(isCaptchaClientEnabled()).toBe(true)
expect(isCaptchaVerificationEnabled()).toBe(false)
})
+
+ it('uses the same explicit disable flag for client and server captcha', async () => {
+ vi.stubEnv('NEXT_PUBLIC_DISABLE_RECAPTCHA', 'true')
+ vi.stubEnv('NEXT_PUBLIC_RECAPTCHA_SITE_KEY', 'site-key')
+ vi.stubEnv('RECAPTCHA_SECRET_KEY', 'secret-key')
+ vi.resetModules()
+
+ const { isCaptchaClientEnabled, isCaptchaVerificationEnabled } = await import('./config')
+
+ expect(isCaptchaClientEnabled()).toBe(false)
+ expect(isCaptchaVerificationEnabled()).toBe(false)
+ })
})
describe('verifyRecaptcha', () => {
diff --git a/src/lib/errors.ts b/src/lib/errors.ts
index 79379008e..975ff3156 100644
--- a/src/lib/errors.ts
+++ b/src/lib/errors.ts
@@ -6,7 +6,6 @@ import { toArray } from '@/utils/array'
import { formatUserRole } from '@/utils/format'
import { type Role } from '@orm'
-// Define error types as constants for better type safety
export const ERROR_CODES = {
BAD_REQUEST: 'BAD_REQUEST',
CONFLICT: 'CONFLICT',
@@ -17,8 +16,6 @@ export const ERROR_CODES = {
UNAUTHORIZED: 'UNAUTHORIZED',
} as const
-// Specific error identifiers for client-side error handling
-// These are used in error.cause to identify specific error types
export const APP_ERROR_CODES = {
GAME_ALREADY_EXISTS: 'GAME_ALREADY_EXISTS',
GAME_SUBMISSION_LIMIT_EXCEEDED: 'GAME_SUBMISSION_LIMIT_EXCEEDED',
@@ -28,7 +25,6 @@ export type AppErrorCode = (typeof APP_ERROR_CODES)[keyof typeof APP_ERROR_CODES
export type ErrorCode = keyof typeof ERROR_CODES
-// Define common error scenarios with default messages
export const ERROR_MESSAGES = {
// Authentication & Authorization
FORBIDDEN: 'You do not have permission to perform this action',
diff --git a/src/lib/monitoring/seo-metrics.ts b/src/lib/monitoring/seo-metrics.ts
deleted file mode 100644
index 3278430d5..000000000
--- a/src/lib/monitoring/seo-metrics.ts
+++ /dev/null
@@ -1,189 +0,0 @@
-import { cache } from '@/lib/cache/seo-cache'
-
-/**
- * SEO Performance Monitoring
- * Integrates with existing monitoring infrastructure
- */
-
-interface PerformanceMetrics {
- cacheLookupTime: number
- databaseQueryTime: number
- totalTime: number
- cacheHit: boolean
- staleServed: boolean
-}
-
-// Type guard for cached items
-interface CachedItem {
- data: T
- timestamp: number
- ttl: number
- staleWhileRevalidate: number
-}
-
-function isCachedItem(value: unknown): value is CachedItem {
- return (
- value !== null &&
- typeof value === 'object' &&
- 'data' in value &&
- 'timestamp' in value &&
- 'ttl' in value &&
- 'staleWhileRevalidate' in value &&
- typeof (value as Record).timestamp === 'number' &&
- typeof (value as Record).ttl === 'number'
- )
-}
-
-class SEOMetricsCollector {
- private metrics: PerformanceMetrics[] = []
- private maxMetrics = 1000 // Keep last 1000 operations
-
- recordMetric(metric: PerformanceMetrics) {
- this.metrics.push(metric)
-
- // Keep only recent metrics
- if (this.metrics.length > this.maxMetrics) {
- this.metrics = this.metrics.slice(-this.maxMetrics)
- }
-
- // Log slow queries
- if (metric.totalTime > 100) {
- console.warn('[SEO Performance] Slow operation detected:', {
- totalTime: `${metric.totalTime}ms`,
- cacheHit: metric.cacheHit,
- dbTime: `${metric.databaseQueryTime}ms`,
- })
- }
- }
-
- getAggregatedMetrics() {
- if (this.metrics.length === 0) {
- return {
- avgCacheLookupTime: 0,
- avgDatabaseQueryTime: 0,
- avgTotalTime: 0,
- cacheHitRate: 0,
- staleServeRate: 0,
- sampleSize: 0,
- p95ResponseTime: 0,
- maxResponseTime: 0,
- minResponseTime: 0,
- medianResponseTime: 0,
- }
- }
-
- const cacheHits = this.metrics.filter((m) => m.cacheHit).length
- const staleServed = this.metrics.filter((m) => m.staleServed).length
-
- const sumMetrics = this.metrics.reduce(
- (acc, m) => ({
- cacheLookup: acc.cacheLookup + m.cacheLookupTime,
- dbQuery: acc.dbQuery + m.databaseQueryTime,
- total: acc.total + m.totalTime,
- }),
- { cacheLookup: 0, dbQuery: 0, total: 0 },
- )
-
- // Calculate percentiles and min/max
- const sortedTimes = this.metrics.map((m) => m.totalTime).sort((a, b) => a - b)
-
- const p95Index = Math.floor(sortedTimes.length * 0.95)
- const medianIndex = Math.floor(sortedTimes.length * 0.5)
-
- return {
- avgCacheLookupTime: Math.round(sumMetrics.cacheLookup / this.metrics.length),
- avgDatabaseQueryTime: Math.round(sumMetrics.dbQuery / this.metrics.length),
- avgTotalTime: Math.round(sumMetrics.total / this.metrics.length),
- cacheHitRate: (cacheHits / this.metrics.length) * 100,
- staleServeRate: (staleServed / this.metrics.length) * 100,
- sampleSize: this.metrics.length,
- p95ResponseTime: Math.round(sortedTimes[p95Index] || 0),
- maxResponseTime: Math.round(sortedTimes[sortedTimes.length - 1] || 0),
- minResponseTime: Math.round(sortedTimes[0] || 0),
- medianResponseTime: Math.round(sortedTimes[medianIndex] || 0),
- }
- }
-
- reset() {
- this.metrics = []
- }
-}
-
-export const seoMetrics = new SEOMetricsCollector()
-
-/**
- * Performance monitoring wrapper
- */
-export async function withMetrics(
- operation: string,
- fn: () => Promise,
- options: { cacheKey?: string } = {},
-): Promise {
- const startTime = performance.now()
- let cacheHit = false
- let staleServed = false
- let dbQueryTime = 0
-
- try {
- // Check if this is a cache operation
- if (options.cacheKey) {
- const cachedValue = cache.get(options.cacheKey)
- if (isCachedItem(cachedValue)) {
- cacheHit = true
- const age = Date.now() - cachedValue.timestamp
- staleServed = age > cachedValue.ttl
- }
- }
-
- const dbStart = performance.now()
- const result = await fn()
- dbQueryTime = performance.now() - dbStart
-
- return result
- } finally {
- const totalTime = performance.now() - startTime
-
- seoMetrics.recordMetric({
- cacheLookupTime: cacheHit ? totalTime - dbQueryTime : 0,
- databaseQueryTime: cacheHit ? 0 : dbQueryTime,
- totalTime,
- cacheHit,
- staleServed,
- })
- }
-}
-
-/**
- * Export metrics for external monitoring systems
- */
-export function exportMetrics() {
- const cacheMetrics = cache.dump().map(([key, value]) => {
- // Safely access the cached item properties
- let age = 0
- if (isCachedItem(value.value)) {
- age = Date.now() - value.value.timestamp
- }
-
- return {
- key,
- size: JSON.stringify(value).length,
- age,
- }
- })
-
- // Handle empty cache scenario
- const totalSize = cacheMetrics.reduce((sum, m) => sum + m.size, 0)
- const oldestEntry = cacheMetrics.length > 0 ? Math.max(...cacheMetrics.map((m) => m.age)) : 0
-
- return {
- cache: {
- entries: cacheMetrics,
- totalSize,
- oldestEntry,
- averageSize: cacheMetrics.length > 0 ? Math.round(totalSize / cacheMetrics.length) : 0,
- totalEntries: cacheMetrics.length,
- },
- performance: seoMetrics.getAggregatedMetrics(),
- timestamp: new Date().toISOString(),
- }
-}
diff --git a/src/lib/trpc-client-errors.test.ts b/src/lib/trpc-client-errors.test.ts
new file mode 100644
index 000000000..59eac143f
--- /dev/null
+++ b/src/lib/trpc-client-errors.test.ts
@@ -0,0 +1,45 @@
+import { TRPCClientError } from '@trpc/client'
+import { describe, expect, it } from 'vitest'
+import { isTRPCNotFoundError, shouldRetryTRPCQuery } from './trpc-client-errors'
+import type { AppRouter } from '@/types/trpc'
+
+type TestTRPCErrorCode = 'NOT_FOUND' | 'INTERNAL_SERVER_ERROR'
+
+function createTRPCError(code: TestTRPCErrorCode): TRPCClientError {
+ const httpStatus = code === 'NOT_FOUND' ? 404 : 500
+
+ return new TRPCClientError('Request failed', {
+ result: {
+ error: {
+ message: 'Request failed',
+ code: code === 'NOT_FOUND' ? -32004 : -32603,
+ data: {
+ code,
+ httpStatus,
+ path: 'test.procedure',
+ zodError: null,
+ },
+ },
+ },
+ })
+}
+
+describe('tRPC client error helpers', () => {
+ it('detects tRPC NOT_FOUND errors', () => {
+ expect(isTRPCNotFoundError(createTRPCError('NOT_FOUND'))).toBe(true)
+ expect(isTRPCNotFoundError(createTRPCError('INTERNAL_SERVER_ERROR'))).toBe(false)
+ expect(isTRPCNotFoundError(new Error('plain error'))).toBe(false)
+ })
+
+ it('does not retry NOT_FOUND errors', () => {
+ expect(shouldRetryTRPCQuery(0, createTRPCError('NOT_FOUND'))).toBe(false)
+ })
+
+ it('keeps the default three-attempt retry policy for retryable errors', () => {
+ const error = createTRPCError('INTERNAL_SERVER_ERROR')
+
+ expect(shouldRetryTRPCQuery(0, error)).toBe(true)
+ expect(shouldRetryTRPCQuery(2, error)).toBe(true)
+ expect(shouldRetryTRPCQuery(3, error)).toBe(false)
+ })
+})
diff --git a/src/lib/trpc-client-errors.ts b/src/lib/trpc-client-errors.ts
new file mode 100644
index 000000000..95ee52db3
--- /dev/null
+++ b/src/lib/trpc-client-errors.ts
@@ -0,0 +1,13 @@
+import { isTRPCClientError } from '@trpc/client'
+import type { AppRouter } from '@/types/trpc'
+
+const MAX_QUERY_RETRIES = 3
+const NOT_FOUND_ERROR_CODE = 'NOT_FOUND'
+
+export function isTRPCNotFoundError(error: unknown): boolean {
+ return isTRPCClientError(error) && error.data?.code === NOT_FOUND_ERROR_CODE
+}
+
+export function shouldRetryTRPCQuery(failureCount: number, error: Error): boolean {
+ return !isTRPCNotFoundError(error) && failureCount < MAX_QUERY_RETRIES
+}
diff --git a/src/middleware.ts b/src/proxy.ts
similarity index 71%
rename from src/middleware.ts
rename to src/proxy.ts
index 66faf56bc..5200f4975 100644
--- a/src/middleware.ts
+++ b/src/proxy.ts
@@ -1,17 +1,18 @@
import { clerkMiddleware, createRouteMatcher } from '@clerk/nextjs/server'
import { NextResponse } from 'next/server'
-import { getAllowedOrigins, isAllowedRequestOrigin } from '@/lib/cors'
+import { getAllowedOrigins, getOriginFromUrl, isAllowedRequestOrigin } from '@/lib/cors'
import { ms } from '@/utils/time'
import type { NextRequest, NextFetchEvent } from 'next/server'
-// In-memory rate limiting with automatic cleanup
-// TODO: For distributed deployments, consider Redis or database-backed rate limiting
+// Process-local rate limiting only; counts are not shared across server instances.
+// TODO: For production abuse control, prefer provider/WAF rate limits before traffic reaches Next.
const rateLimitMap = new Map()
-// Rate limiting configuration
-const RATE_LIMIT_REQUESTS = process.env.NODE_ENV === 'test' ? 10000 : 100 // Much higher limit for tests
+const RATE_LIMIT_REQUESTS = process.env.NODE_ENV === 'test' ? 10000 : 100
const RATE_LIMIT_WINDOW = ms.minutes(3)
+const RATE_LIMIT_CLEANUP_SAMPLE_RATE = 0.01
const DEV_NO_STORE_HOSTS = new Set(['dev.emuready.com'])
+const LOCAL_RATE_LIMIT_BYPASS_IDENTIFIERS = new Set(['::1', '127.0.0.1', 'localhost', 'unknown'])
function applyDevNoStoreHeader(
response: T,
@@ -29,39 +30,29 @@ function applyDevNoStoreHeader(
}
function getClientIdentifier(req: NextRequest): string {
- // Use IP from forwarded headers or fallback
const forwarded = req.headers.get('x-forwarded-for')
const realIp = req.headers.get('x-real-ip')
- const cfConnectingIp = req.headers.get('cf-connecting-ip') // Cloudflare
+ const cfConnectingIp = req.headers.get('cf-connecting-ip')
if (forwarded) return forwarded.split(',')[0].trim()
return realIp || cfConnectingIp || 'unknown'
}
-function checkRateLimit(identifier: string): boolean {
- // Skip rate limiting if explicitly disabled (for E2E tests)
- if (process.env.DISABLE_RATE_LIMIT === 'true') {
- return true
- }
+function shouldBypassRateLimit(identifier: string): boolean {
+ if (process.env.DISABLE_RATE_LIMIT === 'true') return true
- // Skip rate limiting for localhost in test/development environments
- if (
- (process.env.NODE_ENV === 'test' || process.env.NODE_ENV === 'development') &&
- (identifier === '::1' ||
- identifier === '127.0.0.1' ||
- identifier === 'localhost' ||
- identifier === 'unknown')
- ) {
- return true
- }
+ if (process.env.NODE_ENV !== 'test' && process.env.NODE_ENV !== 'development') return false
+
+ return LOCAL_RATE_LIMIT_BYPASS_IDENTIFIERS.has(identifier)
+}
+
+function checkRateLimit(identifier: string): boolean {
+ if (shouldBypassRateLimit(identifier)) return true
const now = Date.now()
- // Clean up expired entries to prevent memory leaks
- // Only clean every 100-ish requests to avoid performance impact
- if (Math.random() < 0.01) {
- // 1% chance per request
+ if (Math.random() < RATE_LIMIT_CLEANUP_SAMPLE_RATE) {
for (const [key, value] of rateLimitMap.entries()) {
if (now > value.resetTime) rateLimitMap.delete(key)
}
@@ -70,14 +61,13 @@ function checkRateLimit(identifier: string): boolean {
const userLimit = rateLimitMap.get(identifier)
if (!userLimit || now > userLimit.resetTime) {
- // Reset or create new limit window
rateLimitMap.set(identifier, {
count: 1,
resetTime: now + RATE_LIMIT_WINDOW,
})
return true
}
- // Slow down boy, rate limit exceeded
+
if (userLimit.count >= RATE_LIMIT_REQUESTS) return false
userLimit.count++
@@ -90,6 +80,10 @@ function isValidOrigin(req: NextRequest): boolean {
const allowedOrigins = getAllowedOrigins()
+ if (isSameOriginSource(req, origin) || isSameOriginSource(req, referer)) {
+ return true
+ }
+
if (isAllowedRequestOrigin({ allowedOrigins, source: origin })) {
return true
}
@@ -98,7 +92,6 @@ function isValidOrigin(req: NextRequest): boolean {
return true
}
- // Allow requests with no origin/referer (server-side, mobile apps, etc.) but check for the API key
if (!origin && !referer) {
const apiKey = req.headers.get('x-api-key')
const internalApiKey = process.env.INTERNAL_API_KEY
@@ -108,28 +101,28 @@ function isValidOrigin(req: NextRequest): boolean {
return false
}
+function isSameOriginSource(req: NextRequest, source: string | null): boolean {
+ const sourceOrigin = getOriginFromUrl(source ?? '')
+ if (!sourceOrigin) return false
+
+ const host = req.headers.get('host')
+ if (!host) return false
+
+ return sourceOrigin === `${req.nextUrl.protocol}//${host}`
+}
+
function protectTRPCAPI(req: NextRequest): NextResponse | null {
const pathname = req.nextUrl.pathname
- // Skip protection for mobile routes - they have their own CORS handling
if (pathname.startsWith('/api/mobile/trpc/')) return null
- // Only protect TRPC API routes
if (!pathname.startsWith('/api/trpc/')) return null
- // Skip protection for mobile procedures in the main tRPC router
if (pathname.startsWith('/api/trpc/mobile.')) return null
const clientId = getClientIdentifier(req)
- // Check rate limit (skip if disabled or in test/dev environment for localhost)
- const skipRateLimit =
- process.env.DISABLE_RATE_LIMIT === 'true' ||
- ((process.env.NODE_ENV === 'test' || process.env.NODE_ENV === 'development') &&
- (clientId === '::1' ||
- clientId === '127.0.0.1' ||
- clientId === 'localhost' ||
- clientId === 'unknown'))
+ const skipRateLimit = shouldBypassRateLimit(clientId)
if (!skipRateLimit && !checkRateLimit(clientId)) {
console.warn(`Rate limit exceeded for client: ${clientId}, path: ${pathname}`)
@@ -149,7 +142,6 @@ function protectTRPCAPI(req: NextRequest): NextResponse | null {
)
}
- // Check origin for public API routes (skip in test environment)
if (process.env.NODE_ENV !== 'test' && !isValidOrigin(req)) {
console.warn(
`Invalid origin for client: ${clientId}, origin: ${req.headers.get('origin')}, referer: ${req.headers.get('referer')}, path: ${pathname}`,
@@ -169,7 +161,6 @@ function protectTRPCAPI(req: NextRequest): NextResponse | null {
)
}
- // Add security headers to successful requests
const response = applyDevNoStoreHeader(NextResponse.next(), req)
response.headers.set('X-Content-Type-Options', 'nosniff')
response.headers.set('X-Frame-Options', 'DENY')
@@ -190,9 +181,15 @@ const handleClerkAuth = clerkMiddleware(async (auth, req) => {
return
})
-export default async function middleware(req: NextRequest, evt: NextFetchEvent) {
+export async function proxy(req: NextRequest, evt: NextFetchEvent) {
const pathname = req.nextUrl.pathname
+ if (pathname === '/api/mobile/auth') {
+ const response = await handleClerkAuth(req, evt)
+ if (!response) return applyDevNoStoreHeader(NextResponse.next(), req)
+ return applyDevNoStoreHeader(response, req)
+ }
+
if (pathname.startsWith('/api/mobile/')) {
const apiProtectionResponse = protectTRPCAPI(req)
if (apiProtectionResponse) return apiProtectionResponse
@@ -212,9 +209,7 @@ export default async function middleware(req: NextRequest, evt: NextFetchEvent)
export const config = {
matcher: [
- // Skip Next.js internals and all static files, unless found in search params
'/((?!_next|[^?]*\\.(?:html?|css|js(?!on)|jpe?g|webp|png|gif|svg|ttf|woff2?|ico|csv|docx?|xlsx?|zip|webmanifest)).*)',
- // Always run for API routes
'/(api|trpc)(.*)',
],
}
diff --git a/src/rest/http.ts b/src/rest/http.ts
index a985c2e2e..dfa50ba50 100644
--- a/src/rest/http.ts
+++ b/src/rest/http.ts
@@ -1,5 +1,6 @@
import axios, { type AxiosError } from 'axios'
import analytics from '@/lib/analytics'
+import { logger } from '@/lib/logger'
const http = axios.create({
timeout: 20000,
@@ -11,7 +12,7 @@ const http = axios.create({
http.interceptors.response.use(
(response) => response,
(error: AxiosError) => {
- // Track errors to analytics
+ logger.error('HTTP Error:', error)
analytics.performance.errorOccurred({
errorType: 'api_request_error',
errorMessage: error.message,
diff --git a/src/schemas/cache.ts b/src/schemas/cache.ts
deleted file mode 100644
index 102a37a48..000000000
--- a/src/schemas/cache.ts
+++ /dev/null
@@ -1,9 +0,0 @@
-import { z } from 'zod'
-
-export const GetCacheEntrySchema = z.object({
- key: z.string(),
-})
-
-export const DeleteCacheEntrySchema = z.object({
- key: z.string(),
-})
diff --git a/src/server/api/root.ts b/src/server/api/root.ts
index 09badaaed..923774dbe 100644
--- a/src/server/api/root.ts
+++ b/src/server/api/root.ts
@@ -8,7 +8,6 @@ import { apiKeysRouter } from './routers/apiKeys'
import { auditLogsRouter } from './routers/auditLogs'
import { badgesRouter } from './routers/badges'
import { bookmarksRouter } from './routers/bookmarks'
-import { cacheRouter } from './routers/cache'
import { cpusRouter } from './routers/cpus'
import { customFieldCategoryRouter } from './routers/customFieldCategories'
import { customFieldDefinitionRouter } from './routers/customFieldDefinitions'
@@ -63,7 +62,6 @@ export const appRouter = createTRPCRouter({
userPreferences: userPreferencesRouter,
userBans: userBansRouter,
badges: badgesRouter,
- cache: cacheRouter,
notifications: notificationsRouter,
customFieldCategories: customFieldCategoryRouter,
customFieldDefinitions: customFieldDefinitionRouter,
diff --git a/src/server/api/routers/cache.ts b/src/server/api/routers/cache.ts
deleted file mode 100644
index 76042885d..000000000
--- a/src/server/api/routers/cache.ts
+++ /dev/null
@@ -1,218 +0,0 @@
-import { cache, getCacheMetrics } from '@/lib/cache/seo-cache'
-import { AppError } from '@/lib/errors'
-import { seoMetrics, exportMetrics } from '@/lib/monitoring/seo-metrics'
-import { GetCacheEntrySchema, DeleteCacheEntrySchema } from '@/schemas/cache'
-import { createTRPCRouter, superAdminProcedure } from '@/server/api/trpc'
-import {
- createQueryCacheKey,
- QueryPerformanceMonitor,
- suggestIndexes,
- analyzeQueryComplexity,
-} from '@/server/utils/query-performance'
-import { ApprovalStatus, ReportStatus } from '@orm/client'
-
-export const cacheRouter = createTRPCRouter({
- /**
- * Get cache metrics and statistics
- */
- getMetrics: superAdminProcedure.query(async () => {
- const cacheMetrics = getCacheMetrics()
- const seoData = seoMetrics.getAggregatedMetrics()
- const exportData = exportMetrics()
- const queryMetrics = QueryPerformanceMonitor.getMetrics()
-
- return {
- cache: cacheMetrics,
- seo: seoData,
- export: exportData,
- query: queryMetrics,
- timestamp: new Date().toISOString(),
- }
- }),
-
- /**
- * Clear all cache entries
- */
- clear: superAdminProcedure.mutation(async () => {
- try {
- cache.clear()
- seoMetrics.reset()
-
- return {
- success: true,
- message: 'Cache cleared successfully',
- timestamp: new Date().toISOString(),
- }
- } catch {
- AppError.internalError('Failed to clear cache')
- }
- }),
-
- /**
- * Warm the cache with critical data
- */
- warm: superAdminProcedure.mutation(async ({ ctx }) => {
- try {
- // Warm critical paths
- const warmedPaths = []
-
- // Fetch popular games for cache warming
- const popularGames = await ctx.prisma.game.findMany({
- take: 10,
- orderBy: { listings: { _count: 'desc' } },
- select: { id: true, title: true },
- })
-
- // Warm game metadata
- for (const game of popularGames) {
- const cacheKey = createQueryCacheKey('seo', 'game', { id: game.id })
- const cacheData = {
- title: game.title,
- description: `${game.title} compatibility information`,
- }
- cache.set(cacheKey, {
- data: cacheData,
- timestamp: Date.now(),
- ttl: 3600 * 1000, // Convert to milliseconds
- staleWhileRevalidate: 7200 * 1000,
- })
- warmedPaths.push(cacheKey)
- }
-
- // Fetch popular listings
- const popularListings = await ctx.prisma.listing.findMany({
- take: 10,
- where: { status: ApprovalStatus.APPROVED },
- orderBy: { votes: { _count: 'desc' } },
- include: {
- game: { select: { title: true } },
- device: { include: { brand: true } },
- emulator: true,
- },
- })
-
- // Warm listing metadata
- for (const listing of popularListings) {
- const cacheKey = createQueryCacheKey('seo', 'listing', {
- id: listing.id,
- })
- const cacheData = {
- title: `${listing.game.title} on ${listing.device.brand.name} ${listing.device.modelName}`,
- description: `${listing.game.title} running on ${listing.emulator.name}`,
- }
- cache.set(cacheKey, {
- data: cacheData,
- timestamp: Date.now(),
- ttl: 3600 * 1000, // Convert to milliseconds
- staleWhileRevalidate: 7200 * 1000,
- })
- warmedPaths.push(cacheKey)
- }
-
- return {
- success: true,
- message: `Cache warmed with ${warmedPaths.length} entries`,
- warmedPaths,
- timestamp: new Date().toISOString(),
- }
- } catch (error) {
- console.error('Cache warming error:', error)
- AppError.internalError('Failed to warm cache')
- }
- }),
-
- /**
- * Get specific cache entry
- */
- get: superAdminProcedure.input(GetCacheEntrySchema).query(async ({ input }) => {
- const value = cache.get(input.key)
- return {
- key: input.key,
- value,
- exists: value !== undefined,
- timestamp: new Date().toISOString(),
- }
- }),
-
- /**
- * Delete specific cache entry
- */
- delete: superAdminProcedure.input(DeleteCacheEntrySchema).mutation(async ({ input }) => {
- const existed = cache.has(input.key)
- cache.delete(input.key)
-
- return {
- success: true,
- existed,
- message: existed ? 'Cache entry deleted' : 'Entry did not exist',
- timestamp: new Date().toISOString(),
- }
- }),
-
- /**
- * Analyze query patterns and suggest database indexes
- */
- analyzeQueries: superAdminProcedure.query(async () => {
- // Common query patterns in the application
- const queryPatterns = [
- {
- name: 'Listings by status and author',
- model: 'listing',
- where: { status: ApprovalStatus.APPROVED, authorId: 'user_id' },
- orderBy: { createdAt: 'desc' },
- },
- {
- name: 'Listings by game and device',
- model: 'listing',
- where: { gameId: 'game_id', deviceId: 'device_id' },
- orderBy: { createdAt: 'desc' },
- },
- {
- name: 'Games by system with approval',
- model: 'game',
- where: { systemId: 'system_id', status: ApprovalStatus.APPROVED },
- orderBy: { title: 'asc' },
- },
- {
- name: 'PC Listings by CPU and GPU',
- model: 'pcListing',
- where: {
- cpuId: 'cpu_id',
- gpuId: 'gpu_id',
- status: ApprovalStatus.APPROVED,
- },
- orderBy: { createdAt: 'desc' },
- },
- {
- name: 'Users with listings count',
- model: 'user',
- where: { listings: { some: { status: ApprovalStatus.APPROVED } } },
- },
- {
- name: 'Reports by status',
- model: 'listingReport',
- where: { status: ReportStatus.PENDING },
- orderBy: { createdAt: 'desc' },
- },
- ]
-
- const suggestions = queryPatterns.map((pattern) => ({
- pattern: pattern.name,
- model: pattern.model,
- complexity: analyzeQueryComplexity(
- pattern.model === 'user' ? { listings: true } : undefined,
- pattern.where,
- ),
- indexSuggestions: suggestIndexes(pattern.model, pattern.where, pattern.orderBy),
- }))
-
- // Get actual query performance metrics
- const performanceMetrics = QueryPerformanceMonitor.getMetrics()
-
- return {
- suggestions,
- performanceMetrics,
- timestamp: new Date().toISOString(),
- }
- }),
-})
diff --git a/src/server/api/routers/listings/admin.test.ts b/src/server/api/routers/listings/admin.test.ts
index a3d80f030..27b944789 100644
--- a/src/server/api/routers/listings/admin.test.ts
+++ b/src/server/api/routers/listings/admin.test.ts
@@ -43,14 +43,14 @@ vi.mock('@/server/notifications/eventEmitter', () => ({
}))
vi.mock('@/server/cache/invalidation', () => ({
- invalidateListing: vi.fn().mockResolvedValue(undefined),
- invalidateListPages: vi.fn().mockResolvedValue(undefined),
- invalidateSitemap: vi.fn().mockResolvedValue(undefined),
- revalidateByTag: vi.fn().mockResolvedValue(undefined),
+ invalidateListingSeo: vi.fn().mockResolvedValue(undefined),
+ invalidateListingsSeo: vi.fn().mockResolvedValue(undefined),
}))
vi.mock('@/server/utils/cache/instances', () => ({
listingStatsCache: { delete: vi.fn(), get: vi.fn(), set: vi.fn() },
+ invalidateCatalogCompatibilityCacheForDevice: vi.fn(),
+ invalidateCatalogCompatibilityCacheForDevices: vi.fn(),
}))
vi.mock('@/server/utils/emulator-config/emulator-detector', () => ({
diff --git a/src/server/api/routers/listings/admin.ts b/src/server/api/routers/listings/admin.ts
index 607c198bf..2d401b675 100644
--- a/src/server/api/routers/listings/admin.ts
+++ b/src/server/api/routers/listings/admin.ts
@@ -27,12 +27,7 @@ import {
protectedProcedure,
} from '@/server/api/trpc'
import { buildProcessedOrderBy } from '@/server/api/utils/listingHelpers'
-import {
- invalidateListing,
- invalidateListPages,
- invalidateSitemap,
- revalidateByTag,
-} from '@/server/cache/invalidation'
+import { invalidateListingSeo, invalidateListingsSeo } from '@/server/cache/invalidation'
import { notificationEventEmitter, NOTIFICATION_EVENTS } from '@/server/notifications/eventEmitter'
import { ListingsRepository } from '@/server/repositories/listings.repository'
import { PcListingsRepository } from '@/server/repositories/pc-listings.repository'
@@ -41,7 +36,11 @@ import {
computeReviewRiskProfiles,
getRiskOnlyReviewPage,
} from '@/server/services/review-risk.service'
-import { listingStatsCache } from '@/server/utils/cache/instances'
+import {
+ invalidateCatalogCompatibilityCacheForDevice,
+ invalidateCatalogCompatibilityCacheForDevices,
+ listingStatsCache,
+} from '@/server/utils/cache/instances'
import { generateEmulatorConfig } from '@/server/utils/emulator-config/emulator-detector'
import { paginate } from '@/server/utils/pagination'
import { hasRolePermission } from '@/utils/permissions'
@@ -212,19 +211,13 @@ export const adminRouter = createTRPCRouter({
},
})
- // Invalidate SEO cache
- await invalidateListing(listingId)
- await invalidateListPages()
- await invalidateSitemap()
- await revalidateByTag('listings')
- await revalidateByTag(`listing-${listingId}`)
- await revalidateByTag(`game-${listingToApprove.gameId}`)
- await revalidateByTag(`device-${listingToApprove.deviceId}`)
- await revalidateByTag(`emulator-${listingToApprove.emulatorId}`)
-
- // Invalidate catalog compatibility cache for this device
- const { catalogCompatibilityCache } = await import('@/server/utils/cache/instances')
- catalogCompatibilityCache.invalidatePattern(`device:${listingToApprove.deviceId}:*`)
+ await invalidateListingSeo({
+ id: listingId,
+ gameId: listingToApprove.gameId,
+ deviceId: listingToApprove.deviceId,
+ emulatorId: listingToApprove.emulatorId,
+ })
+ invalidateCatalogCompatibilityCacheForDevice(listingToApprove.deviceId)
// Apply trust action for listing approval to the author
if (listingToApprove.authorId) {
@@ -342,9 +335,7 @@ export const adminRouter = createTRPCRouter({
// Invalidate listing stats cache
listingStatsCache.delete(LISTING_STATS_CACHE_KEY)
- // Invalidate catalog compatibility cache for this device
- const { catalogCompatibilityCache } = await import('@/server/utils/cache/instances')
- catalogCompatibilityCache.invalidatePattern(`device:${listingToReject.deviceId}:*`)
+ invalidateCatalogCompatibilityCacheForDevice(listingToReject.deviceId)
return updatedListing
}),
@@ -630,17 +621,7 @@ export const adminRouter = createTRPCRouter({
const { validListings } = transactionResult
const approvedAt = new Date()
- // Invalidate SEO cache for all approved listings
- await Promise.all([
- ...validListings.map((listing) => invalidateListing(listing.id)),
- ...validListings.map((listing) => revalidateByTag(`listing-${listing.id}`)),
- ...validListings.map((listing) => revalidateByTag(`game-${listing.gameId}`)),
- ...validListings.map((listing) => revalidateByTag(`device-${listing.deviceId}`)),
- ...validListings.map((listing) => revalidateByTag(`emulator-${listing.emulatorId}`)),
- ])
- await invalidateListPages()
- await invalidateSitemap()
- await revalidateByTag('listings')
+ await invalidateListingsSeo(validListings)
// Emit notification events for each approved listing
for (const listing of validListings) {
@@ -674,6 +655,10 @@ export const adminRouter = createTRPCRouter({
listingStatsCache.delete(LISTING_STATS_CACHE_KEY)
const { validListings, bannedUserListings, notFoundOrNotPendingIds } = transactionResult
+ invalidateCatalogCompatibilityCacheForDevices([
+ ...validListings.map((listing) => listing.deviceId),
+ ...bannedUserListings.map((listing) => listing.deviceId),
+ ])
let message = `Successfully approved ${validListings.length} listing(s).`
@@ -828,6 +813,9 @@ export const adminRouter = createTRPCRouter({
listingStatsCache.delete(LISTING_STATS_CACHE_KEY)
const { listingsToReject, notFoundOrNotPendingIds } = transactionResult
+ invalidateCatalogCompatibilityCacheForDevices(
+ listingsToReject.map((listing) => listing.deviceId),
+ )
const message =
notFoundOrNotPendingIds.length > 0
diff --git a/src/server/api/routers/mobile/pcListings.ts b/src/server/api/routers/mobile/pcListings.ts
index 49bfb40a8..047beca35 100644
--- a/src/server/api/routers/mobile/pcListings.ts
+++ b/src/server/api/routers/mobile/pcListings.ts
@@ -14,9 +14,8 @@ import {
} from '@/server/api/mobileContext'
import { pcListingInclude, buildPcListingWhere } from '@/server/api/utils/pcListingHelpers'
import {
- invalidateListPages,
- invalidateSitemap,
- revalidateByTag,
+ invalidatePcListingSeo,
+ invalidatePcListingSeoForUpdate,
} from '@/server/cache/invalidation'
import { PcListingsRepository } from '@/server/repositories/pc-listings.repository'
import { listingStatsCache } from '@/server/utils/cache'
@@ -181,11 +180,13 @@ export const mobilePcListingsRouter = createMobileTRPCRouter({
// Invalidate stats cache
listingStatsCache.delete('pc-listing-stats')
- // Invalidate pages if approved
if (created.status === ApprovalStatus.APPROVED) {
- await invalidateListPages()
- await invalidateSitemap()
- await revalidateByTag('pc-listings')
+ await invalidatePcListingSeo({
+ id: created.id,
+ gameId: created.gameId,
+ cpuId: created.cpuId,
+ gpuId: created.gpuId,
+ })
}
return created
@@ -197,10 +198,9 @@ export const mobilePcListingsRouter = createMobileTRPCRouter({
update: mobileProtectedProcedure.input(UpdatePcListingSchema).mutation(async ({ ctx, input }) => {
const { id, customFieldValues, ...updateData } = input
- // Check if user owns the listing
const existing = await ctx.prisma.pcListing.findUnique({
where: { id },
- select: { authorId: true },
+ select: { authorId: true, status: true, gameId: true, cpuId: true, gpuId: true },
})
if (!existing) return ResourceError.pcListing.notFound()
@@ -209,7 +209,7 @@ export const mobilePcListingsRouter = createMobileTRPCRouter({
return ResourceError.pcListing.canOnlyEditOwn()
}
- return await ctx.prisma.pcListing.update({
+ const updated = await ctx.prisma.pcListing.update({
where: { id },
data: {
...updateData,
@@ -233,6 +233,25 @@ export const mobilePcListingsRouter = createMobileTRPCRouter({
_count: { select: { reports: true, developerVerifications: true } },
},
})
+
+ if (existing.status === ApprovalStatus.APPROVED) {
+ await invalidatePcListingSeoForUpdate(
+ {
+ id,
+ gameId: existing.gameId,
+ cpuId: existing.cpuId,
+ gpuId: existing.gpuId,
+ },
+ {
+ id,
+ gameId: updated.gameId,
+ cpuId: updated.cpuId,
+ gpuId: updated.gpuId,
+ },
+ )
+ }
+
+ return updated
}),
/**
diff --git a/src/server/api/routers/pcListings.test.ts b/src/server/api/routers/pcListings.test.ts
index 30b0d87d6..63b441acf 100644
--- a/src/server/api/routers/pcListings.test.ts
+++ b/src/server/api/routers/pcListings.test.ts
@@ -1,6 +1,11 @@
-import { describe, expect, it, beforeEach, vi } from 'vitest'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
import { RISK_SIGNAL_TYPES } from '@/schemas/authorRisk'
import { SUBMISSION_RISK_SIGNAL_TYPES } from '@/schemas/submissionRisk'
+import {
+ invalidatePcListingSeo,
+ invalidatePcListingSeoForUpdate,
+ invalidatePcListingsSeo,
+} from '@/server/cache/invalidation'
import { PERMISSIONS } from '@/utils/permission-system'
import { ApprovalStatus, PcOs, Role, TrustAction } from '@orm/client'
import type * as AuthorRiskService from '@/server/services/author-risk.service'
@@ -62,9 +67,9 @@ vi.mock('@/server/utils/cache', () => ({
}))
vi.mock('@/server/cache/invalidation', () => ({
- invalidateListPages: vi.fn().mockResolvedValue(undefined),
- invalidateSitemap: vi.fn().mockResolvedValue(undefined),
- revalidateByTag: vi.fn().mockResolvedValue(undefined),
+ invalidatePcListingSeo: vi.fn().mockResolvedValue(undefined),
+ invalidatePcListingSeoForUpdate: vi.fn().mockResolvedValue(undefined),
+ invalidatePcListingsSeo: vi.fn().mockResolvedValue(undefined),
}))
vi.mock('@/lib/analytics', () => ({
@@ -169,6 +174,7 @@ function createMockPrisma() {
pcListing: {
findUnique: vi.fn(),
findMany: vi.fn().mockResolvedValue([]),
+ update: vi.fn(),
updateMany: vi.fn().mockResolvedValue({ count: 0 }),
},
userBan: {
@@ -806,16 +812,71 @@ describe('pcListings trust integration', () => {
})
})
+ describe('updateAdmin', () => {
+ it('invalidates public SEO when an admin update approves a PC report', async () => {
+ const gameId = '00000000-0000-4000-a000-000000000040'
+ const cpuId = '00000000-0000-4000-a000-000000000070'
+ const emulatorId = '00000000-0000-4000-a000-000000000060'
+ const updatedListing = {
+ id: LISTING_ID,
+ gameId,
+ cpuId,
+ gpuId: null,
+ status: ApprovalStatus.APPROVED,
+ }
+
+ const { caller, prisma } = createCaller({
+ userId: ADMIN_ID,
+ role: Role.MODERATOR,
+ permissions: [PERMISSIONS.APPROVE_LISTINGS],
+ })
+ prisma.pcListing.findUnique.mockResolvedValue({
+ id: LISTING_ID,
+ gameId,
+ cpuId,
+ gpuId: null,
+ status: ApprovalStatus.PENDING,
+ customFieldValues: [],
+ })
+ prisma.pcListing.update.mockResolvedValue(updatedListing)
+
+ await caller.updateAdmin({
+ id: LISTING_ID,
+ gameId,
+ cpuId,
+ emulatorId,
+ performanceId: 1,
+ memorySize: 16,
+ os: PcOs.WINDOWS,
+ osVersion: '11',
+ notes: 'Updated report',
+ status: ApprovalStatus.APPROVED,
+ })
+
+ expect(invalidatePcListingSeo).toHaveBeenCalledWith({
+ id: LISTING_ID,
+ gameId,
+ cpuId,
+ gpuId: null,
+ })
+ expect(invalidatePcListingSeoForUpdate).not.toHaveBeenCalled()
+ })
+ })
+
describe('bulkApprove', () => {
it('calls applyTrustAction with LISTING_APPROVED for each listing author', async () => {
const listing1 = {
id: LISTING_ID,
gameId: '00000000-0000-4000-a000-000000000040',
+ cpuId: '00000000-0000-4000-a000-000000000070',
+ gpuId: '00000000-0000-4000-a000-000000000080',
authorId: AUTHOR_ID,
}
const listing2 = {
id: '00000000-0000-4000-a000-000000000011',
gameId: '00000000-0000-4000-a000-000000000041',
+ cpuId: '00000000-0000-4000-a000-000000000071',
+ gpuId: null,
authorId: '00000000-0000-4000-a000-000000000050',
}
@@ -836,6 +897,7 @@ describe('pcListings trust integration', () => {
action: TrustAction.LISTING_APPROVED,
context: expect.objectContaining({ pcListingId: '00000000-0000-4000-a000-000000000011' }),
})
+ expect(invalidatePcListingsSeo).toHaveBeenCalledWith([listing1, listing2])
})
})
diff --git a/src/server/api/routers/pcListings.ts b/src/server/api/routers/pcListings.ts
index 3676c4df1..95ccc36d9 100644
--- a/src/server/api/routers/pcListings.ts
+++ b/src/server/api/routers/pcListings.ts
@@ -57,9 +57,9 @@ import {
} from '@/server/api/utils/pcListingHelpers'
import { canManageCommentPins } from '@/server/api/utils/pinPermissions'
import {
- invalidateListPages,
- invalidateSitemap,
- revalidateByTag,
+ invalidatePcListingSeo,
+ invalidatePcListingSeoForUpdate,
+ invalidatePcListingsSeo,
} from '@/server/cache/invalidation'
import { NOTIFICATION_EVENTS, notificationEventEmitter } from '@/server/notifications/eventEmitter'
import { PcListingsRepository } from '@/server/repositories/pc-listings.repository'
@@ -340,16 +340,13 @@ export const pcListingsRouter = createTRPCRouter({
// Invalidate stats cache when PC listing is created
listingStatsCache.delete('pc-listing-stats')
- // Invalidate SEO cache if listing is approved
if (newListing.status === ApprovalStatus.APPROVED) {
- await invalidateListPages()
- await invalidateSitemap()
- await revalidateByTag('pc-listings')
- await revalidateByTag(`game-${payload.gameId}`)
- await revalidateByTag(`cpu-${payload.cpuId}`)
- if (payload.gpuId) {
- await revalidateByTag(`gpu-${payload.gpuId}`)
- }
+ await invalidatePcListingSeo({
+ id: newListing.id,
+ gameId: payload.gameId,
+ cpuId: payload.cpuId,
+ gpuId: payload.gpuId ?? null,
+ })
}
return newListing
@@ -371,19 +368,28 @@ export const pcListingsRouter = createTRPCRouter({
where: { id: input.id },
})
- // Invalidate stats cache when PC listing is deleted
listingStatsCache.delete('pc-listing-stats')
+ if (pcListing.status === ApprovalStatus.APPROVED) {
+ await invalidatePcListingSeo(pcListing)
+ }
+
return deletedListing
}),
update: protectedProcedure.input(UpdatePcListingUserSchema).mutation(async ({ ctx, input }) => {
const EDIT_TIME_LIMIT_MINUTES = 60
- // First check if user can edit this PC listing
const pcListing = await ctx.prisma.pcListing.findUnique({
where: { id: input.id },
- select: { authorId: true, status: true, processedAt: true },
+ select: {
+ authorId: true,
+ status: true,
+ processedAt: true,
+ gameId: true,
+ cpuId: true,
+ gpuId: true,
+ },
})
if (!pcListing) return ResourceError.pcListing.notFound()
@@ -473,6 +479,23 @@ export const pcListingsRouter = createTRPCRouter({
}
}
+ if (pcListing.status === ApprovalStatus.APPROVED) {
+ await invalidatePcListingSeoForUpdate(
+ {
+ id,
+ gameId: pcListing.gameId,
+ cpuId: pcListing.cpuId,
+ gpuId: pcListing.gpuId,
+ },
+ {
+ id,
+ gameId: updatedPcListing.gameId,
+ cpuId: updatedPcListing.cpuId,
+ gpuId: updatedPcListing.gpuId,
+ },
+ )
+ }
+
return updatedPcListing
}),
@@ -599,9 +622,15 @@ export const pcListingsRouter = createTRPCRouter({
})
}
- // Invalidate stats cache when PC listing is approved
listingStatsCache.delete('pc-listing-stats')
+ await invalidatePcListingSeo({
+ id: input.pcListingId,
+ gameId: pcListing.gameId,
+ cpuId: pcListing.cpuId,
+ gpuId: pcListing.gpuId,
+ })
+
notificationEventEmitter.emitNotificationEvent({
eventType: NOTIFICATION_EVENTS.PC_LISTING_APPROVED,
entityType: 'pcListing',
@@ -708,6 +737,15 @@ export const pcListingsRouter = createTRPCRouter({
listingStatsCache.delete('pc-listing-stats')
+ if (pcListing.status === ApprovalStatus.APPROVED) {
+ await invalidatePcListingSeo({
+ id: input.pcListingId,
+ gameId: pcListing.gameId,
+ cpuId: pcListing.cpuId,
+ gpuId: pcListing.gpuId,
+ })
+ }
+
return updatedListing
}),
@@ -725,7 +763,7 @@ export const pcListingsRouter = createTRPCRouter({
const pendingListings = await ctx.prisma.pcListing.findMany({
where: { id: { in: input.pcListingIds }, status: ApprovalStatus.PENDING },
- select: { id: true, gameId: true, authorId: true },
+ select: { id: true, gameId: true, cpuId: true, gpuId: true, authorId: true },
})
const result = await ctx.prisma.pcListing.updateMany({
@@ -757,6 +795,8 @@ export const pcListingsRouter = createTRPCRouter({
listingStatsCache.delete('pc-listing-stats')
+ await invalidatePcListingsSeo(pendingListings)
+
for (const listing of pendingListings) {
notificationEventEmitter.emitNotificationEvent({
eventType: NOTIFICATION_EVENTS.PC_LISTING_APPROVED,
@@ -926,21 +966,17 @@ export const pcListingsRouter = createTRPCRouter({
if (!pcListing) return ResourceError.pcListing.notFound()
- // Update PC listing and handle custom field values
const updatedPcListing = await ctx.prisma.pcListing.update({
where: { id },
data: { ...data, updatedAt: new Date() },
include: pcListingDetailInclude,
})
- // Handle custom field values if provided
if (customFieldValues) {
- // Delete existing custom field values
await ctx.prisma.pcListingCustomFieldValue.deleteMany({
where: { pcListingId: id },
})
- // Create new custom field values
if (customFieldValues.length > 0) {
await ctx.prisma.pcListingCustomFieldValue.createMany({
data: customFieldValues.map((cfv) => ({
@@ -952,6 +988,29 @@ export const pcListingsRouter = createTRPCRouter({
}
}
+ const previousSeoTarget = {
+ id,
+ gameId: pcListing.gameId,
+ cpuId: pcListing.cpuId,
+ gpuId: pcListing.gpuId,
+ }
+ const nextSeoTarget = {
+ id,
+ gameId: updatedPcListing.gameId,
+ cpuId: updatedPcListing.cpuId,
+ gpuId: updatedPcListing.gpuId,
+ }
+ const wasApproved = pcListing.status === ApprovalStatus.APPROVED
+ const isApproved = updatedPcListing.status === ApprovalStatus.APPROVED
+
+ if (wasApproved && isApproved) {
+ await invalidatePcListingSeoForUpdate(previousSeoTarget, nextSeoTarget)
+ } else if (wasApproved) {
+ await invalidatePcListingSeo(previousSeoTarget)
+ } else if (isApproved) {
+ await invalidatePcListingSeo(nextSeoTarget)
+ }
+
return updatedPcListing
}),
diff --git a/src/server/cache/invalidation.test.ts b/src/server/cache/invalidation.test.ts
new file mode 100644
index 000000000..5d7870ba6
--- /dev/null
+++ b/src/server/cache/invalidation.test.ts
@@ -0,0 +1,70 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+const nextCacheMocks = vi.hoisted(() => ({
+ revalidatePath: vi.fn(),
+ revalidateTag: vi.fn(),
+}))
+
+vi.mock('next/cache', () => nextCacheMocks)
+
+const {
+ invalidateListingSeo,
+ invalidatePcListing,
+ invalidatePcListingSeoForUpdate,
+ revalidateByTag,
+} = await import('./invalidation')
+
+describe('cache invalidation', () => {
+ beforeEach(() => {
+ vi.clearAllMocks()
+ })
+
+ it('uses the stale-while-revalidate profile for tag invalidation', async () => {
+ await revalidateByTag('games')
+
+ expect(nextCacheMocks.revalidateTag).toHaveBeenCalledWith('games', 'max')
+ })
+
+ it('invalidates PC listing paths and tags consistently', async () => {
+ await invalidatePcListing('pc-listing-1')
+
+ expect(nextCacheMocks.revalidatePath).toHaveBeenCalledWith('/pc-listings/pc-listing-1')
+ expect(nextCacheMocks.revalidateTag).toHaveBeenCalledWith('pc-listing-pc-listing-1', 'max')
+ })
+
+ it('deduplicates related PC listing SEO tags for updates', async () => {
+ await invalidatePcListingSeoForUpdate(
+ { id: 'pc-listing-1', gameId: 'old-game', cpuId: 'old-cpu', gpuId: 'gpu-1' },
+ { id: 'pc-listing-1', gameId: 'new-game', cpuId: 'new-cpu', gpuId: 'gpu-1' },
+ )
+
+ expect(nextCacheMocks.revalidatePath).toHaveBeenCalledWith('/pc-listings/pc-listing-1')
+ expect(nextCacheMocks.revalidatePath).toHaveBeenCalledWith('/pc-listings')
+ expect(nextCacheMocks.revalidatePath).toHaveBeenCalledWith('/sitemap.xml')
+ expect(nextCacheMocks.revalidateTag).toHaveBeenCalledWith('pc-listings', 'max')
+ expect(nextCacheMocks.revalidateTag).toHaveBeenCalledWith('game-old-game', 'max')
+ expect(nextCacheMocks.revalidateTag).toHaveBeenCalledWith('game-new-game', 'max')
+ expect(nextCacheMocks.revalidateTag).toHaveBeenCalledWith('cpu-old-cpu', 'max')
+ expect(nextCacheMocks.revalidateTag).toHaveBeenCalledWith('cpu-new-cpu', 'max')
+ expect(nextCacheMocks.revalidateTag).toHaveBeenCalledWith('gpu-gpu-1', 'max')
+ expect(nextCacheMocks.revalidateTag).toHaveBeenCalledTimes(8)
+ })
+
+ it('invalidates handheld listing SEO paths and tags consistently', async () => {
+ await invalidateListingSeo({
+ id: 'listing-1',
+ gameId: 'game-1',
+ deviceId: 'device-1',
+ emulatorId: 'emulator-1',
+ })
+
+ expect(nextCacheMocks.revalidatePath).toHaveBeenCalledWith('/listings/listing-1')
+ expect(nextCacheMocks.revalidatePath).toHaveBeenCalledWith('/listings')
+ expect(nextCacheMocks.revalidatePath).toHaveBeenCalledWith('/sitemap.xml')
+ expect(nextCacheMocks.revalidateTag).toHaveBeenCalledWith('listing-listing-1', 'max')
+ expect(nextCacheMocks.revalidateTag).toHaveBeenCalledWith('listings', 'max')
+ expect(nextCacheMocks.revalidateTag).toHaveBeenCalledWith('game-game-1', 'max')
+ expect(nextCacheMocks.revalidateTag).toHaveBeenCalledWith('device-device-1', 'max')
+ expect(nextCacheMocks.revalidateTag).toHaveBeenCalledWith('emulator-emulator-1', 'max')
+ })
+})
diff --git a/src/server/cache/invalidation.ts b/src/server/cache/invalidation.ts
index 8b148c352..a897da932 100644
--- a/src/server/cache/invalidation.ts
+++ b/src/server/cache/invalidation.ts
@@ -1,18 +1,25 @@
import { revalidatePath, revalidateTag } from 'next/cache'
-import { invalidateCache } from '@/lib/cache/seo-cache'
-/**
- * Cache invalidation strategies for SEO content
- * Coordinates between in-memory cache and Next.js ISR cache
- */
+interface PcListingSeoTarget {
+ id: string
+ gameId: string
+ cpuId: string
+ gpuId: string | null
+}
+
+interface ListingSeoTarget {
+ id: string
+ gameId: string
+ deviceId: string
+ emulatorId: string
+}
export async function invalidateGame(gameId: string) {
const startTime = performance.now()
- invalidateCache(`seo:game:${gameId}`)
-
try {
revalidatePath(`/games/${gameId}`)
+ revalidateTag(`game-${gameId}`, 'max')
} catch (error) {
console.error(`Failed to revalidate game path: ${gameId}`, error)
}
@@ -24,40 +31,36 @@ export async function invalidateGame(gameId: string) {
}
export async function invalidateListing(listingId: string) {
- invalidateCache(`seo:listing:${listingId}`)
-
try {
revalidatePath(`/listings/${listingId}`)
+ revalidateTag(`listing-${listingId}`, 'max')
} catch (error) {
console.error(`Failed to revalidate listing path: ${listingId}`, error)
}
}
export async function invalidatePcListing(pcListingId: string) {
- invalidateCache(`seo:pclisting:${pcListingId}`)
-
try {
revalidatePath(`/pc-listings/${pcListingId}`)
+ revalidateTag(`pc-listing-${pcListingId}`, 'max')
} catch (error) {
console.error(`Failed to revalidate PC listing path: ${pcListingId}`, error)
}
}
export async function invalidateUser(userId: string) {
- invalidateCache(`seo:user:${userId}`)
-
try {
revalidatePath(`/users/${userId}`)
+ revalidateTag(`user-${userId}`, 'max')
} catch (error) {
console.error(`Failed to revalidate user path: ${userId}`, error)
}
}
export async function invalidateSitemap() {
- invalidateCache(/^seo:sitemap:/)
-
try {
revalidatePath('/sitemap.xml')
+ revalidateTag('sitemap', 'max')
} catch (error) {
console.error('Failed to revalidate sitemap', error)
}
@@ -77,23 +80,96 @@ export async function invalidateGameRelatedContent(gameId: string) {
const startTime = performance.now()
await invalidateGame(gameId)
-
- const listingsInvalidated = invalidateCache(
- new RegExp(`seo:(listing|pclisting):.*game:${gameId}`),
- )
-
await invalidateListPages()
const duration = performance.now() - startTime
- console.log(
- `[SEO] Batch invalidation for game ${gameId}: ${listingsInvalidated} listings cleared in ${duration.toFixed(2)}ms`,
+ console.log(`[SEO] Batch invalidation for game ${gameId} completed in ${duration.toFixed(2)}ms`)
+}
+
+export async function invalidatePcListingSeo(listing: PcListingSeoTarget) {
+ await invalidatePcListingSeoTargets([listing.id], [listing])
+}
+
+export async function invalidateListingSeo(listing: ListingSeoTarget) {
+ await invalidateListingSeoTargets([listing.id], [listing])
+}
+
+export async function invalidatePcListingSeoForUpdate(
+ previous: PcListingSeoTarget,
+ next: PcListingSeoTarget,
+) {
+ await invalidatePcListingSeoTargets([previous.id], [previous, next])
+}
+
+export async function invalidatePcListingsSeo(listings: PcListingSeoTarget[]) {
+ await invalidatePcListingSeoTargets(
+ listings.map((listing) => listing.id),
+ listings,
+ )
+}
+
+export async function invalidateListingsSeo(listings: ListingSeoTarget[]) {
+ await invalidateListingSeoTargets(
+ listings.map((listing) => listing.id),
+ listings,
)
}
export async function revalidateByTag(tag: string) {
try {
- revalidateTag(tag)
+ revalidateTag(tag, 'max')
} catch (error) {
console.error(`Failed to revalidate tag: ${tag}`, error)
}
}
+
+async function invalidateListingSeoTargets(listingIds: string[], tagTargets: ListingSeoTarget[]) {
+ if (listingIds.length === 0 && tagTargets.length === 0) return
+
+ const uniqueListingIds = [...new Set(listingIds)]
+ const tags = collectListingSeoTags(tagTargets)
+
+ await Promise.all(uniqueListingIds.map((listingId) => invalidateListing(listingId)))
+ await invalidateListPages()
+ await invalidateSitemap()
+ await Promise.all([...tags].map((tag) => revalidateByTag(tag)))
+}
+
+async function invalidatePcListingSeoTargets(
+ listingIds: string[],
+ tagTargets: PcListingSeoTarget[],
+) {
+ if (listingIds.length === 0 && tagTargets.length === 0) return
+
+ const uniqueListingIds = [...new Set(listingIds)]
+ const tags = collectPcListingSeoTags(tagTargets)
+
+ await Promise.all(uniqueListingIds.map((listingId) => invalidatePcListing(listingId)))
+ await invalidateListPages()
+ await invalidateSitemap()
+ await Promise.all([...tags].map((tag) => revalidateByTag(tag)))
+}
+
+function collectListingSeoTags(listings: ListingSeoTarget[]): Set {
+ const tags = new Set(['listings'])
+
+ for (const listing of listings) {
+ tags.add(`game-${listing.gameId}`)
+ tags.add(`device-${listing.deviceId}`)
+ tags.add(`emulator-${listing.emulatorId}`)
+ }
+
+ return tags
+}
+
+function collectPcListingSeoTags(listings: PcListingSeoTarget[]): Set {
+ const tags = new Set(['pc-listings'])
+
+ for (const listing of listings) {
+ tags.add(`game-${listing.gameId}`)
+ tags.add(`cpu-${listing.cpuId}`)
+ if (listing.gpuId) tags.add(`gpu-${listing.gpuId}`)
+ }
+
+ return tags
+}
diff --git a/src/server/cache/warming.ts b/src/server/cache/warming.ts
deleted file mode 100644
index 548f5bfc9..000000000
--- a/src/server/cache/warming.ts
+++ /dev/null
@@ -1,208 +0,0 @@
-import { warmCache } from '@/lib/cache/seo-cache'
-import { prisma } from '@/server/db'
-import {
- getGameForSEO,
- getListingForSEO,
- getPcListingForSEO,
- getApprovedGamesForSitemap,
- getApprovedListingsForSitemap,
- getApprovedPcListingsForSitemap,
-} from '@/server/db/seo-queries'
-import { ListingsRepository } from '@/server/repositories/listings.repository'
-import { ms } from '@/utils/time'
-import { ApprovalStatus } from '@orm/client'
-
-/**
- * Cache warming strategies for popular content
- * Runs periodically to pre-populate cache with frequently accessed data
- */
-
-interface WarmingResult {
- warmedItems: number
- duration: number
- errors: string[]
-}
-
-export async function warmPopularGames(limit = 50): Promise {
- const startTime = Date.now()
- const errors: string[] = []
- let warmedItems = 0
-
- try {
- // Get most popular games (those with most listings)
- const popularGames = await prisma.game.findMany({
- where: { status: ApprovalStatus.APPROVED },
- select: {
- id: true,
- _count: { select: { listings: true, pcListings: true } },
- },
- orderBy: [{ listings: { _count: 'desc' } }],
- take: limit,
- })
-
- // Warm cache for popular games
- const gameWarmingTasks = popularGames.map((game) => ({
- key: `seo:game:${game.id}`,
- fetchFn: () => getGameForSEO(game.id),
- }))
-
- await warmCache(gameWarmingTasks, {
- ttl: ms.hours(1),
- staleWhileRevalidate: ms.days(1),
- })
-
- warmedItems += gameWarmingTasks.length
- } catch (error) {
- errors.push(`Failed to warm popular games: ${error}`)
- }
-
- return {
- warmedItems,
- duration: Date.now() - startTime,
- errors,
- }
-}
-
-export async function warmRecentListings(limit = 100): Promise {
- const startTime = Date.now()
- const errors: string[] = []
- let warmedItems = 0
-
- try {
- const repository = new ListingsRepository(prisma)
-
- // Get recent approved listings using repository
- const recentListingsResult = await repository.listRecent(limit)
- const recentListings = recentListingsResult.listings.map((listing) => ({ id: listing.id }))
-
- // Get recent approved PC listings
- const recentPcListings = await prisma.pcListing.findMany({
- where: { status: ApprovalStatus.APPROVED },
- select: { id: true },
- orderBy: { createdAt: 'desc' },
- take: limit,
- })
-
- // Warm cache for listings separately
- const listingTasks = recentListings.map((listing) => ({
- key: `seo:listing:${listing.id}`,
- fetchFn: () => getListingForSEO(listing.id),
- }))
-
- const pcListingTasks = recentPcListings.map((listing) => ({
- key: `seo:pclisting:${listing.id}`,
- fetchFn: () => getPcListingForSEO(listing.id),
- }))
-
- await warmCache(listingTasks, {
- ttl: ms.minutes(30),
- staleWhileRevalidate: ms.hours(12),
- })
-
- await warmCache(pcListingTasks, {
- ttl: ms.minutes(30),
- staleWhileRevalidate: ms.hours(12),
- })
-
- warmedItems += listingTasks.length + pcListingTasks.length
- } catch (error) {
- errors.push(`Failed to warm recent listings: ${error}`)
- }
-
- return {
- warmedItems,
- duration: Date.now() - startTime,
- errors,
- }
-}
-
-export async function warmSitemapData(): Promise {
- const startTime = Date.now()
- const errors: string[] = []
- let warmedItems = 0
-
- try {
- // Warm sitemap data
- const sitemapTasks = [
- {
- key: 'seo:sitemap:games:1000',
- fetchFn: () => getApprovedGamesForSitemap(1000),
- },
- {
- key: 'seo:sitemap:listings:500',
- fetchFn: () => getApprovedListingsForSitemap(500),
- },
- {
- key: 'seo:sitemap:pclistings:500',
- fetchFn: () => getApprovedPcListingsForSitemap(500),
- },
- ]
-
- await warmCache(sitemapTasks, {
- ttl: ms.hours(6),
- staleWhileRevalidate: ms.days(2),
- })
-
- warmedItems += sitemapTasks.length
- } catch (error) {
- errors.push(`Failed to warm sitemap data: ${error}`)
- }
-
- return {
- warmedItems,
- duration: Date.now() - startTime,
- errors,
- }
-}
-
-export async function warmAllCaches(): Promise {
- console.log('[Cache Warming] Starting comprehensive cache warming...')
-
- const results = await Promise.all([
- warmPopularGames(50),
- warmRecentListings(100),
- warmSitemapData(),
- ])
-
- const totalWarmed = results.reduce((sum, r) => sum + r.warmedItems, 0)
- const totalDuration = Math.max(...results.map((r) => r.duration))
- const allErrors = results.flatMap((r) => r.errors)
-
- console.info(`[Cache Warming] Completed: ${totalWarmed} items warmed in ${totalDuration}ms`)
-
- if (allErrors.length > 0) {
- console.error('[Cache Warming] Errors encountered:', allErrors)
- }
-
- return {
- warmedItems: totalWarmed,
- duration: totalDuration,
- errors: allErrors,
- }
-}
-
-/**
- * Schedule cache warming
- * This should be called from a cron job or similar scheduler
- */
-export function scheduleCacheWarming() {
- // Initial warming on startup
- setTimeout(() => {
- warmAllCaches().catch(console.error)
- }, ms.seconds(5))
-
- // Warm popular content every hour
- setInterval(() => {
- warmPopularGames(30).catch(console.error)
- }, ms.hours(1))
-
- // Warm recent listings every 30 minutes
- setInterval(() => {
- warmRecentListings(50).catch(console.error)
- }, ms.minutes(30))
-
- // Warm sitemap data every 6 hours
- setInterval(() => {
- warmSitemapData().catch(console.error)
- }, ms.hours(6))
-}
diff --git a/src/server/db/seo-queries.test.ts b/src/server/db/seo-queries.test.ts
new file mode 100644
index 000000000..4b7de5a1d
--- /dev/null
+++ b/src/server/db/seo-queries.test.ts
@@ -0,0 +1,167 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+const cacheMocks = vi.hoisted(() => ({
+ cacheLife: vi.fn(),
+ cacheTag: vi.fn(),
+}))
+
+const prismaMocks = vi.hoisted(() => ({
+ game: {
+ findUnique: vi.fn(),
+ findMany: vi.fn(),
+ },
+ listing: {
+ findUnique: vi.fn(),
+ findMany: vi.fn(),
+ },
+ pcListing: {
+ findUnique: vi.fn(),
+ findMany: vi.fn(),
+ },
+ user: {
+ findUnique: vi.fn(),
+ },
+}))
+
+vi.mock('next/cache', () => cacheMocks)
+vi.mock('@/server/db', () => ({ prisma: prismaMocks }))
+
+const {
+ getApprovedGamesForSitemap,
+ getApprovedListingsForSitemap,
+ getApprovedPcListingsForSitemap,
+ getGameForSEO,
+ getListingForSEO,
+ getPcListingForSEO,
+ getUserForSEO,
+} = await import('./seo-queries')
+
+describe('SEO query cache metadata', () => {
+ beforeEach(() => {
+ vi.clearAllMocks()
+ })
+
+ it('uses a short cache profile for missing SEO records', async () => {
+ prismaMocks.game.findUnique.mockResolvedValueOnce(null)
+
+ await getGameForSEO('game-1')
+
+ expect(cacheMocks.cacheTag).toHaveBeenCalledWith('games', 'game-game-1')
+ expect(cacheMocks.cacheLife).toHaveBeenCalledWith('seo-miss')
+ })
+
+ it('does not convert SEO query failures into cacheable misses', async () => {
+ const error = new Error('database unavailable')
+ prismaMocks.game.findUnique.mockRejectedValueOnce(error)
+
+ await expect(getGameForSEO('game-1')).rejects.toThrow(error)
+
+ expect(cacheMocks.cacheLife).not.toHaveBeenCalled()
+ })
+
+ it('tags handheld report metadata by listing, game, device, and emulator', async () => {
+ const listing = {
+ id: 'listing-1',
+ gameId: 'game-1',
+ deviceId: 'device-1',
+ emulatorId: 'emulator-1',
+ notes: null,
+ createdAt: new Date('2026-01-01T00:00:00.000Z'),
+ game: { title: 'Game', imageUrl: null },
+ device: { modelName: 'Pocket', brand: { name: 'Brand' } },
+ emulator: { name: 'Emulator' },
+ performance: { label: 'Perfect', rank: 5 },
+ author: { name: 'Author' },
+ }
+ prismaMocks.listing.findUnique.mockResolvedValueOnce(listing)
+
+ await getListingForSEO('listing-1')
+
+ expect(cacheMocks.cacheTag).toHaveBeenCalledWith('listings', 'listing-listing-1')
+ expect(cacheMocks.cacheTag).toHaveBeenCalledWith(
+ 'game-game-1',
+ 'device-device-1',
+ 'emulator-emulator-1',
+ )
+ expect(cacheMocks.cacheLife).toHaveBeenCalledWith('seo-report')
+ })
+
+ it('tags PC report metadata by listing, game, CPU, and GPU', async () => {
+ const listing = {
+ id: 'pc-listing-1',
+ gameId: 'game-1',
+ cpuId: 'cpu-1',
+ gpuId: 'gpu-1',
+ notes: null,
+ createdAt: new Date('2026-01-01T00:00:00.000Z'),
+ game: { title: 'Game', imageUrl: null },
+ cpu: { modelName: 'CPU', brand: { name: 'Brand' } },
+ gpu: { modelName: 'GPU', brand: { name: 'Brand' } },
+ performance: { label: 'Perfect', rank: 5 },
+ author: { name: 'Author' },
+ }
+ prismaMocks.pcListing.findUnique.mockResolvedValueOnce(listing)
+
+ await getPcListingForSEO('pc-listing-1')
+
+ expect(cacheMocks.cacheTag).toHaveBeenCalledWith('pc-listings', 'pc-listing-pc-listing-1')
+ expect(cacheMocks.cacheTag).toHaveBeenCalledWith('game-game-1', 'cpu-cpu-1', 'gpu-gpu-1')
+ expect(cacheMocks.cacheLife).toHaveBeenCalledWith('seo-report')
+ })
+
+ it('uses the sitemap cache profile and tags sitemap data', async () => {
+ prismaMocks.game.findMany.mockResolvedValueOnce([])
+
+ await getApprovedGamesForSitemap(1000)
+
+ expect(cacheMocks.cacheLife).toHaveBeenCalledWith('seo-sitemap')
+ expect(cacheMocks.cacheTag).toHaveBeenCalledWith('sitemap', 'games')
+ })
+
+ it('tags user metadata by user id', async () => {
+ const user = {
+ id: 'user-1',
+ name: 'Author',
+ profileImage: null,
+ }
+ prismaMocks.user.findUnique.mockResolvedValueOnce(user)
+
+ await expect(getUserForSEO('user-1')).resolves.toEqual(user)
+
+ expect(cacheMocks.cacheTag).toHaveBeenCalledWith('user-user-1')
+ expect(cacheMocks.cacheLife).toHaveBeenCalledWith('seo-record')
+ })
+
+ it('tags handheld report sitemap data', async () => {
+ const listings = [{ id: 'listing-1', createdAt: new Date('2026-01-01T00:00:00.000Z') }]
+ prismaMocks.listing.findMany.mockResolvedValueOnce(listings)
+
+ await expect(getApprovedListingsForSitemap(10)).resolves.toEqual(listings)
+
+ expect(prismaMocks.listing.findMany).toHaveBeenCalledWith(expect.objectContaining({ take: 10 }))
+ expect(cacheMocks.cacheLife).toHaveBeenCalledWith('seo-sitemap')
+ expect(cacheMocks.cacheTag).toHaveBeenCalledWith('sitemap', 'listings')
+ })
+
+ it('tags PC report sitemap data', async () => {
+ const listings = [{ id: 'pc-listing-1', createdAt: new Date('2026-01-01T00:00:00.000Z') }]
+ prismaMocks.pcListing.findMany.mockResolvedValueOnce(listings)
+
+ await expect(getApprovedPcListingsForSitemap(10)).resolves.toEqual(listings)
+
+ expect(prismaMocks.pcListing.findMany).toHaveBeenCalledWith(
+ expect.objectContaining({ take: 10 }),
+ )
+ expect(cacheMocks.cacheLife).toHaveBeenCalledWith('seo-sitemap')
+ expect(cacheMocks.cacheTag).toHaveBeenCalledWith('sitemap', 'pc-listings')
+ })
+
+ it('does not cache an empty sitemap when the sitemap query fails', async () => {
+ const error = new Error('database unavailable')
+ prismaMocks.game.findMany.mockRejectedValueOnce(error)
+
+ await expect(getApprovedGamesForSitemap(1000)).rejects.toThrow(error)
+
+ expect(cacheMocks.cacheLife).not.toHaveBeenCalled()
+ })
+})
diff --git a/src/server/db/seo-queries.ts b/src/server/db/seo-queries.ts
index a2d6c5fcc..9631237a6 100644
--- a/src/server/db/seo-queries.ts
+++ b/src/server/db/seo-queries.ts
@@ -1,246 +1,165 @@
-import { getFromCache } from '@/lib/cache/seo-cache'
-import { withMetrics } from '@/lib/monitoring/seo-metrics'
+import { cacheLife, cacheTag } from 'next/cache'
import { prisma } from '@/server/db'
-import { ms } from '@/utils/time'
import { ApprovalStatus } from '@orm/client'
-/**
- * Database queries optimized for SEO metadata generation.
- * These queries are designed to be fast and fetch only the data needed for metadata.
- * All queries use caching to minimize database load.
- */
-
-// Cache TTLs based on content type
-const CACHE_TTL = {
- GAME: ms.hours(1),
- LISTING: ms.minutes(30),
- USER: ms.hours(1),
- SITEMAP: ms.hours(6),
-}
-
-const CACHE_STALE = {
- GAME: ms.days(1),
- LISTING: ms.hours(12),
- USER: ms.days(1),
- SITEMAP: ms.days(2),
-}
+const SEO_CACHE_PROFILE = {
+ RECORD: 'seo-record',
+ REPORT: 'seo-report',
+ SITEMAP: 'seo-sitemap',
+ MISS: 'seo-miss',
+} as const
export async function getGameForSEO(id: string) {
- return withMetrics(
- 'getGameForSEO',
- () =>
- getFromCache(
- `seo:game:${id}`,
- async () => {
- try {
- return await prisma.game.findUnique({
- where: { id },
- select: {
- id: true,
- title: true,
- imageUrl: true,
- system: { select: { name: true } },
- },
- })
- } catch {
- return null
- }
- },
- {
- ttl: CACHE_TTL.GAME,
- staleWhileRevalidate: CACHE_STALE.GAME,
- },
- ),
- { cacheKey: `seo:game:${id}` },
- )
+ 'use cache'
+
+ const game = await prisma.game.findUnique({
+ where: { id },
+ select: {
+ id: true,
+ title: true,
+ imageUrl: true,
+ system: { select: { name: true } },
+ },
+ })
+
+ cacheTag('games', `game-${id}`)
+ cacheLife(game ? SEO_CACHE_PROFILE.RECORD : SEO_CACHE_PROFILE.MISS)
+ return game
}
export async function getListingForSEO(id: string) {
- return withMetrics(
- 'getListingForSEO',
- () =>
- getFromCache(
- `seo:listing:${id}`,
- async () => {
- try {
- return await prisma.listing.findUnique({
- where: { id },
- select: {
- id: true,
- notes: true,
- createdAt: true,
- game: { select: { title: true, imageUrl: true } },
- device: {
- select: {
- modelName: true,
- brand: { select: { name: true } },
- },
- },
- emulator: { select: { name: true } },
- performance: { select: { label: true, rank: true } },
- author: { select: { name: true } },
- },
- })
- } catch {
- return null
- }
- },
- {
- ttl: CACHE_TTL.LISTING,
- staleWhileRevalidate: CACHE_STALE.LISTING,
+ 'use cache'
+
+ const listing = await prisma.listing.findUnique({
+ where: { id },
+ select: {
+ id: true,
+ gameId: true,
+ deviceId: true,
+ emulatorId: true,
+ notes: true,
+ createdAt: true,
+ game: { select: { title: true, imageUrl: true } },
+ device: {
+ select: {
+ modelName: true,
+ brand: { select: { name: true } },
},
- ),
- { cacheKey: `seo:listing:${id}` },
- )
+ },
+ emulator: { select: { name: true } },
+ performance: { select: { label: true, rank: true } },
+ author: { select: { name: true } },
+ },
+ })
+
+ cacheTag('listings', `listing-${id}`)
+ if (listing) {
+ cacheTag(
+ `game-${listing.gameId}`,
+ `device-${listing.deviceId}`,
+ `emulator-${listing.emulatorId}`,
+ )
+ }
+
+ cacheLife(listing ? SEO_CACHE_PROFILE.REPORT : SEO_CACHE_PROFILE.MISS)
+ return listing
}
export async function getPcListingForSEO(id: string) {
- return withMetrics(
- 'getPcListingForSEO',
- () =>
- getFromCache(
- `seo:pclisting:${id}`,
- async () => {
- try {
- return await prisma.pcListing.findUnique({
- where: { id },
- select: {
- id: true,
- notes: true,
- createdAt: true,
- game: { select: { title: true, imageUrl: true } },
- cpu: {
- select: {
- modelName: true,
- brand: { select: { name: true } },
- },
- },
- gpu: {
- select: {
- modelName: true,
- brand: { select: { name: true } },
- },
- },
- performance: { select: { label: true, rank: true } },
- author: { select: { name: true } },
- },
- })
- } catch {
- return null
- }
+ 'use cache'
+
+ const listing = await prisma.pcListing.findUnique({
+ where: { id },
+ select: {
+ id: true,
+ gameId: true,
+ cpuId: true,
+ gpuId: true,
+ notes: true,
+ createdAt: true,
+ game: { select: { title: true, imageUrl: true } },
+ cpu: {
+ select: {
+ modelName: true,
+ brand: { select: { name: true } },
},
- {
- ttl: CACHE_TTL.LISTING,
- staleWhileRevalidate: CACHE_STALE.LISTING,
+ },
+ gpu: {
+ select: {
+ modelName: true,
+ brand: { select: { name: true } },
},
- ),
- { cacheKey: `seo:pclisting:${id}` },
- )
+ },
+ performance: { select: { label: true, rank: true } },
+ author: { select: { name: true } },
+ },
+ })
+
+ cacheTag('pc-listings', `pc-listing-${id}`)
+ if (listing) {
+ const tags = [`game-${listing.gameId}`, `cpu-${listing.cpuId}`]
+ if (listing.gpuId) tags.push(`gpu-${listing.gpuId}`)
+ cacheTag(...tags)
+ }
+
+ cacheLife(listing ? SEO_CACHE_PROFILE.REPORT : SEO_CACHE_PROFILE.MISS)
+ return listing
}
export async function getUserForSEO(id: string) {
- return withMetrics(
- 'getUserForSEO',
- () =>
- getFromCache(
- `seo:user:${id}`,
- async () => {
- try {
- return await prisma.user.findUnique({
- where: { id },
- select: { id: true, name: true, profileImage: true },
- })
- } catch {
- return null
- }
- },
- {
- ttl: CACHE_TTL.USER,
- staleWhileRevalidate: CACHE_STALE.USER,
- },
- ),
- { cacheKey: `seo:user:${id}` },
- )
+ 'use cache'
+
+ const user = await prisma.user.findUnique({
+ where: { id },
+ select: { id: true, name: true, profileImage: true },
+ })
+
+ cacheTag(`user-${id}`)
+ cacheLife(user ? SEO_CACHE_PROFILE.RECORD : SEO_CACHE_PROFILE.MISS)
+ return user
}
-// For sitemap generation - cached longer since it's expensive
export async function getApprovedGamesForSitemap(limit = 1000) {
- return withMetrics(
- 'getApprovedGamesForSitemap',
- () =>
- getFromCache(
- `seo:sitemap:games:${limit}`,
- async () => {
- try {
- return await prisma.game.findMany({
- where: { status: ApprovalStatus.APPROVED },
- select: { id: true, createdAt: true },
- orderBy: { createdAt: 'desc' },
- take: limit,
- })
- } catch {
- return []
- }
- },
- {
- ttl: CACHE_TTL.SITEMAP,
- staleWhileRevalidate: CACHE_STALE.SITEMAP,
- },
- ),
- { cacheKey: `seo:sitemap:games:${limit}` },
- )
+ 'use cache'
+
+ const games = await prisma.game.findMany({
+ where: { status: ApprovalStatus.APPROVED },
+ select: { id: true, createdAt: true },
+ orderBy: { createdAt: 'desc' },
+ take: limit,
+ })
+
+ cacheLife(SEO_CACHE_PROFILE.SITEMAP)
+ cacheTag('sitemap', 'games')
+ return games
}
export async function getApprovedListingsForSitemap(limit = 500) {
- return withMetrics(
- 'getApprovedListingsForSitemap',
- () =>
- getFromCache(
- `seo:sitemap:listings:${limit}`,
- async () => {
- try {
- return await prisma.listing.findMany({
- where: { status: ApprovalStatus.APPROVED },
- select: { id: true, createdAt: true },
- orderBy: { createdAt: 'desc' },
- take: limit,
- })
- } catch {
- return []
- }
- },
- {
- ttl: CACHE_TTL.SITEMAP,
- staleWhileRevalidate: CACHE_STALE.SITEMAP,
- },
- ),
- { cacheKey: `seo:sitemap:listings:${limit}` },
- )
+ 'use cache'
+
+ const listings = await prisma.listing.findMany({
+ where: { status: ApprovalStatus.APPROVED },
+ select: { id: true, createdAt: true },
+ orderBy: { createdAt: 'desc' },
+ take: limit,
+ })
+
+ cacheLife(SEO_CACHE_PROFILE.SITEMAP)
+ cacheTag('sitemap', 'listings')
+ return listings
}
export async function getApprovedPcListingsForSitemap(limit = 500) {
- return withMetrics(
- 'getApprovedPcListingsForSitemap',
- () =>
- getFromCache(
- `seo:sitemap:pclistings:${limit}`,
- async () => {
- try {
- return await prisma.pcListing.findMany({
- where: { status: ApprovalStatus.APPROVED },
- select: { id: true, createdAt: true },
- orderBy: { createdAt: 'desc' },
- take: limit,
- })
- } catch {
- return []
- }
- },
- {
- ttl: CACHE_TTL.SITEMAP,
- staleWhileRevalidate: CACHE_STALE.SITEMAP,
- },
- ),
- { cacheKey: `seo:sitemap:pclistings:${limit}` },
- )
+ 'use cache'
+
+ const listings = await prisma.pcListing.findMany({
+ where: { status: ApprovalStatus.APPROVED },
+ select: { id: true, createdAt: true },
+ orderBy: { createdAt: 'desc' },
+ take: limit,
+ })
+
+ cacheLife(SEO_CACHE_PROFILE.SITEMAP)
+ cacheTag('sitemap', 'pc-listings')
+ return listings
}
diff --git a/src/server/notifications/analyticsService.ts b/src/server/notifications/analyticsService.ts
index 032324a2b..40c168678 100644
--- a/src/server/notifications/analyticsService.ts
+++ b/src/server/notifications/analyticsService.ts
@@ -489,13 +489,6 @@ export class NotificationAnalyticsService {
notificationAnalyticsCache.clear()
}
- /**
- * Get cache statistics for monitoring
- */
- getCacheStats() {
- return notificationAnalyticsCache.getStats()
- }
-
private buildDateFilter(startDate?: Date, endDate?: Date): Record {
const filter: Record = {}
diff --git a/src/server/services/catalog.service.test.ts b/src/server/services/catalog.service.test.ts
new file mode 100644
index 000000000..f2404f9d0
--- /dev/null
+++ b/src/server/services/catalog.service.test.ts
@@ -0,0 +1,88 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { Role, type PrismaClient } from '@orm/client'
+
+const mockDeviceById = vi.hoisted(() => vi.fn())
+const mockFindByModelAndBrandName = vi.hoisted(() => vi.fn())
+const mockGetDeviceCompatibilityData = vi.hoisted(() => vi.fn())
+const mockGetSocCompatibilityData = vi.hoisted(() => vi.fn())
+
+const cacheMocks = vi.hoisted(() => ({
+ get: vi.fn(),
+ set: vi.fn(),
+}))
+
+vi.mock('@/server/repositories/devices.repository', () => ({
+ DevicesRepository: vi.fn().mockImplementation(function MockDevicesRepository() {
+ return {
+ byId: mockDeviceById,
+ findByModelAndBrandName: mockFindByModelAndBrandName,
+ }
+ }),
+}))
+
+vi.mock('@/server/repositories/listings.repository', () => ({
+ ListingsRepository: vi.fn().mockImplementation(function MockListingsRepository() {
+ return {
+ getDeviceCompatibilityData: mockGetDeviceCompatibilityData,
+ getSocCompatibilityData: mockGetSocCompatibilityData,
+ }
+ }),
+}))
+
+vi.mock('@/server/utils/cache/instances', () => ({
+ catalogCompatibilityCache: cacheMocks,
+}))
+
+const { getDeviceCompatibility } = await import('./catalog.service')
+
+const device = {
+ id: 'device-1',
+ modelName: 'Pocket',
+ socId: 'soc-1',
+ brand: { name: 'Brand' },
+ soc: { id: 'soc-1', name: 'SoC', manufacturer: 'Maker' },
+}
+
+const cachedResponse = {
+ device: {
+ id: 'device-1',
+ modelName: 'Pocket',
+ brandName: 'Brand',
+ socId: 'soc-1',
+ socName: 'SoC',
+ socManufacturer: 'Maker',
+ },
+ systems: [],
+ generatedAt: new Date('2026-01-01T00:00:00.000Z'),
+ cacheExpiresIn: 600,
+}
+
+describe('catalog compatibility cache', () => {
+ beforeEach(() => {
+ vi.clearAllMocks()
+ mockDeviceById.mockResolvedValue(device)
+ cacheMocks.get.mockReturnValue(cachedResponse)
+ })
+
+ it('uses a public visibility cache key for regular users', async () => {
+ await getDeviceCompatibility(
+ { deviceId: 'device-1', systemIds: ['system-b', 'system-a'] },
+ { prisma: {} as PrismaClient, userRole: Role.USER, userId: 'user-1' },
+ )
+
+ expect(cacheMocks.get).toHaveBeenCalledWith(
+ 'device:device-1:systems:system-a,system-b:breakdown:true:min:1:soc:soc-1:visibility:public',
+ )
+ })
+
+ it('uses a moderator visibility cache key for moderators', async () => {
+ await getDeviceCompatibility(
+ { deviceId: 'device-1', includeEmulatorBreakdown: false, minListingCount: 3 },
+ { prisma: {} as PrismaClient, userRole: Role.MODERATOR, userId: 'mod-1' },
+ )
+
+ expect(cacheMocks.get).toHaveBeenCalledWith(
+ 'device:device-1:systems:all:breakdown:false:min:3:soc:soc-1:visibility:moderator',
+ )
+ })
+})
diff --git a/src/server/services/catalog.service.ts b/src/server/services/catalog.service.ts
index 2ac4b4c26..2f5cdcea8 100644
--- a/src/server/services/catalog.service.ts
+++ b/src/server/services/catalog.service.ts
@@ -8,12 +8,13 @@ import {
MINIMUM_DEVICE_LISTINGS,
type ScoringListingWithMetadata,
} from '@/server/utils/compatibility-scoring'
+import { hasRolePermission } from '@/utils/permissions'
+import { Role, type PrismaClient } from '@orm/client'
import type {
DeviceCompatibilityResponse,
EmulatorCompatibility,
SystemCompatibility,
} from '@/schemas/mobile'
-import type { Role, PrismaClient } from '@orm/client'
export interface GetDeviceCompatibilityInput {
deviceId?: string
@@ -53,7 +54,6 @@ export async function getDeviceCompatibility(
const devicesRepo = new DevicesRepository(ctx.prisma)
const listingsRepo = new ListingsRepository(ctx.prisma)
- // Resolve device by ID or by name + brand
let device
if (input.deviceId) {
device = await devicesRepo.byId(input.deviceId)
@@ -63,14 +63,14 @@ export async function getDeviceCompatibility(
if (!device) throw ResourceError.device.notFound()
- // Create cache key from device ID and input parameters (include SoC in key)
- const cacheKey = `device:${device.id}:systems:${input.systemIds?.sort().join(',') ?? 'all'}:breakdown:${input.includeEmulatorBreakdown ?? true}:min:${input.minListingCount ?? 1}:soc:${device.socId ?? 'none'}`
+ const systemKey = input.systemIds ? [...input.systemIds].sort().join(',') : 'all'
+ const visibilityBucket =
+ ctx.userRole && hasRolePermission(ctx.userRole, Role.MODERATOR) ? 'moderator' : 'public'
+ const cacheKey = `device:${device.id}:systems:${systemKey}:breakdown:${input.includeEmulatorBreakdown ?? true}:min:${input.minListingCount ?? 1}:soc:${device.socId ?? 'none'}:visibility:${visibilityBucket}`
- // Check cache first
const cached = catalogCompatibilityCache.get(cacheKey)
if (cached) return cached
- // Fetch device-specific listings
const deviceListings = await listingsRepo.getDeviceCompatibilityData(device.id, {
systemIds: input.systemIds,
userRole: ctx.userRole,
@@ -88,11 +88,10 @@ export async function getDeviceCompatibility(
},
systems: [],
generatedAt: new Date(),
- cacheExpiresIn: 600, // 10 minutes
+ cacheExpiresIn: 600,
}
}
- // Get all verified developers for emulators in these listings
const allListings = [...deviceListings]
const emulatorIds = [...new Set(allListings.map((l) => l.emulatorId))]
const verifiedDevs = await ctx.prisma.verifiedDeveloper.findMany({
@@ -100,7 +99,6 @@ export async function getDeviceCompatibility(
select: { userId: true, emulatorId: true },
})
- // Create a map of verified developers: userId_emulatorId -> true
const verifiedDevMap = new Set()
for (const vd of verifiedDevs) {
verifiedDevMap.add(`${vd.userId}_${vd.emulatorId}`)
@@ -113,13 +111,11 @@ export async function getDeviceCompatibility(
const deviceSystemAggregations = aggregateBySystem(listingsWithMetadata)
- // Track data source info per system
const dataSourceMap = new Map<
string,
{ dataSource: 'device' | 'soc'; deviceCount: number; socCount: number; deviceIds: Set }
>()
- // Initialize all device systems as 'device' source
for (const sysAgg of deviceSystemAggregations) {
dataSourceMap.set(sysAgg.system.id, {
dataSource: 'device',
@@ -129,12 +125,10 @@ export async function getDeviceCompatibility(
})
}
- // Identify systems needing SoC fallback
const systemsNeedingFallback = deviceSystemAggregations.filter(
(s) => s.listings.length < MINIMUM_DEVICE_LISTINGS,
)
- // If device has SoC AND some systems need fallback, fetch SoC data
if (device.socId && systemsNeedingFallback.length > 0) {
const socListings = await listingsRepo.getSocCompatibilityData(device.socId, device.id, {
systemIds: systemsNeedingFallback.map((s) => s.system.id),
@@ -142,7 +136,6 @@ export async function getDeviceCompatibility(
})
if (socListings.length > 0) {
- // Track unique devices contributing SoC data per system
const socDevicesBySystem = new Map>()
for (const listing of socListings) {
@@ -153,16 +146,13 @@ export async function getDeviceCompatibility(
socDevicesBySystem.get(systemId)!.add(listing.deviceId)
}
- // Enhance SoC listings with metadata
const socListingsWithMetadata: ScoringListingWithMetadata[] = socListings.map((listing) => ({
...listing,
isVerifiedDeveloper: verifiedDevMap.has(`${listing.authorId}_${listing.emulatorId}`),
}))
- // Combine device + SoC listings
listingsWithMetadata = [...listingsWithMetadata, ...socListingsWithMetadata]
- // Update data source info for systems that used SoC fallback
for (const sysAgg of systemsNeedingFallback) {
const systemId = sysAgg.system.id
const socDevices = socDevicesBySystem.get(systemId)
@@ -178,15 +168,12 @@ export async function getDeviceCompatibility(
}
}
- // Re-aggregate with combined listings
const systemAggregations = aggregateBySystem(listingsWithMetadata)
- // Filter by minimum listing count
const filteredSystems = systemAggregations.filter(
(s) => s.listings.length >= (input.minListingCount ?? 1),
)
- // Convert to response format
const systems: SystemCompatibility[] = filteredSystems.map((systemAgg) => {
const confidence = calculateConfidenceLevel(systemAgg.listings.length, systemAgg.totalVotes)
const sourceInfo = dataSourceMap.get(systemAgg.system.id)
@@ -255,7 +242,7 @@ export async function getDeviceCompatibility(
cacheExpiresIn: 600, // 10 minutes
}
- catalogCompatibilityCache.set(cacheKey, response) // Cache the response
+ catalogCompatibilityCache.set(cacheKey, response)
return response
}
diff --git a/src/server/tgdb.ts b/src/server/tgdb.ts
index 5f449e587..c7262eb11 100644
--- a/src/server/tgdb.ts
+++ b/src/server/tgdb.ts
@@ -77,15 +77,12 @@ export async function searchGames(
throw new TGDBError('Search query cannot be empty')
}
- // Get TGDB platform ID from system key
const tgdbPlatformId = systemKey
? (PLATFORM_MAPPINGS.tgdb[systemKey as PlatformKey] ?? null)
: null
- // Create cache key for this search
const cacheKey = createCacheKey('tgdb:searchGames', query.trim(), systemKey ?? 'none', page)
- // Check cache first
const cached = tgdbGamesCache.get(cacheKey)
if (cached) return cached
@@ -95,12 +92,10 @@ export async function searchGames(
include: 'boxart',
}
- // Add platform filter if platform ID is provided
if (tgdbPlatformId) params['filter[platform]'] = tgdbPlatformId.toString()
const response = await makeRequest('/v1.1/Games/ByGameName', params)
- // Score and sort the results if we have games
if (response.data.games.length > 0) {
const scoredResults = response.data.games.map((game, originalIndex) => ({
game,
@@ -108,7 +103,6 @@ export async function searchGames(
originalIndex,
}))
- // Sort by score (descending), then by original index (ascending) for ties
scoredResults.sort((a, b) =>
b.score !== a.score ? b.score - a.score : a.originalIndex - b.originalIndex,
)
@@ -116,13 +110,11 @@ export async function searchGames(
response.data.games = scoredResults.map((item) => item.game)
}
- // Cache the response
tgdbGamesCache.set(cacheKey, response)
return response
}
-// Helper function to get boxart URL from search response
export function getBoxartUrlFromGame(
gameId: number,
searchResponse: TGDBGamesByNameResponse,
@@ -130,7 +122,6 @@ export function getBoxartUrlFromGame(
const gameIdStr = gameId.toString()
const boxartData = searchResponse.include?.boxart?.data[gameIdStr]
- // Early returns to avoid deep nesting
if (!boxartData?.length) return undefined
if (!searchResponse.include?.boxart?.base_url) return undefined
@@ -146,11 +137,9 @@ export async function getGameImages(gameIds: number[]): Promise a - b) // Sort for consistent caching
+ const sortedIds = [...gameIds].sort((a, b) => a - b)
const cacheKey = createCacheKey('tgdb:getGameImages', sortedIds.join(','))
- // Check cache first
const cached = tgdbImagesCache.get(cacheKey)
if (cached) return cached
@@ -159,17 +148,14 @@ export async function getGameImages(gameIds: number[]): Promise {
- // Create cache key for platforms (this data rarely changes)
const cacheKey = createCacheKey('tgdb:getPlatforms')
- // Check cache first
const cached = tgdbPlatformsCache.get(cacheKey)
if (cached) {
return cached
@@ -177,8 +163,7 @@ export async function getPlatforms(): Promise {
const response = await makeRequest('/v1/Platforms')
- // Cache the response with longer TTL since platforms don't change often
- tgdbPlatformsCache.set(cacheKey, response, 60 * 60 * 1000) // 1 hour
+ tgdbPlatformsCache.set(cacheKey, response, { ttl: 60 * 60 * 1000 })
return response
}
@@ -186,10 +171,8 @@ export async function getPlatforms(): Promise {
export async function getGameImageUrls(
gameId: number,
): Promise<{ boxartUrl?: string; bannerUrl?: string }> {
- // Create cache key for this specific game's image URLs
const cacheKey = createCacheKey('tgdb:getGameImageUrls', gameId)
- // Check cache first
const cached = tgdbImageUrlsCache.get(cacheKey)
if (cached) return cached
@@ -199,7 +182,6 @@ export async function getGameImageUrls(
const gameIdStr = gameId.toString()
const gameImagesData = imagesResponse.data.images[gameIdStr] ?? []
- // Use functional approach to find images
const validImages = gameImagesData
.filter((image) => image.filename && imagesResponse.data.base_url)
.map((image) => ({
@@ -211,15 +193,12 @@ export async function getGameImageUrls(
const boxartUrl = validImages.find((img) => img.type === 'boxart')?.fullUrl
let bannerUrl = validImages.find((img) => img.type === 'banner')?.fullUrl
- // Try alternative image types if banner is not found
bannerUrl ??= validImages.find(
(img) => img.type === 'fanart' || img.type === 'clearlogo',
)?.fullUrl
- // fallback to boxart if no banner found
const result = { boxartUrl, bannerUrl: bannerUrl ? bannerUrl : boxartUrl }
- // Cache the result
tgdbImageUrlsCache.set(cacheKey, result)
return result
@@ -233,13 +212,10 @@ export async function searchGameImages(
query: string,
systemKey?: string | null,
): Promise> {
- // Create cache key for this search
const cacheKey = createCacheKey('tgdb:searchGameImages', query.trim(), systemKey ?? 'none')
- // Check cache first - need to handle Map serialization
const cached = tgdbGameImagesCache.get(cacheKey)
if (cached) {
- // Convert cached object back to Map
const resultMap = new Map()
Object.entries(cached).forEach(([gameId, images]) => {
resultMap.set(parseInt(gameId), images)
@@ -251,22 +227,18 @@ export async function searchGameImages(
const gameImageMap = new Map()
if (gamesResponse.data.games.length === 0) {
- // Cache empty result too
tgdbGameImagesCache.set(cacheKey, {})
return gameImageMap
}
try {
- // Get images for all found games
const gameIds = gamesResponse.data.games.map((game) => game.id)
const imagesResponse = await getGameImages(gameIds)
- // Process each game's images using functional approach
gamesResponse.data.games.forEach((game) => {
const boxartImages = createBoxartImages(game, gamesResponse)
const otherImages = createOtherImages(game, imagesResponse)
- // Combine and deduplicate images based on URL
const allImages = [...boxartImages, ...otherImages]
const uniqueImages = allImages.reduce((acc, image) => {
const existingImage = acc.find((existing) => existing.url === image.url)
@@ -276,7 +248,6 @@ export async function searchGameImages(
if (uniqueImages.length > 0) gameImageMap.set(game.id, uniqueImages)
})
- // Cache the result - convert Map to plain object for JSON serialization
const cacheObject: Record = {}
gameImageMap.forEach((images, gameId) => {
cacheObject[gameId.toString()] = images
@@ -284,13 +255,11 @@ export async function searchGameImages(
tgdbGameImagesCache.set(cacheKey, cacheObject)
} catch (error) {
console.error('Error fetching game images from TGDB:', error)
- // Continue without images rather than failing completely
}
return gameImageMap
}
-// Helper function to create boxart images from games response
function createBoxartImages(
game: TGDBGamesByNameResponse['data']['games'][0],
gamesResponse: TGDBGamesByNameResponse,
@@ -309,7 +278,7 @@ function createBoxartImages(
url,
resolution: boxart.resolution,
id: boxart.id,
- index, // Add index to ensure uniqueness
+ index,
}
})
.filter((boxart) => isValidImageUrl(boxart.url))
@@ -325,11 +294,6 @@ function createBoxartImages(
}))
}
-/**
- * Creates other image types (fanart, banner, etc.) from TGDB images response.
- * @param game - The game object from TGDB search response.
- * @param imagesResponse - The full images response from TGDB.
- */
function createOtherImages(
game: TGDBGamesByNameResponse['data']['games'][0],
imagesResponse: TGDBGamesImagesResponse,
diff --git a/src/server/utils/cache/MemoryCache.test.ts b/src/server/utils/cache/MemoryCache.test.ts
deleted file mode 100644
index 18d8c1ec1..000000000
--- a/src/server/utils/cache/MemoryCache.test.ts
+++ /dev/null
@@ -1,263 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest'
-import MemoryCache from './MemoryCache'
-
-describe('MemoryCache', () => {
- let cache: MemoryCache
- let consoleDebugSpy: ReturnType
-
- beforeEach(() => {
- // Mock console.debug to suppress cache cleanup messages
- consoleDebugSpy = vi.spyOn(console, 'debug').mockImplementation(() => {})
-
- cache = new MemoryCache({
- ttl: 50, // 50ms - much faster for tests
- maxSize: 3,
- cleanupInterval: 25, // 25ms - faster cleanup
- })
- })
-
- afterEach(() => {
- cache.destroy()
- consoleDebugSpy.mockRestore()
- })
-
- describe('basic operations', () => {
- it('should store and retrieve values', () => {
- cache.set('key1', 'value1')
- expect(cache.get('key1')).toBe('value1')
- })
-
- it('should return undefined for non-existent keys', () => {
- expect(cache.get('nonexistent')).toBeUndefined()
- })
-
- it('should delete values', () => {
- cache.set('key1', 'value1')
- expect(cache.delete('key1')).toBe(true)
- expect(cache.get('key1')).toBeUndefined()
- })
-
- it('should return false when deleting non-existent keys', () => {
- expect(cache.delete('nonexistent')).toBe(false)
- })
-
- it('should clear all values', () => {
- cache.set('key1', 'value1')
- cache.set('key2', 'value2')
- cache.clear()
- expect(cache.get('key1')).toBeUndefined()
- expect(cache.get('key2')).toBeUndefined()
- expect(cache.getSize()).toBe(0)
- })
- })
-
- describe('TTL (Time To Live)', () => {
- it('should expire entries after TTL', async () => {
- cache.set('key1', 'value1')
- expect(cache.get('key1')).toBe('value1')
-
- // Wait for expiration (now much faster - 60ms)
- await new Promise((resolve) => setTimeout(resolve, 60))
-
- expect(cache.get('key1')).toBeUndefined()
- })
-
- it('should support custom TTL per entry', async () => {
- cache.set('short', 'value1', 10) // 10ms TTL
- cache.set('long', 'value2', 100) // 100ms TTL
-
- await new Promise((resolve) => setTimeout(resolve, 15))
-
- expect(cache.get('short')).toBeUndefined()
- expect(cache.get('long')).toBe('value2')
- })
-
- it('should update lastAccessed on get', () => {
- cache.set('key1', 'value1')
-
- // Access the key multiple times
- cache.get('key1')
- cache.get('key1')
-
- expect(cache.get('key1')).toBe('value1')
- })
- })
-
- describe('LRU eviction', () => {
- it('should evict least recently used items when at capacity', () => {
- // Fill cache to capacity (maxSize: 3)
- cache.set('key1', 'value1')
- cache.set('key2', 'value2')
- cache.set('key3', 'value3')
-
- // Access key1 to make it recently used
- cache.get('key1')
-
- // Add fourth item, should evict key2 (least recently used)
- cache.set('key4', 'value4')
-
- expect(cache.get('key1')).toBe('value1') // Still present (recently accessed)
- expect(cache.get('key2')).toBeUndefined() // Evicted
- expect(cache.get('key3')).toBe('value3') // Still present
- expect(cache.get('key4')).toBe('value4') // Newly added
- })
-
- it('should not evict when updating existing keys', () => {
- cache.set('key1', 'value1')
- cache.set('key2', 'value2')
- cache.set('key3', 'value3')
-
- // Update existing key (should not trigger eviction)
- cache.set('key1', 'updated_value1')
-
- expect(cache.getSize()).toBe(3)
- expect(cache.get('key1')).toBe('updated_value1')
- expect(cache.get('key2')).toBe('value2')
- expect(cache.get('key3')).toBe('value3')
- })
- })
-
- describe('pattern invalidation', () => {
- it('should invalidate entries matching pattern', () => {
- // Clear cache to ensure we start fresh for this test
- cache.clear()
-
- cache.set('user:1:profile', 'profile1')
- cache.set('user:1:settings', 'settings1')
- cache.set('user:2:profile', 'profile2')
- // Don't add the 4th item to avoid LRU eviction (maxSize: 3)
-
- const deletedCount = cache.invalidatePattern('user:1:*')
-
- expect(deletedCount).toBe(2)
- expect(cache.get('user:1:profile')).toBeUndefined()
- expect(cache.get('user:1:settings')).toBeUndefined()
- expect(cache.get('user:2:profile')).toBe('profile2')
-
- // Now add the product item separately to test it wasn't affected
- cache.set('product:1:info', 'product1')
- expect(cache.get('product:1:info')).toBe('product1')
- })
-
- it('should handle complex patterns', () => {
- cache.set('api:v1:users', 'users')
- cache.set('api:v1:products', 'products')
- cache.set('api:v2:users', 'users_v2')
-
- const deletedCount = cache.invalidatePattern('api:v1:*')
-
- expect(deletedCount).toBe(2)
- expect(cache.get('api:v2:users')).toBe('users_v2')
- })
- })
-
- describe('statistics', () => {
- it('should track cache statistics', () => {
- const initialStats = cache.getStats()
- expect(initialStats.hits).toBe(0)
- expect(initialStats.misses).toBe(0)
- expect(initialStats.size).toBe(0)
-
- cache.set('key1', 'value1')
- cache.get('key1') // Hit
- cache.get('nonexistent') // Miss
-
- const stats = cache.getStats()
- expect(stats.hits).toBe(1)
- expect(stats.misses).toBe(1)
- expect(stats.size).toBe(1)
- expect(stats.maxSize).toBe(3)
- })
-
- it('should track evictions', () => {
- // Fill cache beyond capacity to trigger evictions
- cache.set('key1', 'value1')
- cache.set('key2', 'value2')
- cache.set('key3', 'value3')
- cache.set('key4', 'value4') // Should trigger eviction
-
- const stats = cache.getStats()
- expect(stats.evictions).toBe(1)
- })
- })
-
- describe('cleanup and memory management', () => {
- it('should automatically cleanup expired entries', async () => {
- cache.set('temp1', 'value1', 10) // 10ms TTL
- cache.set('temp2', 'value2', 10) // 10ms TTL
- cache.set('permanent', 'value3', 200) // 200ms TTL
-
- expect(cache.getSize()).toBe(3)
-
- // Wait for cleanup to run (cleanupInterval: 25ms, entries expire after 10ms)
- await new Promise((resolve) => setTimeout(resolve, 35))
-
- expect(cache.getSize()).toBe(1)
- expect(cache.get('permanent')).toBe('value3')
- })
-
- it('should destroy properly and clear timer', () => {
- const destroySpy = vi.spyOn(cache, 'destroy')
-
- cache.destroy()
-
- expect(destroySpy).toHaveBeenCalled()
- expect(cache.getSize()).toBe(0)
- })
- })
-
- describe('type safety', () => {
- it('should work with different value types', () => {
- const numberCache = new MemoryCache({
- ttl: 1000,
- maxSize: 10,
- })
-
- const objectCache = new MemoryCache<{ id: number; name: string }>({
- ttl: 1000,
- maxSize: 10,
- })
-
- numberCache.set('count', 42)
- objectCache.set('user', { id: 1, name: 'John' })
-
- expect(numberCache.get('count')).toBe(42)
- expect(objectCache.get('user')).toEqual({ id: 1, name: 'John' })
-
- numberCache.destroy()
- objectCache.destroy()
- })
- })
-
- describe('edge cases', () => {
- it('should handle rapid successive operations', () => {
- // Rapidly set and get many values
- for (let i = 0; i < 100; i++) {
- cache.set(`key${i}`, `value${i}`)
- }
-
- // Should only keep the last 3 due to maxSize: 3
- expect(cache.getSize()).toBe(3)
- expect(cache.get('key99')).toBe('value99')
- expect(cache.get('key98')).toBe('value98')
- expect(cache.get('key97')).toBe('value97')
- })
-
- it('should handle setting the same key multiple times', () => {
- cache.set('key1', 'value1')
- cache.set('key1', 'value2')
- cache.set('key1', 'value3')
-
- expect(cache.get('key1')).toBe('value3')
- expect(cache.getSize()).toBe(1)
- })
-
- it('should handle empty string keys and values', () => {
- cache.set('', 'empty_key')
- cache.set('empty_value', '')
-
- expect(cache.get('')).toBe('empty_key')
- expect(cache.get('empty_value')).toBe('')
- })
- })
-})
diff --git a/src/server/utils/cache/MemoryCache.ts b/src/server/utils/cache/MemoryCache.ts
deleted file mode 100644
index 0b99c3c06..000000000
--- a/src/server/utils/cache/MemoryCache.ts
+++ /dev/null
@@ -1,210 +0,0 @@
-/**
- * High-performance in-memory cache with TTL, LRU eviction, and memory management
- * Features: Time-to-live, Least Recently Used eviction, automatic cleanup, cache statistics
- */
-
-interface CacheEntry {
- value: T
- expires: number
- lastAccessed: number
- createdAt: number
-}
-
-interface CacheStats {
- hits: number
- misses: number
- size: number
- maxSize: number
- evictions: number
-}
-
-interface CacheOptions {
- ttl: number // Time to live in milliseconds
- maxSize: number // Maximum number of entries
- cleanupInterval?: number // Cleanup interval in milliseconds (default: 5 minutes)
-}
-
-class MemoryCache {
- private cache = new Map>()
- private readonly options: Required
- private cleanupTimer: NodeJS.Timeout | null = null
- private entryCounter = 0 // Add counter for unique timestamps
- private stats: CacheStats = {
- hits: 0,
- misses: 0,
- size: 0,
- maxSize: 0,
- evictions: 0,
- }
-
- constructor(options: CacheOptions) {
- this.options = {
- cleanupInterval: 5 * 60 * 1000, // 5 minutes default
- ...options,
- }
- this.stats.maxSize = options.maxSize
- this.startCleanupTimer()
- }
-
- get(key: string): T | undefined {
- const entry = this.cache.get(key)
-
- if (!entry) {
- this.stats.misses++
- return undefined
- }
-
- const now = Date.now()
-
- // Check if expired
- if (entry.expires < now) {
- this.cache.delete(key)
- this.stats.misses++
- this.stats.size--
- return undefined
- }
-
- // Update last accessed time for LRU with unique ordering
- entry.lastAccessed = now + this.entryCounter++ * 0.001
- this.stats.hits++
- return entry.value
- }
-
- set(key: string, value: T, customTtl?: number): void {
- const now = Date.now()
- const ttl = customTtl ?? this.options.ttl
-
- const entry: CacheEntry = {
- value,
- expires: now + ttl,
- lastAccessed: now + this.entryCounter++ * 0.001, // Add microsecond precision
- createdAt: now,
- }
-
- const isExistingKey = this.cache.has(key)
-
- // If we're at capacity and this is a new key, evict LRU
- if (!isExistingKey && this.cache.size >= this.options.maxSize) {
- this.evictLRU()
- }
-
- this.cache.set(key, entry)
-
- // Update stats only for new keys
- if (!isExistingKey) {
- this.stats.size++
- }
- }
-
- delete(key: string): boolean {
- const deleted = this.cache.delete(key)
- if (deleted) {
- this.stats.size--
- }
- return deleted
- }
-
- clear(): void {
- this.cache.clear()
- this.stats.size = 0
- }
-
- invalidatePattern(pattern: string): number {
- // Escape special regex characters except for our wildcard *
- const escapedPattern = pattern.replace(/[.*+?^${}()|[\]\\]/g, '\\$&').replace(/\\\*/g, '.*')
- const regex = new RegExp(`^${escapedPattern}$`)
- let deletedCount = 0
-
- // Collect keys to delete first to avoid modifying during iteration
- const keysToDelete: string[] = []
- for (const key of this.cache.keys()) {
- if (regex.test(key)) {
- keysToDelete.push(key)
- }
- }
-
- // Delete the collected keys
- for (const key of keysToDelete) {
- this.cache.delete(key)
- deletedCount++
- }
-
- // Update stats.size to match actual cache size
- this.stats.size = this.cache.size
-
- return deletedCount
- }
-
- getStats(): Readonly {
- return { ...this.stats }
- }
-
- getSize(): number {
- return this.cache.size
- }
-
- getCreatedAt(key: string): Date | null {
- const entry = this.cache.get(key)
- if (!entry) return null
-
- // Update last accessed time
- entry.lastAccessed = Date.now()
-
- return new Date(entry.createdAt)
- }
-
- destroy(): void {
- if (this.cleanupTimer) {
- clearInterval(this.cleanupTimer)
- this.cleanupTimer = null
- }
- this.clear()
- }
-
- private evictLRU(): void {
- let oldestKey: string | null = null
- let oldestTime = Infinity
-
- for (const [key, entry] of this.cache.entries()) {
- if (entry.lastAccessed < oldestTime) {
- oldestTime = entry.lastAccessed
- oldestKey = key
- }
- }
-
- if (oldestKey) {
- this.cache.delete(oldestKey)
- this.stats.evictions++
- this.stats.size--
- }
- }
-
- private startCleanupTimer(): void {
- this.cleanupTimer = setInterval(() => {
- this.cleanup()
- }, this.options.cleanupInterval)
- // Allow process to exit if this is the only active timer
- this.cleanupTimer.unref?.()
- }
-
- private cleanup(): void {
- const now = Date.now()
- let cleanedCount = 0
-
- for (const [key, entry] of this.cache.entries()) {
- if (entry.expires < now) {
- this.cache.delete(key)
- cleanedCount++
- }
- }
-
- // Update stats.size to match actual cache size
- this.stats.size = this.cache.size
-
- if (cleanedCount > 0) {
- console.debug(`Cache cleanup: removed ${cleanedCount} expired entries`)
- }
- }
-}
-
-export default MemoryCache
diff --git a/src/server/utils/cache/index.ts b/src/server/utils/cache/index.ts
index 93bc865f6..32d7510c1 100644
--- a/src/server/utils/cache/index.ts
+++ b/src/server/utils/cache/index.ts
@@ -1,8 +1,2 @@
-/**
- * Cache module exports
- * in-memory caching with TTL, LRU eviction, and type safety
- */
-
-export { default as MemoryCache } from './MemoryCache'
export * from './instances'
export * from './utils'
diff --git a/src/server/utils/cache/instances.ts b/src/server/utils/cache/instances.ts
index 8c8338487..fa3fed181 100644
--- a/src/server/utils/cache/instances.ts
+++ b/src/server/utils/cache/instances.ts
@@ -1,10 +1,5 @@
-/**
- * Cache instances for different parts of the application
- * Each cache is typed for its specific use case
- */
-
+import { LRUCache } from 'lru-cache'
import { TIME_CONSTANTS } from '@/utils/time'
-import MemoryCache from './MemoryCache'
import type { DeviceCompatibilityResponse } from '@/schemas/mobile'
import type { BatchBySteamAppIdsResponse } from '@/server/api/routers/mobile/games'
import type {
@@ -23,30 +18,34 @@ import type {
} from '@/types/tgdb'
import type { NotificationType } from '@orm/client'
-// Game statistics cache
-export const gameStatsCache = new MemoryCache<{
- pending: number
- approved: number
- rejected: number
- total: number
-}>({
+export const gameStatsCache = new LRUCache<
+ string,
+ {
+ pending: number
+ approved: number
+ rejected: number
+ total: number
+ }
+>({
ttl: TIME_CONSTANTS.FIVE_MINUTES,
- maxSize: 100, // Small cache for stats
+ max: 100,
})
-// Listing statistics cache
-export const listingStatsCache = new MemoryCache<{
- pending: number
- approved: number
- rejected: number
- total: number
-}>({
+export const listingStatsCache = new LRUCache<
+ string,
+ {
+ pending: number
+ approved: number
+ rejected: number
+ total: number
+ }
+>({
ttl: TIME_CONSTANTS.FIVE_MINUTES,
- maxSize: 100, // Small cache for stats
+ max: 100,
})
-// Notification analytics cache - for expensive analytics queries
-export const notificationAnalyticsCache = new MemoryCache<
+export const notificationAnalyticsCache = new LRUCache<
+ string,
| NotificationMetrics
| ChannelMetrics
| TypeMetrics
@@ -59,53 +58,74 @@ export const notificationAnalyticsCache = new MemoryCache<
clickRate: number
}[]
>({
- ttl: TIME_CONSTANTS.TEN_MINUTES, // analytics can be slightly stale
- maxSize: 200, // Analytics queries with different date ranges and params
+ ttl: TIME_CONSTANTS.TEN_MINUTES,
+ max: 200,
})
-// TGDB-specific caches with proper typing
-export const tgdbGamesCache = new MemoryCache({
+export const tgdbGamesCache = new LRUCache({
ttl: TIME_CONSTANTS.TEN_MINUTES,
- maxSize: 200,
+ max: 200,
})
-export const tgdbImagesCache = new MemoryCache({
+export const tgdbImagesCache = new LRUCache({
ttl: TIME_CONSTANTS.TEN_MINUTES,
- maxSize: 200,
+ max: 200,
})
-export const tgdbPlatformsCache = new MemoryCache({
- ttl: TIME_CONSTANTS.TEN_MINUTES, // rarely change
- maxSize: 10,
+export const tgdbPlatformsCache = new LRUCache({
+ ttl: TIME_CONSTANTS.TEN_MINUTES,
+ max: 10,
})
-export const tgdbImageUrlsCache = new MemoryCache<{
- boxartUrl?: string
- bannerUrl?: string
-}>({
+export const tgdbImageUrlsCache = new LRUCache<
+ string,
+ {
+ boxartUrl?: string
+ bannerUrl?: string
+ }
+>({
ttl: TIME_CONSTANTS.TEN_MINUTES,
- maxSize: 500,
+ max: 500,
})
-export const tgdbGameImagesCache = new MemoryCache>({
+export const tgdbGameImagesCache = new LRUCache>({
ttl: TIME_CONSTANTS.TEN_MINUTES,
- maxSize: 100,
+ max: 100,
})
-// Driver version cache to avoid hitting GitHub rate limits
-export const driverVersionsCache = new MemoryCache({
+export const driverVersionsCache = new LRUCache({
ttl: TIME_CONSTANTS.THIRTY_MINUTES,
- maxSize: 1,
+ max: 1,
})
-// Batch Steam App ID lookup cache - for GameHub Lite integration
-export const steamBatchQueryCache = new MemoryCache({
- ttl: TIME_CONSTANTS.TEN_MINUTES, // listings data changes frequently
- maxSize: 100, // Cache up to 100 different batch queries
+export const steamBatchQueryCache = new LRUCache({
+ ttl: TIME_CONSTANTS.TEN_MINUTES,
+ max: 100,
})
-// Catalog compatibility cache - for RetroCatalog integration
-export const catalogCompatibilityCache = new MemoryCache({
- ttl: TIME_CONSTANTS.TEN_MINUTES, // balance freshness with server load
- maxSize: 500, // cache popular device queries
+export const catalogCompatibilityCache = new LRUCache({
+ ttl: TIME_CONSTANTS.TEN_MINUTES,
+ max: 500,
})
+
+export function invalidateCatalogCompatibilityCacheForDevice(deviceId: string): number {
+ const prefix = `device:${deviceId}:`
+ let deleted = 0
+
+ for (const key of catalogCompatibilityCache.keys()) {
+ if (!key.startsWith(prefix)) continue
+ if (catalogCompatibilityCache.delete(key)) deleted++
+ }
+
+ return deleted
+}
+
+export function invalidateCatalogCompatibilityCacheForDevices(deviceIds: Iterable): number {
+ let deleted = 0
+
+ for (const deviceId of new Set(deviceIds)) {
+ deleted += invalidateCatalogCompatibilityCacheForDevice(deviceId)
+ }
+
+ return deleted
+}
diff --git a/src/server/utils/driver-versions.ts b/src/server/utils/driver-versions.ts
index 9d4508bd0..4b2abb80d 100644
--- a/src/server/utils/driver-versions.ts
+++ b/src/server/utils/driver-versions.ts
@@ -144,7 +144,7 @@ export async function getDriverVersions(): Promise {
releases,
rateLimited: false,
}
- driverVersionsCache.set(CACHE_KEY, payload, ms.minutes(30))
+ driverVersionsCache.set(CACHE_KEY, payload, { ttl: ms.minutes(30) })
return payload
} catch (error) {
if (isRateLimitError(error)) {
@@ -154,7 +154,7 @@ export async function getDriverVersions(): Promise {
rateLimited: true,
errorMessage: 'GitHub rate limit exceeded. Try again in a few minutes.',
}
- driverVersionsCache.set(CACHE_KEY, payload, ms.minutes(5))
+ driverVersionsCache.set(CACHE_KEY, payload, { ttl: ms.minutes(5) })
return payload
}
@@ -164,7 +164,7 @@ export async function getDriverVersions(): Promise {
rateLimited: false,
errorMessage: 'Failed to fetch driver versions. Please try again later.',
}
- driverVersionsCache.set(CACHE_KEY, payload, ms.minutes(2))
+ driverVersionsCache.set(CACHE_KEY, payload, { ttl: ms.minutes(2) })
return payload
}
}
diff --git a/src/server/utils/steamGameBatcher.ts b/src/server/utils/steamGameBatcher.ts
index cd76b17d4..0b64197bc 100644
--- a/src/server/utils/steamGameBatcher.ts
+++ b/src/server/utils/steamGameBatcher.ts
@@ -1,14 +1,7 @@
-/**
- * Steam Game Batch Matcher
- * Efficiently matches Steam App IDs to games in the database
- * Optimized for large batches (up to 1000 Steam App IDs)
- */
-
+import { LRUCache } from 'lru-cache'
import { ms } from '@/utils/time'
-import { MemoryCache } from './cache'
import { getSteamGamesData } from './steamGameSearch'
-// Validation constants
const MAX_STEAM_APP_ID = 10000000
const MAX_BATCH_SIZE = 1000
@@ -23,55 +16,41 @@ interface GameMatchResult {
matchStrategy: 'metadata' | 'exact' | 'normalized' | 'not_found'
}
-// Cache for Steam App ID → Game Name mappings (1 hour TTL)
-const steamAppNameCache = new MemoryCache({
+const steamAppNameCache = new LRUCache({
ttl: ms.hours(1),
- maxSize: 10000, // Cache up to 10k mappings
+ max: 10000,
})
-/**
- * Normalize game titles for better matching
- * Removes special characters, extra spaces, and converts to lowercase
- */
export function normalizeGameTitle(title: string): string {
return title
.toLowerCase()
- .replace(/[™®©]/g, '') // Remove trademark symbols
- .replace(/[:\-–—]/g, ' ') // Convert separators to spaces
- .replace(/\s+/g, ' ') // Collapse multiple spaces
- .replace(/[^\w\s]/g, '') // Remove special characters
+ .replace(/[™®©]/g, '')
+ .replace(/[:\-–—]/g, ' ')
+ .replace(/\s+/g, ' ')
+ .replace(/[^\w\s]/g, '')
.trim()
}
-/**
- * Get Steam app information from our cached Steam app list
- * This reuses the cache from our existing Steam App ID search feature
- */
async function getSteamAppInfo(appIds: string[]): Promise> {
const result = new Map()
try {
- // Get all Steam apps from cache (already implemented in steamGameSearch.ts)
const allSteamApps = await getSteamGamesData()
- // Create a lookup map for O(1) access
const steamAppMap = new Map()
for (const app of allSteamApps) {
steamAppMap.set(String(app.appid), app)
}
- // Look up each requested app ID
for (const appId of appIds) {
const cacheKey = `steam-app-${appId}`
- // Try cache first
const cachedName = steamAppNameCache.get(cacheKey)
if (cachedName) {
result.set(appId, { appid: Number(appId), name: cachedName })
continue
}
- // Lookup in Steam app list
const appInfo = steamAppMap.get(appId)
if (appInfo) {
result.set(appId, appInfo)
@@ -85,14 +64,9 @@ async function getSteamAppInfo(appIds: string[]): Promise {
const results: GameMatchResult[] = []
- // Get Steam app information for all requested IDs
const steamApps = await getSteamAppInfo(steamAppIds)
for (const appId of steamAppIds) {
@@ -102,7 +76,7 @@ export async function matchSteamAppIdsToNames(steamAppIds: string[]): Promise {
const normalizedMap = new Map()
@@ -132,17 +103,12 @@ export function createNormalizedTitleMap(gameMatches: GameMatchResult[]): Map MAX_STEAM_APP_ID) {
errors.push(`Steam App ID out of valid range: ${appId}`)
diff --git a/src/server/utils/steamGameSearch.ts b/src/server/utils/steamGameSearch.ts
index f1b4ba0c7..b4ce70a1b 100644
--- a/src/server/utils/steamGameSearch.ts
+++ b/src/server/utils/steamGameSearch.ts
@@ -1,13 +1,7 @@
-/**
- * Steam game data management with fuzzy search capabilities
- * Fetches and caches Steam game data from Steam Web API with periodic updates
- */
-
import Fuse from 'fuse.js'
+import { LRUCache } from 'lru-cache'
import { ms } from '@/utils/time'
-import { MemoryCache } from './cache'
-// Types for Steam game data
interface SteamAppEntry {
appid: number
name: string
@@ -28,19 +22,21 @@ interface SteamGameSearchResult {
score: number
}
-// Cache for Steam games data - longer TTL since the list is large and updates periodically
-const steamGamesDataCache = new MemoryCache({
+interface CachedData {
+ data: T
+ createdAt: Date
+}
+
+const steamGamesDataCache = new LRUCache>({
ttl: ms.days(1),
- maxSize: 1,
+ max: 1,
})
-// Cache for Fuse.js search instance - rebuild when data updates
-const steamGamesFuseCache = new MemoryCache>({
+const steamGamesFuseCache = new LRUCache>({
ttl: ms.days(1),
- maxSize: 1,
+ max: 1,
})
-// Configuration for fuzzy search
const FUSE_OPTIONS = {
keys: [{ name: 'name', weight: 1.0 }],
threshold: 0.4,
@@ -54,16 +50,11 @@ const FUSE_OPTIONS = {
// ISteamApps/GetAppList/v2 was removed by Valve. The replacement requires a key.
const STEAM_STORE_API_URL = 'https://api.steampowered.com/IStoreService/GetAppList/v1/'
-const FETCH_TIMEOUT_MS = 30_000 // 30s — avoids hanging on serverless cold starts
-const PAGE_SIZE = 50_000 // max allowed by the API
+const FETCH_TIMEOUT_MS = 30_000
+const PAGE_SIZE = 50_000
-// In-flight deduplication: prevents concurrent cold starts from each firing a fetch
let inflightFetch: Promise | null = null
-/**
- * Fetches Steam games data from IStoreService/GetAppList/v1 with pagination.
- * Requires STEAM_API_KEY env var.
- */
async function fetchSteamGamesData(): Promise {
const apiKey = process.env.STEAM_API_KEY
if (!apiKey) {
@@ -119,16 +110,12 @@ async function fetchSteamGamesData(): Promise {
return allApps
}
-/**
- * Gets cached Steam games data or fetches fresh data
- */
export async function getSteamGamesData(): Promise {
const cacheKey = 'steam-games-data'
const cachedData = steamGamesDataCache.get(cacheKey)
- if (cachedData) return cachedData
+ if (cachedData) return cachedData.data
- // Deduplicate concurrent fetches so only one in-flight request runs at a time
if (!inflightFetch) {
inflightFetch = fetchSteamGamesData().finally(() => {
inflightFetch = null
@@ -137,7 +124,7 @@ export async function getSteamGamesData(): Promise {
try {
const freshData = await inflightFetch
- steamGamesDataCache.set(cacheKey, freshData)
+ steamGamesDataCache.set(cacheKey, { data: freshData, createdAt: new Date() })
return freshData
} catch (error) {
const message = error instanceof Error ? error.message : String(error)
@@ -149,17 +136,12 @@ export async function getSteamGamesData(): Promise {
}
}
-/**
- * Gets or creates Fuse.js search instance
- */
async function getFuseInstance(): Promise> {
const cacheKey = 'steam-games-fuse'
- // Try to get from cache first
const cachedFuse = steamGamesFuseCache.get(cacheKey)
if (cachedFuse) return cachedFuse
- // Create new Fuse instance with fresh data
const gamesData = await getSteamGamesData()
const fuse = new Fuse(gamesData, FUSE_OPTIONS)
@@ -167,9 +149,6 @@ async function getFuseInstance(): Promise> {
return fuse
}
-/**
- * Normalizes a title for better matching
- */
function normalizeTitle(title: string): string {
return title
.toLowerCase()
@@ -178,12 +157,6 @@ function normalizeTitle(title: string): string {
.trim()
}
-/**
- * Searches for Steam App ID based on game name using fuzzy matching
- * @param gameName - The name of the game to search for
- * @param maxResults - Maximum number of results to return (default: 5)
- * @returns Array of search results with app IDs and match scores
- */
export async function findSteamAppIdForGameName(
gameName: string,
maxResults: number = 5,
@@ -195,17 +168,14 @@ export async function findSteamAppIdForGameName(
const searchTerm = gameName.trim().toLowerCase()
const searchResults = fuse.search(searchTerm, { limit: maxResults * 2 })
- // Filter and enhance results with better scoring
const enhancedResults = searchResults
.map((result) => {
const item = result.item
const fuseScore = result.score || 0
- // Calculate enhanced score based on multiple factors
const nameMatch = item.name.toLowerCase()
const normalizedMatch = normalizeTitle(item.name)
- // Exact match bonus
let bonusScore = 0
if (nameMatch === searchTerm || normalizedMatch === normalizeTitle(searchTerm)) {
bonusScore = 40
@@ -213,7 +183,6 @@ export async function findSteamAppIdForGameName(
bonusScore = 20
}
- // Word match bonus
const searchWords = searchTerm.split(' ').filter((w) => w.length > 2)
const nameWords = nameMatch.split(' ')
@@ -224,7 +193,6 @@ export async function findSteamAppIdForGameName(
}
})
- // Penalize soundtrack/dlc/demo entries unless specifically searched for
let contentBonus = 0
const lowerName = nameMatch
const isDlc =
@@ -243,7 +211,6 @@ export async function findSteamAppIdForGameName(
if (isSoundtrack && !searchesForSoundtrack) contentBonus = -15
if (isDemo && !searchesForDemo) contentBonus = -15
- // Final score calculation
const baseScore = Math.round((1 - fuseScore) * 100)
const finalScore = Math.min(
100,
@@ -262,7 +229,6 @@ export async function findSteamAppIdForGameName(
})
.filter((result) => result.score >= 30)
.sort((a, b) => {
- // Prioritize main game versions if scores are close
if (Math.abs(a.score - b.score) <= 10) {
const aExtra = a.isDlc || a.isSoundtrack || a.isDemo
const bExtra = b.isDlc || b.isSoundtrack || b.isDemo
@@ -273,7 +239,6 @@ export async function findSteamAppIdForGameName(
})
.slice(0, maxResults)
- // Remove the extra properties from final results
return enhancedResults.map(({ isDlc, isSoundtrack, isDemo, ...result }) => result)
} catch (error) {
console.error('Error searching for Steam App ID:', error)
@@ -281,19 +246,11 @@ export async function findSteamAppIdForGameName(
}
}
-/**
- * Gets the best matching App ID for a game name (highest score)
- * @param gameName - The name of the game to search for
- * @returns The best matching App ID or null if no good match found
- */
export async function getBestSteamAppIdMatch(gameName: string): Promise {
const results = await findSteamAppIdForGameName(gameName, 1)
return results.length > 0 && results[0].score >= 50 ? results[0].appId : null
}
-/**
- * Forces a refresh of the Steam games data cache
- */
export async function refreshSteamGamesData(): Promise {
try {
steamGamesDataCache.clear()
@@ -306,9 +263,6 @@ export async function refreshSteamGamesData(): Promise {
}
}
-/**
- * Gets statistics about the cached Steam games data
- */
export async function getSteamGamesStats(): Promise<{
totalGames: number
cacheStatus: 'hit' | 'miss' | 'empty'
@@ -318,21 +272,20 @@ export async function getSteamGamesStats(): Promise<{
const cachedData = steamGamesDataCache.get(cacheKey)
if (cachedData) {
- const lastUpdated = steamGamesDataCache.getCreatedAt(cacheKey)
return {
- totalGames: cachedData.length,
+ totalGames: cachedData.data.length,
cacheStatus: 'hit',
- lastUpdated: lastUpdated || undefined,
+ lastUpdated: cachedData.createdAt,
}
}
try {
const freshData = await getSteamGamesData()
- const lastUpdated = steamGamesDataCache.getCreatedAt(cacheKey)
+ const cached = steamGamesDataCache.get(cacheKey)
return {
totalGames: freshData.length,
cacheStatus: 'miss',
- lastUpdated: lastUpdated || undefined,
+ lastUpdated: cached?.createdAt,
}
} catch (error) {
console.error('[steamGameSearch] getSteamGamesStats failed to load data:', error)
diff --git a/src/server/utils/switchGameSearch.ts b/src/server/utils/switchGameSearch.ts
index adf23b504..06915ee19 100644
--- a/src/server/utils/switchGameSearch.ts
+++ b/src/server/utils/switchGameSearch.ts
@@ -1,13 +1,7 @@
-/**
- * Nintendo Switch game data management with fuzzy search capabilities
- * Fetches and caches Switch game data from external source with periodic updates
- */
-
import Fuse from 'fuse.js'
+import { LRUCache } from 'lru-cache'
import { ms } from '@/utils/time'
-import { MemoryCache } from './cache'
-// Types for Switch game data
interface SwitchGameEntry {
program_id: string
name: string
@@ -21,38 +15,37 @@ interface SwitchGameSearchResult {
score: number
}
-// Cache for Switch games data - longer TTL since data updates weekly
-const switchGamesDataCache = new MemoryCache({
+interface CachedData {
+ data: T
+ createdAt: Date
+}
+
+const switchGamesDataCache = new LRUCache>({
ttl: ms.days(1),
- maxSize: 1,
+ max: 1,
})
-// Cache for Fuse.js search instance - rebuild when data updates
-const switchGamesFuseCache = new MemoryCache>({
+const switchGamesFuseCache = new LRUCache>({
ttl: ms.days(1),
- maxSize: 1,
+ max: 1,
})
-// Configuration for fuzzy search
const FUSE_OPTIONS = {
keys: [
{ name: 'name', weight: 0.7 },
{ name: 'title_normalized', weight: 0.3 },
],
- threshold: 0.4, // More strict threshold for better matches
- distance: 50, // Reduced distance for better precision
- minMatchCharLength: 3, // Require at least 3 characters to match
+ threshold: 0.4,
+ distance: 50,
+ minMatchCharLength: 3,
includeScore: true,
- includeMatches: true, // Include match details for better filtering
- ignoreLocation: true, // Don't penalize matches at different positions
- findAllMatches: true, // Find all matching patterns
+ includeMatches: true,
+ ignoreLocation: true,
+ findAllMatches: true,
}
const SWITCH_GAMES_URL = 'https://producdevity.github.io/switch-games-json/switchbrew_id_names.json'
-/**
- * Fetches Switch games data from external source
- */
async function fetchSwitchGamesData(): Promise {
const response = await fetch(SWITCH_GAMES_URL, {
headers: { 'User-Agent': 'EmuReady-GameSearch/1.0' },
@@ -68,9 +61,7 @@ async function fetchSwitchGamesData(): Promise {
throw new Error('Invalid Switch games data format: expected array')
}
- // Validate data structure
for (const entry of data.slice(0, 5)) {
- // Check first 5 entries
if (!entry.program_id || !entry.name || !entry.title_normalized) {
throw new Error('Invalid Switch game entry structure')
}
@@ -79,23 +70,17 @@ async function fetchSwitchGamesData(): Promise {
return data
}
-/**
- * Gets cached Switch games data or fetches fresh data
- */
async function getSwitchGamesData(): Promise {
const cacheKey = 'switch-games-data'
- // Try to get from cache first
const cachedData = switchGamesDataCache.get(cacheKey)
- if (cachedData) return cachedData
+ if (cachedData) return cachedData.data
- // Fetch fresh data and cache it
try {
const freshData = await fetchSwitchGamesData()
- switchGamesDataCache.set(cacheKey, freshData)
+ switchGamesDataCache.set(cacheKey, { data: freshData, createdAt: new Date() })
return freshData
} catch (error) {
- // Add context to the error without losing the original stack trace
if (error instanceof Error) {
error.message = `Switch games data fetch failed: ${error.message}`
}
@@ -103,17 +88,12 @@ async function getSwitchGamesData(): Promise {
}
}
-/**
- * Gets or creates Fuse.js search instance
- */
async function getFuseInstance(): Promise> {
const cacheKey = 'switch-games-fuse'
- // Try to get from cache first
const cachedFuse = switchGamesFuseCache.get(cacheKey)
if (cachedFuse) return cachedFuse
- // Create new Fuse instance with fresh data
const gamesData = await getSwitchGamesData()
const fuse = new Fuse(gamesData, FUSE_OPTIONS)
@@ -121,12 +101,6 @@ async function getFuseInstance(): Promise> {
return fuse
}
-/**
- * Searches for Nintendo Switch title ID based on game name using fuzzy matching
- * @param gameName - The name of the game to search for
- * @param maxResults - Maximum number of results to return (default: 5)
- * @returns Array of search results with title IDs and match scores
- */
export async function findTitleIdForGameName(
gameName: string,
maxResults: number = 5,
@@ -136,19 +110,16 @@ export async function findTitleIdForGameName(
try {
const fuse = await getFuseInstance()
const searchTerm = gameName.trim().toLowerCase()
- const searchResults = fuse.search(searchTerm, { limit: maxResults * 2 }) // Get more results for filtering
+ const searchResults = fuse.search(searchTerm, { limit: maxResults * 2 })
- // Filter and enhance results with better scoring
const enhancedResults = searchResults
.map((result) => {
const item = result.item
const fuseScore = result.score || 0
- // Calculate enhanced score based on multiple factors
const nameMatch = item.name.toLowerCase()
const normalizedMatch = item.title_normalized.toLowerCase()
- // Exact match bonus
let bonusScore = 0
if (nameMatch === searchTerm || normalizedMatch === searchTerm) {
bonusScore = 40
@@ -156,7 +127,6 @@ export async function findTitleIdForGameName(
bonusScore = 20
}
- // Word match bonus
const searchWords = searchTerm.split(' ').filter((w) => w.length > 2)
const nameWords = nameMatch.split(' ')
const normalizedWords = normalizedMatch.split(' ')
@@ -171,16 +141,14 @@ export async function findTitleIdForGameName(
}
})
- // Avoid demo/kiosk versions unless specifically searched for
let demoBonus = 0
const isDemo = nameMatch.includes('demo') || nameMatch.includes('kiosk')
const searchesForDemo = searchTerm.includes('demo') || searchTerm.includes('kiosk')
if (isDemo && !searchesForDemo) {
- demoBonus = -15 // Penalize demos if not specifically searched
+ demoBonus = -15
}
- // Final score calculation
const baseScore = Math.round((1 - fuseScore) * 100)
const finalScore = Math.min(
100,
@@ -195,9 +163,8 @@ export async function findTitleIdForGameName(
isDemo,
}
})
- .filter((result) => result.score >= 30) // Only return results with decent scores
+ .filter((result) => result.score >= 30)
.sort((a, b) => {
- // Prioritize non-demo versions if scores are close
if (Math.abs(a.score - b.score) <= 10) {
if (a.isDemo && !b.isDemo) return 1
if (!a.isDemo && b.isDemo) return -1
@@ -206,7 +173,6 @@ export async function findTitleIdForGameName(
})
.slice(0, maxResults)
- // Remove the isDemo property from final results
return enhancedResults.map(({ isDemo, ...result }) => result)
} catch (error) {
console.error('Error searching for Switch title ID:', error)
@@ -214,29 +180,17 @@ export async function findTitleIdForGameName(
}
}
-/**
- * Gets the best matching title ID for a game name (highest score)
- * @param gameName - The name of the game to search for
- * @returns The best matching title ID or null if no good match found
- */
export async function getBestTitleIdMatch(gameName: string): Promise {
const results = await findTitleIdForGameName(gameName, 1)
- // Return the best match if score is good enough (>= 50% for more flexibility)
return results.length > 0 && results[0].score >= 50 ? results[0].titleId : null
}
-/**
- * Forces a refresh of the Switch games data cache
- * Useful for periodic updates or manual refresh
- */
export async function refreshSwitchGamesData(): Promise {
try {
- // Clear caches to force fresh fetch
switchGamesDataCache.clear()
switchGamesFuseCache.clear()
- // Pre-populate cache with fresh data
await getSwitchGamesData()
await getFuseInstance()
} catch (error) {
@@ -245,9 +199,6 @@ export async function refreshSwitchGamesData(): Promise {
}
}
-/**
- * Gets statistics about the cached Switch games data
- */
export async function getSwitchGamesStats(): Promise<{
totalGames: number
cacheStatus: 'hit' | 'miss' | 'empty'
@@ -257,21 +208,20 @@ export async function getSwitchGamesStats(): Promise<{
const cachedData = switchGamesDataCache.get(cacheKey)
if (cachedData) {
- const lastUpdated = switchGamesDataCache.getCreatedAt(cacheKey)
return {
- totalGames: cachedData.length,
+ totalGames: cachedData.data.length,
cacheStatus: 'hit',
- lastUpdated: lastUpdated || undefined,
+ lastUpdated: cachedData.createdAt,
}
}
try {
const freshData = await getSwitchGamesData()
- const lastUpdated = switchGamesDataCache.getCreatedAt(cacheKey)
+ const cached = switchGamesDataCache.get(cacheKey)
return {
totalGames: freshData.length,
cacheStatus: 'miss',
- lastUpdated: lastUpdated || undefined,
+ lastUpdated: cached?.createdAt,
}
} catch {
return {
diff --git a/src/server/utils/threeDsGameSearch.ts b/src/server/utils/threeDsGameSearch.ts
index f94163ca0..c4c9f1464 100644
--- a/src/server/utils/threeDsGameSearch.ts
+++ b/src/server/utils/threeDsGameSearch.ts
@@ -1,11 +1,6 @@
-/**
- * Nintendo 3DS title ID lookup with fuzzy search and caching
- * Mirrors the Nintendo Switch lookup flow but sources data from the 3DS title manifest
- */
-
import Fuse from 'fuse.js'
+import { LRUCache } from 'lru-cache'
import { ms } from '@/utils/time'
-import { MemoryCache } from './cache'
import type { IFuseOptions } from 'fuse.js'
interface RawThreeDsTitleEntry {
@@ -37,6 +32,11 @@ export interface ThreeDsGameSearchResult {
productCode: string | null
}
+interface CachedData {
+ data: T
+ createdAt: Date
+}
+
const REGION_PRIORITY = [
'US',
'GB',
@@ -78,14 +78,14 @@ const FUSE_OPTIONS: IFuseOptions = {
const THREEDS_TITLES_URL = 'https://dantheman827.github.io/nus-info/titles.json'
const THREEDS_TITLE_NAMES_URL = 'https://dantheman827.github.io/nus-info/title-names.json'
-const threeDsGamesDataCache = new MemoryCache({
+const threeDsGamesDataCache = new LRUCache>({
ttl: ms.days(1),
- maxSize: 1,
+ max: 1,
})
-const threeDsGamesFuseCache = new MemoryCache>({
+const threeDsGamesFuseCache = new LRUCache>({
ttl: ms.days(1),
- maxSize: 1,
+ max: 1,
})
function normalizeTitle(title: string): string {
@@ -205,11 +205,11 @@ async function fetchThreeDsGamesData(): Promise {
async function getThreeDsGamesData(): Promise {
const cacheKey = '3ds-games-data'
const cached = threeDsGamesDataCache.get(cacheKey)
- if (cached) return cached
+ if (cached) return cached.data
try {
const fresh = await fetchThreeDsGamesData()
- threeDsGamesDataCache.set(cacheKey, fresh)
+ threeDsGamesDataCache.set(cacheKey, { data: fresh, createdAt: new Date() })
return fresh
} catch (error) {
if (error instanceof Error) {
@@ -358,21 +358,20 @@ export async function getThreeDsGamesStats(): Promise<{
const cached = threeDsGamesDataCache.get(cacheKey)
if (cached) {
- const lastUpdated = threeDsGamesDataCache.getCreatedAt(cacheKey)
return {
- totalGames: cached.length,
+ totalGames: cached.data.length,
cacheStatus: 'hit',
- lastUpdated: lastUpdated ?? undefined,
+ lastUpdated: cached.createdAt,
}
}
try {
const fresh = await getThreeDsGamesData()
- const lastUpdated = threeDsGamesDataCache.getCreatedAt(cacheKey)
+ const cachedAfterRefresh = threeDsGamesDataCache.get(cacheKey)
return {
totalGames: fresh.length,
cacheStatus: 'miss',
- lastUpdated: lastUpdated ?? undefined,
+ lastUpdated: cachedAfterRefresh?.createdAt,
}
} catch {
return {
diff --git a/tsconfig.json b/tsconfig.json
index 5a1351ef1..d40a002d3 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -11,7 +11,7 @@
"moduleResolution": "bundler",
"resolveJsonModule": true,
"isolatedModules": true,
- "jsx": "preserve",
+ "jsx": "react-jsx",
"incremental": true,
"plugins": [{ "name": "next" }],
"paths": {