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

nsj_rest_lib2/compiler/compiler.py

@@ -1,3 +1,4 @@
+import re
 from typing import Any
 
 from nsj_rest_lib2.compiler.compiler_structures import (
@@ -5,6 +6,7 @@ from nsj_rest_lib2.compiler.compiler_structures import (
     PropertiesCompilerStructure,
 )
 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.property_compiler import EDLPropertyCompiler
@@ -13,11 +15,15 @@ from nsj_rest_lib2.compiler.edl_model.entity_model import EntityModel
 
 from nsj_rest_lib2.settings import get_logger
 
+# 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 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)
 
 
 class CompilerResult:
@@ -102,17 +108,22 @@ class EDLCompiler:
         )
 
         # Criando a lista de atributos do DTO e da Entity; e recuperando as chaves primarias
-        ast_dto_attributes, ast_entity_attributes, props_pk, enum_classes = (
-            self._properties_compiler.compile(
-                properties_structure,
-                map_unique_by_property,
-                entity_model,
-            )
+        (
+            ast_dto_attributes,
+            ast_entity_attributes,
+            props_pk,
+            enum_classes,
+            related_imports,
+        ) = self._properties_compiler.compile(
+            properties_structure,
+            map_unique_by_property,
+            entity_model,
+            entity_models,
         )
 
         # Gerando o código do DTO
         dto_class_name, code_dto = self._dto_compiler.compile(
-            entity_model, ast_dto_attributes, enum_classes
+            entity_model, ast_dto_attributes, enum_classes, related_imports
         )
 
         # Gerando o código da Entity
@@ -232,16 +243,27 @@ class EDLCompiler:
 
     def _list_dependencies(self, entity_model: EntityModel) -> list[str]:
         entities: list[str] = []
+
         if entity_model.trait_from:
             entities.append(entity_model.trait_from)
 
+        # Populando com as dependências de propriedades de relacionamento 1_N
+        for pkey in entity_model.properties:
+            prop = entity_model.properties[pkey]
+
+            if isinstance(prop.type, str):
+                external_match = re.match(REGEX_EXTERNAL_REF, prop.type)
+                if external_match:
+                    external_dependency = external_match.group(0)
+                    entities.append(external_dependency)
+
         return entities
 
 
 def get_files_from_directory(directory):
     files = []
     for file in os.listdir(directory):
-        if file.endswith(".json"):
+        if file.endswith(".json") or file.endswith(".yml") or file.endswith(".yaml"):
             files.append(os.path.join(directory, file))
     return files
 
@@ -250,6 +272,7 @@ if __name__ == "__main__":
     import argparse
     import json
     import os
+    import yaml
 
     parser = argparse.ArgumentParser(
         description="Compila arquivos EDL para classes Python"
@@ -267,13 +290,16 @@ if __name__ == "__main__":
 
     entities = {}
     for file in files:
-        with open(file) as f:
-            edl_json = json.load(f)
+        with open(file, "r") as f:
+            if file.endswith(".json"):
+                edl = json.load(f)
+            else:
+                edl = yaml.safe_load(f)
 
         # Instanciando o objeto de modelo de entidade a partir do JSON,
         # e já realizando as validações básicas de tipo e estrutura.
         print(f"Validando arquivo: {file}")
-        entity_model = EntityModel(**edl_json)
+        entity_model = EntityModel(**edl)
 
         complete_entity_id = f"{entity_model.escopo}/{entity_model.id}"
         entities[complete_entity_id] = entity_model

nsj_rest_lib2/compiler/dto_compiler.py

@@ -4,6 +4,7 @@ import black
 
 from nsj_rest_lib2.compiler.edl_model.entity_model import EntityModel
 from nsj_rest_lib2.compiler.util.str_util import CompilerStrUtil
+from nsj_rest_lib2.compiler.util.type_naming_util import compile_dto_class_name
 
 
 class DTOCompiler:
@@ -15,6 +16,7 @@ class DTOCompiler:
         entity_model: EntityModel,
         ast_dto_attributes: list[ast.stmt],
         enum_classes: list[ast.stmt],
+        related_imports: list[tuple[str, str, str]],
     ) -> tuple[str, str]:
         """
         Compila o código do DTO a partir do AST e retorna o código compilado.
@@ -31,6 +33,7 @@ class DTOCompiler:
         :return: Código compilado do DTO
         :rtype: str
         """
+        # Criando o ast dos imports
         imports = [
             # import datetime
             ast.Import(names=[ast.alias(name="datetime", asname=None)]),
@@ -50,6 +53,12 @@ class DTOCompiler:
                 names=[ast.alias(name="DTOField", asname=None)],
                 level=0,
             ),
+            # from nsj_rest_lib.descriptor.dto_list_field import DTOField
+            ast.ImportFrom(
+                module="nsj_rest_lib.descriptor.dto_list_field",
+                names=[ast.alias(name="DTOListField", asname=None)],
+                level=0,
+            ),
             # from nsj_rest_lib.descriptor.dto_field_validators import DTOFieldValidators
             ast.ImportFrom(
                 module="nsj_rest_lib.descriptor.dto_field_validators",
@@ -64,7 +73,24 @@ class DTOCompiler:
             ),
         ]
 
-        class_name = f"{CompilerStrUtil.to_pascal_case(entity_model.id)}DTO"
+        for import_ in related_imports:
+            imports.append(
+                ast.ImportFrom(
+                    module=f"dynamic.{import_[0]}",
+                    names=[ast.alias(name=import_[1])],
+                    level=0,
+                )
+            )
+            imports.append(
+                ast.ImportFrom(
+                    module=f"dynamic.{import_[0]}",
+                    names=[ast.alias(name=import_[2])],
+                    level=0,
+                )
+            )
+
+        # Criando o ast da classe
+        class_name = compile_dto_class_name(entity_model.id)
         ast_class = ast.ClassDef(
             name=class_name,
             bases=[ast.Name(id="DTOBase", ctx=ast.Load())],

nsj_rest_lib2/compiler/edl_model/column_meta_model.py

@@ -1,6 +1,16 @@
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, Field, model_validator
 from typing import List, Optional, Literal
 
 
 class ColumnMetaModel(BaseModel):
-    column: str = Field(..., description="Nome da coluna no banco de dados.")
+    column: Optional[str] = Field(None, description="Nome da coluna no banco de dados.")
+    relation_column: Optional[str] = Field(
+        None,
+        description="Nome da coluna usada para relacionamento com outra entidade (para um relacionamento 1_N, indica a coluna da entidade relacionada, que aponta para a PK da entidade corrente).",
+    )
+
+    @model_validator(mode="after")
+    def check_columns(self):
+        if self.column is None and self.relation_column is None:
+            raise ValueError("column or relation_column must be provided")
+        return self

nsj_rest_lib2/compiler/edl_model/entity_model.py

@@ -1,3 +1,5 @@
+import uuid
+
 from pydantic import BaseModel, Field
 from typing import Dict, List, Optional
 
@@ -64,3 +66,9 @@ class EntityModel(BaseModel):
         ...,
         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/primitives.py

@@ -1,5 +1,13 @@
 import enum
-from typing import List
+
+from typing import Annotated, List, Union
+from pydantic import StringConstraints
+
+REGEX_EXTERNAL_REF = r"^(\w+)\/(\w+)$"
+REGEX_INTERNAL_REF = r"^#\/(\w+)\/(\w+)$"
+
+ExternalRefType = Annotated[str, StringConstraints(pattern=REGEX_EXTERNAL_REF)]
+InternalRefType = Annotated[str, StringConstraints(pattern=REGEX_INTERNAL_REF)]
 
 
 class PrimitiveTypes(enum.Enum):
@@ -8,8 +16,6 @@ class PrimitiveTypes(enum.Enum):
     NUMBER = "number"
     INTEGER = "integer"
     BOOLEAN = "boolean"
-    ARRAY = "array"
-    OBJECT = "object"
     UUID = "uuid"
     CURRENCY = "currency"
     QUANTITY = "quantity"
@@ -21,13 +27,13 @@ class PrimitiveTypes(enum.Enum):
     DATETIME = "datetime"
 
 
+PropertyType = Union[PrimitiveTypes, ExternalRefType, InternalRefType]
+
 MAPPING_PRIMITIVE_TYPES_TO_PYTHON = {
     PrimitiveTypes.STRING: "str",
     PrimitiveTypes.NUMBER: "float",
     PrimitiveTypes.INTEGER: "int",
     PrimitiveTypes.BOOLEAN: "bool",
-    PrimitiveTypes.ARRAY: "List",
-    PrimitiveTypes.OBJECT: "dict",
     PrimitiveTypes.UUID: "uuid.UUID",
     PrimitiveTypes.CURRENCY: "float",
     PrimitiveTypes.QUANTITY: "float",
@@ -41,3 +47,9 @@ MAPPING_PRIMITIVE_TYPES_TO_PYTHON = {
 
 BasicTypes = int | bool | float | str
 DefaultTypes = BasicTypes | List[BasicTypes]
+
+
+class CardinalityTypes(enum.Enum):
+    C1_1 = "1_1"
+    C1_N = "1_N"
+    CN_N = "N_N"

nsj_rest_lib2/compiler/edl_model/property_meta_model.py

@@ -1,8 +1,8 @@
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, Field, model_validator
 from typing import List, Optional
 
 from nsj_rest_lib2.compiler.edl_model.primitives import BasicTypes, DefaultTypes
-from nsj_rest_lib2.compiler.edl_model.primitives import PrimitiveTypes
+from nsj_rest_lib2.compiler.edl_model.primitives import CardinalityTypes, PropertyType
 
 
 class DomainConfigModel(BaseModel):
@@ -13,7 +13,7 @@ class DomainConfigModel(BaseModel):
 
 
 class PropertyMetaModel(BaseModel):
-    type: PrimitiveTypes = Field(..., description="Tipo da propriedade.")
+    type: PropertyType = Field(..., description="Tipo da propriedade.")
     label: Optional[str] = Field(None, description="Rótulo da propriedade.")
     description: Optional[str] = Field(None, description="Descrição da propriedade.")
     default: Optional[DefaultTypes] = Field(
@@ -28,6 +28,10 @@ class PropertyMetaModel(BaseModel):
         description="Indica se a propriedade é parte de uma chave alternativa (chave natural).",
         alias="keyAlternative",
     )
+    cardinality: Optional[CardinalityTypes] = Field(
+        None,
+        description="Cardinalidade do relacionamento (válido para propriedades do tipo 'array' ou 'object').",
+    )
     # Validação
     max_length: Optional[int] = Field(
         None, description="Comprimento máximo (para strings)."
@@ -80,3 +84,11 @@ class PropertyMetaModel(BaseModel):
         None,
         description="Função de conversão do tipo da entidade para o tipo da API (ex.: converter uuid para string).",
     )
+
+    @model_validator(mode="after")
+    def check_cardinality_required(self):
+        if isinstance(self.type, str) and self.cardinality is None:
+            raise ValueError(
+                "The property 'cardinality' is required when type point to other entity."
+            )
+        return self

nsj_rest_lib2/compiler/edl_model/trait_property_meta_model.py

@@ -1,10 +1,10 @@
 from pydantic import BaseModel, Field
 
-from nsj_rest_lib2.compiler.edl_model.primitives import BasicTypes, PrimitiveTypes
+from nsj_rest_lib2.compiler.edl_model.primitives import BasicTypes, PropertyType
 
 
 class TraitPropertyMetaModel(BaseModel):
-    type: PrimitiveTypes = Field(..., description="Tipo da propriedade.")
+    type: PropertyType = Field(..., description="Tipo da propriedade.")
     value: BasicTypes = Field(
         ..., description="Valor fixo da propriedade de condicionamento do trait."
     )

nsj_rest_lib2/compiler/entity_compiler.py

@@ -5,6 +5,7 @@ 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.util.str_util import CompilerStrUtil
+from nsj_rest_lib2.compiler.util.type_naming_util import compile_entity_class_name
 
 
 class EntityCompiler:
@@ -66,7 +67,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 = f"{CompilerStrUtil.to_pascal_case(entity_model.id)}Entity"
+        class_name = compile_entity_class_name(entity_model.id)
         ast_class = ast.ClassDef(
             name=class_name,
             bases=[ast.Name(id="EntityBase", ctx=ast.Load())],

nsj_rest_lib2/compiler/property_compiler.py

@@ -1,13 +1,24 @@
 import ast
+import re
 
 from nsj_rest_lib2.compiler.compiler_structures import (
     IndexCompilerStructure,
     PropertiesCompilerStructure,
 )
 from nsj_rest_lib2.compiler.edl_model.entity_model import EntityModel
-from nsj_rest_lib2.compiler.edl_model.primitives import PrimitiveTypes
+from nsj_rest_lib2.compiler.edl_model.primitives import (
+    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.util.str_util import CompilerStrUtil
+from nsj_rest_lib2.compiler.util.type_naming_util import (
+    compile_dto_class_name,
+    compile_entity_class_name,
+    compile_namespace_keys,
+)
 from nsj_rest_lib2.compiler.util.type_util import TypeUtil
 
 # TODO pattern
@@ -22,288 +33,430 @@ class EDLPropertyCompiler:
         properties_structure: PropertiesCompilerStructure,
         map_unique_by_property: dict[str, IndexCompilerStructure],
         entity_model: EntityModel,
-    ) -> tuple[list[ast.stmt], list[ast.stmt], list[str], list[ast.stmt]]:
+        entity_models: dict[str, EntityModel],
+    ) -> tuple[
+        list[ast.stmt],
+        list[ast.stmt],
+        list[str],
+        list[ast.stmt],
+        list[tuple[str, str, str]],
+    ]:
 
         # 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)"
+        #     )
+
+        # pk_key = pk_keys[0]
+
+        # Instanciando as listas de retorno
         ast_dto_attributes = []
         ast_entity_attributes = []
         props_pk = []
         enum_classes = []
+        related_imports = []
 
         if properties_structure.properties is None:
             return (ast_dto_attributes, ast_entity_attributes, props_pk, enum_classes)
 
         for pkey in properties_structure.properties:
             prop = properties_structure.properties[pkey]
-            enum_class_name = None
 
             # DTO
             ## Tratando propriedade simples (não array, não object)
-            if prop.type not in [PrimitiveTypes.ARRAY, PrimitiveTypes.OBJECT]:
-                keywords = []
-
-                if prop.pk:
-                    keywords.append(ast.keyword(arg="pk", value=ast.Constant(True)))
-                    props_pk.append(pkey)
+            if isinstance(prop.type, PrimitiveTypes):
+                self.compile_simple_property(
+                    properties_structure,
+                    map_unique_by_property,
+                    entity_model,
+                    ast_dto_attributes,
+                    ast_entity_attributes,
+                    props_pk,
+                    enum_classes,
+                    pkey,
+                    prop,
+                )
 
-                if prop.key_alternative:
-                    keywords.append(
-                        ast.keyword(arg="candidate_key", value=ast.Constant(True))
-                    )
+            elif isinstance(prop.type, str):
+                external_match = re.match(REGEX_EXTERNAL_REF, prop.type)
 
-                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 external_match:
+                    # Resolvendo o id da entidade
+                    related_entity_id = external_match.group(2)
 
-                if (
-                    properties_structure.partition_data
-                    and pkey in properties_structure.partition_data
-                ):
-                    keywords.append(
-                        ast.keyword(arg="partition_data", value=ast.Constant(True))
+                    # 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
                     )
 
-                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),
-                        )
-                    )
+                    # Resolvendo o caminho do import
+                    related_entity_key = external_match.group(0)
 
-                if (
-                    prop.default
-                ):  # TODO Verificar esse modo de tratar valores default (principalmente expressões)
-                    keywords.append(
-                        ast.keyword(
-                            arg="default_value",
-                            value=ast.Name(str(prop.default), ctx=ast.Load()),
+                    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}'."
                         )
-                    )
 
-                if prop.trim:
-                    keywords.append(ast.keyword(arg="strip", value=ast.Constant(True)))
-
-                max = None
-                min = None
-                if prop.type in [PrimitiveTypes.STRING, PrimitiveTypes.EMAIL]:
-                    if prop.max_length:
-                        max = prop.max_length
-                    elif prop.min_length:
-                        min = prop.min_length
-                elif prop.type in [PrimitiveTypes.INTEGER, PrimitiveTypes.NUMBER]:
-                    if prop.minimum:
-                        min = prop.minimum
-                    elif prop.maximum:
-                        max = prop.maximum
-
-                if max:
-                    keywords.append(
-                        ast.keyword(arg="max", value=ast.Constant(prop.max_length))
-                    )
-                if min:
-                    keywords.append(
-                        ast.keyword(arg="min", value=ast.Constant(prop.min_length))
-                    )
-
-                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))
+                    tenant = related_entity.tenant
+                    grupo_empresarial = related_entity.grupo_empresarial
+                    grupo_key, tenant_key, default_key = compile_namespace_keys(
+                        tenant, grupo_empresarial
                     )
 
-                if (
-                    properties_structure.metric_label
-                    and pkey in properties_structure.metric_label
-                ):
-                    keywords.append(
-                        ast.keyword(arg="metric_label", value=ast.Constant(True))
+                    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,
+                        )
                     )
 
-                if prop.type == PrimitiveTypes.CPF and not prop.validator:
-                    keywords.append(
-                        ast.keyword(
-                            arg="validator",
-                            value=ast.Attribute(
-                                value=ast.Call(
-                                    func=ast.Name(
-                                        id="DTOFieldValidators", ctx=ast.Load()
-                                    ),
-                                    args=[],
-                                    keywords=[],
+                    # 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()
                                 ),
-                                attr="validate_cpf",
-                                ctx=ast.Load(),
                             ),
-                        )
-                    )
-                elif prop.type == PrimitiveTypes.CNPJ and not prop.validator:
-                    keywords.append(
-                        ast.keyword(
-                            arg="validator",
-                            value=ast.Attribute(
-                                value=ast.Call(
-                                    func=ast.Name(
-                                        id="DTOFieldValidators", ctx=ast.Load()
-                                    ),
-                                    args=[],
-                                    keywords=[],
+                            ast.keyword(
+                                arg="entity_type",
+                                value=ast.Name(
+                                    id=related_entity_class_name, ctx=ast.Load()
                                 ),
-                                attr="validate_cnpj",
-                                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),
+                            )
                         )
-                    )
-                elif prop.type == PrimitiveTypes.CPF_CNPJ and not prop.validator:
-                    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(),
+
+                        ast_attr = ast.AnnAssign(
+                            target=ast.Name(
+                                id=CompilerStrUtil.to_snake_case(pkey), ctx=ast.Store()
                             ),
-                        )
-                    )
-                elif prop.type == PrimitiveTypes.EMAIL and not prop.validator:
-                    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",
+                            annotation=ast.Name(
+                                id="list",
                                 ctx=ast.Load(),
                             ),
-                        )
-                    )
-                elif prop.validator:
-                    keywords.append(
-                        ast.keyword(
-                            arg="validator",
-                            value=ast.Name(prop.validator, ctx=ast.Load()),
-                        )
-                    )
-
-                if prop.immutable:
-                    keywords.append(
-                        ast.keyword(arg="read_only", value=ast.Constant(True))
-                    )
-
-                if prop.on_save:
-                    keywords.append(
-                        ast.keyword(
-                            arg="convert_to_entity",
-                            value=ast.Name(prop.on_save, ctx=ast.Load()),
-                        )
-                    )
-
-                if prop.on_retrieve:
-                    keywords.append(
-                        ast.keyword(
-                            arg="convert_from_entity",
-                            value=ast.Name(id=prop.on_retrieve, ctx=ast.Load()),
-                        )
-                    )
-
-                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}"
+                            value=ast.Call(
+                                func=ast.Name(id="DTOListField", ctx=ast.Load()),
+                                args=[],
+                                keywords=keywords,
+                            ),
+                            simple=1,
                         )
 
-                    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),
-                        )
-                    )
+                        ast_dto_attributes.append(ast_attr)
+                    else:
+                        # TODO
+                        pass
 
-                # Instanciando o atributo AST
-                if enum_class_name:
-                    prop_type = enum_class_name
+                elif re.match(REGEX_INTERNAL_REF, prop.type):
+                    # TODO
+                    pass
                 else:
-                    prop_type = TypeUtil.property_type_to_python_type(prop.type)
+                    raise Exception(f"Tipo de propriedade não suportado: {prop.type}")
+
+        return (
+            ast_dto_attributes,
+            ast_entity_attributes,
+            props_pk,
+            enum_classes,
+            related_imports,
+        )
 
-                ast_attr = ast.AnnAssign(
-                    target=ast.Name(
-                        id=CompilerStrUtil.to_snake_case(pkey), ctx=ast.Store()
-                    ),
-                    annotation=ast.Name(
-                        id=prop_type,
+    def compile_simple_property(
+        self,
+        properties_structure,
+        map_unique_by_property,
+        entity_model,
+        ast_dto_attributes,
+        ast_entity_attributes,
+        props_pk,
+        enum_classes,
+        pkey,
+        prop,
+    ):
+        enum_class_name = None
+        keywords = []
+
+        if prop.pk:
+            keywords.append(ast.keyword(arg="pk", value=ast.Constant(True)))
+            props_pk.append(pkey)
+
+        if prop.key_alternative:
+            keywords.append(ast.keyword(arg="candidate_key", 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 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 (
+            prop.default
+        ):  # TODO Verificar esse modo de tratar valores default (principalmente expressões)
+            keywords.append(
+                ast.keyword(
+                    arg="default_value",
+                    value=ast.Name(str(prop.default), ctx=ast.Load()),
+                )
+            )
+
+        if prop.trim:
+            keywords.append(ast.keyword(arg="strip", value=ast.Constant(True)))
+
+        max = None
+        min = None
+        if prop.type in [PrimitiveTypes.STRING, PrimitiveTypes.EMAIL]:
+            if prop.max_length:
+                max = prop.max_length
+            elif prop.min_length:
+                min = prop.min_length
+        elif prop.type in [PrimitiveTypes.INTEGER, PrimitiveTypes.NUMBER]:
+            if prop.minimum:
+                min = prop.minimum
+            elif prop.maximum:
+                max = prop.maximum
+
+        if max:
+            keywords.append(ast.keyword(arg="max", value=ast.Constant(prop.max_length)))
+        if min:
+            keywords.append(ast.keyword(arg="min", value=ast.Constant(prop.min_length)))
+
+        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 and not prop.validator:
+            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(),
                     ),
-                    value=ast.Call(
-                        func=ast.Name(id="DTOField", ctx=ast.Load()),
-                        args=[],
-                        keywords=keywords,
+                )
+            )
+        elif prop.type == PrimitiveTypes.CNPJ and not prop.validator:
+            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(),
                     ),
-                    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(),
+            )
+        elif prop.type == PrimitiveTypes.CPF_CNPJ and not prop.validator:
+            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(),
                     ),
-                    annotation=ast.Name(
-                        id=TypeUtil.property_type_to_python_type(prop.type),
+                )
+            )
+        elif prop.type == PrimitiveTypes.EMAIL and not prop.validator:
+            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(),
                     ),
-                    value=ast.Constant(value=None),
-                    simple=1,
                 )
+            )
+        elif prop.validator:
+            keywords.append(
+                ast.keyword(
+                    arg="validator",
+                    value=ast.Name(prop.validator, ctx=ast.Load()),
+                )
+            )
 
-                ast_entity_attributes.append(ast_entity_attr)
+        if prop.immutable:
+            keywords.append(ast.keyword(arg="read_only", value=ast.Constant(True)))
+
+        if prop.on_save:
+            keywords.append(
+                ast.keyword(
+                    arg="convert_to_entity",
+                    value=ast.Name(prop.on_save, ctx=ast.Load()),
+                )
+            )
+
+        if prop.on_retrieve:
+            keywords.append(
+                ast.keyword(
+                    arg="convert_from_entity",
+                    value=ast.Name(id=prop.on_retrieve, ctx=ast.Load()),
+                )
+            )
+
+        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 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,
+        )
 
-        return ast_dto_attributes, ast_entity_attributes, props_pk, enum_classes
+        ast_entity_attributes.append(ast_entity_attr)
 
     def _compile_domain_config(
         self,

nsj_rest_lib2/compiler/util/type_naming_util.py

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

nsj_rest_lib2/service/entity_loader.py

@@ -6,6 +6,7 @@ import types
 
 from nsj_rest_lib.settings import get_logger
 
+from nsj_rest_lib2.compiler.util.type_naming_util import compile_namespace_keys
 from nsj_rest_lib2.exception import MissingEntityConfigException
 from nsj_rest_lib2.redis_config import get_redis
 from nsj_rest_lib2.settings import ESCOPO_RESTLIB2, MIN_TIME_SOURCE_REFRESH
@@ -44,9 +45,9 @@ class EntityLoader:
         grupo_empresarial: str | None,
     ) -> tuple[str, str, dict, bool, list[str]]:
         # Montando as chaves dos namespaces
-        grupo_key = f"tenant_{tenant}.ge_{grupo_empresarial}"
-        tenant_key = f"tenant_{tenant}"
-        default_key = "default"
+        grupo_key, tenant_key, default_key = compile_namespace_keys(
+            tenant, grupo_empresarial
+        )
 
         result = self._load_entity_source_from_memory(
             entity_resource, grupo_key, tenant_key, default_key
@@ -182,6 +183,18 @@ class EntityLoader:
         with self._lock:
             namespaces_dict.clear()
 
+    def _ensure_dynamic_package(self):
+        """
+        Garante que exista um pacote 'dynamic' em sys.modules.
+        """
+        pkg = sys.modules.get("dynamic")
+        if pkg is None:
+            pkg = types.ModuleType("dynamic")
+            pkg.__path__ = []  # marca como pacote
+            pkg.__package__ = "dynamic"
+            sys.modules["dynamic"] = pkg
+        return pkg
+
     def _execute_entity_source(
         self,
         entity_config_str: str,
@@ -233,19 +246,32 @@ class EntityLoader:
 
         # Carregando a entidade no namespace
         with self._lock:
+            self._ensure_dynamic_package()
+
             namespace = namespaces_dict.get(entity_config_key)
             if namespace is None:
                 namespace = Namespace()
                 namespace.key = entity_config_key
                 namespaces_dict[entity_config_key] = namespace
 
-            # Executando o código da entidade
-            module = types.ModuleType(entity_config_key)
-            sys.modules[entity_config_key] = module
-            module.__dict__["__builtins__"] = __builtins__
+            # Hot reload: removendo o módulo do sys.modules, se existir
+            full_name = f"dynamic.{entity_config_key}"
+            # if full_name in sys.modules:
+            #     sys.modules.pop(full_name)
 
-            namespace.module = module
-            namespace.entities_dict = module.__dict__
+            # Executando o código da entidade
+            module = sys.modules.get(full_name)
+            if not module:
+                module = types.ModuleType(full_name)
+                module.__package__ = "dynamic"
+                module.__dict__["__builtins__"] = __builtins__
+                sys.modules[full_name] = module
+
+                parent = sys.modules["dynamic"]
+                setattr(parent, entity_config_key, module)
+
+                namespace.module = module
+                namespace.entities_dict = module.__dict__
 
             self._safe_exec(source_dto, namespace.entities_dict, "DTO source")
             self._safe_exec(source_entity, namespace.entities_dict, "Entity source")

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nsj_rest_lib2
-Version: 0.0.8
+Version: 0.0.9
 Summary: Biblioteca para permitir a distribuição de rotas dinâmicas numa API, configuradas por meio de EDLs declarativos (em formato JSON).
 Home-page: https://github.com/Nasajon/nsj_rest_lib2
 Author: Nasajon Sistemas
@@ -17,6 +17,7 @@ Requires-Dist: redis<7.0.0,>=6.4.0
 Requires-Dist: nsj-multi-database-lib<3.0.0,>=2.0.1
 Requires-Dist: pydantic<3.0.0,>=2.11.9
 Requires-Dist: black<26.0.0,>=25.1.0
+Requires-Dist: pyyaml>7.0.0,>=6.0.3
 
 # nsj_rest_lib2
 

{nsj_rest_lib2-0.0.8.dist-info → nsj_rest_lib2-0.0.9.dist-info}/RECORD

@@ -4,29 +4,30 @@ 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=oFuHBSQekXYhYREAiiHARC9Rpr5ZKUlgh5aDQ8bqslE,11143
+nsj_rest_lib2/compiler/compiler.py,sha256=wkREdCrQ6mq6-R-5nC5ZXDGNpSEIPjuSjt-NCxOS6to,12228
 nsj_rest_lib2/compiler/compiler_structures.py,sha256=2bM4_7lG1fytDGxJl6SU9pLsbspiNV36gVn9-O-23Q8,1009
-nsj_rest_lib2/compiler/dto_compiler.py,sha256=WyUM3V2_5r3Zn-teR1CNMgRKr9sH_yALzUe-VRDJOwY,3163
-nsj_rest_lib2/compiler/entity_compiler.py,sha256=ytcS-RPQTJtf56z4HqT3xQLBYzbd6UUPGsaGB1pj_EA,4240
-nsj_rest_lib2/compiler/property_compiler.py,sha256=ZJ3GLSbth1nGgxujUKjlR2lg-PeiOZ2NeqfqQuZm2xU,14396
+nsj_rest_lib2/compiler/dto_compiler.py,sha256=GAKWFvks0Duqs2EsEr1-BFx2-Kny72jJMbl9ZyIEDXw,4125
+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/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=V1VI0LslSDO6oB2cOQrTcBijBnWIPL7s4xNbI2Wb8Kk,195
-nsj_rest_lib2/compiler/edl_model/entity_model.py,sha256=lE4RS4776IsP5yoxHuGUV6B7G1_yxM0kb0ogFgSYVhs,3364
+nsj_rest_lib2/compiler/edl_model/column_meta_model.py,sha256=3OLsRwEz66Cktzew6Hie3HZXK9u20GXlWUU0HtFtwfk,709
+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=VAzTbpkQAZWkeTdpoXL4FSaO1KEMTPXOxl6WxIJMWHk,1104
-nsj_rest_lib2/compiler/edl_model/property_meta_model.py,sha256=i7lu-JFvPzUDBdsHB6kspGUyCkqf_GuTRmKfpIZj-K0,3444
+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=NA8eRh5rA0boFmFd-0sHLrilOoOQSeN-amN_4TXcGiA,358
+nsj_rest_lib2/compiler/edl_model/trait_property_meta_model.py,sha256=ZC2oTvc9Y2Oiy4NLNHQLiMOLRWDAOdF8GJxOw4nqHdk,354
 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_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=ITYnC7syPmSVct12flRpyQhMCA1jUiGSiu6539kQW9k,12525
-nsj_rest_lib2-0.0.8.dist-info/METADATA,sha256=Dd83C-bWpwER9sjSsUAFn0E9TrkNmS0qfKWaqDjBt0A,1324
-nsj_rest_lib2-0.0.8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-nsj_rest_lib2-0.0.8.dist-info/top_level.txt,sha256=L6zh0EfH8_rur7OJ8_V-El-XEMf4qg3bkF8ADgqLVIA,14
-nsj_rest_lib2-0.0.8.dist-info/RECORD,,
+nsj_rest_lib2/service/entity_loader.py,sha256=PJX-cPPCllhZuqSZzj8ZX_0HZQBnt20dqLc9E0e0GtA,13472
+nsj_rest_lib2-0.0.9.dist-info/METADATA,sha256=SGdzF8Wef-XXnNnH3Q1bKfM-fVAetqyXTGHHIiKDLAk,1360
+nsj_rest_lib2-0.0.9.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+nsj_rest_lib2-0.0.9.dist-info/top_level.txt,sha256=L6zh0EfH8_rur7OJ8_V-El-XEMf4qg3bkF8ADgqLVIA,14
+nsj_rest_lib2-0.0.9.dist-info/RECORD,,