apexdevkit 1.5.23__tar.gz → 1.5.25__tar.gz

{apexdevkit-1.5.23 → apexdevkit-1.5.25}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: apexdevkit
-Version: 1.5.23
+Version: 1.5.25
 Summary: Apex Development Tools for python.
 Author: Apex Dev
 Author-email: dev@apex.ge

apexdevkit-1.5.25/apexdevkit/fastapi/resource.py

@@ -0,0 +1,129 @@
+from dataclasses import dataclass
+from functools import cached_property
+from typing import Any, Callable
+
+from starlette.responses import JSONResponse
+
+from apexdevkit.error import DoesNotExistError, ExistsError, ForbiddenError
+from apexdevkit.fastapi.response import RestfulResponse
+from apexdevkit.testing import RestfulName
+
+_Response = JSONResponse | dict[str, Any]
+
+
+@dataclass
+class RestfulResource:
+    name: RestfulName
+
+    @cached_property
+    def response(self) -> RestfulResponse:
+        return RestfulResponse(name=self.name)
+
+    def create_one(self, Service, Item) -> Callable[..., _Response]:  # type: ignore
+        def endpoint(service: Service, item: Item) -> _Response:
+            try:
+                item = service.create_one(item)
+            except ExistsError as e:
+                return JSONResponse(self.response.exists(e), 409)
+            except ForbiddenError as e:
+                return JSONResponse(self.response.forbidden(e), 403)
+
+            return self.response.created_one(item)
+
+        return endpoint
+
+    def create_many(self, Service, Collection) -> Callable[..., _Response]:  # type: ignore
+        def endpoint(service: Service, items: Collection) -> _Response:
+            try:
+                return self.response.created_many(service.create_many(items))
+            except ExistsError as e:
+                return JSONResponse(self.response.exists(e), 409)
+            except ForbiddenError as e:
+                return JSONResponse(self.response.forbidden(e), 403)
+
+        return endpoint
+
+    def read_one(self, Service, ItemId) -> Callable[..., _Response]:  # type: ignore
+        def endpoint(service: Service, item_id: ItemId) -> _Response:
+            try:
+                return self.response.found_one(service.read_one(item_id))
+            except DoesNotExistError as e:
+                return JSONResponse(self.response.not_found(e), 404)
+            except ForbiddenError as e:
+                return JSONResponse(self.response.forbidden(e), 403)
+
+        return endpoint
+
+    def read_all(self, Service) -> Callable[..., _Response]:  # type: ignore
+        def endpoint(service: Service) -> _Response:
+            try:
+                return self.response.found_many(list(service.read_all()))
+            except ForbiddenError as e:
+                return JSONResponse(self.response.forbidden(e), 403)
+
+        return endpoint
+
+    def update_one(self, Service, ItemId, Updates) -> Callable[..., _Response]:  # type: ignore
+        def endpoint(service: Service, item_id: ItemId, updates: Updates) -> _Response:
+            try:
+                service.update_one(item_id, **updates)
+            except DoesNotExistError as e:
+                return JSONResponse(self.response.not_found(e), 404)
+            except ForbiddenError as e:
+                return JSONResponse(self.response.forbidden(e), 403)
+
+            return self.response.ok()
+
+        return endpoint
+
+    def update_many(self, Service, Collection) -> Callable[..., _Response]:  # type: ignore
+        def endpoint(service: Service, items: Collection) -> _Response:
+            try:
+                service.update_many(items)
+            except DoesNotExistError as e:
+                return JSONResponse(self.response.not_found(e), 404)
+            except ForbiddenError as e:
+                return JSONResponse(self.response.forbidden(e), 403)
+
+            return self.response.ok()
+
+        return endpoint
+
+    def replace_one(self, Service, Item) -> Callable[..., _Response]:  # type: ignore
+        def endpoint(service: Service, item: Item) -> _Response:
+            try:
+                service.replace_one(item)
+            except DoesNotExistError as e:
+                return JSONResponse(self.response.not_found(e), 404)
+            except ForbiddenError as e:
+                return JSONResponse(self.response.forbidden(e), 403)
+
+            return self.response.ok()
+
+        return endpoint
+
+    def replace_many(self, Service, Collection) -> Callable[..., _Response]:  # type: ignore
+        def endpoint(service: Service, items: Collection) -> _Response:
+            try:
+                service.replace_many(items)
+            except DoesNotExistError as e:
+                return JSONResponse(self.response.not_found(e), 404)
+            except ForbiddenError as e:
+                return JSONResponse(self.response.forbidden(e), 403)
+
+            return self.response.ok()
+
+        return endpoint
+
+    def delete_one(self, Service, ItemId) -> Callable[..., _Response]:  # type: ignore
+        def endpoint(service: Service, item_id: ItemId) -> _Response:
+            try:
+                service.delete_one(item_id)
+            except DoesNotExistError as e:
+                return JSONResponse(self.response.not_found(e), 404)
+            except ForbiddenError as e:
+                return JSONResponse(self.response.forbidden(e), 403)
+
+            return self.response.ok()
+
+        return endpoint

{apexdevkit-1.5.23 → apexdevkit-1.5.25}/apexdevkit/fastapi/router.py

@@ -1,12 +1,14 @@
 from dataclasses import dataclass, field
 from functools import cached_property
-from typing import Annotated, Any, Callable, Self, TypeVar
+from typing import Annotated, Any, Callable, Self, Type, TypeVar
 
-from fastapi import APIRouter, Depends, Path
+from fastapi import APIRouter, Depends, HTTPException, Path
 from fastapi.responses import JSONResponse
 
+from apexdevkit.error import DoesNotExistError
 from apexdevkit.fastapi.builder import RestfulServiceBuilder
-from apexdevkit.fastapi.resource import RestfulRootResource, RestfulSubResource
+from apexdevkit.fastapi.resource import RestfulResource
+from apexdevkit.fastapi.response import RestfulResponse
 from apexdevkit.fastapi.schema import RestfulSchema, SchemaFields
 from apexdevkit.fastapi.service import RawCollection, RawItem, RestfulService
 from apexdevkit.testing import RestfulName
@@ -50,16 +52,17 @@ class RestfulRouter:
         return RestfulSchema(name=self.name, fields=self.fields)
 
     @property
-    def resource(self) -> RestfulRootResource | RestfulSubResource:
-        if not self.parent:
-            return RestfulRootResource(self.name, self.infra)
-
-        return RestfulSubResource(self.name, self.infra, RestfulName(self.parent))
+    def resource(self) -> RestfulResource:
+        return RestfulResource(self.name)
 
     @property
     def id_alias(self) -> str:
         return self.name.singular + "_id"
 
+    @property
+    def parent_id_alias(self) -> str:
+        return self.parent + "_id"
+
     @property
     def item_path(self) -> str:
         return "/{" + self.id_alias + "}"
@@ -92,10 +95,7 @@ class RestfulRouter:
         self.router.add_api_route(
             "",
             self.resource.create_one(
-                User=Annotated[
-                    Any,
-                    Depends(extract_user),
-                ],
+                Service=self._service(extract_user),
                 Item=Annotated[
                     RawItem,
                     Depends(self.schema.for_create_one()),
@@ -119,10 +119,7 @@ class RestfulRouter:
         self.router.add_api_route(
             "/batch",
             self.resource.create_many(
-                User=Annotated[
-                    Any,
-                    Depends(extract_user),
-                ],
+                Service=self._service(extract_user),
                 Collection=Annotated[
                     RawCollection,
                     Depends(self.schema.for_create_many()),
@@ -146,10 +143,7 @@ class RestfulRouter:
         self.router.add_api_route(
             self.item_path,
             self.resource.read_one(
-                User=Annotated[
-                    Any,
-                    Depends(extract_user),
-                ],
+                Service=self._service(extract_user),
                 ItemId=Annotated[
                     str,
                     Path(alias=self.id_alias),
@@ -173,10 +167,7 @@ class RestfulRouter:
         self.router.add_api_route(
             "",
             self.resource.read_all(
-                User=Annotated[
-                    Any,
-                    Depends(extract_user),
-                ],
+                Service=self._service(extract_user),
             ),
             methods=["GET"],
             status_code=200,
@@ -196,10 +187,7 @@ class RestfulRouter:
         self.router.add_api_route(
             self.item_path,
             self.resource.update_one(
-                User=Annotated[
-                    Any,
-                    Depends(extract_user),
-                ],
+                Service=self._service(extract_user),
                 ItemId=Annotated[
                     str,
                     Path(alias=self.id_alias),
@@ -227,10 +215,7 @@ class RestfulRouter:
         self.router.add_api_route(
             "",
             self.resource.update_many(
-                User=Annotated[
-                    Any,
-                    Depends(extract_user),
-                ],
+                Service=self._service(extract_user),
                 Collection=Annotated[
                     RawCollection,
                     Depends(self.schema.for_update_many()),
@@ -254,10 +239,7 @@ class RestfulRouter:
         self.router.add_api_route(
             "",
             self.resource.replace_one(
-                User=Annotated[
-                    Any,
-                    Depends(extract_user),
-                ],
+                Service=self._service(extract_user),
                 Item=Annotated[
                     RawItem,
                     Depends(self.schema.for_replace_one()),
@@ -281,10 +263,7 @@ class RestfulRouter:
         self.router.add_api_route(
             "/batch",
             self.resource.replace_many(
-                User=Annotated[
-                    Any,
-                    Depends(extract_user),
-                ],
+                Service=self._service(extract_user),
                 Collection=Annotated[
                     RawCollection,
                     Depends(self.schema.for_replace_many()),
@@ -308,10 +287,7 @@ class RestfulRouter:
         self.router.add_api_route(
             self.item_path,
             self.resource.delete_one(
-                User=Annotated[
-                    Any,
-                    Depends(extract_user),
-                ],
+                Service=self._service(extract_user),
                 ItemId=Annotated[
                     str,
                     Path(alias=self.id_alias),
@@ -346,3 +322,32 @@ class RestfulRouter:
 
     def build(self) -> APIRouter:
         return self.router
+
+    def _service(
+        self, extract_user: Callable[..., Any] = no_user
+    ) -> Type[RestfulService]:
+        User = Annotated[Any, Depends(extract_user)]
+        ParentId = Annotated[str, Path(alias=self.parent_id_alias)]
+
+        def srv_child(user: User, parent_id: ParentId) -> RestfulService:
+            try:
+                return self.infra.with_user(user).with_parent(parent_id).build()
+            except DoesNotExistError as e:
+                raise HTTPException(
+                    status_code=404,
+                    detail=RestfulResponse(RestfulName(self.parent)).not_found(e),
+                )
+
+        def srv_root(user: User) -> RestfulService:
+            try:
+                return self.infra.with_user(user).build()
+            except DoesNotExistError as e:
+                raise HTTPException(
+                    status_code=404,
+                    detail=RestfulResponse(RestfulName(self.parent)).not_found(e),
+                )
+
+        if self.parent:
+            return Annotated[RestfulService, Depends(srv_child)]  # type: ignore
+        else:
+            return Annotated[RestfulService, Depends(srv_root)]  # type: ignore

{apexdevkit-1.5.23 → apexdevkit-1.5.25}/apexdevkit/http/httpx.py

@@ -4,34 +4,37 @@ from dataclasses import dataclass, field
 from typing import Any, Iterator, Mapping, Self
 
 import httpx
+from httpx import Client
 
 from apexdevkit.http.fluent import HttpMethod, HttpResponse
 from apexdevkit.http.json import JsonDict
-from apexdevkit.http.url import HttpUrl
+
+
+def default_config() -> HttpxConfig:
+    return HttpxConfig()
 
 
 @dataclass(frozen=True)
 class Httpx:
-    url: HttpUrl
-    config: HttpxConfig
+    client: httpx.Client
+
+    config: HttpxConfig = field(default_factory=default_config)
 
     @classmethod
     def create_for(cls, url: str) -> Self:
-        return cls(HttpUrl(url), HttpxConfig())
+        return cls(Client(base_url=url), HttpxConfig())
 
     def with_header(self, key: str, value: str) -> Httpx:
-        return Httpx(self.url, self.config.with_header(key, value))
+        return Httpx(self.client, self.config.with_header(key, value))
 
     def with_param(self, key: str, value: str) -> Httpx:
-        return Httpx(self.url, self.config.with_param(key, value))
+        return Httpx(self.client, self.config.with_param(key, value))
 
     def with_json(self, value: JsonDict) -> Httpx:
-        return Httpx(self.url, self.config.with_json(value))
+        return Httpx(self.client, self.config.with_json(value))
 
     def request(self, method: HttpMethod, endpoint: str) -> HttpResponse:
-        return _HttpxResponse(
-            httpx.request(method.name, self.url + endpoint, **self.config)
-        )
+        return _HttpxResponse(self.client.request(method.name, endpoint, **self.config))
 
 
 @dataclass

{apexdevkit-1.5.23 → apexdevkit-1.5.25}/apexdevkit/testing/rest.py

@@ -5,67 +5,76 @@ from dataclasses import dataclass, field
 from functools import cached_property
 from typing import Any, Iterable, Self
 
-import httpx
 from fastapi.testclient import TestClient
 
-from apexdevkit.http import HttpUrl, JsonDict
+from apexdevkit.http import Http, HttpUrl, JsonDict
+from apexdevkit.http.fluent import HttpMethod, HttpResponse
+from apexdevkit.http.httpx import Httpx
 
 
 @dataclass
 class RestResource:
-    http: TestClient
+    http: TestClient | Http
     name: RestfulName
 
+    def __post_init__(self) -> None:
+        if isinstance(self.http, TestClient):
+            self.http = Httpx(self.http)
+
+    @property
+    def _http(self) -> Http:
+        assert not isinstance(self.http, TestClient)
+
+        return self.http
+
     def create_one(self) -> CreateOne:
-        return CreateOne(self.name, self.http)
+        return CreateOne(self.name, self._http)
 
     def create_many(self) -> CreateMany:
-        return CreateMany(self.name, self.http)
+        return CreateMany(self.name, self._http)
 
     def read_one(self) -> ReadOne:
-        return ReadOne(self.name, self.http)
+        return ReadOne(self.name, self._http)
 
     def read_all(self) -> ReadAll:
-        return ReadAll(self.name, self.http)
+        return ReadAll(self.name, self._http)
 
     def update_one(self) -> UpdateOne:
-        return UpdateOne(self.name, self.http)
+        return UpdateOne(self.name, self._http)
 
     def update_many(self) -> UpdateMany:
-        return UpdateMany(self.name, self.http)
+        return UpdateMany(self.name, self._http)
 
     def replace_one(self) -> ReplaceOne:
-        return ReplaceOne(self.name, self.http)
+        return ReplaceOne(self.name, self._http)
 
     def replace_many(self) -> ReplaceMany:
-        return ReplaceMany(self.name, self.http)
+        return ReplaceMany(self.name, self._http)
 
     def delete_one(self) -> DeleteOne:
-        return DeleteOne(self.name, self.http)
+        return DeleteOne(self.name, self._http)
 
 
 @dataclass
 class RestCollection(RestResource):
     def sub_resource(self, name: str) -> RestItem:
-        return RestItem(
-            TestClient(
-                self.http.app,
-                base_url=HttpUrl(str(self.http.base_url)) + self.name.plural,
-            ),
-            RestfulName(name),
-        )
+        assert isinstance(self.http, Httpx), "sub resource only works with Httpx"
+
+        client = self.http.client
+        client.base_url = client.base_url.join(self.name.plural)
+
+        return RestItem(self.http, RestfulName(name))
 
 
 @dataclass
 class RestItem(RestResource):
     def sub_resource(self, name: str) -> RestItem:
-        return RestItem(
-            TestClient(
-                self.http.app,
-                base_url=HttpUrl(str(self.http.base_url)) + self.name.singular,
-            ),
-            RestfulName(name),
-        )
+        assert isinstance(self.http, Httpx), "sub resource only works with Httpx"
+
+        client = self.http.client
+        client.base_url = client.base_url.join(self.name.plural)
+
+        return RestItem(self.http, RestfulName(name))
 
 
 @dataclass
@@ -103,11 +112,11 @@ def as_plural(singular: str) -> str:
 @dataclass
 class RestRequest:
     resource: RestfulName
-    http: TestClient
+    http: Http
 
     @abstractmethod
     @cached_property
-    def response(self) -> httpx.Response:  # pragma: no cover
+    def response(self) -> HttpResponse:  # pragma: no cover
         pass
 
     def unpack(self) -> JsonDict:
@@ -122,7 +131,7 @@ class RestRequest:
         return RestResponse(
             resource=self.resource,
             json=JsonDict(self.response.json()),
-            http_code=self.response.status_code,
+            http_code=self.response.code(),
         )
 
 
@@ -136,8 +145,11 @@ class CreateOne(RestRequest):
         return self
 
     @cached_property
-    def response(self) -> httpx.Response:
-        return self.http.post(self.resource + "", json=dict(self.data))
+    def response(self) -> HttpResponse:
+        return self.http.with_json(self.data).request(
+            method=HttpMethod.post,
+            endpoint=self.resource + "",
+        )
 
 
 @dataclass
@@ -145,8 +157,11 @@ class ReadOne(RestRequest):
     item_id: str = field(init=False)
 
     @cached_property
-    def response(self) -> httpx.Response:
-        return self.http.get(self.resource + str(self.item_id))
+    def response(self) -> HttpResponse:
+        return self.http.request(
+            method=HttpMethod.get,
+            endpoint=self.resource + str(self.item_id),
+        )
 
     def with_id(self, value: Any) -> Self:
         self.item_id = str(value)
@@ -159,8 +174,12 @@ class ReadAll(RestRequest):
     params: dict[str, Any] = field(init=False, default_factory=dict)
 
     @cached_property
-    def response(self) -> httpx.Response:
-        return self.http.get(self.resource + "", params=self.params)
+    def response(self) -> HttpResponse:
+        http = self.http
+        for param, value in self.params.items():
+            http = http.with_param(param, value)
+
+        return http.request(method=HttpMethod.get, endpoint=self.resource + "")
 
     def with_params(self, **kwargs: Any) -> Self:
         self.params = {**kwargs}
@@ -174,8 +193,11 @@ class UpdateOne(RestRequest):
     data: JsonDict = field(init=False)
 
     @cached_property
-    def response(self) -> httpx.Response:
-        return self.http.patch(self.resource + str(self.item_id), json=dict(self.data))
+    def response(self) -> HttpResponse:
+        return self.http.with_json(self.data).request(
+            method=HttpMethod.patch,
+            endpoint=self.resource + str(self.item_id),
+        )
 
     def with_id(self, value: Any) -> Self:
         self.item_id = str(value)
@@ -193,8 +215,11 @@ class ReplaceOne(RestRequest):
     data: JsonDict = field(init=False)
 
     @cached_property
-    def response(self) -> httpx.Response:
-        return self.http.put(self.resource + "", json=dict(self.data))
+    def response(self) -> HttpResponse:
+        return self.http.with_json(self.data).request(
+            method=HttpMethod.put,
+            endpoint=self.resource + "",
+        )
 
     def from_data(self, value: JsonDict) -> Self:
         self.data = value
@@ -207,10 +232,12 @@ class CreateMany(RestRequest):
     data: list[JsonDict] = field(default_factory=list)
 
     @cached_property
-    def response(self) -> httpx.Response:
-        return self.http.post(
-            self.resource + "batch",
-            json={self.resource.plural: [dict(data) for data in self.data]},
+    def response(self) -> HttpResponse:
+        json = JsonDict({self.resource.plural: [dict(data) for data in self.data]})
+
+        return self.http.with_json(json).request(
+            method=HttpMethod.post,
+            endpoint=self.resource + "batch",
         )
 
     def from_data(self, value: JsonDict) -> Self:
@@ -227,10 +254,12 @@ class UpdateMany(RestRequest):
     data: list[JsonDict] = field(default_factory=list)
 
     @cached_property
-    def response(self) -> httpx.Response:
-        return self.http.patch(
-            self.resource + "",
-            json={self.resource.plural: [dict(data) for data in self.data]},
+    def response(self) -> HttpResponse:
+        json = JsonDict({self.resource.plural: [dict(data) for data in self.data]})
+
+        return self.http.with_json(json).request(
+            method=HttpMethod.patch,
+            endpoint=self.resource + "",
         )
 
     def from_data(self, value: JsonDict) -> Self:
@@ -247,10 +276,12 @@ class ReplaceMany(RestRequest):
     data: list[JsonDict] = field(default_factory=list)
 
     @cached_property
-    def response(self) -> httpx.Response:
-        return self.http.put(
-            self.resource + "batch",
-            json={self.resource.plural: [dict(data) for data in self.data]},
+    def response(self) -> HttpResponse:
+        json = JsonDict({self.resource.plural: [dict(data) for data in self.data]})
+
+        return self.http.with_json(json).request(
+            method=HttpMethod.put,
+            endpoint=self.resource + "batch",
         )
 
     def from_data(self, value: JsonDict) -> Self:
@@ -267,8 +298,11 @@ class DeleteOne(RestRequest):
     item_id: str = field(init=False)
 
     @cached_property
-    def response(self) -> httpx.Response:
-        return self.http.delete(self.resource + str(self.item_id))
+    def response(self) -> HttpResponse:
+        return self.http.request(
+            method=HttpMethod.delete,
+            endpoint=self.resource + str(self.item_id),
+        )
 
     def with_id(self, value: Any) -> Self:
         self.item_id = str(value)

{apexdevkit-1.5.23 → apexdevkit-1.5.25}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "apexdevkit"
-version = "1.5.23"
+version = "1.5.25"
 description = "Apex Development Tools for python."
 authors = ["Apex Dev <dev@apex.ge>"]
 readme = "README.md"

apexdevkit-1.5.23/apexdevkit/fastapi/resource.py

@@ -1,342 +0,0 @@
-from dataclasses import dataclass
-from functools import cached_property
-from typing import Annotated, Any, Callable
-
-from fastapi import Path
-from starlette.responses import JSONResponse
-
-from apexdevkit.error import DoesNotExistError, ExistsError, ForbiddenError
-from apexdevkit.fastapi.builder import RestfulServiceBuilder
-from apexdevkit.fastapi.response import RestfulResponse
-from apexdevkit.testing import RestfulName
-
-_Response = JSONResponse | dict[str, Any]
-
-
-@dataclass
-class RestfulSubResource:
-    name: RestfulName
-    infra: RestfulServiceBuilder
-    parent: RestfulName
-
-    @property
-    def parent_id_alias(self) -> str:
-        return self.parent.singular + "_id"
-
-    @cached_property
-    def response(self) -> RestfulResponse:
-        return RestfulResponse(name=self.name)
-
-    def create_one(self, User, Item) -> Callable[..., _Response]:  # type: ignore
-        ParentId = Annotated[str, Path(alias=self.parent_id_alias)]
-
-        def endpoint(user: User, parent_id: ParentId, item: Item) -> _Response:
-            try:
-                service = self.infra.with_user(user).with_parent(parent_id).build()
-            except DoesNotExistError as e:
-                return JSONResponse(RestfulResponse(self.parent).not_found(e), 404)
-
-            try:
-                item = service.create_one(item)
-            except ExistsError as e:
-                return JSONResponse(self.response.exists(e), 409)
-            except ForbiddenError as e:
-                return JSONResponse(self.response.forbidden(e), 403)
-
-            return self.response.created_one(item)
-
-        return endpoint
-
-    def create_many(self, User, Collection) -> Callable[..., _Response]:  # type: ignore
-        ParentId = Annotated[str, Path(alias=self.parent_id_alias)]
-
-        def endpoint(user: User, parent_id: ParentId, items: Collection) -> _Response:
-            try:
-                service = self.infra.with_user(user).with_parent(parent_id).build()
-            except DoesNotExistError as e:
-                return JSONResponse(RestfulResponse(self.parent).not_found(e), 404)
-
-            try:
-                return self.response.created_many(service.create_many(items))
-            except ExistsError as e:
-                return JSONResponse(self.response.exists(e), 409)
-            except ForbiddenError as e:
-                return JSONResponse(self.response.forbidden(e), 403)
-
-        return endpoint
-
-    def read_one(self, User, ItemId) -> Callable[..., _Response]:  # type: ignore
-        ParentId = Annotated[str, Path(alias=self.parent_id_alias)]
-
-        def endpoint(user: User, parent_id: ParentId, item_id: ItemId) -> _Response:
-            try:
-                service = self.infra.with_user(user).with_parent(parent_id).build()
-            except DoesNotExistError as e:
-                return JSONResponse(RestfulResponse(self.parent).not_found(e), 404)
-
-            try:
-                return self.response.found_one(service.read_one(item_id))
-            except DoesNotExistError as e:
-                return JSONResponse(self.response.not_found(e), 404)
-            except ForbiddenError as e:
-                return JSONResponse(self.response.forbidden(e), 403)
-
-        return endpoint
-
-    def read_all(self, User) -> Callable[..., _Response]:  # type: ignore
-        ParentId = Annotated[str, Path(alias=self.parent_id_alias)]
-
-        def endpoint(user: User, parent_id: ParentId) -> _Response:
-            try:
-                service = self.infra.with_user(user).with_parent(parent_id).build()
-            except DoesNotExistError as e:
-                return JSONResponse(RestfulResponse(self.parent).not_found(e), 404)
-
-            try:
-                return self.response.found_many(list(service.read_all()))
-            except ForbiddenError as e:
-                return JSONResponse(self.response.forbidden(e), 403)
-
-        return endpoint
-
-    def update_one(self, User, ItemId, Updates) -> Callable[..., _Response]:  # type: ignore
-        ParentId = Annotated[str, Path(alias=self.parent_id_alias)]
-
-        def endpoint(
-            user: User,
-            parent_id: ParentId,
-            item_id: ItemId,
-            updates: Updates,
-        ) -> _Response:
-            try:
-                service = self.infra.with_user(user).with_parent(parent_id).build()
-            except DoesNotExistError as e:
-                return JSONResponse(RestfulResponse(self.parent).not_found(e), 404)
-
-            try:
-                service.update_one(item_id, **updates)
-            except DoesNotExistError as e:
-                return JSONResponse(self.response.not_found(e), 404)
-            except ForbiddenError as e:
-                return JSONResponse(self.response.forbidden(e), 403)
-
-            return self.response.ok()
-
-        return endpoint
-
-    def update_many(self, User, Collection) -> Callable[..., _Response]:  # type: ignore
-        ParentId = Annotated[str, Path(alias=self.parent_id_alias)]
-
-        def endpoint(user: User, parent_id: ParentId, items: Collection) -> _Response:
-            try:
-                service = self.infra.with_user(user).with_parent(parent_id).build()
-            except DoesNotExistError as e:
-                return JSONResponse(RestfulResponse(self.parent).not_found(e), 404)
-
-            try:
-                service.update_many(items)
-            except DoesNotExistError as e:
-                return JSONResponse(self.response.not_found(e), 404)
-            except ForbiddenError as e:
-                return JSONResponse(self.response.forbidden(e), 403)
-
-            return self.response.ok()
-
-        return endpoint
-
-    def replace_one(self, User, Item) -> Callable[..., _Response]:  # type: ignore
-        ParentId = Annotated[str, Path(alias=self.parent_id_alias)]
-
-        def endpoint(user: User, parent_id: ParentId, item: Item) -> _Response:
-            try:
-                service = self.infra.with_user(user).with_parent(parent_id).build()
-            except DoesNotExistError as e:
-                return JSONResponse(RestfulResponse(self.parent).not_found(e), 404)
-
-            try:
-                service.replace_one(item)
-            except DoesNotExistError as e:
-                return JSONResponse(self.response.not_found(e), 404)
-            except ForbiddenError as e:
-                return JSONResponse(self.response.forbidden(e), 403)
-
-            return self.response.ok()
-
-        return endpoint
-
-    def replace_many(self, User, Collection) -> Callable[..., _Response]:  # type: ignore
-        ParentId = Annotated[str, Path(alias=self.parent_id_alias)]
-
-        def endpoint(user: User, parent_id: ParentId, items: Collection) -> _Response:
-            try:
-                service = self.infra.with_user(user).with_parent(parent_id).build()
-            except DoesNotExistError as e:
-                return JSONResponse(RestfulResponse(self.parent).not_found(e), 404)
-
-            try:
-                service.replace_many(items)
-            except DoesNotExistError as e:
-                return JSONResponse(self.response.not_found(e), 404)
-            except ForbiddenError as e:
-                return JSONResponse(self.response.forbidden(e), 403)
-
-            return self.response.ok()
-
-        return endpoint
-
-    def delete_one(self, User, ItemId) -> Callable[..., _Response]:  # type: ignore
-        ParentId = Annotated[str, Path(alias=self.parent_id_alias)]
-
-        def endpoint(user: User, parent_id: ParentId, item_id: ItemId) -> _Response:
-            try:
-                service = self.infra.with_user(user).with_parent(parent_id).build()
-            except DoesNotExistError as e:
-                return JSONResponse(RestfulResponse(self.parent).not_found(e), 404)
-
-            try:
-                service.delete_one(item_id)
-            except DoesNotExistError as e:
-                return JSONResponse(self.response.not_found(e), 404)
-            except ForbiddenError as e:
-                return JSONResponse(self.response.forbidden(e), 403)
-
-            return self.response.ok()
-
-        return endpoint
-
-
-@dataclass
-class RestfulRootResource:
-    name: RestfulName
-    infra: RestfulServiceBuilder
-
-    @cached_property
-    def response(self) -> RestfulResponse:
-        return RestfulResponse(name=self.name)
-
-    def create_one(self, User, Item) -> Callable[..., _Response]:  # type: ignore
-        def endpoint(user: User, item: Item) -> _Response:
-            service = self.infra.with_user(user).build()
-
-            try:
-                item = service.create_one(item)
-            except ExistsError as e:
-                return JSONResponse(self.response.exists(e), 409)
-            except ForbiddenError as e:
-                return JSONResponse(self.response.forbidden(e), 403)
-
-            return self.response.created_one(item)
-
-        return endpoint
-
-    def create_many(self, User, Collection) -> Callable[..., _Response]:  # type: ignore
-        def endpoint(user: User, items: Collection) -> _Response:
-            service = self.infra.with_user(user).build()
-
-            try:
-                return self.response.created_many(service.create_many(items))
-            except ExistsError as e:
-                return JSONResponse(self.response.exists(e), 409)
-            except ForbiddenError as e:
-                return JSONResponse(self.response.forbidden(e), 403)
-
-        return endpoint
-
-    def read_one(self, User, ItemId) -> Callable[..., _Response]:  # type: ignore
-        def endpoint(user: User, item_id: ItemId) -> _Response:
-            service = self.infra.with_user(user).build()
-
-            try:
-                return self.response.found_one(service.read_one(item_id))
-            except DoesNotExistError as e:
-                return JSONResponse(self.response.not_found(e), 404)
-            except ForbiddenError as e:
-                return JSONResponse(self.response.forbidden(e), 403)
-
-        return endpoint
-
-    def read_all(self, User) -> Callable[..., _Response]:  # type: ignore
-        def endpoint(user: User) -> _Response:
-            service = self.infra.with_user(user).build()
-
-            try:
-                return self.response.found_many(list(service.read_all()))
-            except ForbiddenError as e:
-                return JSONResponse(self.response.forbidden(e), 403)
-
-        return endpoint
-
-    def update_one(self, User, ItemId, Updates) -> Callable[..., _Response]:  # type: ignore
-        def endpoint(user: User, item_id: ItemId, updates: Updates) -> _Response:
-            service = self.infra.with_user(user).build()
-
-            try:
-                service.update_one(item_id, **updates)
-            except DoesNotExistError as e:
-                return JSONResponse(self.response.not_found(e), 404)
-            except ForbiddenError as e:
-                return JSONResponse(self.response.forbidden(e), 403)
-
-            return self.response.ok()
-
-        return endpoint
-
-    def update_many(self, User, Collection) -> Callable[..., _Response]:  # type: ignore
-        def endpoint(user: User, items: Collection) -> _Response:
-            service = self.infra.with_user(user).build()
-
-            try:
-                service.update_many(items)
-            except DoesNotExistError as e:
-                return JSONResponse(self.response.not_found(e), 404)
-            except ForbiddenError as e:
-                return JSONResponse(self.response.forbidden(e), 403)
-
-            return self.response.ok()
-
-        return endpoint
-
-    def replace_one(self, User, Item) -> Callable[..., _Response]:  # type: ignore
-        def endpoint(user: User, item: Item) -> _Response:
-            service = self.infra.with_user(user).build()
-
-            try:
-                service.replace_one(item)
-            except DoesNotExistError as e:
-                return JSONResponse(self.response.not_found(e), 404)
-            except ForbiddenError as e:
-                return JSONResponse(self.response.forbidden(e), 403)
-
-            return self.response.ok()
-
-        return endpoint
-
-    def replace_many(self, User, Collection) -> Callable[..., _Response]:  # type: ignore
-        def endpoint(user: User, items: Collection) -> _Response:
-            service = self.infra.with_user(user).build()
-
-            try:
-                service.replace_many(items)
-            except DoesNotExistError as e:
-                return JSONResponse(self.response.not_found(e), 404)
-            except ForbiddenError as e:
-                return JSONResponse(self.response.forbidden(e), 403)
-
-            return self.response.ok()
-
-        return endpoint
-
-    def delete_one(self, User, ItemId) -> Callable[..., _Response]:  # type: ignore
-        def endpoint(user: User, item_id: ItemId) -> _Response:
-            service = self.infra.with_user(user).build()
-
-            try:
-                service.delete_one(item_id)
-            except DoesNotExistError as e:
-                return JSONResponse(self.response.not_found(e), 404)
-            except ForbiddenError as e:
-                return JSONResponse(self.response.forbidden(e), 403)
-
-            return self.response.ok()
-
-        return endpoint