nsj-rest-lib2 0.0.35__tar.gz → 0.0.37__tar.gz

nsj_rest_lib2-0.0.37/PKG-INFO

@@ -0,0 +1,203 @@
+Metadata-Version: 2.4
+Name: nsj_rest_lib2
+Version: 0.0.37
+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
+Author-email: contact.dev@nasajon.com.br
+Project-URL: Source, https://github.com/Nasajon/nsj_rest_lib2
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.4
+Description-Content-Type: text/markdown
+Requires-Dist: nsj-rest-lib<7.0.0,>=5.1.3
+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
+
+# RestLib2
+
+O RestLib2 é uma plataforma que tem por objetivo o fornecimento de APIs para os clientes, a partir da descrição da entidades envolvidas, e sem a necessidade de programação imperativa tradicional.
+
+Em resumo, a partir da declaração em JSON das entidades que compõe um negócio, bem como dos relacionamentos entre estas, as APIs já estarão disponíveis em produção.
+
+O objetivo final é permitir que o desenvolvimento de APIs se torne rápido e simples, acessível àqueles que tratam diretamente com o negócio (incluindo implantadores, e, no limite, o próprio cliente).
+
+## Links
+
+[Guia do EDL](docs/README.md)
+[ESPECIFICAÇÃO DO MODELO DE ENTIDADES](docs/especificacao.md)
+
+## Rota das APIs geradas
+
+A rota para acesso a uma API gerada por variar de acordo com o modo de configuração escolhido pela aplicação que usar o RestLib2. Mas, via de regra, sugere-se o padrão aplicado na API de DadosMestre:
+
+```http
+#############################
+# List Prod
+#############################
+GET https://api.nasajon.app/dados-mestre/edl1/clientes?tenant=47&grupo_empresarial=NASAJON HTTP/1.1
+Authorization: Bearer *****
+Accept: application/json
+```
+
+* Note que, na API de Dados Mestre, todas as APIs do RestLib2 ficarão debaixo da rota: ```https://api.nasajon.app/dados-mestre/edl1/```
+* O endpoint em si, varia a cada JSON, e fica configurado no nó ```api.resource``` do JSON de EDL em questão.
+
+## Fluxo básico de uso
+
+Há dois modos básicos de publicar novas APIs a partir de um JSON gerado, para uma aplicação previamente configurada para uso da plataforma:
+
+### Fluxo por meio de código versionado
+1. Criar o JSON de descrição da entidade desejada, gravando-o no diretório "@schemas/entities" da aplicação em questão (tome [como exemplo o "dados-mestre"](https://github.com/Nasajon/dados-mestre-api/tree/production/%40schemas)).
+2. Fazer push das alterações.
+3. Aguardar o build da aplicação (pode ser útil conferir os logs do job de atualização dos JSON, na aplicação em questão, e também os logs do [worker de compilação](https://ci.nasajon.in/applications/restlib2?view=pods&conditions=false), no Argo).
+4. Testar as APIs compiladas.
+   
+### Fluxo de deploy direto pela API
+1. Criar o JSON de descrição da entidade desejada.
+2. Registrá-lo diretamente, por meio da API de controle do RestLib2. segue exemplo de chamada abaixo:
+
+```http
+###############################
+# Post dinâmico
+###############################
+POST https://api.nasajon.app/restlib2/entities HTTP/1.1
+Authorization: Bearer ******
+Content-Type: application/json
+
+{
+  "id": "{UUID}",
+  "escopo": "{escopo}",
+  "tenant": 0,
+  "grupo_empresarial": "00000000-0000-0000-0000-000000000000",
+  "codigo": "{codigo da entidade}",
+  "descricao": "{descrição da entidade}",
+  "json_schema": {
+    "edl_version": "1.0",
+    "escopo": "{escopo}",
+    "description": "{descrição da entidade}",
+    "id": "cliente",
+    "version": "0.0.1",
+    ...
+  }
+}
+```
+
+Observações:
+* Note que, acima há placeholders a alterar.
+* Note também que o JSON não está completo, e, o correto é deguir a documentação do EDL.
+* Os valores tenant=0 e grupo_empresarial=00000000-0000-0000-0000-000000000000, indicam que a entidade é padrão, e serve para todos os tenants e grupos.
+
+3. Essa rota irá retornar algo semelhante a:
+
+```http
+HTTP/1.1 202 ACCEPTED
+Location: https://api.nasajon.app/restlib2/entity-compilations/status/{UUID do processo de compilação}
+```
+
+E, se você fizer uma chamada à rota retornada, poderá acompanhar o status da compilação, incluindo eventuais erros que venham a ocorrer.
+
+4. Testar a API compilada.
+
+## Como rodar a compilação de EDLs localmente?
+
+Você pode testar a compilação de seus EDLs localmente, incluindo a execução de diversas validações sobre os mesmos, desde que todos estejam dispostos num mesmo diertório.
+
+Para isso, considere os passos a seguir:
+
+1. Crie um diretório, e coloque todos os seus EDLs lá (garantindo que EDLs relacionados estejam no mesmo).
+2. Instale, no seu ambiente pyhton de teste, a biblioteca `nsj-rest-lib2`:
+   
+```sh
+pip install nsj-rest-lib2
+```
+
+3. Rode o comando abaixo (adaptado para seu diretório):
+```sh
+python3 -m nsj_rest_lib2.compiler.compiler -d $(shell pwd)/{diretorio_com_os_edls_json}
+```
+
+O resultado da compilação será impresso no console (erros, ou código total gerado).
+
+## Como configurar uma aplicação para expôr rotas de acordo com o padrão do RestLib2?
+
+Para que uma aplicação exponha as rotas no padrão do RestLib2, não são necessários muitos passos. Antes basta:
+
+1. Instalar, em sua aplicação, a dependência para o projeto nsj-rest-lib2
+
+```sh
+pip install nsj-rest-lib2
+```
+
+Não esqueça de fixar a versão usada (como sendo a última), no arquivo requirements.txt.
+
+2. Adicione a variável de ambiente abaixo em sua aplciação
+
+```env
+ESCOPO_RESTLIB2: "{COLOQUE O IDENTIFICADOR DE ESCOPO QUE DESEJAR PARA SUA APLICAÇÃO (UMA SIMPLES STRING SEM ESPAÇO)}"
+```
+
+* Esse identificador de escopo deve se único para sua aplicação.
+* É importante nota que sua aplicação só irá expôr JSONs de EDL configurados para o mesmo escopo definido aqui.
+
+3. Instale, como dependência a biblioteca, nsj-rest-lib2:
+
+```sh
+pip install nsj-rest-lib2
+```
+
+Não esqueça de fixar a versão usada (como sendo a última), no arquivo requirements.txt.
+
+4. Adicione a linha abaixo no arquivo wsgi.py (de inicilização de sua aplicação):
+
+```python
+from nsj_rest_lib2.controller.dynamic_controller import setup_dynamic_routes
+from nasajon.injector_factory_multibanco import InjectorFactoryMultibanco
+
+setup_dynamic_routes(application, injector_factory=InjectorFactoryMultibanco)
+```
+
+* No exemplo acima, a rota é multibanco, mas, não é obrigatório.
+* Os parâmetros de setup são:
+  * flask_app: Variável obrigatório, que aponte para sua aplicação Flask.
+  * multidb: Flag (padrão True)
+  * dynamic_root_path: URL padrão base de todos os endpoints do RestLib2 (padrão: "edl1")
+  * injector_factory: Classe de injeção de depndência usada (normalmente necessária para aplicações multibanco; o principal uso é justamente manipular a criação da conexão com o BD).
+
+## Carregando EDLs direto do disco
+
+Também é possível carregar EDLs diretamente do disco, sem depender exclusivamente do Redis. Para isso, use o parâmetro opcional `edls_path` em `setup_dynamic_routes`, apontando para um caminho relativo ao workdir da aplicação (ou absoluto), contendo arquivos `.json`, `.yml` ou `.yaml` com os EDLs.
+
+Exemplo:
+
+```python
+from nsj_rest_lib2.controller.dynamic_controller import setup_dynamic_routes
+
+setup_dynamic_routes(
+    application,
+    injector_factory=InjectorFactoryMultibanco,
+    edls_path="@schemas/entities",
+)
+```
+
+Observações:
+* Os EDLs são carregados e compilados uma vez, ficando em cache em memória. Chamadas seguintes reutilizam o cache.
+* A resolução das entidades ocorre primeiro pelo cache local; se não encontrar, o Redis é consultado (quando habilitado).
+
+Para desabilitar o Redis e usar somente EDLs do disco, defina a variável de ambiente abaixo:
+
+```env
+EDLS_FROM_REDIS=false
+```
+
+O valor padrão de `EDLS_FROM_REDIS` é `true`.
+
+
+**Pronto, isso deve bastar para expôr os EDLs configurados para o mesmo escopo da aplicação.**
+
+**OBSERVAÇÃO GERAL: Isso só funciona para aplicações Flask.**

nsj_rest_lib2-0.0.37/README.md

@@ -0,0 +1,182 @@
+# RestLib2
+
+O RestLib2 é uma plataforma que tem por objetivo o fornecimento de APIs para os clientes, a partir da descrição da entidades envolvidas, e sem a necessidade de programação imperativa tradicional.
+
+Em resumo, a partir da declaração em JSON das entidades que compõe um negócio, bem como dos relacionamentos entre estas, as APIs já estarão disponíveis em produção.
+
+O objetivo final é permitir que o desenvolvimento de APIs se torne rápido e simples, acessível àqueles que tratam diretamente com o negócio (incluindo implantadores, e, no limite, o próprio cliente).
+
+## Links
+
+[Guia do EDL](docs/README.md)
+[ESPECIFICAÇÃO DO MODELO DE ENTIDADES](docs/especificacao.md)
+
+## Rota das APIs geradas
+
+A rota para acesso a uma API gerada por variar de acordo com o modo de configuração escolhido pela aplicação que usar o RestLib2. Mas, via de regra, sugere-se o padrão aplicado na API de DadosMestre:
+
+```http
+#############################
+# List Prod
+#############################
+GET https://api.nasajon.app/dados-mestre/edl1/clientes?tenant=47&grupo_empresarial=NASAJON HTTP/1.1
+Authorization: Bearer *****
+Accept: application/json
+```
+
+* Note que, na API de Dados Mestre, todas as APIs do RestLib2 ficarão debaixo da rota: ```https://api.nasajon.app/dados-mestre/edl1/```
+* O endpoint em si, varia a cada JSON, e fica configurado no nó ```api.resource``` do JSON de EDL em questão.
+
+## Fluxo básico de uso
+
+Há dois modos básicos de publicar novas APIs a partir de um JSON gerado, para uma aplicação previamente configurada para uso da plataforma:
+
+### Fluxo por meio de código versionado
+1. Criar o JSON de descrição da entidade desejada, gravando-o no diretório "@schemas/entities" da aplicação em questão (tome [como exemplo o "dados-mestre"](https://github.com/Nasajon/dados-mestre-api/tree/production/%40schemas)).
+2. Fazer push das alterações.
+3. Aguardar o build da aplicação (pode ser útil conferir os logs do job de atualização dos JSON, na aplicação em questão, e também os logs do [worker de compilação](https://ci.nasajon.in/applications/restlib2?view=pods&conditions=false), no Argo).
+4. Testar as APIs compiladas.
+   
+### Fluxo de deploy direto pela API
+1. Criar o JSON de descrição da entidade desejada.
+2. Registrá-lo diretamente, por meio da API de controle do RestLib2. segue exemplo de chamada abaixo:
+
+```http
+###############################
+# Post dinâmico
+###############################
+POST https://api.nasajon.app/restlib2/entities HTTP/1.1
+Authorization: Bearer ******
+Content-Type: application/json
+
+{
+  "id": "{UUID}",
+  "escopo": "{escopo}",
+  "tenant": 0,
+  "grupo_empresarial": "00000000-0000-0000-0000-000000000000",
+  "codigo": "{codigo da entidade}",
+  "descricao": "{descrição da entidade}",
+  "json_schema": {
+    "edl_version": "1.0",
+    "escopo": "{escopo}",
+    "description": "{descrição da entidade}",
+    "id": "cliente",
+    "version": "0.0.1",
+    ...
+  }
+}
+```
+
+Observações:
+* Note que, acima há placeholders a alterar.
+* Note também que o JSON não está completo, e, o correto é deguir a documentação do EDL.
+* Os valores tenant=0 e grupo_empresarial=00000000-0000-0000-0000-000000000000, indicam que a entidade é padrão, e serve para todos os tenants e grupos.
+
+3. Essa rota irá retornar algo semelhante a:
+
+```http
+HTTP/1.1 202 ACCEPTED
+Location: https://api.nasajon.app/restlib2/entity-compilations/status/{UUID do processo de compilação}
+```
+
+E, se você fizer uma chamada à rota retornada, poderá acompanhar o status da compilação, incluindo eventuais erros que venham a ocorrer.
+
+4. Testar a API compilada.
+
+## Como rodar a compilação de EDLs localmente?
+
+Você pode testar a compilação de seus EDLs localmente, incluindo a execução de diversas validações sobre os mesmos, desde que todos estejam dispostos num mesmo diertório.
+
+Para isso, considere os passos a seguir:
+
+1. Crie um diretório, e coloque todos os seus EDLs lá (garantindo que EDLs relacionados estejam no mesmo).
+2. Instale, no seu ambiente pyhton de teste, a biblioteca `nsj-rest-lib2`:
+   
+```sh
+pip install nsj-rest-lib2
+```
+
+3. Rode o comando abaixo (adaptado para seu diretório):
+```sh
+python3 -m nsj_rest_lib2.compiler.compiler -d $(shell pwd)/{diretorio_com_os_edls_json}
+```
+
+O resultado da compilação será impresso no console (erros, ou código total gerado).
+
+## Como configurar uma aplicação para expôr rotas de acordo com o padrão do RestLib2?
+
+Para que uma aplicação exponha as rotas no padrão do RestLib2, não são necessários muitos passos. Antes basta:
+
+1. Instalar, em sua aplicação, a dependência para o projeto nsj-rest-lib2
+
+```sh
+pip install nsj-rest-lib2
+```
+
+Não esqueça de fixar a versão usada (como sendo a última), no arquivo requirements.txt.
+
+2. Adicione a variável de ambiente abaixo em sua aplciação
+
+```env
+ESCOPO_RESTLIB2: "{COLOQUE O IDENTIFICADOR DE ESCOPO QUE DESEJAR PARA SUA APLICAÇÃO (UMA SIMPLES STRING SEM ESPAÇO)}"
+```
+
+* Esse identificador de escopo deve se único para sua aplicação.
+* É importante nota que sua aplicação só irá expôr JSONs de EDL configurados para o mesmo escopo definido aqui.
+
+3. Instale, como dependência a biblioteca, nsj-rest-lib2:
+
+```sh
+pip install nsj-rest-lib2
+```
+
+Não esqueça de fixar a versão usada (como sendo a última), no arquivo requirements.txt.
+
+4. Adicione a linha abaixo no arquivo wsgi.py (de inicilização de sua aplicação):
+
+```python
+from nsj_rest_lib2.controller.dynamic_controller import setup_dynamic_routes
+from nasajon.injector_factory_multibanco import InjectorFactoryMultibanco
+
+setup_dynamic_routes(application, injector_factory=InjectorFactoryMultibanco)
+```
+
+* No exemplo acima, a rota é multibanco, mas, não é obrigatório.
+* Os parâmetros de setup são:
+  * flask_app: Variável obrigatório, que aponte para sua aplicação Flask.
+  * multidb: Flag (padrão True)
+  * dynamic_root_path: URL padrão base de todos os endpoints do RestLib2 (padrão: "edl1")
+  * injector_factory: Classe de injeção de depndência usada (normalmente necessária para aplicações multibanco; o principal uso é justamente manipular a criação da conexão com o BD).
+
+## Carregando EDLs direto do disco
+
+Também é possível carregar EDLs diretamente do disco, sem depender exclusivamente do Redis. Para isso, use o parâmetro opcional `edls_path` em `setup_dynamic_routes`, apontando para um caminho relativo ao workdir da aplicação (ou absoluto), contendo arquivos `.json`, `.yml` ou `.yaml` com os EDLs.
+
+Exemplo:
+
+```python
+from nsj_rest_lib2.controller.dynamic_controller import setup_dynamic_routes
+
+setup_dynamic_routes(
+    application,
+    injector_factory=InjectorFactoryMultibanco,
+    edls_path="@schemas/entities",
+)
+```
+
+Observações:
+* Os EDLs são carregados e compilados uma vez, ficando em cache em memória. Chamadas seguintes reutilizam o cache.
+* A resolução das entidades ocorre primeiro pelo cache local; se não encontrar, o Redis é consultado (quando habilitado).
+
+Para desabilitar o Redis e usar somente EDLs do disco, defina a variável de ambiente abaixo:
+
+```env
+EDLS_FROM_REDIS=false
+```
+
+O valor padrão de `EDLS_FROM_REDIS` é `true`.
+
+
+**Pronto, isso deve bastar para expôr os EDLs configurados para o mesmo escopo da aplicação.**
+
+**OBSERVAÇÃO GERAL: Isso só funciona para aplicações Flask.**

{nsj_rest_lib2-0.0.35 → nsj_rest_lib2-0.0.37}/nsj_rest_lib2/compiler/compiler.py

@@ -28,6 +28,7 @@ from nsj_rest_lib2.compiler.util.type_naming_util import (
     compile_entity_class_name,
     compile_namespace_keys,
 )
+from nsj_rest_lib2.compiler.response_dto_compiler import ResponseDTOCompiler
 from nsj_rest_lib2.compiler.util.relation_ref import RelationRefParser
 
 from nsj_rest_lib2.compiler.edl_model.entity_model import EntityModel
@@ -169,9 +170,12 @@ class EDLCompiler:
         get_function_name = None
         list_function_name = None
         delete_function_name = None
+        handlers: dict[str, Any] = {}
+        post_handler = None
+        put_handler = None
+        patch_handler = None
 
         if isinstance(entity_model, EntityModel) and entity_model.api:
-            handlers = {}
             if entity_model.api.handlers:
                 handlers = {
                     (verb or "").lower(): handler
@@ -179,16 +183,20 @@ class EDLCompiler:
                     if handler
                 }
 
+            post_handler = handlers.get("post")
+            put_handler = handlers.get("put")
+            patch_handler = handlers.get("patch")
+
             insert_output = self._function_compiler.compile_insert(
                 entity_model,
                 properties_structure,
-                handlers.get("post"),
+                post_handler,
                 prefx_class_name,
             )
             update_output = self._function_compiler.compile_update(
                 entity_model,
                 properties_structure,
-                handlers.get("put"),
+                put_handler,
                 prefx_class_name,
             )
             get_handler = handlers.get("get")
@@ -354,6 +362,16 @@ class EDLCompiler:
         # Adicionando as dependências das relações
         relations_dependencies_complete.extend(relations_dependencies)
 
+        response_dto_compiler = ResponseDTOCompiler(
+            dto_compiler=self._dto_compiler,
+            entity_model=entity_model,
+            prefx_class_name=prefx_class_name,
+            ast_dto_attributes=ast_dto_attributes,
+            aux_classes=aux_classes,
+            related_imports=related_imports,
+            fixed_filters=fixed_filters,
+        )
+
         # Adicionando as dependências da extensão parcial
         if partial_metadata and partial_base_model:
             relation_dependency = RelationDependency()
@@ -367,6 +385,68 @@ class EDLCompiler:
             relation_dependency.grupo_empresarial = partial_base_model.grupo_empresarial
             relations_dependencies_complete.append(relation_dependency)
 
+        post_expected = "empty"
+        put_expected = "empty"
+        patch_expected = "empty"
+        get_expected = "empty"
+        list_expected = "empty"
+        delete_expected = "empty"
+        post_properties = None
+        put_properties = None
+        patch_properties = None
+        if isinstance(entity_model, EntityModel) and entity_model.api:
+            post_expected, post_properties = (
+                response_dto_compiler.handler_result_details(post_handler)
+            )
+            put_expected, put_properties = (
+                response_dto_compiler.handler_result_details(put_handler)
+            )
+            patch_expected, patch_properties = (
+                response_dto_compiler.handler_result_details(patch_handler)
+            )
+            get_expected, _ = response_dto_compiler.handler_result_details(
+                get_handler
+            )
+            list_expected, _ = response_dto_compiler.handler_result_details(
+                list_handler
+            )
+            delete_expected, _ = response_dto_compiler.handler_result_details(
+                delete_handler
+            )
+
+        if post_expected == "partial_row":
+            post_class_name, post_code = (
+                response_dto_compiler.compile_partial_response_dto(
+                    "post", post_properties or []
+                )
+            )
+            compiler_result_post_class = post_class_name
+            dto_code += "\n\n" + post_code
+        else:
+            compiler_result_post_class = None
+
+        if put_expected == "partial_row":
+            put_class_name, put_code = (
+                response_dto_compiler.compile_partial_response_dto(
+                    "put", put_properties or []
+                )
+            )
+            compiler_result_put_class = put_class_name
+            dto_code += "\n\n" + put_code
+        else:
+            compiler_result_put_class = None
+
+        if patch_expected == "partial_row":
+            patch_class_name, patch_code = (
+                response_dto_compiler.compile_partial_response_dto(
+                    "patch", patch_properties or []
+                )
+            )
+            compiler_result_patch_class = patch_class_name
+            dto_code += "\n\n" + patch_code
+        else:
+            compiler_result_patch_class = None
+
         # Construindo o resultado
         compiler_result = CompilerResult()
         compiler_result.entity_class_name = entity_class_name
@@ -389,6 +469,34 @@ class EDLCompiler:
         compiler_result.source_delete_function_type = (
             delete_function_code.strip() or None
         )
+        compiler_result.retrieve_after_insert = post_expected == "entity_row"
+        compiler_result.retrieve_after_update = put_expected == "entity_row"
+        compiler_result.retrieve_after_partial_update = (
+            patch_expected == "entity_row"
+        )
+        compiler_result.post_response_dto_class_name = compiler_result_post_class
+        compiler_result.put_response_dto_class_name = compiler_result_put_class
+        compiler_result.patch_response_dto_class_name = (
+            compiler_result_patch_class
+        )
+        compiler_result.custom_json_post_response = (
+            post_expected == "custom_json"
+        )
+        compiler_result.custom_json_put_response = (
+            put_expected == "custom_json"
+        )
+        compiler_result.custom_json_patch_response = (
+            patch_expected == "custom_json"
+        )
+        compiler_result.custom_json_get_response = (
+            get_expected == "custom_json"
+        )
+        compiler_result.custom_json_list_response = (
+            list_expected == "custom_json"
+        )
+        compiler_result.custom_json_delete_response = (
+            delete_expected == "custom_json"
+        )
 
         insert_code_compiled = insert_function_code.strip()
         update_code_compiled = update_function_code.strip()

{nsj_rest_lib2-0.0.35 → nsj_rest_lib2-0.0.37}/nsj_rest_lib2/compiler/dto_compiler.py

@@ -1,4 +1,5 @@
 import ast
+from typing import Optional
 
 import black
 
@@ -21,6 +22,7 @@ class DTOCompiler:
         fixed_filters: list[tuple[str, BasicTypes]],
         prefx_class_name: str,
         partial_metadata: dict[str, str] | None,
+        class_name_override: Optional[str] = None,
     ) -> tuple[str, str]:
         """
         Compila o código do DTO a partir do AST e retorna o código compilado.
@@ -158,7 +160,9 @@ class DTOCompiler:
             )
 
         # Criando o ast da classe
-        class_name = compile_dto_class_name(entity_model.id, prefx_class_name)
+        class_name = class_name_override or compile_dto_class_name(
+            entity_model.id, prefx_class_name
+        )
         ast_class = ast.ClassDef(
             name=class_name,
             bases=[ast.Name(id="DTOBase", ctx=ast.Load())],

{nsj_rest_lib2-0.0.35 → nsj_rest_lib2-0.0.37}/nsj_rest_lib2/compiler/edl_model/api_model.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from typing import Dict, List, Literal, Optional
 
-from pydantic import AliasChoices, BaseModel, Field
+from pydantic import AliasChoices, BaseModel, Field, model_validator
 
 APIVerbs = Literal["GET", "POST", "PUT", "DELETE", "PATCH"]
 
@@ -46,10 +46,22 @@ class HandlerCall(BaseModel):
 
 
 class HandlerResult(BaseModel):
-    expected: Literal["empty", "entity_row"] = Field(
+    expected: Literal["empty", "entity_row", "custom_json", "partial_row"] = Field(
         default="empty",
         description="Define o formato esperado do retorno da função.",
     )
+    properties: Optional[List[str]] = Field(
+        default=None,
+        description="Lista de propriedades a serem retornadas quando o resultado esperado for 'partial_row'.",
+    )
+
+    @model_validator(mode="after")
+    def validate_partial_row(self):
+        if self.expected == "partial_row" and not self.properties:
+            raise ValueError(
+                "result.properties é obrigatório quando result.expected for 'partial_row'."
+            )
+        return self
 
 
 class HandlerError(BaseModel):
@@ -68,12 +80,12 @@ class HandlerError(BaseModel):
 
 
 class HandlerConfig(BaseModel):
-    impl: Literal["pg_function"] = Field(
-        ...,
+    impl: Optional[Literal["pg_function"]] = Field(
+        default=None,
         description="Somente funções PostgreSQL (pg_function) são suportadas neste estágio.",
     )
-    function_ref: str = Field(
-        ...,
+    function_ref: Optional[str] = Field(
+        default=None,
         description="Referência qualificada para a função no banco (ex.: schema.fn_nome).",
     )
     call: Optional[HandlerCall] = Field(

{nsj_rest_lib2-0.0.35 → nsj_rest_lib2-0.0.37}/nsj_rest_lib2/compiler/model.py

@@ -59,3 +59,15 @@ class CompilerResult:
         self.source_get_function_type: str | None = None
         self.source_list_function_type: str | None = None
         self.source_delete_function_type: str | None = None
+        self.retrieve_after_insert: bool | None = None
+        self.retrieve_after_update: bool | None = None
+        self.retrieve_after_partial_update: bool | None = None
+        self.post_response_dto_class_name: str | None = None
+        self.put_response_dto_class_name: str | None = None
+        self.patch_response_dto_class_name: str | None = None
+        self.custom_json_post_response: bool | None = None
+        self.custom_json_put_response: bool | None = None
+        self.custom_json_patch_response: bool | None = None
+        self.custom_json_get_response: bool | None = None
+        self.custom_json_list_response: bool | None = None
+        self.custom_json_delete_response: bool | None = None