haveapi-go-client 0.28.4 → 0.29.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6f8e8ca71c9d33fc75d52ba7763c7d474a51a2d17db5467d40fd769a285217cf
-  data.tar.gz: 2ff6be50150de27d116dd272f0987d40d2eaa3f57ff09e8f71ce3a611ca0969e
+  metadata.gz: fa106a3e9f534f8b38eb7dad77a01c8a93e0eec07cf2ff1a847e1310e4b66445
+  data.tar.gz: e1606903a5b5991eda7ce2ae2ac7df59e623f7b2fadad2f45ec2e6cb84568f6b
 SHA512:
-  metadata.gz: '0192a300f26c9562803e3ab6d1a9286b623be01e4a59e72686122c21a9f81cc52d2857a46caee4f3e1056ff705b9222af246bbd2ae90f663a7a527e432856688'
-  data.tar.gz: f0320e8d633d6a3bd023b333213c86fc5cf0a81501967311b4c04333951aa194f17391473d90a8c9093eca950e28859d964128a2da1c0e680e1a6dfa657567f0
+  metadata.gz: 8850e3b1488d265ba0b20fc79a94cf4d9d9bf07c628d8538b4c00aae7a5f744536f637d3bd0f2ca4bb11afd56314b84e5971d624260f2230cf62d62b55fb85d2
+  data.tar.gz: e55cabd02c8f5751d9d7f81c46cba29e15b2c90ecb5036457bcb362091ca3c09e6a98e723d9a34bba4ef06a5208bd5ed3c5e7c9dd95cc4963a09baeb99cbba67

data/README.md

@@ -46,6 +46,7 @@ import (
 
 func main() {
 	api := client.New("https://api.vpsfree.cz")
+	api.SetLanguage("cs")
 	api.SetBasicAuthentication("admin", "secret")
 
 	action := api.Cluster.PublicStats.Prepare()
@@ -62,3 +63,17 @@ func main() {
 	fmt.Printf("%+v\n", resp.Output)
 }
 ```
+
+## Localization
+
+Generated clients include bundled HaveAPI client translations. Set the
+language before making requests:
+
+```go
+api := client.New("https://api.vpsfree.cz")
+api.SetLanguage("cs")
+```
+
+The value is sent in `Accept-Language` by default. Use
+`SetLanguageHeader("X-Language")` when the API is configured with a custom
+language header.

data/haveapi-go-client.gemspec

@@ -18,5 +18,5 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
 
-  spec.add_dependency 'haveapi-client', '~> 0.28.4'
+  spec.add_dependency 'haveapi-client', '~> 0.29.0'
 end

data/lib/haveapi/go_client/generator.rb

@@ -1,4 +1,5 @@
 require 'fileutils'
+require 'yaml'
 require 'haveapi/client'
 require 'haveapi/go_client/utils'
 
@@ -50,12 +51,13 @@ module HaveAPI::GoClient
         FileUtils.mkpath(dst)
       end
 
-      %w[client authentication request response types].each do |v|
+      %w[client authentication request response types i18n].each do |v|
         ErbTemplate.render_to_if_changed(
           "#{v}.go",
           {
             package:,
-            api:
+            api:,
+            i18n_messages:
           },
           File.join(dst, "#{v}.go")
         )
@@ -74,5 +76,12 @@ module HaveAPI::GoClient
     protected
 
     attr_reader :api
+
+    def i18n_messages
+      @i18n_messages ||= YAML.safe_load_file(
+        File.expand_path('i18n_messages.yml', __dir__),
+        aliases: true
+      )
+    end
   end
 end

data/lib/haveapi/go_client/i18n_messages.yml

@@ -0,0 +1,82 @@
+# This file is generated from i18n/haveapi.yml.
+# Do not edit it manually; manual changes will be overwritten.
+# Update i18n/haveapi.yml and run bundle exec rake i18n:update.
+---
+en:
+  authentication:
+    callback_failed: "%{callback} failed: %{error}"
+    callback_invalid_return: callback has to return an array or 'stop'
+    callback_required: Implement callback %{callback}
+    invalid_credentials: invalid credentials
+    invalid_oauth2_pkce_verifier: Invalid OAuth2 PKCE verifier
+    invalid_oauth2_state: Invalid OAuth2 state
+    mfa_required: implement multi-factor authentication
+    multistep_callback_required: add callback to handle multi-step authentication
+    oauth2_access_token_required: Option access_token must be provided
+    oauth2_not_configured: OAuth2 authentication is not configured
+    oauth2_revoke_failed: Unable to revoke access token, HTTP %{status}
+    token_request_failed: 'Unable to request token: %{message}'
+    token_revoke_failed: 'Unable to revoke token: %{message}'
+    token_step_failed: 'Failed at authentication step ''%{action}'': %{message}'
+    unsupported_auth_action: Unsupported authentication action '%{action}'
+  errors:
+    access_forbidden: Access forbidden. Bad user name or password? Not authorized?
+    action_failed: "%{action} failed: %{message}"
+    fatal_api_error: 'Fatal API error: %{error}'
+    input_parameters_not_valid: input parameters not valid
+    input_parameters_not_valid_for_action: Input parameters not valid for action '%{action}'
+    invalid_input_parameters: invalid input parameters
+    uncancelable_action: 'Action state #%{id} cannot be cancelled'
+    unresolved_arguments: 'Unable to execute action ''%{action}'': unresolved arguments'
+  validation:
+    cannot_be_null: cannot be null
+    invalid_boolean: not a valid boolean
+    invalid_datetime: not in ISO 8601 format
+    invalid_float: not a valid float
+    invalid_input_layout: invalid input layout
+    invalid_integer: not a valid integer
+    invalid_resource_id: not a valid resource id
+    invalid_string: not a valid string
+    required_parameter_missing: required parameter missing
+    validation_failed: validation failed
+    validation_failed_with_errors: 'validation failed: %{errors}'
+cs:
+  authentication:
+    callback_failed: "%{callback} selhal: %{error}"
+    callback_invalid_return: callback musí vrátit pole nebo 'stop'
+    callback_required: Implementujte callback %{callback}
+    invalid_credentials: neplatné přihlašovací údaje
+    invalid_oauth2_pkce_verifier: Neplatný OAuth2 PKCE verifier
+    invalid_oauth2_state: Neplatný OAuth2 state
+    mfa_required: implementujte vícefaktorové ověření
+    multistep_callback_required: přidejte callback pro zpracování vícefázového ověření
+    oauth2_access_token_required: Volba access_token musí být zadána
+    oauth2_not_configured: OAuth2 ověření není nastaveno
+    oauth2_revoke_failed: Přístupový token nelze zrušit, HTTP %{status}
+    token_request_failed: 'Token nelze vyžádat: %{message}'
+    token_revoke_failed: 'Token nelze zrušit: %{message}'
+    token_step_failed: 'Krok ověření ''%{action}'' selhal: %{message}'
+    unsupported_auth_action: Nepodporovaná ověřovací akce '%{action}'
+  errors:
+    access_forbidden: Přístup odepřen. Chybné uživatelské jméno nebo heslo? Nejste
+      oprávněni?
+    action_failed: "%{action} selhala: %{message}"
+    fatal_api_error: 'Fatální chyba API: %{error}'
+    input_parameters_not_valid: vstupní parametry nejsou platné
+    input_parameters_not_valid_for_action: Vstupní parametry pro akci '%{action}'
+      nejsou platné
+    invalid_input_parameters: neplatné vstupní parametry
+    uncancelable_action: 'Stav akce #%{id} nelze zrušit'
+    unresolved_arguments: 'Akci ''%{action}'' nelze spustit: chybí argumenty'
+  validation:
+    cannot_be_null: nesmí být null
+    invalid_boolean: neplatná pravdivostní hodnota
+    invalid_datetime: není ve formátu ISO 8601
+    invalid_float: neplatné desetinné číslo
+    invalid_input_layout: neplatná struktura vstupu
+    invalid_integer: neplatné celé číslo
+    invalid_resource_id: neplatné ID prostředku
+    invalid_string: neplatný řetězec
+    required_parameter_missing: povinný parametr chybí
+    validation_failed: validace selhala
+    validation_failed_with_errors: 'validace selhala: %{errors}'

data/lib/haveapi/go_client/version.rb

@@ -1,5 +1,5 @@
 module HaveAPI
   module GoClient
-    VERSION = '0.28.4'.freeze
+    VERSION = '0.29.0'.freeze
   end
 end

data/spec/integration/generator_spec.rb

@@ -170,6 +170,8 @@ RSpec.describe HaveAPI::GoClient::Generator do
 
         import (
           "math"
+          "net/http"
+          "strings"
           "testing"
         )
 
@@ -179,6 +181,21 @@ RSpec.describe HaveAPI::GoClient::Generator do
           return c
         }
 
+        func TestValidationErrorCompatibility(t *testing.T) {
+          verr := NewValidationError()
+          verr.Add("field", "broken")
+          if verr.Empty() {
+            t.Fatalf("expected validation error to be non-empty")
+          }
+
+          legacyLiteral := ValidationError{map[string][]string{
+            "field": []string{"broken"},
+          }}
+          if legacyLiteral.Empty() {
+            t.Fatalf("expected legacy literal validation error to be non-empty")
+          }
+        }
+
         func TestEchoRejectsNaNFloat(t *testing.T) {
           c := newValidationClient()
           req := c.Test.Echo.Prepare()
@@ -205,6 +222,52 @@ RSpec.describe HaveAPI::GoClient::Generator do
           }
         }
 
+        func TestLanguageHeaderAndLocalizedValidation(t *testing.T) {
+          c := newValidationClient()
+          if err := c.SetLanguage("cs-CZ"); err != nil {
+            t.Fatalf("set language failed: %v", err)
+          }
+          if err := c.SetLanguageHeader("X-Language"); err != nil {
+            t.Fatalf("set language header failed: %v", err)
+          }
+
+          httpReq, err := http.NewRequest("GET", "#{base_url}/v1/test", nil)
+          if err != nil {
+            t.Fatalf("new request failed: %v", err)
+          }
+          c.addLanguageHeader(httpReq)
+          if got := httpReq.Header.Get("X-Language"); got != "cs-CZ" {
+            t.Fatalf("expected language header cs-CZ, got %q", got)
+          }
+
+          req := c.Test.Echo.Prepare()
+          in := req.NewInput()
+          in.SetI(1)
+          in.SetF(math.NaN())
+          in.SetB(true)
+          in.SetDt("2020-01-01T00:00:00Z")
+          in.SetS("x")
+          in.SetT("y")
+
+          _, err = req.Call()
+          if err == nil {
+            t.Fatalf("expected validation error, got nil")
+          }
+
+          verr, ok := err.(*ValidationError)
+          if !ok {
+            t.Fatalf("expected ValidationError, got %T: %v", err, err)
+          }
+
+          if got := strings.Join(verr.Errors["f"], " "); !strings.Contains(got, "neplatné desetinné číslo") {
+            t.Fatalf("expected Czech float error, got %q", got)
+          }
+
+          if !strings.Contains(err.Error(), "validace selhala") {
+            t.Fatalf("expected Czech validation summary, got %q", err.Error())
+          }
+        }
+
         func TestEchoRejectsInvalidDatetime(t *testing.T) {
           c := newValidationClient()
           req := c.Test.Echo.Prepare()
@@ -422,6 +485,12 @@ RSpec.describe HaveAPI::GoClient::Generator do
           c := New("http://unused.example")
           c.SetHTTPClient(&http.Client{Transport: transport})
           c.SetExistingOAuth2Auth(token)
+          if err := c.SetLanguage("cs-CZ"); err != nil {
+            t.Fatalf("set language failed: %v", err)
+          }
+          if err := c.SetLanguageHeader("X-Language"); err != nil {
+            t.Fatalf("set language header failed: %v", err)
+          }
 
           if err := c.RevokeAccessToken(); err != nil {
             t.Fatalf("revoke failed: %v", err)
@@ -443,6 +512,10 @@ RSpec.describe HaveAPI::GoClient::Generator do
             t.Fatalf("expected OAuth2 header %q, got %q", token, got)
           }
 
+          if got := transport.req.Header.Get("X-Language"); got != "cs-CZ" {
+            t.Fatalf("expected language header cs-CZ, got %q", got)
+          }
+
           if got := transport.req.Header.Get("Content-Type"); got != "application/x-www-form-urlencoded" {
             t.Fatalf("expected form content type, got %q", got)
           }

data/template/action.go.erb

@@ -367,7 +367,7 @@ func (inv *<%= action.go_invocation_type %>) IsMetaParameterNil(param string) bo
 <% end -%>
 
 func (inv *<%= action.go_invocation_type %>) validate() error {
-	verr := NewValidationError()
+	verr := NewValidationError(inv.Action.Client)
 <% if action.has_input? -%>
 	if inv.Input != nil {
 <% action.input.parameters.each do |p| -%>
@@ -376,18 +376,18 @@ func (inv *<%= action.go_invocation_type %>) validate() error {
 			if !inv.IsParameterNil(<%= go_string_literal(p.go_name) %>) {
 <% if p.type == 'Float' -%>
 			if !isFiniteFloat64(inv.Input.<%= p.go_name %>) {
-				verr.Add(<%= go_string_literal(p.name) %>, "not a valid float")
+				verr.Add(<%= go_string_literal(p.name) %>, t(inv.Action.Client, "validation.invalid_float", nil))
 			}
 <% elsif p.type == 'Datetime' -%>
 			normalized, ok := normalizeAndCheckDatetimeString(inv.Input.<%= p.go_name %>)
 			if !ok {
-				verr.Add(<%= go_string_literal(p.name) %>, "not a valid datetime")
+				verr.Add(<%= go_string_literal(p.name) %>, t(inv.Action.Client, "validation.invalid_datetime", nil))
 			} else {
 				inv.Input.<%= p.go_name %> = normalized
 			}
 <% elsif p.type == 'Resource' -%>
 			if inv.Input.<%= p.go_name %> < 0 {
-				verr.Add(<%= go_string_literal(p.name) %>, "not a valid resource id")
+				verr.Add(<%= go_string_literal(p.name) %>, t(inv.Action.Client, "validation.invalid_resource_id", nil))
 			}
 <% end -%>
 			}
@@ -404,18 +404,18 @@ func (inv *<%= action.go_invocation_type %>) validate() error {
 			if !inv.IsMetaParameterNil(<%= go_string_literal(p.go_name) %>) {
 <% if p.type == 'Float' -%>
 			if !isFiniteFloat64(inv.MetaInput.<%= p.go_name %>) {
-				verr.Add(<%= go_string_literal(p.name) %>, "not a valid float")
+				verr.Add(<%= go_string_literal(p.name) %>, t(inv.Action.Client, "validation.invalid_float", nil))
 			}
 <% elsif p.type == 'Datetime' -%>
 			normalized, ok := normalizeAndCheckDatetimeString(inv.MetaInput.<%= p.go_name %>)
 			if !ok {
-				verr.Add(<%= go_string_literal(p.name) %>, "not a valid datetime")
+				verr.Add(<%= go_string_literal(p.name) %>, t(inv.Action.Client, "validation.invalid_datetime", nil))
 			} else {
 				inv.MetaInput.<%= p.go_name %> = normalized
 			}
 <% elsif p.type == 'Resource' -%>
 			if inv.MetaInput.<%= p.go_name %> < 0 {
-				verr.Add(<%= go_string_literal(p.name) %>, "not a valid resource id")
+				verr.Add(<%= go_string_literal(p.name) %>, t(inv.Action.Client, "validation.invalid_resource_id", nil))
 			}
 <% end -%>
 			}

data/template/authentication/oauth2.go.erb

@@ -28,7 +28,7 @@ func (client *Client) SetExistingOAuth2Auth(accessToken string) {
 func (client *Client) RevokeAccessToken() error {
 	auth, ok := client.Authentication.(*OAuth2Auth)
 	if !ok {
-		return fmt.Errorf("OAuth2 authentication is not configured")
+		return fmt.Errorf("%s", t(client, "authentication.oauth2_not_configured", nil))
 	}
 
 	form := url.Values{}
@@ -46,6 +46,7 @@ func (client *Client) RevokeAccessToken() error {
 	}
 
 	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+	client.addLanguageHeader(req)
 	auth.Authenticate(req)
 
 	resp, err := client.do(req)
@@ -57,7 +58,9 @@ func (client *Client) RevokeAccessToken() error {
 	defer resp.Body.Close()
 
 	if resp.StatusCode != 200 {
-		return fmt.Errorf("Unable to revoke access token, HTTP %v", resp.StatusCode)
+		return fmt.Errorf("%s", t(client, "authentication.oauth2_revoke_failed", map[string]string{
+			"status": fmt.Sprint(resp.StatusCode),
+		}))
 	}
 
 	client.Authentication = nil

data/template/authentication/token.go.erb

@@ -65,7 +65,9 @@ func (client *Client) SetNewTokenAuth(options *TokenAuthOptions) error {
 	if err != nil {
 		return err
 	} else if !resp.Status {
-		return fmt.Errorf("Unable to request token: %v", resp.Message)
+		return fmt.Errorf("%s", t(client, "authentication.token_request_failed", map[string]string{
+			"message": resp.Message,
+		}))
 	}
 
 	if resp.Output.Complete {
@@ -101,11 +103,16 @@ func (auth *TokenAuth) nextAuthenticationStep(options *TokenAuthOptions, action
 		input.SetToken(token)
 
 		if options.<%= "#{a.go_name}Callback" %> == nil {
-			return fmt.Errorf(<%= go_string_literal("Implement callback #{a.go_name}Callback") %>)
+			return fmt.Errorf("%s", t(auth.Resource.Client, "authentication.callback_required", map[string]string{
+				"callback": <%= go_string_literal("#{a.go_name}Callback") %>,
+			}))
 		}
 
 		if err := options.<%= "#{a.go_name}Callback" %>(input); err != nil {
-			return fmt.Errorf(<%= go_string_literal("#{a.go_name}Callback failed: %v") %>, err)
+			return fmt.Errorf("%s", t(auth.Resource.Client, "authentication.callback_failed", map[string]string{
+				"callback": <%= go_string_literal("#{a.go_name}Callback") %>,
+				"error": err.Error(),
+			}))
 		}
 
 		resp, err := request.Call()
@@ -113,7 +120,10 @@ func (auth *TokenAuth) nextAuthenticationStep(options *TokenAuthOptions, action
 		if err != nil {
 			return err
 		} else if !resp.Status {
-			return fmt.Errorf("Failed at authentication step '%s': %v", action, resp.Message)
+			return fmt.Errorf("%s", t(auth.Resource.Client, "authentication.token_step_failed", map[string]string{
+				"action": action,
+				"message": resp.Message,
+			}))
 		}
 
 		if resp.Output.Complete {
@@ -130,7 +140,9 @@ func (auth *TokenAuth) nextAuthenticationStep(options *TokenAuthOptions, action
 	}
 <% end -%>
 
-	return fmt.Errorf("Unsupported authentication action '%s'", action)
+	return fmt.Errorf("%s", t(auth.Resource.Client, "authentication.unsupported_auth_action", map[string]string{
+		"action": action,
+	}))
 }
 
 // SetExistingTokenAuth will use a previously acquired token
@@ -156,7 +168,9 @@ func (client *Client) RevokeAuthToken() error {
 	if err != nil {
 		return err
 	} else if !resp.Status {
-		return fmt.Errorf("Unable to revoke token: %v", resp.Message)
+		return fmt.Errorf("%s", t(client, "authentication.token_revoke_failed", map[string]string{
+			"message": resp.Message,
+		}))
 	}
 
 	client.Authentication = nil

data/template/client.go.erb

@@ -13,6 +13,12 @@ type Client struct {
 	// Options for authentication method
 	Authentication Authenticator
 
+	// Language sent to the API server, e.g. "cs" or "cs-CZ".
+	Language string
+
+	// HTTP header used to send Language. Defaults to Accept-Language.
+	LanguageHeader string
+
 	httpClient            *http.Client
 	oauth2TrustedOrigins map[string]struct{}
 

data/template/i18n.go.erb

@@ -0,0 +1,198 @@
+package <%= package %>
+
+import (
+	"net/http"
+	"sort"
+	"strconv"
+	"strings"
+)
+
+const defaultLanguageHeader = "Accept-Language"
+
+var clientI18nMessages = map[string]map[string]map[string]string{
+<% i18n_messages.keys.sort.each do |locale| -%>
+	<%= go_string_literal(locale) %>: {
+<% i18n_messages[locale].keys.sort.each do |group| -%>
+		<%= go_string_literal(group) %>: {
+<% i18n_messages[locale][group].keys.sort.each do |key| -%>
+			<%= go_string_literal(key) %>: <%= go_string_literal(i18n_messages[locale][group][key]) %>,
+<% end -%>
+		},
+<% end -%>
+	},
+<% end -%>
+}
+
+// SetLanguage configures the value sent in the language request header.
+func (client *Client) SetLanguage(language string) error {
+	if strings.ContainsAny(language, "\x00\r\n") {
+		err := NewValidationError(client)
+		err.Errors["language"] = []string{
+			t(client, "validation.invalid_string", nil),
+		}
+		return err
+	}
+
+	client.Language = language
+	return nil
+}
+
+// SetLanguageHeader configures the HTTP header used by SetLanguage.
+func (client *Client) SetLanguageHeader(header string) error {
+	if !validHeaderName(header) {
+		err := NewValidationError(client)
+		err.Errors["language_header"] = []string{
+			t(client, "validation.invalid_string", nil),
+		}
+		return err
+	}
+
+	client.LanguageHeader = header
+	return nil
+}
+
+func (client *Client) addLanguageHeader(req *http.Request) {
+	if client == nil || req == nil || client.Language == "" {
+		return
+	}
+
+	req.Header.Set(client.languageHeaderName(), client.Language)
+}
+
+func (client *Client) languageHeaderName() string {
+	if client == nil || client.LanguageHeader == "" {
+		return defaultLanguageHeader
+	}
+
+	return client.LanguageHeader
+}
+
+func t(client *Client, key string, values map[string]string) string {
+	language := ""
+	if client != nil {
+		language = client.Language
+	}
+
+	return tLanguage(language, key, values)
+}
+
+func tLanguage(language string, key string, values map[string]string) string {
+	message := lookupMessage(localeFor(language), key)
+	if message == "" {
+		message = lookupMessage("en", key)
+	}
+	if message == "" {
+		message = key
+	}
+
+	for name, value := range values {
+		message = strings.ReplaceAll(message, "%{"+name+"}", value)
+	}
+
+	return message
+}
+
+func lookupMessage(locale string, key string) string {
+	parts := strings.Split(strings.TrimPrefix(key, "haveapi_client."), ".")
+	if len(parts) != 2 {
+		return ""
+	}
+
+	groups, ok := clientI18nMessages[locale]
+	if !ok {
+		return ""
+	}
+
+	messages, ok := groups[parts[0]]
+	if !ok {
+		return ""
+	}
+
+	return messages[parts[1]]
+}
+
+func localeFor(language string) string {
+	if language == "" {
+		return "en"
+	}
+
+	for _, tag := range parseAcceptLanguage(language) {
+		locale := normalizeLocale(tag)
+		if _, ok := clientI18nMessages[locale]; ok {
+			return locale
+		}
+	}
+
+	return "en"
+}
+
+func parseAcceptLanguage(header string) []string {
+	type tag struct {
+		name string
+		q    float64
+	}
+
+	tags := []tag{}
+	for _, part := range strings.Split(header, ",") {
+		tokens := strings.Split(part, ";")
+		name := strings.TrimSpace(tokens[0])
+		q := 1.0
+
+		for _, token := range tokens[1:] {
+			pair := strings.SplitN(token, "=", 2)
+			if len(pair) == 2 && strings.TrimSpace(pair[0]) == "q" {
+				if parsed, err := strconv.ParseFloat(strings.TrimSpace(pair[1]), 64); err == nil {
+					q = parsed
+				}
+			}
+		}
+
+		if name != "" && q > 0 {
+			tags = append(tags, tag{name: name, q: q})
+		}
+	}
+
+	sort.SliceStable(tags, func(i, j int) bool {
+		return tags[i].q > tags[j].q
+	})
+
+	ret := make([]string, 0, len(tags))
+	for _, tag := range tags {
+		ret = append(ret, tag.name)
+	}
+
+	return ret
+}
+
+func normalizeLocale(tag string) string {
+	normalized := strings.ToLower(strings.TrimSpace(strings.ReplaceAll(tag, "_", "-")))
+	if i := strings.Index(normalized, "."); i >= 0 {
+		normalized = normalized[:i]
+	}
+	if i := strings.Index(normalized, "-"); i >= 0 {
+		normalized = normalized[:i]
+	}
+
+	return normalized
+}
+
+func validHeaderName(header string) bool {
+	if header == "" {
+		return false
+	}
+
+	for _, r := range header {
+		if (r >= 'A' && r <= 'Z') || (r >= 'a' && r <= 'z') || (r >= '0' && r <= '9') {
+			continue
+		}
+
+		switch r {
+		case '!', '#', '$', '%', '&', '\'', '*', '+', '-', '.', '^', '_', '`', '|', '~':
+			continue
+		default:
+			return false
+		}
+	}
+
+	return true
+}

data/template/request.go.erb

@@ -182,6 +182,8 @@ func (client *Client) DoQueryStringRequest(path string, queryParams map[string]s
 		return err
 	}
 
+	client.addLanguageHeader(req)
+
 	if client.Authentication != nil {
 		client.Authentication.Authenticate(req)
 	}
@@ -232,6 +234,7 @@ func (client *Client) DoBodyRequest(method string, path string, params interface
 	}
 
 	req.Header.Set("Content-Type", "application/json")
+	client.addLanguageHeader(req)
 
 	if client.Authentication != nil {
 		client.Authentication.Authenticate(req)

data/template/types.go.erb

@@ -2,10 +2,13 @@ package <%= package %>
 
 import (
 	"math"
+	"runtime"
 	"sort"
 	"strconv"
 	"strings"
+	"sync"
 	"time"
+	"unsafe"
 )
 
 type ProgressCallbackReturn int
@@ -28,10 +31,22 @@ type ValidationError struct {
 	Errors map[string][]string
 }
 
-func NewValidationError() *ValidationError {
-	return &ValidationError{
+// Keep the exported ValidationError layout compatible with older generated clients.
+var validationErrorLanguages sync.Map
+
+func NewValidationError(client ...*Client) *ValidationError {
+	ret := &ValidationError{
 		Errors: make(map[string][]string),
 	}
+
+	if len(client) > 0 && client[0] != nil && client[0].Language != "" {
+		validationErrorLanguages.Store(validationErrorKey(ret), client[0].Language)
+		runtime.SetFinalizer(ret, func(e *ValidationError) {
+			validationErrorLanguages.Delete(validationErrorKey(e))
+		})
+	}
+
+	return ret
 }
 
 func (e *ValidationError) Add(param string, msg string) {
@@ -52,7 +67,11 @@ func (e *ValidationError) Empty() bool {
 
 func (e *ValidationError) Error() string {
 	if e == nil || len(e.Errors) == 0 {
-		return "validation failed"
+		if e == nil {
+			return t(nil, "validation.validation_failed", nil)
+		}
+
+		return tLanguage(e.language(), "validation.validation_failed", nil)
 	}
 
 	keys := make([]string, 0, len(e.Errors))
@@ -72,7 +91,27 @@ func (e *ValidationError) Error() string {
 		}
 	}
 
-	return "validation failed: " + strings.Join(parts, "; ")
+	return tLanguage(e.language(), "validation.validation_failed_with_errors", map[string]string{
+		"errors": strings.Join(parts, "; "),
+	})
+}
+
+func (e *ValidationError) language() string {
+	if e == nil {
+		return ""
+	}
+
+	v, ok := validationErrorLanguages.Load(validationErrorKey(e))
+	if !ok {
+		return ""
+	}
+
+	language, _ := v.(string)
+	return language
+}
+
+func validationErrorKey(e *ValidationError) uintptr {
+	return uintptr(unsafe.Pointer(e))
 }
 
 func isFiniteFloat64(v float64) bool {

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: haveapi-go-client
 version: !ruby/object:Gem::Version
-  version: 0.28.4
+  version: 0.29.0
 platform: ruby
 authors:
 - Jakub Skokan
@@ -15,14 +15,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.28.4
+        version: 0.29.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.28.4
+        version: 0.29.0
 description: Go client generator
 email:
 - jakub.skokan@vpsfree.cz
@@ -49,6 +49,7 @@ files:
 - lib/haveapi/go_client/cli.rb
 - lib/haveapi/go_client/erb_template.rb
 - lib/haveapi/go_client/generator.rb
+- lib/haveapi/go_client/i18n_messages.yml
 - lib/haveapi/go_client/input_output.rb
 - lib/haveapi/go_client/metadata.rb
 - lib/haveapi/go_client/parameter.rb
@@ -70,6 +71,7 @@ files:
 - template/authentication/token.go.erb
 - template/client.go.erb
 - template/go.mod.erb
+- template/i18n.go.erb
 - template/request.go.erb
 - template/resource.go.erb
 - template/response.go.erb