django-cfg 1.4.62__py3-none-any.whl → 1.4.64__py3-none-any.whl

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
+	}
+}

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

@@ -0,0 +1,388 @@
+// Code generated by django-cfg/django_client - DO NOT EDIT.
+// Generated at: {{ generated_at }}
+
+package {{ package_name }}
+
+import (
+	"context"
+	"log"
+	"math"
+	"net/http"
+	"net/http/httputil"
+	"time"
+)
+
+// RetryConfig configures retry behavior.
+type RetryConfig struct {
+	// Maximum number of retry attempts (default: 3)
+	MaxRetries int
+
+	// Initial backoff duration (default: 1s)
+	InitialBackoff time.Duration
+
+	// Maximum backoff duration (default: 30s)
+	MaxBackoff time.Duration
+
+	// Backoff multiplier (default: 2.0)
+	BackoffMultiplier float64
+
+	// Retry on these status codes (default: [429, 500, 502, 503, 504])
+	RetryableStatusCodes []int
+}
+
+// DefaultRetryConfig returns default retry configuration.
+func DefaultRetryConfig() *RetryConfig {
+	return &RetryConfig{
+		MaxRetries:           3,
+		InitialBackoff:       1 * time.Second,
+		MaxBackoff:           30 * time.Second,
+		BackoffMultiplier:    2.0,
+		RetryableStatusCodes: []int{429, 500, 502, 503, 504},
+	}
+}
+
+// RetryTransport implements automatic retry with exponential backoff.
+type RetryTransport struct {
+	Base   http.RoundTripper
+	Config *RetryConfig
+}
+
+// NewRetryTransport creates a new retry transport.
+func NewRetryTransport(base http.RoundTripper, config *RetryConfig) *RetryTransport {
+	if base == nil {
+		base = http.DefaultTransport
+	}
+	if config == nil {
+		config = DefaultRetryConfig()
+	}
+	return &RetryTransport{
+		Base:   base,
+		Config: config,
+	}
+}
+
+// RoundTrip executes a single HTTP transaction with retry logic.
+func (t *RetryTransport) RoundTrip(req *http.Request) (*http.Response, error) {
+	var resp *http.Response
+	var err error
+
+	for attempt := 0; attempt <= t.Config.MaxRetries; attempt++ {
+		// Clone request for retry (body can only be read once)
+		reqClone := req.Clone(req.Context())
+
+		resp, err = t.Base.RoundTrip(reqClone)
+
+		// Success - no retry needed
+		if err == nil && !t.shouldRetry(resp.StatusCode) {
+			return resp, nil
+		}
+
+		// Last attempt - return error
+		if attempt == t.Config.MaxRetries {
+			return resp, err
+		}
+
+		// Calculate backoff
+		backoff := t.calculateBackoff(attempt)
+
+		// Check context cancellation
+		select {
+		case <-req.Context().Done():
+			return resp, req.Context().Err()
+		case <-time.After(backoff):
+			// Continue to next attempt
+		}
+
+		// Close previous response body if exists
+		if resp != nil {
+			resp.Body.Close()
+		}
+	}
+
+	return resp, err
+}
+
+// shouldRetry determines if a status code should trigger a retry.
+func (t *RetryTransport) shouldRetry(statusCode int) bool {
+	for _, code := range t.Config.RetryableStatusCodes {
+		if statusCode == code {
+			return true
+		}
+	}
+	return false
+}
+
+// calculateBackoff calculates exponential backoff duration.
+func (t *RetryTransport) calculateBackoff(attempt int) time.Duration {
+	backoff := float64(t.Config.InitialBackoff) * math.Pow(t.Config.BackoffMultiplier, float64(attempt))
+	maxBackoff := float64(t.Config.MaxBackoff)
+
+	if backoff > maxBackoff {
+		backoff = maxBackoff
+	}
+
+	return time.Duration(backoff)
+}
+
+// LoggingTransport logs HTTP requests and responses.
+type LoggingTransport struct {
+	Base    http.RoundTripper
+	Logger  *log.Logger
+	Verbose bool // If true, logs request/response bodies
+}
+
+// NewLoggingTransport creates a new logging transport.
+func NewLoggingTransport(base http.RoundTripper, logger *log.Logger, verbose bool) *LoggingTransport {
+	if base == nil {
+		base = http.DefaultTransport
+	}
+	return &LoggingTransport{
+		Base:    base,
+		Logger:  logger,
+		Verbose: verbose,
+	}
+}
+
+// RoundTrip executes a single HTTP transaction with logging.
+func (t *LoggingTransport) RoundTrip(req *http.Request) (*http.Response, error) {
+	start := time.Now()
+
+	// Log request
+	if t.Logger != nil {
+		if t.Verbose {
+			reqDump, _ := httputil.DumpRequestOut(req, true)
+			t.Logger.Printf("→ Request:\n%s\n", string(reqDump))
+		} else {
+			t.Logger.Printf("→ %s %s", req.Method, req.URL.String())
+		}
+	}
+
+	// Execute request
+	resp, err := t.Base.RoundTrip(req)
+	duration := time.Since(start)
+
+	// Log response
+	if t.Logger != nil {
+		if err != nil {
+			t.Logger.Printf("← Error after %v: %v", duration, err)
+		} else {
+			if t.Verbose {
+				respDump, _ := httputil.DumpResponse(resp, true)
+				t.Logger.Printf("← Response after %v:\n%s\n", duration, string(respDump))
+			} else {
+				t.Logger.Printf("← %d %s after %v", resp.StatusCode, resp.Status, duration)
+			}
+		}
+	}
+
+	return resp, err
+}
+
+// RateLimitTransport implements client-side rate limiting.
+type RateLimitTransport struct {
+	Base     http.RoundTripper
+	Limiter  *time.Ticker
+	requests chan struct{}
+}
+
+// NewRateLimitTransport creates a new rate limit transport.
+// requestsPerSecond: maximum number of requests per second
+func NewRateLimitTransport(base http.RoundTripper, requestsPerSecond int) *RateLimitTransport {
+	if base == nil {
+		base = http.DefaultTransport
+	}
+
+	interval := time.Second / time.Duration(requestsPerSecond)
+	limiter := time.NewTicker(interval)
+	requests := make(chan struct{}, requestsPerSecond)
+
+	return &RateLimitTransport{
+		Base:     base,
+		Limiter:  limiter,
+		requests: requests,
+	}
+}
+
+// RoundTrip executes a single HTTP transaction with rate limiting.
+func (t *RateLimitTransport) RoundTrip(req *http.Request) (*http.Response, error) {
+	// Wait for rate limiter
+	select {
+	case <-req.Context().Done():
+		return nil, req.Context().Err()
+	case <-t.Limiter.C:
+		// Proceed with request
+	}
+
+	return t.Base.RoundTrip(req)
+}
+
+// Close stops the rate limiter.
+func (t *RateLimitTransport) Close() {
+	if t.Limiter != nil {
+		t.Limiter.Stop()
+	}
+}
+
+// TimeoutTransport adds request-level timeout.
+type TimeoutTransport struct {
+	Base    http.RoundTripper
+	Timeout time.Duration
+}
+
+// NewTimeoutTransport creates a new timeout transport.
+func NewTimeoutTransport(base http.RoundTripper, timeout time.Duration) *TimeoutTransport {
+	if base == nil {
+		base = http.DefaultTransport
+	}
+	return &TimeoutTransport{
+		Base:    base,
+		Timeout: timeout,
+	}
+}
+
+// RoundTrip executes a single HTTP transaction with timeout.
+func (t *TimeoutTransport) RoundTrip(req *http.Request) (*http.Response, error) {
+	ctx, cancel := context.WithTimeout(req.Context(), t.Timeout)
+	defer cancel()
+
+	return t.Base.RoundTrip(req.WithContext(ctx))
+}
+
+// ChainTransports chains multiple http.RoundTrippers together.
+// The order matters: first transport wraps second, second wraps third, etc.
+//
+// Example:
+//   transport := ChainTransports(
+//       NewLoggingTransport(nil, logger, false),  // Outermost
+//       NewRetryTransport(nil, nil),               // Middle
+//       http.DefaultTransport,                     // Innermost (base)
+//   )
+func ChainTransports(transports ...http.RoundTripper) http.RoundTripper {
+	if len(transports) == 0 {
+		return http.DefaultTransport
+	}
+
+	// Start from the innermost (last) transport
+	base := transports[len(transports)-1]
+
+	// Wrap each transport from right to left
+	for i := len(transports) - 2; i >= 0; i-- {
+		switch t := transports[i].(type) {
+		case *RetryTransport:
+			t.Base = base
+			base = t
+		case *LoggingTransport:
+			t.Base = base
+			base = t
+		case *RateLimitTransport:
+			t.Base = base
+			base = t
+		case *TimeoutTransport:
+			t.Base = base
+			base = t
+		default:
+			// For custom transports, just use as-is
+			base = t
+		}
+	}
+
+	return base
+}
+
+// HTTPClientWithMiddleware creates an HTTP client with middleware.
+//
+// Example:
+//   client := HTTPClientWithMiddleware(
+//       WithRetry(3),
+//       WithLogging(logger, false),
+//       WithRateLimit(10), // 10 requests per second
+//       WithTimeout(30 * time.Second),
+//   )
+func HTTPClientWithMiddleware(options ...MiddlewareOption) *http.Client {
+	config := &middlewareConfig{
+		baseTransport: http.DefaultTransport,
+	}
+
+	// Apply options
+	for _, option := range options {
+		option(config)
+	}
+
+	// Build transport chain
+	var transports []http.RoundTripper
+
+	if config.loggingTransport != nil {
+		transports = append(transports, config.loggingTransport)
+	}
+	if config.retryTransport != nil {
+		transports = append(transports, config.retryTransport)
+	}
+	if config.rateLimitTransport != nil {
+		transports = append(transports, config.rateLimitTransport)
+	}
+	if config.timeoutTransport != nil {
+		transports = append(transports, config.timeoutTransport)
+	}
+
+	transports = append(transports, config.baseTransport)
+
+	return &http.Client{
+		Transport: ChainTransports(transports...),
+	}
+}
+
+// middlewareConfig holds middleware configuration.
+type middlewareConfig struct {
+	baseTransport       http.RoundTripper
+	retryTransport      *RetryTransport
+	loggingTransport    *LoggingTransport
+	rateLimitTransport  *RateLimitTransport
+	timeoutTransport    *TimeoutTransport
+}
+
+// MiddlewareOption configures middleware.
+type MiddlewareOption func(*middlewareConfig)
+
+// WithRetry adds retry middleware.
+func WithRetry(maxRetries int) MiddlewareOption {
+	return func(c *middlewareConfig) {
+		config := DefaultRetryConfig()
+		config.MaxRetries = maxRetries
+		c.retryTransport = NewRetryTransport(nil, config)
+	}
+}
+
+// WithRetryConfig adds retry middleware with custom config.
+func WithRetryConfig(config *RetryConfig) MiddlewareOption {
+	return func(c *middlewareConfig) {
+		c.retryTransport = NewRetryTransport(nil, config)
+	}
+}
+
+// WithLogging adds logging middleware.
+func WithLogging(logger *log.Logger, verbose bool) MiddlewareOption {
+	return func(c *middlewareConfig) {
+		c.loggingTransport = NewLoggingTransport(nil, logger, verbose)
+	}
+}
+
+// WithRateLimit adds rate limiting middleware.
+func WithRateLimit(requestsPerSecond int) MiddlewareOption {
+	return func(c *middlewareConfig) {
+		c.rateLimitTransport = NewRateLimitTransport(nil, requestsPerSecond)
+	}
+}
+
+// WithTimeout adds timeout middleware.
+func WithTimeout(timeout time.Duration) MiddlewareOption {
+	return func(c *middlewareConfig) {
+		c.timeoutTransport = NewTimeoutTransport(nil, timeout)
+	}
+}
+
+// WithBaseTransport sets custom base transport.
+func WithBaseTransport(transport http.RoundTripper) MiddlewareOption {
+	return func(c *middlewareConfig) {
+		c.baseTransport = transport
+	}
+}

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

@@ -0,0 +1,28 @@
+// Code generated by django-cfg/django_client - DO NOT EDIT.
+// Generated at: {{ generated_at }}
+
+package {{ package_name }}
+
+{% if imports %}
+import (
+{% for import_path in imports %}
+	"{{ import_path }}"
+{% endfor %}
+)
+{% endif %}
+
+{% for struct in structs %}
+// {{ struct.doc | replace('\n', '\n// ') }}
+type {{ struct.name }} struct {
+{% for field in struct.fields %}
+{% if field.description %}
+	// {{ field.description | replace('\n', '\n\t// ') }}
+{% endif %}
+{% if field.deprecated %}
+	// Deprecated: This field is deprecated.
+{% endif %}
+	{{ field.name }} {{ field.type }} {{ field.json_tag }}
+{% endfor %}
+}
+
+{% endfor %}