134 lines
4.0 KiB
TypeScript
134 lines
4.0 KiB
TypeScript
import "server-only";
|
|
import { createHash } from "node:crypto";
|
|
import fs from "node:fs/promises";
|
|
import path from "node:path";
|
|
import { cache } from "react";
|
|
import { type AppLocale, isSupportedLocale } from "@/i18n/locales";
|
|
import type { MessageTree } from "@/i18n/merge-messages";
|
|
import { validateCmsMessage } from "./cms-message-validation";
|
|
import { logger } from "./logger";
|
|
import {
|
|
withGamedataLock,
|
|
writeGamedataJsonAtomic,
|
|
} from "./services/import/core/gamedata-json";
|
|
import { flattenObject, unflattenObject } from "./translations-utils";
|
|
|
|
const defaultRoot = path.join(
|
|
/*turbopackIgnore: true*/ process.cwd(),
|
|
"storage",
|
|
"cms-translations",
|
|
);
|
|
export interface CmsTranslationSnapshot {
|
|
messages: Record<string, string>;
|
|
revision: string;
|
|
}
|
|
export class CmsTranslationError extends Error {
|
|
constructor(
|
|
public readonly code:
|
|
| "conflict"
|
|
| "unknownKey"
|
|
| "empty"
|
|
| "invalid"
|
|
| "variables",
|
|
public readonly key = "",
|
|
) {
|
|
super(`${code}: ${key}`);
|
|
}
|
|
}
|
|
async function bundled(locale: AppLocale): Promise<Record<string, string>> {
|
|
return flattenObject((await import(`../messages/${locale}.json`)).default);
|
|
}
|
|
async function readOverrides(file: string): Promise<Record<string, string>> {
|
|
try {
|
|
const parsed: unknown = JSON.parse(
|
|
await fs.readFile(/*turbopackIgnore: true*/ file, "utf8"),
|
|
);
|
|
if (
|
|
!parsed ||
|
|
typeof parsed !== "object" ||
|
|
Array.isArray(parsed) ||
|
|
Object.values(parsed).some((v) => typeof v !== "string")
|
|
)
|
|
throw new Error("Invalid CMS translation override file");
|
|
return parsed as Record<string, string>;
|
|
} catch (error) {
|
|
if ((error as NodeJS.ErrnoException).code === "ENOENT") return {};
|
|
throw error;
|
|
}
|
|
}
|
|
function localeFile(locale: AppLocale, root: string) {
|
|
if (!isSupportedLocale(locale)) throw new Error("Unsupported locale");
|
|
return path.join(root, `${locale}.json`);
|
|
}
|
|
export async function readCmsTranslation(
|
|
locale: AppLocale,
|
|
root = defaultRoot,
|
|
): Promise<CmsTranslationSnapshot> {
|
|
const [base, source, overrides] = await Promise.all([
|
|
bundled(locale),
|
|
bundled("en"),
|
|
readOverrides(localeFile(locale, root)),
|
|
]);
|
|
const messages = { ...base };
|
|
for (const [key, value] of Object.entries(overrides)) {
|
|
// Obsolete or incompatible overrides must not break new releases.
|
|
if (!Object.hasOwn(source, key) || validateCmsMessage(value, source[key]))
|
|
continue;
|
|
messages[key] = value;
|
|
}
|
|
return {
|
|
messages,
|
|
revision: createHash("sha256")
|
|
.update(JSON.stringify([base, overrides]))
|
|
.digest("hex"),
|
|
};
|
|
}
|
|
export async function saveCmsTranslation(
|
|
locale: AppLocale,
|
|
revision: string,
|
|
changes: Record<string, string | null>,
|
|
root = defaultRoot,
|
|
): Promise<CmsTranslationSnapshot> {
|
|
const file = localeFile(locale, root);
|
|
await fs.mkdir(root, { recursive: true });
|
|
return withGamedataLock(file, async () => {
|
|
const current = await readCmsTranslation(locale, root);
|
|
if (current.revision !== revision)
|
|
throw new CmsTranslationError("conflict");
|
|
const [base, source, overrides] = await Promise.all([
|
|
bundled(locale),
|
|
bundled("en"),
|
|
readOverrides(file),
|
|
]);
|
|
for (const [key, value] of Object.entries(changes)) {
|
|
if (!Object.hasOwn(source, key))
|
|
throw new CmsTranslationError("unknownKey", key);
|
|
if (value === null || value === base[key]) {
|
|
delete overrides[key];
|
|
continue;
|
|
}
|
|
const issue = validateCmsMessage(value, source[key]);
|
|
if (issue) throw new CmsTranslationError(issue, key);
|
|
overrides[key] = value;
|
|
}
|
|
await writeGamedataJsonAtomic(file, overrides);
|
|
return readCmsTranslation(locale, root);
|
|
});
|
|
}
|
|
/** Per-request deduplication; runtime edits are visible on the next request. */
|
|
export const loadCmsMessages = cache(
|
|
async (locale: AppLocale): Promise<MessageTree> => {
|
|
try {
|
|
return unflattenObject(
|
|
(await readCmsTranslation(locale)).messages,
|
|
) as MessageTree;
|
|
} catch (error) {
|
|
logger.error("CMS translation overrides could not be loaded", {
|
|
locale,
|
|
error,
|
|
});
|
|
return (await import(`../messages/${locale}.json`)).default;
|
|
}
|
|
},
|
|
);
|