nsj-rest-lib2 0.0.7__tar.gz → 0.0.8__tar.gz

{nsj_rest_lib2-0.0.7 → nsj_rest_lib2-0.0.8}/PKG-INFO

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

{nsj_rest_lib2-0.0.7 → nsj_rest_lib2-0.0.8}/nsj_rest_lib2/compiler/compiler.py

@@ -13,14 +13,11 @@ from nsj_rest_lib2.compiler.edl_model.entity_model import EntityModel
 
 from nsj_rest_lib2.settings import get_logger
 
-# TODO Rever a questão do tempo de expiração ser renovado, na leitura do redis
 # TODO Atualizar o status da entidade pelo worker de compilação (e talvez parar uma compilação, quando se delete uma entidade)
 # TODO Relacionamentos
 # TODO Classes Abstratas
 # TODO Partial Classes
 # TODO Migrations
-# TODO Migrar para a nsj_rest_lib2
-# TODO Alterar o padrão de nomenclatura para snake_case
 
 
 class CompilerResult:
@@ -29,7 +26,9 @@ class CompilerResult:
         self.dto_code: str | None = None
         self.entity_class_name: str | None = None
         self.entity_code: str | None = None
-        # TODO Informacoes das rotas
+        self.api_expose: bool | None = None
+        self.api_resource: str | None = None
+        self.api_verbs: list[str] | None = None
 
 
 class EDLCompiler:
@@ -121,13 +120,18 @@ class EDLCompiler:
             entity_model, ast_entity_attributes, props_pk
         )
 
-        # Retornando o resultado
+        # Construindo o resultado
         compiler_result = CompilerResult()
         compiler_result.entity_class_name = entity_class_name
         compiler_result.entity_code = code_entity
         compiler_result.dto_class_name = dto_class_name
         compiler_result.dto_code = code_dto
 
+        # Compilando questões das APIs
+        compiler_result.api_expose = entity_model.api.expose
+        compiler_result.api_resource = entity_model.api.resource
+        compiler_result.api_verbs = entity_model.api.verbs
+
         return compiler_result
 
     def _make_properties_structures(
@@ -286,3 +290,10 @@ if __name__ == "__main__":
         print(f"DTO: {compiler_result.dto_class_name}")
         print(f"{compiler_result.dto_code}")
         print("\n")
+
+        print("==========================================================")
+        print("API Expose: ", compiler_result.api_expose)
+        print("API Route Path: ", compiler_result.api_resource)
+        print("API Verbs: ", compiler_result.api_verbs)
+        print("==========================================================")
+        print("\n")

{nsj_rest_lib2-0.0.7 → nsj_rest_lib2-0.0.8}/nsj_rest_lib2/compiler/edl_model/entity_model.py

@@ -60,7 +60,7 @@ class EntityModel(BaseModel):
     repository: RepositoryModel = Field(
         ..., description="Configurações de mapeamento para o banco de dados."
     )
-    api: Optional[APIModel] = Field(
-        None,
+    api: APIModel = Field(
+        ...,
         description="Definição da API REST associada ao modelo, com todos os seus endpoints.",
     )

{nsj_rest_lib2-0.0.7 → nsj_rest_lib2-0.0.8}/nsj_rest_lib2/compiler/property_compiler.py

@@ -243,6 +243,26 @@ class EDLPropertyCompiler:
                     enum_class_name, ast_enum_class = result
                     enum_classes.append(ast_enum_class)
 
+                # Resolvendo o nome da propriedade no Entity
+                if (
+                    properties_structure.entity_properties
+                    and pkey in properties_structure.entity_properties
+                ):
+                    entity_field_name = properties_structure.entity_properties[
+                        pkey
+                    ].column
+                else:
+                    entity_field_name = pkey
+
+                # Escrevendo, se necessário, o alias para o nome da entity
+                if entity_field_name != pkey:
+                    keywords.append(
+                        ast.keyword(
+                            arg="entity_field",
+                            value=ast.Constant(value=entity_field_name),
+                        )
+                    )
+
                 # Instanciando o atributo AST
                 if enum_class_name:
                     prop_type = enum_class_name
@@ -268,16 +288,6 @@ class EDLPropertyCompiler:
                 ast_dto_attributes.append(ast_attr)
 
                 # Entity
-                if (
-                    properties_structure.entity_properties
-                    and pkey in properties_structure.entity_properties
-                ):
-                    entity_field_name = properties_structure.entity_properties[
-                        pkey
-                    ].column
-                else:
-                    entity_field_name = pkey
-
                 ast_entity_attr = ast.AnnAssign(
                     target=ast.Name(
                         id=CompilerStrUtil.to_snake_case(entity_field_name),

{nsj_rest_lib2-0.0.7 → nsj_rest_lib2-0.0.8}/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-0.0.7 → nsj_rest_lib2-0.0.8}/nsj_rest_lib2/service/entity_loader.py

@@ -18,6 +18,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 +39,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"
 
         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 +60,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 +101,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 +153,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):
         """
@@ -135,9 +186,9 @@ class EntityLoader:
         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 +198,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 +219,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,7 +228,7 @@ 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
@@ -200,10 +255,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 +271,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 +310,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 +320,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 → nsj_rest_lib2-0.0.8}/nsj_rest_lib2.egg-info/PKG-INFO

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

{nsj_rest_lib2-0.0.7 → nsj_rest_lib2-0.0.8}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = nsj_rest_lib2
-version = 0.0.7
+version = 0.0.8
 author = Nasajon Sistemas
 author_email = contact.dev@nasajon.com.br
 description = Biblioteca para permitir a distribuição de rotas dinâmicas numa API, configuradas por meio de EDLs declarativos (em formato JSON).