nsj-rest-lib2 0.0.7__py3-none-any.whl → 0.0.9__py3-none-any.whl

nsj_rest_lib2/compiler/util/type_naming_util.py

@@ -0,0 +1,21 @@
+import uuid
+
+from nsj_rest_lib2.compiler.util.str_util import CompilerStrUtil
+
+
+def compile_namespace_keys(
+    tenant: str | int | None, grupo_empresarial: str | uuid.UUID | None
+) -> tuple[str, str, str]:
+    grupo_key = f"tenant_{tenant}.ge_{grupo_empresarial}"
+    tenant_key = f"tenant_{tenant}"
+    default_key = "default"
+
+    return (grupo_key, tenant_key, default_key)
+
+
+def compile_dto_class_name(entity_id: str) -> str:
+    return f"{CompilerStrUtil.to_pascal_case(entity_id)}DTO"
+
+
+def compile_entity_class_name(entity_id: str) -> str:
+    return f"{CompilerStrUtil.to_pascal_case(entity_id)}Entity"

nsj_rest_lib2/controller/dynamic_controller.py

@@ -55,17 +55,17 @@ def setup_dynamic_routes(
     injector_factory: Any = None,
 ) -> None:
 
-    COLLECTION_DYNAMIC_ROUTE = f"/{APP_NAME}/{dynamic_root_path}/<entity_id>"
-    ONE_DYNAMIC_ROUTE = f"/{APP_NAME}/{dynamic_root_path}/<entity_id>/<id>"
+    COLLECTION_DYNAMIC_ROUTE = f"/{APP_NAME}/{dynamic_root_path}/<entity_resource>"
+    ONE_DYNAMIC_ROUTE = f"/{APP_NAME}/{dynamic_root_path}/<entity_resource>/<id>"
 
     def list_dynamic_wrapper(injector_factory: Any, *args: Any, **kwargs: Any) -> Any:
 
         def list_dynamic(*args: Any, **kwargs: Any):
             # Recuperando o identificador da entidade
-            if "entity_id" not in kwargs:
+            if "entity_resource" not in kwargs:
                 msg = "Faltando parâmetro identificador da entidade na URL."
                 return (format_json_error(msg), 400, {**DEFAULT_RESP_HEADERS})
-            entity_id = kwargs.pop("entity_id")
+            entity_resource = kwargs.pop("entity_resource")
 
             # Lendo tenant e grupo_empresarial
             tenant, grupo_empresarial = _get_tenant_grupo()
@@ -73,12 +73,20 @@ def setup_dynamic_routes(
             try:
                 # Recuperando o código do DTO e Entity correspondente
                 entity_loader = EntityLoader()
-                dto_class_name, entity_class_name, etities_dict = (
-                    entity_loader.load_entity_source(
-                        entity_id, tenant, grupo_empresarial
-                    )
+                (
+                    dto_class_name,
+                    entity_class_name,
+                    etities_dict,
+                    api_expose,
+                    api_verbs,
+                ) = entity_loader.load_entity_source(
+                    entity_resource, tenant, grupo_empresarial
                 )
 
+                # Verificando se essa API deve ser exposta
+                if not api_expose or "GET" not in api_verbs:
+                    return ("", 405, {})
+
                 # Executando o list pelo RestLib
                 route = ListRoute(
                     url=COLLECTION_DYNAMIC_ROUTE,
@@ -90,7 +98,7 @@ def setup_dynamic_routes(
 
                 return route.handle_request(*args, **kwargs)
             except MissingEntityConfigException:
-                msg = f"Entity configuration for {entity_id} not found."
+                msg = f"Entity configuration for {entity_resource} not found."
                 return (format_json_error(msg), 412, {**DEFAULT_RESP_HEADERS})
 
         return list_dynamic
@@ -99,10 +107,10 @@ def setup_dynamic_routes(
 
         def get_dynamic(*args: Any, **kwargs: Any):
             # Recuperando o identificador da entidade
-            if "entity_id" not in kwargs:
+            if "entity_resource" not in kwargs:
                 msg = "Faltando parâmetro identificador da entidade na URL."
                 return (format_json_error(msg), 400, {**DEFAULT_RESP_HEADERS})
-            entity_id = kwargs.pop("entity_id")
+            entity_resource = kwargs.pop("entity_resource")
 
             # Lendo tenant e grupo_empresarial
             tenant, grupo_empresarial = _get_tenant_grupo()
@@ -110,12 +118,20 @@ def setup_dynamic_routes(
             try:
                 # Recuperando o código do DTO e Entity correspondente
                 entity_loader = EntityLoader()
-                dto_class_name, entity_class_name, etities_dict = (
-                    entity_loader.load_entity_source(
-                        entity_id, tenant, grupo_empresarial
-                    )
+                (
+                    dto_class_name,
+                    entity_class_name,
+                    etities_dict,
+                    api_expose,
+                    api_verbs,
+                ) = entity_loader.load_entity_source(
+                    entity_resource, tenant, grupo_empresarial
                 )
 
+                # Verificando se essa API deve ser exposta
+                if not api_expose or "GET" not in api_verbs:
+                    return ("", 405, {})
+
                 # Executando o list pelo RestLib
                 route = GetRoute(
                     url=ONE_DYNAMIC_ROUTE,
@@ -127,7 +143,7 @@ def setup_dynamic_routes(
 
                 return route.handle_request(*args, **kwargs)
             except MissingEntityConfigException:
-                msg = f"Entity configuration for {entity_id} not found."
+                msg = f"Entity configuration for {entity_resource} not found."
                 return (format_json_error(msg), 412, {**DEFAULT_RESP_HEADERS})
 
         return get_dynamic
@@ -135,10 +151,10 @@ def setup_dynamic_routes(
     def post_dynamic_wrapper(injector_factory: Any, *args: Any, **kwargs: Any) -> Any:
         def post_dynamic(*args: Any, **kwargs: Any):
             # Recuperando o identificador da entidade
-            if "entity_id" not in kwargs:
+            if "entity_resource" not in kwargs:
                 msg = "Faltando parâmetro identificador da entidade na URL."
                 return (format_json_error(msg), 400, {**DEFAULT_RESP_HEADERS})
-            entity_id = kwargs.pop("entity_id")
+            entity_resource = kwargs.pop("entity_resource")
 
             # Lendo tenant e grupo_empresarial
             tenant, grupo_empresarial = _get_tenant_grupo()
@@ -146,12 +162,20 @@ def setup_dynamic_routes(
             try:
                 # Recuperando o código do DTO e Entity correspondente
                 entity_loader = EntityLoader()
-                dto_class_name, entity_class_name, etities_dict = (
-                    entity_loader.load_entity_source(
-                        entity_id, tenant, grupo_empresarial
-                    )
+                (
+                    dto_class_name,
+                    entity_class_name,
+                    etities_dict,
+                    api_expose,
+                    api_verbs,
+                ) = entity_loader.load_entity_source(
+                    entity_resource, tenant, grupo_empresarial
                 )
 
+                # Verificando se essa API deve ser exposta
+                if not api_expose or "POST" not in api_verbs:
+                    return ("", 405, {})
+
                 # Executando o list pelo RestLib
                 route = PostRoute(
                     url=COLLECTION_DYNAMIC_ROUTE,
@@ -163,7 +187,7 @@ def setup_dynamic_routes(
 
                 return route.handle_request(*args, **kwargs)
             except MissingEntityConfigException:
-                msg = f"Entity configuration for {entity_id} not found."
+                msg = f"Entity configuration for {entity_resource} not found."
                 return (format_json_error(msg), 412, {**DEFAULT_RESP_HEADERS})
 
         return post_dynamic
@@ -171,10 +195,10 @@ def setup_dynamic_routes(
     def put_dynamic_wrapper(injector_factory: Any, *args: Any, **kwargs: Any) -> Any:
         def put_dynamic(*args: Any, **kwargs: Any):
             # Recuperando o identificador da entidade
-            if "entity_id" not in kwargs:
+            if "entity_resource" not in kwargs:
                 msg = "Faltando parâmetro identificador da entidade na URL."
                 return (format_json_error(msg), 400, {**DEFAULT_RESP_HEADERS})
-            entity_id = kwargs.pop("entity_id")
+            entity_resource = kwargs.pop("entity_resource")
 
             # Lendo tenant e grupo_empresarial
             tenant, grupo_empresarial = _get_tenant_grupo()
@@ -182,12 +206,20 @@ def setup_dynamic_routes(
             try:
                 # Recuperando o código do DTO e Entity correspondente
                 entity_loader = EntityLoader()
-                dto_class_name, entity_class_name, etities_dict = (
-                    entity_loader.load_entity_source(
-                        entity_id, tenant, grupo_empresarial
-                    )
+                (
+                    dto_class_name,
+                    entity_class_name,
+                    etities_dict,
+                    api_expose,
+                    api_verbs,
+                ) = entity_loader.load_entity_source(
+                    entity_resource, tenant, grupo_empresarial
                 )
 
+                # Verificando se essa API deve ser exposta
+                if not api_expose or "PUT" not in api_verbs:
+                    return ("", 405, {})
+
                 # Executando o list pelo RestLib
                 route = PutRoute(
                     url=ONE_DYNAMIC_ROUTE,
@@ -199,7 +231,7 @@ def setup_dynamic_routes(
 
                 return route.handle_request(*args, **kwargs)
             except MissingEntityConfigException:
-                msg = f"Entity configuration for {entity_id} not found."
+                msg = f"Entity configuration for {entity_resource} not found."
                 return (format_json_error(msg), 412, {**DEFAULT_RESP_HEADERS})
 
         return put_dynamic
@@ -207,10 +239,10 @@ def setup_dynamic_routes(
     def patch_dynamic_wrapper(injector_factory: Any, *args: Any, **kwargs: Any) -> Any:
         def patch_dynamic(*args: Any, **kwargs: Any):
             # Recuperando o identificador da entidade
-            if "entity_id" not in kwargs:
+            if "entity_resource" not in kwargs:
                 msg = "Faltando parâmetro identificador da entidade na URL."
                 return (format_json_error(msg), 400, {**DEFAULT_RESP_HEADERS})
-            entity_id = kwargs.pop("entity_id")
+            entity_resource = kwargs.pop("entity_resource")
 
             # Lendo tenant e grupo_empresarial
             tenant, grupo_empresarial = _get_tenant_grupo()
@@ -218,12 +250,20 @@ def setup_dynamic_routes(
             try:
                 # Recuperando o código do DTO e Entity correspondente
                 entity_loader = EntityLoader()
-                dto_class_name, entity_class_name, etities_dict = (
-                    entity_loader.load_entity_source(
-                        entity_id, tenant, grupo_empresarial
-                    )
+                (
+                    dto_class_name,
+                    entity_class_name,
+                    etities_dict,
+                    api_expose,
+                    api_verbs,
+                ) = entity_loader.load_entity_source(
+                    entity_resource, tenant, grupo_empresarial
                 )
 
+                # Verificando se essa API deve ser exposta
+                if not api_expose or "PATCH" not in api_verbs:
+                    return ("", 405, {})
+
                 # Executando o list pelo RestLib
                 route = PatchRoute(
                     url=ONE_DYNAMIC_ROUTE,
@@ -235,7 +275,7 @@ def setup_dynamic_routes(
 
                 return route.handle_request(*args, **kwargs)
             except MissingEntityConfigException:
-                msg = f"Entity configuration for {entity_id} not found."
+                msg = f"Entity configuration for {entity_resource} not found."
                 return (format_json_error(msg), 412, {**DEFAULT_RESP_HEADERS})
 
         return patch_dynamic
@@ -243,10 +283,10 @@ def setup_dynamic_routes(
     def delete_dynamic_wrapper(injector_factory: Any, *args: Any, **kwargs: Any) -> Any:
         def delete_dynamic(*args: Any, **kwargs: Any):
             # Recuperando o identificador da entidade
-            if "entity_id" not in kwargs:
+            if "entity_resource" not in kwargs:
                 msg = "Faltando parâmetro identificador da entidade na URL."
                 return (format_json_error(msg), 400, {**DEFAULT_RESP_HEADERS})
-            entity_id = kwargs.pop("entity_id")
+            entity_resource = kwargs.pop("entity_resource")
 
             # Lendo tenant e grupo_empresarial
             tenant, grupo_empresarial = _get_tenant_grupo()
@@ -254,12 +294,20 @@ def setup_dynamic_routes(
             try:
                 # Recuperando o código do DTO e Entity correspondente
                 entity_loader = EntityLoader()
-                dto_class_name, entity_class_name, etities_dict = (
-                    entity_loader.load_entity_source(
-                        entity_id, tenant, grupo_empresarial
-                    )
+                (
+                    dto_class_name,
+                    entity_class_name,
+                    etities_dict,
+                    api_expose,
+                    api_verbs,
+                ) = entity_loader.load_entity_source(
+                    entity_resource, tenant, grupo_empresarial
                 )
 
+                # Verificando se essa API deve ser exposta
+                if not api_expose or "DELETE" not in api_verbs:
+                    return ("", 405, {})
+
                 # Executando o list pelo RestLib
                 route = DeleteRoute(
                     url=ONE_DYNAMIC_ROUTE,
@@ -271,7 +319,7 @@ def setup_dynamic_routes(
 
                 return route.handle_request(*args, **kwargs)
             except MissingEntityConfigException:
-                msg = f"Entity configuration for {entity_id} not found."
+                msg = f"Entity configuration for {entity_resource} not found."
                 return (format_json_error(msg), 412, {**DEFAULT_RESP_HEADERS})
 
         return delete_dynamic

nsj_rest_lib2/service/entity_loader.py

@@ -6,6 +6,7 @@ import types
 
 from nsj_rest_lib.settings import get_logger
 
+from nsj_rest_lib2.compiler.util.type_naming_util import compile_namespace_keys
 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
@@ -18,6 +19,8 @@ class LoadedEntity:
         self.entity_class_name: str = ""
         self.entity_hash: str = ""
         self.loaded_at: datetime.datetime = datetime.datetime.now()
+        self.api_expose: bool = False
+        self.api_verbs: list[str] = []
 
 
 class Namespace:
@@ -37,17 +40,17 @@ class EntityLoader:
 
     def load_entity_source(
         self,
-        entity_id: str,
+        entity_resource: str,
         tenant: str | None,
         grupo_empresarial: str | None,
-    ) -> tuple[str, str, dict]:
+    ) -> tuple[str, str, dict, bool, list[str]]:
         # Montando as chaves dos namespaces
-        grupo_key = f"tenant_{tenant}.ge_{grupo_empresarial}"
-        tenant_key = f"tenant_{tenant}"
-        default_key = "default"
+        grupo_key, tenant_key, default_key = compile_namespace_keys(
+            tenant, grupo_empresarial
+        )
 
         result = self._load_entity_source_from_memory(
-            entity_id, grupo_key, tenant_key, default_key
+            entity_resource, grupo_key, tenant_key, default_key
         )
 
         # Se conseguiu carregar da memória, verifica se houve alteração no hash, em relação ao redis
@@ -58,24 +61,39 @@ class EntityLoader:
                 namespace,
             ) = result
 
-            loaded_entity = namespace.loaded_entities[entity_id]
+            loaded_entity = namespace.loaded_entities[entity_resource]
             dto_class_name = loaded_entity.dto_class_name
             entity_class_name = loaded_entity.entity_class_name
             entities_dict = namespace.entities_dict
+            api_expose = loaded_entity.api_expose
+            api_verbs = loaded_entity.api_verbs
 
             # 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
 
             if time_diff.total_seconds() >= MIN_TIME_SOURCE_REFRESH * 60:
+                # Renovando o tempo de refresh
+                loaded_entity.loaded_at = datetime.datetime.now()
+
                 # Recuperando do Redis direto pela key (faz uma só chamada ao redis)
                 loaded_config = self._load_entity_config_from_redis(
-                    entity_id, grupo_key, tenant_key, default_key, entity_config_key
+                    entity_resource,
+                    grupo_key,
+                    tenant_key,
+                    default_key,
+                    entity_config_key,
                 )
 
                 # 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)
+                    return (
+                        dto_class_name,
+                        entity_class_name,
+                        entities_dict,
+                        api_expose,
+                        api_verbs,
+                    )
 
                 # Desempacotando resultado
                 entity_config_key, entity_config_str = loaded_config
@@ -84,23 +102,47 @@ class EntityLoader:
                 result_execute = self._execute_entity_source(
                     entity_config_str,
                     entity_config_key,
-                    entity_id,
+                    entity_resource,
                     check_refresh=True,
                 )
 
                 # 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)
+                    return (
+                        dto_class_name,
+                        entity_class_name,
+                        entities_dict,
+                        api_expose,
+                        api_verbs,
+                    )
                 else:
-                    dto_class_name, entity_class_name, namespace = result_execute
-                    return (dto_class_name, entity_class_name, namespace.entities_dict)
+                    (
+                        dto_class_name,
+                        entity_class_name,
+                        namespace,
+                        api_expose,
+                        api_verbs,
+                    ) = result_execute
+                    return (
+                        dto_class_name,
+                        entity_class_name,
+                        namespace.entities_dict,
+                        api_expose,
+                        api_verbs,
+                    )
             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)
+                return (
+                    dto_class_name,
+                    entity_class_name,
+                    entities_dict,
+                    api_expose,
+                    api_verbs,
+                )
 
         # Se não conseguir recuperar a entidade, procura no redis:
         loaded_config = self._load_entity_config_from_redis(
-            entity_id, grupo_key, tenant_key, default_key, None
+            entity_resource, grupo_key, tenant_key, default_key, None
         )
 
         # Se também não achar no redis, lanca exceção
@@ -112,14 +154,24 @@ class EntityLoader:
 
         # Executando o código da entidade
         result_execute = self._execute_entity_source(
-            entity_config_str, entity_config_key, entity_id
+            entity_config_str, entity_config_key, entity_resource
         )
 
         if result_execute is None:
-            raise RuntimeError(f"Erro desconhecido carregando entidade: {entity_id}")
-        dto_class_name, entity_class_name, namespace = result_execute
+            raise RuntimeError(
+                f"Erro desconhecido carregando entidade: {entity_resource}"
+            )
+        dto_class_name, entity_class_name, namespace, api_expose, api_verbs = (
+            result_execute
+        )
 
-        return (dto_class_name, entity_class_name, namespace.entities_dict)
+        return (
+            dto_class_name,
+            entity_class_name,
+            namespace.entities_dict,
+            api_expose,
+            api_verbs,
+        )
 
     def clear_namespaces(self):
         """
@@ -131,13 +183,25 @@ class EntityLoader:
         with self._lock:
             namespaces_dict.clear()
 
+    def _ensure_dynamic_package(self):
+        """
+        Garante que exista um pacote 'dynamic' em sys.modules.
+        """
+        pkg = sys.modules.get("dynamic")
+        if pkg is None:
+            pkg = types.ModuleType("dynamic")
+            pkg.__path__ = []  # marca como pacote
+            pkg.__package__ = "dynamic"
+            sys.modules["dynamic"] = pkg
+        return pkg
+
     def _execute_entity_source(
         self,
         entity_config_str: str,
         entity_config_key: str,
-        entity_id: str,
+        entity_resource: str,
         check_refresh: bool = False,
-    ) -> tuple[str, str, Namespace] | None:
+    ) -> tuple[str, str, Namespace, bool, list[str]] | None:
         # Interpretando o json de configuração da entidade
         try:
             entity_config = json.loads(entity_config_str)
@@ -147,14 +211,18 @@ class EntityLoader:
             source_dto = entity_config["source_dto"]
             source_entity = entity_config["source_entity"]
             entity_hash = entity_config["entity_hash"]
+
+            api_expose = entity_config["api_expose"]
+            # api_resource = entity_config["api_resource"]
+            api_verbs = entity_config["api_verbs"]
         except json.JSONDecodeError as e:
             if not check_refresh:
                 raise RuntimeError(
-                    f"Erro ao decodificar JSON da entidade {entity_id}; na chave {entity_config_key}: {e}"
+                    f"Erro ao decodificar JSON da entidade {entity_resource}; na chave {entity_config_key}: {e}"
                 )
             else:
                 get_logger().error(
-                    f"Erro ao decodificar JSON da entidade {entity_id}; na chave {entity_config_key}: {e}"
+                    f"Erro ao decodificar JSON da entidade {entity_resource}; na chave {entity_config_key}: {e}"
                 )
                 return None
 
@@ -164,7 +232,7 @@ class EntityLoader:
             if not loaded_namespace:
                 return None
 
-            loaded_entity = loaded_namespace.loaded_entities.get(entity_id)
+            loaded_entity = loaded_namespace.loaded_entities.get(entity_resource)
             if not loaded_entity:
                 return None
 
@@ -173,24 +241,37 @@ class EntityLoader:
 
         # Imprimindo alerta de load no log
         get_logger().debug(
-            f"Carregando entidade {entity_id} no namespace {entity_config_key}."
+            f"Carregando entidade {entity_resource} no namespace {entity_config_key}."
         )
 
         # Carregando a entidade no namespace
         with self._lock:
+            self._ensure_dynamic_package()
+
             namespace = namespaces_dict.get(entity_config_key)
             if namespace is None:
                 namespace = Namespace()
                 namespace.key = entity_config_key
                 namespaces_dict[entity_config_key] = namespace
 
+            # Hot reload: removendo o módulo do sys.modules, se existir
+            full_name = f"dynamic.{entity_config_key}"
+            # if full_name in sys.modules:
+            #     sys.modules.pop(full_name)
+
             # Executando o código da entidade
-            module = types.ModuleType(entity_config_key)
-            sys.modules[entity_config_key] = module
-            module.__dict__["__builtins__"] = __builtins__
+            module = sys.modules.get(full_name)
+            if not module:
+                module = types.ModuleType(full_name)
+                module.__package__ = "dynamic"
+                module.__dict__["__builtins__"] = __builtins__
+                sys.modules[full_name] = module
+
+                parent = sys.modules["dynamic"]
+                setattr(parent, entity_config_key, module)
 
-            namespace.module = module
-            namespace.entities_dict = module.__dict__
+                namespace.module = module
+                namespace.entities_dict = module.__dict__
 
             self._safe_exec(source_dto, namespace.entities_dict, "DTO source")
             self._safe_exec(source_entity, namespace.entities_dict, "Entity source")
@@ -200,10 +281,12 @@ class EntityLoader:
             loaded_entity.dto_class_name = dto_class_name
             loaded_entity.entity_class_name = entity_class_name
             loaded_entity.entity_hash = entity_hash
+            loaded_entity.api_expose = api_expose
+            loaded_entity.api_verbs = api_verbs
 
-            namespace.loaded_entities[entity_id] = loaded_entity
+            namespace.loaded_entities[entity_resource] = loaded_entity
 
-        return (dto_class_name, entity_class_name, namespace)
+        return (dto_class_name, entity_class_name, namespace, api_expose, api_verbs)
 
     def _safe_exec(self, source_code, context, description):
         try:
@@ -214,35 +297,35 @@ class EntityLoader:
 
     def _load_entity_config_from_redis(
         self,
-        entity_id: str,
+        entity_resource: str,
         grupo_key: str,
         tenant_key: str,
         default_key: str,
         entity_config_key: str | None,
     ) -> tuple[str, str] | None:
         get_logger().debug(
-            f"Procurando a configuração da entidade {entity_id} no redis"
+            f"Procurando a configuração da entidade {entity_resource} no redis"
         )
 
         if entity_config_key is not None:
             entity_config_str = get_redis(
-                "entity_config", ESCOPO_RESTLIB2, entity_config_key, entity_id
+                "entity_config", ESCOPO_RESTLIB2, entity_config_key, entity_resource
             )
 
         else:
             entity_config_key = grupo_key
             entity_config_str = get_redis(
-                "entity_config", ESCOPO_RESTLIB2, grupo_key, entity_id
+                "entity_config", ESCOPO_RESTLIB2, grupo_key, entity_resource
             )
             if entity_config_str is None:
                 entity_config_key = tenant_key
                 entity_config_str = get_redis(
-                    "entity_config", ESCOPO_RESTLIB2, tenant_key, entity_id
+                    "entity_config", ESCOPO_RESTLIB2, tenant_key, entity_resource
                 )
             if entity_config_str is None:
                 entity_config_key = default_key
                 entity_config_str = get_redis(
-                    "entity_config", ESCOPO_RESTLIB2, default_key, entity_id
+                    "entity_config", ESCOPO_RESTLIB2, default_key, entity_resource
                 )
 
         # Se não encontrar no redis, retorna None
@@ -253,7 +336,7 @@ class EntityLoader:
 
     def _load_entity_source_from_memory(
         self,
-        entity_id: str,
+        entity_resource: str,
         grupo_key: str,
         tenant_key: str,
         default_key: str,
@@ -263,19 +346,19 @@ class EntityLoader:
 
         # Pesquisando a entidade no namespace mais específico (grupo_empresarial)
         grupo_namespace = namespaces_dict.get(grupo_key)
-        if grupo_namespace and entity_id in grupo_namespace.loaded_entities:
+        if grupo_namespace and entity_resource in grupo_namespace.loaded_entities:
             entity_config_key = grupo_key
             namespace = grupo_namespace
 
         # Pesquisando a entidade no namespace intermediário (tenant)
         tenant_namespace = namespaces_dict.get(tenant_key)
-        if tenant_namespace and entity_id in tenant_namespace.loaded_entities:
+        if tenant_namespace and entity_resource in tenant_namespace.loaded_entities:
             entity_config_key = tenant_key
             namespace = tenant_namespace
 
         # Pesquisando a entidade no namespace padrão (default)
         default_namespace = namespaces_dict.get(default_key)
-        if default_namespace and entity_id in default_namespace.loaded_entities:
+        if default_namespace and entity_resource in default_namespace.loaded_entities:
             entity_config_key = default_key
             namespace = default_namespace
 

{nsj_rest_lib2-0.0.7.dist-info → nsj_rest_lib2-0.0.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nsj_rest_lib2
-Version: 0.0.7
+Version: 0.0.9
 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
@@ -17,6 +17,7 @@ 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