tea

thé

Fork de vweb avec modélisation et validation des données.
Ceci est une preuve de concept.

Installation

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

Usage

Probablement toute l'utilisation normale de Vweb s'applique.
Il s'agit simplement d'un mince wrapper au-dessus de Vweb qui en expose suffisamment pour permettre de modifier les signatures de route.

Il y a beaucoup d'exemples dans example.v
Un exemple simple et complet est le suivant :

Créons une route /login qui prend en compte un modèle utilisateur.
Importez d’abord du thé et déclarez votre variable d’application comme telle :

 import tea

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

Définissez votre modèle user :

 struct User {
        username string
        password string
}

Définissez une fonction pour vérifier que le modèle user est valide :

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

Définissez votre itinéraire /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 "}')
}

Définissez votre fonction principale :

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

Maintenant, dans cette fonction principale, vous pouvez créer votre validateur de données user .
(Vous pouvez également définir cela comme une fonction nommée)

 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 )
 }

Le validateur de données doit décompresser une sorte de données (dans ce cas, le corps json de la requête), les valider et, en fonction du résultat, renvoyer une erreur de validation ou transmettre le(s) modèle(s) validé(s) à l'itinéraire.
L'application doit désormais connaître le validateur et la route sur laquelle l'exécuter. Ainsi, après avoir déclaré le validateur, vous devez l'ajouter à app.validators :

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

Ensuite, lancez simplement l'application comme vous le feriez avec Vweb :

 tea . run ( & app , 8080 )

Problèmes connus

• Plus d'un paramètre d'URL n'est pas pris en charge dans Vweb

Autres remarques

• Si vous combinez des paramètres d'URL tels que /user/:user_id avec d'autres paramètres, le paramètre d'url user_id doit être après les autres paramètres. c'est à dire

 // 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) prend une chaîne json en entrée et la décode en une structure
• app.url_params expose les paramètres du chemin d'URL, le cas échéant, sous forme de map[string]string
  • Par conséquent, vous pouvez avoir des routes validées qui ne prennent pas le paramètre url, c'est-à-dire :user_id comme paramètre mais qui y accèdent quand même.
• tea.from_map<T>(map[string]string) peut être utilisé pour prendre app.query et le transformer en une structure avec des champs de chaîne uniquement

Objectif final

Chaque fois que la réflexion au moment de la compilation est plus complète dans V, quelque chose comme ceci devrait être possible, ce qui masquerait la plupart des éléments internes :

 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 )
}