fix: use query params for resource get/delete/deactivate methods (#24)

Match API migration from path-based to query-param-based resource
endpoints. Adds missing delete_resource tests for both sync and async.

Author: tngotr

src/pragma_sdk/client.py

@@ -25,7 +25,6 @@
     TrustTier,
     UpgradePolicy,
     UserInfo,
-    format_resource_id,
 )
 
 
@@ -271,13 +270,16 @@ def get_resource[ResourceT: Resource](
         Raises:
             httpx.HTTPStatusError: If resource not found or request fails.
         """  # noqa: DOC502
-        resource_id = format_resource_id(provider, resource, name)
-        params: dict[str, Any] = {}
+        params: dict[str, Any] = {"provider": provider, "resource": resource, "name": name}
+
         if reveal:
             params["reveal"] = "true"
-        response = self._request("GET", f"/resources/{resource_id}", params=params)
+
+        response = self._request("GET", "/resources/by-name", params=params)
+
         if model is not None:
             return model.model_validate(response)
+
         return response
 
     def apply_resource[ResourceT: Resource](
@@ -334,8 +336,8 @@ def deactivate_resource[ResourceT: Resource](
         Raises:
             httpx.HTTPStatusError: If resource not found or deactivation fails.
         """  # noqa: DOC502
-        resource_id = format_resource_id(provider, resource, name)
-        response = self._request("POST", f"/resources/{resource_id}/deactivate")
+        params = {"provider": provider, "resource": resource, "name": name}
+        response = self._request("POST", "/resources/deactivate", params=params)
 
         if model is not None:
             return model.model_validate(response)
@@ -348,8 +350,8 @@ def delete_resource(self, provider: str, resource: str, name: str) -> None:
         Raises:
             httpx.HTTPStatusError: If resource not found or deletion fails.
         """  # noqa: DOC502
-        resource_id = format_resource_id(provider, resource, name)
-        self._request("DELETE", f"/resources/{resource_id}")
+        params = {"provider": provider, "resource": resource, "name": name}
+        self._request("DELETE", "/resources/by-name", params=params)
 
     def list_dead_letter_events(self, provider: str | None = None) -> list[dict[str, Any]]:
         """List dead letter events with optional provider filter.
@@ -1018,13 +1020,16 @@ async def get_resource[ResourceT: Resource](
         Raises:
             httpx.HTTPStatusError: If resource not found or request fails.
         """  # noqa: DOC502
-        resource_id = format_resource_id(provider, resource, name)
-        params: dict[str, Any] = {}
+        params: dict[str, Any] = {"provider": provider, "resource": resource, "name": name}
+
         if reveal:
             params["reveal"] = "true"
-        response = await self._request("GET", f"/resources/{resource_id}", params=params)
+
+        response = await self._request("GET", "/resources/by-name", params=params)
+
         if model is not None:
             return model.model_validate(response)
+
         return response
 
     async def apply_resource[ResourceT: Resource](
@@ -1081,8 +1086,8 @@ async def deactivate_resource[ResourceT: Resource](
         Raises:
             httpx.HTTPStatusError: If resource not found or deactivation fails.
         """  # noqa: DOC502
-        resource_id = format_resource_id(provider, resource, name)
-        response = await self._request("POST", f"/resources/{resource_id}/deactivate")
+        params = {"provider": provider, "resource": resource, "name": name}
+        response = await self._request("POST", "/resources/deactivate", params=params)
 
         if model is not None:
             return model.model_validate(response)
@@ -1095,8 +1100,8 @@ async def delete_resource(self, provider: str, resource: str, name: str) -> None
         Raises:
             httpx.HTTPStatusError: If resource not found or deletion fails.
         """  # noqa: DOC502
-        resource_id = format_resource_id(provider, resource, name)
-        await self._request("DELETE", f"/resources/{resource_id}")
+        params = {"provider": provider, "resource": resource, "name": name}
+        await self._request("DELETE", "/resources/by-name", params=params)
 
     async def list_dead_letter_events(self, provider: str | None = None) -> list[dict[str, Any]]:
         """List dead letter events with optional provider filter.

tests/test_client.py

@@ -83,7 +83,10 @@ def test_pragma_client_list_resources_returns_typed_resources_with_model() -> No
 @respx.mock
 def test_pragma_client_get_resource_returns_dict_without_model() -> None:
     """Returns dict when no model parameter provided."""
-    respx.get("http://localhost:8000/resources/postgres/database/mydb").mock(
+    respx.get(
+        "http://localhost:8000/resources/by-name",
+        params={"provider": "postgres", "resource": "database", "name": "mydb"},
+    ).mock(
         return_value=httpx.Response(
             200,
             json={
@@ -104,7 +107,10 @@ def test_pragma_client_get_resource_returns_dict_without_model() -> None:
 @respx.mock
 def test_pragma_client_get_resource_returns_typed_resource_with_model() -> None:
     """Returns typed Resource instance when model parameter provided."""
-    respx.get("http://localhost:8000/resources/test/stub/mydb").mock(
+    respx.get(
+        "http://localhost:8000/resources/by-name",
+        params={"provider": "test", "resource": "stub", "name": "mydb"},
+    ).mock(
         return_value=httpx.Response(
             200,
             json={
@@ -169,7 +175,10 @@ def test_pragma_client_apply_resource_returns_typed_resource_with_model() -> Non
 @respx.mock
 def test_pragma_client_deactivate_resource_returns_dict_without_model() -> None:
     """Returns dict when no model parameter provided."""
-    respx.post("http://localhost:8000/resources/postgres/database/mydb/deactivate").mock(
+    respx.post(
+        "http://localhost:8000/resources/deactivate",
+        params={"provider": "postgres", "resource": "database", "name": "mydb"},
+    ).mock(
         return_value=httpx.Response(
             200,
             json={
@@ -190,7 +199,10 @@ def test_pragma_client_deactivate_resource_returns_dict_without_model() -> None:
 @respx.mock
 def test_pragma_client_deactivate_resource_returns_typed_resource_with_model() -> None:
     """Returns typed Resource instance when model parameter provided."""
-    respx.post("http://localhost:8000/resources/test/stub/mydb/deactivate").mock(
+    respx.post(
+        "http://localhost:8000/resources/deactivate",
+        params={"provider": "test", "resource": "stub", "name": "mydb"},
+    ).mock(
         return_value=httpx.Response(
             200,
             json={
@@ -209,12 +221,28 @@ def test_pragma_client_deactivate_resource_returns_typed_resource_with_model() -
     assert result.lifecycle_state == LifecycleState.DELETING
 
 
+@respx.mock
+def test_pragma_client_delete_resource_sends_delete_request() -> None:
+    """Sends DELETE to /resources/by-name with correct params and returns None."""
+    route = respx.delete(
+        "http://localhost:8000/resources/by-name",
+        params={"provider": "postgres", "resource": "database", "name": "mydb"},
+    ).mock(return_value=httpx.Response(200, json=None))
+
+    with PragmaClient(auth_token=None) as client:
+        result = client.delete_resource("postgres", "database", "mydb")
+
+    assert result is None
+    assert route.called
+
+
 @respx.mock
 def test_pragma_client_raises_on_not_found() -> None:
     """Raises HTTPStatusError when resource not found."""
-    respx.get("http://localhost:8000/resources/test/db/notfound").mock(
-        return_value=httpx.Response(404, json={"detail": "Not found"})
-    )
+    respx.get(
+        "http://localhost:8000/resources/by-name",
+        params={"provider": "test", "resource": "db", "name": "notfound"},
+    ).mock(return_value=httpx.Response(404, json={"detail": "Not found"}))
 
     with PragmaClient(auth_token=None) as client:
         with pytest.raises(httpx.HTTPStatusError) as exc_info:
@@ -315,7 +343,10 @@ async def test_async_pragma_client_list_resources_returns_typed_resources_with_m
 @respx.mock
 async def test_async_pragma_client_get_resource_returns_dict_without_model() -> None:
     """Returns dict when no model parameter provided."""
-    respx.get("http://localhost:8000/resources/postgres/database/mydb").mock(
+    respx.get(
+        "http://localhost:8000/resources/by-name",
+        params={"provider": "postgres", "resource": "database", "name": "mydb"},
+    ).mock(
         return_value=httpx.Response(
             200,
             json={
@@ -336,7 +367,10 @@ async def test_async_pragma_client_get_resource_returns_dict_without_model() ->
 @respx.mock
 async def test_async_pragma_client_get_resource_returns_typed_resource_with_model() -> None:
     """Returns typed Resource instance when model parameter provided."""
-    respx.get("http://localhost:8000/resources/test/stub/mydb").mock(
+    respx.get(
+        "http://localhost:8000/resources/by-name",
+        params={"provider": "test", "resource": "stub", "name": "mydb"},
+    ).mock(
         return_value=httpx.Response(
             200,
             json={
@@ -403,7 +437,10 @@ async def test_async_pragma_client_apply_resource_returns_typed_resource_with_mo
 @respx.mock
 async def test_async_pragma_client_deactivate_resource_returns_dict_without_model() -> None:
     """Returns dict when no model parameter provided."""
-    respx.post("http://localhost:8000/resources/postgres/database/mydb/deactivate").mock(
+    respx.post(
+        "http://localhost:8000/resources/deactivate",
+        params={"provider": "postgres", "resource": "database", "name": "mydb"},
+    ).mock(
         return_value=httpx.Response(
             200,
             json={
@@ -424,7 +461,10 @@ async def test_async_pragma_client_deactivate_resource_returns_dict_without_mode
 @respx.mock
 async def test_async_pragma_client_deactivate_resource_returns_typed_resource_with_model() -> None:
     """Returns typed Resource instance when model parameter provided."""
-    respx.post("http://localhost:8000/resources/test/stub/mydb/deactivate").mock(
+    respx.post(
+        "http://localhost:8000/resources/deactivate",
+        params={"provider": "test", "resource": "stub", "name": "mydb"},
+    ).mock(
         return_value=httpx.Response(
             200,
             json={
@@ -443,12 +483,28 @@ async def test_async_pragma_client_deactivate_resource_returns_typed_resource_wi
     assert result.lifecycle_state == LifecycleState.DELETING
 
 
+@respx.mock
+async def test_async_pragma_client_delete_resource_sends_delete_request() -> None:
+    """Sends DELETE to /resources/by-name with correct params and returns None."""
+    route = respx.delete(
+        "http://localhost:8000/resources/by-name",
+        params={"provider": "postgres", "resource": "database", "name": "mydb"},
+    ).mock(return_value=httpx.Response(200, json=None))
+
+    async with AsyncPragmaClient(auth_token=None) as client:
+        result = await client.delete_resource("postgres", "database", "mydb")
+
+    assert result is None
+    assert route.called
+
+
 @respx.mock
 async def test_async_pragma_client_raises_on_not_found() -> None:
     """Raises HTTPStatusError when resource not found."""
-    respx.get("http://localhost:8000/resources/test/db/notfound").mock(
-        return_value=httpx.Response(404, json={"detail": "Not found"})
-    )
+    respx.get(
+        "http://localhost:8000/resources/by-name",
+        params={"provider": "test", "resource": "db", "name": "notfound"},
+    ).mock(return_value=httpx.Response(404, json={"detail": "Not found"}))
 
     async with AsyncPragmaClient(auth_token=None) as client:
         with pytest.raises(httpx.HTTPStatusError) as exc_info: