nsj-rest-lib2 0.0.25__py3-none-any.whl → 0.0.27__py3-none-any.whl

nsj_rest_lib2/compiler/property_compiler.py

@@ -18,6 +18,7 @@ from nsj_rest_lib2.compiler.edl_model.primitives import (
     STR_BASED_TYPES,
 )
 from nsj_rest_lib2.compiler.edl_model.property_meta_model import PropertyMetaModel
+from nsj_rest_lib2.compiler.function_model import FunctionBindingConfig
 from nsj_rest_lib2.compiler.edl_model.trait_property_meta_model import (
     TraitPropertyMetaModel,
 )
@@ -41,6 +42,7 @@ class EDLPropertyCompiler:
         entity_model: EntityModelBase,
         entity_models: dict[str, EntityModel],
         prefx_class_name: str,
+        function_bindings: FunctionBindingConfig | None = None,
     ) -> tuple[
         list[ast.stmt],
         list[ast.stmt],
@@ -76,6 +78,9 @@ class EDLPropertyCompiler:
 
         # pk_key = pk_keys[0]
 
+        function_bindings = function_bindings or FunctionBindingConfig()
+        self._function_bindings = function_bindings
+
         # Instanciando as listas de retorno
         ast_dto_attributes = []
         ast_entity_attributes = []
@@ -433,6 +438,50 @@ class EDLPropertyCompiler:
             ),
         ]
 
+        insert_binding = self._function_bindings.insert_relations.get(pkey)
+        if insert_binding:
+            if (
+                insert_binding.field_name
+                and insert_binding.field_name != CompilerStrUtil.to_snake_case(pkey)
+            ):
+                keywords.append(
+                    ast.keyword(
+                        arg="insert_function_field",
+                        value=ast.Constant(value=insert_binding.field_name),
+                    )
+                )
+            if insert_binding.function_type_class:
+                keywords.append(
+                    ast.keyword(
+                        arg="insert_function_type",
+                        value=ast.Name(
+                            id=insert_binding.function_type_class, ctx=ast.Load()
+                        ),
+                    )
+                )
+
+        update_binding = self._function_bindings.update_relations.get(pkey)
+        if update_binding:
+            if (
+                update_binding.field_name
+                and update_binding.field_name != CompilerStrUtil.to_snake_case(pkey)
+            ):
+                keywords.append(
+                    ast.keyword(
+                        arg="update_function_field",
+                        value=ast.Constant(value=update_binding.field_name),
+                    )
+                )
+            if update_binding.function_type_class:
+                keywords.append(
+                    ast.keyword(
+                        arg="update_function_type",
+                        value=ast.Name(
+                            id=update_binding.function_type_class, ctx=ast.Load()
+                        ),
+                    )
+                )
+
         # Tratando das opções básicas do descritor de propriedade
         if properties_structure.required and pkey in properties_structure.required:
             keywords.append(ast.keyword(arg="not_null", value=ast.Constant(True)))
@@ -518,6 +567,50 @@ class EDLPropertyCompiler:
             ),
         ]
 
+        insert_binding = self._function_bindings.insert_relations.get(pkey)
+        if insert_binding:
+            if (
+                insert_binding.field_name
+                and insert_binding.field_name != CompilerStrUtil.to_snake_case(pkey)
+            ):
+                keywords.append(
+                    ast.keyword(
+                        arg="insert_function_field",
+                        value=ast.Constant(value=insert_binding.field_name),
+                    )
+                )
+            if insert_binding.function_type_class:
+                keywords.append(
+                    ast.keyword(
+                        arg="insert_function_type",
+                        value=ast.Name(
+                            id=insert_binding.function_type_class, ctx=ast.Load()
+                        ),
+                    )
+                )
+
+        update_binding = self._function_bindings.update_relations.get(pkey)
+        if update_binding:
+            if (
+                update_binding.field_name
+                and update_binding.field_name != CompilerStrUtil.to_snake_case(pkey)
+            ):
+                keywords.append(
+                    ast.keyword(
+                        arg="update_function_field",
+                        value=ast.Constant(value=update_binding.field_name),
+                    )
+                )
+            if update_binding.function_type_class:
+                keywords.append(
+                    ast.keyword(
+                        arg="update_function_type",
+                        value=ast.Name(
+                            id=update_binding.function_type_class, ctx=ast.Load()
+                        ),
+                    )
+                )
+
         # Tratando das opções básicas do descritor de propriedade
         if properties_structure.required and pkey in properties_structure.required:
             keywords.append(ast.keyword(arg="not_null", value=ast.Constant(True)))
@@ -861,6 +954,24 @@ class EDLPropertyCompiler:
                 )
             )
 
+        insert_binding = self._function_bindings.insert_fields.get(pkey)
+        if insert_binding:
+            keywords.append(
+                ast.keyword(
+                    arg="insert_function_field",
+                    value=ast.Constant(value=insert_binding),
+                )
+            )
+
+        update_binding = self._function_bindings.update_fields.get(pkey)
+        if update_binding:
+            keywords.append(
+                ast.keyword(
+                    arg="update_function_field",
+                    value=ast.Constant(value=update_binding),
+                )
+            )
+
         # Resolvendo o nome da propriedade no Entity
         if (
             properties_structure.entity_properties

nsj_rest_lib2/compiler/util/type_naming_util.py

@@ -1,4 +1,5 @@
 import uuid
+from typing import Iterable
 
 from nsj_rest_lib2.compiler.util.str_util import CompilerStrUtil
 
@@ -19,3 +20,24 @@ def compile_dto_class_name(entity_id: str, prefx_class_name: str = "") -> str:
 
 def compile_entity_class_name(entity_id: str, prefx_class_name: str = "") -> str:
     return f"{CompilerStrUtil.to_pascal_case(prefx_class_name)}{CompilerStrUtil.to_pascal_case(entity_id)}Entity"
+
+
+def compile_function_class_name(
+    entity_id: str,
+    prefx_class_name: str,
+    path_parts: Iterable[str],
+    operation: str,
+) -> str:
+    """
+    Gera o nome da classe para FunctionTypes (insert/update),
+    incorporando o caminho dos relacionamentos (quando houver).
+    """
+
+    suffix = "InsertType" if operation == "insert" else "UpdateType"
+    path_suffix = "".join(CompilerStrUtil.to_pascal_case(part) for part in path_parts)
+    return (
+        f"{CompilerStrUtil.to_pascal_case(prefx_class_name)}"
+        f"{CompilerStrUtil.to_pascal_case(entity_id)}"
+        f"{path_suffix}"
+        f"{suffix}"
+    )

nsj_rest_lib2/controller/dynamic_controller.py

@@ -22,11 +22,12 @@ from nsj_rest_lib2.exception import MissingEntityConfigException
 from nsj_rest_lib2.service.entity_loader import EntityLoader
 
 
-def _get_tenant_grupo() -> tuple[str, str]:
+def _get_query_args() -> tuple[str, str, bool]:
     # Tentando ler do query args
     query_args = request.args
     tenant = query_args.get("tenant")
     grupo_empresarial = query_args.get("grupo_empresarial")
+    force_reload = query_args.get("force_reload", "false").lower() == "true"
 
     # Tentando ler do corpo da requisição
     try:
@@ -40,7 +41,7 @@ def _get_tenant_grupo() -> tuple[str, str]:
     except:
         pass
 
-    return (str(tenant), str(grupo_empresarial))
+    return (str(tenant), str(grupo_empresarial), force_reload)
 
 
 def _endpoint_name(func: Any, multidb: bool, root: str) -> str:
@@ -81,13 +82,8 @@ def setup_dynamic_routes(
             if "entity_escopo" in kwargs:
                 entity_escopo = kwargs.pop("entity_escopo")
 
-            # Verificando se foi solicitado reload forçado do código
-            force_reload = False
-            if "force_reload" in kwargs:
-                force_reload = kwargs.pop("force_reload").lower() == "true"
-
             # Lendo tenant e grupo_empresarial
-            tenant, grupo_empresarial = _get_tenant_grupo()
+            tenant, grupo_empresarial, force_reload = _get_query_args()
 
             try:
                 # Recuperando o código do DTO e Entity correspondente
@@ -98,6 +94,8 @@ def setup_dynamic_routes(
                     etities_dict,
                     api_expose,
                     api_verbs,
+                    _insert_function_class_name,
+                    _update_function_class_name,
                 ) = entity_loader.load_entity_source(
                     entity_resource,
                     tenant,
@@ -140,13 +138,8 @@ def setup_dynamic_routes(
             if "entity_escopo" in kwargs:
                 entity_escopo = kwargs.pop("entity_escopo")
 
-            # Verificando se foi solicitado reload forçado do código
-            force_reload = False
-            if "force_reload" in kwargs:
-                force_reload = kwargs.pop("force_reload").lower() == "true"
-
             # Lendo tenant e grupo_empresarial
-            tenant, grupo_empresarial = _get_tenant_grupo()
+            tenant, grupo_empresarial, force_reload = _get_query_args()
 
             try:
                 # Recuperando o código do DTO e Entity correspondente
@@ -157,6 +150,8 @@ def setup_dynamic_routes(
                     etities_dict,
                     api_expose,
                     api_verbs,
+                    _insert_function_class_name,
+                    _update_function_class_name,
                 ) = entity_loader.load_entity_source(
                     entity_resource,
                     tenant,
@@ -198,13 +193,8 @@ def setup_dynamic_routes(
             if "entity_escopo" in kwargs:
                 entity_escopo = kwargs.pop("entity_escopo")
 
-            # Verificando se foi solicitado reload forçado do código
-            force_reload = False
-            if "force_reload" in kwargs:
-                force_reload = kwargs.pop("force_reload").lower() == "true"
-
             # Lendo tenant e grupo_empresarial
-            tenant, grupo_empresarial = _get_tenant_grupo()
+            tenant, grupo_empresarial, force_reload = _get_query_args()
 
             try:
                 # Recuperando o código do DTO e Entity correspondente
@@ -215,6 +205,8 @@ def setup_dynamic_routes(
                     etities_dict,
                     api_expose,
                     api_verbs,
+                    insert_function_class_name,
+                    _update_function_class_name,
                 ) = entity_loader.load_entity_source(
                     entity_resource,
                     tenant,
@@ -228,12 +220,19 @@ def setup_dynamic_routes(
                     return ("", 405, {})
 
                 # Executando o list pelo RestLib
+                insert_function_type_class = (
+                    etities_dict.get(insert_function_class_name)
+                    if insert_function_class_name
+                    else None
+                )
+
                 route = PostRoute(
                     url=COLLECTION_DYNAMIC_ROUTE,
                     http_method="POST",
                     dto_class=etities_dict[dto_class_name],
                     entity_class=etities_dict[entity_class_name],
                     injector_factory=injector_factory,
+                    insert_function_type_class=insert_function_type_class,
                 )
 
                 return route.handle_request(*args, **kwargs)
@@ -256,13 +255,8 @@ def setup_dynamic_routes(
             if "entity_escopo" in kwargs:
                 entity_escopo = kwargs.pop("entity_escopo")
 
-            # Verificando se foi solicitado reload forçado do código
-            force_reload = False
-            if "force_reload" in kwargs:
-                force_reload = kwargs.pop("force_reload").lower() == "true"
-
             # Lendo tenant e grupo_empresarial
-            tenant, grupo_empresarial = _get_tenant_grupo()
+            tenant, grupo_empresarial, force_reload = _get_query_args()
 
             try:
                 # Recuperando o código do DTO e Entity correspondente
@@ -273,6 +267,8 @@ def setup_dynamic_routes(
                     etities_dict,
                     api_expose,
                     api_verbs,
+                    _insert_function_class_name,
+                    update_function_class_name,
                 ) = entity_loader.load_entity_source(
                     entity_resource,
                     tenant,
@@ -286,12 +282,19 @@ def setup_dynamic_routes(
                     return ("", 405, {})
 
                 # Executando o list pelo RestLib
+                update_function_type_class = (
+                    etities_dict.get(update_function_class_name)
+                    if update_function_class_name
+                    else None
+                )
+
                 route = PutRoute(
                     url=ONE_DYNAMIC_ROUTE,
                     http_method="PUT",
                     dto_class=etities_dict[dto_class_name],
                     entity_class=etities_dict[entity_class_name],
                     injector_factory=injector_factory,
+                    update_function_type_class=update_function_type_class,
                 )
 
                 return route.handle_request(*args, **kwargs)
@@ -314,13 +317,8 @@ def setup_dynamic_routes(
             if "entity_escopo" in kwargs:
                 entity_escopo = kwargs.pop("entity_escopo")
 
-            # Verificando se foi solicitado reload forçado do código
-            force_reload = False
-            if "force_reload" in kwargs:
-                force_reload = kwargs.pop("force_reload").lower() == "true"
-
             # Lendo tenant e grupo_empresarial
-            tenant, grupo_empresarial = _get_tenant_grupo()
+            tenant, grupo_empresarial, force_reload = _get_query_args()
 
             try:
                 # Recuperando o código do DTO e Entity correspondente
@@ -331,6 +329,8 @@ def setup_dynamic_routes(
                     etities_dict,
                     api_expose,
                     api_verbs,
+                    _insert_function_class_name,
+                    _update_function_class_name,
                 ) = entity_loader.load_entity_source(
                     entity_resource,
                     tenant,
@@ -372,13 +372,8 @@ def setup_dynamic_routes(
             if "entity_escopo" in kwargs:
                 entity_escopo = kwargs.pop("entity_escopo")
 
-            # Verificando se foi solicitado reload forçado do código
-            force_reload = False
-            if "force_reload" in kwargs:
-                force_reload = kwargs.pop("force_reload").lower() == "true"
-
             # Lendo tenant e grupo_empresarial
-            tenant, grupo_empresarial = _get_tenant_grupo()
+            tenant, grupo_empresarial, force_reload = _get_query_args()
 
             try:
                 # Recuperando o código do DTO e Entity correspondente
@@ -389,6 +384,8 @@ def setup_dynamic_routes(
                     etities_dict,
                     api_expose,
                     api_verbs,
+                    _insert_function_class_name,
+                    _update_function_class_name,
                 ) = entity_loader.load_entity_source(
                     entity_resource,
                     tenant,

nsj_rest_lib2/service/entity_config_writer.py

@@ -0,0 +1,134 @@
+from __future__ import annotations
+
+import hashlib
+import json
+from typing import Any, Dict, Iterator, Optional
+
+from nsj_rest_lib2.compiler.edl_model.entity_model import EntityModel
+from nsj_rest_lib2.compiler.edl_model.entity_model_base import EntityModelBase
+from nsj_rest_lib2.compiler.model import CompilerResult
+from nsj_rest_lib2.compiler.util.type_naming_util import compile_namespace_keys
+from nsj_rest_lib2.redis_config import set_redis
+from nsj_rest_lib2.settings import ESCOPO_RESTLIB2
+
+
+class EntityConfigWriter:
+    """
+    Serializa o resultado da compilação e publica no Redis usando o mesmo
+    layout consumido pelo EntityLoader.
+    """
+
+    def __init__(self, escopo: str = ESCOPO_RESTLIB2) -> None:
+        self._escopo = escopo or ESCOPO_RESTLIB2
+
+    def publish(
+        self,
+        entity_model: EntityModelBase,
+        compiler_result: CompilerResult,
+        *,
+        entity_hash: str | None = None,
+    ) -> Dict[str, Any]:
+        """
+        Serializa e grava o resultado da compilação no Redis.
+
+        :return: Payload serializado (útil para inspeção/testes).
+        """
+
+        payload = self.build_payload(
+            entity_model, compiler_result, entity_hash=entity_hash
+        )
+        namespace_key = self._resolve_namespace_key(entity_model)
+        resource = self._resolve_resource(entity_model)
+
+        set_redis(
+            "entity_config",
+            self._escopo,
+            namespace_key,
+            resource,
+            json.dumps(payload, ensure_ascii=False),
+        )
+
+        return payload
+
+    def build_payload(
+        self,
+        entity_model: EntityModelBase,
+        compiler_result: CompilerResult,
+        *,
+        entity_hash: str | None = None,
+    ) -> Dict[str, Any]:
+        """
+        Constrói o dicionário serializável que representa a entidade compilada.
+        """
+
+        resource = self._resolve_resource(entity_model)
+        relations = [
+            rd.to_dict()
+            for rd in (compiler_result.relations_dependencies or [])
+        ]
+
+        return {
+            "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,
+            "source_insert_function": compiler_result.source_insert_function,
+            "update_function_class_name": compiler_result.update_function_class_name,
+            "source_update_function": compiler_result.source_update_function,
+            "source_dto": compiler_result.dto_code,
+            "source_entity": compiler_result.entity_code,
+            "entity_hash": entity_hash
+            if entity_hash is not None
+            else self._build_entity_hash(compiler_result),
+            "api_expose": compiler_result.api_expose,
+            "api_resource": resource,
+            "api_verbs": compiler_result.api_verbs or [],
+            "relations_dependencies": relations,
+        }
+
+    def _resolve_namespace_key(self, entity_model: EntityModelBase) -> str:
+        tenant = getattr(entity_model, "tenant", None)
+        grupo_empresarial = getattr(entity_model, "grupo_empresarial", None)
+
+        grupo_key, tenant_key, default_key = compile_namespace_keys(
+            tenant,
+            grupo_empresarial,
+        )
+
+        if (
+            tenant
+            and tenant != 0
+            and grupo_empresarial
+            and str(grupo_empresarial) != "00000000-0000-0000-0000-000000000000"
+        ):
+            return grupo_key
+        if tenant and tenant != 0:
+            return tenant_key
+        return default_key
+
+    def _resolve_resource(self, entity_model: EntityModelBase) -> str:
+        if not isinstance(entity_model, EntityModel) or not entity_model.api:
+            raise ValueError(
+                "EntityModel precisa possuir bloco de API para publicação no Redis."
+            )
+        if not entity_model.api.resource:
+            raise ValueError("api.resource é obrigatório para publicação no Redis.")
+        return entity_model.api.resource
+
+    def _build_entity_hash(self, compiler_result: CompilerResult) -> str:
+        hasher = hashlib.sha256()
+
+        for content in self._iter_hash_chunks(
+            compiler_result.dto_code,
+            compiler_result.entity_code,
+            compiler_result.source_insert_function,
+            compiler_result.source_update_function,
+        ):
+            hasher.update(content)
+
+        return hasher.hexdigest()
+
+    @staticmethod
+    def _iter_hash_chunks(*chunks: Optional[str]) -> Iterator[bytes]:
+        for chunk in chunks:
+            if chunk:
+                yield chunk.encode("utf-8")

nsj_rest_lib2/service/entity_loader.py

@@ -24,6 +24,8 @@ class LoadedEntity:
         self.api_expose: bool = False
         self.api_verbs: list[str] = []
         self.relations_dependencies: list[RelationDependency] = []
+        self.insert_function_class_name: str | None = None
+        self.update_function_class_name: str | None = None
 
 
 class Namespace:
@@ -48,7 +50,7 @@ class EntityLoader:
         grupo_empresarial: str | None,
         escopo: str = ESCOPO_RESTLIB2,
         force_reload: bool = False,
-    ) -> tuple[str, str, dict, bool, list[str]]:
+    ) -> tuple[str, str, dict, bool, list[str], str | None, str | None]:
         # Assumind o escopo default se necessário
         if not escopo:
             escopo = ESCOPO_RESTLIB2
@@ -77,6 +79,8 @@ class EntityLoader:
             api_expose = loaded_entity.api_expose
             api_verbs = loaded_entity.api_verbs
             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
 
             # Verificando se alguma de suas dependências precisariam ser recarregadas
             for rd in relations_dependencies:
@@ -122,6 +126,8 @@ class EntityLoader:
                         entities_dict,
                         api_expose,
                         api_verbs,
+                        insert_function_class_name,
+                        update_function_class_name,
                     )
 
                 # Desempacotando resultado
@@ -143,6 +149,8 @@ class EntityLoader:
                         entities_dict,
                         api_expose,
                         api_verbs,
+                        insert_function_class_name,
+                        update_function_class_name,
                     )
                 else:
                     (
@@ -167,6 +175,8 @@ class EntityLoader:
                     entities_dict,
                     api_expose,
                     api_verbs,
+                    insert_function_class_name,
+                    update_function_class_name,
                 )
 
         # Se não conseguir recuperar a entidade, procura no redis:
@@ -195,9 +205,15 @@ class EntityLoader:
             raise RuntimeError(
                 f"Erro desconhecido carregando entidade: {entity_resource}"
             )
-        dto_class_name, entity_class_name, namespace, api_expose, api_verbs = (
-            result_execute
-        )
+        (
+            dto_class_name,
+            entity_class_name,
+            namespace,
+            api_expose,
+            api_verbs,
+            insert_function_class_name,
+            update_function_class_name,
+        ) = result_execute
 
         return (
             dto_class_name,
@@ -205,6 +221,8 @@ class EntityLoader:
             namespace.entities_dict,
             api_expose,
             api_verbs,
+            insert_function_class_name,
+            update_function_class_name,
         )
 
     def clear_namespaces(self):
@@ -235,7 +253,7 @@ class EntityLoader:
         entity_config_key: str,
         entity_resource: str,
         check_refresh: bool = False,
-    ) -> tuple[str, str, Namespace, bool, list[str]] | None:
+    ) -> tuple[str, str, Namespace, bool, list[str], str | None, str | None] | None:
         # Interpretando o json de configuração da entidade
         try:
             entity_config = json.loads(entity_config_str)
@@ -249,6 +267,14 @@ class EntityLoader:
             api_expose = entity_config["api_expose"]
             # api_resource = entity_config["api_resource"]
             api_verbs = entity_config["api_verbs"]
+            insert_function_class_name = entity_config.get(
+                "insert_function_class_name"
+            )
+            insert_function_code = entity_config.get("source_insert_function")
+            update_function_class_name = entity_config.get(
+                "update_function_class_name"
+            )
+            update_function_code = entity_config.get("source_update_function")
             relations_dependencies = [
                 RelationDependency().from_dict(rd)
                 for rd in entity_config.get("relations_dependencies", [])
@@ -331,6 +357,20 @@ class EntityLoader:
             get_logger().debug(f"Entity source:\n{source_entity}")
             get_logger().debug(f"DTO source:\n{source_dto}")
 
+            if insert_function_code:
+                self._safe_exec(
+                    insert_function_code,
+                    namespace.entities_dict,
+                    "Insert Function source",
+                )
+
+            if update_function_code:
+                self._safe_exec(
+                    update_function_code,
+                    namespace.entities_dict,
+                    "Update Function source",
+                )
+
             self._safe_exec(source_entity, namespace.entities_dict, "Entity source")
             self._safe_exec(source_dto, namespace.entities_dict, "DTO source")
 
@@ -342,10 +382,20 @@ class EntityLoader:
             loaded_entity.api_expose = api_expose
             loaded_entity.api_verbs = api_verbs
             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
 
             namespace.loaded_entities[entity_resource] = loaded_entity
 
-        return (dto_class_name, entity_class_name, namespace, api_expose, api_verbs)
+        return (
+            dto_class_name,
+            entity_class_name,
+            namespace,
+            api_expose,
+            api_verbs,
+            insert_function_class_name,
+            update_function_class_name,
+        )
 
     def _safe_exec(self, source_code, context, description):
         try:

{nsj_rest_lib2-0.0.25.dist-info → nsj_rest_lib2-0.0.27.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nsj_rest_lib2
-Version: 0.0.25
+Version: 0.0.27
 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