nsj-rest-lib2 0.0.21__tar.gz → 0.0.23__tar.gz

{nsj_rest_lib2-0.0.21 → nsj_rest_lib2-0.0.23}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nsj_rest_lib2
-Version: 0.0.21
+Version: 0.0.23
 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
@@ -25,16 +25,3 @@ Biblioteca para permitir a distribuição de rotas dinâmicas numa API, configur
 
 [ESPECIFICAÇÃO DO MODELO DE ENTIDADES](docs/especificacao.md)
 
-## TODO
-* Valores default
-* Usar trait_properties como valor default
-* Não está carregando a lista de dependências de execução, para os components
-* Implementar gravação de entidades com extensão parcial
-* Unificar o arquivo redis_config.py
-* Usar pydantic, ou similar, para transformar a configuração das entidades, no redis, num objeto
-* Rever modo de usar o InjectFactory (talvez dando ciência, ao RestLib, do padrão multibanco)
-* Implementar e documentar campos join
-* Implementar e documentar conjuntos
-* Dar erro ao haver conflito de nomes das propriedades (por qualquer tipo de herança)
-* Rotas para o inline
-* inline será para composição (arquivo externo é agregação)

nsj_rest_lib2-0.0.23/README.md

@@ -0,0 +1,6 @@
+# nsj_rest_lib2
+
+Biblioteca para permitir a distribuição de rotas dinâmicas numa API, configuradas por meio de EDLs declarativos (em formato JSON).
+
+[ESPECIFICAÇÃO DO MODELO DE ENTIDADES](docs/especificacao.md)
+

{nsj_rest_lib2-0.0.21 → nsj_rest_lib2-0.0.23}/nsj_rest_lib2/compiler/compiler.py

@@ -25,18 +25,6 @@ from nsj_rest_lib2.compiler.edl_model.entity_model import EntityModel
 
 from nsj_rest_lib2.settings import get_logger
 
-# TODO GET e POST de relacionamentos 1X1
-# TODO Revisar compilação de valores default (sensível a tipos)
-# TODO Implementar suporte a conjuntos
-# TODO Autenticação nas rotas
-# TODO Atualizar o status da entidade pelo worker de compilação (e talvez parar uma compilação, quando se delete uma entidade)
-# TODO Classes Abstratas
-# TODO Partial Classes
-# TODO Migrations
-# 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:
@@ -117,7 +105,9 @@ class EDLCompiler:
                     f"Entidade base '{entity_model.partial_of}' da extensão parcial '{entity_model.id}' é inválida."
                 )
 
-            self._validate_partial_model(entity_model, base_model_candidate, entity_models)
+            self._validate_partial_model(
+                entity_model, base_model_candidate, entity_models
+            )
             partial_metadata = self._build_partial_metadata(
                 entity_model, base_model_candidate
             )

{nsj_rest_lib2-0.0.21 → nsj_rest_lib2-0.0.23}/nsj_rest_lib2/compiler/edl_model/primitives.py

@@ -48,6 +48,14 @@ MAPPING_PRIMITIVE_TYPES_TO_PYTHON = {
 BasicTypes = int | bool | float | str
 DefaultTypes = BasicTypes | List[BasicTypes]
 
+STR_BASED_TYPES = {
+    PrimitiveTypes.STRING,
+    PrimitiveTypes.EMAIL,
+    PrimitiveTypes.CPF,
+    PrimitiveTypes.CNPJ,
+    PrimitiveTypes.CPF_CNPJ,
+}
+
 
 class CardinalityTypes(enum.Enum):
     C1_1 = "1_1"

{nsj_rest_lib2-0.0.21 → nsj_rest_lib2-0.0.23}/nsj_rest_lib2/compiler/edl_model/property_meta_model.py

@@ -36,7 +36,6 @@ class PropertyMetaModel(BaseModel):
         None, description="Comprimento máximo (para strings)."
     )
 
-    ## TODO Sugestões de validação
     min_length: Optional[int] = Field(
         None, description="Comprimento mínimo (para strings)."
     )

{nsj_rest_lib2-0.0.21 → nsj_rest_lib2-0.0.23}/nsj_rest_lib2/compiler/property_compiler.py

@@ -1,5 +1,7 @@
 import ast
+import datetime
 import re
+import uuid
 
 from nsj_rest_lib2.compiler.compiler_structures import (
     IndexCompilerStructure,
@@ -13,6 +15,7 @@ from nsj_rest_lib2.compiler.edl_model.primitives import (
     PrimitiveTypes,
     REGEX_EXTERNAL_REF,
     REGEX_INTERNAL_REF,
+    STR_BASED_TYPES,
 )
 from nsj_rest_lib2.compiler.edl_model.property_meta_model import PropertyMetaModel
 from nsj_rest_lib2.compiler.edl_model.trait_property_meta_model import (
@@ -27,10 +30,6 @@ from nsj_rest_lib2.compiler.util.type_naming_util import (
 )
 from nsj_rest_lib2.compiler.util.type_util import TypeUtil
 
-# TODO pattern
-# TODO lowercase
-# TODO uppercase
-
 
 class EDLPropertyCompiler:
 
@@ -51,9 +50,6 @@ class EDLPropertyCompiler:
         list[RelationDependency],
         list[tuple[str, BasicTypes]],
     ]:
-
-        # TODO Criar opção de campo calculado?
-
         # Descobrindo os atributos marcados como PK (e recuperando a chave primária)
         # TODO Verificar se devemos manter essa verificação
         pk_keys = []
@@ -64,8 +60,8 @@ class EDLPropertyCompiler:
                 if prop.pk:
                     pk_keys.append(pkey)
 
-        is_partial_extension = (
-            isinstance(entity_model, EntityModel) and bool(entity_model.partial_of)
+        is_partial_extension = isinstance(entity_model, EntityModel) and bool(
+            entity_model.partial_of
         )
 
         if not entity_model.mixin:
@@ -92,6 +88,10 @@ class EDLPropertyCompiler:
         if properties_structure.properties is None:
             return (ast_dto_attributes, ast_entity_attributes, props_pk, aux_classes)
 
+        trait_fixed_filters = self._merge_trait_extends_properties(
+            properties_structure
+        )
+
         composed_properties = properties_structure.composed_properties or {}
 
         aggregator_class_names: dict[str, str] = {}
@@ -155,6 +155,9 @@ class EDLPropertyCompiler:
                     prefx_class_name,
                 )
 
+                if pkey in trait_fixed_filters:
+                    fixed_filters.append((pkey, trait_fixed_filters[pkey]))
+
             elif isinstance(prop.type, str):
                 # Tratando propriedade de relacionamento
                 external_match = re.match(REGEX_EXTERNAL_REF, prop.type)
@@ -197,40 +200,6 @@ class EDLPropertyCompiler:
                         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_extends_property(
-                properties_structure,
-                map_unique_by_property,
-                pkey,
-                prop,
-                ast_dto_attributes,
-                ast_entity_attributes,
-                fixed_filters,
-                escopo,
-                entity_model,
-                aux_classes,
-                prefx_class_name,
-            )
-
-        for pkey in properties_structure.extends_properties:
-            prop = properties_structure.extends_properties[pkey]
-
-            self._compile_trait_extends_property(
-                properties_structure,
-                map_unique_by_property,
-                pkey,
-                prop,
-                ast_dto_attributes,
-                ast_entity_attributes,
-                fixed_filters,
-                escopo,
-                entity_model,
-                aux_classes,
-                prefx_class_name,
-            )
-
         for composed_key, class_name in aggregator_class_names.items():
             dto_attributes = aggregator_dto_attributes.get(composed_key, [])
 
@@ -258,199 +227,6 @@ class EDLPropertyCompiler:
             fixed_filters,
         )
 
-    def _compile_trait_extends_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]],
-        escopo: str,
-        entity_model: EntityModelBase,
-        aux_classes: list[ast.stmt],
-        prefx_class_name: str,
-    ):
-        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, escopo, entity_model, prefx_class_name
-            )
-            if not result:
-                raise Exception(f"Erro desconhecido ao compilar a propriedade {pkey}")
-
-            enum_class_name, ast_enum_class = result
-            aux_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 Pensar em validações para esse value (se está de acordo com o tipo ou enum)
-        fixed_filters.append((pkey, prop.value))
-
     def _build_aggregator_class_ast(
         self,
         class_name: str,
@@ -944,16 +720,6 @@ class EDLPropertyCompiler:
                 )
             )
 
-        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)))
 
@@ -1086,6 +852,15 @@ class EDLPropertyCompiler:
             enum_class_name, ast_enum_class = result
             aux_classes.append(ast_enum_class)
 
+        default_value_ast = self._build_default_value_ast(pkey, prop, enum_class_name)
+        if default_value_ast is not None:
+            keywords.append(
+                ast.keyword(
+                    arg="default_value",
+                    value=default_value_ast,
+                )
+            )
+
         # Resolvendo o nome da propriedade no Entity
         if (
             properties_structure.entity_properties
@@ -1118,6 +893,297 @@ class EDLPropertyCompiler:
 
         ast_entity_attributes.append(ast_entity_attr)
 
+    def _build_default_value_ast(
+        self,
+        pkey: str,
+        prop: PropertyMetaModel,
+        enum_class_name: str | None,
+    ) -> ast.expr | None:
+        default_value = prop.default
+        if default_value is None:
+            return None
+
+        if prop.domain_config and enum_class_name:
+            return self._build_enum_default_value_ast(
+                pkey, prop, enum_class_name, default_value
+            )
+
+        if not isinstance(prop.type, PrimitiveTypes):
+            raise ValueError(
+                f"Propriedade '{pkey}' não suporta valor default para relacionamentos."
+            )
+
+        return self._build_primitive_default_value_ast(pkey, prop, default_value)
+
+    def _build_enum_default_value_ast(
+        self,
+        pkey: str,
+        prop: PropertyMetaModel,
+        enum_class_name: str,
+        default_value: object,
+    ) -> ast.expr:
+        target_option = None
+        for option in prop.domain_config or []:
+            if option.value == default_value:
+                target_option = option
+                break
+
+            if option.mapped_value is not None and option.mapped_value == default_value:
+                target_option = option
+                break
+
+        if not target_option:
+            raise ValueError(
+                f"Propriedade '{pkey}' possui valor default '{default_value}' que não corresponde a nenhuma opção do enum."
+            )
+
+        enum_member_name = CompilerStrUtil.to_enum_member_name(target_option.value)
+
+        return ast.Attribute(
+            value=ast.Name(id=enum_class_name, ctx=ast.Load()),
+            attr=enum_member_name,
+            ctx=ast.Load(),
+        )
+
+    def _merge_trait_extends_properties(
+        self, properties_structure: PropertiesCompilerStructure
+    ) -> dict[str, BasicTypes]:
+        fixed_filters: dict[str, BasicTypes] = {}
+
+        trait_sources = (
+            properties_structure.trait_properties or {},
+            properties_structure.extends_properties or {},
+        )
+
+        for prop_dict in trait_sources:
+            for pkey, tprop in prop_dict.items():
+                if not isinstance(tprop.type, PrimitiveTypes):
+                    raise ValueError(
+                        f"Propriedade '{pkey}' definida em trait/extends precisa ser um tipo primitivo."
+                    )
+
+                base_prop = properties_structure.properties.get(pkey)
+
+                if base_prop:
+                    if base_prop.type != tprop.type:
+                        raise ValueError(
+                            f"Tipo da propriedade '{pkey}' em trait/extends não coincide com a definição existente."
+                        )
+
+                    base_prop.default = tprop.value
+
+                    if tprop.domain_config and not base_prop.domain_config:
+                        base_prop.domain_config = tprop.domain_config
+                else:
+                    base_prop = PropertyMetaModel(
+                        type=tprop.type,
+                        default=tprop.value,
+                        domain_config=tprop.domain_config,
+                    )
+                    properties_structure.properties[pkey] = base_prop
+
+                fixed_filters[pkey] = tprop.value
+
+        return fixed_filters
+
+    def _build_primitive_default_value_ast(
+        self,
+        pkey: str,
+        prop: PropertyMetaModel,
+        default_value: object,
+    ) -> ast.expr:
+        primitive_type = prop.type
+
+        if isinstance(default_value, str):
+            expression_ast = self._build_python_expression_from_string(default_value)
+            if expression_ast is not None:
+                return expression_ast
+
+        if primitive_type in STR_BASED_TYPES:
+            if not isinstance(default_value, str):
+                raise ValueError(
+                    f"Propriedade '{pkey}' exige valor default textual, recebido '{default_value}'."
+                )
+            return ast.Constant(value=default_value)
+
+        if primitive_type == PrimitiveTypes.BOOLEAN:
+            if isinstance(default_value, bool):
+                return ast.Constant(value=default_value)
+            raise ValueError(
+                f"Propriedade '{pkey}' exige valor default booleano, recebido '{default_value}'."
+            )
+
+        if primitive_type == PrimitiveTypes.INTEGER:
+            return self._build_numeric_constant_default_ast(
+                pkey,
+                default_value,
+                int,
+                "inteiro",
+                forbid_fraction=True,
+            )
+
+        if primitive_type in (
+            PrimitiveTypes.NUMBER,
+            PrimitiveTypes.CURRENCY,
+            PrimitiveTypes.QUANTITY,
+        ):
+            return self._build_numeric_constant_default_ast(
+                pkey,
+                default_value,
+                float,
+                "numérico",
+            )
+
+        if primitive_type == PrimitiveTypes.UUID:
+            return self._build_uuid_default_ast(pkey, default_value)
+
+        if primitive_type == PrimitiveTypes.DATE:
+            return self._build_iso_datetime_default_ast(
+                pkey,
+                default_value,
+                target="date",
+            )
+
+        if primitive_type == PrimitiveTypes.DATETIME:
+            return self._build_iso_datetime_default_ast(
+                pkey,
+                default_value,
+                target="datetime",
+            )
+
+        raise ValueError(
+            f"Propriedade '{pkey}' não suporta valor default para o tipo '{primitive_type.value}'."
+        )
+
+    def _build_numeric_constant_default_ast(
+        self,
+        pkey: str,
+        default_value: object,
+        cast_type: type,
+        type_label: str,
+        *,
+        forbid_fraction: bool = False,
+    ) -> ast.expr:
+        if isinstance(default_value, bool):
+            raise ValueError(
+                f"Propriedade '{pkey}' exige valor default {type_label}, recebido '{default_value}'."
+            )
+
+        value_to_convert = (
+            default_value.strip() if isinstance(default_value, str) else default_value
+        )
+
+        if forbid_fraction and isinstance(value_to_convert, float):
+            if not value_to_convert.is_integer():
+                raise ValueError(
+                    f"Propriedade '{pkey}' exige valor default inteiro, recebido '{default_value}'."
+                )
+
+        try:
+            converted_value = cast_type(value_to_convert)
+        except (TypeError, ValueError) as exc:
+            raise ValueError(
+                f"Propriedade '{pkey}' exige valor default {type_label}, recebido '{default_value}'."
+            ) from exc
+
+        if forbid_fraction and isinstance(value_to_convert, float):
+            converted_value = int(converted_value)
+
+        return ast.Constant(value=converted_value)
+
+    def _build_uuid_default_ast(
+        self,
+        pkey: str,
+        default_value: object,
+    ) -> ast.expr:
+        if isinstance(default_value, uuid.UUID):
+            uuid_value = str(default_value)
+        elif isinstance(default_value, str):
+            try:
+                uuid_value = str(uuid.UUID(default_value))
+            except ValueError as exc:
+                raise ValueError(
+                    f"Propriedade '{pkey}' exige UUID válido ou expressão Python, recebido '{default_value}'."
+                ) from exc
+        else:
+            raise ValueError(
+                f"Propriedade '{pkey}' exige UUID válido ou expressão Python, recebido '{default_value}'."
+            )
+
+        return ast.Call(
+            func=ast.Attribute(
+                value=ast.Name(id="uuid", ctx=ast.Load()),
+                attr="UUID",
+                ctx=ast.Load(),
+            ),
+            args=[ast.Constant(value=uuid_value)],
+            keywords=[],
+        )
+
+    def _build_iso_datetime_default_ast(
+        self,
+        pkey: str,
+        default_value: object,
+        *,
+        target: str,
+    ) -> ast.expr:
+        if target == "date":
+            parser = datetime.date
+        else:
+            parser = datetime.datetime
+
+        if isinstance(default_value, parser):
+            iso_value = default_value.isoformat()
+        elif isinstance(default_value, str):
+            iso_value = default_value.strip()
+        else:
+            raise ValueError(
+                f"Propriedade '{pkey}' exige {target} em formato ISO ou expressão Python, recebido '{default_value}'."
+            )
+
+        try:
+            parser.fromisoformat(iso_value)
+        except ValueError as exc:
+            raise ValueError(
+                f"Propriedade '{pkey}' exige {target} em formato ISO ou expressão Python, recebido '{default_value}'."
+            ) from exc
+
+        return ast.Call(
+            func=ast.Attribute(
+                value=ast.Attribute(
+                    value=ast.Name(id="datetime", ctx=ast.Load()),
+                    attr=target,
+                    ctx=ast.Load(),
+                ),
+                attr="fromisoformat",
+                ctx=ast.Load(),
+            ),
+            args=[ast.Constant(value=iso_value)],
+            keywords=[],
+        )
+
+    def _build_python_expression_from_string(self, expression: str) -> ast.expr | None:
+        try:
+            parsed_expr = ast.parse(expression, mode="eval").body
+        except SyntaxError:
+            return None
+
+        if self._is_safe_python_expression(parsed_expr):
+            return parsed_expr
+
+        return None
+
+    def _is_safe_python_expression(self, node: ast.AST) -> bool:
+        if isinstance(node, ast.Name):
+            return True
+        if isinstance(node, ast.Attribute):
+            return self._is_safe_python_expression(node.value)
+        if isinstance(node, ast.Call):
+            if node.keywords or node.args:
+                return False
+            return self._is_safe_python_expression(node.func)
+        return False
+
     def _compile_domain_config(
         self,
         pkey: str,
@@ -1139,7 +1205,7 @@ class EDLPropertyCompiler:
         # Compilando as opções do enum
         ast_values = []
         for value in prop.domain_config:
-            value_name = CompilerStrUtil.to_snake_case(value.value).upper()
+            value_name = CompilerStrUtil.to_enum_member_name(value.value)
 
             if use_mapped_value and value.mapped_value is None:
                 raise Exception(

{nsj_rest_lib2-0.0.21 → nsj_rest_lib2-0.0.23}/nsj_rest_lib2/compiler/util/str_util.py

@@ -1,3 +1,6 @@
+import re
+
+
 class CompilerStrUtil:
     @staticmethod
     def to_camel_case(snake_str: str) -> str:
@@ -20,3 +23,10 @@ class CompilerStrUtil:
                 snake_str += "_"
             snake_str += char.lower()
         return snake_str
+
+    @staticmethod
+    def to_enum_member_name(raw_value: str) -> str:
+        """Converte um valor livre para o nome de membro enum padronizado."""
+        sanitized = re.sub(r"[^0-9A-Za-z]+", "_", raw_value.strip())
+        sanitized = sanitized.strip("_")
+        return CompilerStrUtil.to_snake_case(sanitized).upper()

{nsj_rest_lib2-0.0.21 → nsj_rest_lib2-0.0.23}/nsj_rest_lib2/service/entity_loader.py

@@ -15,7 +15,6 @@ from nsj_rest_lib2.redis_config import get_redis
 from nsj_rest_lib2.settings import ESCOPO_RESTLIB2, MIN_TIME_SOURCE_REFRESH
 
 
-# TODO Verificar se está atualizando o loaded_at, quando o hash não muda
 class LoadedEntity:
     def __init__(self):
         self.dto_class_name: str = ""

{nsj_rest_lib2-0.0.21 → nsj_rest_lib2-0.0.23}/nsj_rest_lib2.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nsj_rest_lib2
-Version: 0.0.21
+Version: 0.0.23
 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
@@ -25,16 +25,3 @@ Biblioteca para permitir a distribuição de rotas dinâmicas numa API, configur
 
 [ESPECIFICAÇÃO DO MODELO DE ENTIDADES](docs/especificacao.md)
 
-## TODO
-* Valores default
-* Usar trait_properties como valor default
-* Não está carregando a lista de dependências de execução, para os components
-* Implementar gravação de entidades com extensão parcial
-* Unificar o arquivo redis_config.py
-* Usar pydantic, ou similar, para transformar a configuração das entidades, no redis, num objeto
-* Rever modo de usar o InjectFactory (talvez dando ciência, ao RestLib, do padrão multibanco)
-* Implementar e documentar campos join
-* Implementar e documentar conjuntos
-* Dar erro ao haver conflito de nomes das propriedades (por qualquer tipo de herança)
-* Rotas para o inline
-* inline será para composição (arquivo externo é agregação)

{nsj_rest_lib2-0.0.21 → nsj_rest_lib2-0.0.23}/setup.cfg

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

nsj_rest_lib2-0.0.21/README.md

@@ -1,19 +0,0 @@
-# nsj_rest_lib2
-
-Biblioteca para permitir a distribuição de rotas dinâmicas numa API, configuradas por meio de EDLs declarativos (em formato JSON).
-
-[ESPECIFICAÇÃO DO MODELO DE ENTIDADES](docs/especificacao.md)
-
-## TODO
-* Valores default
-* Usar trait_properties como valor default
-* Não está carregando a lista de dependências de execução, para os components
-* Implementar gravação de entidades com extensão parcial
-* Unificar o arquivo redis_config.py
-* Usar pydantic, ou similar, para transformar a configuração das entidades, no redis, num objeto
-* Rever modo de usar o InjectFactory (talvez dando ciência, ao RestLib, do padrão multibanco)
-* Implementar e documentar campos join
-* Implementar e documentar conjuntos
-* Dar erro ao haver conflito de nomes das propriedades (por qualquer tipo de herança)
-* Rotas para o inline
-* inline será para composição (arquivo externo é agregação)