nsj-rest-lib2 0.0.31__tar.gz → 0.0.33__tar.gz

{nsj_rest_lib2-0.0.31 → nsj_rest_lib2-0.0.33}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nsj_rest_lib2
-Version: 0.0.31
+Version: 0.0.33
 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
@@ -12,7 +12,7 @@ Classifier: Topic :: Software Development :: Libraries
 Classifier: Programming Language :: Python :: 3
 Requires-Python: >=3.4
 Description-Content-Type: text/markdown
-Requires-Dist: nsj-rest-lib<6.0.0,>=5.1.3
+Requires-Dist: nsj-rest-lib<7.0.0,>=5.1.3
 Requires-Dist: redis<7.0.0,>=6.4.0
 Requires-Dist: nsj-multi-database-lib<3.0.0,>=2.0.1
 Requires-Dist: pydantic<3.0.0,>=2.11.9

{nsj_rest_lib2-0.0.31 → nsj_rest_lib2-0.0.33}/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-0.0.33/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-0.0.31/nsj_rest_lib2/compiler/function_compiler.py → nsj_rest_lib2-0.0.33/nsj_rest_lib2/compiler/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-0.0.31 → nsj_rest_lib2-0.0.33}/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-0.0.31 → nsj_rest_lib2-0.0.33}/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-0.0.31 → nsj_rest_lib2-0.0.33}/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-0.0.31 → nsj_rest_lib2-0.0.33}/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-0.0.31 → nsj_rest_lib2-0.0.33}/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-0.0.31 → nsj_rest_lib2-0.0.33}/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 → nsj_rest_lib2-0.0.33}/nsj_rest_lib2.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nsj_rest_lib2
-Version: 0.0.31
+Version: 0.0.33
 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
@@ -12,7 +12,7 @@ Classifier: Topic :: Software Development :: Libraries
 Classifier: Programming Language :: Python :: 3
 Requires-Python: >=3.4
 Description-Content-Type: text/markdown
-Requires-Dist: nsj-rest-lib<6.0.0,>=5.1.3
+Requires-Dist: nsj-rest-lib<7.0.0,>=5.1.3
 Requires-Dist: redis<7.0.0,>=6.4.0
 Requires-Dist: nsj-multi-database-lib<3.0.0,>=2.0.1
 Requires-Dist: pydantic<3.0.0,>=2.11.9

{nsj_rest_lib2-0.0.31 → nsj_rest_lib2-0.0.33}/nsj_rest_lib2.egg-info/SOURCES.txt

@@ -15,7 +15,8 @@ setup.cfg
 ./nsj_rest_lib2/compiler/compiler_structures.py
 ./nsj_rest_lib2/compiler/dto_compiler.py
 ./nsj_rest_lib2/compiler/entity_compiler.py
-./nsj_rest_lib2/compiler/function_compiler.py
+./nsj_rest_lib2/compiler/function_get_delete_compiler.py
+./nsj_rest_lib2/compiler/function_insert_update_compiler.py
 ./nsj_rest_lib2/compiler/function_model.py
 ./nsj_rest_lib2/compiler/migration_compiler.py
 ./nsj_rest_lib2/compiler/migration_compiler_alter_table.py
@@ -59,7 +60,8 @@ nsj_rest_lib2/compiler/compiler.py
 nsj_rest_lib2/compiler/compiler_structures.py
 nsj_rest_lib2/compiler/dto_compiler.py
 nsj_rest_lib2/compiler/entity_compiler.py
-nsj_rest_lib2/compiler/function_compiler.py
+nsj_rest_lib2/compiler/function_get_delete_compiler.py
+nsj_rest_lib2/compiler/function_insert_update_compiler.py
 nsj_rest_lib2/compiler/function_model.py
 nsj_rest_lib2/compiler/migration_compiler.py
 nsj_rest_lib2/compiler/migration_compiler_alter_table.py
@@ -89,4 +91,5 @@ nsj_rest_lib2/controller/dynamic_controller.py
 nsj_rest_lib2/service/__init__.py
 nsj_rest_lib2/service/entity_config_writer.py
 nsj_rest_lib2/service/entity_loader.py
+tests/test_function_handler_compilation.py
 tests/test_migration_generation.py

{nsj_rest_lib2-0.0.31 → nsj_rest_lib2-0.0.33}/nsj_rest_lib2.egg-info/requires.txt

@@ -1,4 +1,4 @@
-nsj-rest-lib<6.0.0,>=5.1.3
+nsj-rest-lib<7.0.0,>=5.1.3
 redis<7.0.0,>=6.4.0
 nsj-multi-database-lib<3.0.0,>=2.0.1
 pydantic<3.0.0,>=2.11.9

{nsj_rest_lib2-0.0.31 → nsj_rest_lib2-0.0.33}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = nsj_rest_lib2
-version = 0.0.31
+version = 0.0.33
 author = Nasajon Sistemas
 author_email = contact.dev@nasajon.com.br
 description = Biblioteca para permitir a distribuição de rotas dinâmicas numa API, configuradas por meio de EDLs declarativos (em formato JSON).
@@ -21,7 +21,7 @@ package_dir =
 packages = find:
 python_requires = >=3.4
 install_requires = 
-	nsj-rest-lib>=5.1.3,<6.0.0
+	nsj-rest-lib>=5.1.3,<7.0.0
 	redis>=6.4.0,<7.0.0
 	nsj-multi-database-lib>=2.0.1,<3.0.0
 	pydantic>=2.11.9,<3.0.0

nsj_rest_lib2-0.0.33/tests/test_function_handler_compilation.py

@@ -0,0 +1,152 @@
+import json
+import os
+import sys
+from pathlib import Path
+
+ROOT_DIR = Path(__file__).resolve().parents[1]
+if str(ROOT_DIR) not in sys.path:
+    sys.path.insert(0, str(ROOT_DIR))
+
+os.environ.setdefault("ESCOPO_RESTLIB2", "test-scope")
+
+from nsj_rest_lib2.compiler.compiler import EDLCompiler
+from nsj_rest_lib2.compiler.edl_model.entity_model import EntityModel
+from nsj_rest_lib2.compiler.edl_model.entity_model_root import EntityModelRoot
+from nsj_rest_lib2.compiler.util.type_naming_util import (
+    compile_function_class_name,
+)
+
+
+def _load_entity(path: Path):
+    with path.open("r") as fp:
+        edl_data = json.load(fp)
+
+    model = (
+        EntityModelRoot(**edl_data)
+        if edl_data.get("mixin", False)
+        else EntityModel(**edl_data)
+    )
+    complete_id = f"{model.escopo}/{model.id}"
+    return complete_id, model
+
+
+def _load_entity_models(base_dir: Path) -> dict[str, EntityModel]:
+    models: dict[str, EntityModel] = {}
+    for path in base_dir.iterdir():
+        if path.suffix.lower() != ".json":
+            continue
+        key, model = _load_entity(path)
+        models[key] = model
+    return models
+
+
+def test_compile_handlers_for_classificacao_financeira_generates_delete_function_type():
+    base_dir = ROOT_DIR / "@schemas_test"
+    entity_models = _load_entity_models(base_dir)
+
+    model_key = "financas/ClassificacaoFinanceira"
+    entity_model = entity_models[model_key]
+
+    compiler = EDLCompiler()
+    result = compiler.compile_model(entity_model, list(entity_models.items()))
+
+    assert result is not None
+
+    # Nomes das funções de banco para post/put/delete
+    assert result.insert_function_name == "financas.api_classificacaofinanceiranovo"
+    assert result.update_function_name == "financas.api_classificacaofinanceiraalterar"
+    assert result.delete_function_name == "financas.api_classificacaofinanceiraexcluir"
+
+    # FunctionType para delete
+    delete_code = result.source_delete_function_type
+    assert delete_code is not None
+
+    expected_class = compile_function_class_name(entity_model.id, "", [], "delete")
+    assert result.delete_function_type_class_name == expected_class
+    assert f"class {expected_class}" in delete_code
+    # Campos esperados (derivados do mapping do handler de delete)
+    assert "classificacao: uuid.UUID = FunctionField(" in delete_code
+    assert "grupoempresarial: uuid.UUID = FunctionField(" in delete_code
+
+
+def test_compile_handlers_generates_get_and_list_function_types_from_edl():
+    edl_json = {
+        "edl_version": "1.0",
+        "escopo": "test",
+        "description": "Entidade de teste para funções GET/LIST.",
+        "id": "Foo",
+        "version": "1.0",
+        "properties": {
+            "id": {"type": "uuid", "pk": True},
+            "codigo": {"type": "string"},
+        },
+        "repository": {
+            "map": "test.foo",
+            "shared_table": False,
+            "properties": {
+                "id": {"column": "id"},
+                "codigo": {"column": "codigo"},
+            },
+            "indexes": [],
+        },
+        "api": {
+            "resource": "foos",
+            "expose": True,
+            "verbs": ["GET"],
+            "handlers": {
+                "get": {
+                    "impl": "pg_function",
+                    "function_ref": "test.fn_foo_get",
+                    "call": {
+                        "arg_binding": {
+                            "type_name": "test.tfoo_get",
+                            "mapping": [
+                                {"attr": "id_func", "from": "path.id"},
+                                {"attr": "tenant", "from": "args.tenant"},
+                            ],
+                        }
+                    },
+                    "result": {"expected": "entity_row"},
+                },
+                "list": {
+                    "impl": "pg_function",
+                    "function_ref": "test.fn_foo_list",
+                    "call": {
+                        "arg_binding": {
+                            "type_name": "test.tfoo_list",
+                            "mapping": [
+                                {"attr": "tenant", "from": "args.tenant"},
+                                {"attr": "search", "from": "args.search"},
+                            ],
+                        }
+                    },
+                    "result": {"expected": "entity_row"},
+                },
+            },
+        },
+    }
+
+    compiler = EDLCompiler()
+    result = compiler.compile_model_from_edl(edl_json, [])
+
+    assert result is not None
+    assert result.get_function_name == "test.fn_foo_get"
+    assert result.list_function_name == "test.fn_foo_list"
+
+    get_code = result.source_get_function_type
+    list_code = result.source_list_function_type
+    assert get_code is not None
+    assert list_code is not None
+
+    expected_get_class = compile_function_class_name("Foo", "", [], "get")
+    expected_list_class = compile_function_class_name("Foo", "", [], "list")
+
+    assert result.get_function_type_class_name == expected_get_class
+    assert result.list_function_type_class_name == expected_list_class
+    assert f"class {expected_get_class}" in get_code
+    assert "id_func: uuid.UUID = FunctionField(" in get_code
+    assert "tenant: Any = FunctionField(" in get_code
+
+    assert f"class {expected_list_class}" in list_code
+    assert "tenant: Any = FunctionField(" in list_code
+    assert "search: Any = FunctionField(" in list_code