Implement zod checking on translator compiler

front/src/Translator/TranslationCompiler.ts

@@ -1,4 +1,5 @@
 import fs from "fs";
+import { z } from "zod";
 
 export type LanguageFound = {
     id: string;
@@ -7,6 +8,10 @@ export type LanguageFound = {
     default: boolean;
 };
 
+type LanguageObject = {
+    [key: string]: string | boolean | LanguageObject;
+};
+
 const translationsBasePath = "./translations";
 const fallbackLanguage = process.env.FALLBACK_LANGUAGE || "en-US";
 
@@ -27,17 +32,23 @@ const getAllLanguagesByFiles = (dirPath: string, languages: Array<LanguageFound>
             const rawData = fs.readFileSync(dirPath + "/" + file, "utf-8");
             const languageObject = JSON.parse(rawData);
 
-            if (
-                "language" in languageObject && typeof languageObject.language === "string" &&
-                "country" in languageObject && typeof languageObject.country === "string" &&
-                "default" in languageObject && typeof languageObject.default === "boolean"
-            ) {
+            const indexLanguageObject = z.object({
+                language: z.string(),
+                country: z.string(),
+                default: z.boolean(),
+            });
+
+            try {
+                const indexLanguage = indexLanguageObject.parse(languageObject);
+
                 languages?.push({
                     id: parts[1],
-                    language: languageObject.language,
-                    country: languageObject.country,
-                    default: languageObject.default
+                    language: indexLanguage.language,
+                    country: indexLanguage.country,
+                    default: indexLanguage.default,
                 });
+            } catch (e) {
+                console.error(e);
             }
         }
     });
@@ -45,7 +56,7 @@ const getAllLanguagesByFiles = (dirPath: string, languages: Array<LanguageFound>
     return languages;
 };
 
-const getFallbackLanguageObject = (dirPath: string, languageObject: Object | undefined) => {
+const getFallbackLanguageObject = (dirPath: string, languageObject: LanguageObject | undefined) => {
     const files = fs.readdirSync(dirPath);
     languageObject = languageObject || {};
 
@@ -59,8 +70,19 @@ const getFallbackLanguageObject = (dirPath: string, languageObject: Object | und
                 return;
             }
 
-            const rawData = fs.readFileSync(dirPath + "/" + file, "utf-8");
-            languageObject = { ...languageObject, ...JSON.parse(rawData) };
+            const data = JSON.parse(fs.readFileSync(dirPath + "/" + file, "utf-8"));
+
+            try {
+                const languageObjectFormat: z.ZodType<LanguageObject> = z.lazy(() => {
+                    return z.object({}).catchall(z.union([z.string(), z.boolean(), languageObjectFormat]));
+                });
+
+                const languageObjectData = languageObjectFormat.parse(data);
+
+                languageObject = { ...languageObject, ...languageObjectData };
+            } catch (e) {
+                console.error(e);
+            }
         }
     });
 

front/src/Translator/Translator.ts

@@ -5,10 +5,6 @@ export type Language = {
     country: string;
 };
 
-type LanguageObject = {
-    [key: string]: string | LanguageObject;
-};
-
 type TranslationParams = {
     [key: string]: string | number;
 };
@@ -19,7 +15,7 @@ class Translator {
         country: "US",
     };
 
-    private readonly fallbackLanguageObject: LanguageObject = FALLBACK_LANGUAGE_OBJECT as LanguageObject;
+    private readonly fallbackLanguageObject: LanguageObject = FALLBACK_LANGUAGE_OBJECT;
 
     /**
      * Current language
@@ -186,10 +182,14 @@ class Translator {
      */
     private getObjectValueByPath(key: string, object: LanguageObject): string | undefined {
         const paths = key.split(".");
-        let currentValue: LanguageObject | string = object;
+        let currentValue: string | boolean | LanguageObject = object;
 
         for (const path of paths) {
-            if (typeof currentValue === "string" || currentValue[path] === undefined) {
+            if (
+                typeof currentValue === "string" ||
+                typeof currentValue === "boolean" ||
+                currentValue[path] === undefined
+            ) {
                 return undefined;
             }
 

front/src/define-plugin.d.ts

@@ -1,5 +1,5 @@
 type LanguageObject = {
-    [key: string]: string | LanguageObject;
+    [key: string]: string | boolean | LanguageObject;
 };
 
 type LanguageFound = {