i18n-dashboard 0.1.0

package/server/enums/auth.enum.ts

@@ -0,0 +1,5 @@
+export enum ROLES {
+	ADMIN = 'admin',
+	MODERATOR = 'moderator',
+	TRANSLATOR = 'translator',
+}

package/server/enums/translation.enum.ts

@@ -0,0 +1,6 @@
+export enum TRANSLATION_STATUS {
+	DRAFT = 'draft',
+	REVIEWED = 'reviewed',
+	APPROVED = 'approved',
+	REJECTED = 'rejected',
+}

package/server/interfaces/profile.interface.ts

@@ -0,0 +1,48 @@
+export interface ProfileStats {
+  total: number
+  thisWeek: number
+  thisMonth: number
+}
+
+export interface ProfileRole {
+  role: string
+  project_id: number | null
+  project_name: string | null
+  project_color: string | null
+}
+
+export interface ProfileLanguage {
+  id: number
+  code: string
+  name: string
+  project_id: number
+  project_name: string
+}
+
+export interface ProfileRecentTranslation {
+  id: number
+  key: string
+  key_id: number
+  project_id?: number
+  language_code: string
+  new_value: string
+  old_value: string | null
+  changed_at: string
+  project_name: string
+  project_color: string
+}
+
+export interface UserProfile {
+  user: {
+    id: number
+    name: string
+    email: string
+    is_super_admin: boolean
+    last_login_at: string | null
+    created_at: string
+  }
+  roles: ProfileRole[]
+  stats: ProfileStats
+  languages: ProfileLanguage[]
+  recentTranslations: ProfileRecentTranslation[]
+}

package/server/interfaces/project-config.interface.ts

@@ -0,0 +1,9 @@
+export interface DashboardConfig {
+	uiLanguages?: string[]        // e.g. ["fr", "en", "es"]
+	defaultUiLanguage?: string    // e.g. "fr"
+	project?: {
+		name?: string
+		localesPath?: string
+		keySeparator?: string
+	}
+}

package/server/interfaces/scanner.interface.ts

@@ -0,0 +1,18 @@
+export interface KeyUsage {
+	key: string
+	filePath: string
+	lineNumber: number
+	detectedFunction: string
+}
+
+export interface DetectedLanguage {
+	code: string
+	name: string
+	source: 'locales-dir' | 'config-file'
+}
+
+export interface ScanResult {
+	usages: KeyUsage[]
+	scannedFiles: string[]
+	errors: string[]
+}

package/server/interfaces/translation-job.interface.ts

@@ -0,0 +1,13 @@
+import type { JobStatus } from '../consts/translation-job.const'
+
+export interface TranslationJob {
+  id: string
+  status: JobStatus
+  projectId: number
+  languageCode: string
+  languageName: string
+  total: number
+  done: number
+  errors: number
+  startedAt: number
+}

package/server/middleware/auth.ts

@@ -0,0 +1,32 @@
+import { useSession } from 'h3'
+
+import { getDb } from '../db/index'
+import { sessionConfig } from '../utils/auth.util'
+import { PUBLIC_ROUTES } from '../consts/commons.const'
+
+export default defineEventHandler(async (event) => {
+	const path = event.path || ''
+
+	// Only protect API routes
+	if (!path.startsWith('/api/')) return
+
+	// Allow public endpoints
+	if (PUBLIC_ROUTES.includes(path)) return
+
+	// Check session
+	const session = await useSession(event, sessionConfig())
+	const userId = (session.data as any).userId
+
+	if (!userId) {
+		throw createError({ statusCode: 401, message: 'Non authentifié' })
+	}
+
+	// Attach user to context for downstream handlers
+	const db = getDb()
+	const user = await db('users').where({ id: userId, is_active: true }).first()
+	if (!user) {
+		throw createError({ statusCode: 401, message: 'Session invalide' })
+	}
+
+	event.context.user = user
+})

package/server/plugins/db.ts

@@ -0,0 +1,6 @@
+import { initDb } from '../db/index'
+
+export default defineNitroPlugin(async () => {
+  await initDb()
+  console.log('[i18n-dashboard] Database initialized')
+})

package/server/routes/locale/[lang].get.ts

@@ -0,0 +1,179 @@
+import { getDb } from '../../db/index'
+import { unflattenObject } from '#server/utils/lang-api.util'
+import type { Knex } from 'knex'
+
+/**
+ * Normalise une URL en gardant uniquement origin (scheme + host + port).
+ */
+function normalizeOrigin(url: string): string {
+  try {
+    return new URL(url).origin.toLowerCase()
+  } catch {
+    return url.toLowerCase().replace(/\/$/, '')
+  }
+}
+
+/**
+ * Remonte d'un niveau dans un tag BCP 47.
+ * fr-CA → fr | zh-Hant-TW → zh-Hant | fr → null
+ */
+function parentBcp47(code: string): string | null {
+  const parts = code.split('-')
+  if (parts.length <= 1) return null
+  parts.pop()
+  return parts.join('-')
+}
+
+/**
+ * Construit la chaîne de fallback pour `requestedCode` dans un projet.
+ * Résolution :
+ *   1. Si la langue existe dans le projet → l'ajoute à la chaîne
+ *      puis suit son fallback_code explicite (ou auto BCP 47 si absent)
+ *   2. Si la langue n'existe PAS → remonte le tag BCP 47 (fr-CA → fr)
+ *      jusqu'à trouver une langue configurée dans le projet
+ * La chaîne est ordonnée du plus spécifique au moins spécifique.
+ */
+async function buildFallbackChain(
+  db: Knex,
+  projectId: number,
+  requestedCode: string,
+): Promise<string[]> {
+  const chain: string[] = []
+  const visited = new Set<string>()
+  let current: string | null = requestedCode
+
+  while (current && !visited.has(current) && chain.length < 10) {
+    visited.add(current)
+    const langRow = await db('languages')
+      .where({ project_id: projectId, code: current })
+      .first()
+
+    if (!langRow) {
+      // Langue non configurée dans ce projet → tenter le parent BCP 47
+      current = parentBcp47(current)
+      continue
+    }
+
+    chain.push(current)
+
+    if (langRow.fallback_code) {
+      // Fallback explicitement configuré
+      current = langRow.fallback_code
+    } else {
+      // Auto-fallback BCP 47 : fr-CA → fr → null
+      current = parentBcp47(current)
+    }
+  }
+
+  return chain
+}
+
+/**
+ * Charge toutes les traductions non-nulles d'une locale donnée dans un projet.
+ */
+async function loadTranslations(
+  db: Knex,
+  projectId: number,
+  langCode: string,
+): Promise<Record<string, string>> {
+  const rows = await db('translations as t')
+    .join('translation_keys as k', 't.key_id', 'k.id')
+    .where('t.language_code', langCode)
+    .where('k.project_id', projectId)
+    .whereNotNull('t.value')
+    .where('t.value', '!=', '')
+    .select('k.key', 't.value')
+
+  const flat: Record<string, string> = {}
+  for (const row of rows) flat[row.key] = row.value
+  return flat
+}
+
+export default defineEventHandler(async (event) => {
+  // Extract lang from the URL - handles /locale/fr-CA.json
+  const url = event.path || getRequestURL(event).pathname
+  const match = url.match(/\/locale\/([^/]+)\.json/)
+  const lang = match ? match[1] : getRouterParam(event, 'lang')
+
+  if (!lang) {
+    throw createError({ statusCode: 400, message: 'Language code is required' })
+  }
+
+  const db = getDb()
+  const query = getQuery(event)
+
+  let projectId: number | null = query.project_id ? Number(query.project_id) : null
+
+  if (!projectId) {
+    // 1. Match by project_name query param
+    if (query.project_name) {
+      const p = await db('projects').where({ name: query.project_name.toString() }).first()
+      if (p) projectId = p.id
+    }
+
+    // 2. Match by request Origin / Referer against project source_url
+    if (!projectId) {
+      const requestOrigin = getHeader(event, 'origin') || getHeader(event, 'referer') || ''
+      if (requestOrigin) {
+        const normalizedRequest = normalizeOrigin(requestOrigin)
+        const projectsWithUrl = await db('projects')
+          .whereNotNull('source_url')
+          .where('source_url', '!=', '')
+          .select('id', 'source_url')
+
+        for (const p of projectsWithUrl) {
+          if (normalizeOrigin(p.source_url) === normalizedRequest) {
+            projectId = p.id
+            break
+          }
+        }
+      }
+    }
+
+    // 3. Fallback: first non-system project
+    if (!projectId) {
+      const firstProject = await db('projects')
+        .where({ is_system: false })
+        .orderBy('id', 'asc')
+        .first()
+      if (firstProject) projectId = firstProject.id
+    }
+  }
+
+  if (!projectId) {
+    throw createError({ statusCode: 404, message: 'No project found' })
+  }
+
+  // ── Fallback chain resolution ─────────────────────────────────────────────
+  const chain = await buildFallbackChain(db, projectId, lang)
+
+  if (chain.length === 0) {
+    throw createError({
+      statusCode: 404,
+      message: `Language '${lang}' not found in this project and no BCP 47 fallback available`,
+    })
+  }
+
+  const project = await db('projects').where({ id: projectId }).first()
+  const separator = project?.key_separator || '.'
+
+  // Merge translations: du moins spécifique au plus spécifique
+  // chain[0] = fr-CA (priorité max), chain[last] = fr ou en (priorité min)
+  // On charge du dernier au premier et on écrase — ainsi fr-CA prime sur fr
+  const flat: Record<string, string> = {}
+  for (const code of [...chain].reverse()) {
+    const translations = await loadTranslations(db, projectId, code)
+    Object.assign(flat, translations)
+  }
+
+  const nested = unflattenObject(flat, separator)
+
+  setHeader(event, 'Content-Type', 'application/json')
+  setHeader(event, 'Cache-Control', 'no-cache')
+  setHeader(event, 'Access-Control-Allow-Origin', '*')
+
+  // Expose la chaîne résolue dans les headers pour debug
+  setHeader(event, 'X-I18n-Fallback-Chain', chain.join(' → '))
+
+  return nested
+})

package/server/types/auth.type.ts

@@ -0,0 +1,3 @@
+import type { ROLES } from '../enums/auth.enum'
+
+export type Role = `${ROLES}`

package/server/utils/auth.util.ts

@@ -0,0 +1,89 @@
+import type { H3Event } from 'h3'
+import { useSession } from 'h3'
+import { useRuntimeConfig } from '#imports'
+
+import { getDb } from '../db/index'
+import { ROLES } from '../enums/auth.enum'
+import type { Role } from '../types/auth.type'
+
+export function sessionConfig() {
+  const config = useRuntimeConfig()
+  return {
+    password: config.sessionSecret as string,
+    name: 'i18n-dashboard-session',
+    maxAge: 60 * 60 * 24 * 7, // 7 days
+  }
+}
+
+/** Get the current session data */
+export async function getSession(event: H3Event) {
+  return useSession(event, sessionConfig())
+}
+
+/** Require a logged-in user. Returns user row or throws 401. */
+export async function requireAuth(event: H3Event) {
+  const session = await getSession(event)
+  const userId = (session.data as any).userId
+  if (!userId) throw createError({ statusCode: 401, message: 'Non authentifié' })
+
+  const db = getDb()
+  const user = await db('users').where({ id: userId, is_active: true }).first()
+  if (!user) throw createError({ statusCode: 401, message: 'Session invalide' })
+
+  return user
+}
+
+/** Get effective role for a user on a specific project. Returns null if no access. */
+export async function getUserRole(userId: number, projectId: number): Promise<Role | null> {
+  const db = getDb()
+
+  // Specific project role takes priority
+  const specific = await db('user_project_roles')
+    .where({ user_id: userId, project_id: projectId })
+    .first()
+  if (specific) return specific.role as Role
+
+  // Global role (project_id IS NULL) — access to all projects
+  const global_ = await db('user_project_roles')
+    .where({ user_id: userId })
+    .whereNull('project_id')
+    .first()
+  if (global_) return global_.role as Role
+
+  return null
+}
+
+/** Check if user can edit translations (translator+) */
+export function canEdit(role: Role | null, isSuperAdmin: boolean) {
+  return isSuperAdmin || role !== null
+}
+
+/** Check if user can approve translations (moderator+) */
+export function canApprove(role: Role | null, isSuperAdmin: boolean) {
+  return isSuperAdmin || role === ROLES.MODERATOR || role === ROLES.ADMIN
+}
+
+/** Check if user can manage project settings, scan, sync (admin+) */
+export function canManageProject(role: Role | null, isSuperAdmin: boolean) {
+  return isSuperAdmin || role === ROLES.ADMIN
+}
+
+/** Check if user can manage users (admin+ of that project, or super_admin) */
+export function canManageUsers(role: Role | null, isSuperAdmin: boolean) {
+  return isSuperAdmin || role === ROLES.ADMIN
+}
+
+/** Full user profile with roles */
+export async function getUserProfile(userId: number) {
+  const db = getDb()
+  const user = await db('users').where({ id: userId }).first()
+  if (!user) return null
+
+  const roles = await db('user_project_roles as r')
+    .leftJoin('projects as p', 'r.project_id', 'p.id')
+    .where('r.user_id', userId)
+    .select('r.role', 'r.project_id', 'p.name as project_name')
+
+  const { password_hash, ...safeUser } = user
+  return { ...safeUser, roles }
+}

package/server/utils/auto-translate.util.ts

@@ -0,0 +1,112 @@
+import { translate } from '@vitalets/google-translate-api'
+import type { Knex } from 'knex'
+
+import { BATCH_DELAY_MS, BATCH_SIZE } from '../consts/auto-translate.const'
+
+/**
+ * Auto-translates all missing Dashboard UI strings for a given language,
+ * using the EN translations as the source.
+ * Runs in batches to stay within free API limits.
+ */
+export async function autoTranslateUtil(db: Knex, targetLang: string): Promise<void> {
+  const systemProject = await db('projects').where({ is_system: true }).first()
+  if (!systemProject) return
+
+  // Get all EN translations for the system project
+  const enTranslations = await db('translation_keys as tk')
+    .join('translations as t', function () {
+      this.on('t.key_id', '=', 'tk.id').andOn('t.language_code', '=', db.raw('?', ['en']))
+    })
+    .where('tk.project_id', systemProject.id)
+    .whereNotNull('t.value')
+    .where('t.value', '!=', '')
+    .select('tk.id as key_id', 't.value as en_value')
+
+  if (!enTranslations.length) return
+
+  // Find which keys already have a translation in targetLang
+  const existingTargetKeyIds = new Set(
+    (await db('translations')
+      .whereIn('key_id', enTranslations.map((r: any) => r.key_id))
+      .where('language_code', targetLang)
+      .whereNotNull('value')
+      .where('value', '!=', '')
+      .select('key_id')
+    ).map((r: any) => r.key_id),
+  )
+
+  const toTranslate = enTranslations.filter((r: any) => !existingTargetKeyIds.has(r.key_id))
+  if (!toTranslate.length) return
+
+  console.log(`[autoTranslateUI] Translating ${toTranslate.length} UI strings to "${targetLang}"…`)
+
+  // Process in batches
+  const separator = '\n\n'
+
+  for (let i = 0; i < toTranslate.length; i += BATCH_SIZE) {
+    const chunk = toTranslate.slice(i, i + BATCH_SIZE)
+
+    let translatedTexts: string[] | null = null
+
+    // Attempt batch translation — faster but may fail for some languages
+    try {
+      const combined = chunk.map((r: any) => r.en_value).join(separator)
+      const result = await translate(combined, { from: 'en', to: targetLang })
+      const parts = result.text.split(separator)
+
+      // Only use batch result if the split produced the expected number of parts
+      if (parts.length === chunk.length) {
+        translatedTexts = parts
+      } else {
+        console.warn(`[autoTranslateUI] Batch split mismatch for "${targetLang}" (got ${parts.length}, expected ${chunk.length}) — falling back to individual calls`)
+      }
+    } catch (e: any) {
+      console.error(`[autoTranslateUI] Batch ${i / BATCH_SIZE + 1} failed for "${targetLang}":`, e.message)
+    }
+
+    // Fallback: translate each string individually when batch split is unreliable
+    if (!translatedTexts) {
+      translatedTexts = []
+      for (const item of chunk) {
+        try {
+          const r = await translate(item.en_value, { from: 'en', to: targetLang })
+          translatedTexts.push(r.text)
+        } catch (e: any) {
+          console.error(`[autoTranslateUI] Individual translation failed for "${targetLang}":`, e.message)
+          translatedTexts.push('')
+        }
+        await new Promise((r) => setTimeout(r, BATCH_DELAY_MS))
+      }
+    }
+
+    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: targetLang })
+        .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: targetLang,
+          value,
+          status: 'draft',
+        })
+      }
+    }
+
+    if (!translatedTexts && i + BATCH_SIZE < toTranslate.length) {
+      await new Promise((r) => setTimeout(r, BATCH_DELAY_MS))
+    }
+  }
+
+  console.log(`[autoTranslateUI] Done translating UI to "${targetLang}".`)
+}

package/server/utils/lang-api.util.ts

@@ -0,0 +1,24 @@
+/**
+ * Reconstruct a nested object from flat dot-separated keys
+ * e.g. { 'a.b': 'hello' } => { a: { b: 'hello' } }
+ */
+export function unflattenObject(flat: Record<string, string>, separator: string): Record<string, any> {
+	const result: Record<string, any> = {}
+
+	for (const [key, value] of Object.entries(flat)) {
+		const parts = key.split(separator)
+		let current = result
+
+		for (let i = 0; i < parts.length - 1; i++) {
+			const part = parts[i]
+			if (!(part in current) || typeof current[part] !== 'object') {
+				current[part] = {}
+			}
+			current = current[part]
+		}
+
+		current[parts[parts.length - 1]] = value
+	}
+
+	return result
+}

package/server/utils/mailer.util.ts

@@ -0,0 +1,80 @@
+import { useRuntimeConfig } from '#imports'
+
+export async function sendEmail({ to, subject, html }: { to: string; subject: string; html: string }) {
+  const config = useRuntimeConfig()
+
+  if (!config.smtpHost) {
+    // No SMTP configured — log to console as fallback
+    console.log(`\n[i18n-dashboard] 📧 Email (non envoyé — SMTP non configuré)`)
+    console.log(`  À      : ${to}`)
+    console.log(`  Sujet  : ${subject}`)
+    console.log(`  Contenu: ${html.replace(/<[^>]+>/g, ' ').replace(/\s+/g, ' ').trim()}\n`)
+    return
+  }
+
+  const nodemailer = await import('nodemailer')
+  const transporter = nodemailer.createTransport({
+    host: config.smtpHost as string,
+    port: Number(config.smtpPort) || 587,
+    secure: config.smtpSecure === 'true',
+    auth: config.smtpUser
+      ? { user: config.smtpUser as string, pass: config.smtpPass as string }
+      : undefined,
+  })
+
+  await transporter.sendMail({
+    from: config.smtpFrom as string || 'noreply@i18n-dashboard.local',
+    to,
+    subject,
+    html,
+  })
+}
+
+export function inviteEmailHtml({
+  name,
+  email,
+  tempPassword,
+  dashboardUrl,
+  projectName,
+  role,
+}: {
+  name: string
+  email: string
+  tempPassword: string
+  dashboardUrl: string
+  projectName?: string
+  role: string
+}) {
+  const roleLabels: Record<string, string> = {
+    translator: 'Traducteur',
+    moderator: 'Modérateur',
+    admin: 'Administrateur',
+  }
+  const scopeMsg = projectName
+    ? `sur le projet <strong>${projectName}</strong>`
+    : `sur tous les projets`
+
+  return `
+<!DOCTYPE html>
+<html>
+<body style="font-family: system-ui, sans-serif; max-width: 600px; margin: 0 auto; padding: 24px; color: #333;">
+  <div style="background: #4f46e5; padding: 24px; border-radius: 8px 8px 0 0;">
+    <h1 style="color: white; margin: 0; font-size: 1.5rem;">🌐 i18n Dashboard</h1>
+  </div>
+  <div style="background: #f9fafb; padding: 24px; border-radius: 0 0 8px 8px; border: 1px solid #e5e7eb;">
+    <h2>Bonjour ${name},</h2>
+    <p>Un compte a été créé pour vous sur <strong>i18n-dashboard</strong>.</p>
+    <p>Vous avez le rôle <strong>${roleLabels[role] || role}</strong> ${scopeMsg}.</p>
+    <div style="background: white; padding: 16px; border-radius: 6px; border: 1px solid #e5e7eb; margin: 20px 0;">
+      <p style="margin: 4px 0;"><strong>Email :</strong> ${email}</p>
+      <p style="margin: 4px 0;"><strong>Mot de passe temporaire :</strong> <code style="background: #f3f4f6; padding: 2px 8px; border-radius: 4px;">${tempPassword}</code></p>
+    </div>
+    <p>Connectez-vous et changez votre mot de passe dès que possible :</p>
+    <a href="${dashboardUrl}/login" style="display: inline-block; background: #4f46e5; color: white; padding: 12px 24px; border-radius: 6px; text-decoration: none; font-weight: 600;">Se connecter</a>
+    <p style="margin-top: 24px; font-size: 0.85rem; color: #6b7280;">
+      Si vous n'attendiez pas cet email, vous pouvez l'ignorer.
+    </p>
+  </div>
+</body>
+</html>`
+}

package/server/utils/project-config.util.ts

@@ -0,0 +1,37 @@
+import { existsSync, readFileSync } from 'fs'
+import { resolve } from 'path'
+import { useRuntimeConfig } from '#imports'
+
+import type { DashboardConfig } from '../interfaces/project-config.interface'
+
+let _cachedConfig: DashboardConfig | null = null
+
+export function readProjectConfig(): DashboardConfig {
+  if (_cachedConfig) return _cachedConfig
+
+  const config = useRuntimeConfig()
+  const projectRoot = (config.projectRoot as string || '').trim() || process.cwd()
+
+  const candidates = [
+    resolve(projectRoot, 'i18n-dashboard.config.json'),
+    resolve(projectRoot, 'i18n-dashboard.config.js'),
+    resolve(process.cwd(), 'i18n-dashboard.config.json'),
+    resolve(process.cwd(), 'i18n-dashboard.config.js'),
+  ]
+
+  for (const filePath of candidates) {
+    if (existsSync(filePath)) {
+      try {
+        const raw = readFileSync(filePath, 'utf-8')
+        _cachedConfig = JSON.parse(raw)
+        console.log(`[i18n-dashboard] Config file loaded: ${filePath}`)
+        return _cachedConfig!
+      } catch (e) {
+        console.warn(`[i18n-dashboard] Failed to parse config file: ${filePath}`, e)
+      }
+    }
+  }
+
+  _cachedConfig = {}
+  return _cachedConfig
+}