// retoor <retoor@molodetz.nl>
import "regex" for Regex
import "base64" for Base64
import "json" for Json
import "uuid" for Uuid
class Validator {
static email(value) {
if (!(value is String)) return false
var at = value.indexOf("@")
if (at < 1) return false
var dot = value.indexOf(".", at)
if (dot < at + 2) return false
if (dot >= value.count - 1) return false
for (c in value) {
var code = c.codePoints.toList[0]
if (c == "@" || c == "." || c == "_" || c == "-" || c == "+") continue
if (code >= 48 && code <= 57) continue
if (code >= 65 && code <= 90) continue
if (code >= 97 && code <= 122) continue
return false
}
return true
}
static domain(value) {
if (!(value is String)) return false
if (value.count == 0) return false
if (value[0] == "-" || value[-1] == "-") return false
var parts = value.split(".")
if (parts.count < 2) return false
for (part in parts) {
if (part.count == 0 || part.count > 63) return false
if (part[0] == "-" || part[-1] == "-") return false
for (c in part) {
var code = c.codePoints.toList[0]
if (c == "-") continue
if (code >= 48 && code <= 57) continue
if (code >= 65 && code <= 90) continue
if (code >= 97 && code <= 122) continue
return false
}
}
return true
}
static safeStr(value) {
if (!(value is String)) return false
for (b in value.bytes) {
if (b < 32 || b > 126) return false
}
return true
}
static httpEncoded(value) {
if (!(value is String)) return false
for (c in value) {
var code = c.codePoints.toList[0]
if (c == "_" || c == "." || c == "~" || c == "-" || c == "+") continue
if (c == "\%") continue
if (code >= 48 && code <= 57) continue
if (code >= 65 && code <= 90) continue
if (code >= 97 && code <= 122) continue
return false
}
return true
}
static base64(value) {
if (!(value is String)) return false
if (value.count % 4 != 0) return false
var padCount = 0
for (i in 0...value.count) {
var c = value[i]
if (c == "=") {
padCount = padCount + 1
if (i < value.count - 2) return false
} else if (padCount > 0) {
return false
} else {
var code = c.codePoints.toList[0]
if (c == "+" || c == "/") continue
if (code >= 48 && code <= 57) continue
if (code >= 65 && code <= 90) continue
if (code >= 97 && code <= 122) continue
return false
}
}
return padCount <= 2
}
static json(value) {
if (!(value is String)) return false
var fiber = Fiber.new {
Json.parse(value)
}
var result = fiber.try()
return !fiber.error
}
static regex(value, pattern) {
if (!(value is String)) return false
var re = Regex.new(pattern)
return re.test(value)
}
static url(value) {
if (!(value is String)) return false
if (!value.startsWith("http://") && !value.startsWith("https://")) return false
var rest = value.startsWith("https://") ? value[8..-1] : value[7..-1]
if (rest.count == 0) return false
return true
}
static uuid(value) {
return Uuid.isValid(value)
}
static minLength(value, min) {
if (value is String) return value.count >= min
if (value is List) return value.count >= min
return false
}
static maxLength(value, max) {
if (value is String) return value.count <= max
if (value is List) return value.count <= max
return false
}
static range(value, min, max) {
if (!(value is Num)) return false
return value >= min && value <= max
}
static positive(value) {
if (!(value is Num)) return false
return value > 0
}
static negative(value) {
if (!(value is Num)) return false
return value < 0
}
static integer(value) {
if (!(value is Num)) return false
return value == value.floor
}
static ipv4(value) {
if (!(value is String)) return false
var parts = value.split(".")
if (parts.count != 4) return false
for (part in parts) {
if (part.count == 0 || part.count > 3) return false
var n = Num.fromString(part)
if (n == null || n < 0 || n > 255) return false
if (part.count > 1 && part[0] == "0") return false
}
return true
}
}
class Field {
static string() { StringField.new() }
static string(options) { StringField.new(options) }
static integer() { IntegerField.new() }
static integer(options) { IntegerField.new(options) }
static number() { NumberField.new() }
static number(options) { NumberField.new(options) }
static email() { EmailField.new() }
static boolean() { BooleanField.new() }
static list(itemType) { ListField.new(itemType) }
static map() { MapField.new() }
static optional(fieldDef) { OptionalField.new(fieldDef) }
static required(fieldDef) {
fieldDef.required = true
return fieldDef
}
}
class BaseField {
construct new() {
_required = true
_default = null
_validators = []
}
construct new(options) {
_required = options.containsKey("required") ? options["required"] : true
_default = options.containsKey("default") ? options["default"] : null
_validators = options.containsKey("validators") ? options["validators"] : []
}
required { _required }
required=(value) { _required = value }
default { _default }
validators { _validators }
addValidator(fn) {
_validators.add(fn)
return this
}
validate(value, path) {
if (value == null) {
if (_required) return ValidationError.new(path, "Field is required")
return null
}
var typeError = validateType_(value, path)
if (typeError) return typeError
for (validator in _validators) {
if (!validator.call(value)) {
return ValidationError.new(path, "Custom validation failed")
}
}
return null
}
validateType_(value, path) { null }
coerce(value) { value }
}
class StringField is BaseField {
construct new() {
super()
_minLength = null
_maxLength = null
_pattern = null
}
construct new(options) {
super(options)
_minLength = options.containsKey("minLength") ? options["minLength"] : null
_maxLength = options.containsKey("maxLength") ? options["maxLength"] : null
_pattern = options.containsKey("pattern") ? options["pattern"] : null
}
validateType_(value, path) {
if (!(value is String)) return ValidationError.new(path, "Expected string")
if (_minLength && value.count < _minLength) {
return ValidationError.new(path, "String too short")
}
if (_maxLength && value.count > _maxLength) {
return ValidationError.new(path, "String too long")
}
if (_pattern) {
var re = Regex.new(_pattern)
if (!re.test(value)) {
return ValidationError.new(path, "String does not match pattern")
}
}
return null
}
minLength { _minLength }
maxLength { _maxLength }
}
class IntegerField is BaseField {
construct new() {
super()
_min = null
_max = null
}
construct new(options) {
super(options)
_min = options.containsKey("min") ? options["min"] : null
_max = options.containsKey("max") ? options["max"] : null
}
validateType_(value, path) {
if (!(value is Num)) return ValidationError.new(path, "Expected integer")
if (value != value.floor) return ValidationError.new(path, "Expected integer, got float")
if (_min && value < _min) return ValidationError.new(path, "Value below minimum")
if (_max && value > _max) return ValidationError.new(path, "Value above maximum")
return null
}
min { _min }
max { _max }
coerce(value) {
if (value is String) return Num.fromString(value)
return value
}
}
class NumberField is BaseField {
construct new() {
super()
_min = null
_max = null
}
construct new(options) {
super(options)
_min = options.containsKey("min") ? options["min"] : null
_max = options.containsKey("max") ? options["max"] : null
}
validateType_(value, path) {
if (!(value is Num)) return ValidationError.new(path, "Expected number")
if (_min && value < _min) return ValidationError.new(path, "Value below minimum")
if (_max && value > _max) return ValidationError.new(path, "Value above maximum")
return null
}
min { _min }
max { _max }
coerce(value) {
if (value is String) return Num.fromString(value)
return value
}
}
class EmailField is BaseField {
construct new() { super() }
validateType_(value, path) {
if (!(value is String)) return ValidationError.new(path, "Expected string")
if (!Validator.email(value)) return ValidationError.new(path, "Invalid email format")
return null
}
}
class BooleanField is BaseField {
construct new() { super() }
validateType_(value, path) {
if (!(value is Bool)) return ValidationError.new(path, "Expected boolean")
return null
}
coerce(value) {
if (value is String) {
if (value == "true" || value == "1") return true
if (value == "false" || value == "0") return false
}
return value
}
}
class ListField is BaseField {
construct new(itemType) {
super()
_itemType = itemType
}
validateType_(value, path) {
if (!(value is List)) return ValidationError.new(path, "Expected list")
for (i in 0...value.count) {
var itemPath = path + "[" + i.toString + "]"
var error = _itemType.validate(value[i], itemPath)
if (error) return error
}
return null
}
itemType { _itemType }
}
class MapField is BaseField {
construct new() { super() }
validateType_(value, path) {
if (!(value is Map)) return ValidationError.new(path, "Expected map")
return null
}
}
class OptionalField is BaseField {
construct new(fieldDef) {
super()
_field = fieldDef
_required = false
}
validate(value, path) {
if (value == null) return null
return _field.validate(value, path)
}
}
class ValidationError {
construct new(path, message) {
_path = path
_message = message
}
path { _path }
message { _message }
toString { _path + ": " + _message }
}
class ValidationResult {
construct new(isValid, errors, data) {
_isValid = isValid
_errors = errors
_data = data
}
isValid { _isValid }
errors { _errors }
data { _data }
}
class Schema {
construct new(definition) {
_definition = definition
}
validate(data) {
if (!(data is Map)) {
return ValidationResult.new(false, [ValidationError.new("", "Expected object")], null)
}
var errors = []
var validData = {}
for (key in _definition.keys) {
var field = _definition[key]
var value = data.containsKey(key) ? data[key] : null
if (value != null) {
value = field.coerce(value)
}
var error = field.validate(value, key)
if (error) {
errors.add(error)
} else {
validData[key] = value != null ? value : field.default
}
}
return ValidationResult.new(errors.count == 0, errors, errors.count == 0 ? validData : null)
}
validateOrAbort(data) {
var result = validate(data)
if (!result.isValid) {
var messages = []
for (error in result.errors) {
messages.add(error.toString)
}
Fiber.abort("Validation failed: " + messages.join(", "))
}
return result.data
}
}
Reference in New Issue View Git Blame Copy Permalink