apexdevkit 2.1.4__tar.gz → 2.3.1__tar.gz

{apexdevkit-2.1.4 → apexdevkit-2.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: apexdevkit
-Version: 2.1.4
+Version: 2.3.1
 Summary: Apex Development Tools for python.
 License-File: LICENSE
 Author: Apex Dev

apexdevkit-2.3.1/apexdevkit/fastapi/__init__.py

@@ -0,0 +1,15 @@
+from apexdevkit.fastapi.builder import FastApiBuilder
+from apexdevkit.fastapi.router import RestfulRouter
+from apexdevkit.fastapi.service import (
+    RestfulRepository,
+    RestfulResource,
+    RestfulService,
+)
+
+__all__ = [
+    "FastApiBuilder",
+    "RestfulRepository",
+    "RestfulResource",
+    "RestfulRouter",
+    "RestfulService",
+]

{apexdevkit-2.1.4 → apexdevkit-2.3.1}/apexdevkit/fastapi/builder.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-from abc import ABC, abstractmethod
 from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Any, Protocol, Self
 
@@ -10,13 +9,10 @@ from fastapi.responses import JSONResponse
 
 from apexdevkit.annotation import deprecated
 from apexdevkit.error import ApiError
-from apexdevkit.fastapi.dependable import DependableBuilder
 
 if TYPE_CHECKING:
     from collections.abc import Mapping, MutableSet
 
-    from apexdevkit.fastapi.service import RestfulService
-
 
 @dataclass
 class FastApiBuilder:
@@ -57,7 +53,7 @@ class FastApiBuilder:
         for key, value in values.items():
             self.app.include_router(
                 value,
-                prefix=_Endpoint(key).normilized(),
+                prefix=_Endpoint(key).normalized(),
                 tags=value.tags or [key.title()],
             )
 
@@ -65,7 +61,7 @@ class FastApiBuilder:
 
     def with_mounted(self, **apps: FastAPI) -> Self:
         for path, app in apps.items():
-            self.app.mount(_Endpoint(path).normilized(), app)
+            self.app.mount(_Endpoint(path).normalized(), app)
 
         return self
 
@@ -125,43 +121,12 @@ class CORSApplicator:
         )
 
 
-@dataclass
-class RestfulServiceBuilder(ABC):
-    parent_id: str = field(init=False)
-    user: Any = field(init=False)
-
-    def as_dependable(self) -> DependableBuilder:
-        return DependableBuilder.from_builder(self)
-
-    def with_user(self, user: Any) -> RestfulServiceBuilder:
-        self.user = user
-
-        return self
-
-    def with_parent(self, identity: str) -> RestfulServiceBuilder:
-        self.parent_id = identity
-
-        return self
-
-    @abstractmethod
-    def build(self) -> RestfulService:  # pragma: no cover
-        pass
-
-
-@dataclass
-class PreBuilt(RestfulServiceBuilder):  # pragma: no cover
-    service: RestfulService
-
-    def build(self) -> RestfulService:
-        return self.service
-
-
 @dataclass(frozen=True)
 class _Endpoint:
     raw: str
 
-    def normilized(self) -> str:
+    def normalized(self) -> str:
         return f"/{self.raw.replace('_', '-')}"
 
     def __str__(self) -> str:  # pragma: no cover
-        return self.normilized()
+        return self.normalized()

{apexdevkit-2.1.4 → apexdevkit-2.3.1}/apexdevkit/fastapi/dependable.py

@@ -3,19 +3,11 @@ from dataclasses import dataclass
 from typing import Annotated, Any, Protocol
 
 from fastapi import Depends, Path
-from fastapi.requests import Request
 
 from apexdevkit.error import ApiError, DoesNotExistError, ForbiddenError
 from apexdevkit.fastapi.name import RestfulName
 from apexdevkit.fastapi.response import RestfulResponse
-from apexdevkit.fastapi.service import RestfulService
-
-
-def inject(dependency: str) -> Any:  # pragma: no cover
-    def get(request: Request) -> Any:
-        return getattr(request.app.state, dependency)
-
-    return Depends(get)
+from apexdevkit.fastapi.service import RestfulResource
 
 
 class _ServiceBuilder(Protocol):
@@ -25,7 +17,7 @@ class _ServiceBuilder(Protocol):
     def with_parent(self, identity: str) -> "_ServiceBuilder":
         pass
 
-    def build(self) -> RestfulService:  # pragma: no cover
+    def build(self) -> RestfulResource:  # pragma: no cover
         pass
 
 
@@ -38,10 +30,10 @@ class _Dependency(Protocol):
 class ServiceDependency:
     dependency: _Dependency
 
-    def as_dependable(self) -> type[RestfulService]:
+    def as_dependable(self) -> type[RestfulResource]:
         Builder = self.dependency.as_dependable()
 
-        def _(builder: Builder) -> RestfulService:
+        def _(builder: Builder) -> RestfulResource:
             try:
                 return builder.build()
             except ForbiddenError as e:
@@ -49,7 +41,7 @@ class ServiceDependency:
                     403, RestfulResponse(RestfulName("unknown")).forbidden(e)
                 ) from e
 
-        return Annotated[RestfulService, Depends(_)]
+        return Annotated[RestfulResource, Depends(_)]
 
 
 @dataclass(frozen=True)
@@ -119,5 +111,5 @@ class DependableBuilder:
     def with_user(self, extract_user: Callable[..., Any]) -> "DependableBuilder":
         return DependableBuilder(UserDependency(extract_user, self.dependency))
 
-    def as_dependable(self) -> type[RestfulService]:
+    def as_dependable(self) -> type[RestfulResource]:
         return ServiceDependency(self.dependency).as_dependable()

apexdevkit-2.3.1/apexdevkit/fastapi/endpoints.py

@@ -0,0 +1,103 @@
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import Any
+
+from fastapi.responses import JSONResponse
+
+from apexdevkit.error import DoesNotExistError, ExistsError, ForbiddenError
+from apexdevkit.fastapi.response import RestfulResponse
+
+_Response = JSONResponse | dict[str, Any]
+_Endpoint = Callable[..., _Response]
+
+
+@dataclass(frozen=True)
+class RestfulEndpoints:
+    response: RestfulResponse
+
+    def create_one_endpoint(self, Service, Item) -> _Endpoint:
+        def endpoint(service: Service, item: Item) -> _Response:
+            try:
+                result = 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(result)
+
+        return endpoint
+
+    def read_one_endpoint(self, Service, ItemId) -> _Endpoint:
+        def endpoint(service: Service, item_id: ItemId) -> _Response:
+            try:
+                result = 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 self.response.found_one(result)
+
+        return endpoint
+
+    def read_many_endpoint(self, Service, QueryParams) -> _Endpoint:
+        def endpoint(service: Service, params: QueryParams) -> _Response:
+            try:
+                result = list(service.read_many(**dict(params)))
+            except ForbiddenError as e:
+                return JSONResponse(self.response.forbidden(e), 403)
+
+            return self.response.found_many(result)
+
+        return endpoint
+
+    def read_all_endpoint(self, Service) -> _Endpoint:
+        def endpoint(service: Service) -> _Response:
+            try:
+                result = list(service.read_all())
+            except ForbiddenError as e:
+                return JSONResponse(self.response.forbidden(e), 403)
+
+            return self.response.found_many(result)
+
+        return endpoint
+
+    def update_one_endpoint(self, Service, ItemId, Updates) -> _Endpoint:
+        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 replace_one_endpoint(self, Service, Item) -> _Endpoint:
+        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 delete_one_endpoint(self, Service, ItemId) -> _Endpoint:
+        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-2.1.4 → apexdevkit-2.3.1}/apexdevkit/fastapi/router.py

@@ -1,17 +1,19 @@
-from collections.abc import Callable
+from collections.abc import Callable, Mapping
 from dataclasses import dataclass, field
 from enum import Enum
-from typing import Annotated, Any, Protocol, Self, TypeVar
+from typing import Annotated, Any, Protocol, Self
 
 from fastapi import APIRouter, Depends, Path, Query
 from fastapi.responses import JSONResponse
 from pypebbles import FluentDict
 
+from apexdevkit.fastapi.endpoints import RestfulEndpoints
 from apexdevkit.fastapi.name import RestfulName
-from apexdevkit.fastapi.resource import RestfulResource
 from apexdevkit.fastapi.response import RestfulResponse
 from apexdevkit.fastapi.schema import RestfulSchema, Schema, SchemaFields
-from apexdevkit.fastapi.service import RawItem, RestfulService
+from apexdevkit.fastapi.service import RestfulResource
+
+RawItem = Mapping[str, Any]
 
 
 class RouterWithHiddenUnderscoreRoutes(APIRouter):
@@ -47,26 +49,24 @@ class RouterWithHiddenUnderscoreRoutes(APIRouter):
 
 _Response = JSONResponse | dict[str, Any]
 
-T = TypeVar("T")
-
 
-class Dependency(Protocol):  # pragma: no cover
-    def as_dependable(self) -> type[RestfulService]:
+class Dependency[T](Protocol):  # pragma: no cover
+    def as_dependable(self) -> type[RestfulResource[T]]:
         pass
 
 
 @dataclass
-class RestfulRouter:
+class RestfulRouter[T]:
     name: RestfulName
 
     parent: RestfulName | None = None
     router: APIRouter = field(default_factory=RouterWithHiddenUnderscoreRoutes)
 
     _schema: RestfulSchema = field(init=False)
-    _dependency: Dependency | None = field(init=False, default=None)
+    _dependency: Dependency[T] | None = field(init=False, default=None)
 
     @classmethod
-    def named(cls, singular: str, *, plural: str | None = None) -> "RestfulRouter":
+    def named(cls, singular: str, *, plural: str | None = None) -> "RestfulRouter[T]":
         if plural:
             return cls(RestfulName(singular, plural))
 
@@ -81,8 +81,8 @@ class RestfulRouter:
         return self
 
     @property
-    def resource(self) -> RestfulResource:
-        return RestfulResource(RestfulResponse(self.name))
+    def endpoints(self) -> RestfulEndpoints:
+        return RestfulEndpoints(RestfulResponse(self.name))
 
     @property
     def id_alias(self) -> str:
@@ -115,20 +115,20 @@ class RestfulRouter:
 
         return self
 
-    def with_default_dependency(self, value: Dependency) -> Self:
+    def with_default_dependency(self, value: Dependency[T]) -> Self:
         self._dependency = value
 
         return self
 
     def with_create_one(
         self,
-        dependency: Dependency | None = None,
+        dependency: Dependency[T] | None = None,
         *,
         is_documented: bool = True,
     ) -> Self:
         self.router.add_api_route(
             "",
-            self.resource.create_one(
+            self.endpoints.create_one_endpoint(
                 Service=self._resolve(dependency),
                 Item=Annotated[
                     RawItem,
@@ -147,13 +147,13 @@ class RestfulRouter:
 
     def with_read_one(
         self,
-        dependency: Dependency | None = None,
+        dependency: Dependency[T] | None = None,
         *,
         is_documented: bool = True,
     ) -> Self:
         self.router.add_api_route(
             self.item_path,
-            self.resource.read_one(
+            self.endpoints.read_one_endpoint(
                 Service=self._resolve(dependency),
                 ItemId=Annotated[
                     str,
@@ -173,16 +173,19 @@ class RestfulRouter:
     def with_read_many(
         self,
         query: FluentDict[Any],
-        dependency: Dependency | None = None,
+        dependency: Dependency[T] | None = None,
         *,
         is_documented: bool = True,
     ) -> Self:
         self.router.add_api_route(
             "",
-            self.resource.read_many(
+            self.endpoints.read_many_endpoint(
                 Service=self._resolve(dependency),
                 QueryParams=Annotated[
-                    Schema(self.name.singular).optional_schema_for("ReadMany", query),
+                    Schema(self.name.singular).optional_schema_for(
+                        action="ReadMany",
+                        fields=query,
+                    ),
                     Query(),
                 ],
             ),
@@ -198,13 +201,15 @@ class RestfulRouter:
 
     def with_read_all(
         self,
-        dependency: Dependency | None = None,
+        dependency: Dependency[T] | None = None,
         *,
         is_documented: bool = True,
     ) -> Self:
         self.router.add_api_route(
             "",
-            self.resource.read_all(Service=self._resolve(dependency)),
+            self.endpoints.read_all_endpoint(
+                Service=self._resolve(dependency),
+            ),
             methods=["GET"],
             status_code=200,
             responses={},
@@ -217,13 +222,13 @@ class RestfulRouter:
 
     def with_update_one(
         self,
-        dependency: Dependency | None = None,
+        dependency: Dependency[T] | None = None,
         *,
         is_documented: bool = True,
     ) -> Self:
         self.router.add_api_route(
             self.item_path,
-            self.resource.update_one(
+            self.endpoints.update_one_endpoint(
                 Service=self._resolve(dependency),
                 ItemId=Annotated[
                     str,
@@ -246,13 +251,13 @@ class RestfulRouter:
 
     def with_replace_one(
         self,
-        dependency: Dependency | None = None,
+        dependency: Dependency[T] | None = None,
         *,
         is_documented: bool = True,
     ) -> Self:
         self.router.add_api_route(
             "",
-            self.resource.replace_one(
+            self.endpoints.replace_one_endpoint(
                 Service=self._resolve(dependency),
                 Item=Annotated[
                     RawItem,
@@ -271,13 +276,13 @@ class RestfulRouter:
 
     def with_delete_one(
         self,
-        dependency: Dependency | None = None,
+        dependency: Dependency[T] | None = None,
         *,
         is_documented: bool = True,
     ) -> Self:
         self.router.add_api_route(
             self.item_path,
-            self.resource.delete_one(
+            self.endpoints.delete_one_endpoint(
                 Service=self._resolve(dependency),
                 ItemId=Annotated[
                     str,
@@ -312,7 +317,7 @@ class RestfulRouter:
     def build(self) -> APIRouter:
         return self.router
 
-    def _resolve(self, dependency: Dependency | None) -> type[RestfulService]:
+    def _resolve(self, dependency: Dependency[T] | None) -> type[RestfulResource[T]]:
         resolved = dependency or self._dependency
         assert resolved, "One of default or endpoint dependency must be specified"
 

{apexdevkit-2.1.4 → apexdevkit-2.3.1}/apexdevkit/fastapi/schema.py

@@ -11,9 +11,6 @@ from apexdevkit.fastapi.name import RestfulName
 
 
 class SchemaFields(ABC):
-    def id(self) -> FluentDict[type]:
-        return self.readable().select("id")
-
     def writable(self) -> FluentDict[type]:
         return self.readable().drop("id")
 

apexdevkit-2.3.1/apexdevkit/fastapi/service.py

@@ -0,0 +1,137 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Any
+
+from pypebbles import JsonDict
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable, Mapping
+
+    from apexdevkit.formatter import Formatter
+    from apexdevkit.repository import Entity, Repository
+
+
+@dataclass(frozen=True, kw_only=True)
+class RestfulResource[T]:
+    service: RestfulService[T]
+    formatter: Formatter[Mapping[str, Any], T]
+
+    def create_one(self, item: Mapping[str, Any]) -> Mapping[str, Any]:
+        result = self.service.create_one(self.formatter.load(item))
+
+        return self.formatter.dump(result)
+
+    def read_one(self, item_id: str) -> Mapping[str, Any]:
+        result = self.service.read_one(with_id=item_id)
+
+        return self.formatter.dump(result)
+
+    def read_all(self) -> Iterable[Mapping[str, Any]]:
+        result = self.service.read_all()
+
+        return [self.formatter.dump(item) for item in result]
+
+    def read_many(self, **params: Any) -> Iterable[Mapping[str, Any]]:
+        result = self.service.read_many(JsonDict(params))
+
+        return [self.formatter.dump(item) for item in result]
+
+    def update_one(self, item_id: str, **with_fields: Any) -> Mapping[str, Any]:
+        current = self.service.read_one(with_id=item_id)
+        updated = {**self.formatter.dump(current), **with_fields}
+        result = self.service.update_one(self.formatter.load(updated))
+
+        return self.formatter.dump(result)
+
+    def replace_one(self, item: Mapping[str, Any]) -> Mapping[str, Any]:
+        result = self.service.update_one(self.formatter.load(item))
+
+        return self.formatter.dump(result)
+
+    def delete_one(self, item_id: str) -> None:
+        self.service.delete_one(with_id=item_id)
+
+    @dataclass(kw_only=True)
+    class Builder[BT](ABC):
+        formatter: Formatter[Mapping[str, Any], BT]
+
+        parent_id: str = field(init=False)
+        user: Any = field(init=False)
+
+        def with_user(self, user: Any) -> RestfulResource.Builder[BT]:
+            self.user = user
+
+            return self
+
+        def with_parent(self, identity: str) -> RestfulResource.Builder[BT]:
+            self.parent_id = identity
+
+            return self
+
+        def build(self) -> RestfulResource[BT]:
+            return RestfulResource(
+                service=self.service(),
+                formatter=self.formatter,
+            )
+
+        @abstractmethod
+        def service(self) -> RestfulService[BT]:
+            pass
+
+    @dataclass(kw_only=True)
+    class PreBuilt[PBT](Builder[PBT]):  # pragma: no cover
+        instance: RestfulService[PBT]
+
+        def service(self) -> RestfulService[PBT]:
+            return self.instance
+
+
+class RestfulService[T]:
+    def create_one(self, item: T) -> T:
+        raise NotImplementedError
+
+    def read_one(self, *, with_id: str) -> T:
+        raise NotImplementedError
+
+    def read_all(self) -> Iterable[T]:
+        raise NotImplementedError
+
+    def read_many(self, query: JsonDict) -> Iterable[T]:
+        raise NotImplementedError
+
+    def update_one(self, item: T) -> T:
+        raise NotImplementedError
+
+    def delete_one(self, with_id: str) -> T:
+        raise NotImplementedError
+
+
+@dataclass(frozen=True)
+class RestfulRepository[T: Entity](RestfulService[T]):
+    repository: Repository[T]
+
+    def create_one(self, item: T) -> T:
+        return self.repository.create(item)
+
+    def read_one(self, *, with_id: str) -> T:
+        return self.repository.read(with_id)
+
+    def read_all(self) -> Iterable[T]:
+        yield from self.repository
+
+    def read_many(self, query: JsonDict) -> Iterable[T]:
+        raise NotImplementedError
+
+    def update_one(self, item: T) -> T:
+        self.repository.update(item)
+
+        return item
+
+    def delete_one(self, with_id: str) -> T:
+        result = self.repository.read(with_id)
+
+        self.repository.delete(with_id)
+
+        return result

{apexdevkit-2.1.4 → apexdevkit-2.3.1}/apexdevkit/formatter.py

@@ -17,6 +17,14 @@ class Formatter[SourceT, TargetT](Protocol):  # pragma: no cover
         pass
 
 
+class NoFormatter[S, T]:
+    def load(self, source: S) -> T:
+        raise NotImplementedError
+
+    def dump(self, target: T) -> S:
+        raise NotImplementedError
+
+
 @dataclass(frozen=True)
 class AliasFormatter[TargetT](Formatter[Mapping[str, Any], TargetT]):
     inner: Formatter[Mapping[str, Any], TargetT]

{apexdevkit-2.1.4 → apexdevkit-2.3.1}/apexdevkit/testing.py

@@ -127,9 +127,10 @@ class ResponseProbe:
         return self.with_item(value)
 
     def with_item(self, value: Any) -> Self:
-        assert self.response.item() == value, self.response.raw
+        if self.response.item() == value:
+            return self
 
-        return self
+        raise AssertionError("expected=", self.response.item(), "actual=", value)
 
     def and_collection(self, values: Collection[Any]) -> Self:
         return self.with_collection(values)

{apexdevkit-2.1.4 → apexdevkit-2.3.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "apexdevkit"
-version = "2.1.4"
+version = "2.3.1"
 description = "Apex Development Tools for python."
 readme = "README.md"
 authors = [
@@ -31,7 +31,7 @@ pytest-env = "*"
 pytest-recording = "*"
 
 [tool.ruff.lint.per-file-ignores]
-"apexdevkit/fastapi/resource.py" = [ "N803" ]
+"apexdevkit/fastapi/endpoints.py" = [ "N803" ]
 "apexdevkit/fastapi/dependable.py" = [ "N806" ]
 
 [tool.ruff.lint.mccabe]
@@ -80,6 +80,7 @@ ignore = [
 [tool.mypy]
 exclude = [
     "apexdevkit/fastapi/dependable.py",
+    "apexdevkit/fastapi/endpoints.py",
     "apexdevkit/fastapi/schema.py",
 ]
 ignore_missing_imports = true

apexdevkit-2.1.4/apexdevkit/fastapi/__init__.py

@@ -1,13 +0,0 @@
-from apexdevkit.fastapi.builder import FastApiBuilder, RestfulServiceBuilder
-from apexdevkit.fastapi.dependable import inject
-from apexdevkit.fastapi.router import RestfulRouter, RouterWithHiddenUnderscoreRoutes
-from apexdevkit.fastapi.service import RestfulRepository
-
-__all__ = [
-    "FastApiBuilder",
-    "RestfulRepository",
-    "RestfulRouter",
-    "RestfulServiceBuilder",
-    "RouterWithHiddenUnderscoreRoutes",
-    "inject",
-]

apexdevkit-2.1.4/apexdevkit/fastapi/docs.py

@@ -1,15 +0,0 @@
-from typing import TypeVar
-
-from pydantic import BaseModel
-
-PayloadT = TypeVar("PayloadT")
-
-
-class Response[PayloadT](BaseModel):
-    status: str
-    code: int
-    data: PayloadT
-
-
-class NoData(BaseModel):
-    pass

apexdevkit-2.1.4/apexdevkit/fastapi/resource.py

@@ -1,319 +0,0 @@
-import re
-from collections.abc import Callable
-from dataclasses import dataclass
-from typing import Any, Union
-
-from fastapi.responses import JSONResponse
-from pydantic import BaseModel
-
-from apexdevkit.error import DoesNotExistError, ExistsError, ForbiddenError
-from apexdevkit.fastapi.response import RestfulResponse
-from apexdevkit.query.query import (
-    Aggregation,
-    AggregationOption,
-    DateValue,
-    Filter,
-    FooterOptions,
-    Leaf,
-    ListValue,
-    NullValue,
-    NumericValue,
-    Operation,
-    Operator,
-    Page,
-    QueryOptions,
-    Sort,
-    StringValue,
-)
-
-_Response = JSONResponse | dict[str, Any]
-_Endpoint = Callable[..., _Response]
-
-
-@dataclass(frozen=True)
-class RestfulResource:
-    response: RestfulResponse
-
-    def create_one(self, Service, Item) -> _Endpoint:  # 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) -> _Endpoint:  # 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) -> _Endpoint:  # 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_many(self, Service, QueryParams) -> _Endpoint:  # type: ignore
-        def endpoint(service: Service, params: QueryParams) -> _Response:
-            try:
-                return self.response.found_many(list(service.read_many(**dict(params))))
-            except ForbiddenError as e:
-                return JSONResponse(self.response.forbidden(e), 403)
-
-        return endpoint
-
-    def filter_with(self, Service, QueryOptions) -> _Endpoint:  # type: ignore
-        def endpoint(service: Service, options: QueryOptions) -> _Response:
-            try:
-                return self.response.found_many(list(service.filter_with(options)))
-            except ForbiddenError as e:
-                return JSONResponse(self.response.forbidden(e), 403)
-
-        return endpoint
-
-    def aggregation_with(self, Service, FilterOptions) -> _Endpoint:  # type: ignore
-        def endpoint(service: Service, options: FilterOptions) -> _Response:
-            try:
-                return {
-                    "status": "success",
-                    "code": 200,
-                    "aggregations": service.aggregation_with(options),
-                }
-            except ForbiddenError as e:
-                return JSONResponse(self.response.forbidden(e), 403)
-
-        return endpoint
-
-    def read_all(self, Service) -> _Endpoint:  # 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) -> _Endpoint:  # 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) -> _Endpoint:  # 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) -> _Endpoint:  # 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) -> _Endpoint:  # 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) -> _Endpoint:  # 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
-
-
-@dataclass
-class _ColumnName:
-    raw: str
-
-    def __str__(self) -> str:
-        return re.sub(r"(?<!^)(?=[A-Z])", "_", self.raw).lower()
-
-
-class _NumericItem(BaseModel):
-    value: int
-    exponent: int
-
-    def to_value(self) -> NumericValue:
-        return NumericValue(self.value, self.exponent)
-
-
-class _StringItem(BaseModel):
-    value: str
-
-    def to_value(self) -> StringValue:
-        return StringValue(self.value)
-
-
-class _DateItem(BaseModel):
-    date: str
-
-    def to_value(self) -> DateValue:
-        return DateValue(self.date)
-
-
-class _ListItem(BaseModel):
-    values: list[_NumericItem | _StringItem | _DateItem]
-
-    def to_value(self) -> ListValue:
-        return ListValue([item.to_value() for item in self.values])
-
-
-class _LeafItem(BaseModel):
-    name: str
-    values: list[_NumericItem | _StringItem | _DateItem]
-
-    def to_value(self) -> Leaf:
-        return Leaf(
-            name=str(_ColumnName(self.name)),
-            values=[item.to_value() for item in self.values],
-        )
-
-
-class _OperatorItem(BaseModel):
-    operation: Operation
-    operands: list[Union["_LeafItem", "_OperatorItem"]]
-
-    def to_value(self) -> Operator:
-        return Operator(self.operation, [item.to_value() for item in self.operands])
-
-
-class _SortItem(BaseModel):
-    name: str
-    is_descending: bool
-
-    def to_value(self) -> Sort:
-        return Sort(str(_ColumnName(self.name)), self.is_descending)
-
-
-class _PageItem(BaseModel):
-    page: int | None
-    length: int | None
-    offset: int | None
-
-    def to_value(self) -> Page:
-        return Page(self.page, self.length, self.offset)
-
-
-class _FilterItem(BaseModel):
-    args: list[_NumericItem | _StringItem | _DateItem | _ListItem | None]
-
-    def to_value(self) -> Filter:
-        return Filter(
-            [arg.to_value() if arg is not None else None for arg in self.args]
-        )
-
-
-class _AggregationOptionItem(BaseModel):
-    name: str | None
-    aggregation: Aggregation
-
-    def to_value(self) -> AggregationOption:
-        return AggregationOption(
-            str(_ColumnName(self.name)) if self.name else None,
-            self.aggregation,
-        )
-
-
-class _FooterOptions(BaseModel):
-    filter: _FilterItem | None
-    condition: _OperatorItem | None
-    aggregations: list[_AggregationOptionItem]
-
-    def to_footer_options(self) -> FooterOptions:
-        return FooterOptions(
-            filter=self.filter.to_value() if self.filter else None,
-            condition=self.condition.to_value() if self.condition else None,
-            aggregations=[item.to_value() for item in self.aggregations],
-        )
-
-
-class _QueryOptions(BaseModel):
-    filter: _FilterItem | None
-    condition: _OperatorItem | None
-    ordering: list[_SortItem]
-    paging: _PageItem
-
-    def to_query_options(self) -> QueryOptions:
-        return QueryOptions(
-            filter=self.filter.to_value() if self.filter else None,
-            condition=self.condition.to_value() if self.condition else None,
-            ordering=[item.to_value() for item in self.ordering],
-            paging=self.paging.to_value(),
-        )
-
-
-class _SummaryItem(BaseModel):
-    name: str | None
-    aggregation: Aggregation
-    result: NumericValue | StringValue | DateValue | NullValue
-
-
-class _SummaryListEnvelope(BaseModel):
-    count: int
-    summaries: list[_SummaryItem]
-
-
-class SummaryResponse(BaseModel):
-    status: str
-    code: int
-    data: _SummaryListEnvelope
-
-
-class SumResponse(BaseModel):
-    status: str
-    code: int
-    count: int

apexdevkit-2.1.4/apexdevkit/fastapi/service.py

@@ -1,120 +0,0 @@
-from __future__ import annotations
-
-from collections.abc import Iterable, Mapping
-from dataclasses import dataclass
-from functools import cached_property
-from typing import TYPE_CHECKING, Any
-
-from apexdevkit.repository import BruteForceBatch, Entity, Repository
-
-if TYPE_CHECKING:
-    from apexdevkit.formatter import Formatter
-    from apexdevkit.repository.core.interface import BatchRepository
-
-RawItem = Mapping[str, Any]
-RawCollection = Iterable[RawItem]
-
-
-class _RawItemWithId(dict[str, Any]):
-    def __post_init__(self) -> None:
-        assert "id" in self
-
-
-RawCollectionWithId = Iterable[_RawItemWithId]
-
-
-class RestfulService:  # pragma: no cover
-    def create_one(self, item: RawItem) -> RawItem:
-        raise NotImplementedError(self.create_one.__name__)
-
-    def create_many(self, items: RawCollection) -> RawCollection:
-        raise NotImplementedError(self.create_many.__name__)
-
-    def read_one(self, item_id: str) -> RawItem:
-        raise NotImplementedError(self.read_one.__name__)
-
-    def read_many(self, **params: Any) -> RawCollection:
-        raise NotImplementedError(self.read_many.__name__)
-
-    def filter_with(self, options: RawItem) -> RawCollection:
-        raise NotImplementedError(self.filter_with.__name__)
-
-    def aggregation_with(self, options: RawItem) -> RawItem:
-        raise NotImplementedError(self.filter_with.__name__)
-
-    def read_all(self) -> RawCollection:
-        raise NotImplementedError(self.read_all.__name__)
-
-    def update_one(self, item_id: str, **with_fields: Any) -> RawItem:
-        raise NotImplementedError(self.update_one.__name__)
-
-    def update_many(self, items: RawCollectionWithId) -> RawCollection:
-        raise NotImplementedError(self.update_many.__name__)
-
-    def replace_one(self, item: RawItem) -> RawItem:
-        raise NotImplementedError(self.replace_one.__name__)
-
-    def replace_many(self, items: RawCollection) -> RawCollection:
-        raise NotImplementedError(self.replace_many.__name__)
-
-    def delete_one(self, item_id: str) -> None:
-        raise NotImplementedError(self.delete_one.__name__)
-
-
-@dataclass(frozen=True)
-class RestfulRepository[ItemT: Entity](RestfulService):
-    repository: Repository[ItemT]
-
-    formatter: Formatter[Mapping[str, Any], ItemT]
-
-    @cached_property
-    def _batch(self) -> BatchRepository[ItemT]:
-        return BruteForceBatch(inner=self.repository)
-
-    def create_one(self, item: RawItem) -> RawItem:
-        return self.formatter.dump(self.repository.create(self.formatter.load(item)))
-
-    def create_many(self, items: RawCollection) -> RawCollection:
-        return [
-            self.formatter.dump(item)
-            for item in self._batch.load(
-                [self.formatter.load(fields) for fields in items]
-            )
-        ]
-
-    def read_one(self, item_id: str) -> RawItem:
-        return self.formatter.dump(self.repository.read(item_id))
-
-    def read_all(self) -> RawCollection:
-        return [self.formatter.dump(item) for item in self.repository]
-
-    def update_one(self, item_id: str, **with_fields: Any) -> RawItem:
-        data = dict(self.formatter.dump(self.repository.read(item_id)))
-        data.update(**with_fields)
-
-        self.repository.update(self.formatter.load(data))
-
-        return data
-
-    def update_many(self, items: RawCollectionWithId) -> RawCollection:
-        updates = []
-        for fields in items:
-            data = dict(self.formatter.dump(self.repository.read(fields["id"])))
-            data.update(**fields)
-
-            updates.append(self.formatter.load(data))
-
-        return [self.formatter.dump(item) for item in self._batch.renew(updates)]
-
-    def replace_one(self, item: RawItem) -> RawItem:
-        self.repository.update(self.formatter.load(item))
-
-        return item
-
-    def replace_many(self, items: RawCollection) -> RawCollection:
-        updated = self._batch.renew([self.formatter.load(item) for item in items])
-
-        return [self.formatter.dump(item) for item in updated]
-
-    def delete_one(self, item_id: str) -> None:
-        self.repository.delete(item_id)