replylayer 0.14.0__py3-none-any.whl

replylayer/resources/webhooks.py

@@ -0,0 +1,175 @@
+from __future__ import annotations
+
+import hashlib
+import hmac
+import time
+from typing import Any
+
+from .._http import AsyncHttpClient, SyncHttpClient
+from ..errors import WebhookSignatureError
+
+
+def verify_webhook_signature(
+    payload: str | bytes,
+    signature: str,
+    secret: str,
+    *,
+    tolerance: int = 300,
+) -> bool:
+    parts = signature.split(",")
+    timestamp: str | None = None
+    v1_hex: str | None = None
+
+    for part in parts:
+        trimmed = part.strip()
+        if trimmed.startswith("t="):
+            timestamp = trimmed[2:]
+        if trimmed.startswith("v1="):
+            v1_hex = trimmed[3:]
+
+    if not timestamp or not v1_hex:
+        raise WebhookSignatureError("Invalid signature format: missing t= or v1= component")
+
+    try:
+        ts = int(timestamp)
+    except ValueError:
+        raise WebhookSignatureError("Invalid signature format: timestamp is not a number")
+
+    now = int(time.time())
+    if abs(now - ts) > tolerance:
+        raise WebhookSignatureError(
+            f"Webhook timestamp too old ({abs(now - ts)}s exceeds {tolerance}s tolerance)"
+        )
+
+    body = payload if isinstance(payload, str) else payload.decode("utf-8")
+    expected = hmac.new(
+        secret.encode("utf-8"),
+        f"{timestamp}.{body}".encode("utf-8"),
+        hashlib.sha256,
+    ).hexdigest()
+
+    if not hmac.compare_digest(expected, v1_hex):
+        raise WebhookSignatureError("Webhook signature mismatch")
+
+    return True
+
+
+class SyncWebhooks:
+    def __init__(self, http: SyncHttpClient) -> None:
+        self._http = http
+
+    def create(self, *, url: str, enabled_events: list[str], description: str | None = None, enabled: bool = True) -> dict[str, Any]:
+        """Create a new webhook subscription.
+
+        Raises ``ForbiddenError`` (HTTP 403) when the account is at its
+        tier cap. The error's ``details`` carries
+        ``{"feature": "webhook_count_extended", "current_count": int,
+        "max_allowed": int}`` so callers can render actionable upgrade
+        prompts. Cap matrix: Sandbox 1, Starter 3, Pro 25, Team 100,
+        Scale 250, Enterprise unbounded.
+        """
+        payload: dict[str, Any] = {"url": url, "enabled_events": enabled_events, "enabled": enabled}
+        if description is not None:
+            payload["description"] = description
+        return self._http.request("POST", "/v1/webhooks", body=payload)
+
+    def list(self) -> dict[str, Any]:
+        return self._http.request("GET", "/v1/webhooks")
+
+    def get(self, id: str) -> dict[str, Any]:
+        return self._http.request("GET", f"/v1/webhooks/{id}")
+
+    def update(self, id: str, **kwargs: Any) -> dict[str, Any]:
+        return self._http.request("PATCH", f"/v1/webhooks/{id}", body=kwargs)
+
+    def delete(self, id: str) -> dict[str, Any]:
+        return self._http.request("DELETE", f"/v1/webhooks/{id}")
+
+    def rotate_secret(self, id: str) -> dict[str, Any]:
+        return self._http.request("POST", f"/v1/webhooks/{id}/rotate-secret")
+
+    def test(self, id: str) -> dict[str, Any]:
+        return self._http.request("POST", f"/v1/webhooks/{id}/test")
+
+    def list_deliveries(
+        self,
+        id: str,
+        *,
+        limit: int | None = None,
+        before_at: str | None = None,
+        before_id: str | None = None,
+    ) -> dict[str, Any]:
+        # The API requires before_at + before_id together (400s otherwise).
+        # Enforce the pair at the SDK layer so a partial call doesn't build
+        # a request the server will reject.
+        query: dict[str, str | None] = {}
+        if limit is not None:
+            query["limit"] = str(limit)
+        if before_at and before_id:
+            query["before_at"] = before_at
+            query["before_id"] = before_id
+        return self._http.request("GET", f"/v1/webhooks/{id}/deliveries", query=query)
+
+    def retry_delivery(self, id: str, delivery_id: str) -> dict[str, Any]:
+        return self._http.request(
+            "POST", f"/v1/webhooks/{id}/deliveries/{delivery_id}/retry"
+        )
+
+    @staticmethod
+    def verify_signature(payload: str | bytes, signature: str, secret: str, *, tolerance: int = 300) -> bool:
+        return verify_webhook_signature(payload, signature, secret, tolerance=tolerance)
+
+
+class AsyncWebhooks:
+    def __init__(self, http: AsyncHttpClient) -> None:
+        self._http = http
+
+    async def create(self, *, url: str, enabled_events: list[str], description: str | None = None, enabled: bool = True) -> dict[str, Any]:
+        """Create a new webhook subscription. See SyncWebhooks.create for tier-cap details."""
+        payload: dict[str, Any] = {"url": url, "enabled_events": enabled_events, "enabled": enabled}
+        if description is not None:
+            payload["description"] = description
+        return await self._http.request("POST", "/v1/webhooks", body=payload)
+
+    async def list(self) -> dict[str, Any]:
+        return await self._http.request("GET", "/v1/webhooks")
+
+    async def get(self, id: str) -> dict[str, Any]:
+        return await self._http.request("GET", f"/v1/webhooks/{id}")
+
+    async def update(self, id: str, **kwargs: Any) -> dict[str, Any]:
+        return await self._http.request("PATCH", f"/v1/webhooks/{id}", body=kwargs)
+
+    async def delete(self, id: str) -> dict[str, Any]:
+        return await self._http.request("DELETE", f"/v1/webhooks/{id}")
+
+    async def rotate_secret(self, id: str) -> dict[str, Any]:
+        return await self._http.request("POST", f"/v1/webhooks/{id}/rotate-secret")
+
+    async def test(self, id: str) -> dict[str, Any]:
+        return await self._http.request("POST", f"/v1/webhooks/{id}/test")
+
+    async def list_deliveries(
+        self,
+        id: str,
+        *,
+        limit: int | None = None,
+        before_at: str | None = None,
+        before_id: str | None = None,
+    ) -> dict[str, Any]:
+        query: dict[str, str | None] = {}
+        if limit is not None:
+            query["limit"] = str(limit)
+        if before_at and before_id:
+            query["before_at"] = before_at
+            query["before_id"] = before_id
+        return await self._http.request("GET", f"/v1/webhooks/{id}/deliveries", query=query)
+
+    async def retry_delivery(self, id: str, delivery_id: str) -> dict[str, Any]:
+        return await self._http.request(
+            "POST", f"/v1/webhooks/{id}/deliveries/{delivery_id}/retry"
+        )
+
+    @staticmethod
+    def verify_signature(payload: str | bytes, signature: str, secret: str, *, tolerance: int = 300) -> bool:
+        return verify_webhook_signature(payload, signature, secret, tolerance=tolerance)