nsj-rest-lib2 0.0.35__py3-none-any.whl → 0.0.37__py3-none-any.whl

nsj_rest_lib2/service/entity_loader.py

@@ -1,18 +1,34 @@
 import datetime
 import json
+import os
 import re
 import sys
 import threading
 import types
+from typing import Any
 
 from nsj_rest_lib.settings import get_logger
 
+import yaml
+
+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_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.model import RelationDependency
-from nsj_rest_lib2.compiler.util.type_naming_util import compile_namespace_keys
+from nsj_rest_lib2.compiler.model import CompilerResult, RelationDependency
+from nsj_rest_lib2.compiler.util.type_naming_util import (
+    build_entity_hash as build_entity_hash_util,
+    compile_namespace_keys,
+    resolve_namespace_key as resolve_namespace_key_util,
+)
+from nsj_rest_lib2.dto.escopo_dto import EscopoDTO
 from nsj_rest_lib2.exception import MissingEntityConfigException
-from nsj_rest_lib2.redis_config import get_redis
-from nsj_rest_lib2.settings import ESCOPO_RESTLIB2, MIN_TIME_SOURCE_REFRESH
+from nsj_rest_lib2.settings import (
+    EDLS_FROM_REDIS,
+    ESCOPO_RESTLIB2,
+    MIN_TIME_SOURCE_REFRESH,
+)
 
 
 class LoadedEntity:
@@ -24,6 +40,7 @@ class LoadedEntity:
         self.api_expose: bool = False
         self.api_verbs: list[str] = []
         self.relations_dependencies: list[RelationDependency] = []
+        self.never_expire: bool = False
         self.service_account: str | None = None
         self.insert_function_class_name: str | None = None
         self.update_function_class_name: str | None = None
@@ -35,6 +52,18 @@ class LoadedEntity:
         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.retrieve_after_insert: bool = False
+        self.retrieve_after_update: bool = False
+        self.retrieve_after_partial_update: bool = False
+        self.post_response_dto_class_name: str | None = None
+        self.put_response_dto_class_name: str | None = None
+        self.patch_response_dto_class_name: str | None = None
+        self.custom_json_post_response: bool = False
+        self.custom_json_put_response: bool = False
+        self.custom_json_patch_response: bool = False
+        self.custom_json_get_response: bool = False
+        self.custom_json_list_response: bool = False
+        self.custom_json_delete_response: bool = False
 
 
 class Namespace:
@@ -49,8 +78,10 @@ namespaces_dict: dict[str, Namespace] = {}
 
 
 class EntityLoader:
-    def __init__(self) -> types.NoneType:
+    def __init__(self, edls_path: str | None = None) -> types.NoneType:
         self._lock = threading.Lock()
+        if edls_path:
+            self._load_edls_from_disk(edls_path)
 
     def load_entity_source(
         self,
@@ -75,6 +106,19 @@ class EntityLoader:
         str | None,
         str | None,
         str | None,
+        str | None,
+        bool,
+        bool,
+        bool,
+        str | None,
+        str | None,
+        str | None,
+        bool,
+        bool,
+        bool,
+        bool,
+        bool,
+        bool,
     ]:
         # Assumind o escopo default se necessário
         if not escopo:
@@ -122,6 +166,37 @@ class EntityLoader:
                 loaded_entity.delete_function_type_class_name
             )
 
+            cached_result = (
+                dto_class_name,
+                entity_class_name,
+                entities_dict,
+                api_expose,
+                api_verbs,
+                service_account,
+                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,
+                loaded_entity.retrieve_after_insert,
+                loaded_entity.retrieve_after_update,
+                loaded_entity.retrieve_after_partial_update,
+                loaded_entity.post_response_dto_class_name,
+                loaded_entity.put_response_dto_class_name,
+                loaded_entity.patch_response_dto_class_name,
+                loaded_entity.custom_json_post_response,
+                loaded_entity.custom_json_put_response,
+                loaded_entity.custom_json_patch_response,
+                loaded_entity.custom_json_get_response,
+                loaded_entity.custom_json_list_response,
+                loaded_entity.custom_json_delete_response,
+            )
+
             # Verificando se alguma de suas dependências precisariam ser recarregadas
             for rd in relations_dependencies:
                 if rd.entity_resource is None or rd.entity_scope is None:
@@ -137,6 +212,9 @@ class EntityLoader:
                     force_reload=force_reload,
                 )
 
+            if loaded_entity.never_expire or not EDLS_FROM_REDIS:
+                return cached_result
+
             # Se o tempo entre o carregamento e agora for maior do que MIN_TIME_SOURCE_REFRESH minutos,
             # verifica se precisa de refresh
             time_diff = datetime.datetime.now() - loaded_entity.loaded_at
@@ -160,24 +238,7 @@ class EntityLoader:
 
                 # Se não achar no redis, usa o que estava em memória
                 if not loaded_config:
-                    return (
-                        dto_class_name,
-                        entity_class_name,
-                        entities_dict,
-                        api_expose,
-                        api_verbs,
-                        service_account,
-                        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,
-                    )
+                    return cached_result
 
                 # Desempacotando resultado
                 entity_config_key, entity_config_str = loaded_config
@@ -192,24 +253,7 @@ class EntityLoader:
 
                 # Se não carregou novo código, usa o que estava em memória
                 if result_execute is None:
-                    return (
-                        dto_class_name,
-                        entity_class_name,
-                        entities_dict,
-                        api_expose,
-                        api_verbs,
-                        service_account,
-                        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,
-                    )
+                    return cached_result
                 else:
                     (
                         dto_class_name,
@@ -228,6 +272,18 @@ class EntityLoader:
                         get_function_type_class_name,
                         list_function_type_class_name,
                         delete_function_type_class_name,
+                        retrieve_after_insert,
+                        retrieve_after_update,
+                        retrieve_after_partial_update,
+                        post_response_dto_class_name,
+                        put_response_dto_class_name,
+                        patch_response_dto_class_name,
+                        custom_json_post_response,
+                        custom_json_put_response,
+                        custom_json_patch_response,
+                        custom_json_get_response,
+                        custom_json_list_response,
+                        custom_json_delete_response,
                     ) = result_execute
                     return (
                         dto_class_name,
@@ -246,27 +302,25 @@ class EntityLoader:
                         get_function_type_class_name,
                         list_function_type_class_name,
                         delete_function_type_class_name,
+                        retrieve_after_insert,
+                        retrieve_after_update,
+                        retrieve_after_partial_update,
+                        post_response_dto_class_name,
+                        put_response_dto_class_name,
+                        patch_response_dto_class_name,
+                        custom_json_post_response,
+                        custom_json_put_response,
+                        custom_json_patch_response,
+                        custom_json_get_response,
+                        custom_json_list_response,
+                        custom_json_delete_response,
                     )
             else:
                 # Se não deu o intervalo de verificação do refresh, retorna o que está em memória
-                return (
-                    dto_class_name,
-                    entity_class_name,
-                    entities_dict,
-                    api_expose,
-                    api_verbs,
-                    service_account,
-                    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,
-                )
+                return cached_result
+
+        if not EDLS_FROM_REDIS:
+            raise MissingEntityConfigException()
 
         # Se não conseguir recuperar a entidade, procura no redis:
         loaded_config = self._load_entity_config_from_redis(
@@ -311,6 +365,18 @@ class EntityLoader:
             get_function_type_class_name,
             list_function_type_class_name,
             delete_function_type_class_name,
+            retrieve_after_insert,
+            retrieve_after_update,
+            retrieve_after_partial_update,
+            post_response_dto_class_name,
+            put_response_dto_class_name,
+            patch_response_dto_class_name,
+            custom_json_post_response,
+            custom_json_put_response,
+            custom_json_patch_response,
+            custom_json_get_response,
+            custom_json_list_response,
+            custom_json_delete_response,
         ) = result_execute
 
         return (
@@ -330,6 +396,18 @@ class EntityLoader:
             get_function_type_class_name,
             list_function_type_class_name,
             delete_function_type_class_name,
+            retrieve_after_insert,
+            retrieve_after_update,
+            retrieve_after_partial_update,
+            post_response_dto_class_name,
+            put_response_dto_class_name,
+            patch_response_dto_class_name,
+            custom_json_post_response,
+            custom_json_put_response,
+            custom_json_patch_response,
+            custom_json_get_response,
+            custom_json_list_response,
+            custom_json_delete_response,
         )
 
     def clear_namespaces(self):
@@ -342,6 +420,178 @@ class EntityLoader:
         with self._lock:
             namespaces_dict.clear()
 
+    def _load_edls_from_disk(self, edls_path: str) -> None:
+        if namespaces_dict:
+            return
+
+        resolved_path = self._resolve_edls_path(edls_path)
+        if not resolved_path:
+            return
+
+        if os.path.isdir(resolved_path):
+            edl_files = self._list_edl_files(resolved_path)
+        elif os.path.isfile(resolved_path) and self._is_edl_file(resolved_path):
+            edl_files = [resolved_path]
+        else:
+            return
+
+        if not edl_files:
+            return
+
+        entities: dict[str, EntityModelBase] = {}
+        for file_path in edl_files:
+            edl_json = self._read_edl_file(file_path)
+            if not isinstance(edl_json, dict):
+                continue
+
+            if edl_json.get("mixin", False):
+                entity_model = EntityModelRoot(**edl_json)
+            else:
+                entity_model = EntityModel(**edl_json)
+
+            complete_entity_id = f"{entity_model.escopo}/{entity_model.id}"
+            entities[complete_entity_id] = entity_model
+
+        if not entities:
+            return
+
+        escopos: dict[str, EscopoDTO] = {}
+        for entity_model in entities.values():
+            if entity_model.escopo not in escopos:
+                escopos[entity_model.escopo] = EscopoDTO(
+                    codigo=entity_model.escopo,
+                    service_account=None,
+                )
+
+        compiler = EDLCompiler()
+        dependencies = list(entities.items())
+
+        for entity_model in entities.values():
+            escopo_dto = escopos.get(entity_model.escopo)
+            if escopo_dto is None:
+                continue
+
+            compiler_result = compiler.compile_model(
+                entity_model,
+                dependencies,
+                escopo=escopo_dto,
+            )
+            if not compiler_result:
+                continue
+
+            entity_config = self._build_entity_payload(
+                entity_model,
+                compiler_result,
+            )
+            entity_resource = entity_config.get("api_resource")
+            if not entity_resource:
+                continue
+
+            entity_config_key = self._resolve_namespace_key(entity_model)
+            self._execute_entity_source(
+                json.dumps(entity_config, ensure_ascii=False),
+                entity_config_key,
+                entity_resource,
+                from_disk=True,
+                skip_dependency_load=not EDLS_FROM_REDIS,
+            )
+
+    def _resolve_edls_path(self, edls_path: str) -> str | None:
+        edls_path = edls_path.strip()
+        if not edls_path:
+            return None
+        if os.path.isabs(edls_path):
+            return edls_path
+        return os.path.join(os.getcwd(), edls_path)
+
+    def _is_edl_file(self, file_path: str) -> bool:
+        lower_name = file_path.lower()
+        return lower_name.endswith(".json") or lower_name.endswith(
+            ".yml"
+        ) or lower_name.endswith(".yaml")
+
+    def _list_edl_files(self, root_path: str) -> list[str]:
+        edl_files: list[str] = []
+        for current_root, _, files in os.walk(root_path):
+            for file_name in files:
+                file_path = os.path.join(current_root, file_name)
+                if self._is_edl_file(file_path):
+                    edl_files.append(file_path)
+        edl_files.sort()
+        return edl_files
+
+    def _read_edl_file(self, file_path: str) -> dict[str, Any] | None:
+        with open(file_path, "r", encoding="utf-8") as file_handler:
+            if file_path.lower().endswith(".json"):
+                return json.load(file_handler)
+            return yaml.safe_load(file_handler)
+
+    def _resolve_namespace_key(self, entity_model: EntityModelBase) -> str:
+        tenant = getattr(entity_model, "tenant", None)
+        grupo_empresarial = getattr(entity_model, "grupo_empresarial", None)
+
+        return resolve_namespace_key_util(tenant, grupo_empresarial)
+
+    def _build_entity_payload(
+        self,
+        entity_model: EntityModelBase,
+        compiler_result: CompilerResult,
+    ) -> dict[str, Any]:
+        api_resource = compiler_result.api_resource
+        if not api_resource:
+            if isinstance(entity_model, EntityModel) and entity_model.api:
+                api_resource = entity_model.api.resource
+        if not api_resource:
+            raise ValueError("api.resource é obrigatório para carregar EDLs.")
+
+        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,
+            "service_account": compiler_result.service_account,
+            "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,
+            "retrieve_after_insert": compiler_result.retrieve_after_insert,
+            "retrieve_after_update": compiler_result.retrieve_after_update,
+            "retrieve_after_partial_update": compiler_result.retrieve_after_partial_update,
+            "post_response_dto_class_name": compiler_result.post_response_dto_class_name,
+            "put_response_dto_class_name": compiler_result.put_response_dto_class_name,
+            "patch_response_dto_class_name": compiler_result.patch_response_dto_class_name,
+            "custom_json_post_response": compiler_result.custom_json_post_response,
+            "custom_json_put_response": compiler_result.custom_json_put_response,
+            "custom_json_patch_response": compiler_result.custom_json_patch_response,
+            "custom_json_get_response": compiler_result.custom_json_get_response,
+            "custom_json_list_response": compiler_result.custom_json_list_response,
+            "custom_json_delete_response": compiler_result.custom_json_delete_response,
+            "source_dto": compiler_result.dto_code,
+            "source_entity": compiler_result.entity_code,
+            "entity_hash": self._build_entity_hash(compiler_result),
+            "api_expose": compiler_result.api_expose,
+            "api_resource": api_resource,
+            "api_verbs": compiler_result.api_verbs or [],
+            "relations_dependencies": relations,
+        }
+
+    def _build_entity_hash(self, compiler_result: CompilerResult) -> str:
+        return build_entity_hash_util(compiler_result)
+
     def _ensure_dynamic_package(self):
         """
         Garante que exista um pacote 'dynamic' em sys.modules.
@@ -360,6 +610,8 @@ class EntityLoader:
         entity_config_key: str,
         entity_resource: str,
         check_refresh: bool = False,
+        from_disk: bool = False,
+        skip_dependency_load: bool = False,
     ) -> tuple[
         str,
         str,
@@ -377,6 +629,18 @@ class EntityLoader:
         str | None,
         str | None,
         str | None,
+        bool,
+        bool,
+        bool,
+        str | None,
+        str | None,
+        str | None,
+        bool,
+        bool,
+        bool,
+        bool,
+        bool,
+        bool,
     ] | None:
         # Interpretando o json de configuração da entidade
         try:
@@ -414,6 +678,42 @@ class EntityLoader:
             delete_function_type_class_name = entity_config.get(
                 "delete_function_type_class_name"
             )
+            retrieve_after_insert = entity_config.get(
+                "retrieve_after_insert", False
+            )
+            retrieve_after_update = entity_config.get(
+                "retrieve_after_update", False
+            )
+            retrieve_after_partial_update = entity_config.get(
+                "retrieve_after_partial_update", False
+            )
+            post_response_dto_class_name = entity_config.get(
+                "post_response_dto_class_name"
+            )
+            put_response_dto_class_name = entity_config.get(
+                "put_response_dto_class_name"
+            )
+            patch_response_dto_class_name = entity_config.get(
+                "patch_response_dto_class_name"
+            )
+            custom_json_post_response = entity_config.get(
+                "custom_json_post_response", False
+            )
+            custom_json_put_response = entity_config.get(
+                "custom_json_put_response", False
+            )
+            custom_json_patch_response = entity_config.get(
+                "custom_json_patch_response", False
+            )
+            custom_json_get_response = entity_config.get(
+                "custom_json_get_response", False
+            )
+            custom_json_list_response = entity_config.get(
+                "custom_json_list_response", False
+            )
+            custom_json_delete_response = entity_config.get(
+                "custom_json_delete_response", False
+            )
             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")
@@ -433,18 +733,19 @@ class EntityLoader:
                 return None
 
         # Verificando se alguma de suas dependências precisariam ser carregadas (ou recarregadas)
-        for rd in relations_dependencies:
-            if rd.entity_resource is None or rd.entity_scope is None:
-                raise RuntimeError(
-                    f"Erro: Dependência de entidade mal formada na entidade {entity_resource}."
-                )
+        if not skip_dependency_load:
+            for rd in relations_dependencies:
+                if rd.entity_resource is None or rd.entity_scope is None:
+                    raise RuntimeError(
+                        f"Erro: Dependência de entidade mal formada na entidade {entity_resource}."
+                    )
 
-            self.load_entity_source(
-                rd.entity_resource,
-                str(rd.tenant),
-                str(rd.grupo_empresarial),
-                rd.entity_scope,
-            )
+                self.load_entity_source(
+                    rd.entity_resource,
+                    str(rd.tenant),
+                    str(rd.grupo_empresarial),
+                    rd.entity_scope,
+                )
 
         # Verificando se a entidade precisa ou não de refresh
         if check_refresh:
@@ -546,6 +847,7 @@ class EntityLoader:
             loaded_entity.api_verbs = api_verbs
             loaded_entity.service_account = service_account
             loaded_entity.relations_dependencies = relations_dependencies
+            loaded_entity.never_expire = from_disk
             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
@@ -562,6 +864,38 @@ class EntityLoader:
             loaded_entity.delete_function_type_class_name = (
                 delete_function_type_class_name
             )
+            loaded_entity.retrieve_after_insert = bool(retrieve_after_insert)
+            loaded_entity.retrieve_after_update = bool(retrieve_after_update)
+            loaded_entity.retrieve_after_partial_update = bool(
+                retrieve_after_partial_update
+            )
+            loaded_entity.post_response_dto_class_name = (
+                post_response_dto_class_name
+            )
+            loaded_entity.put_response_dto_class_name = (
+                put_response_dto_class_name
+            )
+            loaded_entity.patch_response_dto_class_name = (
+                patch_response_dto_class_name
+            )
+            loaded_entity.custom_json_post_response = bool(
+                custom_json_post_response
+            )
+            loaded_entity.custom_json_put_response = bool(
+                custom_json_put_response
+            )
+            loaded_entity.custom_json_patch_response = bool(
+                custom_json_patch_response
+            )
+            loaded_entity.custom_json_get_response = bool(
+                custom_json_get_response
+            )
+            loaded_entity.custom_json_list_response = bool(
+                custom_json_list_response
+            )
+            loaded_entity.custom_json_delete_response = bool(
+                custom_json_delete_response
+            )
 
             namespace.loaded_entities[entity_resource] = loaded_entity
 
@@ -582,6 +916,18 @@ class EntityLoader:
             get_function_type_class_name,
             list_function_type_class_name,
             delete_function_type_class_name,
+            bool(retrieve_after_insert),
+            bool(retrieve_after_update),
+            bool(retrieve_after_partial_update),
+            post_response_dto_class_name,
+            put_response_dto_class_name,
+            patch_response_dto_class_name,
+            bool(custom_json_post_response),
+            bool(custom_json_put_response),
+            bool(custom_json_patch_response),
+            bool(custom_json_get_response),
+            bool(custom_json_list_response),
+            bool(custom_json_delete_response),
         )
 
     def _safe_exec(self, source_code, context, description):
@@ -600,6 +946,11 @@ class EntityLoader:
         entity_config_key: str | None,
         escopo: str,
     ) -> tuple[str, str] | None:
+        if not EDLS_FROM_REDIS:
+            return None
+
+        from nsj_rest_lib2.redis_config import get_redis
+
         get_logger().debug(
             f"Procurando a configuração da entidade {entity_resource} no redis. Tenant key: {tenant_key} e Grupo key: {grupo_key}"
         )

nsj_rest_lib2/settings.py

@@ -12,5 +12,15 @@ else:
     MIN_TIME_SOURCE_REFRESH = int(os.getenv("MIN_TIME_SOURCE_REFRESH", "15"))
 
 
+def _get_env_bool(name: str, default: bool) -> bool:
+    value = os.getenv(name)
+    if value is None:
+        return default
+    return value.strip().lower() in ("1", "true", "t", "yes", "y", "on")
+
+
+EDLS_FROM_REDIS = _get_env_bool("EDLS_FROM_REDIS", True)
+
+
 def get_logger():
     return logging.getLogger(APP_NAME)