nsj-rest-lib2 0.0.31__py3-none-any.whl → 0.0.32__py3-none-any.whl

nsj_rest_lib2/compiler/compiler.py

@@ -6,10 +6,13 @@ from nsj_rest_lib2.compiler.compiler_structures import (
     PropertiesCompilerStructure,
 )
 from nsj_rest_lib2.compiler.dto_compiler import DTOCompiler
-from nsj_rest_lib2.compiler.function_compiler import (
-    FunctionCompiler,
+from nsj_rest_lib2.compiler.function_insert_update_compiler import (
+    FunctionInsertUpdateCompiler,
     inject_function_bindings,
 )
+from nsj_rest_lib2.compiler.function_get_delete_compiler import (
+    FunctionGetDeleteCompiler,
+)
 from nsj_rest_lib2.compiler.function_model import (
     FunctionBindingConfig,
     FunctionCompilationOutput,
@@ -37,7 +40,8 @@ class EDLCompiler:
         self._properties_compiler = EDLPropertyCompiler()
         self._dto_compiler = DTOCompiler()
         self._entity_compiler = EntityCompiler()
-        self._function_compiler = FunctionCompiler()
+        self._function_compiler = FunctionInsertUpdateCompiler()
+        self._function_get_delete_compiler = FunctionGetDeleteCompiler()
 
     def compile_models(
         self, entity_models: dict[str, EntityModel]
@@ -142,6 +146,15 @@ class EDLCompiler:
         update_output = FunctionCompilationOutput()
         insert_function_code = ""
         update_function_code = ""
+        get_function_code = ""
+        list_function_code = ""
+        delete_function_code = ""
+        get_function_type_class = None
+        list_function_type_class = None
+        delete_function_type_class = None
+        get_function_name = None
+        list_function_name = None
+        delete_function_name = None
 
         if isinstance(entity_model, EntityModel) and entity_model.api:
             handlers = {}
@@ -164,6 +177,15 @@ class EDLCompiler:
                 handlers.get("put"),
                 prefx_class_name,
             )
+            get_handler = handlers.get("get")
+            list_handler = handlers.get("list")
+            delete_handler = handlers.get("delete")
+
+            get_function_name = get_handler.function_ref if get_handler else None
+            list_function_name = list_handler.function_ref if list_handler else None
+            delete_function_name = (
+                delete_handler.function_ref if delete_handler else None
+            )
 
             inject_function_bindings(
                 function_bindings,
@@ -176,6 +198,46 @@ class EDLCompiler:
             if update_output.code:
                 update_function_code += update_output.code + "\n\n"
 
+            # Gerando FunctionTypes para GET/LIST/DELETE (quando configuradas)
+            get_output = self._function_get_delete_compiler.compile(
+                entity_model,
+                properties_structure,
+                get_handler,
+                prefx_class_name,
+                verb="get",
+            )
+            if get_output.class_name and get_output.code:
+                get_function_type_class = get_output.class_name
+                get_function_code = get_output.code
+            if get_output.function_name:
+                get_function_name = get_output.function_name
+
+            list_output = self._function_get_delete_compiler.compile(
+                entity_model,
+                properties_structure,
+                list_handler,
+                prefx_class_name,
+                verb="list",
+            )
+            if list_output.class_name and list_output.code:
+                list_function_type_class = list_output.class_name
+                list_function_code = list_output.code
+            if list_output.function_name:
+                list_function_name = list_output.function_name
+
+            delete_output = self._function_get_delete_compiler.compile(
+                entity_model,
+                properties_structure,
+                delete_handler,
+                prefx_class_name,
+                verb="delete",
+            )
+            if delete_output.class_name and delete_output.code:
+                delete_function_type_class = delete_output.class_name
+                delete_function_code = delete_output.code
+            if delete_output.function_name:
+                delete_function_name = delete_output.function_name
+
         # Criando a lista de atributos do DTO e da Entity; e recuperando as chaves primarias
         (
             ast_dto_attributes,
@@ -299,7 +361,22 @@ class EDLCompiler:
         compiler_result.dto_code = dto_code
         compiler_result.relations_dependencies = relations_dependencies_complete
         compiler_result.insert_function_class_name = insert_output.class_name
+        compiler_result.insert_function_name = insert_output.function_name
         compiler_result.update_function_class_name = update_output.class_name
+        compiler_result.update_function_name = update_output.function_name
+        compiler_result.get_function_name = get_function_name
+        compiler_result.list_function_name = list_function_name
+        compiler_result.delete_function_name = delete_function_name
+        compiler_result.get_function_type_class_name = get_function_type_class
+        compiler_result.list_function_type_class_name = list_function_type_class
+        compiler_result.delete_function_type_class_name = delete_function_type_class
+        compiler_result.source_get_function_type = get_function_code.strip() or None
+        compiler_result.source_list_function_type = (
+            list_function_code.strip() or None
+        )
+        compiler_result.source_delete_function_type = (
+            delete_function_code.strip() or None
+        )
 
         insert_code_compiled = insert_function_code.strip()
         update_code_compiled = update_function_code.strip()

nsj_rest_lib2/compiler/function_get_delete_compiler.py

@@ -0,0 +1,238 @@
+from __future__ import annotations
+
+from typing import Optional
+
+from nsj_rest_lib2.compiler.compiler_structures import PropertiesCompilerStructure
+from nsj_rest_lib2.compiler.edl_model.api_model import HandlerConfig, HandlerMapping
+from nsj_rest_lib2.compiler.edl_model.entity_model_base import EntityModelBase
+from nsj_rest_lib2.compiler.edl_model.primitives import PrimitiveTypes
+from nsj_rest_lib2.compiler.function_model import FunctionCompilationOutput
+from nsj_rest_lib2.compiler.util.str_util import CompilerStrUtil
+from nsj_rest_lib2.compiler.util.type_naming_util import compile_function_class_name
+from nsj_rest_lib2.compiler.util.type_util import TypeUtil
+
+
+class FunctionGetDeleteCompiler:
+    """
+    Responsável por gerar FunctionTypes (Get/List/Delete) baseados no
+    binding de pg_function declarado no EDL.
+    """
+
+    def compile(
+        self,
+        entity_model: EntityModelBase,
+        properties_structure: PropertiesCompilerStructure,
+        handler_config: Optional[HandlerConfig],
+        prefx_class_name: str,
+        verb: str,
+    ) -> FunctionCompilationOutput:
+        if not isinstance(handler_config, HandlerConfig):
+            return FunctionCompilationOutput()
+        if handler_config.impl != "pg_function":
+            return FunctionCompilationOutput()
+        if not handler_config.call or not handler_config.call.arg_binding:
+            return FunctionCompilationOutput()
+
+        arg_binding = handler_config.call.arg_binding
+        if not arg_binding.mapping or not arg_binding.type_name:
+            return FunctionCompilationOutput()
+
+        function_name = handler_config.function_ref
+        if not function_name:
+            return FunctionCompilationOutput()
+
+        class_name = compile_function_class_name(
+            entity_model.id,
+            prefx_class_name,
+            [],
+            verb,
+        )
+
+        fields = self._build_fields(arg_binding.mapping, properties_structure)
+        if not fields:
+            return FunctionCompilationOutput()
+
+        code = self._build_code(class_name, arg_binding.type_name, fields, verb)
+
+        return FunctionCompilationOutput(
+            class_name=class_name,
+            code=code,
+            function_name=function_name,
+        )
+
+    # ------------------------------------------------------------------ #
+    # Helpers
+    # ------------------------------------------------------------------ #
+
+    def _build_fields(
+        self,
+        mappings: list[HandlerMapping],
+        properties_structure: PropertiesCompilerStructure,
+    ) -> list[tuple[str, str, Optional[str], bool]]:
+        """
+        Retorna lista de tuplas:
+        (python_name, annotation, type_field_name, is_pk)
+        """
+        fields: list[tuple[str, str, Optional[str], bool]] = []
+        used: set[str] = set()
+
+        for entry in mappings or []:
+            attr = (entry.attr or "").strip()
+            if not attr:
+                continue
+
+            python_name = self._sanitize_identifier(attr)
+            if python_name in used:
+                continue
+            used.add(python_name)
+
+            type_field_name = attr if python_name != attr else None
+            source = (entry.from_ or "").strip()
+            is_pk = source.startswith("path.")
+
+            annotation = self._resolve_annotation(entry, properties_structure)
+
+            fields.append(
+                (
+                    python_name,
+                    annotation,
+                    type_field_name,
+                    is_pk,
+                )
+            )
+
+        return fields
+
+    def _resolve_annotation(
+        self,
+        entry: HandlerMapping,
+        properties_structure: PropertiesCompilerStructure,
+    ) -> str:
+        """
+        Tenta inferir o tipo a partir das propriedades da entidade.
+        Prioriza:
+        - campos referenciados como body.<campo>;
+        - ou, se o último segmento de 'from' (após o '.') existir como
+          property do EDL, usa esse nome para lookup.
+        """
+        dto_field = self._extract_dto_field(entry.from_)
+
+        # Se não veio de body.*, tenta casar o último segmento de 'from'
+        # com o nome de alguma propriedade do EDL.
+        if not dto_field:
+            candidate = CompilerStrUtil.to_snake_case(
+                (entry.from_ or "").split(".")[-1]
+            )
+            if candidate and properties_structure and candidate in properties_structure.properties:
+                dto_field = candidate
+
+        if not dto_field:
+            return "Any"
+
+        prop = (
+            properties_structure.properties.get(dto_field)
+            if properties_structure
+            else None
+        )
+        if not prop or not isinstance(prop.type, PrimitiveTypes):
+            return "Any"
+
+        return TypeUtil.property_type_to_python_type(prop.type)
+
+    def _build_code(
+        self,
+        class_name: str,
+        type_name: str,
+        fields: list[tuple[str, str, Optional[str], bool]],
+        verb: str,
+    ) -> str:
+        needs_any = any(annotation == "Any" for _, annotation, _, _ in fields)
+        needs_uuid = any(annotation == "uuid.UUID" for _, annotation, _, _ in fields)
+        needs_datetime = any(
+            annotation == "datetime.datetime" for _, annotation, _, _ in fields
+        )
+
+        lines: list[str] = []
+        if needs_uuid:
+            lines.append("import uuid")
+        if needs_datetime:
+            lines.append("import datetime")
+        if needs_any:
+            lines.append("from typing import Any")
+
+        decorator_module, decorator_name, base_class = self._resolve_decorator(verb)
+        lines.extend(
+            [
+                f"from {decorator_module} import {decorator_name}",
+                f"from nsj_rest_lib.entity.function_type_base import {base_class}",
+                "from nsj_rest_lib.descriptor.function_field import FunctionField",
+                "",
+                f"@{decorator_name}(type_name=\"{type_name}\")",
+                f"class {class_name}({base_class}):",
+            ]
+        )
+
+        for name, annotation, type_field_name, is_pk in fields:
+            kwargs: list[str] = []
+            if type_field_name:
+                kwargs.append(f'type_field_name="{type_field_name}"')
+            if is_pk:
+                kwargs.append("pk=True")
+            kwargs_str = ", ".join(kwargs)
+            if kwargs_str:
+                kwargs_str = ", " + kwargs_str
+            lines.append(
+                f"    {name}: {annotation} = FunctionField({kwargs_str.lstrip(', ')})"
+            )
+
+        if not fields:
+            lines.append("    pass")
+
+        lines.append("")  # newline final
+        return "\n".join(lines)
+
+    def _resolve_decorator(self, verb: str) -> tuple[str, str, str]:
+        verb = (verb or "").lower()
+        if verb == "get":
+            return (
+                "nsj_rest_lib.decorator.get_function_type",
+                "GetFunctionType",
+                "GetFunctionTypeBase",
+            )
+        if verb == "list":
+            return (
+                "nsj_rest_lib.decorator.list_function_type",
+                "ListFunctionType",
+                "ListFunctionTypeBase",
+            )
+        if verb == "delete":
+            return (
+                "nsj_rest_lib.decorator.delete_function_type",
+                "DeleteFunctionType",
+                "DeleteFunctionTypeBase",
+            )
+        # fallback genérico
+        return (
+            "nsj_rest_lib.decorator.function_type",
+            "FunctionType",
+            "FunctionTypeBase",
+        )
+
+    def _sanitize_identifier(self, name: str) -> str:
+        candidate = CompilerStrUtil.to_snake_case(name)
+        candidate = "".join(ch if ch.isalnum() or ch == "_" else "_" for ch in candidate)
+        if not candidate:
+            candidate = "field"
+        if candidate[0].isdigit():
+            candidate = f"_{candidate}"
+        return candidate
+
+    def _extract_dto_field(self, source: Optional[str]) -> Optional[str]:
+        if not source:
+            return None
+
+        if source.startswith("body."):
+            segment = source[5:].split(".", 1)[0]
+            return CompilerStrUtil.to_snake_case(segment)
+
+        return None

nsj_rest_lib2/compiler/{function_compiler.py → function_insert_update_compiler.py}

@@ -50,7 +50,7 @@ class _ClassSpec:
     children: list["_ClassSpec"] = field(default_factory=list)
 
 
-class FunctionCompiler:
+class FunctionInsertUpdateCompiler:
     """
     Responsável por compilar tipos usados por funções de banco (Insert/Update)
     com base na configuração declarada no EDL.
@@ -156,6 +156,7 @@ class FunctionCompiler:
         return FunctionCompilationOutput(
             class_name=class_name,
             code=code,
+            function_name=function_name,
             field_bindings=field_bindings,
             relation_bindings=relation_bindings,
         )
@@ -333,9 +334,6 @@ class FunctionCompiler:
             args=[],
             keywords=[
                 ast.keyword(arg="type_name", value=ast.Constant(value=spec.type_name)),
-                ast.keyword(
-                    arg="function_name", value=ast.Constant(value=spec.function_name)
-                ),
             ],
         )
 

nsj_rest_lib2/compiler/function_model.py

@@ -64,6 +64,7 @@ class FunctionCompilationOutput:
 
     class_name: Optional[str] = None
     code: Optional[str] = None
+    function_name: Optional[str] = None
     field_bindings: Dict[str, str] = field(default_factory=dict)
     relation_bindings: Dict[str, FunctionRelationBinding] = field(
         default_factory=dict

nsj_rest_lib2/compiler/model.py

@@ -44,6 +44,17 @@ class CompilerResult:
         self.api_verbs: list[str] | None = None
         self.relations_dependencies: list[RelationDependency] | None = None
         self.insert_function_class_name: str | None = None
+        self.insert_function_name: str | None = None
         self.source_insert_function: str | None = None
         self.update_function_class_name: str | None = None
+        self.update_function_name: str | None = None
         self.source_update_function: str | None = None
+        self.get_function_name: str | None = None
+        self.list_function_name: str | None = None
+        self.delete_function_name: str | None = None
+        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.source_get_function_type: str | None = None
+        self.source_list_function_type: str | None = None
+        self.source_delete_function_type: str | None = None

nsj_rest_lib2/compiler/util/type_naming_util.py

@@ -33,7 +33,17 @@ def compile_function_class_name(
     incorporando o caminho dos relacionamentos (quando houver).
     """
 
-    suffix = "InsertType" if operation == "insert" else "UpdateType"
+    operation = (operation or "").lower()
+    suffix_map = {
+        "insert": "InsertType",
+        "update": "UpdateType",
+        "get": "GetType",
+        "list": "ListType",
+        "delete": "DeleteType",
+    }
+    suffix = suffix_map.get(
+        operation, f"{CompilerStrUtil.to_pascal_case(operation)}Type"
+    )
     path_suffix = "".join(CompilerStrUtil.to_pascal_case(part) for part in path_parts)
     return (
         f"{CompilerStrUtil.to_pascal_case(prefx_class_name)}"
@@ -41,3 +51,30 @@ def compile_function_class_name(
         f"{path_suffix}"
         f"{suffix}"
     )
+
+
+def compile_function_params_dto_class_name(
+    entity_id: str,
+    prefx_class_name: str,
+    verb: str,
+) -> str:
+    """
+    Gera o nome da classe DTO usada como envelope de parâmetros para funções
+    de GET, LIST e DELETE.
+    """
+
+    verb = (verb or "").lower()
+    if verb == "get":
+        suffix = "GetParamsDTO"
+    elif verb == "list":
+        suffix = "ListParamsDTO"
+    elif verb == "delete":
+        suffix = "DeleteParamsDTO"
+    else:
+        suffix = f"{CompilerStrUtil.to_pascal_case(verb)}ParamsDTO"
+
+    return (
+        f"{CompilerStrUtil.to_pascal_case(prefx_class_name)}"
+        f"{CompilerStrUtil.to_pascal_case(entity_id)}"
+        f"{suffix}"
+    )

nsj_rest_lib2/controller/dynamic_controller.py

@@ -96,6 +96,14 @@ def setup_dynamic_routes(
                     api_verbs,
                     _insert_function_class_name,
                     _update_function_class_name,
+                    _insert_function_name,
+                    _update_function_name,
+                    _get_function_name,
+                    list_function_name,
+                    _delete_function_name,
+                    _get_function_type_class_name,
+                    list_function_type_class_name,
+                    _delete_function_type_class_name,
                 ) = entity_loader.load_entity_source(
                     entity_resource,
                     tenant,
@@ -115,6 +123,10 @@ def setup_dynamic_routes(
                     dto_class=etities_dict[dto_class_name],
                     entity_class=etities_dict[entity_class_name],
                     injector_factory=injector_factory,
+                    list_function_name=list_function_name,
+                    list_function_type_class=etities_dict.get(
+                        list_function_type_class_name
+                    ),
                 )
 
                 return route.handle_request(*args, **kwargs)
@@ -152,6 +164,14 @@ def setup_dynamic_routes(
                     api_verbs,
                     _insert_function_class_name,
                     _update_function_class_name,
+                    _insert_function_name,
+                    _update_function_name,
+                    get_function_name,
+                    _list_function_name,
+                    _delete_function_name,
+                    get_function_type_class_name,
+                    _list_function_type_class_name,
+                    _delete_function_type_class_name,
                 ) = entity_loader.load_entity_source(
                     entity_resource,
                     tenant,
@@ -171,6 +191,10 @@ def setup_dynamic_routes(
                     dto_class=etities_dict[dto_class_name],
                     entity_class=etities_dict[entity_class_name],
                     injector_factory=injector_factory,
+                    get_function_name=get_function_name,
+                    get_function_type_class=etities_dict.get(
+                        get_function_type_class_name
+                    ),
                 )
 
                 return route.handle_request(*args, **kwargs)
@@ -207,6 +231,14 @@ def setup_dynamic_routes(
                     api_verbs,
                     insert_function_class_name,
                     _update_function_class_name,
+                    insert_function_name,
+                    _update_function_name,
+                    _get_function_name,
+                    _list_function_name,
+                    _delete_function_name,
+                    _get_function_type_class_name,
+                    _list_function_type_class_name,
+                    _delete_function_type_class_name,
                 ) = entity_loader.load_entity_source(
                     entity_resource,
                     tenant,
@@ -233,6 +265,7 @@ def setup_dynamic_routes(
                     entity_class=etities_dict[entity_class_name],
                     injector_factory=injector_factory,
                     insert_function_type_class=insert_function_type_class,
+                    insert_function_name=insert_function_name,
                 )
 
                 return route.handle_request(*args, **kwargs)
@@ -269,6 +302,14 @@ def setup_dynamic_routes(
                     api_verbs,
                     _insert_function_class_name,
                     update_function_class_name,
+                    _insert_function_name,
+                    update_function_name,
+                    _get_function_name,
+                    _list_function_name,
+                    _delete_function_name,
+                    _get_function_type_class_name,
+                    _list_function_type_class_name,
+                    _delete_function_type_class_name,
                 ) = entity_loader.load_entity_source(
                     entity_resource,
                     tenant,
@@ -295,6 +336,7 @@ def setup_dynamic_routes(
                     entity_class=etities_dict[entity_class_name],
                     injector_factory=injector_factory,
                     update_function_type_class=update_function_type_class,
+                    update_function_name=update_function_name,
                 )
 
                 return route.handle_request(*args, **kwargs)
@@ -331,6 +373,11 @@ def setup_dynamic_routes(
                     api_verbs,
                     _insert_function_class_name,
                     _update_function_class_name,
+                    _insert_function_name,
+                    _update_function_name,
+                    _get_function_name,
+                    _list_function_name,
+                    _delete_function_name,
                 ) = entity_loader.load_entity_source(
                     entity_resource,
                     tenant,
@@ -386,6 +433,14 @@ def setup_dynamic_routes(
                     api_verbs,
                     _insert_function_class_name,
                     _update_function_class_name,
+                    _insert_function_name,
+                    _update_function_name,
+                    _get_function_name,
+                    _list_function_name,
+                    delete_function_name,
+                    _get_function_type_class_name,
+                    _list_function_type_class_name,
+                    delete_function_type_class_name,
                 ) = entity_loader.load_entity_source(
                     entity_resource,
                     tenant,
@@ -405,6 +460,10 @@ def setup_dynamic_routes(
                     dto_class=etities_dict[dto_class_name],
                     entity_class=etities_dict[entity_class_name],
                     injector_factory=injector_factory,
+                    delete_function_name=delete_function_name,
+                    delete_function_type_class=etities_dict.get(
+                        delete_function_type_class_name
+                    ),
                 )
 
                 return route.handle_request(*args, **kwargs)

nsj_rest_lib2/service/entity_config_writer.py

@@ -71,9 +71,20 @@ class EntityConfigWriter:
             "dto_class_name": compiler_result.dto_class_name,
             "entity_class_name": compiler_result.entity_class_name,
             "insert_function_class_name": compiler_result.insert_function_class_name,
+            "insert_function_name": compiler_result.insert_function_name,
             "source_insert_function": compiler_result.source_insert_function,
             "update_function_class_name": compiler_result.update_function_class_name,
+            "update_function_name": compiler_result.update_function_name,
             "source_update_function": compiler_result.source_update_function,
+            "get_function_name": compiler_result.get_function_name,
+            "list_function_name": compiler_result.list_function_name,
+            "delete_function_name": compiler_result.delete_function_name,
+            "get_function_type_class_name": compiler_result.get_function_type_class_name,
+            "list_function_type_class_name": compiler_result.list_function_type_class_name,
+            "delete_function_type_class_name": compiler_result.delete_function_type_class_name,
+            "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,
             "source_dto": compiler_result.dto_code,
             "source_entity": compiler_result.entity_code,
             "entity_hash": entity_hash
@@ -120,8 +131,16 @@ class EntityConfigWriter:
         for content in self._iter_hash_chunks(
             compiler_result.dto_code,
             compiler_result.entity_code,
+            compiler_result.insert_function_name,
+            compiler_result.update_function_name,
+            compiler_result.get_function_name,
+            compiler_result.list_function_name,
+            compiler_result.delete_function_name,
             compiler_result.source_insert_function,
             compiler_result.source_update_function,
+            compiler_result.source_get_function_type,
+            compiler_result.source_list_function_type,
+            compiler_result.source_delete_function_type,
         ):
             hasher.update(content)
 

nsj_rest_lib2/service/entity_loader.py

@@ -26,6 +26,14 @@ class LoadedEntity:
         self.relations_dependencies: list[RelationDependency] = []
         self.insert_function_class_name: str | None = None
         self.update_function_class_name: str | None = None
+        self.insert_function_name: str | None = None
+        self.update_function_name: str | None = None
+        self.get_function_name: str | None = None
+        self.list_function_name: str | None = None
+        self.delete_function_name: str | None = None
+        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
 
 
 class Namespace:
@@ -50,7 +58,23 @@ class EntityLoader:
         grupo_empresarial: str | None,
         escopo: str = ESCOPO_RESTLIB2,
         force_reload: bool = False,
-    ) -> tuple[str, str, dict, bool, list[str], str | None, str | None]:
+    ) -> tuple[
+        str,
+        str,
+        dict,
+        bool,
+        list[str],
+        str | None,
+        str | None,
+        str | None,
+        str | None,
+        str | None,
+        str | None,
+        str | None,
+        str | None,
+        str | None,
+        str | None,
+    ]:
         # Assumind o escopo default se necessário
         if not escopo:
             escopo = ESCOPO_RESTLIB2
@@ -81,6 +105,20 @@ class EntityLoader:
             relations_dependencies = loaded_entity.relations_dependencies
             insert_function_class_name = loaded_entity.insert_function_class_name
             update_function_class_name = loaded_entity.update_function_class_name
+            insert_function_name = loaded_entity.insert_function_name
+            update_function_name = loaded_entity.update_function_name
+            get_function_name = loaded_entity.get_function_name
+            list_function_name = loaded_entity.list_function_name
+            delete_function_name = loaded_entity.delete_function_name
+            get_function_type_class_name = (
+                loaded_entity.get_function_type_class_name
+            )
+            list_function_type_class_name = (
+                loaded_entity.list_function_type_class_name
+            )
+            delete_function_type_class_name = (
+                loaded_entity.delete_function_type_class_name
+            )
 
             # Verificando se alguma de suas dependências precisariam ser recarregadas
             for rd in relations_dependencies:
@@ -128,6 +166,14 @@ class EntityLoader:
                         api_verbs,
                         insert_function_class_name,
                         update_function_class_name,
+                        insert_function_name,
+                        update_function_name,
+                        get_function_name,
+                        list_function_name,
+                        delete_function_name,
+                        get_function_type_class_name,
+                        list_function_type_class_name,
+                        delete_function_type_class_name,
                     )
 
                 # Desempacotando resultado
@@ -151,6 +197,14 @@ class EntityLoader:
                         api_verbs,
                         insert_function_class_name,
                         update_function_class_name,
+                        insert_function_name,
+                        update_function_name,
+                        get_function_name,
+                        list_function_name,
+                        delete_function_name,
+                        get_function_type_class_name,
+                        list_function_type_class_name,
+                        delete_function_type_class_name,
                     )
                 else:
                     (
@@ -159,6 +213,16 @@ class EntityLoader:
                         namespace,
                         api_expose,
                         api_verbs,
+                        insert_function_class_name,
+                        update_function_class_name,
+                        insert_function_name,
+                        update_function_name,
+                        get_function_name,
+                        list_function_name,
+                        delete_function_name,
+                        get_function_type_class_name,
+                        list_function_type_class_name,
+                        delete_function_type_class_name,
                     ) = result_execute
                     return (
                         dto_class_name,
@@ -166,6 +230,16 @@ class EntityLoader:
                         namespace.entities_dict,
                         api_expose,
                         api_verbs,
+                        insert_function_class_name,
+                        update_function_class_name,
+                        insert_function_name,
+                        update_function_name,
+                        get_function_name,
+                        list_function_name,
+                        delete_function_name,
+                        get_function_type_class_name,
+                        list_function_type_class_name,
+                        delete_function_type_class_name,
                     )
             else:
                 # Se não deu o intervalo de verificação do refresh, retorna o que está em memória
@@ -177,6 +251,14 @@ class EntityLoader:
                     api_verbs,
                     insert_function_class_name,
                     update_function_class_name,
+                    insert_function_name,
+                    update_function_name,
+                    get_function_name,
+                    list_function_name,
+                    delete_function_name,
+                    get_function_type_class_name,
+                    list_function_type_class_name,
+                    delete_function_type_class_name,
                 )
 
         # Se não conseguir recuperar a entidade, procura no redis:
@@ -213,6 +295,14 @@ class EntityLoader:
             api_verbs,
             insert_function_class_name,
             update_function_class_name,
+            insert_function_name,
+            update_function_name,
+            get_function_name,
+            list_function_name,
+            delete_function_name,
+            get_function_type_class_name,
+            list_function_type_class_name,
+            delete_function_type_class_name,
         ) = result_execute
 
         return (
@@ -223,6 +313,14 @@ class EntityLoader:
             api_verbs,
             insert_function_class_name,
             update_function_class_name,
+            insert_function_name,
+            update_function_name,
+            get_function_name,
+            list_function_name,
+            delete_function_name,
+            get_function_type_class_name,
+            list_function_type_class_name,
+            delete_function_type_class_name,
         )
 
     def clear_namespaces(self):
@@ -253,7 +351,23 @@ class EntityLoader:
         entity_config_key: str,
         entity_resource: str,
         check_refresh: bool = False,
-    ) -> tuple[str, str, Namespace, bool, list[str], str | None, str | None] | None:
+    ) -> tuple[
+        str,
+        str,
+        Namespace,
+        bool,
+        list[str],
+        str | None,
+        str | None,
+        str | None,
+        str | None,
+        str | None,
+        str | None,
+        str | None,
+        str | None,
+        str | None,
+        str | None,
+    ] | None:
         # Interpretando o json de configuração da entidade
         try:
             entity_config = json.loads(entity_config_str)
@@ -270,11 +384,28 @@ class EntityLoader:
             insert_function_class_name = entity_config.get(
                 "insert_function_class_name"
             )
+            insert_function_name = entity_config.get("insert_function_name")
             insert_function_code = entity_config.get("source_insert_function")
             update_function_class_name = entity_config.get(
                 "update_function_class_name"
             )
+            update_function_name = entity_config.get("update_function_name")
             update_function_code = entity_config.get("source_update_function")
+            get_function_name = entity_config.get("get_function_name")
+            list_function_name = entity_config.get("list_function_name")
+            delete_function_name = entity_config.get("delete_function_name")
+            get_function_type_class_name = entity_config.get(
+                "get_function_type_class_name"
+            )
+            list_function_type_class_name = entity_config.get(
+                "list_function_type_class_name"
+            )
+            delete_function_type_class_name = entity_config.get(
+                "delete_function_type_class_name"
+            )
+            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")
             relations_dependencies = [
                 RelationDependency().from_dict(rd)
                 for rd in entity_config.get("relations_dependencies", [])
@@ -371,6 +502,27 @@ class EntityLoader:
                     "Update Function source",
                 )
 
+            if get_function_code:
+                self._safe_exec(
+                    get_function_code,
+                    namespace.entities_dict,
+                    "Get FunctionType source",
+                )
+
+            if list_function_code:
+                self._safe_exec(
+                    list_function_code,
+                    namespace.entities_dict,
+                    "List FunctionType source",
+                )
+
+            if delete_function_code:
+                self._safe_exec(
+                    delete_function_code,
+                    namespace.entities_dict,
+                    "Delete FunctionType source",
+                )
+
             self._safe_exec(source_entity, namespace.entities_dict, "Entity source")
             self._safe_exec(source_dto, namespace.entities_dict, "DTO source")
 
@@ -384,6 +536,20 @@ class EntityLoader:
             loaded_entity.relations_dependencies = relations_dependencies
             loaded_entity.insert_function_class_name = insert_function_class_name
             loaded_entity.update_function_class_name = update_function_class_name
+            loaded_entity.insert_function_name = insert_function_name
+            loaded_entity.update_function_name = update_function_name
+            loaded_entity.get_function_name = get_function_name
+            loaded_entity.list_function_name = list_function_name
+            loaded_entity.delete_function_name = delete_function_name
+            loaded_entity.get_function_type_class_name = (
+                get_function_type_class_name
+            )
+            loaded_entity.list_function_type_class_name = (
+                list_function_type_class_name
+            )
+            loaded_entity.delete_function_type_class_name = (
+                delete_function_type_class_name
+            )
 
             namespace.loaded_entities[entity_resource] = loaded_entity
 
@@ -395,6 +561,14 @@ class EntityLoader:
             api_verbs,
             insert_function_class_name,
             update_function_class_name,
+            insert_function_name,
+            update_function_name,
+            get_function_name,
+            list_function_name,
+            delete_function_name,
+            get_function_type_class_name,
+            list_function_type_class_name,
+            delete_function_type_class_name,
         )
 
     def _safe_exec(self, source_code, context, description):

{nsj_rest_lib2-0.0.31.dist-info → nsj_rest_lib2-0.0.32.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nsj_rest_lib2
-Version: 0.0.31
+Version: 0.0.32
 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.31.dist-info → nsj_rest_lib2-0.0.32.dist-info}/RECORD

@@ -3,17 +3,18 @@ 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=dDH3WXEaWg6eg95Bix1ZMY_fuB3prgps8xsevw9wYE4,30915
+nsj_rest_lib2/compiler/compiler.py,sha256=f62qzh3R9oC9JJ0pkaHJwVyhM0MEwhZDs_q7MzdDlxw,34467
 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/entity_compiler.py,sha256=LeGEBxsjAmZZog2gh4vjUX1aFp9JSVgHHOdTkY0aH-s,6733
-nsj_rest_lib2/compiler/function_compiler.py,sha256=t5e_NoDB0IckiIEuYLsvk2lPSwrcrjL91s4LTQkpRqA,18085
-nsj_rest_lib2/compiler/function_model.py,sha256=iSKMlCSZDWlP_aTdlcbYQhsEAIMH-XbSJUU0-KNtLCs,2066
+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
+nsj_rest_lib2/compiler/function_model.py,sha256=Wfo6wWfEwazvNGyf2I8W60N5GOBugIWboj0wdE6zmes,2106
 nsj_rest_lib2/compiler/migration_compiler.py,sha256=vlG54XmYRqzIo0Iey-4HbSRzPg3Ylp5kpWWCGFAVzx8,29023
 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=8UxzTvcNgZQdLwC592o8ZMVPhG3AloBCg5q2V72Up8U,1688
+nsj_rest_lib2/compiler/model.py,sha256=hmL9ItHGTX4sNZbAYCzVdZnX8JYb_MjG1PtuaQQ2hsA,2310
 nsj_rest_lib2/compiler/property_compiler.py,sha256=hMQX5vrLqjOEM_wdzuerxuARMq5JhZQ_R8cUVoLHNNM,47631
 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
@@ -30,14 +31,14 @@ 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=fPyzsEsbG9sgzaUJghamijcmZ6Odh_rIv3zk-lcP5pQ,1419
+nsj_rest_lib2/compiler/util/type_naming_util.py,sha256=jYUnr3eC6ewwhIAFHF89OOLoSH9aO_syHMF66AsWX3s,2355
 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=UJtlr0_A6bGJ1gD24oj3481tCbJUgshLFuBRIU-eDEs,18878
+nsj_rest_lib2/controller/dynamic_controller.py,sha256=y9bSGJdQ-mIIkDneY0nRFfmivPOzDbeGFxFU9J3pQTk,21642
 nsj_rest_lib2/service/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nsj_rest_lib2/service/entity_config_writer.py,sha256=DC8M4BYKfaOkNty1YFmAmWiNvENjvmiUqDKgsAV3eNc,4688
-nsj_rest_lib2/service/entity_loader.py,sha256=I8Ua2CPCxxUovHJn8SSRz0bYfmdFqfWj-JQfNTBBypc,17842
-nsj_rest_lib2-0.0.31.dist-info/METADATA,sha256=I1o7yO3ACZoRB6Qnw1qRhegqWBv5_MoK_f-VgIppAcM,1094
-nsj_rest_lib2-0.0.31.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-nsj_rest_lib2-0.0.31.dist-info/top_level.txt,sha256=L6zh0EfH8_rur7OJ8_V-El-XEMf4qg3bkF8ADgqLVIA,14
-nsj_rest_lib2-0.0.31.dist-info/RECORD,,
+nsj_rest_lib2/service/entity_config_writer.py,sha256=4pLNqyw2asTiiuxNwYnH69eLLABa9GfrgD_GxS6vJ18,5991
+nsj_rest_lib2/service/entity_loader.py,sha256=65qa_45tPAQWU6G_vsG9Gy4d9OksYT2yyyr137zrWb0,24812
+nsj_rest_lib2-0.0.32.dist-info/METADATA,sha256=Jw_r7sNxYeJKtk46OthJwrqHvH-pbqTmE37JKHSlFNg,1094
+nsj_rest_lib2-0.0.32.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+nsj_rest_lib2-0.0.32.dist-info/top_level.txt,sha256=L6zh0EfH8_rur7OJ8_V-El-XEMf4qg3bkF8ADgqLVIA,14
+nsj_rest_lib2-0.0.32.dist-info/RECORD,,