i18n-dashboard 0.1.0

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

@@ -0,0 +1,42 @@
+import { getDb } from '../../db/index'
+import { autoTranslateUtil } from '../../utils/auto-translate.util'
+
+export default defineEventHandler(async (event) => {
+  const body = await readBody(event)
+  const { project_id, code, name, is_default, fallback_code } = body
+
+  if (!project_id) throw createError({ statusCode: 400, message: 'project_id is required' })
+  if (!code || !name) throw createError({ statusCode: 400, message: 'code and name are required' })
+
+  const db = getDb()
+
+  if (is_default) {
+    await db('languages').where({ project_id: Number(project_id) }).update({ is_default: false })
+  }
+
+  const existing = await db('languages').where({ project_id: Number(project_id), code }).first()
+  if (existing) {
+    await db('languages').where({ id: existing.id }).update({
+      name,
+      is_default: is_default || false,
+      fallback_code: fallback_code ?? existing.fallback_code,
+    })
+    return db('languages').where({ id: existing.id }).first()
+  }
+
+  const [id] = await db('languages').insert({
+    project_id: Number(project_id),
+    code,
+    name,
+    is_default: is_default || false,
+    fallback_code: fallback_code || null,
+  })
+
+  // If this is the system project and the language isn't English, auto-translate UI strings
+  const project = await db('projects').where({ id: Number(project_id) }).first()
+  if (project?.is_system && code !== 'en') {
+    setImmediate(() => autoTranslateUtil(db, code))
+  }
+
+  return db('languages').where({ id }).first()
+})

package/server/api/onboarding.post.ts

@@ -0,0 +1,56 @@
+import { getDb } from '../db/index'
+import { autoTranslateUtil } from '../utils/auto-translate.util'
+
+// Saves onboarding configuration: UI languages for Dashboard UI project
+export default defineEventHandler(async (event) => {
+  const body = await readBody(event)
+  const { languages, defaultLanguage } = body // languages: Array<{ code, name }>
+
+  const db = getDb()
+  const systemProject = await db('projects').where({ is_system: true }).first()
+
+  const langsToTranslate: string[] = []
+
+  if (systemProject && languages?.length) {
+    const existingLangs = await db('languages').where({ project_id: systemProject.id }).select('code')
+    const existingCodes = existingLangs.map((l: any) => l.code)
+
+    for (const lang of languages) {
+      if (!existingCodes.includes(lang.code)) {
+        await db('languages').insert({
+          project_id: systemProject.id,
+          code: lang.code,
+          name: lang.name,
+          is_default: lang.code === defaultLanguage,
+        })
+        // Queue translation for non-English new languages
+        if (lang.code !== 'en') {
+          langsToTranslate.push(lang.code)
+        }
+      } else {
+        await db('languages')
+          .where({ project_id: systemProject.id, code: lang.code })
+          .update({ is_default: lang.code === defaultLanguage })
+      }
+    }
+  }
+
+  // Mark onboarding as completed (upsert to handle missing row)
+  const existing = await db('settings').where({ key: 'onboarding_completed' }).first()
+  if (existing) {
+    await db('settings').where({ key: 'onboarding_completed' }).update({ value: 'true' })
+  } else {
+    await db('settings').insert({ key: 'onboarding_completed', value: 'true' })
+  }
+
+  // Fire-and-forget: translate UI strings for each new non-EN language
+  if (langsToTranslate.length) {
+    setImmediate(async () => {
+      for (const code of langsToTranslate) {
+        await autoTranslateUtil(db, code)
+      }
+    })
+  }
+
+  return { success: true }
+})

package/server/api/profile.get.ts

@@ -0,0 +1,81 @@
+import { getDb } from '../db/index'
+import type { UserProfile } from '../interfaces/profile.interface'
+
+export default defineEventHandler(async (event): Promise<UserProfile> => {
+  const user = event.context.user
+  const db = getDb()
+
+  // ── Roles with project info ───────────────────────────────────────────────
+  const roles = await db('user_project_roles as upr')
+    .leftJoin('projects as p', 'p.id', 'upr.project_id')
+    .where('upr.user_id', user.id)
+    .select('upr.role', 'upr.project_id', 'p.name as project_name', 'p.color as project_color')
+
+  // ── Languages accessible to the user ─────────────────────────────────────
+  const projectIds = roles.filter((r: any) => r.project_id).map((r: any) => r.project_id)
+
+  let languages: any[]
+  if (user.is_super_admin) {
+    languages = await db('languages as l')
+      .join('projects as p', 'p.id', 'l.project_id')
+      .where('p.is_system', false)
+      .select('l.*', 'p.name as project_name', 'p.color as project_color')
+  } else if (projectIds.length) {
+    languages = await db('languages as l')
+      .join('projects as p', 'p.id', 'l.project_id')
+      .whereIn('l.project_id', projectIds)
+      .where('p.is_system', false)
+      .select('l.*', 'p.name as project_name', 'p.color as project_color')
+  } else {
+    languages = []
+  }
+
+  // ── Stats ─────────────────────────────────────────────────────────────────
+  const weekAgo = new Date(Date.now() - 7 * 24 * 60 * 60 * 1000).toISOString()
+  const monthAgo = new Date(Date.now() - 30 * 24 * 60 * 60 * 1000).toISOString()
+
+  const [countTotal, countWeek, countMonth] = await Promise.all([
+    db('translation_history').where('changed_by', user.name).count('id as n').first(),
+    db('translation_history').where('changed_by', user.name).where('changed_at', '>=', weekAgo).count('id as n').first(),
+    db('translation_history').where('changed_by', user.name).where('changed_at', '>=', monthAgo).count('id as n').first(),
+  ])
+
+  // ── Recent translations ───────────────────────────────────────────────────
+  const recentTranslations = await db('translation_history as th')
+    .join('translations as t', 't.id', 'th.translation_id')
+    .join('translation_keys as tk', 'tk.id', 't.key_id')
+    .join('projects as p', 'p.id', 'tk.project_id')
+    .where('th.changed_by', user.name)
+    .orderBy('th.changed_at', 'desc')
+    .limit(20)
+    .select(
+      'th.id',
+      'th.new_value',
+      'th.old_value',
+      'th.changed_at',
+      'tk.key',
+      'tk.id as key_id',
+      't.language_code',
+      'p.name as project_name',
+      'p.color as project_color',
+    )
+
+  return {
+    user: {
+      id: user.id,
+      name: user.name,
+      email: user.email,
+      is_super_admin: !!user.is_super_admin,
+      last_login_at: user.last_login_at ?? null,
+      created_at: user.created_at,
+    },
+    roles,
+    stats: {
+      total: Number(countTotal?.n ?? 0),
+      thisWeek: Number(countWeek?.n ?? 0),
+      thisMonth: Number(countMonth?.n ?? 0),
+    },
+    languages,
+    recentTranslations,
+  }
+})

package/server/api/project-snapshot.get.ts

@@ -0,0 +1,73 @@
+import { getDb } from '../db/index'
+
+export default defineEventHandler(async (event) => {
+  const query = getQuery(event)
+  const projectId = query.project_id ? Number(query.project_id) : null
+
+  if (!projectId) throw createError({ statusCode: 400, message: 'project_id is required' })
+
+  const db = getDb()
+  const project = await db('projects').where({ id: projectId }).first()
+  if (!project) throw createError({ statusCode: 404, message: 'Project not found' })
+  if (project.is_system) throw createError({ statusCode: 403, message: 'System project cannot be exported' })
+
+  const languages = await db('languages')
+    .where({ project_id: projectId })
+    .select('code', 'name', 'is_default', 'fallback_code')
+
+  const keyRows = await db('translation_keys')
+    .where({ project_id: projectId })
+    .select('id', 'key', 'description')
+
+  const translationRows = await db('translations as t')
+    .join('translation_keys as k', 't.key_id', 'k.id')
+    .where('k.project_id', projectId)
+    .select('k.key', 't.language_code', 't.value', 't.status')
+
+  // Build keys map: key → { description, translations: { lang: { value, status } } }
+  const keysMap: Record<string, { description: string | null; translations: Record<string, { value: string; status: string }> }> = {}
+
+  for (const row of keyRows) {
+    keysMap[row.key] = { description: row.description ?? null, translations: {} }
+  }
+
+  for (const row of translationRows) {
+    if (!keysMap[row.key]) continue
+    if (row.value !== null && row.value !== '') {
+      keysMap[row.key].translations[row.language_code] = {
+        value: row.value,
+        status: row.status ?? 'draft',
+      }
+    }
+  }
+
+  const snapshot = {
+    version: 1,
+    exportedAt: new Date().toISOString(),
+    project: {
+      name: project.name,
+      locales_path: project.locales_path,
+      key_separator: project.key_separator,
+      color: project.color ?? null,
+      description: project.description ?? null,
+      source_url: project.source_url ?? null,
+    },
+    languages: languages.map(l => ({
+      code: l.code,
+      name: l.name,
+      is_default: !!l.is_default,
+      fallback_code: l.fallback_code ?? null,
+    })),
+    keys: Object.entries(keysMap).map(([key, data]) => ({
+      key,
+      description: data.description,
+      translations: data.translations,
+    })),
+  }
+
+  const filename = `${project.name.replace(/[^a-z0-9]/gi, '_')}_snapshot.json`
+  setHeader(event, 'Content-Type', 'application/json')
+  setHeader(event, 'Content-Disposition', `attachment; filename="${filename}"`)
+
+  return snapshot
+})

package/server/api/project-snapshot.post.ts

@@ -0,0 +1,160 @@
+import { getDb } from '../db/index'
+
+interface SnapshotKey {
+  key: string
+  description?: string | null
+  translations: Record<string, { value: string; status?: string } | string>
+}
+
+interface SnapshotLanguage {
+  code: string
+  name: string
+  is_default?: boolean
+  fallback_code?: string | null
+}
+
+interface ProjectSnapshot {
+  version: number
+  project: {
+    name: string
+    locales_path: string
+    key_separator: string
+    color?: string | null
+    description?: string | null
+    source_url?: string | null
+  }
+  languages: SnapshotLanguage[]
+  keys: SnapshotKey[]
+}
+
+export default defineEventHandler(async (event) => {
+  const body = await readBody(event)
+  const { snapshot, project_id, mode = 'merge' } = body as {
+    snapshot: ProjectSnapshot
+    project_id?: number
+    mode?: 'merge' | 'replace'
+  }
+
+  if (!snapshot?.version || !snapshot?.project || !Array.isArray(snapshot.keys)) {
+    throw createError({ statusCode: 400, message: 'Invalid snapshot format' })
+  }
+
+  const db = getDb()
+  let projectId = project_id ? Number(project_id) : null
+  let stats = { keys_added: 0, keys_updated: 0, translations_added: 0, translations_updated: 0, languages_added: 0 }
+
+  // ── Resolve or create project ──────────────────────────────────────────
+  if (projectId) {
+    const existing = await db('projects').where({ id: projectId }).first()
+    if (!existing) throw createError({ statusCode: 404, message: 'Target project not found' })
+    // Update project metadata
+    await db('projects').where({ id: projectId }).update({
+      name: snapshot.project.name,
+      locales_path: snapshot.project.locales_path,
+      key_separator: snapshot.project.key_separator,
+      color: snapshot.project.color ?? existing.color,
+      description: snapshot.project.description ?? existing.description,
+      source_url: snapshot.project.source_url ?? existing.source_url,
+    })
+  } else {
+    // Create new project
+    const [id] = await db('projects').insert({
+      name: snapshot.project.name,
+      locales_path: snapshot.project.locales_path,
+      key_separator: snapshot.project.key_separator,
+      color: snapshot.project.color ?? '#6366f1',
+      description: snapshot.project.description ?? null,
+      source_url: snapshot.project.source_url ?? null,
+      is_system: false,
+    })
+    projectId = id
+  }
+
+  const separator = snapshot.project.key_separator || '.'
+
+  // ── Upsert languages ──────────────────────────────────────────────────
+  for (const lang of snapshot.languages) {
+    const existing = await db('languages').where({ project_id: projectId, code: lang.code }).first()
+    if (existing) {
+      await db('languages').where({ id: existing.id }).update({
+        name: lang.name,
+        is_default: lang.is_default ? 1 : 0,
+        fallback_code: lang.fallback_code ?? null,
+      })
+    } else {
+      await db('languages').insert({
+        project_id: projectId,
+        code: lang.code,
+        name: lang.name,
+        is_default: lang.is_default ? 1 : 0,
+        fallback_code: lang.fallback_code ?? null,
+      })
+      stats.languages_added++
+    }
+  }
+
+  // ── Replace mode: clear existing keys ────────────────────────────────
+  if (mode === 'replace') {
+    const keyIds = await db('translation_keys').where({ project_id: projectId }).pluck('id')
+    if (keyIds.length) {
+      await db('translations').whereIn('key_id', keyIds).delete()
+      await db('key_usages').whereIn('key_id', keyIds).delete()
+      await db('translation_keys').where({ project_id: projectId }).delete()
+    }
+  }
+
+  // ── Upsert keys + translations ────────────────────────────────────────
+  for (const entry of snapshot.keys) {
+    if (!entry.key) continue
+
+    let keyRecord = await db('translation_keys').where({ project_id: projectId, key: entry.key }).first()
+    if (!keyRecord) {
+      const [id] = await db('translation_keys').insert({
+        project_id: projectId,
+        key: entry.key,
+        description: entry.description ?? null,
+      })
+      keyRecord = { id }
+      stats.keys_added++
+    } else if (entry.description !== undefined) {
+      await db('translation_keys').where({ id: keyRecord.id }).update({ description: entry.description })
+      stats.keys_updated++
+    }
+
+    for (const [langCode, translationData] of Object.entries(entry.translations)) {
+      const value = typeof translationData === 'string' ? translationData : translationData.value
+      const status = typeof translationData === 'object' ? (translationData.status ?? 'draft') : 'draft'
+      if (!value) continue
+
+      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: 'snapshot-import',
+          })
+          await db('translations').where({ id: existing.id }).update({ value, status, updated_at: db.fn.now() })
+          stats.translations_updated++
+        }
+      } else {
+        const [id] = await db('translations').insert({
+          key_id: keyRecord.id,
+          language_code: langCode,
+          value,
+          status,
+        })
+        await db('translation_history').insert({
+          translation_id: id,
+          old_value: null,
+          new_value: value,
+          changed_by: 'snapshot-import',
+        })
+        stats.translations_added++
+      }
+    }
+  }
+
+  return { success: true, project_id: projectId, stats }
+})

package/server/api/projects/[id].delete.ts

@@ -0,0 +1,13 @@
+import { getDb } from '../../db/index'
+
+export default defineEventHandler(async (event) => {
+  const id = Number(getRouterParam(event, 'id'))
+  const db = getDb()
+
+  const project = await db('projects').where({ id }).first()
+  if (!project) throw createError({ statusCode: 404, message: 'Project not found' })
+  if (project.is_system) throw createError({ statusCode: 403, message: 'Le projet système ne peut pas être supprimé' })
+
+  await db('projects').where({ id }).delete()
+  return { success: true }
+})

package/server/api/projects/[id].put.ts

@@ -0,0 +1,40 @@
+import { getDb } from '../../db/index'
+import { existsSync } from 'fs'
+import { resolve } from 'path'
+
+export default defineEventHandler(async (event) => {
+  const id = Number(getRouterParam(event, 'id'))
+  const body = await readBody(event)
+  const { name, root_path, source_url, locales_path, key_separator, color, description, enable_number_formats, enable_datetime_formats, enable_modifiers } = body
+
+  const db = getDb()
+  const project = await db('projects').where({ id }).first()
+  if (!project) throw createError({ statusCode: 404, message: 'Project not found' })
+  if (project.is_system) throw createError({ statusCode: 403, message: 'La configuration du projet système ne peut pas être modifiée' })
+
+  const updates: Record<string, any> = {}
+  if (name !== undefined) updates.name = name.trim()
+  if (locales_path !== undefined) updates.locales_path = locales_path
+  if (key_separator !== undefined) updates.key_separator = key_separator
+  if (color !== undefined) updates.color = color
+  if (description !== undefined) updates.description = description
+  if (source_url !== undefined) updates.source_url = source_url?.trim() || null
+  if (enable_number_formats !== undefined) updates.enable_number_formats = enable_number_formats
+  if (enable_datetime_formats !== undefined) updates.enable_datetime_formats = enable_datetime_formats
+  if (enable_modifiers !== undefined) updates.enable_modifiers = enable_modifiers
+
+  if (root_path !== undefined) {
+    if (root_path.trim() === '') {
+      updates.root_path = ''
+    } else {
+      const absolutePath = resolve(root_path)
+      if (!existsSync(absolutePath)) {
+        throw createError({ statusCode: 400, message: `Path does not exist: ${absolutePath}` })
+      }
+      updates.root_path = absolutePath
+    }
+  }
+
+  await db('projects').where({ id }).update(updates)
+  return db('projects').where({ id }).first()
+})

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

@@ -0,0 +1,19 @@
+import { getDb } from '../../db/index'
+
+export default defineEventHandler(async () => {
+  const db = getDb()
+  const projects = await db('projects').select('*').orderBy('created_at', 'asc')
+
+  // For each project, add language count + key count
+  const withStats = await Promise.all(projects.map(async (p: any) => {
+    const keyCount = await db('translation_keys').where({ project_id: p.id }).count('* as count').first()
+    const langCount = await db('languages').where({ project_id: p.id }).count('* as count').first()
+    return {
+      ...p,
+      key_count: Number((keyCount as any)?.count || 0),
+      language_count: Number((langCount as any)?.count || 0),
+    }
+  }))
+
+  return withStats
+})

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

@@ -0,0 +1,34 @@
+import { getDb } from '../../db/index'
+import { existsSync } from 'fs'
+import { resolve } from 'path'
+
+export default defineEventHandler(async (event) => {
+  const body = await readBody(event)
+  const { name, root_path, source_url, locales_path, key_separator, color, description } = body
+
+  if (!name?.trim()) throw createError({ statusCode: 400, message: 'name is required' })
+  if (!root_path?.trim() && !source_url?.trim()) {
+    throw createError({ statusCode: 400, message: 'root_path or source_url is required' })
+  }
+
+  let absolutePath = ''
+  if (root_path?.trim()) {
+    absolutePath = resolve(root_path)
+    if (!existsSync(absolutePath)) {
+      throw createError({ statusCode: 400, message: `Path does not exist: ${absolutePath}` })
+    }
+  }
+
+  const db = getDb()
+  const [id] = await db('projects').insert({
+    name: name.trim(),
+    root_path: absolutePath,
+    source_url: source_url?.trim() || null,
+    locales_path: locales_path || 'src/locales',
+    key_separator: key_separator || '.',
+    color: color || 'primary',
+    description: description || null,
+  })
+
+  return db('projects').where({ id }).first()
+})