Here are the module settings you can place in your ColdBox.cfc by using the validation settings structure:

validation = {
    // The third-party validation manager to use, by default it uses CBValidation.
    manager = "class path",
    // You can store global constraint rules here with unique names
    sharedConstraints = {
        name = {
            field = { constraints here }
        }
    }

}

You can define constraints in several locations:

1. Configuration file

2. Inside domain object

3. A-la-carte

When validating using validate(), validateOrFail() you have to specify a target, but specifying a constraint in your call is optional.

Constraints Discovery

When you call the validation methods with NO constraints passed explicitly, then the validation module will following this lookup procedure:

• Lookup your constraints in myTarget.constraints struct in your target object or struct.

• If you specify your constraint parameter as a string, the validator will lookup a shared constraint in your configuration file.

• If you specify your constraint parameter as a struct, this struct will directly server as your set of constraints, so you can specify your constraints on the fly, or specify an alternative set of constraints in your model, e.g User.constraints vs User.signInConstraints

You can optionally register shared constraints in your ColdBox configuration file under the validation directive. This means you register them with a unique name of your choice and its value is a collection of constraints for properties in your objects or forms.

Later on you will reference the key name in your handlers or wherever in order to validate the object or form. Here is an example:

Declaration

validation = {
    sharedConstraints = {
        sharedUser = {
            fName = {required=true},
            lname = {required=true},
            age   = {required=true, max=18 }
            metadata = {required=false, type="json"}
        },
        loginForm = {
            username = {required=true}, password = {required=true}
        },
        changePasswordForm = {
            password = {required=true,min=6}, password2 = {required=true, sameAs="password", min=6}
        }
    }
}

As you can see, our constraints definition describes the set of rules for a property on ANY target object or form.

Usage

You can then use the keys for those constraints in the validation calls:

validate( target, "sharedUser" );

validate( rc, "loginForm" );

validate( rc, "changePasswordForm" );

Instructions

Just drop into your modules folder or use CommandBox to install

box install cbvalidation

The module will register several objects into WireBox using the @cbvalidation namespace. The validation manager is registered as ValidationManager@cbvalidation. It will also register several helper methods that can be used throughout the ColdBox application.

Mixins - Helper Methods

The module will also register two methods in your handlers/interceptors/layouts/views

• validate()

• validateOrFail()

• getValidationManager()

/**
* Validate an object or structure according to the constraints rules.
* @target An object or structure to validate
* @fields The fields to validate on the target. By default, it validates on all fields
* @constraints A structure of constraint rules or the name of the shared constraint rules to use for validation
* @locale The i18n locale to use for validation messages
* @excludeFields The fields to exclude in the validation
* 
* @return cbvalidation.model.result.IValidationResult
*/
function validate()

/**
 * Validate an object or structure according to the constraints rules and throw an exception if the validation fails.
 * The validation errors will be contained in the `extendedInfo` of the exception in JSON format
 *
 * @target An object or structure to validate
 * @fields The fields to validate on the target. By default, it validates on all fields
 * @constraints A structure of constraint rules or the name of the shared constraint rules to use for validation
 * @locale The i18n locale to use for validation messages
 * @excludeFields The fields to exclude from the validation
 * @includeFields The fields to include in the validation
 *
 * @return The validated object or the structure fields that where validated
 * @throws ValidationException
 */
function validateOrFail(){
	return getValidationManager().validateOrFail( argumentCollection=arguments );
}

/**
* Retrieve the application's configured Validation Manager
*/
function getValidationManager()

Within any domain object you can define a public variable called constraints that is a assigned an implicit structure of validation rules for any fields or properties in your object.

Declaration

component persistent="true"{

    // Object properties
    property name="id" fieldtype="id" generator="native" setter="false";
    property name="fname";
    property name="lname";
    property name="email";
    property name="username";
    property name="password";
    property name="age";

    // Validation
    this.constraints = {
        // Constraints go here
    }
}

We can then create the validation rules for the properties it will apply to it:

component persistent="true"{

    ...

    // Validation
    this.constraints = {
        fname = { required = true },
        lname = { required = true},
        username = {required=true, size="6..10"},
        password = {required=true, size="6..8"},
        email = {required=true, type="email"},
        age = {required=true, type="numeric", min=18}
    };
}

That easy! You can just declare these validation rules and ColdBox will validate your properties according to the rules. In this case you can see that a password must be between 6 and 10 characters long, and it cannot be blank.

Usage

You can then use them implicitly

validate( myUser );

You can also define your constraints on the fly right where you are doing your validation.

In this sample we validate the public request context rc. This sample validates all fields in the rc. If you need more control you can specify the fields parameter (default all) or the includeFields and excludeFields parameters in your validate() call.

// sample REST API create user
function create( event, rc, prc ){
	var validationResult = validate( 
		target = rc,
		constraints = { 
			username = { required = true },
			email = { required = true, type = "email" },
			password = { required = true }
		}
	)
	if ( !validationResult.hasErrors() ) {
		UserService.createUser(rc.username, rc.email, rc.password);
		prc.response.setData( UserService.readUser(username=rc.username) );
	} else {
		prc.response
			.setError( true )
			.addMessage( validationResult.getAllErrors())
			.setStatusCode( STATUS.BAD_REQUEST )
			.setStatusText( "Validation error" );
	}
}

We also setup lots of global {Key} replacements for your messages and also several that the core constraint validators offer as well. This is great for adding these customizations on your custom messages and also your i18n messages (Keep Reading):

Global Replacements

• {rejectedValue} - The rejected value

• {field or property} - The property or field that was validated

• {validationType} - The name of the constraint validator

• {validationData} - The value of the constraint definition, e.g size=5..10, then this value is 5..10

Validator Replacements

• {DiscreteValidator} - operation, operationValue

• {InListValidator} - inList

• {MaxValidator} - max

• {MinValidator} - min

• {RangeValidator} - range, min, max

• {RegexValidator} - regex

• {SameAsValidator}, {SameAsNoCaseValidator} - sameas

• {SizeValidator} - size, min, max

• {TypeValidator} - type

This module is a server side rules validation engine that can provide you with a unified approach to object, struct and form validation. You can construct validation constraint rules and then tell the engine to validate them accordingly.

System Requirements

• Lucee 5+

• ColdFusion 2016+

Introduction

ColdBox validation is based on a way to declaratively specify validation rules for properties or fields in an object or form. The constraints can exist inside of the target object or you can define object and form constraints in your ColdBox configuration file so you can reuse validation constraints or as we call them: shared constraints.

You can then use 2 simple validation methods and report on the results: validate(), validateOrFail()

Professional Open Source

The ColdBox ORM Module is a professional open source software backed by Ortus Solutions, Corp offering services like:

• Custom Development

• Professional Support & Mentoring

• Training

• Server Tuning

• Security Hardening

• Code Reviews

• Much More

HONOR GOES TO GOD ABOVE ALL

Because of His grace, this project exists. If you don't like this, then don't read it, it's not for you.

"Therefore being justified by faith, we have peace with God through our Lord Jesus Christ: By whom also we have access by faith into this grace wherein we stand, and rejoice in hope of the glory of God." Romans 5:5

By default if a constraint fails an error message will be set in the result objects for you in English. If you would like to have your own custom messages for specific constraints you can do so by following the constraint message convention:

Just add the name of the constraint you like and append to it the work Message and you are ready to roll:

Usage

The unique constraint is part of the module. So make sure that the cborm module is installed first.

Declaring the Constraint

The constraints is mapped into WireBox as UniqueValidator@cborm so you can use in your constraints like so:

Case Sensitivity

If you will be using the unique constraint, then the name of the property has to be EXACTLY the same case as the constraint name. To do this, use single or double quotes to declare the constraint name. Please see example below.

In cbValidation 1.5 we introduced the validateOrFail() function. This function works in similar manner to the validate() method, but instead of giving you the results object, it throws an exception.

Exception Extended Info

So your validation fails, where are the results? In the exception structure under the extendedInfo key. We store the validation results as JSON in the extended info and then you can use them for display purposes:

Below are all the currently supported constraints. If you need more you can create your own .

Reference

Custom Validator

With the validator constraint you can specify your own custom validator, but if you need your own parameters for your validator this is a bit limited. You can also specify YourOwnValidator as constraint label where YourOwnValidator is a wirebox id string. In this case you can specify your own parameters.

Most likely you will be validating your objects at the controller layer in your ColdBox event handlers. All event handlers,layouts, views and interceptors have some new methods thanks to our module mixins.

You pass in your target object or structure, an optional list of fields or properties to validate only (by default it does all of them), an an optional constraints argument which can be the shared name or an actual constraints structure a-la-carte. If no constraints are passed, then we will look for the constraints in the target object as a public property called constraints. The validate() method returns a cbvalidation.models.results.IValidationResult type object, which you can then use for evaluating the validation.

The return of validate model is our results interface which has cool methods like:

Some of these methods return error objects which adhere to our Error Interface: cbvalidation.models.result.IValidationError, which can quickly tell you what field had the exception, what was the rejected value and the validation message:

The module will register several objects into WireBox using the @cbvalidation namespace. The validation manager is registered as ValidationManager@cbvalidation, which is the one you can inject and use anywhere you like.

// get reference
property name="validationManager" inject="ValidationManager@cbvalidation";

We also have the ability to validate a target object or form with shared constraints from our configuration file. Just use the name of the key in the configuration form as the name of the constraints argument.

    // validate user object
    prc.results = validateModel( target=user, constraints="sharedUser" );

    // validate incoming form elements in the RC or request collection
    prc.results = validateModel( target=rc, constraints="sharedUser" );

This will validate the object and rc using the sharedUser constraints.

We also have the ability to validate a target object with custom a-la-carte constraints by passing the constraints inline as an struct of structs. This way you can store these constraint rules anywhere you like.

myConstraints = {
	login = { required=true, size=6..10 }, 
	password = { required=true, size=6..10 }
};
prc.results = validateModel( target=user, constraints=myConstraints );

This will validate the object using the inline constraints that you built.

After validation you can use the same results object and use it to display the validation errors in your client side:

Handlers:

// store the validation results in the request collection
prc.validationResults = validate( obj );

Views:

<-- Display all errors as a message box --->
#getInstance( "MessageBox@cbMessagebox" )
    .renderMessage( type="error", messageArray=prc.validationResults.getAllErrors() )#

If you want more control you can use the hasErrors() and iterate over the errors to display:

<cfif prc.validationResults.hasErrors()>
    <ul>
    <cfloop array="#prc.validationResults.getErrors()#" index="thisError">
        <li>#thisError.getMessage()#</li>
    </cfloop>
    </ul>
</cfif>

You can even use the results object in your views to get specific field errors, messagesbox, etc.

Common Methods

The following are some common methods from the validation result object for dealing with errors:

• getResultMetadata()

• getFieldErrors( [field] )

• getAllErrors( [field] )

• getAllErrorsAsJSON( [field] )

• getAllErrorsAsStruct( [field] )

• getErrorCount( [field] )

• hasErrors( [field] )

• getErrors()

The API Docs in the module (once installed) will give you the latest information about these methods and arguments.

Internationalization

If you are using i18n (Internationalization and Localization) in your ColdBox applications you can also localize your validation error messages from the ColdBox validators.

You will do this by our lovely conventions for you resource bundle keys:

Objects:

{ObjectName}.{Field}.{ConstraintType}}=Message

Forms with Shared Constraints Name

{SharedConstraintName}.{Field}.{ConstraintType}=Message

Forms with No Shared Constraints

GenericForm.{Field}.{ConstraintType}=Message

Key Replacements

We also setup lots of global {Key} replacements for your messages and also several that the core constraint validators offer as well:

Global Replacements

• {rejectedValue} - The rejected value

• {field} or property - The property or field that was validated

• {validationType} - The name of the constraint validator

• {validationData} - The value of the constraint definition, e.g size=5..10, then this value is 5..10

• {targetName} - The name of the user, shared constraint or form

i18n Validator Replacements

• {DiscreteValidator} - operation, operationValue

• {InListValidator} - inList

• {MaxValidator} - max

• {MinValidator} - min

• {RangeValidator} - range, min, max

• {RegexValidator} - regex

• {SameAsValidator}, {SameAsNoCaseValidator} - SameAs

• {SizeValidator} - size, min, max

• {TypeValidator} - type

Examples

blank=The field {property} must contain a value.
email=The field {property} is not a valid email address.
unique=The field {property} is not a unique value.
size=The field {property} was not in the size range of {size}.
inlist=The field {property} was not in the list of possible values.
validator=There was a problem with {property}.
min=The minimum value {min} was not met for the field {property}.
max=The maximum value {max} was exceeded for the field {property}.
range=The range was not met for the field {property}.
matches=The field {property} does not match {regex}.
numeric=The field {property} is not a valid number.

You can use multiple custom validators or pass in arbitrary data to custom validators by specifying the validator name as the key in the rules struct.

//sample custom validator constraints
this.constraints = {
  myField = {
    UniqueInDB = { 
      table= "table_name", 
      column = 'column_name' 
    }    
  }
};

This example will look for a UniqueInDBValidator in WireBox and pass in { table = "table_name", column = "column_name" } to the validate method.

//sample validator
/**
* UniqueInDB validator. This checks and returns fals if value is already present in DB
*/
component singleton implements="cbvalidation.models.validators.IValidator" accessors="true"  {
	/**
	 * Constructor
	 */
	UniqueInDB function init(){
		variables.Name = "UniqueInDBValidator";
		return this;
	}
	
	/**
	* validate
	*/
	boolean function validate(
		required cbvalidation.models.result.IValidationResult validationResult,
		required any target,
		required string field,
		any targetValue,
		any validationData
	){
		//check validationdata
		if ( !IsStruct(validationData ) ) {
			throw(message="The validator data is invalid: #arguments.validationData#, it must be a struct with keys 'table' = 'tableName' and 'column' = 'columnName'");
		}
		//check validationdata
		if ( !structKeyExists(validationData,"table") || !structKeyExists(validationData,"column") ) {
			throw(message="The validator data is invalid: #serializeJSON(validationData)# it must be a struct with keys 'table' = 'tableName' and 'column' = 'columnName'");
		}

		var myParams = { table =validationData.table, column=validationData.column, columnvalue=targetValue };
		var sql = "Select #validationData.column# from #validationData.table# where #validationData.column# = :columnvalue";
		var myQuery = queryExecute(sql, myParams);
		// This sample only validates NEW records, additional code is necessary for EDITING existing records
		if  (myQuery.recordcount == 0) { 
			return true 
		} 
		// error messages definieren
		var args = {
			message="The value #targetValue# is not unique in your database",
			field=arguments.field,
			validationType=getName(),
			validationData=arguments.validationData
		};
		var error = validationResult.newError(argumentCollection=args).setErrorMetadata({table=validationData.table, column=validationData.column});
		validationResult.addError( error );
		return false;
	}

	/**
	* getName
	*/
	string function getName(){
		return variables.Name
	}
}

Using these advanced techniques you can build reusable validators that accept the data they need in the validationData struct. You can also include multiple custom validators just by specifying each of them as a key.

If you don't have any custom data to pass to a validator, just pass an empty struct ({})

You can build also your own validators by implementing our interface cbvalidaton.models.validators.IValidator :

/**
* Will check if an incoming value validates
* @validationResult.hint The result object of the validation
* @target.hint The target object to validate on
* @field.hint The field on the target object to validate on
* @targetValue.hint The target value to validate
*/
boolean function validate(required cbvalidation.models.result.IValidationResult validationResult, required any target, required string field, any targetValue, any validationData);

/**
* Get the name of the validator
*/
string function getName();

The arguments received are:

• validationResults : The validation result object

• field : The field or property in the object that is in validation

• targetValue : The value to test

Here is a sample validator:

/**
********************************************************************************
Copyright Since 2005 ColdBox Framework by Luis Majano and Ortus Solutions, Corp
www.coldbox.org | www.luismajano.com | www.ortussolutions.com
********************************************************************************
The ColdBox validator interface, all inspired by awesome Hyrule Validation Framework by Dan Vega
*/
component accessors="true" implements="cbvalidation.models.validators.IValidator" singleton{

    property name="name";

    MaxValidator function init(){
        name = "Max";    
        return this;
    }

    /**
    * Will check if an incoming value validates
    * @validationResult.hint The result object of the validation
    * @target.hint The target object to validate on
    * @field.hint The field on the target object to validate on
    * @targetValue.hint The target value to validate
    * @validationData.hint The validation data the validator was created with
    */
    boolean function validate(required cbvalidation.models.result.IValidationResult validationResult, required any target, required string field, any targetValue, string validationData){

        // Simple Tests
        if( !isNull(arguments.targetValue) AND arguments.targetValue <= arguments.validationData ){
            return true;
        }

        var args = {message="The '#arguments.field#' value is not less than #arguments.validationData#",field=arguments.field,validationType=getName(),validationData=arguments.validationData};
        var error = validationResult.newError(argumentCollection=args).setErrorMetadata({max=arguments.validationData});
        validationResult.addError( error );
        return false;
    }

    /**
    * Get the name of the validator
    */
    string function getName(){
        return name;
    }

}

If you would like to adapt your own validation engines to work with ANY ColdBox application you can do this by implementing the following interfaces:

• Validation Manager : Implement the cbvalidation.models.IValidationManager. Then use the class path in your configuration file so it uses your validation manager instead of ours.

• Validation Results : Implement the cbvalidation.models.result.IValidationResult, which makes it possible for any ColdBox application to use your validation results.

• Validation Error : Implement the cbvalidation.models.result.IValidationError, which makes it possible for any ColdBox application to use your validation error representations.

You can also tell the validation manager to ONLY validate on certain fields and not all the fields declared in the validation constraints.

This will only validate the login and password fields.