i18n-dashboard 0.1.0

package/server/api/scan.post.ts

@@ -0,0 +1,165 @@
+import { resolve } from 'path'
+import { getDb } from '../db/index'
+import { scanProject, detectLanguages } from '../utils/scanner.uti'
+
+export default defineEventHandler(async (event) => {
+  const body = await readBody(event)
+  const { project_id, mode = 'local', root_path: bodyRootPath, url: bodyUrl } = body
+
+  if (!project_id) throw createError({ statusCode: 400, message: 'project_id is required' })
+
+  const db = getDb()
+  const project = await db('projects').where({ id: Number(project_id) }).first()
+  if (!project) throw createError({ statusCode: 404, message: 'Project not found' })
+  if (project.is_system) throw createError({ statusCode: 403, message: 'Cannot scan system project' })
+
+  // ── URL mode: fetch locale files and import keys ───────────────────────
+  if (mode === 'url') {
+    const baseUrl = (bodyUrl || project.source_url || '').replace(/\/$/, '')
+    if (!baseUrl) throw createError({ statusCode: 400, message: 'No URL provided' })
+
+    const languages = await db('languages').where({ project_id: Number(project_id) }).select('code')
+    if (!languages.length) throw createError({ statusCode: 400, message: 'No languages configured for this project' })
+
+    const separator = project.key_separator || '.'
+    let keysAdded = 0
+    let keysFound = 0
+
+    for (const lang of languages) {
+      const url = `${baseUrl}/locale/${lang.code}.json`
+      let data: Record<string, any>
+      try {
+        const res = await fetch(url)
+        if (!res.ok) continue
+        data = await res.json()
+      } catch {
+        continue
+      }
+
+      const flat = flattenObject(data, separator)
+
+      for (const key of Object.keys(flat)) {
+        keysFound++
+        const existing = await db('translation_keys').where({ project_id: Number(project_id), key }).first()
+        if (!existing) {
+          await db('translation_keys').insert({
+            project_id: Number(project_id),
+            key,
+            is_unused: false,
+            last_scanned_at: db.fn.now(),
+          })
+          keysAdded++
+        } else {
+          await db('translation_keys').where({ id: existing.id }).update({ is_unused: false, last_scanned_at: db.fn.now() })
+        }
+      }
+    }
+
+    const totalKeys = await db('translation_keys').where({ project_id: Number(project_id) }).count('* as count').first()
+    return { keysImported: keysFound, keysAdded, total: Number((totalKeys as any)?.count || 0) }
+  }
+
+  // ── Local mode: scan source files ─────────────────────────────────────
+  const rootPath = bodyRootPath || project.root_path
+  if (!rootPath) {
+    throw createError({ statusCode: 400, message: 'No local path provided. Select a folder or use URL mode.' })
+  }
+
+  const settings = await db('settings').select('*')
+  const settingsMap: Record<string, string> = {}
+  for (const s of settings) settingsMap[s.key] = s.value
+
+  const excludeDirs = (settingsMap['scan_exclude'] || 'node_modules,dist,.nuxt,.output,.git')
+    .split(',').map((s) => s.trim()).filter(Boolean)
+
+  const projectRoot = resolve(rootPath)
+
+  // Auto-detect languages from locale files
+  const detectedLangs = detectLanguages({ projectRoot, localesPath: project.locales_path })
+  let langsAdded = 0
+  for (const lang of detectedLangs) {
+    const existing = await db('languages').where({ project_id: Number(project_id), code: lang.code }).first()
+    if (!existing) {
+      await db('languages').insert({ project_id: Number(project_id), code: lang.code, name: lang.name, is_default: false })
+      langsAdded++
+    }
+  }
+
+  // Scan source files
+  const { usages, scannedFiles, errors } = scanProject({
+    projectRoot,
+    excludeDirs,
+    extensions: ['.vue', '.ts', '.js', '.mts', '.mjs'],
+  })
+
+  const keyMap = new Map<string, typeof usages>()
+  for (const usage of usages) {
+    const existing = keyMap.get(usage.key) || []
+    existing.push(usage)
+    keyMap.set(usage.key, existing)
+  }
+
+  const now = db.fn.now()
+  let keysAdded = 0
+  let keysFound = 0
+
+  const existingKeys = await db('translation_keys').where({ project_id: Number(project_id) }).select('id', 'key')
+  const existingKeyMap = new Map<string, number>()
+  for (const k of existingKeys) existingKeyMap.set(k.key, k.id)
+
+  if (existingKeys.length > 0) {
+    await db('key_usages').whereIn('key_id', existingKeys.map(k => k.id)).delete()
+  }
+
+  for (const [key, keyUsages] of keyMap.entries()) {
+    let keyId = existingKeyMap.get(key)
+    if (!keyId) {
+      const [id] = await db('translation_keys').insert({ project_id: Number(project_id), key, is_unused: false, last_scanned_at: now })
+      keyId = id
+      keysAdded++
+    } else {
+      await db('translation_keys').where({ id: keyId }).update({ is_unused: false, last_scanned_at: now })
+    }
+    keysFound++
+
+    await db('key_usages').insert(keyUsages.map(u => ({
+      key_id: keyId,
+      file_path: u.filePath,
+      line_number: u.lineNumber,
+      detected_function: u.detectedFunction,
+      scanned_at: now,
+    })))
+  }
+
+  const foundKeys = new Set(keyMap.keys())
+  const unusedIds = existingKeys.filter(k => !foundKeys.has(k.key)).map(k => k.id)
+  if (unusedIds.length > 0) {
+    await db('translation_keys').whereIn('id', unusedIds).update({ is_unused: true, last_scanned_at: now })
+  }
+
+  const totalKeys = await db('translation_keys').where({ project_id: Number(project_id) }).count('* as count').first()
+
+  return {
+    keysFound,
+    keysAdded,
+    unusedKeys: unusedIds.length,
+    scannedFiles: scannedFiles.length,
+    total: Number((totalKeys as any)?.count || 0),
+    langsDetected: detectedLangs.length,
+    langsAdded,
+    errors: errors.slice(0, 10),
+  }
+})
+
+function flattenObject(obj: Record<string, any>, separator: string, prefix = ''): Record<string, string> {
+  const result: Record<string, string> = {}
+  for (const [key, value] of Object.entries(obj)) {
+    const fullKey = prefix ? `${prefix}${separator}${key}` : key
+    if (value && typeof value === 'object' && !Array.isArray(value)) {
+      Object.assign(result, flattenObject(value, separator, fullKey))
+    } else {
+      result[fullKey] = String(value ?? '')
+    }
+  }
+  return result
+}

package/server/api/settings/index.get.ts

@@ -0,0 +1,9 @@
+import { getDb } from '../../db/index'
+
+export default defineEventHandler(async () => {
+  const db = getDb()
+  const settings = await db('settings').select('*')
+  const map: Record<string, string> = {}
+  for (const s of settings) map[s.key] = s.value
+  return map
+})

package/server/api/settings/index.post.ts

@@ -0,0 +1,20 @@
+import { getDb } from '../../db/index'
+
+export default defineEventHandler(async (event) => {
+  const body = await readBody(event)
+  const db = getDb()
+
+  for (const [key, value] of Object.entries(body)) {
+    const existing = await db('settings').where({ key }).first()
+    if (existing) {
+      await db('settings').where({ key }).update({ value: String(value), updated_at: db.fn.now() })
+    } else {
+      await db('settings').insert({ key, value: String(value) })
+    }
+  }
+
+  const settings = await db('settings').select('*')
+  const map: Record<string, string> = {}
+  for (const s of settings) map[s.key] = s.value
+  return map
+})

package/server/api/setup.post.ts

@@ -0,0 +1,39 @@
+import bcrypt from 'bcryptjs'
+import { getDb } from '../db/index'
+import { getSession } from '../utils/auth.util'
+
+export default defineEventHandler(async (event) => {
+  const db = getDb()
+
+  // Only allowed when no users exist yet
+  const count = await db('users').count('* as count').first()
+  if (Number((count as any)?.count || 0) > 0) {
+    throw createError({ statusCode: 403, message: 'Le setup a déjà été effectué' })
+  }
+
+  const { name, email, password } = await readBody(event)
+
+  if (!name || !email || !password) {
+    throw createError({ statusCode: 400, message: 'Nom, email et mot de passe requis' })
+  }
+  if (password.length < 8) {
+    throw createError({ statusCode: 400, message: 'Le mot de passe doit contenir au moins 8 caractères' })
+  }
+
+  const hash = await bcrypt.hash(password, 12)
+  const [id] = await db('users').insert({
+    name: name.trim(),
+    email: email.toLowerCase().trim(),
+    password_hash: hash,
+    is_super_admin: true,
+    is_active: true,
+  })
+
+  // Auto-login
+  const session = await getSession(event)
+  await session.update({ userId: id })
+
+  console.log(`[i18n-dashboard] Super admin créé : ${email}`)
+
+  return { success: true, id }
+})

package/server/api/stats/global.get.ts

@@ -0,0 +1,126 @@
+import { getDb } from '../../db/index'
+import { requireAuth } from '../../utils/auth.util'
+
+export default defineEventHandler(async (event) => {
+  const user = await requireAuth(event)
+  const db = getDb()
+
+  // Determine accessible project IDs
+  let projectIds: number[]
+
+  if (user.is_super_admin) {
+    const rows = await db('projects').select('id')
+    projectIds = rows.map((r: any) => r.id)
+  } else {
+    // Check for a global role (project_id IS NULL) → access to all non-system projects
+    const globalRole = await db('user_project_roles')
+      .where({ user_id: user.id })
+      .whereNull('project_id')
+      .first()
+
+    if (globalRole) {
+      const rows = await db('projects').select('id')
+      projectIds = rows.map((r: any) => r.id)
+    } else {
+      const specific = await db('user_project_roles')
+        .where({ user_id: user.id })
+        .whereNotNull('project_id')
+        .select('project_id')
+      projectIds = specific.map((r: any) => r.project_id)
+    }
+  }
+
+  if (projectIds.length === 0) {
+    return { totalKeys: 0, unusedKeys: 0, languages: [], recentActivity: [] }
+  }
+
+  // Aggregate totalKeys and unusedKeys
+  const totalKeysRow = await db('translation_keys')
+    .whereIn('project_id', projectIds)
+    .count('* as count')
+    .first()
+  const unusedKeysRow = await db('translation_keys')
+    .whereIn('project_id', projectIds)
+    .where({ is_unused: true })
+    .count('* as count')
+    .first()
+
+  const totalKeys = Number((totalKeysRow as any)?.count || 0)
+  const unusedKeys = Number((unusedKeysRow as any)?.count || 0)
+
+  // Languages: aggregate by code across all accessible projects
+  const allLanguages = await db('languages')
+    .whereIn('project_id', projectIds)
+    .select('*')
+    .orderBy('is_default', 'desc')
+    .orderBy('code', 'asc')
+
+  // Group language stats by code
+  const langMap = new Map<string, { code: string; name: string; is_default: boolean; total: number; translated: number; draft: number; reviewed: number; approved: number }>()
+
+  for (const lang of allLanguages) {
+    const existing = langMap.get(lang.code)
+
+    const translatedRow = await db('translations as t')
+      .join('translation_keys as k', 't.key_id', 'k.id')
+      .whereIn('k.project_id', projectIds)
+      .where('t.language_code', lang.code)
+      .whereNotNull('t.value')
+      .where('t.value', '!=', '')
+      .count('* as count')
+      .first()
+
+    const byStatus = await db('translations as t')
+      .join('translation_keys as k', 't.key_id', 'k.id')
+      .whereIn('k.project_id', projectIds)
+      .where('t.language_code', lang.code)
+      .whereNotNull('t.value')
+      .where('t.value', '!=', '')
+      .groupBy('t.status')
+      .select('t.status')
+      .count('* as count')
+
+    const statusMap: Record<string, number> = { draft: 0, reviewed: 0, approved: 0 }
+    for (const row of byStatus) {
+      statusMap[(row as any).status || 'draft'] = Number((row as any).count)
+    }
+
+    const translatedCount = Number((translatedRow as any)?.count || 0)
+
+    if (!existing) {
+      langMap.set(lang.code, {
+        code: lang.code,
+        name: lang.name,
+        is_default: !!lang.is_default,
+        total: totalKeys,
+        translated: translatedCount,
+        draft: statusMap.draft,
+        reviewed: statusMap.reviewed,
+        approved: statusMap.approved,
+      })
+    }
+    // If already exists (same lang code in multiple projects), skip — already aggregated above per-code
+  }
+
+  const langStats = Array.from(langMap.values()).map(l => ({
+    ...l,
+    missing: l.total - l.translated,
+    coverage: l.total > 0 ? Math.round((l.translated / l.total) * 100) : 0,
+  }))
+
+  // Recent activity across all accessible projects
+  const recentActivity = await db('translation_history as h')
+    .join('translations as t', 'h.translation_id', 't.id')
+    .join('translation_keys as k', 't.key_id', 'k.id')
+    .whereIn('k.project_id', projectIds)
+    .orderBy('h.changed_at', 'desc')
+    .limit(20)
+    .select('h.id', 'h.old_value', 'h.new_value', 'h.changed_by', 'h.changed_at', 'k.key', 't.language_code')
+
+  return {
+    totalKeys,
+    unusedKeys,
+    languages: langStats,
+    recentActivity,
+  }
+})

package/server/api/stats.get.ts

@@ -0,0 +1,70 @@
+import { getDb } from '../db/index'
+
+export default defineEventHandler(async (event) => {
+  const { project_id } = getQuery(event)
+  if (!project_id) return { totalKeys: 0, unusedKeys: 0, languages: [], recentActivity: [] }
+
+  const db = getDb()
+  const pid = Number(project_id)
+
+  const languages = await db('languages').where({ project_id: pid }).select('*').orderBy('is_default', 'desc').orderBy('name', 'asc')
+  const totalKeys = await db('translation_keys').where({ project_id: pid }).count('* as count').first()
+  const unusedKeys = await db('translation_keys').where({ project_id: pid, is_unused: true }).count('* as count').first()
+
+  const langStats = await Promise.all(
+    languages.map(async (lang: any) => {
+      const total = Number((totalKeys as any)?.count || 0)
+
+      const translated = await db('translations as t')
+        .join('translation_keys as k', 't.key_id', 'k.id')
+        .where('k.project_id', pid)
+        .where('t.language_code', lang.code)
+        .whereNotNull('t.value')
+        .where('t.value', '!=', '')
+        .count('* as count')
+        .first()
+
+      const byStatus = await db('translations as t')
+        .join('translation_keys as k', 't.key_id', 'k.id')
+        .where('k.project_id', pid)
+        .where('t.language_code', lang.code)
+        .whereNotNull('t.value')
+        .where('t.value', '!=', '')
+        .groupBy('t.status')
+        .select('t.status')
+        .count('* as count')
+
+      const statusMap: Record<string, number> = { draft: 0, reviewed: 0, approved: 0 }
+      for (const row of byStatus) {
+        statusMap[(row as any).status || 'draft'] = Number((row as any).count)
+      }
+
+      const translatedCount = Number((translated as any)?.count || 0)
+      return {
+        ...lang,
+        total,
+        translated: translatedCount,
+        missing: total - translatedCount,
+        draft: statusMap.draft,
+        reviewed: statusMap.reviewed,
+        approved: statusMap.approved,
+        coverage: total > 0 ? Math.round((translatedCount / total) * 100) : 0,
+      }
+    }),
+  )
+
+  const recentActivity = await db('translation_history as h')
+    .join('translations as t', 'h.translation_id', 't.id')
+    .join('translation_keys as k', 't.key_id', 'k.id')
+    .where('k.project_id', pid)
+    .orderBy('h.changed_at', 'desc')
+    .limit(15)
+    .select('h.id', 'h.old_value', 'h.new_value', 'h.changed_by', 'h.changed_at', 'k.key', 't.language_code')
+
+  return {
+    totalKeys: Number((totalKeys as any)?.count || 0),
+    unusedKeys: Number((unusedKeys as any)?.count || 0),
+    languages: langStats,
+    recentActivity,
+  }
+})

package/server/api/sync.post.ts

@@ -0,0 +1,179 @@
+import { resolve, extname, basename } from 'path'
+import { readdirSync, readFileSync, existsSync } from 'fs'
+import { getDb } from '../db/index'
+
+function flattenObject(obj: Record<string, any>, separator: string, prefix = ''): Record<string, string> {
+  const result: Record<string, string> = {}
+  for (const [key, value] of Object.entries(obj)) {
+    const fullKey = prefix ? `${prefix}${separator}${key}` : key
+    if (value && typeof value === 'object' && !Array.isArray(value)) {
+      Object.assign(result, flattenObject(value, separator, fullKey))
+    } else {
+      result[fullKey] = String(value ?? '')
+    }
+  }
+  return result
+}
+
+async function fetchRemoteLocale(sourceUrl: string, langCode: string): Promise<Record<string, string> | null> {
+  const url = `${sourceUrl.replace(/\/$/, '')}/locale/${langCode}.json`
+  try {
+    const res = await fetch(url)
+    if (!res.ok) return null
+    return await res.json()
+  } catch {
+    return null
+  }
+}
+
+export default defineEventHandler(async (event) => {
+  const body = await readBody(event)
+  const { project_id } = body
+
+  if (!project_id) throw createError({ statusCode: 400, message: 'project_id is required' })
+
+  const db = getDb()
+
+  const project = await db('projects').where({ id: Number(project_id) }).first()
+  if (!project) throw createError({ statusCode: 404, message: 'Project not found' })
+  if (project.is_system) throw createError({ statusCode: 403, message: 'Le projet Dashboard UI ne peut pas être synchronisé.' })
+
+  const hasLocalPath = !!project.root_path
+  const hasRemoteUrl = !!project.source_url
+
+  if (!hasLocalPath && !hasRemoteUrl) {
+    throw createError({
+      statusCode: 400,
+      message: 'Ce projet n\'a ni chemin local ni URL distante configuré. Configurez au moins l\'un des deux pour synchroniser.',
+    })
+  }
+
+  const separator = project.key_separator || '.'
+  let added = 0
+  let updated = 0
+  let syncedFiles: string[] = []
+
+  // ── Local filesystem sync ──────────────────────────────────────────────
+  if (hasLocalPath) {
+    const absoluteLocalesPath = resolve(project.root_path, project.locales_path)
+
+    if (!existsSync(absoluteLocalesPath)) {
+      throw createError({
+        statusCode: 404,
+        message: `Locales directory not found: ${absoluteLocalesPath}`,
+      })
+    }
+
+    const files = readdirSync(absoluteLocalesPath)
+    const jsonFiles = files.filter((f) => extname(f) === '.json')
+
+    if (jsonFiles.length === 0) {
+      return { added: 0, updated: 0, total: 0, message: 'No JSON locale files found' }
+    }
+
+    syncedFiles = jsonFiles
+
+    for (const file of jsonFiles) {
+      const langCode = basename(file, '.json')
+      const filePath = resolve(absoluteLocalesPath, file)
+
+      const existingLang = await db('languages').where({ project_id: Number(project_id), code: langCode }).first()
+      if (!existingLang) {
+        await db('languages').insert({
+          project_id: Number(project_id),
+          code: langCode,
+          name: langCode.toUpperCase(),
+          is_default: false,
+        })
+      }
+
+      const raw = JSON.parse(readFileSync(filePath, 'utf-8'))
+      const flattened = flattenObject(raw, separator)
+
+      const result = await upsertTranslations(db, Number(project_id), langCode, flattened)
+      added += result.added
+      updated += result.updated
+    }
+  }
+  // ── Remote URL sync ────────────────────────────────────────────────────
+  else if (hasRemoteUrl) {
+    const languages = await db('languages').where({ project_id: Number(project_id) }).select('code')
+
+    if (languages.length === 0) {
+      return {
+        added: 0,
+        updated: 0,
+        total: 0,
+        message: 'Aucune langue configurée. Ajoutez des langues avant de synchroniser depuis une URL distante.',
+      }
+    }
+
+    for (const lang of languages) {
+      const remoteData = await fetchRemoteLocale(project.source_url, lang.code)
+      if (!remoteData) continue
+
+      const flattened = flattenObject(remoteData, separator)
+      const result = await upsertTranslations(db, Number(project_id), lang.code, flattened)
+      added += result.added
+      updated += result.updated
+      syncedFiles.push(`${lang.code}.json (remote)`)
+    }
+  }
+
+  const total = await db('translation_keys').where({ project_id: Number(project_id) }).count('* as count').first()
+
+  return {
+    added,
+    updated,
+    total: Number((total as any)?.count || 0),
+    files: syncedFiles,
+  }
+})
+
+async function upsertTranslations(
+  db: any,
+  projectId: number,
+  langCode: string,
+  flattened: Record<string, string>,
+): Promise<{ added: number; updated: number }> {
+  let added = 0
+  let updated = 0
+
+  for (const [key, value] of Object.entries(flattened)) {
+    let keyRecord = await db('translation_keys').where({ project_id: projectId, key }).first()
+    if (!keyRecord) {
+      const [id] = await db('translation_keys').insert({ project_id: projectId, key })
+      keyRecord = { id }
+      added++
+    }
+
+    const existing = await db('translations').where({ key_id: keyRecord.id, language_code: langCode }).first()
+    if (existing) {
+      if (existing.value !== value) {
+        await db('translation_history').insert({
+          translation_id: existing.id,
+          old_value: existing.value,
+          new_value: value,
+          changed_by: 'sync',
+        })
+        await db('translations').where({ id: existing.id }).update({ value, updated_at: db.fn.now() })
+        updated++
+      }
+    } else {
+      const [id] = await db('translations').insert({
+        key_id: keyRecord.id,
+        language_code: langCode,
+        value,
+        status: 'draft',
+      })
+      await db('translation_history').insert({
+        translation_id: id,
+        old_value: null,
+        new_value: value,
+        changed_by: 'sync',
+      })
+    }
+  }
+
+  return { added, updated }
+}

package/server/api/translate.post.ts

@@ -0,0 +1,52 @@
+import { translate } from '@vitalets/google-translate-api'
+import { getDb } from '../db/index'
+
+export default defineEventHandler(async (event) => {
+  const body = await readBody(event)
+  const { text, from, to, key_id, language_code } = body
+
+  if (!text || !to) {
+    throw createError({ statusCode: 400, message: 'text and to are required' })
+  }
+
+  try {
+    const result = await translate(text, { from: from || 'auto', to })
+    const translatedText = result.text
+
+    // If key_id and language_code provided, save the translation
+    if (key_id && language_code) {
+      const db = getDb()
+      const existing = await db('translations').where({ key_id: Number(key_id), language_code }).first()
+
+      if (existing) {
+        if (existing.value !== translatedText) {
+          await db('translation_history').insert({
+            translation_id: existing.id,
+            old_value: existing.value,
+            new_value: translatedText,
+            changed_by: 'google-translate',
+          })
+          await db('translations')
+            .where({ id: existing.id })
+            .update({ value: translatedText, updated_at: db.fn.now() })
+        }
+      } else {
+        const [id] = await db('translations').insert({
+          key_id: Number(key_id),
+          language_code,
+          value: translatedText,
+        })
+        await db('translation_history').insert({
+          translation_id: id,
+          old_value: null,
+          new_value: translatedText,
+          changed_by: 'google-translate',
+        })
+      }
+    }
+
+    return { text: translatedText }
+  } catch (err: any) {
+    throw createError({ statusCode: 500, message: `Translation failed: ${err.message}` })
+  }
+})