tea

chá

Fork do vweb com modelagem e validação de dados.
Esta é uma prova de conceito.

Instalação

mkdir modules
cd modules
git clone https://github.com/intangere/tea.git

Uso

Provavelmente todo o uso normal do Vweb se aplica.
Este é apenas um invólucro fino sobre o Vweb que expõe o suficiente para permitir a alteração das assinaturas de rota.

Há muitos exemplos em example.v
Um exemplo simples e completo é o seguinte:

Vamos criar uma rota /login que aceita um modelo de usuário.
Primeiro importe o chá e declare a variável do seu aplicativo como tal:

 import tea

struct App {
        tea . Context
pub mut:
        validators tea . Validators < App >
}

Defina seu modelo user :

 struct User {
        username string
        password string
}

Defina uma função para verificar se o modelo user é válido:

 fn ( user User ) is_valid () bool {
        username := user . username . strip_margin ()
        password := user . password . strip_margin ()
        return username . len > 3 &&
                password . len > 8
}

Defina sua rota /login :

['/ login '; post ]
fn ( mut app App ) login ( user User ) tea. Result {
        // posted user parameters will be available in user after being validated
        println ('U sername : ' + user . username + ' Password : ' + user . password )
        app . json ('{" status ":" testing "}')
}

Defina sua função principal:

 fn main () {
        mut app := App {}
        
}

Agora nessa função principal você pode criar seu validador de dados user .
(Você também pode definir isso como uma função nomeada)

 login_validator := fn ( mut app App ) {
        model := tea . decode_model < User > ( app . req . data )
        if ! model . is_valid () {
                app. validation_error ('u sername or password too short ')
                return
        }
        app . login ( model )
 }

O validador de dados deve descompactar algum tipo de dado (neste caso o corpo json da solicitação), validá-lo e, dependendo do resultado, retornar um erro de validação ou passar o(s) modelo(s) validado(s) para a rota.
Agora o aplicativo precisa estar ciente do validador e em qual rota executá-lo. Então depois de declarar o validador você precisa adicioná-lo ao app.validators :

 app . validators . validators ['/ login '] = login_validator

Em seguida, basta executar o aplicativo como faria com o Vweb:

 tea . run ( & app , 8080 )

Problemas conhecidos

• Mais de um parâmetro de URL não é suportado no Vweb

Outras notas

• Se você combinar parâmetros de URL como /user/:user_id com outros parâmetros, o parâmetro de URL user_id deverá estar depois dos outros parâmetros. ou seja

 // this will not compile (with or without a validator defined. However it does require one)
['/ user / : user_id ']
fn ( mut app App ) user ( user_id string , user User ) {
}
// this will compile with or without a validator
['/ user / : user_id ']
fn ( mut app App ) user ( user_id string ) {
}
// this will compile with a validator
['/ user / : user_id ']
fn ( mut app App ) user ( user_id int ) {
}
// this is how it has to be defined and will compile (requires a validator defined for /user/:user_id)
['/ user / : user_id ']
fn ( mut app App ) user ( user User , user_id string ) {
}

• tea.decode_model<T>(string) pega uma string json como entrada e a decodifica em uma estrutura
• app.url_params expõe os parâmetros do caminho da URL quando aplicável como uma map[string]string
  • Portanto, você pode ter rotas validadas que não usam o parâmetro url, ou seja :user_id como parâmetro, mas ainda assim acessam-no
• tea.from_map<T>(map[string]string) pode ser usado para pegar app.query e transformá-lo em uma estrutura com campos apenas de string

Objetivo final

Sempre que a reflexão em tempo de compilação for mais completa em V, algo assim deverá ser possível, o que ocultaria a maioria dos detalhes internos:

 import tea

struct App {
        tea . Context
pub mut:
        validators tea . Validators < App >
}

['/ login '; post ]
fn ( mut app App ) login ( user User ) tea. Result {
        // posted user parameters will be available in user after being validated
        println ('U sername : ' + user . username + ' Password : ' + user . password )
        app . json ('{" status ":" testing "}')
}

['/ login '; validator ]
fn ( mut app App ) login_validator () User {
        model := tea . decode_model < User > ( app . req . data )
        if ! model . is_valid () {
                app. validation_error ('u sername or password too short ')
                return
        }
        return model
}

fn main () {
        mut app := App {}
        tea . run ( & app , 8080 )
}