chore: rpc route are the same as ruby

Author: jbarreau

src/agent_rpc/forestadmin/agent_rpc/agent.py

@@ -15,7 +15,6 @@
     ActionFormValuesSerializer,
     ActionResultSerializer,
 )
-from forestadmin.rpc_common.serializers.aes import aes_decrypt, aes_encrypt
 from forestadmin.rpc_common.serializers.collection.aggregation import AggregationSerializer
 from forestadmin.rpc_common.serializers.collection.filter import (
     FilterSerializer,
@@ -42,6 +41,7 @@ def __init__(self, options: RpcOptions):
 
     @web.middleware
     async def hmac_middleware(self, request: web.Request, handler):
+        # TODO: handle HMAC like ruby agent
         if request.method == "POST":
             body = await request.read()
             if not is_valid_hmac(
@@ -51,20 +51,21 @@ async def hmac_middleware(self, request: web.Request, handler):
         return await handler(request)
 
     def setup_routes(self):
+        self.app.router.add_route("GET", "/", lambda _: web.Response(text="OK"))  # type: ignore
         self.app.router.add_route("GET", "/sse", self.sse_handler)
         self.app.router.add_route("GET", "/schema", self.schema)
-        self.app.router.add_route("POST", "/collection/list", self.collection_list)
-        self.app.router.add_route("POST", "/collection/create", self.collection_create)
-        self.app.router.add_route("POST", "/collection/update", self.collection_update)
-        self.app.router.add_route("POST", "/collection/delete", self.collection_delete)
-        self.app.router.add_route("POST", "/collection/aggregate", self.collection_aggregate)
-        self.app.router.add_route("POST", "/collection/get-form", self.collection_get_form)
-        self.app.router.add_route("POST", "/collection/execute", self.collection_execute)
-        self.app.router.add_route("POST", "/collection/render-chart", self.collection_render_chart)
-
-        self.app.router.add_route("POST", "/execute-native-query", self.native_query)
-        self.app.router.add_route("POST", "/render-chart", self.render_chart)
-        self.app.router.add_route("GET", "/", lambda _: web.Response(text="OK"))  # type: ignore
+
+        # self.app.router.add_route("POST", "/execute-native-query", self.native_query)
+        self.app.router.add_route("POST", "/forest/rpc/datasource-chart", self.render_chart)
+
+        self.app.router.add_route("POST", "/forest/rpc/{collection_name}/list", self.collection_list)
+        self.app.router.add_route("POST", "/forest/rpc/{collection_name}/create", self.collection_create)
+        self.app.router.add_route("POST", "/forest/rpc/{collection_name}/update", self.collection_update)
+        self.app.router.add_route("POST", "/forest/rpc/{collection_name}/delete", self.collection_delete)
+        self.app.router.add_route("POST", "/forest/rpc/{collection_name}/aggregate", self.collection_aggregate)
+        self.app.router.add_route("POST", "/forest/rpc/{collection_name}/action-form", self.collection_get_form)
+        self.app.router.add_route("POST", "/forest/rpc/{collection_name}/action-execute", self.collection_execute)
+        self.app.router.add_route("POST", "/forest/rpc/{collection_name}/chart", self.collection_render_chart)
 
     async def sse_handler(self, request: web.Request) -> web.StreamResponse:
         async with sse_response(request) as resp:
@@ -83,7 +84,7 @@ async def schema(self, request):
     async def collection_list(self, request: web.Request):
         body_params = await request.json()
         ds = await self.customizer.get_datasource()
-        collection = ds.get_collection(body_params["collectionName"])
+        collection = ds.get_collection(request.match_info["collection_name"])
         caller = CallerSerializer.deserialize(body_params["caller"])
         filter_ = PaginatedFilterSerializer.deserialize(body_params["filter"], collection)  # type:ignore
         projection = ProjectionSerializer.deserialize(body_params["projection"])
@@ -97,7 +98,7 @@ async def collection_create(self, request: web.Request):
         body_params = json.loads(body_params)
         ds = await self.customizer.get_datasource()
 
-        collection = ds.get_collection(body_params["collectionName"])
+        collection = ds.get_collection(request.match_info["collection_name"])
         caller = CallerSerializer.deserialize(body_params["caller"])
         data = [RecordSerializer.deserialize(r, collection) for r in body_params["data"]]  # type:ignore
 
@@ -110,7 +111,7 @@ async def collection_update(self, request: web.Request):
         body_params = json.loads(body_params)
 
         ds = await self.customizer.get_datasource()
-        collection = ds.get_collection(body_params["collectionName"])
+        collection = ds.get_collection(request.match_info["collection_name"])
         caller = CallerSerializer.deserialize(body_params["caller"])
         filter_ = FilterSerializer.deserialize(body_params["filter"], collection)  # type:ignore
         patch = RecordSerializer.deserialize(body_params["patch"], collection)  # type:ignore
@@ -121,7 +122,7 @@ async def collection_update(self, request: web.Request):
     async def collection_delete(self, request: web.Request):
         body_params = await request.json()
         ds = await self.customizer.get_datasource()
-        collection = ds.get_collection(body_params["collectionName"])
+        collection = ds.get_collection(request.match_info["collection_name"])
         caller = CallerSerializer.deserialize(body_params["caller"])
         filter_ = FilterSerializer.deserialize(body_params["filter"], collection)  # type:ignore
 
@@ -131,7 +132,7 @@ async def collection_delete(self, request: web.Request):
     async def collection_aggregate(self, request: web.Request):
         body_params = await request.json()
         ds = await self.customizer.get_datasource()
-        collection = ds.get_collection(body_params["collectionName"])
+        collection = ds.get_collection(request.match_info["collection_name"])
         caller = CallerSerializer.deserialize(body_params["caller"])
         filter_ = FilterSerializer.deserialize(body_params["filter"], collection)  # type:ignore
         aggregation = AggregationSerializer.deserialize(body_params["aggregation"])
@@ -144,7 +145,7 @@ async def collection_get_form(self, request: web.Request):
         body_params = json.loads(body_params)
 
         ds = await self.customizer.get_datasource()
-        collection = ds.get_collection(body_params["collectionName"])
+        collection = ds.get_collection(request.match_info["collection_name"])
 
         caller = CallerSerializer.deserialize(body_params["caller"])
         action_name = body_params["actionName"]
@@ -163,7 +164,7 @@ async def collection_execute(self, request: web.Request):
         body_params = json.loads(body_params)
 
         ds = await self.customizer.get_datasource()
-        collection = ds.get_collection(body_params["collectionName"])
+        collection = ds.get_collection(request.match_info["collection_name"])
 
         caller = CallerSerializer.deserialize(body_params["caller"])
         action_name = body_params["actionName"]
@@ -181,7 +182,7 @@ async def collection_render_chart(self, request: web.Request):
         body_params = json.loads(body_params)
 
         ds = await self.customizer.get_datasource()
-        collection = ds.get_collection(body_params["collectionName"])
+        collection = ds.get_collection(request.match_info["collection_name"])
 
         caller = CallerSerializer.deserialize(body_params["caller"])
         name = body_params["name"]
@@ -220,17 +221,18 @@ async def render_chart(self, request: web.Request):
         result = await ds.render_chart(caller, name)
         return web.json_response(result)
 
-    async def native_query(self, request: web.Request):
-        body_params = await request.text()
-        body_params = json.loads(body_params)
+    # TODO: speak about; it's currently not implemented in ruby
+    # async def native_query(self, request: web.Request):
+    #     body_params = await request.text()
+    #     body_params = json.loads(body_params)
 
-        ds = await self.customizer.get_datasource()
-        connection_name = body_params["connectionName"]
-        native_query = body_params["nativeQuery"]
-        parameters = body_params["parameters"]
+    #     ds = await self.customizer.get_datasource()
+    #     connection_name = body_params["connectionName"]
+    #     native_query = body_params["nativeQuery"]
+    #     parameters = body_params["parameters"]
 
-        result = await ds.execute_native_query(connection_name, native_query, parameters)
-        return web.json_response(result)
+    #     result = await ds.execute_native_query(connection_name, native_query, parameters)
+    #     return web.json_response(result)
 
     def start(self):
         web.run_app(self.app, host=self.listen_addr, port=int(self.listen_port))

src/datasource_rpc/forestadmin/datasource_rpc/collection.py

@@ -60,7 +60,7 @@ async def list(self, caller: User, filter_: PaginatedFilter, projection: Project
             "projection": ProjectionSerializer.serialize(projection),
             "collectionName": self.name,
         }
-        ret = await self.datasource.requester.list(body=body)
+        ret = await self.datasource.requester.list(self.name, body)
         return [RecordSerializer.deserialize(record, self) for record in ret]
 
     async def create(self, caller: User, data: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
@@ -69,7 +69,7 @@ async def create(self, caller: User, data: List[Dict[str, Any]]) -> List[Dict[st
             "data": [RecordSerializer.serialize(r) for r in data],
             "collectionName": self.name,
         }
-        response = await self.datasource.requester.create(body)
+        response = await self.datasource.requester.create(self.name, body)
         return [RecordSerializer.deserialize(record, self) for record in response]
 
     async def update(self, caller: User, filter_: Optional[Filter], patch: Dict[str, Any]) -> None:
@@ -79,7 +79,7 @@ async def update(self, caller: User, filter_: Optional[Filter], patch: Dict[str,
             "patch": RecordSerializer.serialize(patch),
             "collectionName": self.name,
         }
-        await self.datasource.requester.update(body)
+        await self.datasource.requester.update(self.name, body)
 
     async def delete(self, caller: User, filter_: Filter | None) -> None:
         body = json.dumps(
@@ -89,7 +89,7 @@ async def delete(self, caller: User, filter_: Filter | None) -> None:
                 "collectionName": self.name,
             }
         )
-        await self.datasource.requester.delete(body)
+        await self.datasource.requester.delete(self.name, body)
 
     async def aggregate(
         self, caller: User, filter_: Filter | None, aggregation: Aggregation, limit: int | None = None
@@ -100,7 +100,7 @@ async def aggregate(
             "aggregation": AggregationSerializer.serialize(aggregation),
             "collectionName": self.name,
         }
-        response = await self.datasource.requester.aggregate(body)
+        response = await self.datasource.requester.aggregate(self.name, body)
         return response
 
     async def get_form(
@@ -125,7 +125,7 @@ async def get_form(
             "collectionName": self.name,
             "actionName": name,
         }
-        response = await self.datasource.requester.get_form(body)
+        response = await self.datasource.requester.get_form(self.name, body)
         return ActionFormSerializer.deserialize(response)  # type: ignore
 
     async def execute(
@@ -145,7 +145,7 @@ async def execute(
             "collectionName": self.name,
             "actionName": name,
         }
-        response = await self.datasource.requester.execute(body)
+        response = await self.datasource.requester.execute(self.name, body)
         return ActionResultSerializer.deserialize(response)
 
     async def render_chart(self, caller: User, name: str, record_id: List) -> Chart:
@@ -176,7 +176,7 @@ async def render_chart(self, caller: User, name: str, record_id: List) -> Chart:
             "collectionName": self.name,
             "recordId": ret,
         }
-        return await self.datasource.requester.collection_render_chart(body)
+        return await self.datasource.requester.collection_render_chart(self.name, body)
 
     def get_native_driver(self):
         ForestLogger.log(

src/datasource_rpc/forestadmin/datasource_rpc/datasource.py

@@ -104,14 +104,17 @@ async def sse_callback(self):
         )
         self.thread.start()
 
+    # TODO: speak about; it's currently not implemented in ruby
+    # async def execute_native_query(self, connection_name: str, native_query: str, parameters: Dict[str, str]) -> Any:
+    #     return await self.requester.native_query(
+    #         {
+    #             "connectionName": connection_name,
+    #             "nativeQuery": native_query,
+    #             "parameters": parameters,
+    #         }
+    #     )
     async def execute_native_query(self, connection_name: str, native_query: str, parameters: Dict[str, str]) -> Any:
-        return await self.requester.native_query(
-            {
-                "connectionName": connection_name,
-                "nativeQuery": native_query,
-                "parameters": parameters,
-            }
-        )
+        raise NotImplementedError
 
     async def render_chart(self, caller: User, name: str) -> Chart:
         if name not in self._schema["charts"].keys():

src/datasource_rpc/forestadmin/datasource_rpc/requester.py

@@ -53,25 +53,27 @@ async def schema(self) -> dict:
                 else:
                     raise Exception(f"Failed to get schema: {response.status}")
 
-    async def native_query(self, body):
-        """Execute a native query."""
-        async with aiohttp.ClientSession() as session:
-            async with session.post(
-                f"http://{self.connection_uri}/execute-native-query",
-                json=body,
-                headers={"X-FOREST-HMAC": generate_hmac(self.secret_key.encode("utf-8"), body.encode("utf-8"))},
-            ) as response:
-                if response.status == 200:
-                    return await response.json()
-                else:
-                    raise Exception(f"Failed to execute native query: {response.status}")
+    # TODO: speak about; it's currently not implemented in ruby
+    # async def native_query(self, body):
+    #     """Execute a native query."""
+    #     async with aiohttp.ClientSession() as session:
+    #         async with session.post(
+    #             f"http://{self.connection_uri}/execute-native-query",
+    #             json=body,
+    #             headers={"X-FOREST-HMAC": generate_hmac(self.secret_key.encode("utf-8"), body.encode("utf-8"))},
+    #         ) as response:
+    #             if response.status == 200:
+    #                 return await response.json()
+    #             else:
+    #                 raise Exception(f"Failed to execute native query: {response.status}")
 
     async def datasource_render_chart(self, body):
         """Render a chart."""
         async with aiohttp.ClientSession() as session:
             async with session.post(
-                f"http://{self.connection_uri}/render-chart",
+                f"http://{self.connection_uri}/forest/rpc/datasource-chart",
                 json=body,
+                # TODO: handle HMAC like ruby agent
                 headers={"X-FOREST-HMAC": generate_hmac(self.secret_key.encode("utf-8"), body.encode("utf-8"))},
             ) as response:
                 if response.status == 200:
@@ -81,11 +83,11 @@ async def datasource_render_chart(self, body):
 
     # methods for collection
 
-    async def list(self, body) -> list[dict]:
+    async def list(self, collection_name, body) -> list[dict]:
         """List records in a collection."""
         async with aiohttp.ClientSession() as session:
             async with session.post(
-                f"http://{self.connection_uri}/collection/list",
+                f"http://{self.connection_uri}/forest/rpc/{collection_name}/list",
                 json=body,
                 headers={"X-FOREST-HMAC": generate_hmac(self.secret_key.encode("utf-8"), body.encode("utf-8"))},
             ) as response:
@@ -107,11 +109,11 @@ async def create(self, body) -> List[dict]:
                 else:
                     raise Exception(f"Failed to create query: {response.status}")
 
-    async def update(self, body):
+    async def update(self, collection_name, body):
         """Update records in a collection."""
         async with aiohttp.ClientSession() as session:
             async with session.post(
-                f"http://{self.connection_uri}/collection/update",
+                f"http://{self.connection_uri}/forest/rpc/{collection_name}/update",
                 json=body,
                 headers={"X-FOREST-HMAC": generate_hmac(self.secret_key.encode("utf-8"), body.encode("utf-8"))},
             ) as response:
@@ -120,11 +122,11 @@ async def update(self, body):
                 else:
                     raise Exception(f"Failed to update query: {response.status}")
 
-    async def delete(self, body):
+    async def delete(self, collection_name, body):
         """Delete records in a collection."""
         async with aiohttp.ClientSession() as session:
             async with session.post(
-                f"http://{self.connection_uri}/collection/delete",
+                f"http://{self.connection_uri}/forest/rpc/{collection_name}/delete",
                 json=body,
                 headers={"X-FOREST-HMAC": generate_hmac(self.secret_key.encode("utf-8"), body.encode("utf-8"))},
             ) as response:
@@ -133,11 +135,11 @@ async def delete(self, body):
                 else:
                     raise Exception(f"Failed to delete query: {response.status}")
 
-    async def aggregate(self, body):
+    async def aggregate(self, collection_name, body):
         """Aggregate records in a collection."""
         async with aiohttp.ClientSession() as session:
             async with session.post(
-                f"http://{self.connection_uri}/collection/aggregate",
+                f"http://{self.connection_uri}/forest/rpc/{collection_name}/aggregate",
                 json=body,
                 headers={"X-FOREST-HMAC": generate_hmac(self.secret_key.encode("utf-8"), body.encode("utf-8"))},
             ) as response:
@@ -146,11 +148,11 @@ async def aggregate(self, body):
                 else:
                     raise Exception(f"Failed to aggregate query: {response.status}")
 
-    async def get_form(self, body):
+    async def get_form(self, collection_name, body):
         """Get the form for an action."""
         async with aiohttp.ClientSession() as session:
             async with session.post(
-                f"http://{self.connection_uri}/collection/get-form",
+                f"http://{self.connection_uri}/forest/rpc/{collection_name}/action-form",
                 json=body,
                 headers={"X-FOREST-HMAC": generate_hmac(self.secret_key.encode("utf-8"), body.encode("utf-8"))},
             ) as response:
@@ -159,11 +161,11 @@ async def get_form(self, body):
                 else:
                     raise Exception(f"Failed to aggregate query: {response.status}")
 
-    async def execute(self, body):
+    async def execute(self, collection_name, body):
         """Execute an action."""
         async with aiohttp.ClientSession() as session:
             async with session.post(
-                f"http://{self.connection_uri}/collection/execute",
+                f"http://{self.connection_uri}/forest/rpc/{collection_name}/action-execute",
                 json=body,
                 headers={"X-FOREST-HMAC": generate_hmac(self.secret_key.encode("utf-8"), body.encode("utf-8"))},
             ) as response:
@@ -172,11 +174,11 @@ async def execute(self, body):
                 else:
                     raise Exception(f"Failed to execute query: {response.status}")
 
-    async def collection_render_chart(self, body):
+    async def collection_render_chart(self, collection_name, body):
         """Render a chart."""
         async with aiohttp.ClientSession() as session:
             async with session.post(
-                f"http://{self.connection_uri}/render-chart",
+                f"http://{self.connection_uri}/forest/rpc/{collection_name}/chart",
                 json=body,
                 headers={"X-FOREST-HMAC": generate_hmac(self.secret_key.encode("utf-8"), body.encode("utf-8"))},
             ) as response: