Managing Webhook Endpoints

router.post("/", validateBody(CreateWebhookSchema), asyncHandler(async (req, res) => {
  const { sentService } = servicesForRequest(req);
  const body = req.body as { url: string; eventTypes?: string[] };
  const created = await sentService.createWebhook(body.url, body.eventTypes);
  // Hold the signing secret in memory, keyed by endpoint id, so the receiver
  // can look up the right secret for whichever endpoint Sent delivers to.
  webhookSecretStore.remember(created.id, created.secret);
  res.status(201).json(created);
}));

// In the service layer — note the snake_case → camelCase field mapping:
async createWebhook(url: string, eventTypes?: string[]) {
  const response = await this.client.webhooks.create({
    endpoint_url: url,          // contract `url`         → SDK `endpoint_url`
    event_types: eventTypes,    // contract `eventTypes`  → SDK `event_types`
  });
  const w = response.data ?? {};
  return {
    id: w.id,
    url: w.endpoint_url,
    eventTypes: w.event_types,
    active: w.is_active,        // SDK `is_active`        → contract `active`
    createdAt: w.created_at,
    secret: w.signing_secret,   // SDK `signing_secret`   → contract `secret` (ONCE)
  };
}

@router.post("", response_model=CanonicalCreatedWebhook, status_code=201)
async def create_webhook(request: Request, body: CanonicalCreateWebhookRequest,
                         client=Depends(get_sent_client)):
    service = SentService(client)
    created = await service.create_webhook(body.url, body.eventTypes)
    # Hold the signing secret in memory, keyed by endpoint id, so the receiver
    # can look up the right secret for whichever endpoint Sent delivers to.
    webhook_secret_store.remember(created.id, created.secret)
    return created

# In the service layer — snake_case (SDK) ↔ camelCase (contract):
#   url         → endpoint_url        is_active     → active
#   eventTypes  → event_types         signing_secret → secret (returned ONCE)

func (h *WebhookAdminHandler) Create(c echo.Context) error {
    var req models.CreateWebhookRequest // { URL, EventTypes }
    if err := c.Bind(&req); err != nil {
        return models.BindValidationError(err)
    }
    client, err := h.resolver.ForRequest(c) // per-request, key-scoped client
    if err != nil {
        return err
    }
    resp, err := client.WebhookCreate(c.Request().Context(), req.URL, req.EventTypes)
    if err != nil {
        return err
    }
    created := models.NewWebhookResponse(resp.Data) // maps endpoint_url→url, is_active→active…
    created.Secret = resp.Data.SigningSecret        // signing_secret → secret (ONCE)
    // Hold the signing secret in memory, keyed by endpoint id, so the receiver
    // can look up the right secret for whichever endpoint Sent delivers to.
    h.secrets.Remember(resp.Data.ID, resp.Data.SigningSecret)
    return c.JSON(http.StatusCreated, created)
}

router.get("/", asyncHandler(async (req, res) => {
  const { sentService } = servicesForRequest(req);
  res.json({ items: await sentService.listWebhooks() });
}));

router.patch("/:id/toggle", asyncHandler(async (req, res) => {
  const { sentService } = servicesForRequest(req);
  res.json(await sentService.toggleWebhook(String(req.params.id)));
}));

router.delete("/:id", asyncHandler(async (req, res) => {
  const { sentService } = servicesForRequest(req);
  await sentService.deleteWebhook(String(req.params.id));
  res.status(204).send();
}));

@router.get("", response_model=CanonicalWebhookList)
async def list_webhooks(request: Request, client=Depends(get_sent_client)):
    return await SentService(client).list_webhooks()

@router.patch("/{webhook_id}/toggle", response_model=CanonicalWebhook)
async def toggle_webhook(request: Request, webhook_id: str, client=Depends(get_sent_client)):
    return await SentService(client).toggle_webhook(webhook_id)

@router.delete("/{webhook_id}", status_code=204)
async def delete_webhook(request: Request, webhook_id: str, client=Depends(get_sent_client)):
    await SentService(client).delete_webhook(webhook_id)
    return Response(status_code=204)

func (h *WebhookAdminHandler) Register(e *echo.Echo) {
    e.GET("/api/webhooks", h.List)
    e.POST("/api/webhooks", h.Create)
    e.PATCH("/api/webhooks/:id/toggle", h.Toggle)
    e.POST("/api/webhooks/:id/rotate-secret", h.RotateSecret)
    e.DELETE("/api/webhooks/:id", h.Delete)
}

func (h *WebhookAdminHandler) Toggle(c echo.Context) error {
    client, err := h.resolver.ForRequest(c)
    if err != nil {
        return err
    }
    resp, err := client.WebhookToggle(c.Request().Context(), c.Param("id"))
    if err != nil {
        return err
    }
    return c.JSON(http.StatusOK, models.NewWebhookResponse(resp.Data))
}

router.post("/:id/rotate-secret", asyncHandler(async (req, res) => {
  const { sentService } = servicesForRequest(req);
  const id = String(req.params.id);
  const secret = await sentService.rotateWebhookSecret(id);
  // Persist the new secret immediately — Sent already signs with it. The old
  // entry in the set is harmless now; retire it once new-secret deliveries verify.
  webhookSecretStore.remember(id, secret);
  res.json({ secret });
}));

@router.post("/{webhook_id}/rotate-secret", response_model=CanonicalWebhookSecret)
async def rotate_webhook_secret(request: Request, webhook_id: str,
                                client=Depends(get_sent_client)):
    rotated = await SentService(client).rotate_webhook_secret(webhook_id)
    # Persist the new secret immediately — Sent already signs with it. The old
    # entry in the set is harmless now; retire it once new-secret deliveries verify.
    webhook_secret_store.remember(webhook_id, rotated.secret)
    return rotated

func (h *WebhookAdminHandler) RotateSecret(c echo.Context) error {
    client, err := h.resolver.ForRequest(c)
    if err != nil {
        return err
    }
    resp, err := client.WebhookRotateSecret(c.Request().Context(), c.Param("id"))
    if err != nil {
        return err
    }
    // Persist the new secret immediately — Sent already signs with it. The old
    // entry in the set is harmless now; retire it once new-secret deliveries verify.
    h.secrets.Remember(c.Param("id"), resp.Data.SigningSecret)
    return c.JSON(http.StatusOK, models.WebhookSecretResponse{Secret: resp.Data.SigningSecret})
}