nsj-rest-lib2 0.0.10__py3-none-any.whl → 0.0.12__py3-none-any.whl

nsj_rest_lib2/compiler/compiler.py

@@ -1,4 +1,5 @@
 import re
+
 from typing import Any
 
 from nsj_rest_lib2.compiler.compiler_structures import (
@@ -7,8 +8,8 @@ from nsj_rest_lib2.compiler.compiler_structures import (
 )
 from nsj_rest_lib2.compiler.dto_compiler import DTOCompiler
 from nsj_rest_lib2.compiler.edl_model.primitives import REGEX_EXTERNAL_REF
-from nsj_rest_lib2.compiler.edl_model.repository_model import RepositoryModel
 from nsj_rest_lib2.compiler.entity_compiler import EntityCompiler
+from nsj_rest_lib2.compiler.model import CompilerResult
 from nsj_rest_lib2.compiler.property_compiler import EDLPropertyCompiler
 
 from nsj_rest_lib2.compiler.edl_model.entity_model import EntityModel
@@ -26,17 +27,6 @@ from nsj_rest_lib2.settings import get_logger
 # TODO Criar imagem docker base para as aplicações, usando venv (para poderem atualizar o pydantic)
 
 
-class CompilerResult:
-    def __init__(self):
-        self.dto_class_name: str | None = None
-        self.dto_code: str | None = None
-        self.entity_class_name: str | None = None
-        self.entity_code: str | None = None
-        self.api_expose: bool | None = None
-        self.api_resource: str | None = None
-        self.api_verbs: list[str] | None = None
-
-
 class EDLCompiler:
     def __init__(self) -> None:
         self._properties_compiler = EDLPropertyCompiler()
@@ -114,6 +104,8 @@ class EDLCompiler:
             props_pk,
             enum_classes,
             related_imports,
+            relations_dependencies,
+            fixed_filters,
         ) = self._properties_compiler.compile(
             properties_structure,
             map_unique_by_property,
@@ -123,7 +115,11 @@ class EDLCompiler:
 
         # Gerando o código do DTO
         dto_class_name, code_dto = self._dto_compiler.compile(
-            entity_model, ast_dto_attributes, enum_classes, related_imports
+            entity_model,
+            ast_dto_attributes,
+            enum_classes,
+            related_imports,
+            fixed_filters,
         )
 
         # Gerando o código da Entity
@@ -142,6 +138,7 @@ class EDLCompiler:
         compiler_result.api_expose = entity_model.api.expose
         compiler_result.api_resource = entity_model.api.resource
         compiler_result.api_verbs = entity_model.api.verbs
+        compiler_result.relations_dependencies = relations_dependencies
 
         return compiler_result
 
@@ -244,10 +241,20 @@ class EDLCompiler:
     def _list_dependencies(self, entity_model: EntityModel) -> list[str]:
         entities: list[str] = []
 
+        # Adicionando dependências por traits
         if entity_model.trait_from:
             entities.append(entity_model.trait_from)
 
-        # Populando com as dependências de propriedades de relacionamento 1_N
+        # Populando com as dependências de propriedades de relacionamento
+        relations = self._list_dependencies_relations(entity_model)
+        entities.extend(relations)
+
+        return entities
+
+    def _list_dependencies_relations(self, entity_model) -> list[str]:
+        entities = []
+
+        # Relacionamento 1_N
         for pkey in entity_model.properties:
             prop = entity_model.properties[pkey]
 

nsj_rest_lib2/compiler/dto_compiler.py

@@ -3,6 +3,7 @@ import ast
 import black
 
 from nsj_rest_lib2.compiler.edl_model.entity_model import EntityModel
+from nsj_rest_lib2.compiler.edl_model.primitives import BasicTypes
 from nsj_rest_lib2.compiler.util.str_util import CompilerStrUtil
 from nsj_rest_lib2.compiler.util.type_naming_util import compile_dto_class_name
 
@@ -17,6 +18,7 @@ class DTOCompiler:
         ast_dto_attributes: list[ast.stmt],
         enum_classes: list[ast.stmt],
         related_imports: list[tuple[str, str, str]],
+        fixed_filters: list[tuple[str, BasicTypes]],
     ) -> tuple[str, str]:
         """
         Compila o código do DTO a partir do AST e retorna o código compilado.
@@ -71,6 +73,18 @@ class DTOCompiler:
                 names=[ast.alias(name="DTOBase", asname=None)],
                 level=0,
             ),
+            # from nsj_rest_lib.descriptor.dto_left_join_field import EntityRelationOwner
+            ast.ImportFrom(
+                module="nsj_rest_lib.descriptor.dto_left_join_field",
+                names=[ast.alias(name="EntityRelationOwner", asname=None)],
+                level=0,
+            ),
+            # from nsj_rest_lib.descriptor.dto_object_field import DTOObjectField
+            ast.ImportFrom(
+                module="nsj_rest_lib.descriptor.dto_object_field",
+                names=[ast.alias(name="DTOObjectField", asname=None)],
+                level=0,
+            ),
         ]
 
         for import_ in related_imports:
@@ -89,6 +103,19 @@ class DTOCompiler:
                 )
             )
 
+        # Keywords para tipos usados em fixed_filters
+        keywords_decorator_dto = []
+        for fixed_filter in fixed_filters:
+            keywords_decorator_dto.append(
+                ast.keyword(
+                    arg="fixed_filters",
+                    value=ast.Dict(
+                        keys=[ast.Constant(value=fixed_filter[0])],
+                        values=[ast.Constant(value=fixed_filter[1])],
+                    ),
+                )
+            )
+
         # Criando o ast da classe
         class_name = compile_dto_class_name(entity_model.id)
         ast_class = ast.ClassDef(
@@ -99,7 +126,7 @@ class DTOCompiler:
                 ast.Call(
                     func=ast.Name(id="DTO", ctx=ast.Load()),
                     args=[],
-                    keywords=[],
+                    keywords=keywords_decorator_dto,
                 )
             ],
             body=ast_dto_attributes,

nsj_rest_lib2/compiler/edl_model/column_meta_model.py

@@ -1,5 +1,5 @@
 from pydantic import BaseModel, Field, model_validator
-from typing import List, Optional, Literal
+from typing import Optional
 
 
 class ColumnMetaModel(BaseModel):

nsj_rest_lib2/compiler/edl_model/trait_property_meta_model.py

@@ -1,6 +1,8 @@
+from typing import List, Optional
 from pydantic import BaseModel, Field
 
 from nsj_rest_lib2.compiler.edl_model.primitives import BasicTypes, PropertyType
+from nsj_rest_lib2.compiler.edl_model.property_meta_model import DomainConfigModel
 
 
 class TraitPropertyMetaModel(BaseModel):
@@ -8,3 +10,7 @@ class TraitPropertyMetaModel(BaseModel):
     value: BasicTypes = Field(
         ..., description="Valor fixo da propriedade de condicionamento do trait."
     )
+    domain_config: Optional[List[DomainConfigModel]] = Field(
+        None,
+        description="Lista de valores permitidos.",
+    )

nsj_rest_lib2/compiler/model.py

@@ -0,0 +1,45 @@
+import uuid
+
+from typing import Any
+
+
+class RelationDependency:
+    def __init__(self):
+        self.tenant: int | None = None
+        self.grupo_empresarial: uuid.UUID | None = None
+        self.entity_resource: str | None = None
+        self.entity_scope: str | None = None
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "tenant": self.tenant,
+            "grupo_empresarial": (
+                str(self.grupo_empresarial) if self.grupo_empresarial else None
+            ),
+            "entity_resource": self.entity_resource,
+            "entity_scope": self.entity_scope,
+        }
+
+    def from_dict(self, data: dict[str, Any]) -> "RelationDependency":
+        self.tenant = data.get("tenant")
+        self.grupo_empresarial = (
+            uuid.UUID(data["grupo_empresarial"])
+            if data.get("grupo_empresarial")
+            else None
+        )
+        self.entity_resource = data.get("entity_resource")
+        self.entity_scope = data.get("entity_scope")
+
+        return self
+
+
+class CompilerResult:
+    def __init__(self):
+        self.dto_class_name: str | None = None
+        self.dto_code: str | None = None
+        self.entity_class_name: str | None = None
+        self.entity_code: str | None = None
+        self.api_expose: bool | None = None
+        self.api_resource: str | None = None
+        self.api_verbs: list[str] | None = None
+        self.relations_dependencies: list[RelationDependency] | None = None

nsj_rest_lib2/compiler/property_compiler.py

@@ -7,12 +7,17 @@ from nsj_rest_lib2.compiler.compiler_structures import (
 )
 from nsj_rest_lib2.compiler.edl_model.entity_model import EntityModel
 from nsj_rest_lib2.compiler.edl_model.primitives import (
+    BasicTypes,
     CardinalityTypes,
     PrimitiveTypes,
     REGEX_EXTERNAL_REF,
     REGEX_INTERNAL_REF,
 )
 from nsj_rest_lib2.compiler.edl_model.property_meta_model import PropertyMetaModel
+from nsj_rest_lib2.compiler.edl_model.trait_property_meta_model import (
+    TraitPropertyMetaModel,
+)
+from nsj_rest_lib2.compiler.model import RelationDependency
 from nsj_rest_lib2.compiler.util.str_util import CompilerStrUtil
 from nsj_rest_lib2.compiler.util.type_naming_util import (
     compile_dto_class_name,
@@ -40,6 +45,8 @@ class EDLPropertyCompiler:
         list[str],
         list[ast.stmt],
         list[tuple[str, str, str]],
+        list[RelationDependency],
+        list[tuple[str, BasicTypes]],
     ]:
 
         # TODO Criar opção de campo calculado?
@@ -70,6 +77,8 @@ class EDLPropertyCompiler:
         props_pk = []
         enum_classes = []
         related_imports = []
+        relations_dependencies = []
+        fixed_filters = []
 
         if properties_structure.properties is None:
             return (ast_dto_attributes, ast_entity_attributes, props_pk, enum_classes)
@@ -80,7 +89,7 @@ class EDLPropertyCompiler:
             # DTO
             ## Tratando propriedade simples (não array, não object)
             if isinstance(prop.type, PrimitiveTypes):
-                self.compile_simple_property(
+                self._compile_simple_property(
                     properties_structure,
                     map_unique_by_property,
                     entity_model,
@@ -94,119 +103,48 @@ class EDLPropertyCompiler:
 
             elif isinstance(prop.type, str):
                 external_match = re.match(REGEX_EXTERNAL_REF, prop.type)
+                internal_match = re.match(REGEX_INTERNAL_REF, prop.type)
 
                 if external_match:
                     # Resolvendo o id da entidade
                     related_entity_id = external_match.group(2)
-
-                    # Resolvendo o nome das classes de DTO e Entity
-                    related_dto_class_name = compile_dto_class_name(related_entity_id)
-                    related_entity_class_name = compile_entity_class_name(
-                        related_entity_id
-                    )
-
-                    # Resolvendo o caminho do import
                     related_entity_key = external_match.group(0)
 
-                    related_entity = entity_models.get(related_entity_key)
-                    if not related_entity:
-                        raise Exception(
-                            f"Entidade '{entity_model.id}' possui uma referência externa para uma entidade inexistente: '{related_entity_key}', por meio da propriedade: '{pkey}'."
-                        )
-
-                    tenant = related_entity.tenant
-                    grupo_empresarial = related_entity.grupo_empresarial
-                    grupo_key, tenant_key, default_key = compile_namespace_keys(
-                        tenant, grupo_empresarial
+                    self._compile_external_relation(
+                        related_entity_id,
+                        related_entity_key,
+                        entity_model,
+                        entity_models,
+                        properties_structure,
+                        ast_dto_attributes,
+                        related_imports,
+                        relations_dependencies,
+                        pkey,
+                        prop,
                     )
 
-                    if (
-                        tenant
-                        and tenant != 0
-                        and grupo_empresarial
-                        and grupo_empresarial != "00000000-0000-0000-0000-000000000000"
-                    ):
-                        related_import = grupo_key
-                    elif tenant and tenant != 0:
-                        related_import = tenant_key
-                    else:
-                        related_import = default_key
-
-                    related_imports.append(
-                        (
-                            related_import,
-                            related_dto_class_name,
-                            related_entity_class_name,
-                        )
-                    )
-
-                    # Instanciando o ast
-                    if prop.cardinality == CardinalityTypes.C1_N:
-                        # Para relacionamentos 1_N
-                        keywords = [
-                            ast.keyword(
-                                arg="dto_type",
-                                value=ast.Name(
-                                    id=related_dto_class_name, ctx=ast.Load()
-                                ),
-                            ),
-                            ast.keyword(
-                                arg="entity_type",
-                                value=ast.Name(
-                                    id=related_entity_class_name, ctx=ast.Load()
-                                ),
-                            ),
-                        ]
-
-                        # Resolvendo a coluna usada no relacionamento
-                        if (
-                            not properties_structure.entity_properties
-                            or pkey not in properties_structure.entity_properties
-                            or not properties_structure.entity_properties[
-                                pkey
-                            ].relation_column
-                        ):
-                            raise Exception(
-                                f"Propriedade '{pkey}' possui um relacionamento, mas nenhuma coluna de relacioanamento foi apontada na propriedade correspondente no repository."
-                            )
-
-                        relation_column = properties_structure.entity_properties[
-                            pkey
-                        ].relation_column
-
-                        keywords.append(
-                            ast.keyword(
-                                arg="related_entity_field",
-                                value=ast.Constant(value=relation_column),
-                            )
-                        )
-
-                        ast_attr = ast.AnnAssign(
-                            target=ast.Name(
-                                id=CompilerStrUtil.to_snake_case(pkey), ctx=ast.Store()
-                            ),
-                            annotation=ast.Name(
-                                id="list",
-                                ctx=ast.Load(),
-                            ),
-                            value=ast.Call(
-                                func=ast.Name(id="DTOListField", ctx=ast.Load()),
-                                args=[],
-                                keywords=keywords,
-                            ),
-                            simple=1,
-                        )
-
-                        ast_dto_attributes.append(ast_attr)
-                    else:
-                        # TODO
-                        pass
-
-                elif re.match(REGEX_INTERNAL_REF, prop.type):
+                elif internal_match:
                     # TODO
                     pass
                 else:
-                    raise Exception(f"Tipo de propriedade não suportado: {prop.type}")
+                    raise Exception(
+                        f"Tipo da propriedade '{pkey}' não suportado: {prop.type}"
+                    )
+
+        for pkey in properties_structure.trait_properties:
+            prop = properties_structure.trait_properties[pkey]
+
+            self._compile_trait_property(
+                properties_structure,
+                map_unique_by_property,
+                pkey,
+                prop,
+                ast_dto_attributes,
+                ast_entity_attributes,
+                fixed_filters,
+                entity_model,
+                enum_classes,
+            )
 
         return (
             ast_dto_attributes,
@@ -214,9 +152,411 @@ class EDLPropertyCompiler:
             props_pk,
             enum_classes,
             related_imports,
+            relations_dependencies,
+            fixed_filters,
         )
 
-    def compile_simple_property(
+    def _compile_trait_property(
+        self,
+        properties_structure: PropertiesCompilerStructure,
+        map_unique_by_property: dict[str, IndexCompilerStructure],
+        pkey: str,
+        prop: TraitPropertyMetaModel,
+        ast_dto_attributes: list[ast.stmt],
+        ast_entity_attributes: list[ast.stmt],
+        fixed_filters: list[tuple[str, BasicTypes]],
+        entity_model: EntityModel,
+        enum_classes: list[ast.stmt],
+    ):
+        enum_class_name = None
+        keywords = []
+
+        if (
+            properties_structure.main_properties
+            and pkey in properties_structure.main_properties
+        ):
+            keywords.append(ast.keyword(arg="resume", value=ast.Constant(True)))
+
+        if properties_structure.required and pkey in properties_structure.required:
+            keywords.append(ast.keyword(arg="not_null", value=ast.Constant(True)))
+
+        if (
+            properties_structure.partition_data
+            and pkey in properties_structure.partition_data
+        ):
+            keywords.append(ast.keyword(arg="partition_data", value=ast.Constant(True)))
+
+        if pkey in map_unique_by_property:
+            unique = map_unique_by_property[pkey].index_model
+            keywords.append(
+                ast.keyword(
+                    arg="unique",
+                    value=ast.Constant(unique.name),
+                )
+            )
+
+        if (
+            properties_structure.search_properties
+            and pkey in properties_structure.search_properties
+        ):
+            keywords.append(ast.keyword(arg="search", value=ast.Constant(True)))
+        else:
+            keywords.append(ast.keyword(arg="search", value=ast.Constant(False)))
+
+        if (
+            properties_structure.metric_label
+            and pkey in properties_structure.metric_label
+        ):
+            keywords.append(ast.keyword(arg="metric_label", value=ast.Constant(True)))
+
+        if prop.type == PrimitiveTypes.CPF:
+            keywords.append(
+                ast.keyword(
+                    arg="validator",
+                    value=ast.Attribute(
+                        value=ast.Call(
+                            func=ast.Name(id="DTOFieldValidators", ctx=ast.Load()),
+                            args=[],
+                            keywords=[],
+                        ),
+                        attr="validate_cpf",
+                        ctx=ast.Load(),
+                    ),
+                )
+            )
+        elif prop.type == PrimitiveTypes.CNPJ:
+            keywords.append(
+                ast.keyword(
+                    arg="validator",
+                    value=ast.Attribute(
+                        value=ast.Call(
+                            func=ast.Name(id="DTOFieldValidators", ctx=ast.Load()),
+                            args=[],
+                            keywords=[],
+                        ),
+                        attr="validate_cnpj",
+                        ctx=ast.Load(),
+                    ),
+                )
+            )
+        elif prop.type == PrimitiveTypes.CPF_CNPJ:
+            keywords.append(
+                ast.keyword(
+                    arg="validator",
+                    value=ast.Attribute(
+                        value=ast.Call(
+                            func=ast.Name(id="DTOFieldValidators", ctx=ast.Load()),
+                            args=[],
+                            keywords=[],
+                        ),
+                        attr="validate_cpf_or_cnpj",
+                        ctx=ast.Load(),
+                    ),
+                )
+            )
+        elif prop.type == PrimitiveTypes.EMAIL:
+            keywords.append(
+                ast.keyword(
+                    arg="validator",
+                    value=ast.Attribute(
+                        value=ast.Call(
+                            func=ast.Name(id="DTOFieldValidators", ctx=ast.Load()),
+                            args=[],
+                            keywords=[],
+                        ),
+                        attr="validate_email",
+                        ctx=ast.Load(),
+                    ),
+                )
+            )
+
+        # Trtando de uma definição de enum
+        if prop.domain_config:
+            result = self._compile_domain_config(pkey, prop, entity_model)
+            if not result:
+                raise Exception(f"Erro desconhecido ao compilar a propriedade {pkey}")
+
+            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 not isinstance(prop.type, PrimitiveTypes):
+            raise Exception(
+                f"Tipo da trait_property '{pkey}' não suportado: {prop.type} (deveria ser um Tipo Primitivo)"
+            )
+
+        # Instanciando o atributo AST
+        if enum_class_name:
+            prop_type = enum_class_name
+        else:
+            prop_type = TypeUtil.property_type_to_python_type(prop.type)
+
+        ast_attr = ast.AnnAssign(
+            target=ast.Name(id=CompilerStrUtil.to_snake_case(pkey), ctx=ast.Store()),
+            annotation=ast.Name(
+                id=prop_type,
+                ctx=ast.Load(),
+            ),
+            value=ast.Call(
+                func=ast.Name(id="DTOField", ctx=ast.Load()),
+                args=[],
+                keywords=keywords,
+            ),
+            simple=1,
+        )
+
+        ast_dto_attributes.append(ast_attr)
+
+        # Entity
+        ast_entity_attr = ast.AnnAssign(
+            target=ast.Name(
+                id=CompilerStrUtil.to_snake_case(entity_field_name),
+                ctx=ast.Store(),
+            ),
+            annotation=ast.Name(
+                id=TypeUtil.property_type_to_python_type(prop.type),
+                ctx=ast.Load(),
+            ),
+            value=ast.Constant(value=None),
+            simple=1,
+        )
+
+        ast_entity_attributes.append(ast_entity_attr)
+
+        # Guardando como um fixed_filter
+        # TODO Pernsar em validações para esse value (se está de acordo com o tipo ou enum)
+        fixed_filters.append((pkey, prop.value))
+
+    def _compile_external_relation(
+        self,
+        related_entity_id: str,
+        related_entity_key: str,
+        entity_model: EntityModel,
+        entity_models: dict[str, EntityModel],
+        properties_structure: PropertiesCompilerStructure,
+        ast_dto_attributes: list[ast.stmt],
+        related_imports: list[tuple[str, str, str]],
+        relations_dependencies: list[RelationDependency],
+        pkey: str,
+        prop: PropertyMetaModel,
+    ):
+        # Resolvendo o nome das classes de DTO e Entity
+        related_dto_class_name = compile_dto_class_name(related_entity_id)
+        related_entity_class_name = compile_entity_class_name(related_entity_id)
+
+        # Resolvendo o caminho do import
+        related_entity = entity_models.get(related_entity_key)
+        if not related_entity:
+            raise Exception(
+                f"Entidade '{entity_model.id}' possui uma referência externa para uma entidade inexistente: '{related_entity_key}', por meio da propriedade: '{pkey}'."
+            )
+
+        tenant = related_entity.tenant
+        grupo_empresarial = related_entity.grupo_empresarial
+        grupo_key, tenant_key, default_key = compile_namespace_keys(
+            tenant, grupo_empresarial
+        )
+
+        if (
+            tenant
+            and tenant != 0
+            and grupo_empresarial
+            and grupo_empresarial != "00000000-0000-0000-0000-000000000000"
+        ):
+            related_import = grupo_key
+        elif tenant and tenant != 0:
+            related_import = tenant_key
+        else:
+            related_import = default_key
+
+        related_imports.append(
+            (
+                related_import,
+                related_dto_class_name,
+                related_entity_class_name,
+            )
+        )
+
+        # Gravando a dependência de relacionamento
+        relation_dependency = RelationDependency()
+        relation_dependency.entity_resource = related_entity.api.resource
+        relation_dependency.entity_scope = related_entity.escopo
+        relation_dependency.tenant = tenant
+        relation_dependency.grupo_empresarial = grupo_empresarial
+        relations_dependencies.append(relation_dependency)
+
+        # Instanciando o ast
+        if prop.cardinality == CardinalityTypes.C1_N:
+            # Para relacionamentos 1_N
+            self._build_ast_1_N(
+                properties_structure,
+                ast_dto_attributes,
+                pkey,
+                related_dto_class_name,
+                related_entity_class_name,
+            )
+
+        elif prop.cardinality == CardinalityTypes.C1_1:
+            self._build_ast_1_1(
+                properties_structure,
+                ast_dto_attributes,
+                pkey,
+                related_dto_class_name,
+                related_entity_class_name,
+            )
+
+        elif prop.cardinality == CardinalityTypes.CN_N:
+            # TODO
+            pass
+        else:
+            raise Exception(
+                f"Propriedade '{pkey}' da entidade '{entity_model.id}' possui cardinalidade inválida ou não suportada: {prop.cardinality}"
+            )
+
+    def _build_ast_1_N(
+        self,
+        properties_structure: PropertiesCompilerStructure,
+        ast_dto_attributes: list[ast.stmt],
+        pkey: str,
+        related_dto_class_name: str,
+        related_entity_class_name: str,
+    ):
+        # Propriedade do property descriptor
+        keywords = [
+            ast.keyword(
+                arg="dto_type",
+                value=ast.Name(id=related_dto_class_name, ctx=ast.Load()),
+            ),
+            ast.keyword(
+                arg="entity_type",
+                value=ast.Name(id=related_entity_class_name, ctx=ast.Load()),
+            ),
+        ]
+
+        # Resolvendo a coluna usada no relacionamento
+        if (
+            not properties_structure.entity_properties
+            or pkey not in properties_structure.entity_properties
+            or not properties_structure.entity_properties[pkey].relation_column
+        ):
+            raise Exception(
+                f"Propriedade '{pkey}' possui um relacionamento, mas nenhuma coluna de relacioanamento foi apontada na propriedade correspondente no repository."
+            )
+
+        relation_column = properties_structure.entity_properties[pkey].relation_column
+
+        keywords.append(
+            ast.keyword(
+                arg="related_entity_field",
+                value=ast.Constant(value=relation_column),
+            )
+        )
+
+        ast_attr = ast.AnnAssign(
+            target=ast.Name(id=CompilerStrUtil.to_snake_case(pkey), ctx=ast.Store()),
+            annotation=ast.Name(
+                id="list",
+                ctx=ast.Load(),
+            ),
+            value=ast.Call(
+                func=ast.Name(id="DTOListField", ctx=ast.Load()),
+                args=[],
+                keywords=keywords,
+            ),
+            simple=1,
+        )
+
+        ast_dto_attributes.append(ast_attr)
+
+    def _build_ast_1_1(
+        self,
+        properties_structure: PropertiesCompilerStructure,
+        ast_dto_attributes: list[ast.stmt],
+        pkey: str,
+        related_dto_class_name: str,
+        related_entity_class_name: str,
+    ):
+        # Propriedade do property descriptor
+        keywords = [
+            ast.keyword(
+                arg="entity_type",
+                value=ast.Name(id=related_entity_class_name, ctx=ast.Load()),
+            ),
+        ]
+
+        # Resolvendo a coluna usada no relacionamento
+        if (
+            not properties_structure.entity_properties
+            or pkey not in properties_structure.entity_properties
+            or not properties_structure.entity_properties[pkey].relation_column
+        ):
+            raise Exception(
+                f"Propriedade '{pkey}' possui um relacionamento, mas nenhuma coluna de relacioanamento foi apontada na propriedade correspondente no repository."
+            )
+
+        relation_column = str(
+            properties_structure.entity_properties[pkey].relation_column
+        )
+
+        owner_relation = False
+        if "/" in relation_column:
+            owner_relation = True
+            relation_column = relation_column.split("/")[-1]
+
+        keywords.append(
+            ast.keyword(
+                arg="relation_field",
+                value=ast.Constant(value=relation_column),
+            )
+        )
+
+        if not owner_relation:
+            keywords.append(
+                ast.keyword(
+                    arg="entity_relation_owner",
+                    value=ast.Attribute(
+                        value=ast.Name(id="EntityRelationOwner", ctx=ast.Load()),
+                        attr="OTHER",
+                        ctx=ast.Load(),
+                    ),
+                )
+            )
+
+        ast_attr = ast.AnnAssign(
+            target=ast.Name(id=CompilerStrUtil.to_snake_case(pkey), ctx=ast.Store()),
+            annotation=ast.Name(
+                id=related_dto_class_name,
+                ctx=ast.Load(),
+            ),
+            value=ast.Call(
+                func=ast.Name(id="DTOObjectField", ctx=ast.Load()),
+                args=[],
+                keywords=keywords,
+            ),
+            simple=1,
+        )
+
+        ast_dto_attributes.append(ast_attr)
+
+    def _compile_simple_property(
         self,
         properties_structure,
         map_unique_by_property,
@@ -461,7 +801,7 @@ class EDLPropertyCompiler:
     def _compile_domain_config(
         self,
         pkey: str,
-        prop: PropertyMetaModel,
+        prop: PropertyMetaModel | TraitPropertyMetaModel,
         entity_model: EntityModel,
     ) -> tuple[str, ast.stmt] | None:
         if not prop.domain_config:

nsj_rest_lib2/service/entity_loader.py

@@ -1,11 +1,14 @@
 import datetime
 import json
+import re
 import sys
 import threading
 import types
 
 from nsj_rest_lib.settings import get_logger
 
+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.exception import MissingEntityConfigException
 from nsj_rest_lib2.redis_config import get_redis
@@ -21,14 +24,15 @@ class LoadedEntity:
         self.loaded_at: datetime.datetime = datetime.datetime.now()
         self.api_expose: bool = False
         self.api_verbs: list[str] = []
+        self.relations_dependencies: list[RelationDependency] = []
 
 
 class Namespace:
     def __init__(self):
         self.key: str = ""
         self.loaded_entities: dict[str, LoadedEntity] = {}
-        self.entities_dict: dict = None
-        self.module: types.ModuleType = None
+        self.entities_dict: dict = {}
+        self.module: types.ModuleType = types.ModuleType("empty")
 
 
 namespaces_dict: dict[str, Namespace] = {}
@@ -43,17 +47,18 @@ class EntityLoader:
         entity_resource: str,
         tenant: str | None,
         grupo_empresarial: str | None,
+        escopo: str = ESCOPO_RESTLIB2,
     ) -> tuple[str, str, dict, bool, list[str]]:
         # Montando as chaves dos namespaces
         grupo_key, tenant_key, default_key = compile_namespace_keys(
             tenant, grupo_empresarial
         )
 
-        result = self._load_entity_source_from_memory(
+        result = self._search_entity_namespace_in_memory(
             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
+        # Se conseguiu localizar na memória, verifica se houve alteração no hash, em relação ao redis
         if result is not None:
             # Desempacotando o result e recuperando informações do namespace
             (
@@ -67,6 +72,21 @@ class EntityLoader:
             entities_dict = namespace.entities_dict
             api_expose = loaded_entity.api_expose
             api_verbs = loaded_entity.api_verbs
+            relations_dependencies = loaded_entity.relations_dependencies
+
+            # 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:
+                    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,
+                )
 
             # Se o tempo entre o carregamento e agora for maior do que MIN_TIME_SOURCE_REFRESH minutos,
             # verifica se precisa de refresh
@@ -83,6 +103,7 @@ class EntityLoader:
                     tenant_key,
                     default_key,
                     entity_config_key,
+                    escopo=escopo,
                 )
 
                 # Se não achar no redis, usa o que estava em memória
@@ -142,7 +163,12 @@ class EntityLoader:
 
         # Se não conseguir recuperar a entidade, procura no redis:
         loaded_config = self._load_entity_config_from_redis(
-            entity_resource, grupo_key, tenant_key, default_key, None
+            entity_resource,
+            grupo_key,
+            tenant_key,
+            default_key,
+            None,
+            escopo=escopo,
         )
 
         # Se também não achar no redis, lanca exceção
@@ -215,6 +241,10 @@ class EntityLoader:
             api_expose = entity_config["api_expose"]
             # api_resource = entity_config["api_resource"]
             api_verbs = entity_config["api_verbs"]
+            relations_dependencies = [
+                RelationDependency().from_dict(rd)
+                for rd in entity_config.get("relations_dependencies", [])
+            ]
         except json.JSONDecodeError as e:
             if not check_refresh:
                 raise RuntimeError(
@@ -226,6 +256,20 @@ 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}."
+                )
+
+            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:
             loaded_namespace = namespaces_dict.get(entity_config_key)
@@ -283,6 +327,7 @@ class EntityLoader:
             loaded_entity.entity_hash = entity_hash
             loaded_entity.api_expose = api_expose
             loaded_entity.api_verbs = api_verbs
+            loaded_entity.relations_dependencies = relations_dependencies
 
             namespace.loaded_entities[entity_resource] = loaded_entity
 
@@ -302,30 +347,31 @@ class EntityLoader:
         tenant_key: str,
         default_key: str,
         entity_config_key: str | None,
+        escopo: str,
     ) -> tuple[str, str] | None:
         get_logger().debug(
-            f"Procurando a configuração da entidade {entity_resource} no redis"
+            f"Procurando a configuração da entidade {entity_resource} no redis. Tenant key: {tenant_key} e Grupo key: {grupo_key}"
         )
 
         if entity_config_key is not None:
             entity_config_str = get_redis(
-                "entity_config", ESCOPO_RESTLIB2, entity_config_key, entity_resource
+                "entity_config", escopo, entity_config_key, entity_resource
             )
 
         else:
             entity_config_key = grupo_key
             entity_config_str = get_redis(
-                "entity_config", ESCOPO_RESTLIB2, grupo_key, entity_resource
+                "entity_config", escopo, 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_resource
+                    "entity_config", escopo, 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_resource
+                    "entity_config", escopo, default_key, entity_resource
                 )
 
         # Se não encontrar no redis, retorna None
@@ -334,7 +380,7 @@ class EntityLoader:
 
         return (entity_config_key, entity_config_str)
 
-    def _load_entity_source_from_memory(
+    def _search_entity_namespace_in_memory(
         self,
         entity_resource: str,
         grupo_key: str,

{nsj_rest_lib2-0.0.10.dist-info → nsj_rest_lib2-0.0.12.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nsj_rest_lib2
-Version: 0.0.10
+Version: 0.0.12
 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.10.dist-info → nsj_rest_lib2-0.0.12.dist-info}/RECORD

@@ -4,21 +4,22 @@ nsj_rest_lib2/redis_config.py,sha256=4KLcvYS3nJO7PMQgF6F9_j6r-TyqcS7TBbd3LEQuKDU
 nsj_rest_lib2/settings.py,sha256=Hn_o1HZmievnYb8D1kNT2Nq-OEjxbyNjOiOpbnFsMwE,367
 nsj_rest_lib2/compiler/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nsj_rest_lib2/compiler/ai_compiler.py,sha256=shAtN4T0ai_52qh15L3mK1QbeC6glHOR6C3J3gj14II,9029
-nsj_rest_lib2/compiler/compiler.py,sha256=wkREdCrQ6mq6-R-5nC5ZXDGNpSEIPjuSjt-NCxOS6to,12228
+nsj_rest_lib2/compiler/compiler.py,sha256=tWnhDuHpvpJMWMPxt6U76ZS6J-hSpiB7xRZaeOP3CMc,12334
 nsj_rest_lib2/compiler/compiler_structures.py,sha256=2bM4_7lG1fytDGxJl6SU9pLsbspiNV36gVn9-O-23Q8,1009
-nsj_rest_lib2/compiler/dto_compiler.py,sha256=GAKWFvks0Duqs2EsEr1-BFx2-Kny72jJMbl9ZyIEDXw,4125
+nsj_rest_lib2/compiler/dto_compiler.py,sha256=4e9_8EsNSHPCUEmiuEPdudj9_tFuw2O4ZTv6EYwJrGc,5333
 nsj_rest_lib2/compiler/entity_compiler.py,sha256=zLXO6USY4Rr0Hnk4wGep5K8DiHxJv-W-BBz_-g4OhCA,4307
-nsj_rest_lib2/compiler/property_compiler.py,sha256=RR5F-7D2nLG6ThjC0rdqwU3G5SMN1P5tBusZaAPwIMk,18865
+nsj_rest_lib2/compiler/model.py,sha256=QDBoM26qoZdiNcykl1nvXCrFDhg-6Q__QzVq6uY1QzE,1460
+nsj_rest_lib2/compiler/property_compiler.py,sha256=kr9Pi0kkIrvgEmxrmV_NEQuqekM1h6-jqvF85nZTUcY,29808
 nsj_rest_lib2/compiler/edl_model/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nsj_rest_lib2/compiler/edl_model/ai_entity_edl.py,sha256=664QBDcOgVnyfwtUOXO1W7AKaZhueBG335x5DuogruY,7644
 nsj_rest_lib2/compiler/edl_model/api_model.py,sha256=pH0Uiq_64AGvkHqwY44TrulWWZXbi6M0EKJWUhSqKj0,837
-nsj_rest_lib2/compiler/edl_model/column_meta_model.py,sha256=3OLsRwEz66Cktzew6Hie3HZXK9u20GXlWUU0HtFtwfk,709
+nsj_rest_lib2/compiler/edl_model/column_meta_model.py,sha256=s0sEVkoW1hV2_hto1mws4XhzKGH_b4NzhaOiwFH25Ks,694
 nsj_rest_lib2/compiler/edl_model/entity_model.py,sha256=sXVfC30P3-q2-fQ3XB_-3vpNjqFPIK5oBIVbwkXNFLU,3662
 nsj_rest_lib2/compiler/edl_model/index_model.py,sha256=cXWlu0hxtro5vvYoirkDW4R3PCnBW5oCCWjRJ6AX5zE,508
 nsj_rest_lib2/compiler/edl_model/primitives.py,sha256=cWEys87xDpgotyRUXkzvFvY4LHeawzBEEyz0Xed18AQ,1454
 nsj_rest_lib2/compiler/edl_model/property_meta_model.py,sha256=x2SApvI-5MZTErAHeOXnR6qfjflhSs8r6Y9KMtCykV0,3960
 nsj_rest_lib2/compiler/edl_model/repository_model.py,sha256=Vt1HxlaoifP4w5ij1laKDkD1-COBihE8EX1HkdEDUSo,977
-nsj_rest_lib2/compiler/edl_model/trait_property_meta_model.py,sha256=ZC2oTvc9Y2Oiy4NLNHQLiMOLRWDAOdF8GJxOw4nqHdk,354
+nsj_rest_lib2/compiler/edl_model/trait_property_meta_model.py,sha256=SBSfiu4v0PMsWRsGDySR3P2tkabLbDZxx_FFy_3rGXA,605
 nsj_rest_lib2/compiler/util/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nsj_rest_lib2/compiler/util/str_util.py,sha256=lVP1yHhj1pOd6ULtTnkcfX6Gqrpe4yCBratHUhBNGcI,843
 nsj_rest_lib2/compiler/util/type_naming_util.py,sha256=sahlxtYUPcksqlX1hygaoTF7vuD8tY8eosgOR04YLAs,612
@@ -26,8 +27,8 @@ nsj_rest_lib2/compiler/util/type_util.py,sha256=HTKOH4uRTOY0YgoM8oUv_6cEcReE_bgK
 nsj_rest_lib2/controller/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nsj_rest_lib2/controller/dynamic_controller.py,sha256=XMqxe1NW-NE5XwomXb4pSNdALQHpP74Hc26R4fnmXqg,15194
 nsj_rest_lib2/service/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nsj_rest_lib2/service/entity_loader.py,sha256=PJX-cPPCllhZuqSZzj8ZX_0HZQBnt20dqLc9E0e0GtA,13472
-nsj_rest_lib2-0.0.10.dist-info/METADATA,sha256=-I_ppkmCUjV4aXsBTij-0Ih2JUxbjb5XYyntbSJrhFE,1361
-nsj_rest_lib2-0.0.10.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-nsj_rest_lib2-0.0.10.dist-info/top_level.txt,sha256=L6zh0EfH8_rur7OJ8_V-El-XEMf4qg3bkF8ADgqLVIA,14
-nsj_rest_lib2-0.0.10.dist-info/RECORD,,
+nsj_rest_lib2/service/entity_loader.py,sha256=KVLFQSqj4DL-K-T29ksJE2or9QkekFmyAGUIKjQX6Qk,15372
+nsj_rest_lib2-0.0.12.dist-info/METADATA,sha256=CTk1vS9FJ_U2e6-Vz38wj3Ba2efwuKPW-iDpHlosHzk,1361
+nsj_rest_lib2-0.0.12.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+nsj_rest_lib2-0.0.12.dist-info/top_level.txt,sha256=L6zh0EfH8_rur7OJ8_V-El-XEMf4qg3bkF8ADgqLVIA,14
+nsj_rest_lib2-0.0.12.dist-info/RECORD,,