Webhooks

import "github.com/xraph/authsome/webhook"

type Webhook struct {
    ID          id.ID      `json:"id"`          // awhk_ prefix
    AppID       string     `json:"app_id"`
    EnvID       string     `json:"env_id"`
    OrgID       *id.ID     `json:"org_id,omitempty"` // nil for app-level webhooks
    Name        string     `json:"name"`
    URL         string     `json:"url"`
    Secret      string     `json:"-"`           // HMAC signing secret -- never exposed after creation
    SecretHash  string     `json:"-"`           // stored hash
    Events      []string   `json:"events"`      // subscribed event types
    IsActive    bool       `json:"is_active"`
    Headers     map[string]string `json:"headers,omitempty"` // custom HTTP headers
    MaxRetries  int        `json:"max_retries"` // 0-5, default 3
    TimeoutMs   int        `json:"timeout_ms"`  // delivery timeout, default 5000
    CreatedAt   time.Time  `json:"created_at"`
    UpdatedAt   time.Time  `json:"updated_at"`
}

import "github.com/xraph/authsome/webhook"

result, err := auth.Webhooks().Create(ctx, &webhook.CreateInput{
    Name: "My Backend Notifications",
    URL:  "https://api.myapp.com/authsome/events",
    Events: []string{
        "user.created",
        "user.deleted",
        "auth.signin",
        "auth.signin.failed",
        "session.revoked",
    },
    Headers: map[string]string{
        "X-Source": "authsome",
    },
    MaxRetries: 3,
    TimeoutMs:  5000,
})
if err != nil {
    return err
}

// result.Secret is the signing secret -- only available at creation time.
fmt.Printf("webhook created: id=%s secret=%s\n", result.Webhook.ID, result.Secret)

// List all webhooks.
result, err := auth.Webhooks().List(ctx, &webhook.ListInput{Limit: 50})

// Get a specific webhook.
w, err := auth.Webhooks().GetByID(ctx, webhookID)

// Update a webhook (e.g., change subscribed events).
updated, err := auth.Webhooks().Update(ctx, webhookID, &webhook.UpdateInput{
    Events: []string{"user.created", "user.deleted"},
    IsActive: true,
})

// Deactivate (pause delivery without deleting).
err := auth.Webhooks().Deactivate(ctx, webhookID)

// Delete permanently.
err := auth.Webhooks().Delete(ctx, webhookID)

// Rotate the signing secret.
result, err := auth.Webhooks().RotateSecret(ctx, webhookID)
// result.NewSecret is the new secret -- only available here.

{
  "id": "awhke_01h455vb4pex5vsknk084sn02q",
  "event": "auth.signin",
  "app_id": "myapp",
  "env_id": "aenv_01h455vb...",
  "occurred_at": "2024-03-15T14:30:00Z",
  "data": {
    "user": {
      "id": "ausr_01h455vb...",
      "email": "[email protected]",
      "display_name": "Alice Nguyen"
    },
    "session": {
      "id": "ases_01h455vb...",
      "ip": "203.0.113.42",
      "user_agent": "Mozilla/5.0 ..."
    }
  }
}

package webhookhandler

import (
    "crypto/hmac"
    "crypto/sha256"
    "encoding/hex"
    "io"
    "net/http"
)

func HandleAuthsomeWebhook(secret string) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        body, err := io.ReadAll(r.Body)
        if err != nil {
            http.Error(w, "cannot read body", http.StatusBadRequest)
            return
        }

        // Verify HMAC-SHA256 signature.
        sig := r.Header.Get("X-Authsome-Signature")
        mac := hmac.New(sha256.New, []byte(secret))
        mac.Write(body)
        expected := "sha256=" + hex.EncodeToString(mac.Sum(nil))

        if !hmac.Equal([]byte(sig), []byte(expected)) {
            http.Error(w, "invalid signature", http.StatusUnauthorized)
            return
        }

        // Process the verified payload.
        var payload map[string]any
        json.Unmarshal(body, &payload)
        // ...

        w.WriteHeader(http.StatusOK)
    }
}

// View delivery attempts for a webhook.
deliveries, err := auth.Webhooks().ListDeliveries(ctx, webhookID, &webhook.ListDeliveriesInput{
    Limit: 50,
})

for _, d := range deliveries {
    fmt.Printf("  [%s] attempt=%d status=%d success=%v\n",
        d.CreatedAt.Format(time.RFC3339),
        d.Attempt,
        d.ResponseStatus,
        d.Success,
    )
}

// Manually retry a failed delivery.
err := auth.Webhooks().RetryDelivery(ctx, webhookID, deliveryID)

import (
    "github.com/xraph/authsome"
    "github.com/xraph/authsome/webhook/relay"
)

auth := authsome.New(
    authsome.WithWebhookBridge(relay.NewBridge(
        relay.WithEndpoint("https://relay.internal:8080"),
        relay.WithAPIKey(os.Getenv("RELAY_API_KEY")),
        relay.WithTopic("authsome.events"),
        relay.WithAsync(true),
    )),
)