i18n-dashboard 0.1.0

package/server/utils/scanner.uti.ts

@@ -0,0 +1,307 @@
+import { readdirSync, readFileSync, statSync, existsSync } from 'fs'
+import { resolve, extname, relative, basename } from 'path'
+
+import type { DetectedLanguage, KeyUsage, ScanResult } from '../interfaces/scanner.interface'
+import { AVAILABLE_LOCALES_PATTERN, LOCALE_ARRAY_PATTERN, LOCALE_SINGLE_PATTERN } from '../consts/scanner.const'
+import { LANGUAGES } from '../../consts/languages.const'
+
+function langName(code: string): string {
+  return LANGUAGES[code.toLowerCase()] || code.toUpperCase()
+}
+
+function extractCodesFromArray(str: string): string[] {
+  return [...str.matchAll(/['"`]([a-z]{2}(?:-[a-z]{2,4})?)[`'"]/gi)].map((m) => m[1].toLowerCase())
+}
+
+/**
+ * Detect languages from:
+ * 1. JSON files in the locales directory
+ * 2. i18n config files in the project (i18n.js, i18n.ts, nuxt.config.ts, etc.)
+ */
+export function detectLanguages(options: {
+  projectRoot: string
+  localesPath: string
+}): DetectedLanguage[] {
+  const { projectRoot, localesPath } = options
+  const found = new Map<string, DetectedLanguage>()
+
+  // ── 1. Locale JSON files ──────────────────────────────────────────────
+  const absLocalesPath = resolve(projectRoot, localesPath)
+  if (existsSync(absLocalesPath)) {
+    try {
+      const files = readdirSync(absLocalesPath)
+      for (const file of files) {
+        if (extname(file) !== '.json') continue
+        const code = basename(file, '.json').toLowerCase()
+        if (/^[a-z]{2}(-[a-z]{2,4})?$/.test(code)) {
+          found.set(code, { code, name: langName(code), source: 'locales-dir' })
+        }
+      }
+    } catch { /* ignore */ }
+  }
+
+  // ── 2. Scan config files for locale declarations ───────────────────────
+  const configFileNames = [
+    'i18n.js', 'i18n.ts', 'i18n.mjs', 'i18n.mts',
+    'i18n/index.js', 'i18n/index.ts',
+    'nuxt.config.js', 'nuxt.config.ts', 'nuxt.config.mjs',
+    'vite.config.js', 'vite.config.ts',
+    'vue.config.js', 'vue.config.ts',
+    'src/i18n.js', 'src/i18n.ts', 'src/i18n/index.js', 'src/i18n/index.ts',
+    'src/plugins/i18n.js', 'src/plugins/i18n.ts',
+  ]
+
+  for (const relPath of configFileNames) {
+    const absPath = resolve(projectRoot, relPath)
+    if (!existsSync(absPath)) continue
+
+    let content: string
+    try { content = readFileSync(absPath, 'utf-8') } catch { continue }
+
+    // locales: ['fr', 'en']
+    for (const match of content.matchAll(LOCALE_ARRAY_PATTERN)) {
+      for (const code of extractCodesFromArray(match[1])) {
+        if (!found.has(code)) found.set(code, { code, name: langName(code), source: 'config-file' })
+      }
+    }
+
+    // locales: [{ code: 'fr' }, ...]
+    const objPattern = /locales\s*:\s*\[[\s\S]*?code\s*:\s*['"]([a-z]{2}(?:-[a-z]{2,4})?)['"]/gi
+    for (const match of content.matchAll(objPattern)) {
+      const code = match[1].toLowerCase()
+      if (!found.has(code)) found.set(code, { code, name: langName(code), source: 'config-file' })
+    }
+
+    // availableLocales: ['fr', 'en']
+    for (const match of content.matchAll(AVAILABLE_LOCALES_PATTERN)) {
+      for (const code of extractCodesFromArray(match[1])) {
+        if (!found.has(code)) found.set(code, { code, name: langName(code), source: 'config-file' })
+      }
+    }
+
+    // locale: 'fr', defaultLocale: 'fr', fallbackLocale: 'en'
+    for (const match of content.matchAll(LOCALE_SINGLE_PATTERN)) {
+      const code = match[1].toLowerCase()
+      if (!found.has(code)) found.set(code, { code, name: langName(code), source: 'config-file' })
+    }
+  }
+
+  return [...found.values()]
+}
+
+// All vue-i18n function call patterns
+const PATTERNS: Array<{ regex: RegExp; fn: string }> = [
+  // Template: $t('key'), $t("key"), $t(`key`)
+  { regex: /\$t\s*\(\s*['"`]([^'"`\n]+)['"`]/g, fn: '$t' },
+  // Template: $tc('key'), $te('key'), $tm('key')
+  { regex: /\$tc\s*\(\s*['"`]([^'"`\n]+)['"`]/g, fn: '$tc' },
+  { regex: /\$te\s*\(\s*['"`]([^'"`\n]+)['"`]/g, fn: '$te' },
+  { regex: /\$tm\s*\(\s*['"`]([^'"`\n]+)['"`]/g, fn: '$tm' },
+  // i18n.t(), i18n.global.t()
+  { regex: /i18n(?:\.global)?\.t\s*\(\s*['"`]([^'"`\n]+)['"`]/g, fn: 'i18n.t' },
+  { regex: /i18n(?:\.global)?\.tc\s*\(\s*['"`]([^'"`\n]+)['"`]/g, fn: 'i18n.tc' },
+  // <i18n-t keypath="key"> component
+  { regex: /keypath\s*=\s*['"]([^'"]+)['"]/g, fn: 'i18n-t' },
+  // v-t directive: v-t="'key'" or v-t='"key"'
+  { regex: /v-t\s*=\s*"'([^']+)'"/g, fn: 'v-t' },
+  { regex: /v-t\s*=\s*'"([^"]+)"'/g, fn: 'v-t' },
+  { regex: /v-t\s*=\s*'([^']+)'/g, fn: 'v-t' },
+]
+
+// Pattern to detect useI18n() in a file — to allow t() scanning
+const USE_I18N_PATTERN = /useI18n\s*\(/
+// Pattern for t() only when useI18n is present
+const T_FUNCTION_PATTERN = /(?<![.$\w])t\s*\(\s*['"`]([^'"`\n]+)['"`]/g
+const TC_FUNCTION_PATTERN = /(?<![.$\w])tc\s*\(\s*['"`]([^'"`\n]+)['"`]/g
+const TE_FUNCTION_PATTERN = /(?<![.$\w])te\s*\(\s*['"`]([^'"`\n]+)['"`]/g
+const TM_FUNCTION_PATTERN = /(?<![.$\w])tm\s*\(\s*['"`]([^'"`\n]+)['"`]/g
+
+/**
+ * Parse an <i18n> custom block from a .vue SFC and extract all keys
+ */
+function extractI18nBlock(content: string, filePath: string): KeyUsage[] {
+  const usages: KeyUsage[] = []
+  const i18nBlockRegex = /<i18n(?:\s[^>]*)?>[\s\S]*?<\/i18n>/g
+  const blockMatch = i18nBlockRegex.exec(content)
+
+  if (!blockMatch) return usages
+
+  const block = blockMatch[0]
+  // Get the line number of the block
+  const linesBefore = content.slice(0, blockMatch.index).split('\n').length
+
+  try {
+    // Extract JSON content between tags
+    const jsonMatch = block.match(/<i18n(?:\s[^>]*)?>[\s\S]*?(\{[\s\S]+\})\s*<\/i18n>/)
+    if (!jsonMatch) return usages
+
+    const json = JSON.parse(jsonMatch[1])
+
+    // Keys may be nested under locale codes: { "en": { "key": "val" } }
+    // or directly: { "key": "val" }
+    // Detect by checking if top-level values are objects (locale-keyed)
+    const firstVal = Object.values(json)[0]
+    const messages = (firstVal && typeof firstVal === 'object' && !Array.isArray(firstVal))
+      ? firstVal as Record<string, any>
+      : json
+
+    function extractKeys(obj: Record<string, any>, prefix = ''): void {
+      for (const [k, v] of Object.entries(obj)) {
+        const key = prefix ? `${prefix}.${k}` : k
+        if (v && typeof v === 'object' && !Array.isArray(v)) {
+          extractKeys(v, key)
+        } else {
+          usages.push({ key, filePath, lineNumber: linesBefore, detectedFunction: 'i18n-block' })
+        }
+      }
+    }
+
+    extractKeys(messages)
+  } catch {
+    // Ignore parse errors on malformed blocks
+  }
+
+  return usages
+}
+
+/**
+ * Extract all vue-i18n key usages from a single file
+ */
+function scanFile(filePath: string, content: string): KeyUsage[] {
+  const usages: KeyUsage[] = []
+  const lines = content.split('\n')
+  const hasUseI18n = USE_I18N_PATTERN.test(content)
+
+  function getLineNumber(index: number): number {
+    return content.slice(0, index).split('\n').length
+  }
+
+  // Apply all standard patterns
+  for (const { regex, fn } of PATTERNS) {
+    regex.lastIndex = 0
+    let match: RegExpExecArray | null
+    while ((match = regex.exec(content)) !== null) {
+      const key = match[1].trim()
+      if (key && !key.includes('${') && !key.includes('`')) {
+        usages.push({
+          key,
+          filePath,
+          lineNumber: getLineNumber(match.index),
+          detectedFunction: fn,
+        })
+      }
+    }
+  }
+
+  // t(), tc(), te(), tm() — only if useI18n is used in the file
+  if (hasUseI18n) {
+    const scriptPatterns = [
+      { regex: T_FUNCTION_PATTERN, fn: 't' },
+      { regex: TC_FUNCTION_PATTERN, fn: 'tc' },
+      { regex: TE_FUNCTION_PATTERN, fn: 'te' },
+      { regex: TM_FUNCTION_PATTERN, fn: 'tm' },
+    ]
+    for (const { regex, fn } of scriptPatterns) {
+      regex.lastIndex = 0
+      let match: RegExpExecArray | null
+      while ((match = regex.exec(content)) !== null) {
+        const key = match[1].trim()
+        if (key && !key.includes('${') && !key.includes('`')) {
+          usages.push({
+            key,
+            filePath,
+            lineNumber: getLineNumber(match.index),
+            detectedFunction: fn,
+          })
+        }
+      }
+    }
+  }
+
+  // <i18n> blocks in .vue files
+  if (filePath.endsWith('.vue')) {
+    usages.push(...extractI18nBlock(content, filePath))
+  }
+
+  return usages
+}
+
+/**
+ * Collect all scannable files recursively
+ */
+function collectFiles(dir: string, excludeDirs: string[], extensions: string[]): string[] {
+  const files: string[] = []
+
+  let entries: string[]
+  try {
+    entries = readdirSync(dir)
+  } catch {
+    return files
+  }
+
+  for (const entry of entries) {
+    const fullPath = resolve(dir, entry)
+
+    // Skip excluded directories
+    if (excludeDirs.some((ex) => entry === ex || fullPath.includes(`/${ex}/`))) continue
+
+    try {
+      const stat = statSync(fullPath)
+      if (stat.isDirectory()) {
+        files.push(...collectFiles(fullPath, excludeDirs, extensions))
+      } else if (extensions.includes(extname(entry))) {
+        files.push(fullPath)
+      }
+    } catch {
+      // Skip unreadable files
+    }
+  }
+
+  return files
+}
+
+/**
+ * Main scanner — scans the project for vue-i18n key usages
+ */
+export function scanProject(options: {
+  projectRoot: string
+  excludeDirs?: string[]
+  extensions?: string[]
+}): ScanResult {
+  const {
+    projectRoot,
+    excludeDirs = ['node_modules', 'dist', '.nuxt', '.output', '.git', 'coverage'],
+    extensions = ['.vue', '.ts', '.js', '.mts', '.mjs'],
+  } = options
+
+  const usages: KeyUsage[] = []
+  const errors: string[] = []
+
+  const files = collectFiles(projectRoot, excludeDirs, extensions)
+
+  for (const filePath of files) {
+    try {
+      const content = readFileSync(filePath, 'utf-8')
+      const relPath = relative(projectRoot, filePath)
+      const fileUsages = scanFile(relPath, content)
+      usages.push(...fileUsages)
+    } catch (e: any) {
+      errors.push(`${filePath}: ${e.message}`)
+    }
+  }
+
+  // Deduplicate by key+file+line
+  const seen = new Set<string>()
+  const deduped = usages.filter((u) => {
+    const sig = `${u.key}||${u.filePath}||${u.lineNumber}||${u.detectedFunction}`
+    if (seen.has(sig)) return false
+    seen.add(sig)
+    return true
+  })
+
+  return {
+    usages: deduped,
+    scannedFiles: files.map((f) => relative(projectRoot, f)),
+    errors,
+  }
+}

package/server/utils/translation-job.util.ts

@@ -0,0 +1,142 @@
+import { translate } from '@vitalets/google-translate-api'
+import type { Knex } from 'knex'
+
+import { JobStatus, JOB_BATCH_SIZE, JOB_BATCH_DELAY_MS } from '../consts/translation-job.const'
+import type { TranslationJob } from '../interfaces/translation-job.interface'
+
+// ── In-memory job store ───────────────────────────────────────────────────────
+const _jobs = new Map<string, TranslationJob>()
+
+export function createJob(projectId: number, languageCode: string, languageName: string): TranslationJob {
+  const id = `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`
+  const job: TranslationJob = {
+    id,
+    status: JobStatus.RUNNING,
+    projectId,
+    languageCode,
+    languageName,
+    total: 0,
+    done: 0,
+    errors: 0,
+    startedAt: Date.now(),
+  }
+  _jobs.set(id, job)
+  return job
+}
+
+export function getJob(id: string): TranslationJob | undefined {
+  return _jobs.get(id)
+}
+
+// Clean up finished jobs after 10 minutes
+function scheduleCleanup(id: string) {
+  setTimeout(() => _jobs.delete(id), 10 * 60 * 1000)
+}
+
+// ── Main runner ───────────────────────────────────────────────────────────────
+export async function runTranslationJob(db: Knex, job: TranslationJob): Promise<void> {
+  try {
+    // Find source language (default lang of the project)
+    const sourceLang = await db('languages')
+      .where({ project_id: job.projectId, is_default: true })
+      .first()
+      ?? await db('languages')
+        .where({ project_id: job.projectId })
+        .whereNot({ code: job.languageCode })
+        .first()
+
+    if (!sourceLang) {
+      job.status = JobStatus.ERROR
+      scheduleCleanup(job.id)
+      return
+    }
+
+    // Get all source translations (keys that have a value in source language)
+    const sourceTranslations = await db('translation_keys as tk')
+      .join('translations as t', function () {
+        this.on('t.key_id', '=', 'tk.id')
+          .andOn('t.language_code', '=', db.raw('?', [sourceLang.code]))
+      })
+      .where('tk.project_id', job.projectId)
+      .whereNotNull('t.value')
+      .where('t.value', '!=', '')
+      .select('tk.id as key_id', 't.value as source_value')
+
+    if (!sourceTranslations.length) {
+      job.status = JobStatus.DONE
+      scheduleCleanup(job.id)
+      return
+    }
+
+    // Find which keys already have a translation in target language
+    const existingKeyIds = new Set(
+      (await db('translations')
+        .whereIn('key_id', sourceTranslations.map((r: any) => r.key_id))
+        .where('language_code', job.languageCode)
+        .whereNotNull('value')
+        .where('value', '!=', '')
+        .select('key_id')
+      ).map((r: any) => r.key_id),
+    )
+
+    const toTranslate = sourceTranslations.filter((r: any) => !existingKeyIds.has(r.key_id))
+    job.total = toTranslate.length
+
+    if (!toTranslate.length) {
+      job.status = JobStatus.DONE
+      scheduleCleanup(job.id)
+      return
+    }
+
+    const SEPARATOR = ' ||| '
+
+    for (let i = 0; i < toTranslate.length; i += JOB_BATCH_SIZE) {
+      const chunk = toTranslate.slice(i, i + JOB_BATCH_SIZE)
+      const combined = chunk.map((r: any) => r.source_value).join(SEPARATOR)
+
+      try {
+        const result = await translate(combined, { from: sourceLang.code, to: job.languageCode })
+        const translatedTexts = result.text.split(SEPARATOR)
+
+        for (let j = 0; j < chunk.length; j++) {
+          const value = (translatedTexts[j] || '').trim()
+          if (!value) continue
+
+          const existing = await db('translations')
+            .where({ key_id: chunk[j].key_id, language_code: job.languageCode })
+            .first()
+
+          if (existing) {
+            if (!existing.value) {
+              await db('translations').where({ id: existing.id })
+                .update({ value, status: 'draft', updated_at: db.fn.now() })
+            }
+          } else {
+            await db('translations').insert({
+              key_id: chunk[j].key_id,
+              language_code: job.languageCode,
+              value,
+              status: 'draft',
+            })
+          }
+          job.done++
+        }
+      } catch (e: any) {
+        console.error(`[TranslationJob] Batch failed (${job.languageCode}):`, e.message)
+        job.errors += chunk.length
+        job.done += chunk.length
+      }
+
+      if (i + JOB_BATCH_SIZE < toTranslate.length) {
+        await new Promise(r => setTimeout(r, JOB_BATCH_DELAY_MS))
+      }
+    }
+
+    job.status = JobStatus.DONE
+  } catch (e: any) {
+    console.error(`[TranslationJob] Fatal error:`, e.message)
+    job.status = JobStatus.ERROR
+  } finally {
+    scheduleCleanup(job.id)
+  }
+}

package/services/auth.service.ts

@@ -0,0 +1,31 @@
+import { BaseService } from './base.service'
+import type { AuthUser } from '../composables/useAuth'
+
+class AuthService extends BaseService {
+  async login(email: string, password: string): Promise<AuthUser> {
+    return this.post<AuthUser>('/api/auth/login', {
+      body: { email, password },
+      skipErrorToast: true, // login errors are handled by the page
+    })
+  }
+
+  async logout(): Promise<void> {
+    return this.post('/api/auth/logout', { skipDedup: true })
+  }
+
+  async me(): Promise<AuthUser | null> {
+    return this.get<AuthUser | null>('/api/auth/me', { skipErrorToast: true })
+  }
+
+  async changePassword(currentPassword: string, newPassword: string): Promise<void> {
+    return this.put('/api/auth/password', {
+      body: { current_password: currentPassword, new_password: newPassword },
+    })
+  }
+
+  async updateMe(data: { name?: string; email?: string }): Promise<AuthUser> {
+    return this.put<AuthUser>('/api/auth/me', { body: data })
+  }
+}
+
+export const authService = new AuthService()

package/services/base.service.ts

@@ -0,0 +1,140 @@
+import type { RequestConfig, RequestContext, ServiceHooks } from '../interfaces/commons.interface'
+import type { Method } from '../types/commons.type'
+import { METHODS } from '../enums/commons.enum'
+
+// Deduplication registry shared across all service instances
+const _inFlight = new Map<string, Promise<any>>()
+
+// Refresh lock — prevents concurrent refresh attempts
+let _refreshing: Promise<boolean> | null = null
+
+export abstract class BaseService {
+  // Per-instance active request counter → drives `loading`
+  private _activeCount = 0
+  readonly loading = ref(false)
+
+  // Override in subclass to add lifecycle hooks
+  protected hooks: ServiceHooks = {}
+
+  // ── Internal helpers ────────────────────────────────────────────────────────
+
+  private _setLoading(delta: 1 | -1) {
+    this._activeCount = Math.max(0, this._activeCount + delta)
+    this.loading.value = this._activeCount > 0
+  }
+
+  private _dedupKey(method: Method, path: string, query?: Record<string, any>): string {
+    const q = query ? `:${JSON.stringify(query)}` : ''
+    return `${method}:${path}${q}`
+  }
+
+  private async _doFetch<T>(method: Method, path: string, config: RequestConfig): Promise<T> {
+    return $fetch<T>(path, {
+      method,
+      query: config.query,
+      body: config.body,
+      headers: config.headers,
+    })
+  }
+
+  private async _tryRefresh(): Promise<boolean> {
+    if (_refreshing) return _refreshing
+    _refreshing = $fetch('/api/auth/me')
+      .then(() => true)
+      .catch(() => false)
+      .finally(() => { _refreshing = null })
+    return _refreshing
+  }
+
+  private async _handleAuthFailure(): Promise<void> {
+    try { await $fetch('/api/auth/logout', { method: 'POST' }) } catch {}
+    try {
+      await useNuxtApp().runWithContext(() => navigateTo('/login', { replace: true }))
+    } catch {}
+  }
+
+  // ── Core request ────────────────────────────────────────────────────────────
+
+  private async _request<T>(method: Method, path: string, config: RequestConfig = {}): Promise<T> {
+    const dedupKey = config.skipDedup ? null : this._dedupKey(method, path, config.query)
+
+    // Return existing in-flight promise for the same key
+    if (dedupKey && _inFlight.has(dedupKey)) {
+      return _inFlight.get(dedupKey) as Promise<T>
+    }
+
+    const ctx: RequestContext = { method, path, config }
+
+    const execute = async (): Promise<T> => {
+      this._setLoading(1)
+      try {
+        await this.hooks.beforeRequest?.(ctx)
+
+        let response: T
+        try {
+          response = await this._doFetch<T>(method, path, config)
+        }
+        catch (error: any) {
+          const status = error?.status ?? error?.statusCode
+          if (status === 401) {
+            const sessionStillValid = await this._tryRefresh()
+            if (sessionStillValid) {
+              // Retry once after successful session re-validation
+              response = await this._doFetch<T>(method, path, config)
+            }
+            else {
+              await this._handleAuthFailure()
+              throw new Error('Session expirée. Veuillez vous reconnecter.')
+            }
+          }
+          else {
+            throw error
+          }
+        }
+
+        await this.hooks.afterRequest?.(ctx, response!)
+        return response!
+      }
+      catch (error: any) {
+        await this.hooks.onError?.(ctx, error)
+
+        const message = error?.data?.message ?? error?.message ?? 'Une erreur est survenue'
+        if (!config.skipErrorToast) {
+          try { useToast().add({ title: 'Erreur', description: message, color: 'error' }) }
+          catch {}
+        }
+        throw new Error(message)
+      }
+      finally {
+        this._setLoading(-1)
+        if (dedupKey) _inFlight.delete(dedupKey)
+      }
+    }
+
+    const promise = execute()
+    if (dedupKey) _inFlight.set(dedupKey, promise)
+    return promise
+  }
+
+  // ── Public HTTP methods ─────────────────────────────────────────────────────
+
+  protected get<T = void>(path: string, config?: RequestConfig): Promise<T> {
+    return this._request<T>(METHODS.GET, path, config)
+  }
+
+  protected post<T = void>(path: string, config?: RequestConfig): Promise<T> {
+    return this._request<T>(METHODS.POST, path, config)
+  }
+
+  protected put<T = void>(path: string, config?: RequestConfig): Promise<T> {
+    return this._request<T>(METHODS.PUT, path, config)
+  }
+
+  protected patch<T = void>(path: string, config?: RequestConfig): Promise<T> {
+    return this._request<T>(METHODS.PATCH, path, config)
+  }
+
+  protected delete<T = void>(path: string, config?: RequestConfig): Promise<T> {
+    return this._request<T>(METHODS.DELETE, path, config)
+  }
+}

package/services/job.service.ts

@@ -0,0 +1,10 @@
+import { BaseService } from './base.service'
+import type { JobStatus } from '../interfaces/job.interface'
+
+class JobService extends BaseService {
+  async getJob(jobId: string): Promise<JobStatus> {
+    return this.get<JobStatus>(`/api/translations/job/${jobId}`)
+  }
+}
+
+export const jobService = new JobService()

package/services/key.service.ts

@@ -0,0 +1,26 @@
+import { BaseService } from './base.service'
+import type { KeyItem, KeysQuery, KeysResponse } from '../interfaces/key.interface'
+
+class KeyService extends BaseService {
+  async getKeys(query: KeysQuery): Promise<KeysResponse> {
+    return this.get<KeysResponse>('/api/keys', { query })
+  }
+
+  async getKey(id: number | string): Promise<KeyItem> {
+    return this.get<KeyItem>(`/api/keys/${id}`)
+  }
+
+  async createKey(data: { project_id: number; key: string; description?: string }): Promise<KeyItem> {
+    return this.post<KeyItem>('/api/keys', { body: data, skipDedup: true })
+  }
+
+  async updateKey(id: number | string, data: { description?: string | null }): Promise<void> {
+    return this.patch(`/api/keys/${id}`, { body: data })
+  }
+
+  async deleteKey(id: number | string): Promise<void> {
+    return this.delete(`/api/keys/${id}`)
+  }
+}
+
+export const keyService = new KeyService()

package/services/language.service.ts

@@ -0,0 +1,26 @@
+import { BaseService } from './base.service'
+import type { CreateLanguagePayload, LanguageItem } from '../interfaces/languages.interface'
+
+class LanguageService extends BaseService {
+  async getLanguages(projectId?: number): Promise<LanguageItem[]> {
+    if (!projectId) return []
+    return this.get<LanguageItem[]>('/api/languages', { query: { project_id: projectId } })
+  }
+
+  async create(data: CreateLanguagePayload): Promise<void> {
+    return this.post('/api/languages', { body: data, skipDedup: true })
+  }
+
+  async setDefault(lang: LanguageItem, projectId: number): Promise<void> {
+    return this.post('/api/languages', {
+      body: { ...lang, project_id: projectId, is_default: true },
+      skipDedup: true,
+    })
+  }
+
+  async remove(code: string, projectId: number): Promise<void> {
+    return this.delete(`/api/languages/${code}`, { query: { project_id: projectId } })
+  }
+}
+
+export const languageService = new LanguageService()