jan/scripts/find-missing-translations.js

/**
 * Script to find missing translations in locale files for Jan
 *
 * Usage:
 *   node scripts/find-missing-translations.js [options]
 *
 * Options:
 *   --locale=<locale>   Only check a specific locale (e.g. --locale=id)
 *   --file=<file>       Only check a specific file (e.g. --file=common.json)
 *   --help              Show this help message
 */

const fs = require("fs")
const path = require("path")

// Process command line arguments
const args = process.argv.slice(2).reduce(
	(acc, arg) => {
		if (arg === "--help") {
			acc.help = true
		} else if (arg.startsWith("--locale=")) {
			acc.locale = arg.split("=")[1]
		} else if (arg.startsWith("--file=")) {
			acc.file = arg.split("=")[1]
		}
		return acc
	},
	{}
)

// Show help if requested
if (args.help) {
	console.log(`
Find Missing Translations for Jan

A utility script to identify missing translations across locale files.
Compares non-English locale files to the English ones to find any missing keys.

Usage:
  node scripts/find-missing-translations.js [options]

Options:
  --locale=<locale>   Only check a specific locale (e.g. --locale=id)
  --file=<file>       Only check a specific file (e.g. --file=common.json)
  --help              Show this help message

Output:
  - Generates a report of missing translations for the web-app
  `)
	process.exit(0)
}

// Path to the locales directory
const LOCALES_DIR = path.join(__dirname, "../web-app/src/locales")

// Recursively find all keys in an object
function findKeys(obj, parentKey = "") {
	let keys = []

	for (const [key, value] of Object.entries(obj)) {
		const currentKey = parentKey ? `${parentKey}.${key}` : key

		if (typeof value === "object" && value !== null) {
			// If value is an object, recurse
			keys = [...keys, ...findKeys(value, currentKey)]
		} else {
			// If value is a primitive, add the key
			keys.push(currentKey)
		}
	}

	return keys
}

// Get value at a dotted path in an object
function getValueAtPath(obj, path) {
	const parts = path.split(".")
	let current = obj

	for (const part of parts) {
		if (current === undefined || current === null) {
			return undefined
		}
		current = current[part]
	}

	return current
}

// Function to check translations
function checkTranslations() {
	// Get all locale directories (or filter to the specified locale)
	const allLocales = fs.readdirSync(LOCALES_DIR).filter((item) => {
		const stats = fs.statSync(path.join(LOCALES_DIR, item))
		return stats.isDirectory() && item !== "en" // Exclude English as it's our source
	})

	// Filter to the specified locale if provided
	const locales = args.locale ? allLocales.filter((locale) => locale === args.locale) : allLocales

	if (args.locale && locales.length === 0) {
		console.error(`Error: Locale '${args.locale}' not found in ${LOCALES_DIR}`)
		process.exit(1)
	}

	console.log(`Checking ${locales.length} non-English locale(s): ${locales.join(", ")}`)

	// Get all English JSON files
	const englishDir = path.join(LOCALES_DIR, "en")
	let englishFiles = fs.readdirSync(englishDir).filter((file) => file.endsWith(".json") && !file.startsWith("."))

	// Filter to the specified file if provided
	if (args.file) {
		if (!englishFiles.includes(args.file)) {
			console.error(`Error: File '${args.file}' not found in ${englishDir}`)
			process.exit(1)
		}
		englishFiles = englishFiles.filter((file) => file === args.file)
	}

	// Load file contents
	let englishFileContents

	try {
		englishFileContents = englishFiles.map((file) => ({
			name: file,
			content: JSON.parse(fs.readFileSync(path.join(englishDir, file), "utf8")),
		}))
	} catch (e) {
		console.error(`Error: File '${englishDir}' is not a valid JSON file`)
		process.exit(1)
	}

	console.log(
		`Checking ${englishFileContents.length} translation file(s): ${englishFileContents.map((f) => f.name).join(", ")}`
	)

	// Results object to store missing translations
	const missingTranslations = {}

	// For each locale, check for missing translations
	for (const locale of locales) {
		missingTranslations[locale] = {}

		for (const { name, content: englishContent } of englishFileContents) {
			const localeFilePath = path.join(LOCALES_DIR, locale, name)

			// Check if the file exists in the locale
			if (!fs.existsSync(localeFilePath)) {
				missingTranslations[locale][name] = { file: "File is missing entirely" }
				continue
			}

			// Load the locale file
			let localeContent

			try {
				localeContent = JSON.parse(fs.readFileSync(localeFilePath, "utf8"))
			} catch (e) {
				console.error(`Error: File '${localeFilePath}' is not a valid JSON file`)
				process.exit(1)
			}

			// Find all keys in the English file
			const englishKeys = findKeys(englishContent)

			// Check for missing keys in the locale file
			const missingKeys = []

			for (const key of englishKeys) {
				const englishValue = getValueAtPath(englishContent, key)
				const localeValue = getValueAtPath(localeContent, key)

				if (localeValue === undefined) {
					missingKeys.push({
						key,
						englishValue,
					})
				}
			}

			if (missingKeys.length > 0) {
				missingTranslations[locale][name] = missingKeys
			}
		}
	}

	return outputResults(missingTranslations)
}

// Function to output results
function outputResults(missingTranslations) {
	let hasMissingTranslations = false

	console.log(`\nMissing Translations Report:\n`)

	for (const [locale, files] of Object.entries(missingTranslations)) {
		if (Object.keys(files).length === 0) {
			console.log(`✅ ${locale}: No missing translations`)
			continue
		}

		hasMissingTranslations = true
		console.log(`📝 ${locale}:`)

		for (const [fileName, missingItems] of Object.entries(files)) {
			if (missingItems.file) {
				console.log(`  - ${fileName}: ${missingItems.file}`)
				continue
			}

			console.log(`  - ${fileName}: ${missingItems.length} missing translations`)

			for (const { key, englishValue } of missingItems) {
				console.log(`      ${key}: "${englishValue}"`)
			}
		}

		console.log("")
	}

	return hasMissingTranslations
}

// Main function to find missing translations
function findMissingTranslations() {
	try {
		console.log("Starting translation check for Jan web-app...")

		const hasMissingTranslations = checkTranslations()

		// Summary
		if (!hasMissingTranslations) {
			console.log("\n✅ All translations are complete!")
		} else {
			console.log("\n✏️  To add missing translations:")
			console.log("1. Add the missing keys to the corresponding locale files")
			console.log("2. Translate the English values to the appropriate language")
			console.log("3. You can use yq commands to update JSON files efficiently:")
			console.log("   yq -i '.namespace.key = \"Translation\"' web-app/src/locales/<locale>/<file>.json")
			console.log("4. Run this script again to verify all translations are complete")
			// Exit with error code to fail CI checks
			process.exit(1)
		}
	} catch (error) {
		console.error("Error:", error.message)
		console.error(error.stack)
		process.exit(1)
	}
}

// Run the main function
findMissingTranslations()