fix(yalocales): Nested JSON handling

Author: YaCodesDevelopment

yalocales/errors.go

@@ -11,6 +11,7 @@ var (
 	ErrSubMapNotFound         = errors.New("submap not found")
 	ErrKeyNotFound            = errors.New("key not found")
 	ErrNilLocale              = errors.New("nil locale")
+	ErrPathConflict           = errors.New("path conflict")
 	ErrMismatchedKeys         = errors.New("mismatched locale keys")
 	ErrDefaultCoverage        = errors.New("default language missing keys")
 	ErrMismatchedPlaceholders = errors.New("mismatched locale placeholders")

yalocales/locale.go

@@ -107,11 +107,19 @@ func (c *compiledLocale) insertByCompositeKey(key, value string) yaerrors.Error
 
 	keyPart := strings.SplitN(key, Separator, keySplitMaxParts)
 
-	if c.SubMap == nil {
-		c.SubMap = make(map[string]*compiledLocale)
+	if c.Value != "" {
+		return yaerrors.FromError(
+			http.StatusTeapot,
+			ErrPathConflict,
+			fmt.Sprintf("Key '%s' is a leaf and cannot contain subkeys", c.Key),
+		)
 	}
 
 	if len(keyPart) == keySplitMaxParts {
+		if c.SubMap == nil {
+			c.SubMap = make(map[string]*compiledLocale)
+		}
+
 		_, ok := c.SubMap[keyPart[0]]
 		if !ok {
 			c.SubMap[keyPart[0]] = &compiledLocale{
@@ -127,7 +135,19 @@ func (c *compiledLocale) insertByCompositeKey(key, value string) yaerrors.Error
 		return nil
 	}
 
-	if _, ok := c.SubMap[key]; ok {
+	if c.SubMap == nil {
+		c.SubMap = make(map[string]*compiledLocale)
+	}
+
+	if existing, ok := c.SubMap[key]; ok {
+		if existing != nil && existing.SubMap != nil {
+			return yaerrors.FromError(
+				http.StatusTeapot,
+				ErrPathConflict,
+				fmt.Sprintf("Key '%s' already exists as a namespace", key),
+			)
+		}
+
 		return yaerrors.FromError(
 			http.StatusTeapot,
 			ErrDuplicateKey,

yalocales/locales.go

@@ -298,6 +298,18 @@ func (l *YaLocalizer) GetJSONByCompositeKeyAndLang(
 	key string,
 	lang string,
 ) ([]byte, yaerrors.Error) {
+	if l.data[lang] == nil {
+		if l.fallbackLang != "" && lang != l.fallbackLang {
+			lang = l.fallbackLang
+		} else {
+			return nil, yaerrors.FromError(
+				http.StatusNotFound,
+				ErrInvalidLanguage,
+				fmt.Sprintf("Language '%s' not found", lang),
+			)
+		}
+	}
+
 	value, err := l.data[lang].retriveJSONByCompositeKey(key)
 	if err != nil {
 		if l.fallbackLang != "" && lang != l.fallbackLang {
@@ -325,6 +337,18 @@ func (l *YaLocalizer) GetValueByCompositeKeyAndLang(
 	key string,
 	lang string,
 ) (string, yaerrors.Error) {
+	if l.data[lang] == nil {
+		if l.fallbackLang != "" && lang != l.fallbackLang {
+			lang = l.fallbackLang
+		} else {
+			return "", yaerrors.FromError(
+				http.StatusNotFound,
+				ErrInvalidLanguage,
+				fmt.Sprintf("Language '%s' not found", lang),
+			)
+		}
+	}
+
 	value, err := l.data[lang].retriveValueByCompositeKey(key)
 	if err != nil {
 		if l.fallbackLang != "" && lang != l.fallbackLang {
@@ -526,7 +550,7 @@ func (l *YaLocalizer) loadFolder(fileSystem fs.FS, compositeKey string) yaerrors
 }
 
 func (l *YaLocalizer) processJSONFile(data []byte, lang, compositeKey string) yaerrors.Error {
-	var locales map[string]string
+	var locales map[string]json.RawMessage
 
 	err := json.Unmarshal(data, &locales)
 	if err != nil {
@@ -537,31 +561,95 @@ func (l *YaLocalizer) processJSONFile(data []byte, lang, compositeKey string) ya
 		)
 	}
 
-	for key, value := range locales {
-		fullKey := key
-
-		if compositeKey != "" {
-			fullKey = compositeKey + Separator + key
+	for key, rawValue := range locales {
+		if key == "" {
+			return yaerrors.FromError(
+				http.StatusTeapot,
+				ErrInvalidTranslation,
+				fmt.Sprintf("Empty translation key at path '%s'", compositeKey),
+			)
 		}
 
-		err := l.insertByCompositeKeyAndLang(fullKey, lang, value)
-		if err != nil {
-			return err.Wrap(fmt.Sprintf("Failed to insert locale at key '%s'", fullKey))
+		fullKey := l.joinCompositeKeys(compositeKey, key)
+
+		yaErr := l.processJSONNode(rawValue, lang, fullKey)
+		if yaErr != nil {
+			return yaErr.Wrap(fmt.Sprintf("Failed to process JSON node at key '%s'", fullKey))
 		}
 	}
 
 	return nil
 }
 
+func (l *YaLocalizer) processJSONNode(
+	rawValue json.RawMessage,
+	lang, fullKey string,
+) yaerrors.Error {
+	var value string
+	if err := json.Unmarshal(rawValue, &value); err == nil {
+		yaErr := l.insertByCompositeKeyAndLang(fullKey, lang, value)
+		if yaErr != nil {
+			return yaErr.Wrap(fmt.Sprintf("Failed to insert locale at key '%s'", fullKey))
+		}
+
+		return nil
+	}
+
+	var block map[string]json.RawMessage
+	if err := json.Unmarshal(rawValue, &block); err == nil {
+		for key, subRawValue := range block {
+			if key == "" {
+				return yaerrors.FromError(
+					http.StatusTeapot,
+					ErrInvalidTranslation,
+					fmt.Sprintf("Empty translation key at path '%s'", fullKey),
+				)
+			}
+
+			subKey := l.joinCompositeKeys(fullKey, key)
+
+			yaErr := l.processJSONNode(subRawValue, lang, subKey)
+			if yaErr != nil {
+				return yaErr.Wrap(fmt.Sprintf("Failed to process JSON block at key '%s'", subKey))
+			}
+		}
+
+		return nil
+	}
+
+	return yaerrors.FromError(
+		http.StatusTeapot,
+		ErrInvalidTranslation,
+		fmt.Sprintf(
+			"Invalid translation value at key '%s'; expected string or JSON object",
+			fullKey,
+		),
+	)
+}
+
+func (l *YaLocalizer) joinCompositeKeys(prefix, key string) string {
+	if prefix == "" {
+		return key
+	}
+
+	return prefix + Separator + key
+}
+
 func (l *YaLocalizer) insertByCompositeKeyAndLang(key, lang, value string) yaerrors.Error {
-	if _, ok := l.data[lang]; !ok {
-		keyPart := strings.SplitN(key, Separator, keySplitMaxParts)
+	if key == "" {
+		return yaerrors.FromError(
+			http.StatusTeapot,
+			ErrInvalidTranslation,
+			"Empty translation key is not allowed",
+		)
+	}
 
-		if len(keyPart) == keySplitMaxParts {
+	if _, ok := l.data[lang]; !ok {
+		if lang == "" {
 			return yaerrors.FromError(
 				http.StatusTeapot,
 				ErrInvalidLanguage,
-				"New languages must be populated top-to-bottom",
+				"Language tag cannot be empty",
 			)
 		}
 

yalocales/locales_test.go

@@ -121,7 +121,7 @@ func TestFormattedValueWithMap(t *testing.T) {
 		t.Fatalf("format value: %v", yaErr)
 	}
 
-	// nolint: goconst
+	//nolint: goconst
 	want := "This is a Formatable Locale Replacement"
 	if got != want {
 		t.Fatalf("unexpected formatted value: got %q want %q", got, want)
@@ -416,3 +416,79 @@ func TestGetDefaultLangValueByCompositeKeyNoDefaultLang(t *testing.T) {
 		t.Fatalf("unexpected error cause: %v", yaErr.Unwrap())
 	}
 }
+
+func TestLoadLocalesNestedBlocksMergedWithFolders(t *testing.T) {
+	sub, err := fs.Sub(localesFS, "testdata/nested_blocks_with_folders")
+	if err != nil {
+		t.Fatalf("failed to access sub fs: %v", err)
+	}
+
+	loc := yalocales.NewLocalizer("en", false)
+	if yaErr := loc.LoadLocales(sub); yaErr != nil {
+		t.Fatalf("load locales: %v", yaErr)
+	}
+
+	cases := []struct {
+		key  string
+		lang string
+		want string
+	}{
+		{key: "root", lang: "en", want: "Root"},
+		{key: "home.title", lang: "en", want: "Home"},
+		{key: "home.subtitle", lang: "ua", want: "Ласкаво просимо"},
+		{key: "home.cta", lang: "ua", want: "До дому"},
+	}
+
+	for _, tc := range cases {
+		got, yaErr := loc.GetValueByCompositeKeyAndLang(tc.key, tc.lang)
+		if yaErr != nil {
+			t.Fatalf("get value for key %q lang %q: %v", tc.key, tc.lang, yaErr)
+		}
+
+		if got != tc.want {
+			t.Fatalf(
+				"unexpected value for key %q lang %q: got %q want %q",
+				tc.key,
+				tc.lang,
+				got,
+				tc.want,
+			)
+		}
+	}
+
+	gotJSON, yaErr := loc.GetJSONByCompositeKeyAndLang("home", "en")
+	if yaErr != nil {
+		t.Fatalf("get JSON for key %q lang %q: %v", "home", "en", yaErr)
+	}
+
+	wantJSON, err := json.Marshal(map[string]string{
+		"cta":      "Go Home",
+		"subtitle": "Welcome",
+		"title":    "Home",
+	})
+	if err != nil {
+		t.Fatalf("marshal expected JSON: %v", err)
+	}
+
+	if string(gotJSON) != string(wantJSON) {
+		t.Fatalf("unexpected merged JSON: got %s want %s", string(gotJSON), string(wantJSON))
+	}
+}
+
+func TestLoadLocalesPathConflict(t *testing.T) {
+	sub, err := fs.Sub(localesFS, "testdata/path_conflict")
+	if err != nil {
+		t.Fatalf("failed to access sub fs: %v", err)
+	}
+
+	loc := yalocales.NewLocalizer("en", false)
+
+	yaErr := loc.LoadLocales(sub)
+	if yaErr == nil {
+		t.Fatalf("expected path conflict error, got nil")
+	}
+
+	if !errors.Is(yaErr.Unwrap(), yalocales.ErrPathConflict) {
+		t.Fatalf("unexpected error cause: %v", yaErr.Unwrap())
+	}
+}

yalocales/testdata/nested_blocks_with_folders/en.json

@@ -0,0 +1,7 @@
+{
+  "root": "Root",
+  "home": {
+    "title": "Home",
+    "subtitle": "Welcome"
+  }
+}

yalocales/testdata/nested_blocks_with_folders/home/en.json

@@ -0,0 +1,3 @@
+{
+  "cta": "Go Home"
+}

yalocales/testdata/nested_blocks_with_folders/home/ua.json

@@ -0,0 +1,3 @@
+{
+  "cta": "До дому"
+}

yalocales/testdata/nested_blocks_with_folders/ua.json

@@ -0,0 +1,7 @@
+{
+  "root": "Корінь",
+  "home": {
+    "title": "Дім",
+    "subtitle": "Ласкаво просимо"
+  }
+}

yalocales/testdata/path_conflict/en.json

@@ -0,0 +1,3 @@
+{
+  "section": "Leaf value"
+}

yalocales/testdata/path_conflict/section/en.json

@@ -0,0 +1,3 @@
+{
+  "child": "Nested value"
+}