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

nsj_rest_lib2/compiler/util/relation_ref.py

@@ -0,0 +1,118 @@
+import re
+from dataclasses import dataclass
+from typing import Literal, Sequence
+
+from nsj_rest_lib2.compiler.edl_model.entity_model_base import EntityModelBase
+from nsj_rest_lib2.compiler.edl_model.primitives import (
+    REGEX_EXTERNAL_COMPONENT_REF,
+    REGEX_EXTERNAL_REF,
+    REGEX_INTERNAL_REF,
+)
+
+
+RelationRefType = Literal["internal", "external", "external_component"]
+
+
+@dataclass
+class RelationRef:
+    ref_type: RelationRefType
+    scope: str | None
+    entity: str
+    components: list[str]
+
+    @property
+    def entity_key(self) -> str | None:
+        if not self.scope:
+            return None
+
+        return f"{self.scope}/{self.entity}"
+
+    @property
+    def target_id(self) -> str:
+        return self.components[-1] if self.components else self.entity
+
+    @property
+    def prefx_class_name(self) -> str:
+        if not self.components:
+            return ""
+
+        prefix_parts: list[str] = [self.entity, *self.components[:-1]]
+        return f"_{'_'.join(prefix_parts)}"
+
+    @property
+    def is_external(self) -> bool:
+        return self.ref_type in {"external", "external_component"}
+
+    def resolve_model(
+        self,
+        entity_models: dict[str, EntityModelBase],
+        base_model: EntityModelBase | None = None,
+    ) -> EntityModelBase | None:
+        entity_key = self.entity_key
+        resolved_base: EntityModelBase | None = None
+
+        if entity_key:
+            resolved_base = entity_models.get(entity_key)
+        elif base_model:
+            resolved_base = base_model
+
+        if not resolved_base:
+            return None
+
+        return RelationRefParser.follow_components(resolved_base, self.components)
+
+
+class RelationRefParser:
+    @staticmethod
+    def parse(ref: str) -> RelationRef | None:
+        internal_match = re.match(REGEX_INTERNAL_REF, ref)
+        if internal_match:
+            components = RelationRefParser._split_components(internal_match.group(1))
+            if not components:
+                return None
+            entity = components[0]
+            extra_components = components[1:] if len(components) > 1 else []
+            return RelationRef("internal", None, entity, extra_components)
+
+        external_component_match = re.match(REGEX_EXTERNAL_COMPONENT_REF, ref)
+        if external_component_match:
+            components = RelationRefParser._split_components(
+                external_component_match.group(3)
+            )
+            return RelationRef(
+                "external_component",
+                external_component_match.group(1),
+                external_component_match.group(2),
+                components,
+            )
+
+        external_match = re.match(REGEX_EXTERNAL_REF, ref)
+        if external_match:
+            return RelationRef(
+                "external",
+                external_match.group(1),
+                external_match.group(2),
+                [],
+            )
+
+        return None
+
+    @staticmethod
+    def follow_components(
+        base_model: EntityModelBase, components: Sequence[str]
+    ) -> EntityModelBase | None:
+        target_model: EntityModelBase | None = base_model
+        for component in components:
+            if not target_model or not target_model.components:
+                return None
+            target_model = target_model.components.get(component)
+            if target_model is None:
+                return None
+
+        return target_model
+
+    @staticmethod
+    def _split_components(components_path: str) -> list[str]:
+        # Remove marcadores opcionais '#/components/' intermediários
+        cleaned = components_path.replace("#/components/", "/").replace("#", "")
+        return [part for part in cleaned.split("/") if part]

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.30.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.30
+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