built_in.go

package firevault

import (
	"fmt"
	"reflect"
	"strconv"
	"strings"
	"time"
	"unicode/utf8"
)

const restrictedTagChars = ".[],|=+()`~!@#$%^&*\\\"/?<>{}"

var (
	restrictedRules = map[string]struct{}{
		"dive":               {},
		"omitempty":          {},
		"omitempty_create":   {},
		"omitempty_update":   {},
		"omitempty_validate": {},
	}

	builtInValidators = map[string]ValidationFunc{
		"required":          validateRequired,
		"required_create":   validateRequired,
		"required_update":   validateRequired,
		"required_validate": validateRequired,
		"email":             validateEmail,
		"max":               validateMax,
		"min":               validateMin,
	}

	builtInTransformators = map[string]TransformationFunc{
		"uppercase":  transformUppercase,
		"lowercase":  transformLowercase,
		"trim_space": transformTrimSpace,
	}
)

// validates if field is of supported type
func isSupported(kind reflect.Kind) bool {
	if kind == reflect.Invalid || kind == reflect.Chan || kind == reflect.Func {
		return false
	}

	return true
}

// validates if field's value is the default static value
func isZero(kind reflect.Kind, value reflect.Value) bool {
	if kind == reflect.Slice || kind == reflect.Map || kind == reflect.Pointer || kind == reflect.Interface {
		return value.IsNil()
	}

	return !value.IsValid() || value.IsZero()
}

// validates if field is zero
func validateRequired(fs FieldScope) (bool, error) {
	return !isZero(fs.Kind(), fs.Value()), nil
}

// validates if field is a valid email address
func validateEmail(fs FieldScope) (bool, error) {
	return emailRegex().MatchString(fs.Value().String()), nil
}

// validates if field's value is less than or equal to param's value
func validateMax(fs FieldScope) (bool, error) {
	return checkBoundary(fs, true)
}

// validates if field's value is greater than or equal to param's value
func validateMin(fs FieldScope) (bool, error) {
	return checkBoundary(fs, false)
}

// performs boundary validation - isMax: true for maximum boundary,
// false for minimum boundary
func checkBoundary(fs FieldScope, isMax bool) (bool, error) {
	param := fs.Param()
	if param == "" {
		boundaryType := "max"
		if !isMax {
			boundaryType = "min"
		}

		return false, fmt.Errorf(
			"firevault: '%s' validation requires a parameter for field '%s'",
			boundaryType,
			fs.Path(),
		)
	}

	kind := fs.Kind()
	val := fs.Value()

	// check string length (characters)
	if kind == reflect.String {
		threshold, err := strconv.ParseInt(param, 0, 64)
		if err != nil {
			return false, fmt.Errorf(
				"firevault: failed to parse '%s' parameter for field '%s': %w",
				param,
				fs.Path(),
				err,
			)
		}

		length := int64(utf8.RuneCountInString(val.String()))

		if isMax {
			return length <= threshold, nil
		}

		return length >= threshold, nil
	}

	// check length types
	if kind == reflect.Slice || kind == reflect.Array || kind == reflect.Map {
		threshold, err := strconv.ParseInt(param, 0, 64)
		if err != nil {
			return false, fmt.Errorf(
				"firevault: failed to parse '%s' parameter for field '%s': %w",
				param,
				fs.Path(),
				err,
			)
		}

		length := int64(val.Len())

		if isMax {
			return length <= threshold, nil
		}

		return length >= threshold, nil
	}

	// check signed ints
	if kind == reflect.Int || kind == reflect.Int8 || kind == reflect.Int16 || kind == reflect.Int32 ||
		kind == reflect.Int64 {

		threshold, err := strconv.ParseInt(param, 0, 64)
		if err != nil {
			return false, fmt.Errorf(
				"firevault: failed to parse '%s' parameter for field '%s': %w",
				param,
				fs.Path(),
				err,
			)
		}

		value := val.Int()

		if isMax {
			return value <= threshold, nil
		}

		return value >= threshold, nil
	}

	// check unsigned ints
	if kind == reflect.Uint || kind == reflect.Uint8 || kind == reflect.Uint16 || kind == reflect.Uint32 ||
		kind == reflect.Uint64 {

		threshold, err := strconv.ParseUint(param, 0, 64)
		if err != nil {
			return false, fmt.Errorf(
				"firevault: failed to parse '%s' parameter for field '%s': %w",
				param,
				fs.Path(),
				err,
			)
		}

		value := val.Uint()

		if isMax {
			return value <= threshold, nil
		}

		return value >= threshold, nil
	}

	// check floats
	if kind == reflect.Float32 || kind == reflect.Float64 {
		threshold, err := strconv.ParseFloat(param, 32)
		if err != nil {
			return false, fmt.Errorf(
				"firevault: failed to parse '%s' parameter for field '%s': %w",
				param,
				fs.Path(),
				err,
			)
		}

		value := val.Float()

		if isMax {
			return value <= threshold, nil
		}

		return value >= threshold, nil
	}

	// check times
	if kind == reflect.Struct {
		timeType := reflect.TypeOf(time.Time{})

		if fs.Type().ConvertibleTo(timeType) {
			params := strings.Split(param, "|")
			if len(params) < 2 {
				return false, fmt.Errorf(
					"firevault: time validation for field '%s' requires format 'layout|value', got: %s",
					fs.Path(),
					param,
				)
			}

			threshold, err := time.Parse(params[0], params[1])
			if err != nil {
				return false, fmt.Errorf(
					"firevault: failed to parse time for field '%s' with layout '%s' and value '%s': %w",
					fs.Path(),
					params[0],
					params[1],
					err,
				)
			}

			t, ok := fs.Value().Convert(timeType).Interface().(time.Time)
			if !ok {
				return false, fmt.Errorf(
					"firevault: failed parse time for field '%s': unexpected time type: %T",
					fs.Path(),
					timeType,
				)
			}

			if isMax {
				return (t.Before(threshold) || t.Equal(threshold)), nil
			}

			return (t.After(threshold) || t.Equal(threshold)), nil
		}
	}

	return false, fmt.Errorf(
		"firevault: '%s' validation not supported for field type %s at '%s'",
		fs.Rule(),
		fs.Kind(),
		fs.Path(),
	)
}

// transforms a field of string type to upper case
func transformUppercase(fs FieldScope) (interface{}, error) {
	if fs.Kind() != reflect.String {
		return fs.Value().Interface(), nil
	}

	return strings.ToUpper(fs.Value().String()), nil
}

// transforms a field of string type to lower case
func transformLowercase(fs FieldScope) (interface{}, error) {
	if fs.Kind() != reflect.String {
		return fs.Value().Interface(), nil
	}

	return strings.ToLower(fs.Value().String()), nil
}

// transforms a field of string type by removing all white space
func transformTrimSpace(fs FieldScope) (interface{}, error) {
	if fs.Kind() != reflect.String {
		return fs.Value().Interface(), nil
	}

	return strings.TrimSpace(fs.Value().String()), nil
}