Fix remaining German comment

server/api/service/auth/forgot-password.post.ts

@@ -15,7 +15,7 @@ export default defineEventHandler(async (event) => {
   const email = body.email?.trim().toLowerCase()
 
   if (!email) {
-    throw createError({ statusCode: 400, statusMessage: 'Bitte eine E-Mail-Adresse angeben' })
+    throw createError({ statusCode: 400, statusMessage: 'Please provide an email address' })
   }
 
   const user = await User.findOne({ email })
@@ -32,21 +32,21 @@ export default defineEventHandler(async (event) => {
 
     const salutation = user.name ? ` ${user.name}` : ''
     const lines = [
-      `Hallo${salutation},`,
+      `Hi${salutation},`,
       '',
-      'du hast den Link zum Zurücksetzen deines OpenSquawk-Passworts angefordert.',
-      `Klicke innerhalb von ${RESET_TOKEN_TTL_MINUTES} Minuten auf den folgenden Link, um ein neues Passwort festzulegen:`,
+      'You requested a link to reset your OpenSquawk password.',
+      `Click the link below within ${RESET_TOKEN_TTL_MINUTES} minutes to choose a new password:`,
       resetLink,
       '',
-      'Wenn du diese Anfrage nicht gestellt hast, kannst du diese E-Mail ignorieren.',
+      'If you did not make this request, you can safely ignore this email.',
       '',
       'Blue skies,',
-      'dein OpenSquawk-Team',
+      'Your OpenSquawk crew',
     ]
 
     await sendMail({
       to: user.email,
-      subject: 'OpenSquawk Passwort zurücksetzen',
+      subject: 'Reset your OpenSquawk password',
       text: lines.join('\n'),
     })
   }

server/api/service/auth/login.post.ts

@@ -13,17 +13,17 @@ export default defineEventHandler(async (event) => {
   const password = body.password?.trim()
 
   if (!email || !password) {
-    throw createError({ statusCode: 400, statusMessage: 'Bitte E-Mail und Passwort angeben' })
+    throw createError({ statusCode: 400, statusMessage: 'Please provide email and password' })
   }
 
   const user = await User.findOne({ email })
   if (!user) {
-    throw createError({ statusCode: 401, statusMessage: 'Ungültige Zugangsdaten' })
+    throw createError({ statusCode: 401, statusMessage: 'Invalid credentials' })
   }
 
   const valid = await verifyPassword(password, user.passwordHash)
   if (!valid) {
-    throw createError({ statusCode: 401, statusMessage: 'Ungültige Zugangsdaten' })
+    throw createError({ statusCode: 401, statusMessage: 'Invalid credentials' })
   }
 
   user.lastLoginAt = new Date()

server/api/service/auth/register.post.ts

@@ -23,36 +23,36 @@ export default defineEventHandler(async (event) => {
   const email = emailInput.toLowerCase()
 
   if (!emailInput || !password || !code) {
-    throw createError({ statusCode: 400, statusMessage: 'Bitte E-Mail, Passwort und Einladungscode angeben' })
+    throw createError({ statusCode: 400, statusMessage: 'Please provide email, password and invitation code' })
   }
 
   if (!body.acceptPrivacy || !body.acceptTerms) {
-    throw createError({ statusCode: 400, statusMessage: 'Bitte AGB und Datenschutz bestätigen' })
+    throw createError({ statusCode: 400, statusMessage: 'Please accept the terms and privacy policy' })
   }
 
   if (!isValidEmail(emailInput)) {
-    throw createError({ statusCode: 400, statusMessage: 'Bitte eine gültige E-Mail-Adresse angeben' })
+    throw createError({ statusCode: 400, statusMessage: 'Please provide a valid email address' })
   }
 
   const passwordValidation = validatePasswordStrength(password)
   if (!passwordValidation.valid) {
-    throw createError({ statusCode: 400, statusMessage: passwordValidation.message || 'Passwort ist zu schwach' })
+    throw createError({ statusCode: 400, statusMessage: passwordValidation.message || 'Password is too weak' })
   }
 
   const existingUser = await User.findOne({ email })
   if (existingUser) {
-    throw createError({ statusCode: 409, statusMessage: 'Für diese E-Mail existiert bereits ein Konto' })
+    throw createError({ statusCode: 409, statusMessage: 'An account already exists for this email address' })
   }
 
   const invitation = await InvitationCode.findOne({ code })
   if (!invitation) {
-    throw createError({ statusCode: 404, statusMessage: 'Einladungscode nicht gefunden' })
+    throw createError({ statusCode: 404, statusMessage: 'Invitation code not found' })
   }
   if (invitation.usedBy) {
-    throw createError({ statusCode: 400, statusMessage: 'Einladungscode wurde bereits verwendet' })
+    throw createError({ statusCode: 400, statusMessage: 'Invitation code has already been used' })
   }
   if (invitation.expiresAt && invitation.expiresAt < new Date()) {
-    throw createError({ statusCode: 400, statusMessage: 'Einladungscode ist abgelaufen' })
+    throw createError({ statusCode: 400, statusMessage: 'Invitation code has expired' })
   }
 
   const passwordHash = await hashPassword(password)

server/api/service/auth/reset-password.post.ts

@@ -15,24 +15,24 @@ export default defineEventHandler(async (event) => {
   const password = body.password?.trim()
 
   if (!token || !password) {
-    throw createError({ statusCode: 400, statusMessage: 'Token und neues Passwort erforderlich' })
+    throw createError({ statusCode: 400, statusMessage: 'Token and new password required' })
   }
 
   if (password.length < 8) {
-    throw createError({ statusCode: 400, statusMessage: 'Das Passwort muss mindestens 8 Zeichen enthalten' })
+    throw createError({ statusCode: 400, statusMessage: 'Password must be at least 8 characters long' })
   }
 
   const tokenHash = createHash('sha256').update(token).digest('hex')
   const resetToken = await PasswordResetToken.findOne({ tokenHash })
 
   if (!resetToken || (resetToken.expiresAt && resetToken.expiresAt < new Date()) || resetToken.usedAt) {
-    throw createError({ statusCode: 400, statusMessage: 'Dieser Link ist ungültig oder abgelaufen' })
+    throw createError({ statusCode: 400, statusMessage: 'This link is invalid or has expired' })
   }
 
   const user = await User.findById(resetToken.user)
   if (!user) {
     await resetToken.deleteOne().catch(() => undefined)
-    throw createError({ statusCode: 400, statusMessage: 'Dieser Link ist ungültig oder abgelaufen' })
+    throw createError({ statusCode: 400, statusMessage: 'This link is invalid or has expired' })
   }
 
   user.passwordHash = await hashPassword(password)

server/api/service/invitations/bootstrap.post.ts

@@ -7,11 +7,11 @@ const CREATION_DEADLINE = new Date(process.env.BOOTSTRAP_INVITE_DEADLINE ?? '202
 export default defineEventHandler(async (event) => {
   const now = new Date()
   if (Number.isNaN(CREATION_DEADLINE.getTime())) {
-    throw createError({ statusCode: 500, statusMessage: 'Konfiguration für Bootstrap-Deadline ungültig' })
+    throw createError({ statusCode: 500, statusMessage: 'Invalid bootstrap deadline configuration' })
   }
 
   if (now > CREATION_DEADLINE) {
-    throw createError({ statusCode: 403, statusMessage: 'Bootstrap-Zeitraum abgelaufen' })
+    throw createError({ statusCode: 403, statusMessage: 'Bootstrap window has expired' })
   }
 
   const body = await readBody<{ label?: string }>(event).catch(() => ({ label: undefined }))

server/api/service/invitations/manual.post.ts

@@ -31,14 +31,14 @@ export default defineEventHandler<ManualInviteResponse>(async (event) => {
   const expectedPassword = (config.manualInvitePassword as string | undefined)?.trim() || ''
 
   if (!expectedPassword) {
-    throw createError({ statusCode: 500, statusMessage: 'Konfiguration für manuellen Einladungscode fehlt' })
+    throw createError({ statusCode: 500, statusMessage: 'Manual invitation code configuration missing' })
   }
 
   const body = await readBody<ManualInviteRequestBody>(event).catch(() => ({}) as ManualInviteRequestBody)
   const providedPassword = body.password?.trim() || ''
 
   if (!providedPassword || !safeComparePassword(providedPassword, expectedPassword)) {
-    throw createError({ statusCode: 401, statusMessage: 'Ungültiges Passwort' })
+    throw createError({ statusCode: 401, statusMessage: 'Invalid password' })
   }
 
   const now = new Date()

server/api/service/roadmap-suggestions.post.ts

@@ -21,19 +21,19 @@ export default defineEventHandler(async (event) => {
   const allowContact = Boolean(body.allowContact && email)
 
   if (!title || title.length < MIN_TITLE_LENGTH) {
-    throw createError({ statusCode: 400, statusMessage: 'Bitte gib einen kurzen Titel (mindestens 4 Zeichen) an.' })
+    throw createError({ statusCode: 400, statusMessage: 'Please provide a short title (at least 4 characters).' })
   }
 
   if (!details || details.length < MIN_DETAILS_LENGTH) {
-    throw createError({ statusCode: 400, statusMessage: 'Beschreibe deinen Vorschlag mit mindestens 20 Zeichen.' })
+    throw createError({ statusCode: 400, statusMessage: 'Please describe your suggestion in at least 20 characters.' })
   }
 
   if (!body.consentPrivacy) {
-    throw createError({ statusCode: 400, statusMessage: 'Wir benötigen deine Einwilligung zur Datenschutzerklärung.' })
+    throw createError({ statusCode: 400, statusMessage: 'We need your consent to the privacy policy.' })
   }
 
   if (body.allowContact && !email) {
-    throw createError({ statusCode: 400, statusMessage: 'Bitte gib eine E-Mail an, damit wir dich kontaktieren können.' })
+    throw createError({ statusCode: 400, statusMessage: 'Please provide an email address so we can contact you.' })
   }
 
   const suggestion = await RoadmapSuggestion.create({
@@ -45,15 +45,15 @@ export default defineEventHandler(async (event) => {
   })
 
   const dataEntries = [
-    ['Titel', title],
-    ['Beschreibung', details],
-    ['E-Mail', email || null],
-    ['Kontaktaufnahme erlaubt', allowContact],
+    ['Title', title],
+    ['Description', details],
+    ['Email', email || null],
+    ['Contact allowed', allowContact],
   ]
 
   await sendAdminNotification({
-    event: 'Neuer Roadmap-Vorschlag',
-    summary: `Neuer Roadmap-Vorschlag: ${title}`,
+    event: 'New roadmap suggestion',
+    summary: `New roadmap suggestion: ${title}`,
     data: dataEntries,
   })
 

server/api/service/roadmap.post.ts

@@ -20,11 +20,11 @@ export default defineEventHandler(async (event) => {
   const body = await readBody<{ votes?: RoadmapVotePayload[] }>(event)
 
   if (!body?.votes || !Array.isArray(body.votes) || body.votes.length === 0) {
-    throw createError({ statusCode: 400, statusMessage: 'Keine Stimmen übermittelt' })
+    throw createError({ statusCode: 400, statusMessage: 'No votes submitted' })
   }
 
   if (body.votes.length > MAX_VOTES_PER_SUBMISSION) {
-    throw createError({ statusCode: 400, statusMessage: 'Zu viele Stimmen in einer Anfrage' })
+    throw createError({ statusCode: 400, statusMessage: 'Too many votes in a single request' })
   }
 
   const normalized = new Map<string, number>()
@@ -35,17 +35,17 @@ export default defineEventHandler(async (event) => {
     }
     const key = String(vote.key ?? '').trim()
     if (!ROADMAP_ITEM_KEYS.has(key)) {
-      throw createError({ statusCode: 400, statusMessage: `Unbekannter Roadmap-Eintrag: ${key || '?'}` })
+      throw createError({ statusCode: 400, statusMessage: `Unknown roadmap entry: ${key || '?'}` })
     }
     const importance = Math.round(Number(vote.importance ?? 0))
     if (!Number.isFinite(importance) || importance < 1 || importance > 5) {
-      throw createError({ statusCode: 400, statusMessage: 'Bewertung muss zwischen 1 und 5 liegen' })
+      throw createError({ statusCode: 400, statusMessage: 'Rating must be between 1 and 5' })
     }
     normalized.set(key, importance)
   }
 
   if (normalized.size === 0) {
-    throw createError({ statusCode: 400, statusMessage: 'Keine gültigen Stimmen gefunden' })
+    throw createError({ statusCode: 400, statusMessage: 'No valid votes found' })
   }
 
   const clientHash = buildClientHash(event)

server/api/service/updates.post.ts

@@ -17,15 +17,15 @@ export default defineEventHandler(async (event) => {
   const source = body.source?.trim() || 'landing-updates'
 
   if (!email) {
-    throw createError({ statusCode: 400, statusMessage: 'E-Mail wird benötigt' })
+    throw createError({ statusCode: 400, statusMessage: 'Email is required' })
   }
 
   if (!body.consentPrivacy) {
-    throw createError({ statusCode: 400, statusMessage: 'Bitte bestätige die Datenschutzerklärung' })
+    throw createError({ statusCode: 400, statusMessage: 'Please confirm the privacy policy' })
   }
 
   if (!body.consentMarketing) {
-    throw createError({ statusCode: 400, statusMessage: 'Wir benötigen deine Einwilligung für Produkt-Updates per E-Mail' })
+    throw createError({ statusCode: 400, statusMessage: 'We need your consent to email you product updates' })
   }
 
   const result = await registerUpdateSubscriber({
@@ -38,13 +38,13 @@ export default defineEventHandler(async (event) => {
 
   if (result.created) {
     const dataEntries = [
-      ['E-Mail', email],
+      ['Email', email],
       ['Name', name || null],
-      ['Quelle', source],
+      ['Source', source],
     ]
     await sendAdminNotification({
-      event: 'Neue Updates-Liste',
-      summary: `Neue Updates-Anmeldung: ${email}`,
+      event: 'New updates signup',
+      summary: `New updates signup: ${email}`,
       data: dataEntries,
     })
   }

server/api/service/waitlist.post.ts

@@ -22,11 +22,11 @@ export default defineEventHandler(async (event) => {
   const wantsProductUpdates = Boolean(body.wantsProductUpdates)
 
   if (!email) {
-    throw createError({ statusCode: 400, statusMessage: 'E-Mail wird benötigt' })
+    throw createError({ statusCode: 400, statusMessage: 'Email is required' })
   }
 
   if (!body.consentPrivacy || !body.consentTerms) {
-    throw createError({ statusCode: 400, statusMessage: 'Zustimmung zu AGB und Datenschutz ist erforderlich' })
+    throw createError({ statusCode: 400, statusMessage: 'Accepting the terms and privacy policy is required' })
   }
 
   const now = new Date()
@@ -57,20 +57,20 @@ export default defineEventHandler(async (event) => {
 
       if (!previouslyWantedUpdates && updateResult.created) {
         const dataEntries = [
-          ['E-Mail', email],
+          ['Email', email],
         ]
         if (name) {
           dataEntries.push(['Name', name])
         }
         if (notes) {
-          dataEntries.push(['Notizen', notes])
+          dataEntries.push(['Notes', notes])
         }
-        dataEntries.push(['Quelle', source])
-        dataEntries.push(['Opt-In', 'Produkt-Updates'])
+        dataEntries.push(['Source', source])
+        dataEntries.push(['Opt-in', 'Product updates'])
 
         await sendAdminNotification({
-          event: 'Neue Updates-Liste (via Warteliste)',
-          summary: `Produkt-Updates Opt-in (Warteliste): ${email}`,
+          event: 'New updates signup (waitlist)',
+          summary: `Product updates opt-in (waitlist): ${email}`,
           data: dataEntries,
         })
       }
@@ -106,20 +106,20 @@ export default defineEventHandler(async (event) => {
   }
 
   const dataEntries = [
-    ['E-Mail', email],
+    ['Email', email],
   ]
   if (name) {
     dataEntries.push(['Name', name])
   }
   if (notes) {
-    dataEntries.push(['Notizen', notes])
+    dataEntries.push(['Notes', notes])
   }
-  dataEntries.push(['Quelle', source])
-  dataEntries.push(['Opt-In', wantsProductUpdates ? 'Produkt-Updates' : 'Nur Warteliste'])
+  dataEntries.push(['Source', source])
+  dataEntries.push(['Opt-in', wantsProductUpdates ? 'Product updates' : 'Waitlist only'])
 
   await sendAdminNotification({
-    event: 'Neue Wartelisten-Anmeldung',
-    summary: `Neue Wartelisten-Anmeldung: ${email}`,
+    event: 'New waitlist signup',
+    summary: `New waitlist signup: ${email}`,
     data: dataEntries,
   })