Internationalization and Localization

node ace add @adonisjs/i18n

import app from '@adonisjs/core/services/app'
import { defineConfig, formatters, loaders } from '@adonisjs/i18n'

const i18nConfig = defineConfig({
  defaultLocale: 'en',
  formatter: formatters.icu(),

  loaders: [
    loaders.fs({
      location: app.languageFilesPath()
    })
  ],
})

export default i18nConfig

export default defineConfig({
  formatter: formatters.icu(),
  defaultLocale: 'en',
  fallbackLocales: {
    'de-CH': 'de',  // Swiss German falls back to German
    'fr-CH': 'fr',  // Swiss French falls back to French
    ca: 'es'        // Catalan falls back to Spanish
  }
})

export default defineConfig({
  formatter: formatters.icu(),
  defaultLocale: 'en',
  supportedLocales: ['en', 'fr', 'it']
})

resources
├── lang
│   ├── en
│   └── fr

resources
├── lang
│   ├── en        # English (base)
│   ├── en-us     # English (United States)
│   └── en-gb     # English (United Kingdom)

resources
├── lang
│   ├── en
│   │   └── messages.json
│   └── fr
│       └── messages.json

{
  "greeting": "Hello world"
}

{
  "greeting": "Bonjour le monde"
}

import i18nManager from '@adonisjs/i18n/services/main'

/**
 * Create I18n instances for specific locales
 */
const en = i18nManager.locale('en')
const fr = i18nManager.locale('fr')

import i18nManager from '@adonisjs/i18n/services/main'

const i18n = i18nManager.locale('en')
i18n.t('messages.greeting') // "Hello world"

import i18nManager from '@adonisjs/i18n/services/main'

const i18n = i18nManager.locale('fr')
i18n.t('messages.greeting') // "Bonjour le monde"

export default defineConfig({
  defaultLocale: 'en',
  fallbackLocales: {
    'de-CH': 'de',
    'fr-CH': 'fr'
  }
})

import i18nManager from '@adonisjs/i18n/services/main'

const swissGerman = i18nManager.locale('de-CH')
swissGerman.fallbackLocale // "de" (from fallbackLocales)

const swissFrench = i18nManager.locale('fr-CH')
swissFrench.fallbackLocale // "fr" (from fallbackLocales)

const english = i18nManager.locale('en')
english.fallbackLocale // "en" (uses defaultLocale)

import i18nManager from '@adonisjs/i18n/services/main'

const i18n = i18nManager.locale('en')
i18n.t('messages.hero_title')
// "translation missing: en, messages.hero_title"

import i18nManager from '@adonisjs/i18n/services/main'

const i18n = i18nManager.locale('en')
i18n.t('messages.hero_title', '')
// "" (empty string instead of error message)

import { defineConfig } from '@adonisjs/i18n'

export default defineConfig({
  defaultLocale: 'en',
  formatter: formatters.icu(),
  fallback: (identifier, locale) => {
    return '' // Return empty string for all missing translations
  },
})

import type { HttpContext } from '@adonisjs/core/http'

export default class PostsController {
  async store({ i18n, session, response }: HttpContext) {
    // Create post...
    
    session.flash('success', {
      message: i18n.t('post.created')
    })
    
    return response.redirect().back()
  }
}

<h1>{{ t('messages.heroTitle') }}</h1>

export default class DetectUserLocaleMiddleware {
  static {
    RequestValidator.messagesProvider = (ctx) => {
      return ctx.i18n.createMessagesProvider()
    }
  }
}

{
  "shared": {
    "fields": {
      "first_name": "first name"
    },
    "messages": {
      "required": "Enter {field}",
      "username.required": "Choose a username for your account",
      "email": "The email must be valid"
    }
  }
}

{
  "shared": {
    "fields": {
      "first_name": "Prénom"
    },
    "messages": {
      "required": "Remplisser le champ {field}",
      "username.required": "Choissisez un nom d'utilisateur pour votre compte",
      "email": "L'email doit être valide"
    }
  }
}

import { createJobValidator } from '#validators/jobs'
import i18nManager from '@adonisjs/i18n/services/main'

/**
 * Get an i18n instance for the desired locale
 */
const i18n = i18nManager.locale('fr')

await createJobValidator.validate(data, {
  /**
   * Register the messages provider manually
   */
  messagesProvider: i18n.createMessagesProvider()
})

{
  "greeting": "Hello { username }"
}

{{ t('messages.greeting', { username: 'Virk' }) }}
{{-- Output: Hello Virk --}}

{
  "greeting": "<p>Hello <strong>{ username }</strong></p>"
}

{{{ t('messages.greeting', { username: 'Virk' }) }}}

{
  "bagel_price": "The price of this bagel is {amount, number, ::currency/USD}"
}

{{ t('bagel_price', { amount: 2.49 }) }}
{{-- Output: The price of this bagel is $2.49 --}}

{
  "shipment_update": "Your package will arrive on {expectedDate, date, medium}"
}

{{ t('shipment_update', { expectedDate: luxonDateTime }) }}
{{-- Output: Your package will arrive on Oct 16, 2023 --}}

{
  "appointment": "You have an appointment today at {appointmentAt, time, ::h:m a}"
}

You have an appointment today at 2:48 PM

cart_summary: >
  You have {itemsCount, plural,
    =0 {no items}
    one {1 item}
    other {# items}
  } in your cart

{{ t('messages.cart_summary', { itemsCount: 1 }) }}
{{-- Output: You have 1 item in your cart --}}

{{ t('messages.cart_summary', { itemsCount: 1000 }) }}
{{-- Output: You have 1,000 items in your cart --}}

auto_reply: >
  {gender, select,
    male {He}
    female {She}
    other {They}
  } will respond shortly.

{{ t('messages.auto_reply', { gender: 'female' }) }}
{{-- Output: She will respond shortly. --}}

anniversary_greeting: >
  It's my {years, selectordinal,
    one {#st}
    two {#nd}
    few {#rd}
    other {#th}
  } anniversary

{{ t('messages.anniversary_greeting', { years: 2 }) }}
{{-- Output: It's my 2nd anniversary --}}

import i18nManager from '@adonisjs/i18n/services/main'

i18nManager
  .locale('en')
  .formatNumber(123456.789, {
    maximumSignificantDigits: 3
  })
// "123,000"

import i18nManager from '@adonisjs/i18n/services/main'

i18nManager
  .locale('en')
  .formatCurrency(200, {
    currency: 'USD'
  })
// "$200.00"

import i18nManager from '@adonisjs/i18n/services/main'
import { DateTime } from 'luxon'

i18nManager
  .locale('en')
  .formatDate(new Date(), {
    dateStyle: 'long'
  })
// "January 10, 2026"

i18nManager
  .locale('en')
  .formatDate(DateTime.local(), {
    dateStyle: 'long'
  })
// "January 10, 2026"

import i18nManager from '@adonisjs/i18n/services/main'

i18nManager
  .locale('en')
  .formatTime(new Date())
// "2:48:30 PM"

import { DateTime } from 'luxon'
import i18nManager from '@adonisjs/i18n/services/main'

const futureDate = DateTime.local().plus({ hours: 2 })

i18nManager
  .locale('en')
  .formatRelativeTime(futureDate, 'hours')
// "in 2 hours"

import { DateTime } from 'luxon'
import i18nManager from '@adonisjs/i18n/services/main'

const nearFuture = DateTime.local().plus({ hours: 2 })
i18nManager.locale('en').formatRelativeTime(nearFuture, 'auto')
// "in 2 hours"

const farFuture = DateTime.local().plus({ hours: 200 })
i18nManager.locale('en').formatRelativeTime(farFuture, 'auto')
// "in 8 days"

import i18nManager from '@adonisjs/i18n/services/main'

i18nManager.locale('en').formatPlural(0)  // "other"
i18nManager.locale('en').formatPlural(1)  // "one"
i18nManager.locale('en').formatPlural(2)  // "other"

import i18nManager from '@adonisjs/i18n/services/main'

i18nManager
  .locale('en')
  .formatList(['Me', 'myself', 'I'], { type: 'conjunction' })
// "Me, myself, and I"

i18nManager
  .locale('en')
  .formatList(['5 hours', '3 minutes'], { type: 'unit' })
// "5 hours, 3 minutes"

import i18nManager from '@adonisjs/i18n/services/main'

i18nManager
  .locale('en')
  .formatDisplayNames('INR', { type: 'currency' })
// "Indian Rupee"

i18nManager
  .locale('en')
  .formatDisplayNames('en-US', { type: 'language' })
// "American English"

mkdir -p .vscode
touch .vscode/i18n-ally-custom-framework.yml
touch .vscode/settings.json

{
  "i18n-ally.localesPaths": [
    "resources/lang"
  ],
  "i18n-ally.keystyle": "nested",
  "i18n-ally.namespace": true,
  "i18n-ally.editor.preferEditor": true,
  "i18n-ally.refactor.templates": [
    {
      "templates": [
        "{{ t('{key}'{args}) }}"
      ],
      "include": [
        "**/*.edge"
      ]
    }
  ]
}

languageIds:
  - edge
usageMatchRegex:
  - "[^\\w\\d]t\\(['\"`]({key})['\"`]"
sortKeys: true

import emitter from '@adonisjs/core/services/emitter'

emitter.on('i18n:missing:translation', function (event) {
  console.log(event.identifier)   // The translation key that was missing
  console.log(event.hasFallback)  // Whether a fallback was used
  console.log(event.locale)       // The locale that was requested
})

import i18nManager from '@adonisjs/i18n/services/main'

export default class AdminController {
  async refreshTranslations() {
    await i18nManager.reloadTranslations()
  }
}

import type {
  LoaderFactory,
  TranslationsLoaderContract,
} from '@adonisjs/i18n/types'

/**
 * Configuration options for the loader
 */
export type DbLoaderConfig = {
  connection: string
  tableName: string
}

/**
 * The loader implementation
 */
export class DbLoader implements TranslationsLoaderContract {
  constructor(public config: DbLoaderConfig) {}

  async load() {
    /**
     * Query your database here and return translations
     * grouped by locale with flattened keys
     */
    return {
      en: {
        'messages.greeting': 'Hello world',
        'messages.farewell': 'Goodbye',
      },
      fr: {
        'messages.greeting': 'Bonjour le monde',
        'messages.farewell': 'Au revoir',
      }
    }
  }
}

/**
 * Factory function to reference the loader in config
 */
export function dbLoader(config: DbLoaderConfig): LoaderFactory {
  return () => {
    return new DbLoader(config)
  }
}

import { defineConfig } from '@adonisjs/i18n'
import { dbLoader } from '#app/i18n/db_loader'

const i18nConfig = defineConfig({
  defaultLocale: 'en',
  formatter: formatters.icu(),
  loaders: [
    dbLoader({
      connection: 'pg',
      tableName: 'translations'
    })
  ]
})

export default i18nConfig

import type {
  FormatterFactory,
  TranslationsFormatterContract,
} from '@adonisjs/i18n/types'

/**
 * The formatter implementation
 */
export class FluentFormatter implements TranslationsFormatterContract {
  format(
    message: string,
    locale: string,
    data?: Record<string, any>
  ): string {
    /**
     * Process the message using your chosen format
     * and return the formatted string
     */
    return message // Your formatting logic here
  }
}

/**
 * Factory function to reference the formatter in config
 */
export function fluentFormatter(): FormatterFactory {
  return () => {
    return new FluentFormatter()
  }
}

import { defineConfig } from '@adonisjs/i18n'
import { fluentFormatter } from '#app/i18n/fluent_formatter'

const i18nConfig = defineConfig({
  defaultLocale: 'en',
  formatter: fluentFormatter()
})

export default i18nConfig