feat(bot): persist locale preferences across mini app and replies

apps/bot/src/miniapp-locale.ts

@@ -0,0 +1,150 @@
+import type { HouseholdOnboardingService, LocalePreferenceService } from '@household/application'
+import { normalizeSupportedLocale } from '@household/domain'
+import type { Logger } from '@household/observability'
+
+import {
+  allowedMiniAppOrigin,
+  createMiniAppSessionService,
+  miniAppErrorResponse,
+  miniAppJsonResponse
+} from './miniapp-auth'
+
+interface LocalePreferenceRequest {
+  initData: string
+  locale: 'en' | 'ru'
+  scope: 'member' | 'household'
+}
+
+async function readLocalePreferenceRequest(request: Request): Promise<LocalePreferenceRequest> {
+  const text = await request.text()
+  if (text.trim().length === 0) {
+    throw new Error('Missing initData')
+  }
+
+  let parsed: { initData?: string; locale?: string; scope?: string }
+  try {
+    parsed = JSON.parse(text) as { initData?: string; locale?: string; scope?: string }
+  } catch {
+    throw new Error('Invalid JSON body')
+  }
+
+  const initData = parsed.initData?.trim()
+  if (!initData) {
+    throw new Error('Missing initData')
+  }
+
+  const locale = normalizeSupportedLocale(parsed.locale)
+  if (!locale) {
+    throw new Error('Invalid locale')
+  }
+
+  const scope = parsed.scope?.trim()
+  if (scope !== 'member' && scope !== 'household') {
+    throw new Error('Invalid locale scope')
+  }
+
+  return {
+    initData,
+    locale,
+    scope
+  }
+}
+
+export function createMiniAppLocalePreferenceHandler(options: {
+  allowedOrigins: readonly string[]
+  botToken: string
+  onboardingService: HouseholdOnboardingService
+  localePreferenceService: LocalePreferenceService
+  logger?: Logger
+}): {
+  handler: (request: Request) => Promise<Response>
+} {
+  const sessionService = createMiniAppSessionService({
+    botToken: options.botToken,
+    onboardingService: options.onboardingService
+  })
+
+  return {
+    handler: async (request) => {
+      const origin = allowedMiniAppOrigin(request, options.allowedOrigins)
+
+      if (request.method === 'OPTIONS') {
+        return miniAppJsonResponse({ ok: true }, 204, origin)
+      }
+
+      if (request.method !== 'POST') {
+        return miniAppJsonResponse({ ok: false, error: 'Method Not Allowed' }, 405, origin)
+      }
+
+      try {
+        const payload = await readLocalePreferenceRequest(request)
+        const session = await sessionService.authenticate({
+          initData: payload.initData
+        })
+
+        if (!session) {
+          return miniAppJsonResponse(
+            { ok: false, error: 'Invalid Telegram init data' },
+            401,
+            origin
+          )
+        }
+
+        if (!session.authorized || !session.member || !session.telegramUser) {
+          return miniAppJsonResponse(
+            { ok: false, error: 'Access limited to active household members' },
+            403,
+            origin
+          )
+        }
+
+        let memberPreferredLocale = session.member.preferredLocale
+        let householdDefaultLocale = session.member.householdDefaultLocale
+
+        if (payload.scope === 'member') {
+          const result = await options.localePreferenceService.updateMemberLocale({
+            householdId: session.member.householdId,
+            telegramUserId: session.telegramUser.id,
+            locale: payload.locale
+          })
+
+          if (result.status === 'rejected') {
+            return miniAppJsonResponse({ ok: false, error: 'Member not found' }, 404, origin)
+          }
+
+          memberPreferredLocale = result.member.preferredLocale
+          householdDefaultLocale = result.member.householdDefaultLocale
+        } else {
+          const result = await options.localePreferenceService.updateHouseholdLocale({
+            householdId: session.member.householdId,
+            actorIsAdmin: session.member.isAdmin,
+            locale: payload.locale
+          })
+
+          if (result.status === 'rejected') {
+            return miniAppJsonResponse({ ok: false, error: 'Admin access required' }, 403, origin)
+          }
+
+          householdDefaultLocale = result.household.defaultLocale
+        }
+
+        return miniAppJsonResponse(
+          {
+            ok: true,
+            authorized: true,
+            locale: {
+              scope: payload.scope,
+              effectiveLocale: memberPreferredLocale ?? householdDefaultLocale,
+              memberPreferredLocale,
+              householdDefaultLocale
+            }
+          },
+          200,
+          origin
+        )
+      } catch (error) {
+        return miniAppErrorResponse(error, origin, options.logger)
+      }
+    }
+  }
+}