tea

té

Fork de vweb con modelado y validación de datos.
Esta es una prueba de concepto.

Instalación

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

Uso

Probablemente se aplique todo el uso normal de Vweb.
Esto es solo una envoltura delgada encima de Vweb que expone lo suficiente como para permitir cambiar las firmas de ruta.

Hay muchos ejemplos en example.v
Un ejemplo completo simple es el siguiente:

Creemos una ruta /login que incluya un modelo de usuario.
Primero importe té y declare la variable de su aplicación como tal:

 import tea

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

Defina su modelo user :

 struct User {
        username string
        password string
}

Defina una función para verificar que el modelo user sea 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 su ruta /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 su función principal:

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

Ahora en esa función principal puedes crear tu validador de datos user .
(También podrías definir esto como una función con nombre)

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

El validador de datos debe descomprimir algún tipo de datos (en este caso, el cuerpo json de la solicitud), validarlos y, según el resultado, devolver un error de validación o pasar los modelos validados a la ruta.
Ahora la aplicación debe conocer el validador y en qué ruta ejecutarlo. Entonces, después de declarar el validador, debes agregarlo a app.validators :

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

Luego simplemente ejecuta la aplicación como lo harías con Vweb:

 tea . run ( & app , 8080 )

Problemas conocidos

• Más de un parámetro de URL no es compatible con Vweb

Otras notas

• Si combina parámetros de URL como /user/:user_id con otros parámetros, el parámetro de URL user_id debe estar después de los otros parámetros. es decir

 // 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) toma una cadena json como entrada y la decodifica en una estructura
• app.url_params expone los parámetros de la ruta de la URL cuando corresponde como una map[string]string
  • Por lo tanto, puede tener rutas validadas que no tomen el parámetro de URL, es decir :user_id como parámetro, pero aún así accedan a él.
• tea.from_map<T>(map[string]string) se puede usar para tomar app.query y convertirlo en una estructura con campos solo de cadena

Objetivo final

Siempre que la reflexión en tiempo de compilación sea más completa en V, algo como esto debería ser posible, lo que ocultaría la mayoría de los aspectos 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 )
}