nsj-rest-lib2 0.0.3__py3-none-any.whl → 0.0.5__py3-none-any.whl

nsj_rest_lib2/compiler/ai_compiler.py

@@ -0,0 +1,285 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+Gerador de DTO e Entity a partir de um EDL JSON (v1.x) — AGORA usando 'repository'
+no lugar de 'storage', e propagando o de-para de colunas:
+ - Entity usa os nomes físicos vindos de model.repository.columns[*].column (quando houver).
+ - DTOField ganha entity_field="<nome_do_atributo_na_Entity>" para cada propriedade.
+
+Uso:
+  python generator.py caminho/para/arquivo.edl.json
+"""
+
+import json
+import sys
+import keyword
+from typing import Any, Dict, List, Tuple
+
+# -----------------------
+# Helpers de transformação
+# -----------------------
+
+
+def py_identifier(name: str) -> str:
+    """Garante que o nome é um identificador Python válido."""
+    n = (name or "").strip().replace("-", "_")
+    if not n:
+        n = "_"
+    if not n.isidentifier() or keyword.iskeyword(n):
+        n = f"{n}_"
+    return n
+
+
+def detect_pk(model_props: Dict[str, Any]) -> str:
+    for logical, meta in model_props.items():
+        if isinstance(meta, dict) and meta.get("pk") is True:
+            return logical
+    return ""
+
+
+def to_python_type(prop: Dict[str, Any]) -> str:
+    t = (prop.get("type") or "string").lower()
+    fmt = (prop.get("format") or "").lower()
+
+    if fmt in {"uuid"}:
+        return "uuid.UUID"
+    if t in {"datetime"}:
+        return "datetime.datetime"
+    if t in {"date"}:
+        return "datetime.date"
+    if t in {"integer"}:
+        return "int"
+    if t in {"number"}:
+        return "float"
+    if t in {"boolean"}:
+        return "bool"
+    return "str"
+
+
+def build_entity_field_name(logical: str, columns_map: Dict[str, Any]) -> str:
+    """
+    Retorna o nome do atributo na Entity para um dado campo lógico,
+    priorizando o nome físico em repository.columns[logical].column (se existir).
+    """
+    col_meta = (columns_map or {}).get(logical) or {}
+    entity_attr = col_meta.get("column") or logical
+    return py_identifier(entity_attr)
+
+
+def dto_field_args(
+    logical: str,
+    prop: Dict[str, Any],
+    required: List[str],
+    columns_map: Dict[str, Any],
+) -> Dict[str, Any]:
+    args: Dict[str, Any] = {}
+
+    # Política: sempre expor (resume=True) e nunca ocultar campos que existem na origem
+    args["resume"] = True
+
+    # PK / not_null
+    if prop.get("pk") is True:
+        args["pk"] = True
+        args["not_null"] = True
+    if logical in set(required):
+        args["not_null"] = True
+
+    # Strings: strip + limites
+    t = (prop.get("type") or "string").lower()
+    if t == "string":
+        args["strip"] = True
+        if "length" in prop:
+            args["max"] = int(prop["length"])
+        if "minimum" in prop:
+            args["min"] = int(prop["minimum"])
+
+    # Números
+    if t in {"integer", "number"}:
+        if "minimum" in prop:
+            args["min"] = (
+                int(prop["minimum"]) if t == "integer" else float(prop["minimum"])
+            )
+        if "maximum" in prop:
+            args["max"] = (
+                int(prop["maximum"]) if t == "integer" else float(prop["maximum"])
+            )
+
+    # Formatos especiais
+    fmt = (prop.get("format") or "").lower()
+    if fmt == "uuid":
+        args["validator"] = "DTOFieldValidators().validate_uuid"
+        args["min"] = 36
+        args["max"] = 36
+
+    # Default lógico (quando presente)
+    if "default" in prop and prop["default"] is not None:
+        default_val = prop["default"]
+        if isinstance(default_val, (int, float, bool)):
+            args["default_value"] = repr(default_val)
+        elif isinstance(default_val, str) and default_val.endswith("()"):
+            args["default_value"] = default_val
+        else:
+            args["default_value"] = repr(default_val)
+
+    # Sempre informar o nome do atributo correspondente na Entity
+    args["entity_field"] = build_entity_field_name(logical, columns_map)
+
+    return args
+
+
+def render_dto(edl: Dict[str, Any]) -> Tuple[str, str]:
+    model = edl.get("model", {}) or {}
+    props: Dict[str, Any] = model.get("properties", {}) or {}
+    required: List[str] = model.get("required", []) or []
+    repository = model.get("repository", {}) or {}
+    columns_map: Dict[str, Any] = repository.get("columns", {}) or {}
+
+    entity_name_full = edl.get("id") or "Entity"
+    class_base = entity_name_full.split(".")[-1]
+    class_name = f"{class_base[0].upper()}{class_base[1:]}"
+    dto_class = f"{class_name}DTO"
+
+    # imports
+    need_uuid = any(((p.get("format") or "").lower() == "uuid") for p in props.values())
+    need_datetime = any(
+        ((p.get("type") or "").lower() in {"datetime", "date"}) for p in props.values()
+    )
+
+    header_imports = [
+        "from nsj_rest_lib.decorator.dto import DTO",
+        "from nsj_rest_lib.descriptor.dto_field import DTOField",
+        "from nsj_rest_lib.descriptor.dto_field_validators import DTOFieldValidators",
+        "from nsj_rest_lib.dto.dto_base import DTOBase",
+    ]
+    if need_uuid:
+        header_imports.insert(0, "import uuid")
+    if need_datetime:
+        header_imports.insert(0, "import datetime")
+
+    lines: List[str] = []
+    lines.extend(header_imports)
+    lines.append("")
+    lines.append("")
+    lines.append("@DTO()")
+    lines.append(f"class {dto_class}(DTOBase):")
+    if not props:
+        lines.append("    pass")
+        return (dto_class, "\n".join(lines))
+
+    for logical in props:
+        meta = props[logical] or {}
+        py_type = to_python_type(meta)
+        field_args = dto_field_args(logical, meta, required, columns_map)
+
+        # Monta chamada DTOField(...)
+        arg_parts = []
+        for k, v in field_args.items():
+            if k == "validator":
+                arg_parts.append(f"{k}={v}")
+            else:
+                arg_parts.append(f"{k}={repr(v)}")
+        args_str = ", ".join(arg_parts) if arg_parts else ""
+
+        lines.append("")
+        lines.append(f"    {py_identifier(logical)}: {py_type} = DTOField({args_str})")
+
+    return (dto_class, "\n".join(lines))
+
+
+def render_entity(edl: Dict[str, Any]) -> Tuple[str, str]:
+    model = edl.get("model", {}) or {}
+    props: Dict[str, Any] = model.get("properties", {}) or {}
+    repository = model.get("repository", {}) or {}
+    api = model.get("api", {}) or {}
+
+    entity_name_full = edl.get("id") or "Entity"
+    class_base = entity_name_full.split(".")[-1]
+    class_name = f"{class_base[0].upper()}{class_base[1:]}"
+    entity_class = f"{class_name}Entity"
+
+    table_name = repository.get("map") or "schema.tabela"
+    pk_field = detect_pk(props) or "id"
+
+    # default_order_fields = api.default_sort (removendo prefixos '+'|'-')
+    default_sort: List[str] = []
+    for item in api.get("default_sort", []) or []:
+        fld = str(item).lstrip("+-")
+        if fld in props:
+            default_sort.append(fld)
+    if not default_sort:
+        default_sort = [pk_field] if pk_field else []
+
+    # imports
+    need_uuid = any(((p.get("format") or "").lower() == "uuid") for p in props.values())
+    need_datetime = any(
+        ((p.get("type") or "").lower() in {"datetime", "date"}) for p in props.values()
+    )
+
+    header_imports = [
+        "from nsj_rest_lib.entity.entity_base import EntityBase",
+        "from nsj_rest_lib.decorator.entity import Entity",
+    ]
+    if need_uuid:
+        header_imports.insert(0, "import uuid")
+    if need_datetime:
+        header_imports.insert(0, "import datetime")
+
+    columns_map: Dict[str, Any] = repository.get("columns", {}) or {}
+
+    lines: List[str] = []
+    lines.extend(header_imports)
+    lines.append("")
+    lines.append("")
+    lines.append("@Entity(")
+    lines.append(f"    table_name={repr(table_name)},")
+    lines.append(f"    pk_field={repr(py_identifier(pk_field))},")
+    if default_sort:
+        lines.append(
+            f"    default_order_fields={[py_identifier(x) for x in default_sort]},"
+        )
+    lines.append(")")
+    lines.append(f"class {entity_class}(EntityBase):")
+
+    if not props:
+        lines.append("    pass")
+        return (entity_class, "\n".join(lines))
+
+    for logical, meta in props.items():
+        py_type = to_python_type(meta)
+        entity_attr = build_entity_field_name(logical, columns_map)
+        lines.append(f"    {entity_attr}: {py_type} = None")
+
+    return (entity_class, "\n".join(lines))
+
+
+def generate_from_edl(edl: Dict[str, Any]) -> Tuple[str, str, str, str]:
+    dto_class_name, dto_code = render_dto(edl)
+    entity_class_name, entity_code = render_entity(edl)
+    return (dto_class_name, dto_code, entity_class_name, entity_code)
+
+
+# -----------------------
+# CLI
+# -----------------------
+
+
+def main():
+    if len(sys.argv) < 2:
+        print("Uso: python generator.py caminho/para/arquivo.edl.json", file=sys.stderr)
+        sys.exit(2)
+
+    with open(sys.argv[1], "r", encoding="utf-8") as f:
+        edl = json.load(f)
+
+    _, dto_code, _, entity_code = generate_from_edl(edl)
+
+    sep = "\n" + ("#" * 80) + "\n"
+    print(sep + "# DTO\n" + sep)
+    print(dto_code)
+    print(sep + "# ENTITY\n" + sep)
+    print(entity_code)
+
+
+if __name__ == "__main__":
+    main()

nsj_rest_lib2/compiler/compiler.py

@@ -0,0 +1,288 @@
+from typing import Any
+
+from nsj_rest_lib2.compiler.compiler_structures import (
+    IndexCompilerStructure,
+    PropertiesCompilerStructure,
+)
+from nsj_rest_lib2.compiler.dto_compiler import DTOCompiler
+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
+
+from nsj_rest_lib2.compiler.edl_model.entity_model import EntityModel
+
+from nsj_rest_lib2.settings import get_logger
+
+# TODO Rever a questão do tempo de expiração ser renovado, na leitura do redis
+# TODO Atualizar o status da entidade pelo worker de compilação (e talvez parar uma compilação, quando se delete uma entidade)
+# TODO Relacionamentos
+# TODO Classes Abstratas
+# TODO Partial Classes
+# TODO Migrations
+# TODO Migrar para a nsj_rest_lib2
+# TODO Alterar o padrão de nomenclatura para snake_case
+
+
+class CompilerResult:
+    def __init__(self):
+        self.dto_class_name: str | None = None
+        self.dto_code: str | None = None
+        self.entity_class_name: str | None = None
+        self.entity_code: str | None = None
+        # TODO Informacoes das rotas
+
+
+class EDLCompiler:
+    def __init__(self) -> None:
+        self._properties_compiler = EDLPropertyCompiler()
+        self._dto_compiler = DTOCompiler()
+        self._entity_compiler = EntityCompiler()
+
+    def compile_models(
+        self, entity_models: dict[str, EntityModel]
+    ) -> list[CompilerResult]:
+
+        compiler_results = []
+        for entity_model_id in entity_models:
+            entity_model = entity_models[entity_model_id]
+            if not entity_model.abstract:
+                compiler_result = self._compile_model(entity_model, entity_models)
+                compiler_results.append(compiler_result)
+
+        return compiler_results
+
+    def compile_model_from_edl(
+        self,
+        edl_json: dict[str, Any],
+        dependencies_edls: list[dict[str, Any]],
+    ) -> CompilerResult:
+        entity_model = EntityModel(**edl_json)
+
+        entity_models = []
+        for dependency_edl in dependencies_edls:
+            dependency_entity_model = EntityModel(**dependency_edl)
+            entity_models.append(dependency_entity_model)
+
+        return self.compile_model(entity_model, entity_models)
+
+    def compile_model(
+        self,
+        entity_model: EntityModel,
+        dependencies_models: list[EntityModel],
+    ) -> CompilerResult:
+        entity_models = {}
+        for dependency_entity_model in dependencies_models:
+            complete_entity_id = (
+                f"{dependency_entity_model.escopo}/{dependency_entity_model.id}"
+            )
+            entity_models[complete_entity_id] = dependency_entity_model
+
+        return self._compile_model(entity_model, entity_models)
+
+    def _compile_model(
+        self,
+        entity_model: EntityModel,
+        entity_models: dict[str, EntityModel],
+    ) -> CompilerResult:
+
+        # 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]] = {}
+        map_unique_by_property: dict[str, IndexCompilerStructure] = {}
+        self._make_unique_map_by_property(
+            map_indexes_by_property, map_unique_by_property, entity_model, entity_models
+        )
+
+        # Criando uma cópia das coleções necessárias à compilação das properties
+        # (a ideia é ser possível alterar as coleções sem afetar a entidade modelo,
+        # o que será necessário para o tratamento de traits, etc - os quais serão
+        # uma classe nova, resultado da união dessas propriedades).
+        properties_structure = PropertiesCompilerStructure()
+        self._make_properties_structures(
+            properties_structure, entity_model, entity_models
+        )
+
+        # 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,
+            )
+        )
+
+        # Gerando o código do DTO
+        dto_class_name, code_dto = self._dto_compiler.compile(
+            entity_model, ast_dto_attributes, enum_classes
+        )
+
+        # Gerando o código da Entity
+        entity_class_name, code_entity = self._entity_compiler.compile(
+            entity_model, ast_entity_attributes, props_pk
+        )
+
+        # Retornando o resultado
+        compiler_result = CompilerResult()
+        compiler_result.entity_class_name = entity_class_name
+        compiler_result.entity_code = code_entity
+        compiler_result.dto_class_name = dto_class_name
+        compiler_result.dto_code = code_dto
+
+        return compiler_result
+
+    def _make_properties_structures(
+        self,
+        properties_structure: PropertiesCompilerStructure,
+        entity_model: EntityModel,
+        entity_models: dict[str, EntityModel],
+    ):
+        if not entity_model:
+            return
+
+        # Populando com as propriedades do trait
+        if entity_model.trait_from:
+            trait_model = entity_models[entity_model.trait_from]
+
+            self._make_properties_structures(
+                properties_structure,
+                trait_model,
+                entity_models,
+            )
+
+        # Populando com as propriedades da entidade atual
+        properties_structure.properties.update(entity_model.properties)
+        if entity_model.main_properties:
+            properties_structure.main_properties.extend(entity_model.main_properties)
+        if entity_model.required:
+            properties_structure.required.extend(entity_model.required)
+        if entity_model.partition_data:
+            properties_structure.partition_data.extend(entity_model.partition_data)
+        if entity_model.search_properties:
+            properties_structure.search_properties.extend(
+                entity_model.search_properties
+            )
+        if entity_model.metric_label:
+            properties_structure.metric_label.extend(entity_model.metric_label)
+
+        if entity_model.trait_properties:
+            properties_structure.trait_properties.update(entity_model.trait_properties)
+
+        if entity_model.repository.properties:
+            properties_structure.entity_properties.update(
+                entity_model.repository.properties
+            )
+
+    def _make_unique_map_by_property(
+        self,
+        map_indexes_by_property: dict[str, list[IndexCompilerStructure]],
+        map_unique_by_property: dict[str, IndexCompilerStructure],
+        entity_model: EntityModel,
+        entity_models: dict[str, EntityModel],
+        deep: int = 1,
+    ):
+
+        if not entity_model:
+            return
+
+        # Varrendo e organizando os índices
+        if entity_model.repository.indexes:
+            for index in entity_model.repository.indexes:
+                for pkey in index.columns:
+                    if index.unique:
+                        if pkey in map_unique_by_property:
+                            if deep > 1:
+                                get_logger().warning(
+                                    f"Propriedade '{pkey}' possui mais de um índice de unicidade (sendo um herdado). Por isso a replicação (herdada) será ignorada."
+                                )
+                                continue
+                            else:
+                                raise Exception(
+                                    f"Propriedade '{pkey}' possui mais de um índice de unicidade."
+                                )  # TODO Verificar esse modo de tratar erros
+
+                        map_unique_by_property[pkey] = IndexCompilerStructure(
+                            index, deep > 1
+                        )
+                    else:
+                        list_index = map_indexes_by_property.setdefault(pkey, [])
+                        list_index.append(IndexCompilerStructure(index, deep > 1))
+
+        # Populando com as propriedades do trait
+        if entity_model.trait_from:
+            trait_model = entity_models[entity_model.trait_from]
+
+            self._make_unique_map_by_property(
+                map_indexes_by_property,
+                map_unique_by_property,
+                trait_model,
+                entity_models,
+                deep=deep + 1,
+            )
+
+    def list_dependencies(
+        self, edl_json: dict[str, Any]
+    ) -> tuple[list[str], EntityModel]:
+        entity_model = EntityModel(**edl_json)
+
+        return (self._list_dependencies(entity_model), entity_model)
+
+    def _list_dependencies(self, entity_model: EntityModel) -> list[str]:
+        entities: list[str] = []
+        if entity_model.trait_from:
+            entities.append(entity_model.trait_from)
+
+        return entities
+
+
+def get_files_from_directory(directory):
+    files = []
+    for file in os.listdir(directory):
+        if file.endswith(".json"):
+            files.append(os.path.join(directory, file))
+    return files
+
+
+if __name__ == "__main__":
+    import argparse
+    import json
+    import os
+
+    parser = argparse.ArgumentParser(
+        description="Compila arquivos EDL para classes Python"
+    )
+    parser.add_argument(
+        "-d",
+        "--directory",
+        help="Diretório com arquivos .json para compilar",
+        type=str,
+        required=True,
+    )
+    args = parser.parse_args()
+
+    files = get_files_from_directory(args.directory)
+
+    entities = {}
+    for file in files:
+        with open(file) as f:
+            edl_json = json.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)
+
+        complete_entity_id = f"{entity_model.escopo}/{entity_model.id}"
+        entities[complete_entity_id] = entity_model
+
+    compiler = EDLCompiler()
+    compiler_results = compiler.compile_models(entities)
+
+    for compiler_result in compiler_results:
+        print("==========================================================")
+        print(f"Entity: {compiler_result.entity_class_name}")
+        print(f"{compiler_result.entity_code}")
+        print("\n")
+        print("==========================================================")
+        print(f"DTO: {compiler_result.dto_class_name}")
+        print(f"{compiler_result.dto_code}")
+        print("\n")

nsj_rest_lib2/compiler/compiler_structures.py

@@ -0,0 +1,24 @@
+from nsj_rest_lib2.compiler.edl_model.column_meta_model import ColumnMetaModel
+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 (
+    TraitPropertyMetaModel,
+)
+
+
+class IndexCompilerStructure:
+    def __init__(self, index_model: IndexModel, inherited: bool) -> None:
+        self.index_model: IndexModel = index_model
+        self.inherited: bool = inherited
+
+
+class PropertiesCompilerStructure:
+    def __init__(self) -> None:
+        self.properties: dict[str, PropertyMetaModel] = {}
+        self.main_properties: list[str] = []
+        self.required: list[str] = []
+        self.partition_data: list[str] = []
+        self.search_properties: list[str] = []
+        self.metric_label: list[str] = []
+        self.entity_properties: dict[str, ColumnMetaModel] = {}
+        self.trait_properties: dict[str, TraitPropertyMetaModel] = {}

nsj_rest_lib2/compiler/dto_compiler.py

@@ -0,0 +1,83 @@
+import ast
+
+import black
+
+from nsj_rest_lib2.compiler.edl_model.entity_model import EntityModel
+from nsj_rest_lib2.compiler.util.str_util import CompilerStrUtil
+
+
+class DTOCompiler:
+    def __init__(self):
+        pass
+
+    def compile(
+        self,
+        entity_model: EntityModel,
+        ast_dto_attributes: list[ast.stmt],
+        enum_classes: list[ast.stmt],
+    ) -> tuple[str, str]:
+        """
+        Compila o código do DTO a partir do AST e retorna o código compilado.
+
+        :param entity_model: Modelo de entidade
+        :type entity_model: EntityModel
+
+        :param ast_dto_attributes: Atributos do DTO
+        :type ast_dto_attributes: list[ast.stmt]
+
+        :param enum_classes: Classes de enumeração
+        :type enum_classes: list[ast.stmt]
+
+        :return: Código compilado do DTO
+        :rtype: str
+        """
+        imports = [
+            # import datetime
+            ast.Import(names=[ast.alias(name="datetime", asname=None)]),
+            # import enum
+            ast.Import(names=[ast.alias(name="enum", asname=None)]),
+            # import uuid
+            ast.Import(names=[ast.alias(name="uuid", asname=None)]),
+            # from nsj_rest_lib.decorator.dto import DTO
+            ast.ImportFrom(
+                module="nsj_rest_lib.decorator.dto",
+                names=[ast.alias(name="DTO", asname=None)],
+                level=0,
+            ),
+            # from nsj_rest_lib.descriptor.dto_field import DTOField
+            ast.ImportFrom(
+                module="nsj_rest_lib.descriptor.dto_field",
+                names=[ast.alias(name="DTOField", asname=None)],
+                level=0,
+            ),
+        ]
+
+        class_name = f"{CompilerStrUtil.to_pascal_case(entity_model.id)}DTO"
+        ast_class = ast.ClassDef(
+            name=class_name,
+            bases=[ast.Name(id="DTOBase", ctx=ast.Load())],
+            keywords=[],
+            decorator_list=[
+                ast.Call(
+                    func=ast.Name(id="DTO", ctx=ast.Load()),
+                    args=[],
+                    keywords=[],
+                )
+            ],
+            body=ast_dto_attributes,
+        )
+
+        # Definindo o módulo
+        module = ast.Module(
+            body=imports + enum_classes + [ast_class],
+            type_ignores=[],
+        )
+        module = ast.fix_missing_locations(module)
+
+        # Compilando o AST do DTO para o código Python
+        code = ast.unparse(module)
+
+        # Chamando o black para formatar o código Python do DTO
+        code = black.format_str(code, mode=black.FileMode())
+
+        return (class_name, code)