acrylblends 0.3.0 → 0.4.1

package/plugins/acryl-router/src/core/middleware/language/index.test.ts

@@ -0,0 +1,552 @@
+import { languageDetector } from './index.ts'
+import { App } from '../../app.ts'
+import { DEFAULT_OPTIONS, detectors, normalizeLanguage } from './language.ts'
+
+describe('languageDetector', () => {
+  const createTestApp = (options = {}) => {
+    const app = new App()
+
+    app.use('/*', languageDetector(options))
+
+    app.get('/*', (c) => c.text(c.get('language')))
+
+    return app
+  }
+
+  describe('Query Parameter Detection', () => {
+    it('should detect language from query parameter', async () => {
+      const app = createTestApp({
+        supportedLanguages: ['en', 'fr', 'es'],
+        fallbackLanguage: 'en',
+      })
+
+      const res = await app.request('/?lang=fr')
+      expect(await res.text()).toBe('fr')
+    })
+
+    it('should ignore unsupported languages in query', async () => {
+      const app = createTestApp({
+        supportedLanguages: ['en', 'fr'],
+        fallbackLanguage: 'en',
+      })
+
+      const res = await app.request('/?lang=de')
+      expect(await res.text()).toBe('en')
+    })
+  })
+
+  describe('Cookie Detection', () => {
+    it('should detect language from cookie', async () => {
+      const app = createTestApp({
+        supportedLanguages: ['en', 'fr'],
+        fallbackLanguage: 'en',
+      })
+
+      const res = await app.request('/', {
+        headers: {
+          cookie: 'language=fr',
+        },
+      })
+      expect(await res.text()).toBe('fr')
+    })
+
+    it('should cache detected language in cookie when enabled', async () => {
+      const app = createTestApp({
+        supportedLanguages: ['en', 'fr'],
+        fallbackLanguage: 'en',
+        caches: ['cookie'],
+      })
+
+      const res = await app.request('/?lang=fr')
+      expect(res.headers.get('set-cookie')).toContain('language=fr')
+    })
+  })
+
+  describe('Header Detection', () => {
+    it('should detect language from Accept-Language header', async () => {
+      const app = createTestApp({
+        supportedLanguages: ['en', 'fr', 'es'],
+        fallbackLanguage: 'en',
+      })
+
+      const res = await app.request('/', {
+        headers: {
+          'accept-language': 'fr-FR,fr;q=0.9,en;q=0.8',
+        },
+      })
+      expect(await res.text()).toBe('fr')
+    })
+
+    it('should fallback to language code when locale code is not in supportedLanguages', async () => {
+      const app = createTestApp({
+        supportedLanguages: ['en', 'ja'],
+        fallbackLanguage: 'en',
+        order: ['header'],
+      })
+
+      const res = await app.request('/', {
+        headers: {
+          'accept-language': 'ja-JP',
+        },
+      })
+      expect(await res.text()).toBe('ja')
+    })
+
+    it('should not detect a language explicitly rejected with q=0', async () => {
+      const app = createTestApp({
+        supportedLanguages: ['fr', 'en'],
+        fallbackLanguage: 'en',
+        order: ['header'],
+      })
+
+      const res = await app.request('/', {
+        headers: {
+          'accept-language': 'fr;q=0',
+        },
+      })
+      expect(await res.text()).toBe('en')
+    })
+
+    it('should skip q=0 languages before falling back to the default', async () => {
+      const app = createTestApp({
+        supportedLanguages: ['fr', 'en'],
+        fallbackLanguage: 'en',
+        order: ['header'],
+      })
+
+      const res = await app.request('/', {
+        headers: {
+          'accept-language': 'fr;q=0,de;q=0.8',
+        },
+      })
+      expect(await res.text()).toBe('en')
+    })
+
+    it('should continue to the next detector after a zero-quality language', async () => {
+      const app = createTestApp({
+        supportedLanguages: ['fr', 'en', 'ja'],
+        fallbackLanguage: 'en',
+        order: ['header', 'querystring'],
+      })
+
+      const res = await app.request('/?lang=ja', {
+        headers: { 'accept-language': 'fr;q=0' },
+      })
+      expect(await res.text()).toBe('ja')
+      expect(res.headers.get('set-cookie')).toContain('language=ja')
+    })
+
+    it('should match after multiple truncations', async () => {
+      const app = createTestApp({
+        supportedLanguages: ['zh-Hant', 'en'],
+        fallbackLanguage: 'en',
+        order: ['header'],
+      })
+
+      const res = await app.request('/', {
+        headers: {
+          'accept-language': 'zh-Hant-CN',
+        },
+      })
+      expect(await res.text()).toBe('zh-Hant')
+    })
+
+    it('should select the longest truncated match regardless of supported language order', async () => {
+      const app = createTestApp({
+        supportedLanguages: ['zh', 'zh-Hant'],
+        fallbackLanguage: 'zh',
+        order: ['header'],
+      })
+
+      const res = await app.request('/', {
+        headers: {
+          'accept-language': 'zh-Hant-CN',
+        },
+      })
+      expect(await res.text()).toBe('zh-Hant')
+    })
+
+    it('should fallback when truncation does not match any supported language', async () => {
+      const app = createTestApp({
+        supportedLanguages: ['en', 'ja'],
+        fallbackLanguage: 'en',
+        order: ['header'],
+      })
+
+      const res = await app.request('/', {
+        headers: {
+          'accept-language': 'ko-KR',
+        },
+      })
+      expect(await res.text()).toBe('en')
+    })
+
+    it('should prefer exact match over truncated match', async () => {
+      const app = createTestApp({
+        supportedLanguages: ['fr', 'fr-CA'],
+        fallbackLanguage: 'fr',
+        order: ['header'],
+      })
+
+      const res = await app.request('/', {
+        headers: {
+          'accept-language': 'fr-CA',
+        },
+      })
+      expect(await res.text()).toBe('fr-CA')
+    })
+
+    it('should handle case-insensitive truncation matching', async () => {
+      const app = createTestApp({
+        supportedLanguages: ['en', 'ja'],
+        fallbackLanguage: 'en',
+        order: ['header'],
+        ignoreCase: true,
+      })
+
+      const res = await app.request('/', {
+        headers: {
+          'accept-language': 'JA-JP',
+        },
+      })
+      expect(await res.text()).toBe('ja')
+    })
+
+    it('should handle malformed Accept-Language headers', async () => {
+      const app = createTestApp({
+        supportedLanguages: ['en', 'fr'],
+        fallbackLanguage: 'en',
+      })
+
+      const res = await app.request('/', {
+        headers: {
+          'accept-language': 'invalid;header;;format',
+        },
+      })
+      expect(await res.text()).toBe('en')
+    })
+
+    it('should handle invalid header lookup key gracefully', async () => {
+      const app = createTestApp({
+        order: ['header'],
+        lookupFromHeaderKey: 'accept\nlanguage',
+        supportedLanguages: ['en', 'fr'],
+        fallbackLanguage: 'en',
+      })
+
+      const res = await app.request('/', {
+        headers: {
+          'accept-language': 'fr',
+        },
+      })
+
+      expect(await res.text()).toBe('en')
+    })
+  })
+
+  describe('Language Normalization', () => {
+    it('should preserve the configured value for a case-insensitive truncated match', () => {
+      expect(
+        normalizeLanguage('zh-HANT-CN', {
+          ...DEFAULT_OPTIONS,
+          supportedLanguages: ['en', 'ZH-Hant'],
+        })
+      ).toBe('ZH-Hant')
+    })
+
+    it('should handle a large unsupported language tag', () => {
+      const unsupportedLanguage = 'x-'.repeat(30_000).slice(0, -1)
+
+      expect(
+        normalizeLanguage(unsupportedLanguage, {
+          ...DEFAULT_OPTIONS,
+          supportedLanguages: ['en', 'ja'],
+        })
+      ).toBeUndefined()
+    })
+  })
+
+  describe('Path Detection', () => {
+    it('should detect language from path', async () => {
+      const app = createTestApp({
+        order: ['path'],
+        supportedLanguages: ['en', 'fr'],
+        fallbackLanguage: 'en',
+        lookupFromPathIndex: 0,
+      })
+
+      const res = await app.request('/fr/page')
+      expect(await res.text()).toBe('fr')
+    })
+
+    it('should handle invalid path index gracefully', async () => {
+      const app = createTestApp({
+        order: ['path'],
+        supportedLanguages: ['en', 'fr'],
+        fallbackLanguage: 'en',
+        lookupFromPathIndex: 99,
+      })
+
+      const res = await app.request('/fr/page')
+      expect(await res.text()).toBe('en')
+    })
+
+    it('should detect language from original URL when getPath modifies the path', async () => {
+      const app = new App({
+        getPath: (req) => {
+          const url = new URL(req.url)
+          let pathname = url.pathname
+          // Remove language prefix /fr/
+          if (pathname.startsWith('/fr/')) {
+            pathname = pathname.replace('/fr/', '/')
+          }
+          return pathname
+        },
+      })
+
+      app.use(
+        '*',
+        languageDetector({
+          order: ['path'],
+          supportedLanguages: ['en', 'fr'],
+          fallbackLanguage: 'en',
+          lookupFromPathIndex: 0,
+        })
+      )
+
+      app.get('/home', (c) => c.text(c.get('language')))
+
+      const res = await app.request('/fr/home')
+      expect(await res.text()).toBe('fr')
+    })
+  })
+
+  describe('Detection Order', () => {
+    it('should respect detection order', async () => {
+      const app = createTestApp({
+        order: ['cookie', 'querystring'],
+        supportedLanguages: ['en', 'fr', 'es'],
+        fallbackLanguage: 'en',
+      })
+
+      const res = await app.request('/?lang=fr', {
+        headers: {
+          cookie: 'language=es',
+        },
+      })
+
+      // Since cookie is first in order, it should use 'es'
+      expect(await res.text()).toBe('es')
+    })
+
+    it('should fall back to next detector if first fails', async () => {
+      const app = createTestApp({
+        order: ['cookie', 'querystring'],
+        supportedLanguages: ['en', 'fr'],
+        fallbackLanguage: 'en',
+      })
+
+      const res = await app.request('/?lang=fr') // No cookie
+      expect(await res.text()).toBe('fr') // Should use querystring
+    })
+  })
+
+  describe('Language Conversion', () => {
+    it('should apply language conversion function', async () => {
+      const app = createTestApp({
+        supportedLanguages: ['en', 'fr'],
+        fallbackLanguage: 'en',
+        convertDetectedLanguage: (lang: string) => lang.split('-')[0],
+      })
+
+      const res = await app.request('/?lang=fr-FR')
+      expect(await res.text()).toBe('fr')
+    })
+
+    it('should handle case sensitivity according to options', async () => {
+      const app = createTestApp({
+        supportedLanguages: ['en', 'fr'],
+        fallbackLanguage: 'en',
+        ignoreCase: false,
+      })
+
+      const res = await app.request('/?lang=FR')
+      expect(await res.text()).toBe('en') // Falls back because case doesn't match
+    })
+  })
+
+  describe('Error Handling', () => {
+    it('should fall back to default language on error', async () => {
+      const app = createTestApp({
+        supportedLanguages: ['en', 'fr'],
+        fallbackLanguage: 'en',
+      })
+
+      const detector = vi.spyOn(detectors, 'querystring').mockImplementation(() => {
+        throw new Error('Simulated error')
+      })
+
+      const res = await app.request('/?lang=fr')
+      expect(await res.text()).toBe('en')
+
+      detector.mockRestore()
+    })
+
+    it('should handle missing cookie values gracefully', async () => {
+      const app = createTestApp({
+        supportedLanguages: ['en', 'fr'],
+        fallbackLanguage: 'en',
+        order: ['cookie'],
+      })
+
+      const res = await app.request('/')
+      expect(await res.text()).toBe('en')
+    })
+
+    it('should handle errors in convertDetectedLanguage function', async () => {
+      const app = createTestApp({
+        supportedLanguages: ['en', 'fr'],
+        fallbackLanguage: 'en',
+        convertDetectedLanguage: (lang: string) => {
+          if (lang === 'fr') {
+            throw new Error('Simulated error in convertDetectedLanguage')
+          }
+          return lang
+        },
+      })
+
+      const res = await app.request('/?lang=fr')
+      expect(await res.text()).toBe('en')
+    })
+  })
+
+  describe('Configuration Validation', () => {
+    it('should throw if fallback language is not in supported languages', () => {
+      expect(() => {
+        createTestApp({
+          supportedLanguages: ['fr', 'es'],
+          fallbackLanguage: 'en',
+        })
+      }).toThrow()
+    })
+
+    it('should throw if path index is negative', () => {
+      expect(() => {
+        createTestApp({
+          lookupFromPathIndex: -1,
+        })
+      }).toThrow()
+    })
+
+    it('should handle empty supported languages list', () => {
+      expect(() => {
+        createTestApp({
+          supportedLanguages: [],
+        })
+      }).toThrow()
+    })
+
+    it('should handle invalid order option', async () => {
+      expect(() => {
+        createTestApp({
+          order: ['invalidDetector' as any],
+        })
+      }).toThrow()
+    })
+
+    it('should handle early return for caches', async () => {
+      const app = createTestApp({
+        caches: ['test'],
+        supportedLanguages: ['en'],
+      })
+
+      const res = await app.request('/?lang=en')
+
+      expect(await res.text()).toBe('en')
+      expect(res.headers.get('set-cookie')).toBeNull()
+    })
+  })
+
+  describe('Debug Mode', () => {
+    it('should log errors in debug mode', async () => {
+      const consoleErrorSpy = vi.spyOn(console, 'error')
+
+      const app = createTestApp({
+        supportedLanguages: ['en', 'fr'],
+        fallbackLanguage: 'en',
+        debug: true,
+      })
+
+      const detector = vi.spyOn(detectors, 'querystring').mockImplementation(() => {
+        throw new Error('Simulated error')
+      })
+
+      await app.request('/?lang=fr')
+
+      expect(consoleErrorSpy).toHaveBeenCalledWith(
+        'Error in querystring detector:',
+        expect.any(Error)
+      )
+
+      detector.mockRestore()
+      consoleErrorSpy.mockRestore()
+    })
+
+    // The log test remains unchanged
+    it('should log debug information when enabled', async () => {
+      const consoleSpy = vi.spyOn(console, 'log')
+
+      const app = createTestApp({
+        supportedLanguages: ['en', 'fr'],
+        fallbackLanguage: 'en',
+        debug: true,
+      })
+
+      await app.request('/?lang=fr')
+
+      expect(consoleSpy).toHaveBeenCalledWith(
+        expect.stringContaining('Language detected from querystring')
+      )
+
+      consoleSpy.mockRestore()
+    })
+
+    it('should handle cookie cache errors in debug mode', async () => {
+      const consoleErrorSpy = vi.spyOn(console, 'error')
+
+      const app = createTestApp({
+        supportedLanguages: ['en', 'fr'],
+        fallbackLanguage: 'en',
+        caches: ['cookie'],
+        lookupCookie: 'bad cookie',
+        debug: true,
+      })
+
+      const res = await app.request('/?lang=fr')
+
+      expect(await res.text()).toBe('fr')
+      expect(consoleErrorSpy).toHaveBeenCalledWith('Failed to cache language:', expect.any(Error))
+
+      consoleErrorSpy.mockRestore()
+    })
+
+    it('should silently handle cookie cache errors when debug mode is disabled', async () => {
+      const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
+
+      const app = createTestApp({
+        supportedLanguages: ['en', 'fr'],
+        fallbackLanguage: 'en',
+        caches: ['cookie'],
+        lookupCookie: 'bad cookie',
+        debug: false,
+      })
+
+      const res = await app.request('/?lang=fr')
+
+      expect(await res.text()).toBe('fr')
+      expect(consoleErrorSpy).not.toHaveBeenCalled()
+
+      consoleErrorSpy.mockRestore()
+    })
+  })
+})

package/plugins/acryl-router/src/core/middleware/language/index.ts

@@ -0,0 +1,12 @@
+import type { LanguageVariables, DetectorOptions, DetectorType, CacheType } from './language.ts'
+export type { LanguageVariables, DetectorOptions, DetectorType, CacheType }
+export {
+  languageDetector,
+  detectFromCookie,
+  detectFromHeader,
+  detectFromPath,
+  detectFromQuery,
+} from './language.ts'
+declare module '../../context.ts' {
+  interface ContextVariableMap extends LanguageVariables {}
+}