nsj-rest-lib2 0.0.25__tar.gz → 0.0.27__tar.gz

{nsj_rest_lib2-0.0.25 → nsj_rest_lib2-0.0.27}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nsj_rest_lib2
-Version: 0.0.25
+Version: 0.0.27
 Summary: Biblioteca para permitir a distribuição de rotas dinâmicas numa API, configuradas por meio de EDLs declarativos (em formato JSON).
 Home-page: https://github.com/Nasajon/nsj_rest_lib2
 Author: Nasajon Sistemas

{nsj_rest_lib2-0.0.25 → nsj_rest_lib2-0.0.27}/nsj_rest_lib2/compiler/compiler.py

@@ -8,6 +8,14 @@ from nsj_rest_lib2.compiler.compiler_structures import (
     PropertiesCompilerStructure,
 )
 from nsj_rest_lib2.compiler.dto_compiler import DTOCompiler
+from nsj_rest_lib2.compiler.function_compiler import (
+    FunctionCompiler,
+    inject_function_bindings,
+)
+from nsj_rest_lib2.compiler.function_model import (
+    FunctionBindingConfig,
+    FunctionCompilationOutput,
+)
 from nsj_rest_lib2.compiler.edl_model.entity_model_base import EntityModelBase
 from nsj_rest_lib2.compiler.edl_model.entity_model_root import EntityModelRoot
 from nsj_rest_lib2.compiler.edl_model.primitives import REGEX_EXTERNAL_REF
@@ -31,6 +39,7 @@ class EDLCompiler:
         self._properties_compiler = EDLPropertyCompiler()
         self._dto_compiler = DTOCompiler()
         self._entity_compiler = EntityCompiler()
+        self._function_compiler = FunctionCompiler()
 
     def compile_models(
         self, entity_models: dict[str, EntityModel]
@@ -130,6 +139,45 @@ class EDLCompiler:
             properties_structure, entity_model, entity_models
         )
 
+        function_bindings = FunctionBindingConfig()
+        insert_output = FunctionCompilationOutput()
+        update_output = FunctionCompilationOutput()
+        insert_function_code = ""
+        update_function_code = ""
+
+        if isinstance(entity_model, EntityModel) and entity_model.api:
+            handlers = {}
+            if entity_model.api.handlers:
+                handlers = {
+                    (verb or "").lower(): handler
+                    for verb, handler in entity_model.api.handlers.items()
+                    if handler
+                }
+
+            insert_output = self._function_compiler.compile_insert(
+                entity_model,
+                properties_structure,
+                handlers.get("post"),
+                prefx_class_name,
+            )
+            update_output = self._function_compiler.compile_update(
+                entity_model,
+                properties_structure,
+                handlers.get("put"),
+                prefx_class_name,
+            )
+
+            inject_function_bindings(
+                function_bindings,
+                insert_output,
+                update_output,
+            )
+
+            if insert_output.code:
+                insert_function_code += insert_output.code + "\n\n"
+            if update_output.code:
+                update_function_code += update_output.code + "\n\n"
+
         # Criando a lista de atributos do DTO e da Entity; e recuperando as chaves primarias
         (
             ast_dto_attributes,
@@ -146,6 +194,7 @@ class EDLCompiler:
             entity_model,
             entity_models,
             prefx_class_name,
+            function_bindings=function_bindings,
         )
 
         # Adicionando os imports da extensão parcial
@@ -195,6 +244,14 @@ class EDLCompiler:
                 relations_dependencies_complete.extend(
                     component_compiled.relations_dependencies
                 )
+            if component_compiled.source_insert_function:
+                insert_function_code += (
+                    component_compiled.source_insert_function + "\n\n"
+                )
+            if component_compiled.source_update_function:
+                update_function_code += (
+                    component_compiled.source_update_function + "\n\n"
+                )
 
         # Gerando o código do DTO
         dto_class_name, code_dto = self._dto_compiler.compile(
@@ -243,6 +300,17 @@ class EDLCompiler:
         compiler_result.dto_class_name = dto_class_name
         compiler_result.dto_code = dto_code
         compiler_result.relations_dependencies = relations_dependencies_complete
+        compiler_result.insert_function_class_name = insert_output.class_name
+        compiler_result.update_function_class_name = update_output.class_name
+
+        insert_code_compiled = insert_function_code.strip()
+        update_code_compiled = update_function_code.strip()
+        compiler_result.source_insert_function = (
+            insert_code_compiled if insert_code_compiled else None
+        )
+        compiler_result.source_update_function = (
+            update_code_compiled if update_code_compiled else None
+        )
 
         # Compilando questões das APIs
         if isinstance(entity_model, EntityModel):
@@ -706,6 +774,19 @@ if __name__ == "__main__":
             f.write(f"DTO: {compiler_result.dto_class_name}\n")
             f.write(f"{compiler_result.dto_code}\n")
             f.write("\n")
+            if compiler_result.insert_function_class_name:
+                f.write("==========================================================\n")
+                f.write(
+                    f"Insert Function Type: {compiler_result.insert_function_class_name}\n"
+                )
+                f.write(f"{compiler_result.source_insert_function or ''}\n")
+            if compiler_result.update_function_class_name:
+                f.write("==========================================================\n")
+                f.write(
+                    f"Update Function Type: {compiler_result.update_function_class_name}\n"
+                )
+                f.write(f"{compiler_result.source_update_function or ''}\n")
+            f.write("\n")
             f.write("==========================================================\n")
             f.write(f"API Expose: {compiler_result.api_expose}\n")
             f.write(f"API Route Path: {compiler_result.api_resource}\n")

{nsj_rest_lib2-0.0.25 → nsj_rest_lib2-0.0.27}/nsj_rest_lib2/compiler/dto_compiler.py

@@ -89,7 +89,7 @@ class DTOCompiler:
             ),
             # from nsj_rest_lib.descriptor import DTOAggregator
             ast.ImportFrom(
-                module="nsj_rest_lib.descriptor",
+                module="nsj_rest_lib.descriptor.dto_aggregator",
                 names=[ast.alias(name="DTOAggregator", asname=None)],
                 level=0,
             ),

nsj_rest_lib2-0.0.27/nsj_rest_lib2/compiler/edl_model/api_model.py

@@ -0,0 +1,116 @@
+from __future__ import annotations
+
+from typing import Dict, List, Literal, Optional
+
+from pydantic import AliasChoices, BaseModel, Field
+
+APIVerbs = Literal["GET", "POST", "PUT", "DELETE", "PATCH"]
+
+
+class HandlerMapping(BaseModel):
+    attr: str = Field(..., description="Nome do atributo no tipo composto de destino.")
+    from_: Optional[str] = Field(
+        default=None,
+        validation_alias=AliasChoices("from", "from_"),
+        serialization_alias="from",
+        description="Path de origem no payload (ex.: body.estabelecimento).",
+    )
+    as_: Optional[str] = Field(
+        default=None,
+        validation_alias=AliasChoices("as", "as_"),
+        serialization_alias="as",
+        description="Tipo composto do elemento quando houver arrays (ex.: ns.t_item[]).",
+    )
+    mapping: Optional[List["HandlerMapping"]] = Field(
+        default=None,
+        description="Sub-mapeamento utilizado quando 'from' aponta para coleções.",
+    )
+
+
+class HandlerArgBinding(BaseModel):
+    type_name: str = Field(
+        ...,
+        description="Nome qualificado do tipo composto esperado pela função no banco.",
+    )
+    mapping: List[HandlerMapping] = Field(
+        ...,
+        description="Mapeamento dos campos do payload para os atributos do tipo composto.",
+    )
+
+
+class HandlerCall(BaseModel):
+    arg_binding: HandlerArgBinding = Field(
+        ...,
+        description="Configuração de binding do payload para o tipo composto.",
+    )
+
+
+class HandlerResult(BaseModel):
+    expected: Literal["empty", "entity_row"] = Field(
+        default="empty",
+        description="Define o formato esperado do retorno da função.",
+    )
+
+
+class HandlerError(BaseModel):
+    sqlstate: Optional[str] = Field(
+        default=None,
+        description="Código SQLSTATE tratado explicitamente.",
+    )
+    http_status: Optional[int] = Field(
+        default=None,
+        description="Código HTTP retornado quando o SQLSTATE for encontrado.",
+    )
+    message: Optional[str] = Field(
+        default=None,
+        description="Mensagem alternativa retornada quando o erro for capturado.",
+    )
+
+
+class HandlerConfig(BaseModel):
+    impl: Literal["pg_function"] = Field(
+        ...,
+        description="Somente funções PostgreSQL (pg_function) são suportadas neste estágio.",
+    )
+    function_ref: str = Field(
+        ...,
+        description="Referência qualificada para a função no banco (ex.: schema.fn_nome).",
+    )
+    call: Optional[HandlerCall] = Field(
+        default=None,
+        description="Configuração de chamada (binding de argumentos).",
+    )
+    result: HandlerResult = Field(
+        default_factory=HandlerResult,
+        description="Especificação do que se espera da função.",
+    )
+    errors: Optional[List[HandlerError]] = Field(
+        default=None,
+        description="Tratamento específico para SQLSTATE conhecidos.",
+    )
+
+
+class APIModel(BaseModel):
+    resource: str = Field(
+        ...,
+        description="Nome do recurso REST (rota base dos endpoints; exemplo: 'clientes').",
+    )
+    expose: Optional[bool] = Field(
+        default=True,
+        description="Indica se a API deve ser exposta (padrão: True).",
+    )
+    verbs: Optional[List[APIVerbs]] = Field(
+        default=["GET", "POST", "PUT", "DELETE", "PATCH"],
+        description="Lista de verbos HTTP suportados pela API (padrão: todos).",
+    )
+    default_sort: Optional[List[str]] = Field(
+        None,
+        description="Lista de campos usados na ordenação padrão (padrão: se nada for fornecido, será usada, ao menos, a PK).",
+    )
+    handlers: Optional[Dict[str, HandlerConfig]] = Field(
+        default=None,
+        description="Mapeamento opcional de verbos para handlers implementados via funções pg_function.",
+    )
+
+
+APIModel.model_rebuild()