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

nsj_rest_lib2/compiler/compiler.py

@@ -1,5 +1,3 @@
-import re
-
 from typing import Any
 
 from nsj_rest_lib2.compiler.compiler_structures import (
@@ -8,17 +6,19 @@ 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,
 )
 from nsj_rest_lib2.compiler.edl_model.entity_model_base import EntityModelBase
 from nsj_rest_lib2.compiler.edl_model.entity_model_root import EntityModelRoot
-from nsj_rest_lib2.compiler.edl_model.primitives import REGEX_EXTERNAL_REF
 from nsj_rest_lib2.compiler.entity_compiler import EntityCompiler
 from nsj_rest_lib2.compiler.model import CompilerResult, RelationDependency
 from nsj_rest_lib2.compiler.property_compiler import EDLPropertyCompiler
@@ -28,6 +28,7 @@ from nsj_rest_lib2.compiler.util.type_naming_util import (
     compile_entity_class_name,
     compile_namespace_keys,
 )
+from nsj_rest_lib2.compiler.util.relation_ref import RelationRefParser
 
 from nsj_rest_lib2.compiler.edl_model.entity_model import EntityModel
 
@@ -39,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]
@@ -144,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 = {}
@@ -166,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,
@@ -178,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,
@@ -301,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()
@@ -496,6 +571,7 @@ class EDLCompiler:
         properties_structure: PropertiesCompilerStructure,
         entity_model: EntityModelBase,
         entity_models: dict[str, EntityModel],
+        relation_type: str = "self",
     ):
         if not entity_model:
             return
@@ -511,6 +587,7 @@ class EDLCompiler:
                     properties_structure,
                     mixin_model,
                     entity_models,
+                    relation_type="mixin",
                 )
 
         # Populando com as propriedades da superclasse (extends)
@@ -521,6 +598,7 @@ class EDLCompiler:
                 properties_structure,
                 super_model,
                 entity_models,
+                relation_type="extends",
             )
 
         # Populando com as propriedades do trait
@@ -531,10 +609,18 @@ class EDLCompiler:
                 properties_structure,
                 trait_model,
                 entity_models,
+                relation_type="trait",
             )
 
         # Populando com as propriedades da entidade atual
         properties_structure.properties.update(entity_model.properties)
+        for prop_name in entity_model.properties or {}:
+            # Preferimos não sobrescrever quando já marcado como 'self'
+            if (
+                prop_name not in properties_structure.property_origins
+                or relation_type == "self"
+            ):
+                properties_structure.property_origins[prop_name] = relation_type
         if entity_model.main_properties:
             for main_property in entity_model.main_properties:
                 if not isinstance(main_property, str):
@@ -706,10 +792,10 @@ class EDLCompiler:
             prop = entity_model.properties[pkey]
 
             if isinstance(prop.type, str):
-                external_match = re.match(REGEX_EXTERNAL_REF, prop.type)
-                if external_match:
-                    external_dependency = external_match.group(0)
-                    entities.append(external_dependency)
+                relation_ref = RelationRefParser.parse(prop.type)
+                if relation_ref and relation_ref.is_external:
+                    if relation_ref.entity_key:
+                        entities.append(relation_ref.entity_key)
 
         return entities
 

nsj_rest_lib2/compiler/compiler_structures.py

@@ -27,6 +27,7 @@ class PropertiesCompilerStructure:
         self.trait_properties: dict[str, TraitPropertyMetaModel] = {}
         self.extends_properties: dict[str, ExtendsPropertyMetaModel] = {}
         self.composed_properties: dict[str, list[str]] = {}
+        self.property_origins: dict[str, str] = {}
 
 
 class ComponentsCompilerStructure:

nsj_rest_lib2/compiler/edl_model/primitives.py

@@ -4,15 +4,20 @@ from typing import Annotated, List, Union
 from pydantic import StringConstraints
 
 REGEX_EXTERNAL_REF = r"^(\w+)\/(\w+)$"
-REGEX_INTERNAL_REF = r"^#\/components\/(\w+)$"
+REGEX_EXTERNAL_COMPONENT_REF = r"^(\w+)\/(\w+)\/([\w\/#]+)$"
+REGEX_INTERNAL_REF = r"^#\/components\/([\w\/#]+)$"
 
 ExternalRefType = Annotated[str, StringConstraints(pattern=REGEX_EXTERNAL_REF)]
+ExternalComponentRefType = Annotated[
+    str, StringConstraints(pattern=REGEX_EXTERNAL_COMPONENT_REF)
+]
 InternalRefType = Annotated[str, StringConstraints(pattern=REGEX_INTERNAL_REF)]
 
 
 class PrimitiveTypes(enum.Enum):
     # TODO Validar esses tipos
     STRING = "string"
+    TEXT = "text"
     NUMBER = "number"
     INTEGER = "integer"
     BOOLEAN = "boolean"
@@ -28,10 +33,13 @@ class PrimitiveTypes(enum.Enum):
     DURATION = "duration"
 
 
-PropertyType = Union[PrimitiveTypes, ExternalRefType, InternalRefType]
+PropertyType = Union[
+    PrimitiveTypes, ExternalRefType, ExternalComponentRefType, InternalRefType
+]
 
 MAPPING_PRIMITIVE_TYPES_TO_PYTHON = {
     PrimitiveTypes.STRING: "str",
+    PrimitiveTypes.TEXT: "str",
     PrimitiveTypes.NUMBER: "float",
     PrimitiveTypes.INTEGER: "int",
     PrimitiveTypes.BOOLEAN: "bool",
@@ -44,7 +52,7 @@ MAPPING_PRIMITIVE_TYPES_TO_PYTHON = {
     PrimitiveTypes.EMAIL: "str",
     PrimitiveTypes.DATE: "datetime.date",
     PrimitiveTypes.DATETIME: "datetime.datetime",
-    PrimitiveTypes.DURATION: "relativedelta"
+    PrimitiveTypes.DURATION: "relativedelta",
 }
 
 BasicTypes = int | bool | float | str
@@ -52,6 +60,7 @@ DefaultTypes = BasicTypes | List[BasicTypes]
 
 STR_BASED_TYPES = {
     PrimitiveTypes.STRING,
+    PrimitiveTypes.TEXT,
     PrimitiveTypes.EMAIL,
     PrimitiveTypes.CPF,
     PrimitiveTypes.CNPJ,

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