django-cfg 1.4.48__py3-none-any.whl → 1.5.7__py3-none-any.whl

django_cfg/modules/django_client/core/generator/go/templates/README.md.j2

@@ -0,0 +1,55 @@
+# {{ api_title }} - Go Client
+
+Auto-generated Go client for {{ api_title }} (v{{ api_version }}).
+
+Generated at: {{ generated_at }}
+
+## Installation
+
+```bash
+go get {{ module_name }}
+```
+
+## Usage
+
+```go
+package main
+
+import (
+	"context"
+	"fmt"
+	"log"
+
+	"{{ module_name }}"
+)
+
+func main() {
+	// Create client
+	client := {{ module_name }}.NewClient(
+		"https://api.example.com",
+		{{ module_name }}.WithToken("your-api-token"),
+	)
+
+	// Make requests
+	ctx := context.Background()
+
+	// Example: List users
+	// users, err := client.UsersList(ctx, nil)
+	// if err != nil {
+	//     log.Fatal(err)
+	// }
+	// fmt.Printf("Users: %+v\n", users)
+}
+```
+
+## Features
+
+- ✅ Type-safe Go structs
+- ✅ Context-aware requests
+- ✅ Bearer token authentication
+- ✅ Comprehensive error handling
+- ✅ Auto-generated from OpenAPI spec
+
+## Documentation
+
+See the OpenAPI specification for full API documentation.

django_cfg/modules/django_client/core/generator/go/templates/client.go.j2

@@ -0,0 +1,122 @@
+// Code generated by django-cfg/django_client - DO NOT EDIT.
+// Generated at: {{ generated_at }}
+
+package {{ package_name }}
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+)
+
+// Client is the HTTP API client.
+type Client struct {
+	BaseURL    string
+	HTTPClient *http.Client
+	Token      string // Bearer token for authentication
+}
+
+// Option is a functional option for configuring the Client.
+type Option func(*Client)
+
+// WithHTTPClient sets a custom HTTP client.
+func WithHTTPClient(client *http.Client) Option {
+	return func(c *Client) {
+		c.HTTPClient = client
+	}
+}
+
+// WithToken sets the authentication token.
+func WithToken(token string) Option {
+	return func(c *Client) {
+		c.Token = token
+	}
+}
+
+// NewClient creates a new API client.
+func NewClient(baseURL string, options ...Option) *Client {
+	client := &Client{
+		BaseURL:    baseURL,
+		HTTPClient: &http.Client{},
+	}
+
+	for _, opt := range options {
+		opt(client)
+	}
+
+	return client
+}
+
+// doRequest performs HTTP request with error handling.
+func (c *Client) doRequest(ctx context.Context, method, path string, body interface{}, response interface{}) error {
+	var reqBody io.Reader
+
+	if body != nil {
+		data, err := json.Marshal(body)
+		if err != nil {
+			return fmt.Errorf("failed to marshal request body: %w", err)
+		}
+		reqBody = bytes.NewReader(data)
+	}
+
+	req, err := http.NewRequestWithContext(ctx, method, c.BaseURL+path, reqBody)
+	if err != nil {
+		return fmt.Errorf("failed to create request: %w", err)
+	}
+
+	req.Header.Set("Content-Type", "application/json")
+	if c.Token != "" {
+		req.Header.Set("Authorization", "Bearer "+c.Token)
+	}
+
+	resp, err := c.HTTPClient.Do(req)
+	if err != nil {
+		return fmt.Errorf("HTTP request failed: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode >= 400 {
+		var apiErr APIError
+		apiErr.StatusCode = resp.StatusCode
+		if err := json.NewDecoder(resp.Body).Decode(&apiErr); err != nil {
+			apiErr.Message = resp.Status
+		}
+		return &apiErr
+	}
+
+	if response != nil {
+		if err := json.NewDecoder(resp.Body).Decode(response); err != nil {
+			return fmt.Errorf("failed to decode response: %w", err)
+		}
+	}
+
+	return nil
+}
+
+{% for operation in operations %}
+// {{ operation.name }} - {{ operation.description }}
+func (c *Client) {{ operation.name }}(ctx context.Context{% for param in operation.parameters %}, {{ param.name }} {{ param.type }}{% endfor %}{% if operation.request_type %}, req *{{ operation.request_type }}{% endif %}) ({% if operation.response_type != 'interface{}' %}*{{ operation.response_type }}{% else %}interface{}{% endif %}, error) {
+	{% if operation.response_type != 'interface{}' %}var response {{ operation.response_type }}{% endif %}
+
+	path := "{{ operation.path }}"
+	{% if operation.parameters %}
+	// TODO: Build path with parameters and query string
+	{% endif %}
+
+	err := c.doRequest(ctx, "{{ operation.http_method }}", path, {% if operation.request_type %}req{% else %}nil{% endif %}, {% if operation.response_type != 'interface{}' %}&response{% else %}nil{% endif %})
+	if err != nil {
+		return nil, err
+	}
+
+	{% if operation.response_type != 'interface{}' %}
+	return &response, nil
+	{% else %}
+	return nil, nil
+	{% endif %}
+}
+
+{% endfor %}

django_cfg/modules/django_client/core/generator/go/templates/enums.go.j2

@@ -0,0 +1,49 @@
+// Code generated by django-cfg/django_client - DO NOT EDIT.
+// Generated at: {{ generated_at }}
+
+package {{ package_name }}
+
+import (
+	"encoding/json"
+	"fmt"
+)
+
+{% for enum in enums %}
+// {{ (enum.doc or enum.name) | replace('\n', '\n// ') }}
+type {{ enum.name }} {{ enum.base_type }}
+
+const (
+{% for value in enum['values'] %}
+	// {{ (value.description or value.name) | replace('\n', '\n\t// ') }}
+	{{ value.name }} {{ enum.name }} = {{ value.value if not enum.is_string_enum else '"%s"' % value.value }}
+{% endfor %}
+)
+
+// String returns string representation of {{ enum.name }}.
+func (e {{ enum.name }}) String() string {
+	switch e {
+{% for value in enum['values'] %}
+	case {{ value.name }}:
+		return "{{ value.name }}"
+{% endfor %}
+	default:
+		return fmt.Sprintf("{{ enum.name }}(%v)", {{ enum.base_type }}(e))
+	}
+}
+
+// MarshalJSON implements json.Marshaler.
+func (e {{ enum.name }}) MarshalJSON() ([]byte, error) {
+	return json.Marshal({{ enum.base_type }}(e))
+}
+
+// UnmarshalJSON implements json.Unmarshaler.
+func (e *{{ enum.name }}) UnmarshalJSON(data []byte) error {
+	var v {{ enum.base_type }}
+	if err := json.Unmarshal(data, &v); err != nil {
+		return err
+	}
+	*e = {{ enum.name }}(v)
+	return nil
+}
+
+{% endfor %}

django_cfg/modules/django_client/core/generator/go/templates/errors.go.j2

@@ -0,0 +1,182 @@
+// Code generated by django-cfg/django_client - DO NOT EDIT.
+// Generated at: {{ generated_at }}
+
+package {{ package_name }}
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/http"
+)
+
+// APIError represents an API error response with full context.
+type APIError struct {
+	// HTTP status code (e.g., 404, 500)
+	StatusCode int `json:"status_code"`
+
+	// HTTP status text (e.g., "Not Found")
+	Status string `json:"status"`
+
+	// Error message from API
+	Message string `json:"message"`
+
+	// Detailed error information (can be string, object, or array)
+	Detail interface{} `json:"detail,omitempty"`
+
+	// Field-specific validation errors
+	Errors map[string]interface{} `json:"errors,omitempty"`
+
+	// Raw response body
+	Body []byte `json:"-"`
+
+	// Request method (GET, POST, etc.)
+	Method string `json:"method"`
+
+	// Request URL
+	URL string `json:"url"`
+}
+
+// Error implements the error interface.
+func (e *APIError) Error() string {
+	if e.Detail != nil {
+		return fmt.Sprintf("API error: %s %s -> %d %s: %s (detail: %v)",
+			e.Method, e.URL, e.StatusCode, e.Status, e.Message, e.Detail)
+	}
+	if e.Message != "" {
+		return fmt.Sprintf("API error: %s %s -> %d %s: %s",
+			e.Method, e.URL, e.StatusCode, e.Status, e.Message)
+	}
+	return fmt.Sprintf("API error: %s %s -> %d %s",
+		e.Method, e.URL, e.StatusCode, e.Status)
+}
+
+// IsNotFound returns true if the error is a 404 Not Found.
+func (e *APIError) IsNotFound() bool {
+	return e.StatusCode == http.StatusNotFound
+}
+
+// IsUnauthorized returns true if the error is a 401 Unauthorized.
+func (e *APIError) IsUnauthorized() bool {
+	return e.StatusCode == http.StatusUnauthorized
+}
+
+// IsForbidden returns true if the error is a 403 Forbidden.
+func (e *APIError) IsForbidden() bool {
+	return e.StatusCode == http.StatusForbidden
+}
+
+// IsBadRequest returns true if the error is a 400 Bad Request.
+func (e *APIError) IsBadRequest() bool {
+	return e.StatusCode == http.StatusBadRequest
+}
+
+// IsValidationError returns true if the error is a 422 Unprocessable Entity (validation error).
+func (e *APIError) IsValidationError() bool {
+	return e.StatusCode == http.StatusUnprocessableEntity
+}
+
+// IsServerError returns true if the error is a 5xx server error.
+func (e *APIError) IsServerError() bool {
+	return e.StatusCode >= 500 && e.StatusCode < 600
+}
+
+// IsClientError returns true if the error is a 4xx client error.
+func (e *APIError) IsClientError() bool {
+	return e.StatusCode >= 400 && e.StatusCode < 500
+}
+
+// GetFieldError returns the error message for a specific field, if any.
+func (e *APIError) GetFieldError(field string) (string, bool) {
+	if e.Errors == nil {
+		return "", false
+	}
+	if err, ok := e.Errors[field]; ok {
+		return fmt.Sprintf("%v", err), true
+	}
+	return "", false
+}
+
+// HasFieldErrors returns true if there are field-specific validation errors.
+func (e *APIError) HasFieldErrors() bool {
+	return len(e.Errors) > 0
+}
+
+// ParseAPIError attempts to parse an error response from the API.
+func ParseAPIError(statusCode int, status, method, url string, body []byte) error {
+	apiErr := &APIError{
+		StatusCode: statusCode,
+		Status:     status,
+		Method:     method,
+		URL:        url,
+		Body:       body,
+	}
+
+	// Try to parse JSON error response
+	var errorResponse struct {
+		Message string                 `json:"message"`
+		Detail  interface{}            `json:"detail"`
+		Errors  map[string]interface{} `json:"errors"`
+		Error   string                 `json:"error"`
+	}
+
+	if err := json.Unmarshal(body, &errorResponse); err == nil {
+		// Use message field if available
+		if errorResponse.Message != "" {
+			apiErr.Message = errorResponse.Message
+		} else if errorResponse.Error != "" {
+			apiErr.Message = errorResponse.Error
+		}
+
+		apiErr.Detail = errorResponse.Detail
+		apiErr.Errors = errorResponse.Errors
+	} else {
+		// If JSON parsing fails, use body as message
+		apiErr.Message = string(body)
+	}
+
+	return apiErr
+}
+
+// NetworkError represents a network-level error (connection failed, timeout, etc.).
+type NetworkError struct {
+	// Underlying error
+	Err error
+
+	// Request method
+	Method string
+
+	// Request URL
+	URL string
+}
+
+// Error implements the error interface.
+func (e *NetworkError) Error() string {
+	return fmt.Sprintf("network error: %s %s: %v", e.Method, e.URL, e.Err)
+}
+
+// Unwrap returns the underlying error.
+func (e *NetworkError) Unwrap() error {
+	return e.Err
+}
+
+// UnmarshalError represents an error unmarshaling the response.
+type UnmarshalError struct {
+	// Underlying error
+	Err error
+
+	// Response body
+	Body []byte
+
+	// Expected type
+	Type string
+}
+
+// Error implements the error interface.
+func (e *UnmarshalError) Error() string {
+	return fmt.Sprintf("failed to unmarshal response into %s: %v (body: %s)", e.Type, e.Err, string(e.Body))
+}
+
+// Unwrap returns the underlying error.
+func (e *UnmarshalError) Unwrap() error {
+	return e.Err
+}

django_cfg/modules/django_client/core/generator/go/templates/go.mod.j2

@@ -0,0 +1,6 @@
+// Code generated by django-cfg/django_client - DO NOT EDIT.
+// Generated at: {{ generated_at }}
+
+module {{ module_name }}
+
+go {{ go_version }}

django_cfg/modules/django_client/core/generator/go/templates/main_client.go.j2

@@ -0,0 +1,60 @@
+// Code generated by django-cfg/django_client - DO NOT EDIT.
+// Generated at: {{ generated_at }}
+
+package {{ package_name }}
+
+import (
+	"net/http"
+{% for subclient in subclients %}
+	"{{ module_name }}/{{ subclient.package }}"
+{% endfor %}
+)
+
+// Client is the main API client with sub-clients for each module.
+type Client struct {
+	BaseURL    string
+	HTTPClient *http.Client
+	Token      string
+
+{% for subclient in subclients %}
+	// {{ subclient.name }} provides access to {{ subclient.name }} operations
+	{{ subclient.name }} *{{ subclient.package }}.Client
+{% endfor %}
+}
+
+// NewClient creates a new API client.
+func NewClient(baseURL string, options ...Option) *Client {
+	client := &Client{
+		BaseURL:    baseURL,
+		HTTPClient: &http.Client{},
+	}
+
+	// Apply options
+	for _, opt := range options {
+		opt(client)
+	}
+
+	// Initialize sub-clients
+{% for subclient in subclients %}
+	client.{{ subclient.name }} = {{ subclient.package }}.NewClient(baseURL, client.HTTPClient, client.Token)
+{% endfor %}
+
+	return client
+}
+
+// Option is a functional option for configuring the Client.
+type Option func(*Client)
+
+// WithHTTPClient sets a custom HTTP client.
+func WithHTTPClient(httpClient *http.Client) Option {
+	return func(c *Client) {
+		c.HTTPClient = httpClient
+	}
+}
+
+// WithToken sets the authentication token.
+func WithToken(token string) Option {
+	return func(c *Client) {
+		c.Token = token
+	}
+}