Merge pull request #651 from Jay-Peter-Egemasi/codex/routes-b-request-notifications-dashboard-audit

feat: add routes-b request ids and endpoints

Author: davedumto

app/api/routes-b/_health/route.ts

@@ -1,3 +1,4 @@
+import { withRequestId } from '../_lib/with-request-id'
 import { NextResponse } from 'next/server'
 import { prisma } from '@/lib/db'
 
@@ -13,7 +14,7 @@ async function checkDbWithTimeout() {
   await Promise.race([dbCheck, timeout])
 }
 
-export async function GET() {
+async function GETHandler() {
   const startedAt = Date.now()
   const responseTimeout = new Promise<never>((_, reject) => {
     setTimeout(() => reject(new Error('HEALTH_TIMEOUT')), HARD_TIMEOUT_MS)
@@ -47,3 +48,4 @@ export async function GET() {
   }
 }
 
+export const GET = withRequestId(GETHandler)

app/api/routes-b/_lib/amounts.ts

@@ -0,0 +1,3 @@
+export function normalizeCurrencyAmount(value: unknown): number {
+  return Number(value ?? 0)
+}

app/api/routes-b/_lib/flags.ts

@@ -24,6 +24,9 @@ const defaultFlags: Record<string, FlagValue> = {
   'webhook-event-filtering': 'off',
 };
 
+export const ENABLE_CONTACTS_SOFT_DELETE = process.env.ENABLE_CONTACTS_SOFT_DELETE === 'true' ||
+  process.env.FLAG_CONTACTS_SOFT_DELETE === 'on'
+
 function parseFlagValue(envValue: string | undefined): FlagValue {
   if (!envValue) return 'off';
 
@@ -58,9 +61,9 @@ export function isEnabled(flagName: string, context: FlagContext = {}): boolean
   // Check cache first
   const cacheKey = `${flagName}:${context.userId || 'no-user'}`;
   if (flagCache.has(cacheKey)) {
-    return flagCache.get(cacheKey) === 'on' || 
-           (Array.isArray(flagCache.get(cacheKey)) && context.userId && 
-            (flagCache.get(cacheKey) as string[]).includes(context.userId));
+    const cached = flagCache.get(cacheKey)
+    return cached === 'on' ||
+      Boolean(Array.isArray(cached) && context.userId && cached.includes(context.userId))
   }
 
   // Get flag value from env or defaults

app/api/routes-b/_lib/notification-cache.ts

@@ -0,0 +1,19 @@
+import { deleteCacheValue, getCacheValue, setCacheValue } from './cache'
+
+const UNREAD_COUNT_TTL_MS = 10_000
+
+function unreadCountCacheKey(userId: string) {
+  return `notifications:unread-count:${userId}`
+}
+
+export function getCachedUnreadCount(userId: string): number | null {
+  return getCacheValue<number>(unreadCountCacheKey(userId))
+}
+
+export function setCachedUnreadCount(userId: string, count: number) {
+  setCacheValue(unreadCountCacheKey(userId), count, UNREAD_COUNT_TTL_MS)
+}
+
+export function bustUnreadCountCache(userId: string) {
+  deleteCacheValue(unreadCountCacheKey(userId))
+}

app/api/routes-b/_lib/presigned-upload.ts

@@ -19,11 +19,20 @@ const CLOUDINARY_CLOUD_NAME = process.env.CLOUDINARY_CLOUD_NAME
 const CLOUDINARY_API_KEY = process.env.CLOUDINARY_API_KEY
 const CLOUDINARY_API_SECRET = process.env.CLOUDINARY_API_SECRET
 
-if (!CLOUDINARY_CLOUD_NAME || !CLOUDINARY_API_KEY || !CLOUDINARY_API_SECRET) {
-  throw new Error('Missing Cloudinary configuration')
+function requireCloudinaryConfig() {
+  if (!CLOUDINARY_CLOUD_NAME || !CLOUDINARY_API_KEY || !CLOUDINARY_API_SECRET) {
+    throw new Error('Missing Cloudinary configuration')
+  }
+
+  return {
+    cloudName: CLOUDINARY_CLOUD_NAME,
+    apiKey: CLOUDINARY_API_KEY,
+    apiSecret: CLOUDINARY_API_SECRET,
+  }
 }
 
 export function generatePresignedUpload(userId: string): PresignedUploadResponse {
+  const config = requireCloudinaryConfig()
   const timestamp = Math.round(Date.now() / 1000)
   const publicId = `avatars/${userId}/${timestamp}`
   const folder = 'avatars'
@@ -45,15 +54,15 @@ export function generatePresignedUpload(userId: string): PresignedUploadResponse
     .join('&')
 
   const signature = createHash('sha1')
-    .update(signatureString + CLOUDINARY_API_SECRET)
+    .update(signatureString + config.apiSecret)
     .digest('hex')
 
   const expiresAt = new Date(Date.now() + 60 * 1000) // 60 seconds from now
 
   return {
-    url: `https://api.cloudinary.com/v1_1/${CLOUDINARY_CLOUD_NAME}/auto/upload`,
+    url: `https://api.cloudinary.com/v1_1/${config.cloudName}/auto/upload`,
     fields: {
-      api_key: CLOUDINARY_API_KEY,
+      api_key: config.apiKey,
       timestamp: timestamp.toString(),
       public_id: publicId,
       folder,
@@ -105,7 +114,7 @@ export async function validateUploadedFile(key: string, buffer: ArrayBuffer): Pr
 }
 
 export function generateCloudinaryUrl(key: string): string {
-  return `https://res.cloudinary.com/${CLOUDINARY_CLOUD_NAME}/image/upload/${key}.jpg`
+  return `https://res.cloudinary.com/${CLOUDINARY_CLOUD_NAME || 'demo'}/image/upload/${key}.jpg`
 }
 
 export function isExpiredKey(expiresAt: string): boolean {

app/api/routes-b/_lib/rate-limit.ts

@@ -38,3 +38,14 @@ export function checkRateLimit(
 export function resetRateLimitBuckets() {
   buckets.clear()
 }
+
+export async function rateLimit(key: string, limit: number, windowMs: number) {
+  const result = checkRateLimit(key, { limit, windowMs })
+
+  return result.allowed
+    ? { allowed: true as const }
+    : {
+        allowed: false as const,
+        resetTime: new Date(Date.now() + result.retryAfter * 1000).toISOString(),
+      }
+}

app/api/routes-b/_lib/swr-cache.js

@@ -0,0 +1,47 @@
+const swrStore = globalThis.__routesBSwrStore ??= new Map()
+
+function swrGet(key) {
+  const entry = swrStore.get(key)
+  if (!entry) return null
+  if (Date.now() > entry.staleUntil) {
+    swrStore.delete(key)
+    return null
+  }
+  return entry
+}
+
+function swrSet(key, value, freshMs, staleMs) {
+  const now = Date.now()
+  swrStore.set(key, {
+    value,
+    fetchedAt: now,
+    freshUntil: now + freshMs,
+    staleUntil: now + staleMs,
+  })
+}
+
+function swrDelete(key) {
+  swrStore.delete(key)
+}
+
+function swrClear() {
+  swrStore.clear()
+}
+
+function swrIsFresh(entry) {
+  return Date.now() < entry.freshUntil
+}
+
+function swrIsStale(entry) {
+  const now = Date.now()
+  return now >= entry.freshUntil && now < entry.staleUntil
+}
+
+module.exports = {
+  swrGet,
+  swrSet,
+  swrDelete,
+  swrClear,
+  swrIsFresh,
+  swrIsStale,
+}

app/api/routes-b/_lib/swr-cache.ts

@@ -5,7 +5,9 @@ export type SwrEntry<T> = {
   staleUntil: number
 }
 
-const swrStore = new Map<string, SwrEntry<unknown>>()
+const swrStore = ((globalThis as typeof globalThis & {
+  __routesBSwrStore?: Map<string, SwrEntry<unknown>>
+}).__routesBSwrStore ??= new Map<string, SwrEntry<unknown>>())
 
 export function swrGet<T>(key: string): SwrEntry<T> | null {
   const entry = swrStore.get(key)

app/api/routes-b/_lib/with-request-id.ts

@@ -0,0 +1,105 @@
+import { AsyncLocalStorage } from 'async_hooks'
+import { randomBytes } from 'crypto'
+import { NextResponse } from 'next/server'
+import { logger } from '@/lib/logger'
+
+type RequestContext = {
+  requestId: string
+}
+
+type RouteHandler = (...args: any[]) => unknown | Promise<unknown>
+
+const requestContext = new AsyncLocalStorage<RequestContext>()
+const LOGGER_PATCHED = Symbol.for('routes-b.logger.request-id-patched')
+const UUID_PATTERN =
+  /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i
+
+function generateUuidV7(): string {
+  const bytes = randomBytes(16)
+  const timestamp = Date.now()
+
+  bytes[0] = Math.floor(timestamp / 0x10000000000) & 0xff
+  bytes[1] = Math.floor(timestamp / 0x100000000) & 0xff
+  bytes[2] = Math.floor(timestamp / 0x1000000) & 0xff
+  bytes[3] = Math.floor(timestamp / 0x10000) & 0xff
+  bytes[4] = Math.floor(timestamp / 0x100) & 0xff
+  bytes[5] = timestamp & 0xff
+  bytes[6] = (bytes[6] & 0x0f) | 0x70
+  bytes[8] = (bytes[8] & 0x3f) | 0x80
+
+  const hex = Array.from(bytes, byte => byte.toString(16).padStart(2, '0')).join('')
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`
+}
+
+function isUuid(value: string | null): value is string {
+  return Boolean(value && UUID_PATTERN.test(value))
+}
+
+function getRequestHeader(args: any[], name: string): string | null {
+  const request = args[0]
+  return typeof request?.headers?.get === 'function' ? request.headers.get(name) : null
+}
+
+function resolveRequestId(args: any[]) {
+  const clientRequestId = getRequestHeader(args, 'x-request-id')
+  return isUuid(clientRequestId) ? clientRequestId : generateUuidV7()
+}
+
+export function getRequestId(): string | null {
+  return requestContext.getStore()?.requestId ?? null
+}
+
+function patchLogger() {
+  const target = logger as any
+  if (target[LOGGER_PATCHED]) return
+
+  for (const method of ['trace', 'debug', 'info', 'warn', 'error', 'fatal'] as const) {
+    const original = target[method]
+    if (typeof original !== 'function') continue
+    if (original.mock || original._isMockFunction) continue
+
+    target[method] = function requestIdLoggerMethod(this: unknown, ...args: any[]) {
+      const requestId = getRequestId()
+      if (requestId) {
+        const first = args[0]
+        if (first && typeof first === 'object' && !Array.isArray(first) && !(first instanceof Error)) {
+          args[0] = { requestId, ...first }
+        } else {
+          args.unshift({ requestId })
+        }
+      }
+
+      return original.apply(this, args)
+    }
+  }
+
+  target[LOGGER_PATCHED] = true
+}
+
+function responseWithRequestId(response: unknown, requestId: string): Response {
+  const routeResponse = response instanceof Response
+    ? response
+    : new Response(null, { status: 204 })
+
+  routeResponse.headers.set('X-Request-Id', requestId)
+  return routeResponse
+}
+
+patchLogger()
+
+export function withRequestId<T extends RouteHandler>(handler: T): (...args: any[]) => Promise<Response> {
+  return (async (...args: any[]) => {
+    const requestId = resolveRequestId(args)
+
+    try {
+      const response = await requestContext.run({ requestId }, () => handler(...args))
+      return responseWithRequestId(response, requestId)
+    } catch (error) {
+      logger.error({ err: error }, 'Routes B unhandled route error')
+      return responseWithRequestId(
+        NextResponse.json({ error: 'Internal server error' }, { status: 500 }),
+        requestId,
+      )
+    }
+  })
+}

app/api/routes-b/_openapi/route.ts

@@ -1,7 +1,8 @@
+import { withRequestId } from '../_lib/with-request-id'
 import { NextRequest, NextResponse } from 'next/server'
 import { generateOpenAPIDocument } from '../_lib/openapi'
 
-export async function GET(request: NextRequest) {
+async function GETHandler(request: NextRequest) {
   const baseUrl = process.env.NEXT_PUBLIC_APP_URL || 
                   `https://${request.headers.get('host')}` ||
                   'http://localhost:3000'
@@ -14,4 +15,6 @@ export async function GET(request: NextRequest) {
       'Cache-Control': 'no-cache'
     }
   })
-}
+}
+
+export const GET = withRequestId(GETHandler)