nsj-rest-lib2 0.0.36__py3-none-any.whl → 0.0.38__py3-none-any.whl

nsj_rest_lib2/compiler/compiler.py

@@ -398,15 +398,13 @@ class EDLCompiler:
             post_expected, post_properties = (
                 response_dto_compiler.handler_result_details(post_handler)
             )
-            put_expected, put_properties = (
-                response_dto_compiler.handler_result_details(put_handler)
+            put_expected, put_properties = response_dto_compiler.handler_result_details(
+                put_handler
             )
             patch_expected, patch_properties = (
                 response_dto_compiler.handler_result_details(patch_handler)
             )
-            get_expected, _ = response_dto_compiler.handler_result_details(
-                get_handler
-            )
+            get_expected, _ = response_dto_compiler.handler_result_details(get_handler)
             list_expected, _ = response_dto_compiler.handler_result_details(
                 list_handler
             )
@@ -471,32 +469,16 @@ class EDLCompiler:
         )
         compiler_result.retrieve_after_insert = post_expected == "entity_row"
         compiler_result.retrieve_after_update = put_expected == "entity_row"
-        compiler_result.retrieve_after_partial_update = (
-            patch_expected == "entity_row"
-        )
+        compiler_result.retrieve_after_partial_update = patch_expected == "entity_row"
         compiler_result.post_response_dto_class_name = compiler_result_post_class
         compiler_result.put_response_dto_class_name = compiler_result_put_class
-        compiler_result.patch_response_dto_class_name = (
-            compiler_result_patch_class
-        )
-        compiler_result.custom_json_post_response = (
-            post_expected == "custom_json"
-        )
-        compiler_result.custom_json_put_response = (
-            put_expected == "custom_json"
-        )
-        compiler_result.custom_json_patch_response = (
-            patch_expected == "custom_json"
-        )
-        compiler_result.custom_json_get_response = (
-            get_expected == "custom_json"
-        )
-        compiler_result.custom_json_list_response = (
-            list_expected == "custom_json"
-        )
-        compiler_result.custom_json_delete_response = (
-            delete_expected == "custom_json"
-        )
+        compiler_result.patch_response_dto_class_name = compiler_result_patch_class
+        compiler_result.custom_json_post_response = post_expected == "custom_json"
+        compiler_result.custom_json_put_response = put_expected == "custom_json"
+        compiler_result.custom_json_patch_response = patch_expected == "custom_json"
+        compiler_result.custom_json_get_response = get_expected == "custom_json"
+        compiler_result.custom_json_list_response = list_expected == "custom_json"
+        compiler_result.custom_json_delete_response = delete_expected == "custom_json"
 
         insert_code_compiled = insert_function_code.strip()
         update_code_compiled = update_function_code.strip()

nsj_rest_lib2/compiler/util/type_naming_util.py

@@ -1,6 +1,8 @@
+import hashlib
 import uuid
-from typing import Iterable
+from typing import Iterable, Iterator, Optional
 
+from nsj_rest_lib2.compiler.model import CompilerResult
 from nsj_rest_lib2.compiler.util.str_util import CompilerStrUtil
 
 
@@ -14,6 +16,67 @@ def compile_namespace_keys(
     return (grupo_key, tenant_key, default_key)
 
 
+def resolve_namespace_key(
+    tenant: str | int | None, grupo_empresarial: str | uuid.UUID | None
+) -> str:
+    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 build_entity_hash(compiler_result: CompilerResult) -> str:
+    hasher = hashlib.sha256()
+
+    for content in _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,
+        compiler_result.post_response_dto_class_name,
+        compiler_result.put_response_dto_class_name,
+        compiler_result.patch_response_dto_class_name,
+        str(compiler_result.retrieve_after_insert),
+        str(compiler_result.retrieve_after_update),
+        str(compiler_result.retrieve_after_partial_update),
+        str(compiler_result.custom_json_post_response),
+        str(compiler_result.custom_json_put_response),
+        str(compiler_result.custom_json_patch_response),
+        str(compiler_result.custom_json_get_response),
+        str(compiler_result.custom_json_list_response),
+        str(compiler_result.custom_json_delete_response),
+        compiler_result.service_account,
+    ):
+        hasher.update(content)
+
+    return hasher.hexdigest()
+
+
+def _iter_hash_chunks(*chunks: Optional[str]) -> Iterator[bytes]:
+    for chunk in chunks:
+        if chunk:
+            yield chunk.encode("utf-8")
+
+
 def compile_dto_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)}DTO"
 

nsj_rest_lib2/controller/dynamic_controller.py

@@ -55,6 +55,7 @@ def setup_dynamic_routes(
     dynamic_root_path: str = "edl1",
     injector_factory: Any = None,
     escopo_in_url: bool = False,
+    edls_path: str | None = None,
 ) -> None:
 
     if not escopo_in_url:
@@ -68,6 +69,8 @@ def setup_dynamic_routes(
             f"/{APP_NAME}/{dynamic_root_path}/<entity_escopo>/<entity_resource>/<id>"
         )
 
+    entity_loader = EntityLoader(edls_path=edls_path)
+
     def _dynamic_route_wrapper(
         route_builder: Callable[[tuple[Any, ...]], Callable[..., Any]],
         endpoint_suffix: str | None = None,
@@ -83,7 +86,6 @@ def setup_dynamic_routes(
             tenant, grupo_empresarial, force_reload = _get_query_args()
 
             try:
-                entity_loader = EntityLoader()
                 entity_config = entity_loader.load_entity_source(
                     entity_resource,
                     tenant,
@@ -156,7 +158,7 @@ def setup_dynamic_routes(
                 custom_json_response=bool(custom_json_list_response),
             )
 
-            return route.handle_request(*args, **kwargs)
+            return route.internal_handle_request(*args, **kwargs)
 
         return list_dynamic
 
@@ -199,7 +201,7 @@ def setup_dynamic_routes(
                 custom_json_response=bool(custom_json_get_response),
             )
 
-            return route.handle_request(*args, **kwargs)
+            return route.internal_handle_request(*args, **kwargs)
 
         return get_dynamic
 
@@ -264,7 +266,7 @@ def setup_dynamic_routes(
                 custom_json_response=bool(custom_json_post_response),
             )
 
-            return route.handle_request(*args, **kwargs)
+            return route.internal_handle_request(*args, **kwargs)
 
         return post_dynamic
 
@@ -329,7 +331,7 @@ def setup_dynamic_routes(
                 custom_json_response=bool(custom_json_put_response),
             )
 
-            return route.handle_request(*args, **kwargs)
+            return route.internal_handle_request(*args, **kwargs)
 
         return put_dynamic
 
@@ -386,7 +388,7 @@ def setup_dynamic_routes(
                 custom_json_response=bool(custom_json_patch_response),
             )
 
-            return route.handle_request(*args, **kwargs)
+            return route.internal_handle_request(*args, **kwargs)
 
         return patch_dynamic
 
@@ -431,7 +433,7 @@ def setup_dynamic_routes(
                 custom_json_response=bool(custom_json_delete_response),
             )
 
-            return route.handle_request(*args, **kwargs)
+            return route.internal_handle_request(*args, **kwargs)
 
         return delete_dynamic
 

nsj_rest_lib2/service/entity_config_writer.py

@@ -1,13 +1,15 @@
 from __future__ import annotations
 
-import hashlib
 import json
-from typing import Any, Dict, Iterator, Optional
+from typing import Any, Dict
 
 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.compiler.util.type_naming_util import (
+    build_entity_hash,
+    resolve_namespace_key,
+)
 from nsj_rest_lib2.redis_config import set_redis
 from nsj_rest_lib2.settings import ESCOPO_RESTLIB2
 
@@ -113,21 +115,7 @@ class EntityConfigWriter:
         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
+        return resolve_namespace_key(tenant, grupo_empresarial)
 
     def _resolve_resource(self, entity_model: EntityModelBase) -> str:
         if not isinstance(entity_model, EntityModel) or not entity_model.api:
@@ -139,41 +127,4 @@ class EntityConfigWriter:
         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.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,
-            compiler_result.post_response_dto_class_name,
-            compiler_result.put_response_dto_class_name,
-            compiler_result.patch_response_dto_class_name,
-            str(compiler_result.retrieve_after_insert),
-            str(compiler_result.retrieve_after_update),
-            str(compiler_result.retrieve_after_partial_update),
-            str(compiler_result.custom_json_post_response),
-            str(compiler_result.custom_json_put_response),
-            str(compiler_result.custom_json_patch_response),
-            str(compiler_result.custom_json_get_response),
-            str(compiler_result.custom_json_list_response),
-            str(compiler_result.custom_json_delete_response),
-            compiler_result.service_account,
-        ):
-            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")
+        return build_entity_hash(compiler_result)

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
@@ -61,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,
@@ -147,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:
@@ -162,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
@@ -185,36 +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,
-                        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,
-                    )
+                    return cached_result
 
                 # Desempacotando resultado
                 entity_config_key, entity_config_str = loaded_config
@@ -229,36 +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,
-                        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,
-                    )
+                    return cached_result
                 else:
                     (
                         dto_class_name,
@@ -322,36 +317,10 @@ class EntityLoader:
                     )
             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,
-                    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,
-                )
+                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(
@@ -451,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.
@@ -469,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,
@@ -590,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:
@@ -703,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
@@ -801,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)

nsj_rest_lib2-0.0.38.dist-info/METADATA

@@ -0,0 +1,203 @@
+Metadata-Version: 2.4
+Name: nsj_rest_lib2
+Version: 0.0.38
+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
+Author-email: contact.dev@nasajon.com.br
+Project-URL: Source, https://github.com/Nasajon/nsj_rest_lib2
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.4
+Description-Content-Type: text/markdown
+Requires-Dist: nsj-rest-lib<7.0.0,>=5.1.3
+Requires-Dist: redis<7.0.0,>=6.4.0
+Requires-Dist: nsj-multi-database-lib<3.0.0,>=2.0.1
+Requires-Dist: pydantic<3.0.0,>=2.11.9
+Requires-Dist: black<26.0.0,>=25.1.0
+Requires-Dist: pyyaml<7.0.0,>=6.0.3
+
+# RestLib2
+
+O RestLib2 é uma plataforma que tem por objetivo o fornecimento de APIs para os clientes, a partir da descrição da entidades envolvidas, e sem a necessidade de programação imperativa tradicional.
+
+Em resumo, a partir da declaração em JSON das entidades que compõe um negócio, bem como dos relacionamentos entre estas, as APIs já estarão disponíveis em produção.
+
+O objetivo final é permitir que o desenvolvimento de APIs se torne rápido e simples, acessível àqueles que tratam diretamente com o negócio (incluindo implantadores, e, no limite, o próprio cliente).
+
+## Links
+
+[Guia do EDL](docs/README.md)
+[ESPECIFICAÇÃO DO MODELO DE ENTIDADES](docs/especificacao.md)
+
+## Rota das APIs geradas
+
+A rota para acesso a uma API gerada por variar de acordo com o modo de configuração escolhido pela aplicação que usar o RestLib2. Mas, via de regra, sugere-se o padrão aplicado na API de DadosMestre:
+
+```http
+#############################
+# List Prod
+#############################
+GET https://api.nasajon.app/dados-mestre/edl1/clientes?tenant=47&grupo_empresarial=NASAJON HTTP/1.1
+Authorization: Bearer *****
+Accept: application/json
+```
+
+* Note que, na API de Dados Mestre, todas as APIs do RestLib2 ficarão debaixo da rota: ```https://api.nasajon.app/dados-mestre/edl1/```
+* O endpoint em si, varia a cada JSON, e fica configurado no nó ```api.resource``` do JSON de EDL em questão.
+
+## Fluxo básico de uso
+
+Há dois modos básicos de publicar novas APIs a partir de um JSON gerado, para uma aplicação previamente configurada para uso da plataforma:
+
+### Fluxo por meio de código versionado
+1. Criar o JSON de descrição da entidade desejada, gravando-o no diretório "@schemas/entities" da aplicação em questão (tome [como exemplo o "dados-mestre"](https://github.com/Nasajon/dados-mestre-api/tree/production/%40schemas)).
+2. Fazer push das alterações.
+3. Aguardar o build da aplicação (pode ser útil conferir os logs do job de atualização dos JSON, na aplicação em questão, e também os logs do [worker de compilação](https://ci.nasajon.in/applications/restlib2?view=pods&conditions=false), no Argo).
+4. Testar as APIs compiladas.
+   
+### Fluxo de deploy direto pela API
+1. Criar o JSON de descrição da entidade desejada.
+2. Registrá-lo diretamente, por meio da API de controle do RestLib2. segue exemplo de chamada abaixo:
+
+```http
+###############################
+# Post dinâmico
+###############################
+POST https://api.nasajon.app/restlib2/entities HTTP/1.1
+Authorization: Bearer ******
+Content-Type: application/json
+
+{
+  "id": "{UUID}",
+  "escopo": "{escopo}",
+  "tenant": 0,
+  "grupo_empresarial": "00000000-0000-0000-0000-000000000000",
+  "codigo": "{codigo da entidade}",
+  "descricao": "{descrição da entidade}",
+  "json_schema": {
+    "edl_version": "1.0",
+    "escopo": "{escopo}",
+    "description": "{descrição da entidade}",
+    "id": "cliente",
+    "version": "0.0.1",
+    ...
+  }
+}
+```
+
+Observações:
+* Note que, acima há placeholders a alterar.
+* Note também que o JSON não está completo, e, o correto é deguir a documentação do EDL.
+* Os valores tenant=0 e grupo_empresarial=00000000-0000-0000-0000-000000000000, indicam que a entidade é padrão, e serve para todos os tenants e grupos.
+
+3. Essa rota irá retornar algo semelhante a:
+
+```http
+HTTP/1.1 202 ACCEPTED
+Location: https://api.nasajon.app/restlib2/entity-compilations/status/{UUID do processo de compilação}
+```
+
+E, se você fizer uma chamada à rota retornada, poderá acompanhar o status da compilação, incluindo eventuais erros que venham a ocorrer.
+
+4. Testar a API compilada.
+
+## Como rodar a compilação de EDLs localmente?
+
+Você pode testar a compilação de seus EDLs localmente, incluindo a execução de diversas validações sobre os mesmos, desde que todos estejam dispostos num mesmo diertório.
+
+Para isso, considere os passos a seguir:
+
+1. Crie um diretório, e coloque todos os seus EDLs lá (garantindo que EDLs relacionados estejam no mesmo).
+2. Instale, no seu ambiente pyhton de teste, a biblioteca `nsj-rest-lib2`:
+   
+```sh
+pip install nsj-rest-lib2
+```
+
+3. Rode o comando abaixo (adaptado para seu diretório):
+```sh
+python3 -m nsj_rest_lib2.compiler.compiler -d $(shell pwd)/{diretorio_com_os_edls_json}
+```
+
+O resultado da compilação será impresso no console (erros, ou código total gerado).
+
+## Como configurar uma aplicação para expôr rotas de acordo com o padrão do RestLib2?
+
+Para que uma aplicação exponha as rotas no padrão do RestLib2, não são necessários muitos passos. Antes basta:
+
+1. Instalar, em sua aplicação, a dependência para o projeto nsj-rest-lib2
+
+```sh
+pip install nsj-rest-lib2
+```
+
+Não esqueça de fixar a versão usada (como sendo a última), no arquivo requirements.txt.
+
+2. Adicione a variável de ambiente abaixo em sua aplciação
+
+```env
+ESCOPO_RESTLIB2: "{COLOQUE O IDENTIFICADOR DE ESCOPO QUE DESEJAR PARA SUA APLICAÇÃO (UMA SIMPLES STRING SEM ESPAÇO)}"
+```
+
+* Esse identificador de escopo deve se único para sua aplicação.
+* É importante nota que sua aplicação só irá expôr JSONs de EDL configurados para o mesmo escopo definido aqui.
+
+3. Instale, como dependência a biblioteca, nsj-rest-lib2:
+
+```sh
+pip install nsj-rest-lib2
+```
+
+Não esqueça de fixar a versão usada (como sendo a última), no arquivo requirements.txt.
+
+4. Adicione a linha abaixo no arquivo wsgi.py (de inicilização de sua aplicação):
+
+```python
+from nsj_rest_lib2.controller.dynamic_controller import setup_dynamic_routes
+from nasajon.injector_factory_multibanco import InjectorFactoryMultibanco
+
+setup_dynamic_routes(application, injector_factory=InjectorFactoryMultibanco)
+```
+
+* No exemplo acima, a rota é multibanco, mas, não é obrigatório.
+* Os parâmetros de setup são:
+  * flask_app: Variável obrigatório, que aponte para sua aplicação Flask.
+  * multidb: Flag (padrão True)
+  * dynamic_root_path: URL padrão base de todos os endpoints do RestLib2 (padrão: "edl1")
+  * injector_factory: Classe de injeção de depndência usada (normalmente necessária para aplicações multibanco; o principal uso é justamente manipular a criação da conexão com o BD).
+
+## Carregando EDLs direto do disco
+
+Também é possível carregar EDLs diretamente do disco, sem depender exclusivamente do Redis. Para isso, use o parâmetro opcional `edls_path` em `setup_dynamic_routes`, apontando para um caminho relativo ao workdir da aplicação (ou absoluto), contendo arquivos `.json`, `.yml` ou `.yaml` com os EDLs.
+
+Exemplo:
+
+```python
+from nsj_rest_lib2.controller.dynamic_controller import setup_dynamic_routes
+
+setup_dynamic_routes(
+    application,
+    injector_factory=InjectorFactoryMultibanco,
+    edls_path="@schemas/entities",
+)
+```
+
+Observações:
+* Os EDLs são carregados e compilados uma vez, ficando em cache em memória. Chamadas seguintes reutilizam o cache.
+* A resolução das entidades ocorre primeiro pelo cache local; se não encontrar, o Redis é consultado (quando habilitado).
+
+Para desabilitar o Redis e usar somente EDLs do disco, defina a variável de ambiente abaixo:
+
+```env
+EDLS_FROM_REDIS=false
+```
+
+O valor padrão de `EDLS_FROM_REDIS` é `true`.
+
+
+**Pronto, isso deve bastar para expôr os EDLs configurados para o mesmo escopo da aplicação.**
+
+**OBSERVAÇÃO GERAL: Isso só funciona para aplicações Flask.**

{nsj_rest_lib2-0.0.36.dist-info → nsj_rest_lib2-0.0.38.dist-info}/RECORD

@@ -1,9 +1,9 @@
 nsj_rest_lib2/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nsj_rest_lib2/exception.py,sha256=E9uMUdoCCQOVQfc8f6gD9b5Pxurf3Q4SytDCcqSlkZ8,56
 nsj_rest_lib2/redis_config.py,sha256=4KLcvYS3nJO7PMQgF6F9_j6r-TyqcS7TBbd3LEQuKDU,629
-nsj_rest_lib2/settings.py,sha256=Hn_o1HZmievnYb8D1kNT2Nq-OEjxbyNjOiOpbnFsMwE,367
+nsj_rest_lib2/settings.py,sha256=eK2aIFVhZK8kxEDHCW5agba5XP2aFPoh_PFnNLwCMH8,627
 nsj_rest_lib2/compiler/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nsj_rest_lib2/compiler/compiler.py,sha256=z-u9UeOhNKxH6bwaPWTxkN_SJjgZ6tGJD_iXc2D2Hr4,39433
+nsj_rest_lib2/compiler/compiler.py,sha256=fiDDkLyc-E4b21j3LHZSiFRhBb4VY5cbxqFeZhjGVjw,39209
 nsj_rest_lib2/compiler/compiler_structures.py,sha256=stspjqJGXU7Vz3BqQ-ZF5ZmumFm3R4jpkWgVVsXW5d0,1488
 nsj_rest_lib2/compiler/dto_compiler.py,sha256=kT9v8z0MMHYGkVudkJA0VUY1tNCM7QzV6_RV-aWjSoE,7143
 nsj_rest_lib2/compiler/entity_compiler.py,sha256=LeGEBxsjAmZZog2gh4vjUX1aFp9JSVgHHOdTkY0aH-s,6733
@@ -32,18 +32,18 @@ nsj_rest_lib2/compiler/edl_model/trait_property_meta_model.py,sha256=NtMVZeOPu3L
 nsj_rest_lib2/compiler/util/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nsj_rest_lib2/compiler/util/relation_ref.py,sha256=1M_e-NyeqozlIYLl1rB76KqkmtMvgtqH_nJS-NK0Pck,3695
 nsj_rest_lib2/compiler/util/str_util.py,sha256=0ReIQ2Vy4zAmVMvGv0FcUehRQw15hlz0e7yDsF89ghk,1178
-nsj_rest_lib2/compiler/util/type_naming_util.py,sha256=RAiYSM_tzRmfQZCCiH7_q6AAPB2_M24df6Ve_3LHQyc,2877
+nsj_rest_lib2/compiler/util/type_naming_util.py,sha256=WKBqGZ0a-JO1IO5Q_rHVpLBESUmbc5D_lgF9DWBwkpk,5065
 nsj_rest_lib2/compiler/util/type_util.py,sha256=HTKOH4uRTOY0YgoM8oUv_6cEcReE_bgKYXFBsQCb-3A,357
 nsj_rest_lib2/controller/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nsj_rest_lib2/controller/dynamic_controller.py,sha256=B9cVzJf61O0dJf7UymFz60wzjQMLoUVqEK4g_ccAi-U,17432
+nsj_rest_lib2/controller/dynamic_controller.py,sha256=fgwUUiymg_ECA6kms5hf_-rFmnZTzkGhePv2gvKy_fw,17528
 nsj_rest_lib2/dto/__init__.py,sha256=MsSFjiLMLJZ7QhUPpVBWKiyDnCzryquRyr329NoCACI,2
 nsj_rest_lib2/dto/escopo_dto.py,sha256=R9gxRwYxOVYhGjR3q03_iXvHm14N905zbRKLsS3jI-A,1393
 nsj_rest_lib2/entity/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nsj_rest_lib2/entity/escopo_entity.py,sha256=T4bxFDzHJvIj-nZ_6d0Xh2oQg21HgoRjp19nt6clY18,338
 nsj_rest_lib2/service/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nsj_rest_lib2/service/entity_config_writer.py,sha256=YBYo8a6H8zqt8CqKzPYCtrYjMnT2IOY8-KkJ8-6tPBs,7831
-nsj_rest_lib2/service/entity_loader.py,sha256=WNmnKcRYHPT44eiXXpiMglflJWx3BeqwXdenpXuNJsM,34237
-nsj_rest_lib2-0.0.36.dist-info/METADATA,sha256=lFFBWAgH8YMBDpaDjFpSHeBbT42L7JGXNigD1WkiO7g,1094
-nsj_rest_lib2-0.0.36.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-nsj_rest_lib2-0.0.36.dist-info/top_level.txt,sha256=L6zh0EfH8_rur7OJ8_V-El-XEMf4qg3bkF8ADgqLVIA,14
-nsj_rest_lib2-0.0.36.dist-info/RECORD,,
+nsj_rest_lib2/service/entity_config_writer.py,sha256=QVgEO3Tv5g3dK8MQgCrWD9BZyCKV-BxBLfYNFi53PX8,5806
+nsj_rest_lib2/service/entity_loader.py,sha256=kCAt0uKgnrw4gr48_xjspLDQzl_5PxyUYnM8W1YzIxs,39775
+nsj_rest_lib2-0.0.38.dist-info/METADATA,sha256=wLrQQsYtubI7njehcqfLtwFtRmzuJ750EmxeFAx6eN4,8260
+nsj_rest_lib2-0.0.38.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+nsj_rest_lib2-0.0.38.dist-info/top_level.txt,sha256=L6zh0EfH8_rur7OJ8_V-El-XEMf4qg3bkF8ADgqLVIA,14
+nsj_rest_lib2-0.0.38.dist-info/RECORD,,

{nsj_rest_lib2-0.0.36.dist-info → nsj_rest_lib2-0.0.38.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

nsj_rest_lib2-0.0.36.dist-info/METADATA

@@ -1,27 +0,0 @@
-Metadata-Version: 2.4
-Name: nsj_rest_lib2
-Version: 0.0.36
-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
-Author-email: contact.dev@nasajon.com.br
-Project-URL: Source, https://github.com/Nasajon/nsj_rest_lib2
-Classifier: Development Status :: 3 - Alpha
-Classifier: Intended Audience :: Developers
-Classifier: Topic :: Software Development :: Libraries
-Classifier: Programming Language :: Python :: 3
-Requires-Python: >=3.4
-Description-Content-Type: text/markdown
-Requires-Dist: nsj-rest-lib<7.0.0,>=5.1.3
-Requires-Dist: redis<7.0.0,>=6.4.0
-Requires-Dist: nsj-multi-database-lib<3.0.0,>=2.0.1
-Requires-Dist: pydantic<3.0.0,>=2.11.9
-Requires-Dist: black<26.0.0,>=25.1.0
-Requires-Dist: pyyaml<7.0.0,>=6.0.3
-
-# nsj_rest_lib2
-
-Biblioteca para permitir a distribuição de rotas dinâmicas numa API, configuradas por meio de EDLs declarativos (em formato JSON).
-
-[ESPECIFICAÇÃO DO MODELO DE ENTIDADES](docs/especificacao.md)
-