validation

.swiftlint.yml

@@ -1,5 +1,6 @@
 disabled_rules:
   - line_length
+  - valid_docs
 opt_in_rules:
 included:
 excluded:

Sources/Development/main.swift

@@ -21,7 +21,7 @@ app.resource("users", controller: UserController.self)
 //MARK: Request data
 
 app.post("jsondata") { request in
-    print(request.data.json?["hi"]?.string)
+    print(request.data.json?["hi"].string)
     return "yup"
 }
 
@@ -46,14 +46,14 @@ app.get("json") { request in
 
 app.post("json") { request in
     //parse a key inside the received json
-    guard let count = request.data["unicorns"]?.int else {
+    guard let count = request.data["unicorns"].int else {
         return Response(error: "No unicorn count provided")
     }
     return "Received \(count) unicorns"
 }
 
 app.post("form") { request in
-    guard let name = request.data["name"]?.string else {
+    guard let name = request.data["name"].string else {
         return Response(error: "No name provided")
     }
 
@@ -66,7 +66,7 @@ app.get("redirect") { request in
 
 app.post("json2") { request in
     //parse a key inside the received json
-    guard let count = request.data["unicorns"]?.int else {
+    guard let count = request.data["unicorns"].int else {
         return Response(error: "No unicorn count provided")
     }
     return Response(status: .created, json: Json(["message":"Received \(count) unicorns"]))
@@ -157,6 +157,37 @@ app.get("cookies") { request in
     return response
 }
 
+class Name: ValidationSuite {
+    static func validate(input value: String) throws {
+        let evaluation = OnlyAlphanumeric.self
+            && Count.min(5)
+            && Count.max(20)
+
+        try evaluation.validate(input: value)
+    }
+}
+
+class Employee {
+    var name: Valid<Name>
+
+    init(request: Request) throws {
+        name = try request.data["name"].validated()
+    }
+}
+
+extension Employee: JsonRepresentable {
+    func makeJson() -> Json {
+        return Json([
+            "name": name.value
+        ])
+    }
+}
+
+app.get("validation") { request in
+    let employee = try Employee(request: request)
+    return employee
+}
+
 //MARK: Middleware
 
 app.middleware(AuthMiddleware()) {

Sources/Vapor/Core/Application.swift

@@ -113,6 +113,7 @@ public class Application {
     public init(sessionDriver: SessionDriver? = nil) {
         self.middleware = [
             AbortMiddleware(),
+            ValidationMiddleware()
         ]
 
         self.providers = []

Sources/Vapor/Middleware/AbortMiddleware.swift

@@ -38,7 +38,7 @@ public class AbortMiddleware: Middleware {
 
     func errorResponse(_ status: Response.Status, message: String) throws -> Response {
         let json = Json([
-            "error": "true",
+            "error": true,
             "message": "\(message)"
         ])
         return Response(status: status, json: json)

Sources/Vapor/Node/Node.swift

@@ -26,3 +26,36 @@ public enum NodeError: ErrorProtocol {
     */
     case UnableToConvert(node: Node, toType: String)
 }
+
+extension Extractable where Wrapped == Node {
+    public var isNull: Bool {
+        return extract()?.isNull ?? false
+    }
+    public var bool: Bool? {
+        return extract()?.bool
+    }
+    public var float: Float? {
+        return extract()?.float
+    }
+    public var double: Double? {
+        return extract()?.double
+    }
+    public var int: Int? {
+        return extract()?.int
+    }
+    public var uint: UInt? {
+        return extract()?.uint
+    }
+    public var string: String? {
+        return extract()?.string
+    }
+    public var array: [Node]? {
+        return extract()?.array
+    }
+    public var object: [String : Node]? {
+        return extract()?.object
+    }
+    public var json: Json? {
+        return extract()?.json
+    }
+}

Sources/Vapor/Validation/And.swift

@@ -0,0 +1,98 @@
+/*
+ The MIT License (MIT) Copyright (c) 2016 Benjamin Encz
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy of this
+ software and associated documentation files (the "Software"), to deal in the Software
+ without restriction, including without limitation the rights to use, copy, modify, merge,
+ publish, distribute, sublicense, and/or sell copies of the Software, and to permit
+ persons to whom the Software is furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in all copies or
+ substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+ INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
+ AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+ DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/**
+    This struct is used to encompass multiple Validators into one entity.
+
+    It is possible to access this struct directly using 
+
+     And(validatorOne, validatorTwo)
+
+    But it is more common to create And objects using the `+` operator:
+
+     validatorOne + validatorTwo
+*/
+public struct And<
+    V: Validator,
+    U: Validator where V.InputType == U.InputType> {
+    private typealias Validator = (input: V.InputType) throws -> Void
+    private let validator: Validator
+
+    /**
+        Convenience only.
+
+        Must stay private.
+    */
+    private init(_ lhs: Validator, _ rhs: Validator) {
+        validator = { value in
+            try lhs(input: value)
+            try rhs(input: value)
+        }
+    }
+}
+
+extension And: Validator {
+    /**
+        Validator conformance that allows the 'And' struct
+        to concatenate multiple Validator types.
+
+        - parameter value: the value to validate
+
+        - throws: an error on failed validation
+    */
+    public func validate(input value: V.InputType) throws {
+        try validator(input: value)
+    }
+}
+
+extension And {
+    /**
+        Used to combine two Validator types
+    */
+    public init(_ lhs: V, _ rhs: U) {
+        self.init(lhs.validate, rhs.validate)
+    }
+}
+
+extension And where V: ValidationSuite {
+    /**
+        Used to combine two Validator types where one is a ValidationSuite
+    */
+    public init(_ lhs: V.Type = V.self, _ rhs: U) {
+        self.init(lhs.validate, rhs.validate)
+    }
+}
+
+extension And where U: ValidationSuite {
+    /**
+        Used to combine two Validators where one is a ValidationSuite
+    */
+    public init(_ lhs: V, _ rhs: U.Type = U.self) {
+        self.init(lhs.validate, rhs.validate)
+    }
+}
+
+extension And where V: ValidationSuite, U: ValidationSuite {
+    /**
+        Used to combine two ValidationSuite types
+    */
+    public init(_ lhs: V.Type = V.self, _ rhs: U.Type = U.self) {
+        self.init(lhs.validate, rhs.validate)
+    }
+}

Sources/Vapor/Validation/Convenience/Alphanumeric.swift

@@ -0,0 +1,29 @@
+
+/**
+    A validator that can be used to check that a
+    given string contains only alphanumeric characters
+*/
+public struct OnlyAlphanumeric: ValidationSuite {
+    private static let alphanumeric = "abcdefghijklmnopqrstuvwxyz0123456789"
+    private static let validCharacters = alphanumeric.characters
+
+    /**
+        Validate whether or not an input string contains only
+        alphanumeric characters. a...z0...9
+
+        - parameter value: input value to validate
+
+        - throws: an error if validation fails
+    */
+    public static func validate(input value: String) throws {
+        let passed = value
+            .lowercased()
+            .characters
+            .filter(validCharacters.contains)
+            .count
+
+        if passed != value.characters.count {
+            throw error(with: value)
+        }
+    }
+}

Sources/Vapor/Validation/Convenience/Compare.swift

@@ -0,0 +1,46 @@
+/**
+    Validate a comparable
+
+
+    - greaterThan: validate input is > associated value
+    - greaterThanOrEqual: validate input is >= associated value
+    - lessThan: validate input is < associated value
+    - lessThanOrEqual: validate input is <= associated value
+    - equals: validate input == associated value
+    - containedIn: validate low <= input && input <= high
+*/
+public enum Compare<ComparableType where ComparableType: Comparable, ComparableType: Validatable>: Validator {
+    public typealias InputType = ComparableType
+    case greaterThan(ComparableType)
+    case greaterThanOrEqual(ComparableType)
+    case lessThan(ComparableType)
+    case lessThanOrEqual(ComparableType)
+    case equals(ComparableType)
+    case containedIn(low: ComparableType, high: ComparableType)
+
+    /**
+     Validate that a string passes associated compare evaluation
+
+     - parameter value: input string to validate
+
+     - throws: an error if validation fails
+     */
+    public func validate(input value: InputType) throws {
+        switch self {
+        case .greaterThan(let c) where value > c:
+            break
+        case .greaterThanOrEqual(let c) where value >= c:
+            break
+        case .lessThan(let c) where value < c:
+            break
+        case .lessThanOrEqual(let c) where value <= c:
+            break
+        case .equals(let e) where value == e:
+            break
+        case .containedIn(low: let l, high: let h) where l <= value && value <= h:
+            break
+        default:
+            throw error(with: value)
+        }
+    }
+}

Sources/Vapor/Validation/Convenience/Contains.swift

@@ -0,0 +1,34 @@
+/**
+    Validate that a sequence contains a given value
+*/
+public struct Contains<
+    T where
+    T: Sequence,
+    T: Validatable,
+    T.Iterator.Element: Equatable>: Validator {
+
+    /**
+        The value expected to be in sequence
+    */
+    public let expecting: T.Iterator.Element
+
+    /**
+        Create a validator to check that a sequence contains the given value
+
+        - parameter expecting: the value expected to be in sequence
+     */
+    public init(_ expecting: T.Iterator.Element) {
+        self.expecting = expecting
+    }
+
+    /**
+        validate
+    */
+    public func validate(input sequence: T) throws {
+        for element in sequence where element == expecting {
+            return
+        }
+
+        throw error(with: sequence)
+    }
+}