nexarch/connect/internal/webhookclient/webhookclient.go

// Package webhookclient ist ein schlanker HTTP-Client fuer Core API-07
// (internal/webhook, zentrale Webhook-Registry). Connect ist ein physisch
// getrenntes Go-Modul und kann Cores internal/webhook daher nicht direkt
// importieren -- nur ueber dessen HTTP-Schnittstelle (gleiches Muster wie
// connect/internal/auditclient fuer AUD-08 und dms/internal/retentionclient
// fuer Archive RET-05).
package webhookclient

import (
	"bytes"
	"context"
	"encoding/json"
	"fmt"
	"net/http"
	"net/url"
	"time"

	"gitea.perlbach24.de/scripte/nexarch/common/httpclient"
)

type Client struct {
	BaseURL      string
	ServiceToken string
	HTTPClient   *http.Client
}

func New(baseURL, serviceToken string) *Client {
	return &Client{BaseURL: baseURL, ServiceToken: serviceToken, HTTPClient: httpclient.Default()}
}

// Subscription spiegelt Core API-07s Antwort auf eine Registrierung.
type Subscription struct {
	ID        string    `json:"id"`
	EventType string    `json:"event_type"`
	TargetURL string    `json:"target_url"`
	CreatedAt time.Time `json:"created_at"`
}

type subscribeRequest struct {
	TenantSlug string `json:"tenant_slug"`
	EventType  string `json:"event_type"`
	TargetURL  string `json:"target_url"`
	Secret     string `json:"secret"`
}

// Subscribe registriert targetURL bei Core API-07 fuer eventType. Jeder
// Fehler (Transport, Timeout, Nicht-2xx) wird als Fehler zurueckgegeben --
// der Aufrufer entscheidet, ob/wie er das nachbehandelt (Akzeptanzkriterium
// 1).
func (c *Client) Subscribe(ctx context.Context, tenantSlug, eventType, targetURL, secret string) (Subscription, error) {
	body, err := json.Marshal(subscribeRequest{
		TenantSlug: tenantSlug, EventType: eventType, TargetURL: targetURL, Secret: secret,
	})
	if err != nil {
		return Subscription{}, fmt.Errorf("webhookclient: request kodieren: %w", err)
	}
	req, err := http.NewRequestWithContext(ctx, http.MethodPost, c.BaseURL+"/webhooks/subscriptions", bytes.NewReader(body))
	if err != nil {
		return Subscription{}, fmt.Errorf("webhookclient: request bauen: %w", err)
	}
	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("X-Service-Token", c.ServiceToken)

	resp, err := c.httpClient().Do(req)
	if err != nil {
		return Subscription{}, fmt.Errorf("webhookclient: aufruf fehlgeschlagen: %w", err)
	}
	defer func() { _ = resp.Body.Close() }()

	if resp.StatusCode != http.StatusCreated {
		return Subscription{}, fmt.Errorf("webhookclient: unerwarteter status %d", resp.StatusCode)
	}
	var out Subscription
	if err := json.NewDecoder(resp.Body).Decode(&out); err != nil {
		return Subscription{}, fmt.Errorf("webhookclient: antwort dekodieren: %w", err)
	}
	return out, nil
}

// Unsubscribe entfernt subscriptionID vollstaendig aus Core API-07
// (Akzeptanzkriterium 3).
func (c *Client) Unsubscribe(ctx context.Context, tenantSlug, subscriptionID string) error {
	target := c.BaseURL + "/webhooks/subscriptions/" + url.PathEscape(subscriptionID) +
		"?tenant_slug=" + url.QueryEscape(tenantSlug)
	req, err := http.NewRequestWithContext(ctx, http.MethodDelete, target, nil)
	if err != nil {
		return fmt.Errorf("webhookclient: request bauen: %w", err)
	}
	req.Header.Set("X-Service-Token", c.ServiceToken)

	resp, err := c.httpClient().Do(req)
	if err != nil {
		return fmt.Errorf("webhookclient: aufruf fehlgeschlagen: %w", err)
	}
	defer func() { _ = resp.Body.Close() }()

	if resp.StatusCode != http.StatusNoContent {
		return fmt.Errorf("webhookclient: unerwarteter status %d", resp.StatusCode)
	}
	return nil
}

func (c *Client) httpClient() *http.Client {
	if c.HTTPClient != nil {
		return c.HTTPClient
	}
	return httpclient.Default()
}