i18n-dashboard 0.1.0

package/server/api/export.get.ts

@@ -0,0 +1,64 @@
+import { getDb } from '../db/index'
+import { unflattenObject } from '#server/utils/lang-api.util'
+
+export default defineEventHandler(async (event) => {
+  const query = getQuery(event)
+  const projectId = query.project_id ? Number(query.project_id) : null
+  const lang = query.lang ? String(query.lang) : 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' })
+
+  const separator = project.key_separator || '.'
+
+  // ── Single language ────────────────────────────────────────────────────
+  if (lang) {
+    const language = await db('languages').where({ project_id: projectId, code: lang }).first()
+    if (!language) throw createError({ statusCode: 404, message: `Language '${lang}' not found` })
+
+    const rows = await db('translations as t')
+      .join('translation_keys as k', 't.key_id', 'k.id')
+      .where('t.language_code', lang)
+      .where('k.project_id', projectId)
+      .whereNotNull('t.value')
+      .select('k.key', 't.value')
+
+    const flat: Record<string, string> = {}
+    for (const row of rows) flat[row.key] = row.value
+
+    const nested = unflattenObject(flat, separator)
+    const filename = `${project.name.replace(/[^a-z0-9]/gi, '_')}_${lang}.json`
+
+    setHeader(event, 'Content-Type', 'application/json')
+    setHeader(event, 'Content-Disposition', `attachment; filename="${filename}"`)
+    return nested
+  }
+
+  // ── All languages ──────────────────────────────────────────────────────
+  const languages = await db('languages').where({ project_id: projectId }).select('code')
+
+  const combined: Record<string, any> = {}
+
+  for (const { code } of languages) {
+    const rows = await db('translations as t')
+      .join('translation_keys as k', 't.key_id', 'k.id')
+      .where('t.language_code', code)
+      .where('k.project_id', projectId)
+      .whereNotNull('t.value')
+      .select('k.key', 't.value')
+
+    const flat: Record<string, string> = {}
+    for (const row of rows) flat[row.key] = row.value
+
+    combined[code] = unflattenObject(flat, separator)
+  }
+
+  const filename = `${project.name.replace(/[^a-z0-9]/gi, '_')}_all.json`
+
+  setHeader(event, 'Content-Type', 'application/json')
+  setHeader(event, 'Content-Disposition', `attachment; filename="${filename}"`)
+  return combined
+})

package/server/api/formats/datetime/[id].delete.ts

@@ -0,0 +1,8 @@
+import { getDb } from '../../../db/index'
+
+export default defineEventHandler(async (event) => {
+  const id = Number(getRouterParam(event, 'id'))
+  const db = getDb()
+  await db('project_datetime_formats').where({ id }).delete()
+  return { ok: true }
+})

package/server/api/formats/datetime/[id].put.ts

@@ -0,0 +1,15 @@
+import { getDb } from '../../../db/index'
+
+export default defineEventHandler(async (event) => {
+  const id = Number(getRouterParam(event, 'id'))
+  const body = await readBody(event)
+  const { locale, name, options } = body
+  const db = getDb()
+  await db('project_datetime_formats').where({ id }).update({
+    locale,
+    name,
+    options: JSON.stringify(options || {}),
+  })
+  const row = await db('project_datetime_formats').where({ id }).first()
+  return { ...row, options: JSON.parse(row.options || '{}') }
+})

package/server/api/formats/datetime.get.ts

@@ -0,0 +1,11 @@
+import { getDb } from '../../db/index'
+
+export default defineEventHandler(async (event) => {
+  const { project_id } = getQuery(event)
+  if (!project_id) throw createError({ statusCode: 400, message: 'project_id is required' })
+  const db = getDb()
+  const rows = await db('project_datetime_formats')
+    .where({ project_id: Number(project_id) })
+    .orderBy('locale').orderBy('name')
+  return rows.map((r: any) => ({ ...r, options: JSON.parse(r.options || '{}') }))
+})

package/server/api/formats/datetime.post.ts

@@ -0,0 +1,16 @@
+import { getDb } from '../../db/index'
+
+export default defineEventHandler(async (event) => {
+  const body = await readBody(event)
+  const { project_id, locale, name, options } = body
+  if (!project_id || !locale || !name) throw createError({ statusCode: 400, message: 'project_id, locale and name are required' })
+  const db = getDb()
+  const [id] = await db('project_datetime_formats').insert({
+    project_id: Number(project_id),
+    locale,
+    name,
+    options: JSON.stringify(options || {}),
+  })
+  const row = await db('project_datetime_formats').where({ id }).first()
+  return { ...row, options: JSON.parse(row.options || '{}') }
+})

package/server/api/formats/modifiers/[id].delete.ts

@@ -0,0 +1,8 @@
+import { getDb } from '../../../db/index'
+
+export default defineEventHandler(async (event) => {
+  const id = Number(getRouterParam(event, 'id'))
+  const db = getDb()
+  await db('project_modifiers').where({ id }).delete()
+  return { ok: true }
+})

package/server/api/formats/modifiers/[id].put.ts

@@ -0,0 +1,10 @@
+import { getDb } from '../../../db/index'
+
+export default defineEventHandler(async (event) => {
+  const id = Number(getRouterParam(event, 'id'))
+  const body = await readBody(event)
+  const { name, body: fnBody } = body
+  const db = getDb()
+  await db('project_modifiers').where({ id }).update({ name, body: fnBody })
+  return db('project_modifiers').where({ id }).first()
+})

package/server/api/formats/modifiers.get.ts

@@ -0,0 +1,10 @@
+import { getDb } from '../../db/index'
+
+export default defineEventHandler(async (event) => {
+  const { project_id } = getQuery(event)
+  if (!project_id) throw createError({ statusCode: 400, message: 'project_id is required' })
+  const db = getDb()
+  return db('project_modifiers')
+    .where({ project_id: Number(project_id) })
+    .orderBy('name')
+})

package/server/api/formats/modifiers.post.ts

@@ -0,0 +1,14 @@
+import { getDb } from '../../db/index'
+
+export default defineEventHandler(async (event) => {
+  const body = await readBody(event)
+  const { project_id, name, body: fnBody } = body
+  if (!project_id || !name || !fnBody) throw createError({ statusCode: 400, message: 'project_id, name and body are required' })
+  const db = getDb()
+  const [id] = await db('project_modifiers').insert({
+    project_id: Number(project_id),
+    name,
+    body: fnBody,
+  })
+  return db('project_modifiers').where({ id }).first()
+})

package/server/api/formats/number/[id].delete.ts

@@ -0,0 +1,8 @@
+import { getDb } from '../../../db/index'
+
+export default defineEventHandler(async (event) => {
+  const id = Number(getRouterParam(event, 'id'))
+  const db = getDb()
+  await db('project_number_formats').where({ id }).delete()
+  return { ok: true }
+})

package/server/api/formats/number/[id].put.ts

@@ -0,0 +1,15 @@
+import { getDb } from '../../../db/index'
+
+export default defineEventHandler(async (event) => {
+  const id = Number(getRouterParam(event, 'id'))
+  const body = await readBody(event)
+  const { locale, name, options } = body
+  const db = getDb()
+  await db('project_number_formats').where({ id }).update({
+    locale,
+    name,
+    options: JSON.stringify(options || {}),
+  })
+  const row = await db('project_number_formats').where({ id }).first()
+  return { ...row, options: JSON.parse(row.options || '{}') }
+})

package/server/api/formats/number.get.ts

@@ -0,0 +1,11 @@
+import { getDb } from '../../db/index'
+
+export default defineEventHandler(async (event) => {
+  const { project_id } = getQuery(event)
+  if (!project_id) throw createError({ statusCode: 400, message: 'project_id is required' })
+  const db = getDb()
+  const rows = await db('project_number_formats')
+    .where({ project_id: Number(project_id) })
+    .orderBy('locale').orderBy('name')
+  return rows.map((r: any) => ({ ...r, options: JSON.parse(r.options || '{}') }))
+})

package/server/api/formats/number.post.ts

@@ -0,0 +1,16 @@
+import { getDb } from '../../db/index'
+
+export default defineEventHandler(async (event) => {
+  const body = await readBody(event)
+  const { project_id, locale, name, options } = body
+  if (!project_id || !locale || !name) throw createError({ statusCode: 400, message: 'project_id, locale and name are required' })
+  const db = getDb()
+  const [id] = await db('project_number_formats').insert({
+    project_id: Number(project_id),
+    locale,
+    name,
+    options: JSON.stringify(options || {}),
+  })
+  const row = await db('project_number_formats').where({ id }).first()
+  return { ...row, options: JSON.parse(row.options || '{}') }
+})

package/server/api/formats/snippet.get.ts

@@ -0,0 +1,87 @@
+import { getDb } from '../../db/index'
+
+export default defineEventHandler(async (event) => {
+  const { project_id } = getQuery(event)
+  if (!project_id) throw createError({ statusCode: 400, message: 'project_id is required' })
+  const db = getDb()
+  const pid = Number(project_id)
+
+  const [numRows, dtRows, modRows, languages] = await Promise.all([
+    db('project_number_formats').where({ project_id: pid }).orderBy('locale').orderBy('name'),
+    db('project_datetime_formats').where({ project_id: pid }).orderBy('locale').orderBy('name'),
+    db('project_modifiers').where({ project_id: pid }).orderBy('name'),
+    db('languages').where({ project_id: pid }).orderBy('is_default', 'desc').orderBy('code'),
+  ])
+
+  // Build numberFormats object
+  const numberFormats: Record<string, Record<string, any>> = {}
+  for (const row of numRows) {
+    if (!numberFormats[row.locale]) numberFormats[row.locale] = {}
+    numberFormats[row.locale][row.name] = JSON.parse(row.options || '{}')
+  }
+
+  // Build datetimeFormats object
+  const datetimeFormats: Record<string, Record<string, any>> = {}
+  for (const row of dtRows) {
+    if (!datetimeFormats[row.locale]) datetimeFormats[row.locale] = {}
+    datetimeFormats[row.locale][row.name] = JSON.parse(row.options || '{}')
+  }
+
+  // Build modifiers
+  const modifiers: Record<string, string> = {}
+  for (const row of modRows) {
+    modifiers[row.name] = row.body
+  }
+
+  const defaultLang = languages.find((l: any) => l.is_default)?.code || languages[0]?.code || 'en'
+
+  // Generate snippet
+  const lines: string[] = []
+  lines.push(`import { createI18n } from 'vue-i18n'`)
+  lines.push(``)
+
+  if (Object.keys(numberFormats).length) {
+    lines.push(`const numberFormats = ${JSON.stringify(numberFormats, null, 2)}`)
+    lines.push(``)
+  }
+
+  if (Object.keys(datetimeFormats).length) {
+    lines.push(`const datetimeFormats = ${JSON.stringify(datetimeFormats, null, 2)}`)
+    lines.push(``)
+  }
+
+  lines.push(`const i18n = createI18n({`)
+  lines.push(`  locale: '${defaultLang}',`)
+  lines.push(`  legacy: false,`)
+
+  if (Object.keys(numberFormats).length) {
+    lines.push(`  numberFormats,`)
+  }
+  if (Object.keys(datetimeFormats).length) {
+    lines.push(`  datetimeFormats,`)
+  }
+
+  if (Object.keys(modifiers).length) {
+    lines.push(`  modifiers: {`)
+    for (const [name, body] of Object.entries(modifiers)) {
+      lines.push(`    ${name}: ${body},`)
+    }
+    lines.push(`  },`)
+  }
+
+  lines.push(`  messages: {`)
+  for (const lang of languages) {
+    lines.push(`    ${lang.code}: await fetch('[your-dashboard-url]/locale/${lang.code}.json').then(r => r.json()),`)
+  }
+  lines.push(`  },`)
+  lines.push(`})`)
+  lines.push(``)
+  lines.push(`export default i18n`)
+
+  return {
+    snippet: lines.join('\n'),
+    numberFormats,
+    datetimeFormats,
+    modifiers,
+  }
+})

package/server/api/fs/browse.get.ts

@@ -0,0 +1,50 @@
+import { readdirSync, statSync, existsSync } from 'fs'
+import { resolve, join, dirname, sep } from 'path'
+import { homedir } from 'os'
+
+export default defineEventHandler(async (event) => {
+  const query = getQuery(event)
+  const rawPath = query.path && String(query.path).trim() ? String(query.path).trim() : homedir()
+
+  const absolutePath = resolve(rawPath)
+
+  if (!existsSync(absolutePath)) {
+    throw createError({ statusCode: 404, message: `Path not found: ${absolutePath}` })
+  }
+
+  const stat = statSync(absolutePath)
+  if (!stat.isDirectory()) {
+    throw createError({ statusCode: 400, message: 'Path is not a directory' })
+  }
+
+  let entries: { name: string; path: string }[] = []
+  try {
+    entries = readdirSync(absolutePath, { withFileTypes: true })
+      .filter(e => e.isDirectory() && !e.name.startsWith('.'))
+      .sort((a, b) => a.name.localeCompare(b.name))
+      .map(e => ({ name: e.name, path: join(absolutePath, e.name) }))
+  } catch {
+    entries = []
+  }
+
+  // Build breadcrumbs from path segments
+  const parts = absolutePath.split(sep).filter(Boolean)
+  const breadcrumbs = parts.map((part, i) => ({
+    name: part || sep,
+    path: sep + parts.slice(0, i + 1).join(sep),
+  }))
+  // Add root on unix
+  if (absolutePath.startsWith(sep)) {
+    breadcrumbs.unshift({ name: sep, path: sep })
+  }
+
+  const parent = absolutePath !== sep ? dirname(absolutePath) : null
+
+  return {
+    current: absolutePath,
+    parent,
+    home: homedir(),
+    breadcrumbs,
+    entries,
+  }
+})

package/server/api/history/[translationId].get.ts

@@ -0,0 +1,13 @@
+import { getDb } from '../../db/index'
+
+export default defineEventHandler(async (event) => {
+  const translationId = getRouterParam(event, 'translationId')
+  const db = getDb()
+
+  const history = await db('translation_history')
+    .where({ translation_id: Number(translationId) })
+    .orderBy('changed_at', 'desc')
+    .limit(50)
+
+  return history
+})

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

@@ -0,0 +1,14 @@
+import { getDb } from '../../db/index'
+
+export default defineEventHandler(async (event) => {
+  const id = getRouterParam(event, 'id')
+  const db = getDb()
+
+  const key = await db('translation_keys').where({ id: Number(id) }).first()
+  if (!key) {
+    throw createError({ statusCode: 404, message: 'Key not found' })
+  }
+
+  await db('translation_keys').where({ id: Number(id) }).delete()
+  return { success: true }
+})

package/server/api/keys/[id].get.ts

@@ -0,0 +1,41 @@
+import { getDb } from '../../db/index'
+
+export default defineEventHandler(async (event) => {
+  const id = getRouterParam(event, 'id')
+  const db = getDb()
+
+  const key = await db('translation_keys').where({ id: Number(id) }).first()
+  if (!key) throw createError({ statusCode: 404, message: 'Key not found' })
+
+  const languages = await db('languages')
+    .where({ project_id: key.project_id })
+    .orderBy('is_default', 'desc')
+    .orderBy('name', 'asc')
+
+  const translations = await db('translations')
+    .where({ key_id: Number(id) })
+    .select('*')
+
+  const usages = await db('key_usages')
+    .where({ key_id: Number(id) })
+    .select('*')
+    .orderBy('file_path', 'asc')
+    .orderBy('line_number', 'asc')
+
+  // Build translations map + fetch history per translation
+  const translationMap: Record<string, any> = {}
+  for (const tr of translations) {
+    const history = await db('translation_history')
+      .where({ translation_id: tr.id })
+      .orderBy('changed_at', 'desc')
+      .limit(20)
+    translationMap[tr.language_code] = { ...tr, history }
+  }
+
+  return {
+    ...key,
+    languages,
+    translations: translationMap,
+    usages,
+  }
+})

package/server/api/keys/[id].patch.ts

@@ -0,0 +1,20 @@
+import { getDb } from '../../db/index'
+
+export default defineEventHandler(async (event) => {
+  const id = getRouterParam(event, 'id')
+  const body = await readBody(event)
+  const { description } = body
+
+  const db = getDb()
+
+  const key = await db('translation_keys').where({ id: Number(id) }).first()
+  if (!key) {
+    throw createError({ statusCode: 404, message: 'Key not found' })
+  }
+
+  await db('translation_keys')
+    .where({ id: Number(id) })
+    .update({ description: description ?? null })
+
+  return db('translation_keys').where({ id: Number(id) }).first()
+})

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

@@ -0,0 +1,98 @@
+import { getDb } from '../../db/index'
+
+export default defineEventHandler(async (event) => {
+  const query = getQuery(event)
+  const { project_id, search, page = 1, limit = 50, lang, status } = query
+
+  if (!project_id) throw createError({ statusCode: 400, message: 'project_id is required' })
+
+  const db = getDb()
+  const offset = (Number(page) - 1) * Number(limit)
+
+  const languages = await db('languages')
+    .where({ project_id: Number(project_id) })
+    .select('*')
+    .orderBy('is_default', 'desc')
+    .orderBy('name', 'asc')
+
+  let keysQuery = db('translation_keys as tk')
+    .where('tk.project_id', Number(project_id))
+    .select('tk.*')
+    .orderBy('tk.key', 'asc')
+
+  if (search) {
+    keysQuery = keysQuery.where('tk.key', 'like', `%${search}%`)
+  }
+
+  if (status === 'unused') {
+    keysQuery = keysQuery.where('tk.is_unused', true)
+  } else if (status === 'missing' && lang && lang !== 'all') {
+    keysQuery = keysQuery.whereNotExists(
+      db('translations as t')
+        .where('t.key_id', db.ref('tk.id'))
+        .where('t.language_code', lang as string)
+        .whereNotNull('t.value')
+        .where('t.value', '!=', '')
+        .select('t.id'),
+    )
+  } else if (lang && lang !== 'all') {
+    if (status && status !== 'all') {
+      keysQuery = keysQuery.whereExists(
+        db('translations as t')
+          .where('t.key_id', db.ref('tk.id'))
+          .where('t.language_code', lang as string)
+          .where('t.status', status as string)
+          .select('t.id'),
+      )
+    }
+  } else if (status && status !== 'all' && status !== 'unused') {
+    keysQuery = keysQuery.whereExists(
+      db('translations as t')
+        .where('t.key_id', db.ref('tk.id'))
+        .where('t.status', status as string)
+        .select('t.id'),
+    )
+  }
+
+  const totalQuery = keysQuery.clone().clearOrder().clearSelect().count('* as count')
+  const [{ count }] = await totalQuery
+  const total = Number(count)
+
+  const keys = await keysQuery.offset(offset).limit(Number(limit))
+  const keyIds = keys.map((k: any) => k.id)
+
+  let translations: any[] = []
+  if (keyIds.length > 0) {
+    translations = await db('translations as t')
+      .whereIn('t.key_id', keyIds)
+      .select('t.*')
+  }
+
+  let usages: any[] = []
+  if (keyIds.length > 0) {
+    usages = await db('key_usages')
+      .whereIn('key_id', keyIds)
+      .select('key_id', 'file_path', 'line_number', 'detected_function')
+      .orderBy('file_path', 'asc')
+  }
+
+  const translationMap: Record<number, Record<string, any>> = {}
+  for (const tr of translations) {
+    if (!translationMap[tr.key_id]) translationMap[tr.key_id] = {}
+    translationMap[tr.key_id][tr.language_code] = tr
+  }
+
+  const usageMap: Record<number, any[]> = {}
+  for (const u of usages) {
+    if (!usageMap[u.key_id]) usageMap[u.key_id] = []
+    usageMap[u.key_id].push(u)
+  }
+
+  const result = keys.map((key: any) => ({
+    ...key,
+    translations: translationMap[key.id] || {},
+    usages: usageMap[key.id] || [],
+  }))
+
+  return { data: result, total, page: Number(page), limit: Number(limit), languages }
+})

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

@@ -0,0 +1,17 @@
+import { getDb } from '../../db/index'
+
+export default defineEventHandler(async (event) => {
+  const body = await readBody(event)
+  const { project_id, key, description } = body
+
+  if (!project_id) throw createError({ statusCode: 400, message: 'project_id is required' })
+  if (!key) throw createError({ statusCode: 400, message: 'key is required' })
+
+  const db = getDb()
+
+  const existing = await db('translation_keys').where({ project_id: Number(project_id), key }).first()
+  if (existing) throw createError({ statusCode: 409, message: 'Key already exists' })
+
+  const [id] = await db('translation_keys').insert({ project_id: Number(project_id), key, description })
+  return db('translation_keys').where({ id }).first()
+})

package/server/api/languages/[code].delete.ts

@@ -0,0 +1,15 @@
+import { getDb } from '../../db/index'
+
+export default defineEventHandler(async (event) => {
+  const code = getRouterParam(event, 'code')
+  const { project_id } = getQuery(event)
+
+  if (!project_id) throw createError({ statusCode: 400, message: 'project_id is required' })
+
+  const db = getDb()
+  const language = await db('languages').where({ project_id: Number(project_id), code }).first()
+  if (!language) throw createError({ statusCode: 404, message: 'Language not found' })
+
+  await db('languages').where({ id: language.id }).delete()
+  return { success: true }
+})

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

@@ -0,0 +1,24 @@
+import { getDb } from '../../db/index'
+
+export default defineEventHandler(async (event) => {
+  const id = Number(getRouterParam(event, 'id'))
+  const body = await readBody(event)
+  const { fallback_code, name, is_default } = body
+
+  const db = getDb()
+  const lang = await db('languages').where({ id }).first()
+  if (!lang) throw createError({ statusCode: 404, message: 'Language not found' })
+
+  if (is_default) {
+    await db('languages').where({ project_id: lang.project_id }).update({ is_default: false })
+  }
+
+  const updates: Record<string, any> = {}
+  if (name !== undefined) updates.name = name
+  if (is_default !== undefined) updates.is_default = is_default
+  // fallback_code: null = aucun fallback explicite (auto BCP 47 prend le relais)
+  if ('fallback_code' in body) updates.fallback_code = fallback_code || null
+
+  await db('languages').where({ id }).update(updates)
+  return db('languages').where({ id }).first()
+})

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

@@ -0,0 +1,13 @@
+import { getDb } from '../../db/index'
+
+export default defineEventHandler(async (event) => {
+  const { project_id } = getQuery(event)
+  if (!project_id) throw createError({ statusCode: 400, message: 'project_id is required' })
+
+  const db = getDb()
+  return db('languages')
+    .where({ project_id: Number(project_id) })
+    .select('*')
+    .orderBy('is_default', 'desc')
+    .orderBy('name', 'asc')
+})