nsj-rest-lib2 0.0.13__py3-none-any.whl → 0.0.14__py3-none-any.whl

nsj_rest_lib2/compiler/compiler.py

@@ -3,10 +3,12 @@ import re
 from typing import Any
 
 from nsj_rest_lib2.compiler.compiler_structures import (
+    ComponentsCompilerStructure,
     IndexCompilerStructure,
     PropertiesCompilerStructure,
 )
 from nsj_rest_lib2.compiler.dto_compiler import DTOCompiler
+from nsj_rest_lib2.compiler.edl_model.entity_model_base import EntityModelBase
 from nsj_rest_lib2.compiler.edl_model.primitives import REGEX_EXTERNAL_REF
 from nsj_rest_lib2.compiler.entity_compiler import EntityCompiler
 from nsj_rest_lib2.compiler.model import CompilerResult
@@ -16,16 +18,18 @@ from nsj_rest_lib2.compiler.edl_model.entity_model import EntityModel
 
 from nsj_rest_lib2.settings import get_logger
 
+# TODO Revisar compilação de valores default (sensível a tipos)
+# TODO Implementar suporte a conjuntos
 # TODO Autenticação nas rotas
-# TODO Carregar, dinamicamente, em memória, o código compilado das dependÊncias por relacionamento
 # 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 Mixins
 # TODO Classes Abstratas
 # TODO Partial Classes
 # TODO Migrations
-# TODO Adicionar autenticação aos endpoints dinâmicos
 # TODO Criar imagem docker base para as aplicações, usando venv (para poderem atualizar o pydantic)
 
+# TODO Suporte ao "min_items" dos relacionamentos no RestLib1
+
 
 class EDLCompiler:
     def __init__(self) -> None:
@@ -76,10 +80,18 @@ class EDLCompiler:
 
     def _compile_model(
         self,
-        entity_model: EntityModel,
+        entity_model: EntityModelBase,
         entity_models: dict[str, EntityModel],
+        escopo: str | None = None,
+        prefx_class_name: str = "",
     ) -> CompilerResult:
 
+        if escopo is None and isinstance(entity_model, EntityModel):
+            escopo = entity_model.escopo
+
+        if not escopo:
+            raise Exception(f"Escopo não definido para a entidade: {entity_model.id}.")
+
         # Criando um mapa de índices por nome de property
         # TODO Implementar tratamento dos índices de apoio às query (não de unicidade)
         map_indexes_by_property: dict[str, list[IndexCompilerStructure]] = {}
@@ -109,10 +121,43 @@ class EDLCompiler:
         ) = self._properties_compiler.compile(
             properties_structure,
             map_unique_by_property,
+            escopo,
             entity_model,
             entity_models,
+            prefx_class_name,
         )
 
+        # Gerando o buffer para os códigos de DTO e Entity
+        dto_code = ""
+        entity_code = ""
+        relations_dependencies_complete = []
+
+        # Carregando a estrutura de compilação dos components
+        components_structure = ComponentsCompilerStructure()
+        self._make_components_structures(
+            components_structure, entity_model, entity_models
+        )
+
+        # Gerando o código das entidades filhas (components)
+        for component_key in components_structure.components:
+            component = components_structure.components[component_key]
+            component_compiled = self._compile_model(
+                component,
+                entity_models,
+                escopo,
+                prefx_class_name=f"{prefx_class_name}_{entity_model.id}",
+            )
+
+            # Guardando o código gerado no buffer
+            if component_compiled.dto_code:
+                dto_code += component_compiled.dto_code + "\n\n"
+            if component_compiled.entity_code:
+                entity_code += component_compiled.entity_code + "\n\n"
+            if component_compiled.relations_dependencies:
+                relations_dependencies_complete.extend(
+                    component_compiled.relations_dependencies
+                )
+
         # Gerando o código do DTO
         dto_class_name, code_dto = self._dto_compiler.compile(
             entity_model,
@@ -120,32 +165,65 @@ class EDLCompiler:
             enum_classes,
             related_imports,
             fixed_filters,
+            prefx_class_name,
         )
 
         # Gerando o código da Entity
         entity_class_name, code_entity = self._entity_compiler.compile(
-            entity_model, ast_entity_attributes, props_pk
+            entity_model,
+            ast_entity_attributes,
+            props_pk,
+            prefx_class_name,
         )
 
+        # Extendendo os buffers com os códigos gerados
+        dto_code += code_dto
+        entity_code += code_entity
+        relations_dependencies_complete.extend(relations_dependencies)
+
         # Construindo o resultado
         compiler_result = CompilerResult()
         compiler_result.entity_class_name = entity_class_name
-        compiler_result.entity_code = code_entity
+        compiler_result.entity_code = entity_code
         compiler_result.dto_class_name = dto_class_name
-        compiler_result.dto_code = code_dto
+        compiler_result.dto_code = dto_code
 
         # 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
-        compiler_result.relations_dependencies = relations_dependencies
+        if isinstance(entity_model, EntityModel):
+            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_complete
 
         return compiler_result
 
+    def _make_components_structures(
+        self,
+        components_structure: ComponentsCompilerStructure,
+        entity_model: EntityModelBase,
+        entity_models: dict[str, EntityModel],
+    ):
+        if not entity_model:
+            return
+
+        # Populando com os components do trait
+        if entity_model.trait_from:
+            trait_model = entity_models[entity_model.trait_from]
+
+            self._make_components_structures(
+                components_structure,
+                trait_model,
+                entity_models,
+            )
+
+        # Populando com os components da entidade atual
+        if entity_model.components:
+            components_structure.components.update(entity_model.components)
+
     def _make_properties_structures(
         self,
         properties_structure: PropertiesCompilerStructure,
-        entity_model: EntityModel,
+        entity_model: EntityModelBase,
         entity_models: dict[str, EntityModel],
     ):
         if not entity_model:
@@ -188,7 +266,7 @@ class EDLCompiler:
         self,
         map_indexes_by_property: dict[str, list[IndexCompilerStructure]],
         map_unique_by_property: dict[str, IndexCompilerStructure],
-        entity_model: EntityModel,
+        entity_model: EntityModelBase,
         entity_models: dict[str, EntityModel],
         deep: int = 1,
     ):

nsj_rest_lib2/compiler/compiler_structures.py

@@ -1,4 +1,5 @@
 from nsj_rest_lib2.compiler.edl_model.column_meta_model import ColumnMetaModel
+from nsj_rest_lib2.compiler.edl_model.entity_model_base import EntityModelBase
 from nsj_rest_lib2.compiler.edl_model.index_model import IndexModel
 from nsj_rest_lib2.compiler.edl_model.property_meta_model import PropertyMetaModel
 from nsj_rest_lib2.compiler.edl_model.trait_property_meta_model import (
@@ -22,3 +23,8 @@ class PropertiesCompilerStructure:
         self.metric_label: list[str] = []
         self.entity_properties: dict[str, ColumnMetaModel] = {}
         self.trait_properties: dict[str, TraitPropertyMetaModel] = {}
+
+
+class ComponentsCompilerStructure:
+    def __init__(self) -> None:
+        self.components: dict[str, EntityModelBase] = {}

nsj_rest_lib2/compiler/dto_compiler.py

@@ -3,8 +3,8 @@ import ast
 import black
 
 from nsj_rest_lib2.compiler.edl_model.entity_model import EntityModel
+from nsj_rest_lib2.compiler.edl_model.entity_model_base import EntityModelBase
 from nsj_rest_lib2.compiler.edl_model.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
 
 
@@ -14,11 +14,12 @@ class DTOCompiler:
 
     def compile(
         self,
-        entity_model: EntityModel,
+        entity_model: EntityModelBase,
         ast_dto_attributes: list[ast.stmt],
         enum_classes: list[ast.stmt],
         related_imports: list[tuple[str, str, str]],
         fixed_filters: list[tuple[str, BasicTypes]],
+        prefx_class_name: str,
     ) -> tuple[str, str]:
         """
         Compila o código do DTO a partir do AST e retorna o código compilado.
@@ -117,7 +118,7 @@ class DTOCompiler:
             )
 
         # Criando o ast da classe
-        class_name = compile_dto_class_name(entity_model.id)
+        class_name = compile_dto_class_name(entity_model.id, prefx_class_name)
         ast_class = ast.ClassDef(
             name=class_name,
             bases=[ast.Name(id="DTOBase", ctx=ast.Load())],

nsj_rest_lib2/compiler/edl_model/entity_model.py

@@ -1,27 +1,15 @@
-import uuid
+from __future__ import annotations
 
-from pydantic import BaseModel, Field
-from typing import Dict, List, Optional
+from pydantic import Field
+from typing import Optional
 
-from nsj_rest_lib2.compiler.edl_model.property_meta_model import PropertyMetaModel
-from nsj_rest_lib2.compiler.edl_model.repository_model import RepositoryModel
 from nsj_rest_lib2.compiler.edl_model.api_model import APIModel
-from nsj_rest_lib2.compiler.edl_model.trait_property_meta_model import (
-    TraitPropertyMetaModel,
-)
+from nsj_rest_lib2.compiler.edl_model.entity_model_base import EntityModelBase
 
 
-class EntityModel(BaseModel):
+class EntityModel(EntityModelBase):
     edl_version: Optional[str] = Field(default="1.0", description="Versão do EDL")
     escopo: str = Field(..., description="Escopo do EDL (define a aplicação).")
-    description: str = Field(..., description="Descrição da entidade.")
-    id: str = Field(
-        ...,
-        description="Identificador único da entidade, dentro de um determinado escopo (podendo ser sobreescrito para um tenant ou grupo _empresarial).",
-    )
-    trait_from: Optional[str] = Field(
-        None, description="Identificador da entidade que a trait estende."
-    )
     version: Optional[str] = Field(
         default="1.0", description="Versão da entidade (padrão: 1.0)."
     )
@@ -29,46 +17,7 @@ class EntityModel(BaseModel):
         default=False,
         description="Indica se a entidade é abstrata (padrão: False). Caso positivo, não gera código, mas pode ser usada na geração de código de outras entidades.",
     )
-    mixins: Optional[List[str]] = Field(
-        None,
-        description="Lista de mixins (blocos reutilizáveis) aplicados ao modelo.",
-    )
-    required: Optional[List[str]] = Field(
-        None, description="Lista de campos obrigatórios no modelo."
-    )
-    partition_data: Optional[List[str]] = Field(
-        None,
-        description="Lista de propriedades da entidade, que serã usadas para particionamento dos dados no banco (sendo obrigatórias em todas as chamadas, inclusive como um tipo de filtro obrigatório).",
-    )
-    main_properties: Optional[List[str]] = Field(
-        None,
-        description="Lista de propriedades resumo do modelo (retornadas em qualquer chamada GET, mesmo que não pedidas por meio do parâmetro 'fields').",
-    )
-    search_properties: Optional[List[str]] = Field(
-        None,
-        description="Lista de propriedades do modelo que serão utilizadas nas chamadas de query do usuário (suportando também campos das entidades relacionadas). Sugere-se que a biblioteca crie automaticamente os índices para fulltext search.",
-    )
-    metric_label: Optional[List[str]] = Field(
-        None,
-        description="Lista de campos incluídos no agrupamento das métricas enviadas ao OpenTelemetry.",
-    )
-    trait_properties: Optional[Dict[str, TraitPropertyMetaModel]] = Field(
-        None,
-        description="Dicionário de propriedades condicionais da trait (isso é, especifica propriedades, e seus valores fixos, que serão usados como um tipo de filtro fixo usado como condição para que a propridade principal assum o papel daquele tipo de trait).",
-    )
-    properties: Dict[str, PropertyMetaModel] = Field(
-        ..., description="Dicionário de propriedades do modelo."
-    )
-    repository: RepositoryModel = Field(
-        ..., description="Configurações de mapeamento para o banco de dados."
-    )
     api: APIModel = Field(
         ...,
         description="Definição da API REST associada ao modelo, com todos os seus endpoints.",
     )
-
-    # Propriedades de controle da compilação (não fazem parte do JSON de representação das entidades)
-    tenant: int = Field(default=0, exclude=True)
-    grupo_empresarial: uuid.UUID = Field(
-        default=uuid.UUID("00000000-0000-0000-0000-000000000000"), exclude=True
-    )

nsj_rest_lib2/compiler/edl_model/entity_model_base.py

@@ -0,0 +1,69 @@
+from __future__ import annotations
+
+import uuid
+
+from pydantic import BaseModel, Field
+from typing import Dict, List, Optional
+
+from nsj_rest_lib2.compiler.edl_model.property_meta_model import PropertyMetaModel
+from nsj_rest_lib2.compiler.edl_model.repository_model import RepositoryModel
+from nsj_rest_lib2.compiler.edl_model.trait_property_meta_model import (
+    TraitPropertyMetaModel,
+)
+
+
+class EntityModelBase(BaseModel):
+    description: str = Field(..., description="Descrição da entidade.")
+    id: str = Field(
+        ...,
+        description="Identificador único da entidade, dentro de um determinado escopo (podendo ser sobreescrito para um tenant ou grupo _empresarial).",
+    )
+    trait_from: Optional[str] = Field(
+        None, description="Identificador da entidade que a trait estende."
+    )
+    mixins: Optional[List[str]] = Field(
+        None,
+        description="Lista de mixins (blocos reutilizáveis) aplicados ao modelo.",
+    )
+    required: Optional[List[str]] = Field(
+        None, description="Lista de campos obrigatórios no modelo."
+    )
+    partition_data: Optional[List[str]] = Field(
+        None,
+        description="Lista de propriedades da entidade, que serã usadas para particionamento dos dados no banco (sendo obrigatórias em todas as chamadas, inclusive como um tipo de filtro obrigatório).",
+    )
+    main_properties: Optional[List[str]] = Field(
+        None,
+        description="Lista de propriedades resumo do modelo (retornadas em qualquer chamada GET, mesmo que não pedidas por meio do parâmetro 'fields').",
+    )
+    search_properties: Optional[List[str]] = Field(
+        None,
+        description="Lista de propriedades do modelo que serão utilizadas nas chamadas de query do usuário (suportando também campos das entidades relacionadas). Sugere-se que a biblioteca crie automaticamente os índices para fulltext search.",
+    )
+    metric_label: Optional[List[str]] = Field(
+        None,
+        description="Lista de campos incluídos no agrupamento das métricas enviadas ao OpenTelemetry.",
+    )
+    trait_properties: Optional[Dict[str, TraitPropertyMetaModel]] = Field(
+        None,
+        description="Dicionário de propriedades condicionais da trait (isso é, especifica propriedades, e seus valores fixos, que serão usados como um tipo de filtro fixo usado como condição para que a propridade principal assum o papel daquele tipo de trait).",
+    )
+    properties: Dict[str, PropertyMetaModel] = Field(
+        ..., description="Dicionário de propriedades do modelo."
+    )
+    components: Optional[Dict[str, "EntityModelBase"]] = Field(
+        None,
+        description="Entidades filhas, relacionadas por composição e definidas inline (evitando a criação de novos arquivos EDL para a definição de entidades componentes da entidade atual).",
+    )
+    repository: RepositoryModel = Field(
+        ..., description="Configurações de mapeamento para o banco de dados."
+    )
+
+    # Propriedades de controle da compilação (não fazem parte do JSON de representação das entidades)
+    tenant: int = Field(default=0, exclude=True)
+    grupo_empresarial: uuid.UUID = Field(
+        default=uuid.UUID("00000000-0000-0000-0000-000000000000"), exclude=True
+    )
+
+
+EntityModelBase.model_rebuild()

nsj_rest_lib2/compiler/edl_model/primitives.py

@@ -4,7 +4,7 @@ from typing import Annotated, List, Union
 from pydantic import StringConstraints
 
 REGEX_EXTERNAL_REF = r"^(\w+)\/(\w+)$"
-REGEX_INTERNAL_REF = r"^#\/(\w+)\/(\w+)$"
+REGEX_INTERNAL_REF = r"^#\/components\/(\w+)$"
 
 ExternalRefType = Annotated[str, StringConstraints(pattern=REGEX_EXTERNAL_REF)]
 InternalRefType = Annotated[str, StringConstraints(pattern=REGEX_INTERNAL_REF)]

nsj_rest_lib2/compiler/entity_compiler.py

@@ -3,7 +3,7 @@ import ast
 import black
 
 from nsj_rest_lib2.compiler.edl_model.entity_model import EntityModel
-from nsj_rest_lib2.compiler.edl_model.repository_model import RepositoryModel
+from nsj_rest_lib2.compiler.edl_model.entity_model_base import EntityModelBase
 from nsj_rest_lib2.compiler.util.str_util import CompilerStrUtil
 from nsj_rest_lib2.compiler.util.type_naming_util import compile_entity_class_name
 
@@ -14,9 +14,10 @@ class EntityCompiler:
 
     def compile(
         self,
-        entity_model: EntityModel,
+        entity_model: EntityModelBase,
         ast_entity_attributes: list[ast.stmt],
         props_pk: list[str],
+        prefix_class_name: str,
     ) -> tuple[str, str]:
         # Imports
         imports = [
@@ -49,7 +50,11 @@ class EntityCompiler:
             )
 
         default_order_props = []
-        if entity_model.api and entity_model.api.default_sort:
+        if (
+            isinstance(entity_model, EntityModel)
+            and entity_model.api
+            and entity_model.api.default_sort
+        ):
             default_order_props = entity_model.api.default_sort
 
         default_order_fields = []
@@ -67,7 +72,7 @@ class EntityCompiler:
         if CompilerStrUtil.to_snake_case(props_pk[0]) not in default_order_fields:
             default_order_fields.append(CompilerStrUtil.to_snake_case(props_pk[0]))
 
-        class_name = compile_entity_class_name(entity_model.id)
+        class_name = compile_entity_class_name(entity_model.id, prefix_class_name)
         ast_class = ast.ClassDef(
             name=class_name,
             bases=[ast.Name(id="EntityBase", ctx=ast.Load())],

nsj_rest_lib2/compiler/property_compiler.py

@@ -6,6 +6,7 @@ from nsj_rest_lib2.compiler.compiler_structures import (
     PropertiesCompilerStructure,
 )
 from nsj_rest_lib2.compiler.edl_model.entity_model import EntityModel
+from nsj_rest_lib2.compiler.edl_model.entity_model_base import EntityModelBase
 from nsj_rest_lib2.compiler.edl_model.primitives import (
     BasicTypes,
     CardinalityTypes,
@@ -29,16 +30,18 @@ from nsj_rest_lib2.compiler.util.type_util import TypeUtil
 # TODO pattern
 # TODO lowercase
 # TODO uppercase
-# TODO Adicionar o nome da entidade, no nome das classes de enum (para evitar conflitos no caso das traits)
 
 
 class EDLPropertyCompiler:
+
     def compile(
         self,
         properties_structure: PropertiesCompilerStructure,
         map_unique_by_property: dict[str, IndexCompilerStructure],
-        entity_model: EntityModel,
+        escopo: str,
+        entity_model: EntityModelBase,
         entity_models: dict[str, EntityModel],
+        prefx_class_name: str,
     ) -> tuple[
         list[ast.stmt],
         list[ast.stmt],
@@ -52,22 +55,23 @@ class EDLPropertyCompiler:
         # TODO Criar opção de campo calculado?
 
         # Descobrindo os atributos marcados como PK (e recuperando a chave primária)
-        # pk_keys = []
-        # for pkey in properties_structure.properties:
-        #     prop = properties_structure.properties[pkey]
-
-        #     if isinstance(prop.type, PrimitiveTypes):
-        #         if prop.pk:
-        #             pk_keys.append(pkey)
-
-        # if len(pk_keys) > 1:
-        #     raise Exception(
-        #         f"Entidade '{entity_model.id}' possui mais de uma chave primária (ainda não suportado): {pk_keys}"
-        #     )
-        # elif len(pk_keys) == 0:
-        #     raise Exception(
-        #         f"Entidade '{entity_model.id}' não tem nenhuma chave primária (ainda não suportado)"
-        #     )
+        # TODO Verificar se devemos manter essa verificação
+        pk_keys = []
+        for pkey in properties_structure.properties:
+            prop = properties_structure.properties[pkey]
+
+            if isinstance(prop.type, PrimitiveTypes):
+                if prop.pk:
+                    pk_keys.append(pkey)
+
+        if len(pk_keys) > 1:
+            raise Exception(
+                f"Entidade '{entity_model.id}' possui mais de uma chave primária (ainda não suportado): {pk_keys}"
+            )
+        elif len(pk_keys) == 0:
+            raise Exception(
+                f"Entidade '{entity_model.id}' não tem nenhuma chave primária (ainda não suportado)"
+            )
 
         # pk_key = pk_keys[0]
 
@@ -87,11 +91,12 @@ class EDLPropertyCompiler:
             prop = properties_structure.properties[pkey]
 
             # DTO
-            ## Tratando propriedade simples (não array, não object)
             if isinstance(prop.type, PrimitiveTypes):
+                # Tratando propriedade simples (não array, não object)
                 self._compile_simple_property(
                     properties_structure,
                     map_unique_by_property,
+                    escopo,
                     entity_model,
                     ast_dto_attributes,
                     ast_entity_attributes,
@@ -99,9 +104,11 @@ class EDLPropertyCompiler:
                     enum_classes,
                     pkey,
                     prop,
+                    prefx_class_name,
                 )
 
             elif isinstance(prop.type, str):
+                # Tratando propriedade de relacionamento
                 external_match = re.match(REGEX_EXTERNAL_REF, prop.type)
                 internal_match = re.match(REGEX_INTERNAL_REF, prop.type)
 
@@ -125,8 +132,18 @@ class EDLPropertyCompiler:
                     )
 
                 elif internal_match:
-                    # TODO
-                    pass
+                    related_entity_id = internal_match.group(1)
+
+                    self._compile_internal_relation(
+                        related_entity_id,
+                        entity_model,
+                        properties_structure,
+                        ast_dto_attributes,
+                        ast_entity_attributes,
+                        pkey,
+                        prop,
+                        prefx_class_name,
+                    )
                 else:
                     raise Exception(
                         f"Tipo da propriedade '{pkey}' não suportado: {prop.type}"
@@ -143,8 +160,10 @@ class EDLPropertyCompiler:
                 ast_dto_attributes,
                 ast_entity_attributes,
                 fixed_filters,
+                escopo,
                 entity_model,
                 enum_classes,
+                prefx_class_name,
             )
 
         return (
@@ -166,8 +185,10 @@ class EDLPropertyCompiler:
         ast_dto_attributes: list[ast.stmt],
         ast_entity_attributes: list[ast.stmt],
         fixed_filters: list[tuple[str, BasicTypes]],
-        entity_model: EntityModel,
+        escopo: str,
+        entity_model: EntityModelBase,
         enum_classes: list[ast.stmt],
+        prefx_class_name: str,
     ):
         enum_class_name = None
         keywords = []
@@ -273,7 +294,9 @@ class EDLPropertyCompiler:
 
         # Trtando de uma definição de enum
         if prop.domain_config:
-            result = self._compile_domain_config(pkey, prop, entity_model)
+            result = self._compile_domain_config(
+                pkey, prop, escopo, entity_model, prefx_class_name
+            )
             if not result:
                 raise Exception(f"Erro desconhecido ao compilar a propriedade {pkey}")
 
@@ -343,14 +366,14 @@ class EDLPropertyCompiler:
         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)
+        # TODO Pensar 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_model: EntityModelBase,
         entity_models: dict[str, EntityModel],
         properties_structure: PropertiesCompilerStructure,
         ast_dto_attributes: list[ast.stmt],
@@ -414,6 +437,57 @@ class EDLPropertyCompiler:
                 pkey,
                 related_dto_class_name,
                 related_entity_class_name,
+                prop,
+            )
+
+        elif prop.cardinality == CardinalityTypes.C1_1:
+            self._build_ast_1_1(
+                properties_structure,
+                ast_dto_attributes,
+                ast_entity_attributes,
+                pkey,
+                related_dto_class_name,
+                related_entity_class_name,
+                prop,
+            )
+
+        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 _compile_internal_relation(
+        self,
+        related_entity_id: str,
+        entity_model: EntityModelBase,
+        properties_structure: PropertiesCompilerStructure,
+        ast_dto_attributes: list[ast.stmt],
+        ast_entity_attributes: list[ast.stmt],
+        pkey: str,
+        prop: PropertyMetaModel,
+        prefx_class_name: str,
+    ):
+        # Resolvendo o nome das classes de DTO e Entity
+        related_dto_class_name = compile_dto_class_name(
+            related_entity_id, f"{prefx_class_name}_{entity_model.id}"
+        )
+        related_entity_class_name = compile_entity_class_name(
+            related_entity_id, f"{prefx_class_name}_{entity_model.id}"
+        )
+
+        # 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,
+                prop,
             )
 
         elif prop.cardinality == CardinalityTypes.C1_1:
@@ -424,6 +498,7 @@ class EDLPropertyCompiler:
                 pkey,
                 related_dto_class_name,
                 related_entity_class_name,
+                prop,
             )
 
         elif prop.cardinality == CardinalityTypes.CN_N:
@@ -441,7 +516,10 @@ class EDLPropertyCompiler:
         pkey: str,
         related_dto_class_name: str,
         related_entity_class_name: str,
+        prop: PropertyMetaModel,
     ):
+        # TODO Verificar uso da propriedade relation_key_field do Rest_lib_1
+
         # Propriedade do property descriptor
         keywords = [
             ast.keyword(
@@ -454,6 +532,23 @@ class EDLPropertyCompiler:
             ),
         ]
 
+        # Tratando das opções básicas do descritor de propriedade
+        if properties_structure.required and pkey in properties_structure.required:
+            keywords.append(ast.keyword(arg="not_null", value=ast.Constant(True)))
+
+        if prop.max_length:
+            keywords.append(ast.keyword(arg="max", value=ast.Constant(prop.max_length)))
+        if prop.min_length:
+            keywords.append(ast.keyword(arg="min", value=ast.Constant(prop.min_length)))
+
+        if prop.validator:
+            keywords.append(
+                ast.keyword(
+                    arg="validator",
+                    value=ast.Name(prop.validator, ctx=ast.Load()),
+                )
+            )
+
         # Resolvendo a coluna usada no relacionamento
         if (
             not properties_structure.entity_properties
@@ -464,7 +559,10 @@ class EDLPropertyCompiler:
                 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
+        relation_column_ref = properties_structure.entity_properties[
+            pkey
+        ].relation_column
+        relation_column = str(relation_column_ref).split("/")[-1]
 
         keywords.append(
             ast.keyword(
@@ -497,6 +595,7 @@ class EDLPropertyCompiler:
         pkey: str,
         related_dto_class_name: str,
         related_entity_class_name: str,
+        prop: PropertyMetaModel,
     ):
         # Propriedade do property descriptor
         keywords = [
@@ -506,6 +605,24 @@ class EDLPropertyCompiler:
             ),
         ]
 
+        # Tratando das opções básicas do descritor de propriedade
+        if properties_structure.required and pkey in properties_structure.required:
+            keywords.append(ast.keyword(arg="not_null", value=ast.Constant(True)))
+
+        if (
+            properties_structure.main_properties
+            and pkey in properties_structure.main_properties
+        ):
+            keywords.append(ast.keyword(arg="resume", value=ast.Constant(True)))
+
+        if prop.validator:
+            keywords.append(
+                ast.keyword(
+                    arg="validator",
+                    value=ast.Name(prop.validator, ctx=ast.Load()),
+                )
+            )
+
         # Resolvendo a coluna usada no relacionamento
         if (
             not properties_structure.entity_properties
@@ -525,6 +642,9 @@ class EDLPropertyCompiler:
             owner_relation = True
             relation_column = relation_column.split("/")[-1]
 
+        # TODO Verificar, porque desconfio que o apontamento para a coluna de relacionamento
+        # para o caso do relacionamento OTHER, não é suportado pelo RestLib (acho que, quando
+        # o dono é OTHER, o RestLib sempre aponta para a PK da entidade corrente).
         keywords.append(
             ast.keyword(
                 arg="relation_field",
@@ -621,6 +741,7 @@ class EDLPropertyCompiler:
         self,
         properties_structure,
         map_unique_by_property,
+        escopo,
         entity_model,
         ast_dto_attributes,
         ast_entity_attributes,
@@ -628,6 +749,7 @@ class EDLPropertyCompiler:
         enum_classes,
         pkey,
         prop,
+        prefx_class_name: str,
     ):
         enum_class_name = None
         keywords = []
@@ -681,18 +803,18 @@ class EDLPropertyCompiler:
         if prop.type in [PrimitiveTypes.STRING, PrimitiveTypes.EMAIL]:
             if prop.max_length:
                 max = prop.max_length
-            elif prop.min_length:
+            if prop.min_length:
                 min = prop.min_length
         elif prop.type in [PrimitiveTypes.INTEGER, PrimitiveTypes.NUMBER]:
             if prop.minimum:
                 min = prop.minimum
-            elif prop.maximum:
+            if prop.maximum:
                 max = prop.maximum
 
         if max:
-            keywords.append(ast.keyword(arg="max", value=ast.Constant(prop.max_length)))
+            keywords.append(ast.keyword(arg="max", value=ast.Constant(max)))
         if min:
-            keywords.append(ast.keyword(arg="min", value=ast.Constant(prop.min_length)))
+            keywords.append(ast.keyword(arg="min", value=ast.Constant(min)))
 
         if (
             properties_structure.search_properties
@@ -796,7 +918,9 @@ class EDLPropertyCompiler:
             )
 
         if prop.domain_config:
-            result = self._compile_domain_config(pkey, prop, entity_model)
+            result = self._compile_domain_config(
+                pkey, prop, escopo, entity_model, prefx_class_name
+            )
             if not result:
                 raise Exception(f"Erro desconhecido ao compilar a propriedade {pkey}")
 
@@ -839,7 +963,9 @@ class EDLPropertyCompiler:
         self,
         pkey: str,
         prop: PropertyMetaModel | TraitPropertyMetaModel,
-        entity_model: EntityModel,
+        escopo: str,
+        entity_model: EntityModelBase,
+        prefx_class_name: str,
     ) -> tuple[str, ast.stmt] | None:
         if not prop.domain_config:
             return None
@@ -881,7 +1007,7 @@ class EDLPropertyCompiler:
             ast_values.append(ast_value)
 
         # Instanciando o atributo AST
-        enum_class_name = f"{CompilerStrUtil.to_pascal_case(entity_model.escopo)}{CompilerStrUtil.to_pascal_case(entity_model.id)}{CompilerStrUtil.to_pascal_case(pkey)}Enum"
+        enum_class_name = f"{CompilerStrUtil.to_pascal_case(escopo)}{CompilerStrUtil.to_pascal_case(prefx_class_name)}{CompilerStrUtil.to_pascal_case(entity_model.id)}{CompilerStrUtil.to_pascal_case(pkey)}Enum"
         ast_enum_class = ast.ClassDef(
             name=enum_class_name,
             bases=[

nsj_rest_lib2/compiler/util/type_naming_util.py

@@ -13,9 +13,9 @@ def compile_namespace_keys(
     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_dto_class_name(entity_id: str, prefx_class_name: str = "") -> str:
+    return f"{CompilerStrUtil.to_pascal_case(prefx_class_name)}{CompilerStrUtil.to_pascal_case(entity_id)}DTO"
 
 
-def compile_entity_class_name(entity_id: str) -> str:
-    return f"{CompilerStrUtil.to_pascal_case(entity_id)}Entity"
+def compile_entity_class_name(entity_id: str, prefx_class_name: str = "") -> str:
+    return f"{CompilerStrUtil.to_pascal_case(prefx_class_name)}{CompilerStrUtil.to_pascal_case(entity_id)}Entity"

nsj_rest_lib2/service/entity_loader.py

@@ -317,8 +317,8 @@ class EntityLoader:
                 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")
+            self._safe_exec(source_dto, namespace.entities_dict, "DTO source")
 
             # Gravando a entidade no dict de entidades carregadas
             loaded_entity = LoadedEntity()

{nsj_rest_lib2-0.0.13.dist-info → nsj_rest_lib2-0.0.14.dist-info}/METADATA

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

@@ -4,31 +4,32 @@ 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=tWnhDuHpvpJMWMPxt6U76ZS6J-hSpiB7xRZaeOP3CMc,12334
-nsj_rest_lib2/compiler/compiler_structures.py,sha256=2bM4_7lG1fytDGxJl6SU9pLsbspiNV36gVn9-O-23Q8,1009
-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/compiler.py,sha256=zyHaP2Vi-ONkfc6F59DXtVDgdQ_EOFcWAURUPdJBfx4,15171
+nsj_rest_lib2/compiler/compiler_structures.py,sha256=ZUeWnO-23f3JHq4bOfTcqszMDDXwuFEtMRhqMN7GeWQ,1214
+nsj_rest_lib2/compiler/dto_compiler.py,sha256=KDdfzoghbsO0RpWAhuhZ4gsb11aoxgci-93dwxWNMuY,5400
+nsj_rest_lib2/compiler/entity_compiler.py,sha256=7LypMMlgXnUIkpO7rEYtc2V1sKi9Nv1IxlXkgObX25s,4453
 nsj_rest_lib2/compiler/model.py,sha256=QDBoM26qoZdiNcykl1nvXCrFDhg-6Q__QzVq6uY1QzE,1460
-nsj_rest_lib2/compiler/property_compiler.py,sha256=AvJYY5vbmlodGjgyuCx6u17x0Qv3nEsAdMmBcSQP2f4,31153
+nsj_rest_lib2/compiler/property_compiler.py,sha256=EP-EnszasIKaCgz-_HzBliNA5L7cilixwnhrJD68iJI,35720
 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=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/entity_model.py,sha256=tkx76ldDS5iFr3CbPi4mmq6y5F55LcgAhqCsrqfdzkc,936
+nsj_rest_lib2/compiler/edl_model/entity_model_base.py,sha256=cUpbNUat7GJgJv14-8R2XYPc0vrcLXC6KPoVaXYZZ5A,3291
 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/primitives.py,sha256=GTo8e1mf9munvl_J1-fmaXgSJ8yQvGX56f2rwS85M1Y,1459
 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=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
+nsj_rest_lib2/compiler/util/type_naming_util.py,sha256=wTfxPCezCTt-ltSg_hkaYNH7Z05k-mlJKZd-9AMA9ac,768
 nsj_rest_lib2/compiler/util/type_util.py,sha256=HTKOH4uRTOY0YgoM8oUv_6cEcReE_bgKYXFBsQCb-3A,357
 nsj_rest_lib2/controller/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nsj_rest_lib2/controller/dynamic_controller.py,sha256=XMqxe1NW-NE5XwomXb4pSNdALQHpP74Hc26R4fnmXqg,15194
 nsj_rest_lib2/service/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nsj_rest_lib2/service/entity_loader.py,sha256=KVLFQSqj4DL-K-T29ksJE2or9QkekFmyAGUIKjQX6Qk,15372
-nsj_rest_lib2-0.0.13.dist-info/METADATA,sha256=mR2ZDZ5jbP18qsS288vSwD0tWDPOhibp_iyP-CrQ0Hk,1361
-nsj_rest_lib2-0.0.13.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-nsj_rest_lib2-0.0.13.dist-info/top_level.txt,sha256=L6zh0EfH8_rur7OJ8_V-El-XEMf4qg3bkF8ADgqLVIA,14
-nsj_rest_lib2-0.0.13.dist-info/RECORD,,
+nsj_rest_lib2/service/entity_loader.py,sha256=cv34rNuSOOz4_l5ouW_X-IIDiRtEkN44Dn3quNBDZJE,15372
+nsj_rest_lib2-0.0.14.dist-info/METADATA,sha256=aYvlmJGdy6qZxzyAij9JKvOYIBNawhmVY3SeX8kwkSE,1361
+nsj_rest_lib2-0.0.14.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+nsj_rest_lib2-0.0.14.dist-info/top_level.txt,sha256=L6zh0EfH8_rur7OJ8_V-El-XEMf4qg3bkF8ADgqLVIA,14
+nsj_rest_lib2-0.0.14.dist-info/RECORD,,