nsj-rest-lib2 0.0.35__py3-none-any.whl → 0.0.36__py3-none-any.whl

nsj_rest_lib2/compiler/compiler.py

@@ -28,6 +28,7 @@ from nsj_rest_lib2.compiler.util.type_naming_util import (
     compile_entity_class_name,
     compile_namespace_keys,
 )
+from nsj_rest_lib2.compiler.response_dto_compiler import ResponseDTOCompiler
 from nsj_rest_lib2.compiler.util.relation_ref import RelationRefParser
 
 from nsj_rest_lib2.compiler.edl_model.entity_model import EntityModel
@@ -169,9 +170,12 @@ class EDLCompiler:
         get_function_name = None
         list_function_name = None
         delete_function_name = None
+        handlers: dict[str, Any] = {}
+        post_handler = None
+        put_handler = None
+        patch_handler = None
 
         if isinstance(entity_model, EntityModel) and entity_model.api:
-            handlers = {}
             if entity_model.api.handlers:
                 handlers = {
                     (verb or "").lower(): handler
@@ -179,16 +183,20 @@ class EDLCompiler:
                     if handler
                 }
 
+            post_handler = handlers.get("post")
+            put_handler = handlers.get("put")
+            patch_handler = handlers.get("patch")
+
             insert_output = self._function_compiler.compile_insert(
                 entity_model,
                 properties_structure,
-                handlers.get("post"),
+                post_handler,
                 prefx_class_name,
             )
             update_output = self._function_compiler.compile_update(
                 entity_model,
                 properties_structure,
-                handlers.get("put"),
+                put_handler,
                 prefx_class_name,
             )
             get_handler = handlers.get("get")
@@ -354,6 +362,16 @@ class EDLCompiler:
         # Adicionando as dependências das relações
         relations_dependencies_complete.extend(relations_dependencies)
 
+        response_dto_compiler = ResponseDTOCompiler(
+            dto_compiler=self._dto_compiler,
+            entity_model=entity_model,
+            prefx_class_name=prefx_class_name,
+            ast_dto_attributes=ast_dto_attributes,
+            aux_classes=aux_classes,
+            related_imports=related_imports,
+            fixed_filters=fixed_filters,
+        )
+
         # Adicionando as dependências da extensão parcial
         if partial_metadata and partial_base_model:
             relation_dependency = RelationDependency()
@@ -367,6 +385,68 @@ class EDLCompiler:
             relation_dependency.grupo_empresarial = partial_base_model.grupo_empresarial
             relations_dependencies_complete.append(relation_dependency)
 
+        post_expected = "empty"
+        put_expected = "empty"
+        patch_expected = "empty"
+        get_expected = "empty"
+        list_expected = "empty"
+        delete_expected = "empty"
+        post_properties = None
+        put_properties = None
+        patch_properties = None
+        if isinstance(entity_model, EntityModel) and entity_model.api:
+            post_expected, post_properties = (
+                response_dto_compiler.handler_result_details(post_handler)
+            )
+            put_expected, put_properties = (
+                response_dto_compiler.handler_result_details(put_handler)
+            )
+            patch_expected, patch_properties = (
+                response_dto_compiler.handler_result_details(patch_handler)
+            )
+            get_expected, _ = response_dto_compiler.handler_result_details(
+                get_handler
+            )
+            list_expected, _ = response_dto_compiler.handler_result_details(
+                list_handler
+            )
+            delete_expected, _ = response_dto_compiler.handler_result_details(
+                delete_handler
+            )
+
+        if post_expected == "partial_row":
+            post_class_name, post_code = (
+                response_dto_compiler.compile_partial_response_dto(
+                    "post", post_properties or []
+                )
+            )
+            compiler_result_post_class = post_class_name
+            dto_code += "\n\n" + post_code
+        else:
+            compiler_result_post_class = None
+
+        if put_expected == "partial_row":
+            put_class_name, put_code = (
+                response_dto_compiler.compile_partial_response_dto(
+                    "put", put_properties or []
+                )
+            )
+            compiler_result_put_class = put_class_name
+            dto_code += "\n\n" + put_code
+        else:
+            compiler_result_put_class = None
+
+        if patch_expected == "partial_row":
+            patch_class_name, patch_code = (
+                response_dto_compiler.compile_partial_response_dto(
+                    "patch", patch_properties or []
+                )
+            )
+            compiler_result_patch_class = patch_class_name
+            dto_code += "\n\n" + patch_code
+        else:
+            compiler_result_patch_class = None
+
         # Construindo o resultado
         compiler_result = CompilerResult()
         compiler_result.entity_class_name = entity_class_name
@@ -389,6 +469,34 @@ class EDLCompiler:
         compiler_result.source_delete_function_type = (
             delete_function_code.strip() or None
         )
+        compiler_result.retrieve_after_insert = post_expected == "entity_row"
+        compiler_result.retrieve_after_update = put_expected == "entity_row"
+        compiler_result.retrieve_after_partial_update = (
+            patch_expected == "entity_row"
+        )
+        compiler_result.post_response_dto_class_name = compiler_result_post_class
+        compiler_result.put_response_dto_class_name = compiler_result_put_class
+        compiler_result.patch_response_dto_class_name = (
+            compiler_result_patch_class
+        )
+        compiler_result.custom_json_post_response = (
+            post_expected == "custom_json"
+        )
+        compiler_result.custom_json_put_response = (
+            put_expected == "custom_json"
+        )
+        compiler_result.custom_json_patch_response = (
+            patch_expected == "custom_json"
+        )
+        compiler_result.custom_json_get_response = (
+            get_expected == "custom_json"
+        )
+        compiler_result.custom_json_list_response = (
+            list_expected == "custom_json"
+        )
+        compiler_result.custom_json_delete_response = (
+            delete_expected == "custom_json"
+        )
 
         insert_code_compiled = insert_function_code.strip()
         update_code_compiled = update_function_code.strip()

nsj_rest_lib2/compiler/dto_compiler.py

@@ -1,4 +1,5 @@
 import ast
+from typing import Optional
 
 import black
 
@@ -21,6 +22,7 @@ class DTOCompiler:
         fixed_filters: list[tuple[str, BasicTypes]],
         prefx_class_name: str,
         partial_metadata: dict[str, str] | None,
+        class_name_override: Optional[str] = None,
     ) -> tuple[str, str]:
         """
         Compila o código do DTO a partir do AST e retorna o código compilado.
@@ -158,7 +160,9 @@ class DTOCompiler:
             )
 
         # Criando o ast da classe
-        class_name = compile_dto_class_name(entity_model.id, prefx_class_name)
+        class_name = class_name_override or compile_dto_class_name(
+            entity_model.id, prefx_class_name
+        )
         ast_class = ast.ClassDef(
             name=class_name,
             bases=[ast.Name(id="DTOBase", ctx=ast.Load())],

nsj_rest_lib2/compiler/edl_model/api_model.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from typing import Dict, List, Literal, Optional
 
-from pydantic import AliasChoices, BaseModel, Field
+from pydantic import AliasChoices, BaseModel, Field, model_validator
 
 APIVerbs = Literal["GET", "POST", "PUT", "DELETE", "PATCH"]
 
@@ -46,10 +46,22 @@ class HandlerCall(BaseModel):
 
 
 class HandlerResult(BaseModel):
-    expected: Literal["empty", "entity_row"] = Field(
+    expected: Literal["empty", "entity_row", "custom_json", "partial_row"] = Field(
         default="empty",
         description="Define o formato esperado do retorno da função.",
     )
+    properties: Optional[List[str]] = Field(
+        default=None,
+        description="Lista de propriedades a serem retornadas quando o resultado esperado for 'partial_row'.",
+    )
+
+    @model_validator(mode="after")
+    def validate_partial_row(self):
+        if self.expected == "partial_row" and not self.properties:
+            raise ValueError(
+                "result.properties é obrigatório quando result.expected for 'partial_row'."
+            )
+        return self
 
 
 class HandlerError(BaseModel):
@@ -68,12 +80,12 @@ class HandlerError(BaseModel):
 
 
 class HandlerConfig(BaseModel):
-    impl: Literal["pg_function"] = Field(
-        ...,
+    impl: Optional[Literal["pg_function"]] = Field(
+        default=None,
         description="Somente funções PostgreSQL (pg_function) são suportadas neste estágio.",
     )
-    function_ref: str = Field(
-        ...,
+    function_ref: Optional[str] = Field(
+        default=None,
         description="Referência qualificada para a função no banco (ex.: schema.fn_nome).",
     )
     call: Optional[HandlerCall] = Field(

nsj_rest_lib2/compiler/model.py

@@ -59,3 +59,15 @@ class CompilerResult:
         self.source_get_function_type: str | None = None
         self.source_list_function_type: str | None = None
         self.source_delete_function_type: str | None = None
+        self.retrieve_after_insert: bool | None = None
+        self.retrieve_after_update: bool | None = None
+        self.retrieve_after_partial_update: bool | None = None
+        self.post_response_dto_class_name: str | None = None
+        self.put_response_dto_class_name: str | None = None
+        self.patch_response_dto_class_name: str | None = None
+        self.custom_json_post_response: bool | None = None
+        self.custom_json_put_response: bool | None = None
+        self.custom_json_patch_response: bool | None = None
+        self.custom_json_get_response: bool | None = None
+        self.custom_json_list_response: bool | None = None
+        self.custom_json_delete_response: bool | None = None

nsj_rest_lib2/compiler/response_dto_compiler.py

@@ -0,0 +1,104 @@
+from __future__ import annotations
+
+import ast
+from typing import Any, Optional
+
+from nsj_rest_lib2.compiler.dto_compiler import DTOCompiler
+from nsj_rest_lib2.compiler.edl_model.entity_model_base import EntityModelBase
+from nsj_rest_lib2.compiler.edl_model.primitives import BasicTypes
+from nsj_rest_lib2.compiler.util.str_util import CompilerStrUtil
+from nsj_rest_lib2.compiler.util.type_naming_util import (
+    compile_response_dto_class_name,
+)
+
+
+class ResponseDTOCompiler:
+    def __init__(
+        self,
+        dto_compiler: DTOCompiler,
+        entity_model: EntityModelBase,
+        prefx_class_name: str,
+        ast_dto_attributes: list[ast.stmt],
+        aux_classes: list[ast.stmt],
+        related_imports: list[tuple[str, str, str]],
+        fixed_filters: list[tuple[str, BasicTypes]],
+    ) -> None:
+        self._dto_compiler = dto_compiler
+        self._entity_model = entity_model
+        self._prefx_class_name = prefx_class_name
+        self._aux_classes = aux_classes
+        self._related_imports = related_imports
+        self._fixed_filters = fixed_filters
+        self._dto_attr_map = self._build_attr_map(ast_dto_attributes)
+
+    @staticmethod
+    def handler_result_details(handler: Any) -> tuple[str, list[str] | None]:
+        expected = "empty"
+        properties = None
+        if handler and getattr(handler, "result", None):
+            expected = handler.result.expected or "empty"
+            properties = handler.result.properties
+        return (expected, properties)
+
+    def compile_partial_response_dto(
+        self, verb: str, properties: list[str]
+    ) -> tuple[str, str]:
+        if not properties:
+            raise Exception(
+                f"result.properties não pode ser vazio para '{verb}' na entidade '{self._entity_model.id}'."
+            )
+
+        normalized = [
+            CompilerStrUtil.to_snake_case(prop) for prop in properties
+        ]
+        missing = [
+            properties[idx]
+            for idx, norm in enumerate(normalized)
+            if norm not in self._dto_attr_map
+        ]
+        if missing:
+            raise Exception(
+                f"As propriedades {missing} não foram encontradas na entidade '{self._entity_model.id}'."
+            )
+
+        filtered_attrs = [self._dto_attr_map[name] for name in normalized]
+        filtered_fixed_filters = [
+            item for item in self._fixed_filters if item[0] in normalized
+        ]
+
+        class_name = compile_response_dto_class_name(
+            self._entity_model.id,
+            self._prefx_class_name,
+            verb,
+        )
+
+        return self._dto_compiler.compile(
+            self._entity_model,
+            filtered_attrs,
+            self._aux_classes,
+            self._related_imports,
+            filtered_fixed_filters,
+            self._prefx_class_name,
+            None,
+            class_name_override=class_name,
+        )
+
+    @staticmethod
+    def _extract_attr_name(stmt: ast.stmt) -> Optional[str]:
+        if isinstance(stmt, ast.AnnAssign) and isinstance(stmt.target, ast.Name):
+            return stmt.target.id
+        if isinstance(stmt, ast.Assign) and stmt.targets:
+            target = stmt.targets[0]
+            if isinstance(target, ast.Name):
+                return target.id
+        return None
+
+    def _build_attr_map(
+        self, ast_dto_attributes: list[ast.stmt]
+    ) -> dict[str, ast.stmt]:
+        dto_attr_map: dict[str, ast.stmt] = {}
+        for stmt in ast_dto_attributes:
+            name = self._extract_attr_name(stmt)
+            if name:
+                dto_attr_map[name] = stmt
+        return dto_attr_map

nsj_rest_lib2/compiler/util/type_naming_util.py

@@ -18,6 +18,25 @@ def compile_dto_class_name(entity_id: str, prefx_class_name: str = "") -> str:
     return f"{CompilerStrUtil.to_pascal_case(prefx_class_name)}{CompilerStrUtil.to_pascal_case(entity_id)}DTO"
 
 
+def compile_response_dto_class_name(
+    entity_id: str, prefx_class_name: str, verb: str
+) -> str:
+    verb = (verb or "").lower()
+    suffix_map = {
+        "post": "PostResponseDTO",
+        "put": "PutResponseDTO",
+        "patch": "PatchResponseDTO",
+    }
+    suffix = suffix_map.get(
+        verb, f"{CompilerStrUtil.to_pascal_case(verb)}ResponseDTO"
+    )
+    return (
+        f"{CompilerStrUtil.to_pascal_case(prefx_class_name)}"
+        f"{CompilerStrUtil.to_pascal_case(entity_id)}"
+        f"{suffix}"
+    )
+
+
 def compile_entity_class_name(entity_id: str, prefx_class_name: str = "") -> str:
     return f"{CompilerStrUtil.to_pascal_case(prefx_class_name)}{CompilerStrUtil.to_pascal_case(entity_id)}Entity"
 

nsj_rest_lib2/controller/dynamic_controller.py

@@ -11,12 +11,12 @@ from nsj_gcf_utils.rest_error_util import format_json_error
 from nsj_multi_database_lib.decorator.multi_database import multi_database
 
 from nsj_rest_lib.controller.controller_util import DEFAULT_RESP_HEADERS
-from nsj_rest_lib.controller.list_route import ListRoute
+from nsj_rest_lib.controller.delete_route import DeleteRoute
 from nsj_rest_lib.controller.get_route import GetRoute
+from nsj_rest_lib.controller.list_route import ListRoute
+from nsj_rest_lib.controller.patch_route import PatchRoute
 from nsj_rest_lib.controller.post_route import PostRoute
 from nsj_rest_lib.controller.put_route import PutRoute
-from nsj_rest_lib.controller.patch_route import PatchRoute
-from nsj_rest_lib.controller.delete_route import DeleteRoute
 
 from nsj_rest_lib2.exception import MissingEntityConfigException
 from nsj_rest_lib2.service.entity_loader import EntityLoader
@@ -133,6 +133,10 @@ def setup_dynamic_routes(
             _get_function_type_class_name,
             list_function_type_class_name,
             _delete_function_type_class_name,
+            *_,
+            _custom_json_get_response,
+            custom_json_list_response,
+            _custom_json_delete_response,
         ) = entity_config
 
         def list_dynamic(*args: Any, **kwargs: Any) -> Any:
@@ -149,6 +153,7 @@ def setup_dynamic_routes(
                 list_function_type_class=etities_dict.get(
                     list_function_type_class_name
                 ),
+                custom_json_response=bool(custom_json_list_response),
             )
 
             return route.handle_request(*args, **kwargs)
@@ -173,6 +178,10 @@ def setup_dynamic_routes(
             get_function_type_class_name,
             _list_function_type_class_name,
             _delete_function_type_class_name,
+            *_,
+            custom_json_get_response,
+            _custom_json_list_response,
+            _custom_json_delete_response,
         ) = entity_config
 
         def get_dynamic(*args: Any, **kwargs: Any) -> Any:
@@ -187,6 +196,7 @@ def setup_dynamic_routes(
                 injector_factory=injector_factory,
                 get_function_name=get_function_name,
                 get_function_type_class=etities_dict.get(get_function_type_class_name),
+                custom_json_response=bool(custom_json_get_response),
             )
 
             return route.handle_request(*args, **kwargs)
@@ -211,6 +221,18 @@ def setup_dynamic_routes(
             _get_function_type_class_name,
             _list_function_type_class_name,
             _delete_function_type_class_name,
+            retrieve_after_insert,
+            _retrieve_after_update,
+            _retrieve_after_partial_update,
+            post_response_dto_class_name,
+            _put_response_dto_class_name,
+            _patch_response_dto_class_name,
+            custom_json_post_response,
+            _custom_json_put_response,
+            _custom_json_patch_response,
+            _custom_json_get_response,
+            _custom_json_list_response,
+            _custom_json_delete_response,
         ) = entity_config
 
         def post_dynamic(*args: Any, **kwargs: Any) -> Any:
@@ -223,6 +245,12 @@ def setup_dynamic_routes(
                 else None
             )
 
+            dto_response_class = (
+                etities_dict.get(post_response_dto_class_name)
+                if post_response_dto_class_name
+                else None
+            )
+
             route = PostRoute(
                 url=COLLECTION_DYNAMIC_ROUTE,
                 http_method="POST",
@@ -231,6 +259,9 @@ def setup_dynamic_routes(
                 injector_factory=injector_factory,
                 insert_function_type_class=insert_function_type_class,
                 insert_function_name=insert_function_name,
+                dto_response_class=dto_response_class,
+                retrieve_after_insert=retrieve_after_insert,
+                custom_json_response=bool(custom_json_post_response),
             )
 
             return route.handle_request(*args, **kwargs)
@@ -255,8 +286,26 @@ def setup_dynamic_routes(
             _get_function_type_class_name,
             _list_function_type_class_name,
             _delete_function_type_class_name,
+            _retrieve_after_insert,
+            retrieve_after_update,
+            _retrieve_after_partial_update,
+            _post_response_dto_class_name,
+            put_response_dto_class_name,
+            _patch_response_dto_class_name,
+            _custom_json_post_response,
+            custom_json_put_response,
+            _custom_json_patch_response,
+            _custom_json_get_response,
+            _custom_json_list_response,
+            _custom_json_delete_response,
         ) = entity_config
 
+        dto_response_class = (
+            etities_dict.get(put_response_dto_class_name)
+            if put_response_dto_class_name
+            else None
+        )
+
         def put_dynamic(*args: Any, **kwargs: Any) -> Any:
             if not api_expose or "PUT" not in api_verbs:
                 return ("", 405, {})
@@ -275,6 +324,9 @@ def setup_dynamic_routes(
                 injector_factory=injector_factory,
                 update_function_type_class=update_function_type_class,
                 update_function_name=update_function_name,
+                dto_response_class=dto_response_class,
+                retrieve_after_update=retrieve_after_update,
+                custom_json_response=bool(custom_json_put_response),
             )
 
             return route.handle_request(*args, **kwargs)
@@ -296,19 +348,42 @@ def setup_dynamic_routes(
             _get_function_name,
             _list_function_name,
             _delete_function_name,
-            *_,
+            _get_function_type_class_name,
+            _list_function_type_class_name,
+            _delete_function_type_class_name,
+            _retrieve_after_insert,
+            _retrieve_after_update,
+            retrieve_after_partial_update,
+            _post_response_dto_class_name,
+            _put_response_dto_class_name,
+            patch_response_dto_class_name,
+            _custom_json_post_response,
+            _custom_json_put_response,
+            custom_json_patch_response,
+            _custom_json_get_response,
+            _custom_json_list_response,
+            _custom_json_delete_response,
         ) = entity_config
 
         def patch_dynamic(*args: Any, **kwargs: Any) -> Any:
             if not api_expose or "PATCH" not in api_verbs:
                 return ("", 405, {})
 
+            dto_response_class = (
+                etities_dict.get(patch_response_dto_class_name)
+                if patch_response_dto_class_name
+                else None
+            )
+
             route = PatchRoute(
                 url=ONE_DYNAMIC_ROUTE,
                 http_method="PATCH",
                 dto_class=etities_dict[dto_class_name],
                 entity_class=etities_dict[entity_class_name],
                 injector_factory=injector_factory,
+                dto_response_class=dto_response_class,
+                retrieve_after_partial_update=retrieve_after_partial_update,
+                custom_json_response=bool(custom_json_patch_response),
             )
 
             return route.handle_request(*args, **kwargs)
@@ -333,6 +408,10 @@ def setup_dynamic_routes(
             _get_function_type_class_name,
             _list_function_type_class_name,
             delete_function_type_class_name,
+            *_,
+            _custom_json_get_response,
+            _custom_json_list_response,
+            custom_json_delete_response,
         ) = entity_config
 
         def delete_dynamic(*args: Any, **kwargs: Any) -> Any:
@@ -349,6 +428,7 @@ def setup_dynamic_routes(
                 delete_function_type_class=etities_dict.get(
                     delete_function_type_class_name
                 ),
+                custom_json_response=bool(custom_json_delete_response),
             )
 
             return route.handle_request(*args, **kwargs)

nsj_rest_lib2/service/entity_config_writer.py

@@ -86,6 +86,18 @@ class EntityConfigWriter:
             "source_get_function_type": compiler_result.source_get_function_type,
             "source_list_function_type": compiler_result.source_list_function_type,
             "source_delete_function_type": compiler_result.source_delete_function_type,
+            "retrieve_after_insert": compiler_result.retrieve_after_insert,
+            "retrieve_after_update": compiler_result.retrieve_after_update,
+            "retrieve_after_partial_update": compiler_result.retrieve_after_partial_update,
+            "post_response_dto_class_name": compiler_result.post_response_dto_class_name,
+            "put_response_dto_class_name": compiler_result.put_response_dto_class_name,
+            "patch_response_dto_class_name": compiler_result.patch_response_dto_class_name,
+            "custom_json_post_response": compiler_result.custom_json_post_response,
+            "custom_json_put_response": compiler_result.custom_json_put_response,
+            "custom_json_patch_response": compiler_result.custom_json_patch_response,
+            "custom_json_get_response": compiler_result.custom_json_get_response,
+            "custom_json_list_response": compiler_result.custom_json_list_response,
+            "custom_json_delete_response": compiler_result.custom_json_delete_response,
             "source_dto": compiler_result.dto_code,
             "source_entity": compiler_result.entity_code,
             "entity_hash": entity_hash
@@ -142,6 +154,18 @@ class EntityConfigWriter:
             compiler_result.source_get_function_type,
             compiler_result.source_list_function_type,
             compiler_result.source_delete_function_type,
+            compiler_result.post_response_dto_class_name,
+            compiler_result.put_response_dto_class_name,
+            compiler_result.patch_response_dto_class_name,
+            str(compiler_result.retrieve_after_insert),
+            str(compiler_result.retrieve_after_update),
+            str(compiler_result.retrieve_after_partial_update),
+            str(compiler_result.custom_json_post_response),
+            str(compiler_result.custom_json_put_response),
+            str(compiler_result.custom_json_patch_response),
+            str(compiler_result.custom_json_get_response),
+            str(compiler_result.custom_json_list_response),
+            str(compiler_result.custom_json_delete_response),
             compiler_result.service_account,
         ):
             hasher.update(content)

nsj_rest_lib2/service/entity_loader.py

@@ -35,6 +35,18 @@ class LoadedEntity:
         self.get_function_type_class_name: str | None = None
         self.list_function_type_class_name: str | None = None
         self.delete_function_type_class_name: str | None = None
+        self.retrieve_after_insert: bool = False
+        self.retrieve_after_update: bool = False
+        self.retrieve_after_partial_update: bool = False
+        self.post_response_dto_class_name: str | None = None
+        self.put_response_dto_class_name: str | None = None
+        self.patch_response_dto_class_name: str | None = None
+        self.custom_json_post_response: bool = False
+        self.custom_json_put_response: bool = False
+        self.custom_json_patch_response: bool = False
+        self.custom_json_get_response: bool = False
+        self.custom_json_list_response: bool = False
+        self.custom_json_delete_response: bool = False
 
 
 class Namespace:
@@ -75,6 +87,19 @@ class EntityLoader:
         str | None,
         str | None,
         str | None,
+        str | None,
+        bool,
+        bool,
+        bool,
+        str | None,
+        str | None,
+        str | None,
+        bool,
+        bool,
+        bool,
+        bool,
+        bool,
+        bool,
     ]:
         # Assumind o escopo default se necessário
         if not escopo:
@@ -177,6 +202,18 @@ class EntityLoader:
                         get_function_type_class_name,
                         list_function_type_class_name,
                         delete_function_type_class_name,
+                        loaded_entity.retrieve_after_insert,
+                        loaded_entity.retrieve_after_update,
+                        loaded_entity.retrieve_after_partial_update,
+                        loaded_entity.post_response_dto_class_name,
+                        loaded_entity.put_response_dto_class_name,
+                        loaded_entity.patch_response_dto_class_name,
+                        loaded_entity.custom_json_post_response,
+                        loaded_entity.custom_json_put_response,
+                        loaded_entity.custom_json_patch_response,
+                        loaded_entity.custom_json_get_response,
+                        loaded_entity.custom_json_list_response,
+                        loaded_entity.custom_json_delete_response,
                     )
 
                 # Desempacotando resultado
@@ -209,6 +246,18 @@ class EntityLoader:
                         get_function_type_class_name,
                         list_function_type_class_name,
                         delete_function_type_class_name,
+                        loaded_entity.retrieve_after_insert,
+                        loaded_entity.retrieve_after_update,
+                        loaded_entity.retrieve_after_partial_update,
+                        loaded_entity.post_response_dto_class_name,
+                        loaded_entity.put_response_dto_class_name,
+                        loaded_entity.patch_response_dto_class_name,
+                        loaded_entity.custom_json_post_response,
+                        loaded_entity.custom_json_put_response,
+                        loaded_entity.custom_json_patch_response,
+                        loaded_entity.custom_json_get_response,
+                        loaded_entity.custom_json_list_response,
+                        loaded_entity.custom_json_delete_response,
                     )
                 else:
                     (
@@ -228,6 +277,18 @@ class EntityLoader:
                         get_function_type_class_name,
                         list_function_type_class_name,
                         delete_function_type_class_name,
+                        retrieve_after_insert,
+                        retrieve_after_update,
+                        retrieve_after_partial_update,
+                        post_response_dto_class_name,
+                        put_response_dto_class_name,
+                        patch_response_dto_class_name,
+                        custom_json_post_response,
+                        custom_json_put_response,
+                        custom_json_patch_response,
+                        custom_json_get_response,
+                        custom_json_list_response,
+                        custom_json_delete_response,
                     ) = result_execute
                     return (
                         dto_class_name,
@@ -246,6 +307,18 @@ class EntityLoader:
                         get_function_type_class_name,
                         list_function_type_class_name,
                         delete_function_type_class_name,
+                        retrieve_after_insert,
+                        retrieve_after_update,
+                        retrieve_after_partial_update,
+                        post_response_dto_class_name,
+                        put_response_dto_class_name,
+                        patch_response_dto_class_name,
+                        custom_json_post_response,
+                        custom_json_put_response,
+                        custom_json_patch_response,
+                        custom_json_get_response,
+                        custom_json_list_response,
+                        custom_json_delete_response,
                     )
             else:
                 # Se não deu o intervalo de verificação do refresh, retorna o que está em memória
@@ -266,6 +339,18 @@ class EntityLoader:
                     get_function_type_class_name,
                     list_function_type_class_name,
                     delete_function_type_class_name,
+                    loaded_entity.retrieve_after_insert,
+                    loaded_entity.retrieve_after_update,
+                    loaded_entity.retrieve_after_partial_update,
+                    loaded_entity.post_response_dto_class_name,
+                    loaded_entity.put_response_dto_class_name,
+                    loaded_entity.patch_response_dto_class_name,
+                    loaded_entity.custom_json_post_response,
+                    loaded_entity.custom_json_put_response,
+                    loaded_entity.custom_json_patch_response,
+                    loaded_entity.custom_json_get_response,
+                    loaded_entity.custom_json_list_response,
+                    loaded_entity.custom_json_delete_response,
                 )
 
         # Se não conseguir recuperar a entidade, procura no redis:
@@ -311,6 +396,18 @@ class EntityLoader:
             get_function_type_class_name,
             list_function_type_class_name,
             delete_function_type_class_name,
+            retrieve_after_insert,
+            retrieve_after_update,
+            retrieve_after_partial_update,
+            post_response_dto_class_name,
+            put_response_dto_class_name,
+            patch_response_dto_class_name,
+            custom_json_post_response,
+            custom_json_put_response,
+            custom_json_patch_response,
+            custom_json_get_response,
+            custom_json_list_response,
+            custom_json_delete_response,
         ) = result_execute
 
         return (
@@ -330,6 +427,18 @@ class EntityLoader:
             get_function_type_class_name,
             list_function_type_class_name,
             delete_function_type_class_name,
+            retrieve_after_insert,
+            retrieve_after_update,
+            retrieve_after_partial_update,
+            post_response_dto_class_name,
+            put_response_dto_class_name,
+            patch_response_dto_class_name,
+            custom_json_post_response,
+            custom_json_put_response,
+            custom_json_patch_response,
+            custom_json_get_response,
+            custom_json_list_response,
+            custom_json_delete_response,
         )
 
     def clear_namespaces(self):
@@ -377,6 +486,18 @@ class EntityLoader:
         str | None,
         str | None,
         str | None,
+        bool,
+        bool,
+        bool,
+        str | None,
+        str | None,
+        str | None,
+        bool,
+        bool,
+        bool,
+        bool,
+        bool,
+        bool,
     ] | None:
         # Interpretando o json de configuração da entidade
         try:
@@ -414,6 +535,42 @@ class EntityLoader:
             delete_function_type_class_name = entity_config.get(
                 "delete_function_type_class_name"
             )
+            retrieve_after_insert = entity_config.get(
+                "retrieve_after_insert", False
+            )
+            retrieve_after_update = entity_config.get(
+                "retrieve_after_update", False
+            )
+            retrieve_after_partial_update = entity_config.get(
+                "retrieve_after_partial_update", False
+            )
+            post_response_dto_class_name = entity_config.get(
+                "post_response_dto_class_name"
+            )
+            put_response_dto_class_name = entity_config.get(
+                "put_response_dto_class_name"
+            )
+            patch_response_dto_class_name = entity_config.get(
+                "patch_response_dto_class_name"
+            )
+            custom_json_post_response = entity_config.get(
+                "custom_json_post_response", False
+            )
+            custom_json_put_response = entity_config.get(
+                "custom_json_put_response", False
+            )
+            custom_json_patch_response = entity_config.get(
+                "custom_json_patch_response", False
+            )
+            custom_json_get_response = entity_config.get(
+                "custom_json_get_response", False
+            )
+            custom_json_list_response = entity_config.get(
+                "custom_json_list_response", False
+            )
+            custom_json_delete_response = entity_config.get(
+                "custom_json_delete_response", False
+            )
             get_function_code = entity_config.get("source_get_function_type")
             list_function_code = entity_config.get("source_list_function_type")
             delete_function_code = entity_config.get("source_delete_function_type")
@@ -562,6 +719,38 @@ class EntityLoader:
             loaded_entity.delete_function_type_class_name = (
                 delete_function_type_class_name
             )
+            loaded_entity.retrieve_after_insert = bool(retrieve_after_insert)
+            loaded_entity.retrieve_after_update = bool(retrieve_after_update)
+            loaded_entity.retrieve_after_partial_update = bool(
+                retrieve_after_partial_update
+            )
+            loaded_entity.post_response_dto_class_name = (
+                post_response_dto_class_name
+            )
+            loaded_entity.put_response_dto_class_name = (
+                put_response_dto_class_name
+            )
+            loaded_entity.patch_response_dto_class_name = (
+                patch_response_dto_class_name
+            )
+            loaded_entity.custom_json_post_response = bool(
+                custom_json_post_response
+            )
+            loaded_entity.custom_json_put_response = bool(
+                custom_json_put_response
+            )
+            loaded_entity.custom_json_patch_response = bool(
+                custom_json_patch_response
+            )
+            loaded_entity.custom_json_get_response = bool(
+                custom_json_get_response
+            )
+            loaded_entity.custom_json_list_response = bool(
+                custom_json_list_response
+            )
+            loaded_entity.custom_json_delete_response = bool(
+                custom_json_delete_response
+            )
 
             namespace.loaded_entities[entity_resource] = loaded_entity
 
@@ -582,6 +771,18 @@ class EntityLoader:
             get_function_type_class_name,
             list_function_type_class_name,
             delete_function_type_class_name,
+            bool(retrieve_after_insert),
+            bool(retrieve_after_update),
+            bool(retrieve_after_partial_update),
+            post_response_dto_class_name,
+            put_response_dto_class_name,
+            patch_response_dto_class_name,
+            bool(custom_json_post_response),
+            bool(custom_json_put_response),
+            bool(custom_json_patch_response),
+            bool(custom_json_get_response),
+            bool(custom_json_list_response),
+            bool(custom_json_delete_response),
         )
 
     def _safe_exec(self, source_code, context, description):

{nsj_rest_lib2-0.0.35.dist-info → nsj_rest_lib2-0.0.36.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nsj_rest_lib2
-Version: 0.0.35
+Version: 0.0.36
 Summary: Biblioteca para permitir a distribuição de rotas dinâmicas numa API, configuradas por meio de EDLs declarativos (em formato JSON).
 Home-page: https://github.com/Nasajon/nsj_rest_lib2
 Author: Nasajon Sistemas

{nsj_rest_lib2-0.0.35.dist-info → nsj_rest_lib2-0.0.36.dist-info}/RECORD

@@ -3,9 +3,9 @@ nsj_rest_lib2/exception.py,sha256=E9uMUdoCCQOVQfc8f6gD9b5Pxurf3Q4SytDCcqSlkZ8,56
 nsj_rest_lib2/redis_config.py,sha256=4KLcvYS3nJO7PMQgF6F9_j6r-TyqcS7TBbd3LEQuKDU,629
 nsj_rest_lib2/settings.py,sha256=Hn_o1HZmievnYb8D1kNT2Nq-OEjxbyNjOiOpbnFsMwE,367
 nsj_rest_lib2/compiler/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nsj_rest_lib2/compiler/compiler.py,sha256=a-lfAEgj2O6mmYKoA3q2x_tVhjBD-y7C6LHixStgqaU,35263
+nsj_rest_lib2/compiler/compiler.py,sha256=z-u9UeOhNKxH6bwaPWTxkN_SJjgZ6tGJD_iXc2D2Hr4,39433
 nsj_rest_lib2/compiler/compiler_structures.py,sha256=stspjqJGXU7Vz3BqQ-ZF5ZmumFm3R4jpkWgVVsXW5d0,1488
-nsj_rest_lib2/compiler/dto_compiler.py,sha256=Fs6VysuAjBgct7_Wc0sugvx7z9tfnlZcSrBu0l0Pyp0,7019
+nsj_rest_lib2/compiler/dto_compiler.py,sha256=kT9v8z0MMHYGkVudkJA0VUY1tNCM7QzV6_RV-aWjSoE,7143
 nsj_rest_lib2/compiler/entity_compiler.py,sha256=LeGEBxsjAmZZog2gh4vjUX1aFp9JSVgHHOdTkY0aH-s,6733
 nsj_rest_lib2/compiler/function_get_delete_compiler.py,sha256=bfzpsKEb_qeGBlaMVJ22P0Ju0YJGrXiMSsBnSl2mqJA,8234
 nsj_rest_lib2/compiler/function_insert_update_compiler.py,sha256=a4KfituXIF1jxsI7Nox0TqxGZAxsO9kuOo7RwoGgbSE,18004
@@ -14,11 +14,12 @@ nsj_rest_lib2/compiler/migration_compiler.py,sha256=vlG54XmYRqzIo0Iey-4HbSRzPg3Y
 nsj_rest_lib2/compiler/migration_compiler_alter_table.py,sha256=awtqVrKox86rmlQV7K17JzZJZqz9cF7McshLBlLx65s,7969
 nsj_rest_lib2/compiler/migration_compiler_create_table.py,sha256=h22cU53EFnuB5t28fMZ_r7MM-14Vqqu3emebBUJN2LY,2606
 nsj_rest_lib2/compiler/migration_compiler_util.py,sha256=WB_GRX78nTRKlZkgL-4yowwlQoAe81llZ-E2AYfIbh4,5168
-nsj_rest_lib2/compiler/model.py,sha256=ow9dQve7npl4OZU2GyS0HMZ2OXvBSebWTQCXFm6iMxM,2358
+nsj_rest_lib2/compiler/model.py,sha256=k3xxgJlogCbdT0cHoksPI-EnyRJJzn2sylpYhzWz4CI,3069
 nsj_rest_lib2/compiler/property_compiler.py,sha256=hMQX5vrLqjOEM_wdzuerxuARMq5JhZQ_R8cUVoLHNNM,47631
+nsj_rest_lib2/compiler/response_dto_compiler.py,sha256=9859w1LSgb-9TcLTUx1bhqLVgJ4ulTwbDufonVJLCow,3614
 nsj_rest_lib2/compiler/edl_model/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nsj_rest_lib2/compiler/edl_model/ai_entity_edl.py,sha256=664QBDcOgVnyfwtUOXO1W7AKaZhueBG335x5DuogruY,7644
-nsj_rest_lib2/compiler/edl_model/api_model.py,sha256=7RpZkUGROZmTBh2psgTG_b3e4xxjc3uBr1EYb-wiAkc,3810
+nsj_rest_lib2/compiler/edl_model/api_model.py,sha256=rDHQpxwVRYSYbu5E9sjhENXAC5Aid6D0cFXvhLMwriw,4376
 nsj_rest_lib2/compiler/edl_model/column_meta_model.py,sha256=s0sEVkoW1hV2_hto1mws4XhzKGH_b4NzhaOiwFH25Ks,694
 nsj_rest_lib2/compiler/edl_model/entity_model.py,sha256=Yc6wvjsiwacmz796mZIU-i9hxzNV9yuLPdULGKYHNbM,854
 nsj_rest_lib2/compiler/edl_model/entity_model_base.py,sha256=eRn0pirIPHvniqGpT0xE-mmgqz5RIVtqghxcnfxKNdQ,4345
@@ -31,18 +32,18 @@ nsj_rest_lib2/compiler/edl_model/trait_property_meta_model.py,sha256=NtMVZeOPu3L
 nsj_rest_lib2/compiler/util/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nsj_rest_lib2/compiler/util/relation_ref.py,sha256=1M_e-NyeqozlIYLl1rB76KqkmtMvgtqH_nJS-NK0Pck,3695
 nsj_rest_lib2/compiler/util/str_util.py,sha256=0ReIQ2Vy4zAmVMvGv0FcUehRQw15hlz0e7yDsF89ghk,1178
-nsj_rest_lib2/compiler/util/type_naming_util.py,sha256=jYUnr3eC6ewwhIAFHF89OOLoSH9aO_syHMF66AsWX3s,2355
+nsj_rest_lib2/compiler/util/type_naming_util.py,sha256=RAiYSM_tzRmfQZCCiH7_q6AAPB2_M24df6Ve_3LHQyc,2877
 nsj_rest_lib2/compiler/util/type_util.py,sha256=HTKOH4uRTOY0YgoM8oUv_6cEcReE_bgKYXFBsQCb-3A,357
 nsj_rest_lib2/controller/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nsj_rest_lib2/controller/dynamic_controller.py,sha256=8kvN75-E4mA1nApNJMMQstKv036z8tDPV5YtLCokNQU,14132
+nsj_rest_lib2/controller/dynamic_controller.py,sha256=B9cVzJf61O0dJf7UymFz60wzjQMLoUVqEK4g_ccAi-U,17432
 nsj_rest_lib2/dto/__init__.py,sha256=MsSFjiLMLJZ7QhUPpVBWKiyDnCzryquRyr329NoCACI,2
 nsj_rest_lib2/dto/escopo_dto.py,sha256=R9gxRwYxOVYhGjR3q03_iXvHm14N905zbRKLsS3jI-A,1393
 nsj_rest_lib2/entity/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nsj_rest_lib2/entity/escopo_entity.py,sha256=T4bxFDzHJvIj-nZ_6d0Xh2oQg21HgoRjp19nt6clY18,338
 nsj_rest_lib2/service/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nsj_rest_lib2/service/entity_config_writer.py,sha256=bLXWrncm_OOjkvF_wcEAJ1NVjhcrV-zt41gDNtPDh68,6100
-nsj_rest_lib2/service/entity_loader.py,sha256=FPHdJs6qA_-bjtHMsJ7OAe0RxVv0vfOMX5lN51ZB_JA,25355
-nsj_rest_lib2-0.0.35.dist-info/METADATA,sha256=dwRpdr9scMDq5gcRqj57_Zai44EHM-GkuZmy5vMG_8w,1094
-nsj_rest_lib2-0.0.35.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-nsj_rest_lib2-0.0.35.dist-info/top_level.txt,sha256=L6zh0EfH8_rur7OJ8_V-El-XEMf4qg3bkF8ADgqLVIA,14
-nsj_rest_lib2-0.0.35.dist-info/RECORD,,
+nsj_rest_lib2/service/entity_config_writer.py,sha256=YBYo8a6H8zqt8CqKzPYCtrYjMnT2IOY8-KkJ8-6tPBs,7831
+nsj_rest_lib2/service/entity_loader.py,sha256=WNmnKcRYHPT44eiXXpiMglflJWx3BeqwXdenpXuNJsM,34237
+nsj_rest_lib2-0.0.36.dist-info/METADATA,sha256=lFFBWAgH8YMBDpaDjFpSHeBbT42L7JGXNigD1WkiO7g,1094
+nsj_rest_lib2-0.0.36.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+nsj_rest_lib2-0.0.36.dist-info/top_level.txt,sha256=L6zh0EfH8_rur7OJ8_V-El-XEMf4qg3bkF8ADgqLVIA,14
+nsj_rest_lib2-0.0.36.dist-info/RECORD,,