hookbase 2.6.0__tar.gz → 2.8.0__tar.gz

{hookbase-2.6.0 → hookbase-2.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: hookbase
-Version: 2.6.0
+Version: 2.8.0
 Summary: Official Python SDK for the Hookbase webhook management platform
 Project-URL: Homepage, https://hookbase.app
 Project-URL: Documentation, https://www.hookbase.app/docs/send/sdk

{hookbase-2.6.0 → hookbase-2.8.0}/src/hookbase/_client.py

@@ -27,9 +27,15 @@ logger = logging.getLogger("hookbase")
 def _parse_error(status_code: int, body: dict[str, Any], request_id: str | None) -> APIError:
     error = body.get("error", body)
     if isinstance(error, str):
+        # This is the shape the real API actually sends: `error` is a plain string, with
+        # `code` and `details` (Zod's `.flatten()` shape: `{ fieldErrors, formErrors }`) as
+        # siblings at the top level of the body, not nested inside `error`.
         message = error
-        code = "unknown_error"
-        validation_errors = None
+        code = body.get("code", "unknown_error")
+        details = body.get("details")
+        validation_errors = (
+            details.get("fieldErrors") if isinstance(details, dict) else None
+        )
     elif isinstance(error, dict):
         message = error.get("message") or body.get("message") or f"API error: {status_code}"
         code = error.get("code", "unknown_error")

hookbase-2.8.0/src/hookbase/_version.py

@@ -0,0 +1 @@
+__version__ = "2.8.0"

{hookbase-2.6.0 → hookbase-2.8.0}/src/hookbase/errors.py

@@ -38,8 +38,11 @@ class APIError(HookbaseError):
     ) -> APIError:
         error = body.get("error", body)
         if isinstance(error, str):
+            # The real API always sends `error` as a plain string, with `code` and `details`
+            # (Zod's `.flatten()` shape: `{ fieldErrors, formErrors }`) as siblings of `error`
+            # at the top level of the body — never nested inside it.
             message = error
-            code = "unknown_error"
+            code = body.get("code", "unknown_error")
         elif isinstance(error, dict):
             message = error.get("message", f"API error: {status_code}")
             code = error.get("code", "unknown_error")
@@ -49,7 +52,11 @@ class APIError(HookbaseError):
 
         if status_code in (400, 422):
             validation_errors = None
-            if isinstance(error, dict):
+            if isinstance(error, str):
+                details = body.get("details")
+                if isinstance(details, dict):
+                    validation_errors = details.get("fieldErrors")
+            elif isinstance(error, dict):
                 validation_errors = error.get("validationErrors")
             return ValidationError(
                 message=message,

{hookbase-2.6.0 → hookbase-2.8.0}/src/hookbase/models/__init__.py

@@ -7,6 +7,7 @@ from .cron_jobs import (
     CreateCronJobParams,
     CronGroup,
     CronJob,
+    CronJobExecution,
     UpdateCronJobParams,
 )
 from .deliveries import (
@@ -123,6 +124,7 @@ __all__ = [
     "CreateCronJobParams",
     "CronGroup",
     "CronJob",
+    "CronJobExecution",
     "UpdateCronJobParams",
     # Deliveries
     "BulkReplayResult",

{hookbase-2.6.0 → hookbase-2.8.0}/src/hookbase/models/cron_jobs.py

@@ -1,11 +1,14 @@
 from __future__ import annotations
 
 import json
+from typing import Literal
 
 from pydantic import field_validator
 
 from ._base import HookbaseModel
 
+CronJobExecutionStatus = Literal["success", "failed"]
+
 
 class CronJob(HookbaseModel):
     id: str
@@ -15,15 +18,19 @@ class CronJob(HookbaseModel):
     url: str = ""
     method: str = "GET"
     headers: dict[str, str] | None = None
-    body: str | None = None
-    schedule: str = ""
+    payload: str | None = None
+    cron_expression: str = ""
     timezone: str = "UTC"
+    timeout_ms: int = 30000
     is_active: bool = True
     use_static_ip: bool = True
     group_id: str | None = None
     last_run_at: str | None = None
     next_run_at: str | None = None
-    last_status: str | None = None
+    consecutive_failures: int = 0
+    notify_on_failure: bool = False
+    notify_on_success: bool = False
+    notify_emails: str | None = None
     created_at: str = ""
     updated_at: str = ""
 
@@ -40,18 +47,29 @@ class CronJob(HookbaseModel):
         return v
 
 
+class CronJobExecution(HookbaseModel):
+    id: str
+    status: CronJobExecutionStatus = "success"
+    response_status: int | None = None
+    latency_ms: int = 0
+
+
 class CreateCronJobParams(HookbaseModel):
     name: str
     description: str | None = None
     url: str
     method: str | None = None
     headers: dict[str, str] | None = None
-    body: str | None = None
-    schedule: str
+    payload: str | None = None
+    cron_expression: str
     timezone: str | None = None
+    timeout_ms: int | None = None
     is_active: bool | None = None
     use_static_ip: bool | None = None
     group_id: str | None = None
+    notify_on_failure: bool | None = None
+    notify_on_success: bool | None = None
+    notify_emails: str | None = None
 
 
 class UpdateCronJobParams(HookbaseModel):
@@ -60,12 +78,16 @@ class UpdateCronJobParams(HookbaseModel):
     url: str | None = None
     method: str | None = None
     headers: dict[str, str] | None = None
-    body: str | None = None
-    schedule: str | None = None
+    payload: str | None = None
+    cron_expression: str | None = None
     timezone: str | None = None
+    timeout_ms: int | None = None
     is_active: bool | None = None
     use_static_ip: bool | None = None
     group_id: str | None = None
+    notify_on_failure: bool | None = None
+    notify_on_success: bool | None = None
+    notify_emails: str | None = None
 
 
 class CronGroup(HookbaseModel):

{hookbase-2.6.0 → hookbase-2.8.0}/src/hookbase/models/destinations.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import json
 from typing import Any, Literal
 
-from pydantic import field_validator, model_validator
+from pydantic import Field, field_validator, model_validator
 
 from ._base import HookbaseModel
 
@@ -209,7 +209,10 @@ class UpdateDestinationParams(HookbaseModel):
 
 class TestResult(HookbaseModel):
     success: bool
-    status_code: int | None = None
-    duration: float | None = None
+    # The API answers with `status`/`latencyMs` (api/src/routes/destinations.ts), not the
+    # `statusCode`/`duration` that HookbaseModel's to_camel alias_generator would otherwise
+    # expect for these field names — override the alias explicitly rather than rely on it.
+    status_code: int | None = Field(default=None, alias="status")
+    duration: float | None = Field(default=None, alias="latencyMs")
     response_body: str | None = None
     error: str | None = None

{hookbase-2.6.0 → hookbase-2.8.0}/src/hookbase/resources/cron_jobs.py

@@ -13,6 +13,7 @@ from ..models.cron_jobs import (
     CreateCronJobParams,
     CronGroup,
     CronJob,
+    CronJobExecution,
     UpdateCronJobParams,
 )
 from ._base import AsyncResource, SyncResource, _to_body
@@ -49,6 +50,11 @@ class CronJobs(SyncResource):
     def delete(self, id: str) -> None:
         self._request("DELETE", f"/api/cron/{id}")
 
+    def trigger(self, id: str) -> CronJobExecution:
+        resp = self._request("POST", f"/api/cron/{id}/trigger")
+        data = resp.get("execution", resp)
+        return self._parse(CronJobExecution, data)
+
     def list_groups(self) -> list[CronGroup]:
         resp = self._request("GET", "/api/cron-groups")
         items = resp.get("groups", resp.get("data", []))
@@ -92,6 +98,11 @@ class AsyncCronJobs(AsyncResource):
     async def delete(self, id: str) -> None:
         await self._request("DELETE", f"/api/cron/{id}")
 
+    async def trigger(self, id: str) -> CronJobExecution:
+        resp = await self._request("POST", f"/api/cron/{id}/trigger")
+        data = resp.get("execution", resp)
+        return self._parse(CronJobExecution, data)
+
     async def list_groups(self) -> list[CronGroup]:
         resp = await self._request("GET", "/api/cron-groups")
         items = resp.get("groups", resp.get("data", []))

hookbase-2.8.0/tests/resources/test_cron_jobs.py

@@ -0,0 +1,160 @@
+from __future__ import annotations
+
+import pytest
+import respx
+
+from hookbase import Hookbase
+from hookbase.models import CronJob, CronJobExecution
+
+from ..conftest import make_paginated_response
+
+CRON_JOB_DATA = {
+    "id": "cron_1",
+    "organizationId": "org_1",
+    "groupId": None,
+    "name": "Nightly sync",
+    "description": None,
+    "cronExpression": "0 0 * * *",
+    "timezone": "UTC",
+    "url": "https://example.com/sync",
+    "method": "POST",
+    "headers": None,
+    "payload": None,
+    "timeoutMs": 30000,
+    "useStaticIp": False,
+    "isActive": True,
+    "notifyOnFailure": True,
+    "notifyOnSuccess": False,
+    "notifyEmails": None,
+    "consecutiveFailures": 0,
+    "lastRunAt": "2026-09-01T00:00:00Z",
+    "nextRunAt": "2026-09-02T00:00:00Z",
+    "createdAt": "2026-01-01T00:00:00Z",
+    "updatedAt": "2026-09-01T00:00:00Z",
+}
+
+
+@pytest.fixture
+def mock_api():
+    with respx.mock(base_url="https://api.hookbase.app") as mock:
+        yield mock
+
+
+@pytest.fixture
+def client(mock_api):
+    c = Hookbase(api_key="whr_test")
+    yield c
+    c.close()
+
+
+def test_list_cron_jobs_uses_real_field_names(mock_api, client):
+    # GET /api/cron sends cronExpression, timezone, nextRunAt, lastRunAt and
+    # consecutiveFailures -- not the old, fabricated "schedule"/"lastStatus" fields.
+    mock_api.get("/api/cron").respond(200, json=make_paginated_response(
+        [CRON_JOB_DATA], data_key="cronJobs", total=1,
+    ))
+    page = client.cron_jobs.list()
+    assert len(page) == 1
+    job = page.data[0]
+    assert isinstance(job, CronJob)
+    assert job.cron_expression == "0 0 * * *"
+    assert job.next_run_at == "2026-09-02T00:00:00Z"
+    assert job.last_run_at == "2026-09-01T00:00:00Z"
+    assert job.consecutive_failures == 0
+    assert job.payload is None
+    assert not hasattr(job, "last_status")
+    assert not hasattr(job, "schedule")
+
+
+def test_get_cron_job_uses_real_field_names(mock_api, client):
+    mock_api.get("/api/cron/cron_1").respond(200, json={"cronJob": CRON_JOB_DATA})
+    job = client.cron_jobs.get("cron_1")
+    assert job.cron_expression == "0 0 * * *"
+    assert job.timeout_ms == 30000
+    assert job.notify_on_failure is True
+    assert job.notify_on_success is False
+    assert job.consecutive_failures == 0
+
+
+def test_create_cron_job(mock_api, client):
+    mock_api.post("/api/cron").respond(200, json={"cronJob": CRON_JOB_DATA})
+    job = client.cron_jobs.create({
+        "name": "Nightly sync",
+        "url": "https://example.com/sync",
+        "cron_expression": "0 0 * * *",
+        "payload": '{"foo": "bar"}',
+    })
+    assert isinstance(job, CronJob)
+    assert job.cron_expression == "0 0 * * *"
+
+
+def test_update_cron_job(mock_api, client):
+    mock_api.patch("/api/cron/cron_1").respond(200, json={"success": True})
+    client.cron_jobs.update("cron_1", {"cron_expression": "*/5 * * * *", "payload": "{}"})
+
+
+def test_delete_cron_job(mock_api, client):
+    mock_api.delete("/api/cron/cron_1").respond(200, json={"success": True})
+    client.cron_jobs.delete("cron_1")
+
+
+def test_trigger_cron_job_calls_trigger_endpoint(mock_api, client):
+    route = mock_api.post("/api/cron/cron_1/trigger").respond(200, json={
+        "execution": {
+            "id": "exec_1",
+            "status": "success",
+            "responseStatus": 200,
+            "latencyMs": 142,
+        }
+    })
+    result = client.cron_jobs.trigger("cron_1")
+    assert route.called
+    assert isinstance(result, CronJobExecution)
+    assert result.id == "exec_1"
+    assert result.status == "success"
+    assert result.response_status == 200
+    assert result.latency_ms == 142
+
+
+def test_trigger_cron_job_failed_execution(mock_api, client):
+    mock_api.post("/api/cron/cron_1/trigger").respond(200, json={
+        "execution": {
+            "id": "exec_2",
+            "status": "failed",
+            "responseStatus": None,
+            "latencyMs": 30000,
+        }
+    })
+    result = client.cron_jobs.trigger("cron_1")
+    assert result.status == "failed"
+    assert result.response_status is None
+
+
+async def test_async_list_cron_jobs(mock_api):
+    from hookbase import AsyncHookbase
+
+    mock_api.get("/api/cron").respond(200, json=make_paginated_response(
+        [CRON_JOB_DATA], data_key="cronJobs", total=1,
+    ))
+    client = AsyncHookbase(api_key="whr_test")
+    page = await client.cron_jobs.list()
+    assert page.data[0].cron_expression == "0 0 * * *"
+    await client.close()
+
+
+async def test_async_trigger_cron_job(mock_api):
+    from hookbase import AsyncHookbase
+
+    mock_api.post("/api/cron/cron_1/trigger").respond(200, json={
+        "execution": {
+            "id": "exec_1",
+            "status": "success",
+            "responseStatus": 200,
+            "latencyMs": 99,
+        }
+    })
+    client = AsyncHookbase(api_key="whr_test")
+    result = await client.cron_jobs.trigger("cron_1")
+    assert isinstance(result, CronJobExecution)
+    assert result.latency_ms == 99
+    await client.close()

{hookbase-2.6.0 → hookbase-2.8.0}/tests/resources/test_destinations.py

@@ -272,10 +272,24 @@ def test_update_destination_params_throttle_serializes_camelcase():
 
 
 def test_test_destination(mock_api, client):
+    # The API answers with `status`/`latencyMs` (api/src/routes/destinations.ts), not
+    # `statusCode`/`duration` — the model aliases onto those field names explicitly.
     mock_api.post("/api/destinations/dst_1/test").respond(200, json={
-        "success": True, "statusCode": 200, "duration": 150.5,
+        "success": True, "status": 200, "latencyMs": 150.5, "responseBody": "OK",
     })
     result = client.destinations.test("dst_1")
     assert isinstance(result, TestResult)
     assert result.success is True
     assert result.status_code == 200
+    assert result.duration == 150.5
+    assert result.response_body == "OK"
+
+
+def test_test_destination_failure_surfaces_error(mock_api, client):
+    mock_api.post("/api/destinations/dst_1/test").respond(200, json={
+        "success": False, "error": "Network error",
+    })
+    result = client.destinations.test("dst_1")
+    assert result.success is False
+    assert result.error == "Network error"
+    assert result.status_code is None

{hookbase-2.6.0 → hookbase-2.8.0}/tests/test_errors.py

@@ -30,16 +30,17 @@ def client(mock_api):
 
 def test_401_raises_authentication_error(mock_api, client):
     mock_api.get("/api/sources/src_1").respond(
-        401, json={"error": {"message": "Invalid API key"}}
+        401, json={"error": "Invalid API key", "code": "authentication_error"}
     )
     with pytest.raises(AuthenticationError) as exc_info:
         client.sources.get("src_1")
     assert exc_info.value.status_code == 401
+    assert str(exc_info.value) == "Invalid API key"
 
 
 def test_403_raises_forbidden_error(mock_api, client):
     mock_api.get("/api/sources/src_1").respond(
-        403, json={"error": {"message": "Forbidden"}}
+        403, json={"error": "Forbidden", "code": "forbidden"}
     )
     with pytest.raises(ForbiddenError):
         client.sources.get("src_1")
@@ -47,7 +48,7 @@ def test_403_raises_forbidden_error(mock_api, client):
 
 def test_404_raises_not_found_error(mock_api, client):
     mock_api.get("/api/sources/src_1").respond(
-        404, json={"error": {"message": "Not found"}}
+        404, json={"error": "Not found", "code": "not_found"}
     )
     with pytest.raises(NotFoundError):
         client.sources.get("src_1")
@@ -56,17 +57,24 @@ def test_404_raises_not_found_error(mock_api, client):
 def test_400_raises_validation_error(mock_api, client):
     mock_api.post("/api/sources").respond(
         400,
-        json={"error": {"message": "Name is required",
-                         "validationErrors": {"name": ["required"]}}},
+        json={
+            "error": "Name is required",
+            "code": "validation_error",
+            "details": {
+                "fieldErrors": {"name": ["required"]},
+                "formErrors": [],
+            },
+        },
     )
     with pytest.raises(ValidationError) as exc_info:
         client.sources.create({"name": ""})
     assert exc_info.value.validation_errors == {"name": ["required"]}
+    assert str(exc_info.value) == "Name is required"
 
 
 def test_409_raises_conflict_error(mock_api, client):
     mock_api.post("/api/sources").respond(
-        409, json={"error": {"message": "Slug already exists"}}
+        409, json={"error": "Slug already exists", "code": "conflict"}
     )
     with pytest.raises(ConflictError):
         client.sources.create({"name": "test", "slug": "existing"})
@@ -75,7 +83,7 @@ def test_409_raises_conflict_error(mock_api, client):
 def test_429_raises_rate_limit_error(mock_api, client):
     mock_api.get("/api/sources/src_1").respond(
         429,
-        json={"error": {"message": "Too many requests"}},
+        json={"error": "Too many requests", "code": "rate_limit_exceeded"},
         headers={"retry-after": "30"},
     )
     with pytest.raises(RateLimitError) as exc_info:
@@ -85,16 +93,45 @@ def test_429_raises_rate_limit_error(mock_api, client):
 
 def test_500_raises_api_error(mock_api, client):
     mock_api.get("/api/sources/src_1").respond(
-        500, json={"error": {"message": "Internal error"}}
+        500, json={"error": "Internal error", "code": "internal_error"}
     )
     with pytest.raises(APIError) as exc_info:
         client.sources.get("src_1")
     assert exc_info.value.status_code == 500
+    # The real API's `code` is a body-level sibling of `error`, not nested inside it —
+    # make sure it's actually read rather than falling back to the generic default.
+    assert exc_info.value.code == "internal_error"
+
+
+def test_error_code_falls_back_to_default_when_absent(mock_api, client):
+    mock_api.get("/api/sources/src_1").respond(500, json={"error": "Internal error"})
+    with pytest.raises(APIError) as exc_info:
+        client.sources.get("src_1")
+    assert exc_info.value.code == "unknown_error"
 
 
 def test_error_from_response_string_error():
-    err = APIError.from_response(500, {"error": "Server error"})
+    err = APIError.from_response(500, {"error": "Server error", "code": "server_error"})
     assert str(err) == "Server error"
+    assert err.code == "server_error"
+
+
+def test_error_from_response_string_error_default_code():
+    err = APIError.from_response(500, {"error": "Server error"})
+    assert err.code == "unknown_error"
+
+
+def test_error_from_response_validation_details():
+    err = APIError.from_response(
+        400,
+        {
+            "error": "Name is required",
+            "code": "validation_error",
+            "details": {"fieldErrors": {"name": ["required"]}},
+        },
+    )
+    assert isinstance(err, ValidationError)
+    assert err.validation_errors == {"name": ["required"]}
 
 
 def test_error_from_response_dict_error():
@@ -102,3 +139,4 @@ def test_error_from_response_dict_error():
         500, {"error": {"message": "Detailed error", "code": "server_error"}},
     )
     assert str(err) == "Detailed error"
+    assert err.code == "server_error"

hookbase-2.6.0/src/hookbase/_version.py

@@ -1 +0,0 @@
-__version__ = "2.6.0"