apexdevkit 1.5.21__tar.gz → 1.5.23__tar.gz

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

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

apexdevkit-1.5.23/apexdevkit/fastapi/__init__.py

@@ -0,0 +1,10 @@
+from apexdevkit.fastapi.builder import FastApiBuilder, RestfulServiceBuilder
+from apexdevkit.fastapi.dependable import inject
+from apexdevkit.fastapi.service import RestfulRepositoryBuilder
+
+__all__ = [
+    "FastApiBuilder",
+    "RestfulServiceBuilder",
+    "inject",
+    "RestfulRepositoryBuilder",
+]

{apexdevkit-1.5.21 → apexdevkit-1.5.23}/apexdevkit/fastapi/builder.py

@@ -1,8 +1,11 @@
+from abc import ABC, abstractmethod
 from dataclasses import dataclass, field
 from typing import Any, Self
 
 from fastapi import APIRouter, FastAPI
 
+from apexdevkit.fastapi.service import RestfulService
+
 
 @dataclass
 class FastApiBuilder:
@@ -37,3 +40,23 @@ class FastApiBuilder:
             self.app.include_router(value, prefix=f"/{key}", tags=[key.title()])
 
         return self
+
+
+@dataclass
+class RestfulServiceBuilder(ABC):
+    parent_id: str = field(init=False)
+    user: Any = field(init=False)
+
+    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

apexdevkit-1.5.23/apexdevkit/fastapi/resource.py

@@ -0,0 +1,342 @@
+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

apexdevkit-1.5.23/apexdevkit/fastapi/response.py

@@ -0,0 +1,130 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Iterable
+
+from fastapi import status
+from fastapi.responses import JSONResponse
+
+from apexdevkit.error import DoesNotExistError, ExistsError, ForbiddenError
+from apexdevkit.testing import RestfulName
+
+
+class SuccessResponse(dict[str, Any]):
+    def __init__(self, status_code: int, **kwargs: Any):
+        super().__init__(
+            {
+                "status": "success",
+                "code": status_code,
+                "data": {**kwargs},
+            }
+        )
+
+
+class ResourceFound(SuccessResponse):
+    def __init__(self, **kwargs: Any):
+        super().__init__(status_code=status.HTTP_200_OK, **kwargs)
+
+
+class ResourceCreated(SuccessResponse):
+    def __init__(self, **kwargs: Any):
+        super().__init__(status_code=status.HTTP_201_CREATED, **kwargs)
+
+
+class ErrorResponse(JSONResponse):
+    def __init__(self, status_code: int, message: str, **kwargs: Any):
+        content = {
+            "status": "fail",
+            "code": status_code,
+            "error": {"message": message},
+        }
+
+        if kwargs:
+            content["data"] = {**kwargs}
+
+        super().__init__(status_code=status_code, content=content)
+
+
+class BadRequest(ErrorResponse):
+    def __init__(self, message: str, **kwargs: Any) -> None:
+        super().__init__(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            message=message,
+            **kwargs,
+        )
+
+
+class ResourceNotFound(ErrorResponse):
+    def __init__(self, message: str):
+        super().__init__(status_code=status.HTTP_404_NOT_FOUND, message=message)
+
+
+class ResourceExists(ErrorResponse):
+    def __init__(self, message: str, **kwargs: Any):
+        super().__init__(
+            status_code=status.HTTP_409_CONFLICT,
+            message=message,
+            **kwargs,
+        )
+
+
+@dataclass
+class RestfulResponse:
+    name: RestfulName
+
+    def _response(self, code: int, data: Any, error: str = "") -> dict[str, Any]:
+        content: dict[str, Any] = {"code": code, "status": "success"}
+
+        if error:
+            content["status"] = "fail"
+            content["error"] = {"message": error}
+
+        match data:
+            case None:
+                content["data"] = {}
+            case list():
+                content["data"] = {self.name.plural: data, "count": len(data)}
+            case _:
+                content["data"] = {self.name.singular: data}
+
+        return content
+
+    def ok(self) -> dict[str, Any]:
+        return self._response(200, data=None)
+
+    def not_found(self, e: DoesNotExistError) -> dict[str, Any]:
+        name = self.name.singular.capitalize()
+
+        return self._response(
+            404,
+            data={"id": str(e.id)},
+            error=f"An item<{name}> with id<{e.id}> does not exist.",
+        )
+
+    def exists(self, e: ExistsError) -> dict[str, Any]:
+        name = self.name.singular.capitalize()
+
+        return self._response(
+            409,
+            data={"id": str(e.id)},
+            error=f"An item<{name}> with the {e} already exists.",
+        )
+
+    def forbidden(self, e: ForbiddenError) -> dict[str, Any]:
+        return self._response(
+            403,
+            data={"id": str(e.id)},
+            error=e.message,
+        )
+
+    def created_one(self, item: Any) -> dict[str, Any]:
+        return self._response(201, item)
+
+    def created_many(self, items: Iterable[Any]) -> dict[str, Any]:
+        return self._response(201, list(items))
+
+    def found_one(self, item: Any) -> dict[str, Any]:
+        return self._response(200, item)
+
+    def found_many(self, items: list[Any]) -> dict[str, Any]:
+        return self._response(200, items)