Forms

Forms are a great way to organise and validate the input from the user. Forms are simple classes inside the Forms directory that extend the Form class and uses the @Field decorator:

import { Field, Form } from '@Typetron/Forms';

export class LoginForm extends Form {

    @Field()
    email: string;

    @Field()
    password: string;
}

You can use the newly created form in your controller methods that have data to process from the user. like a login form:

import { Controller, Get, Post } from '@Typetron/Router';
import { LoginForm } from 'App/Forms/LoginForm';

@Controller()
export class AuthController {

    @Post('login')
    login(loginForm: LoginForm) {
        return ['A nice object with the data for the login form', loginForm];
    }
}

Of course, for security reasons, you might want to validate the input of your forms. You can do this by using the @Rules decorator where you can add a list of rules that will check the form’s fields:

import { Field, Form, Rules } from '@Typetron/Forms';
import { Required, MinLength } from '@Typetron/Validation/Rules';

export class LoginForm extends Form {

    @Field()
    @Rules(
        Required,
    )
    email: string;

    @Field()
    @Rules(
        Required,
        MinLength(6),
    )
    password: string;
}

In the form above we’ve set the email and the password field to be required in the form with the password having at least 6 characters in length. If the form is not valid, Typetron will throw a HTTP error with the code 422 UNPROCESSABLE_ENTITY.

Custom validation

To create a custom validation rule, all you have to do is to extend the base Rule class from the Validation directory like in the example below:

import { Rule, RuleValue } from '@Typetron/Validation';

export class IsNumber extends Rule {
    identifier = 'isNumber';

    passes(attribute: string, value: RuleValue): boolean {
        return !isNaN(Number(value));
    }

    message(attribute: string): string {
        return `The ${attribute} is not a number`;
    }
}

To create a validation rule that accepts parameters, you will have to wrap the class in a function like so:

import { Rule, RuleInterface, RuleValue } from '@Typetron/Validation';
import { Type } from '@Typetron/Support';

export function InArray(values: string[]): Type<RuleInterface> {
    return class extends Rule {
        identifier = 'inArray';

        passes(attribute: string, value: RuleValue): boolean {
            return values.includes(value as string);
        }

        message(attribute: string): string {
            return `The ${attribute} must have a value from the following list ${values.join(', ')}`;
        }
    };
}