Merge pull request #211 from vapor/raw

raw + sql cleanup

Sources/Fluent/Database/Database.swift

@@ -73,13 +73,7 @@ extension Database {
         return try threadConnectionPool.connection().query(query)
     }
 
-    /// Seeee Executor protocol.
-    public func schema(_ schema: Schema) throws {
-        log?(Log(schema))
-        try threadConnectionPool.connection().schema(schema)
-    }
-
-    /// Seeee Executor protocol.
+    /// See Executor protocol.
     @discardableResult
     public func raw(_ raw: String, _ values: [Node]) throws -> Node {
         log?(Log(raw: raw))

Sources/Fluent/Database/Driver.swift

@@ -39,15 +39,10 @@ public protocol Driver: Executor {
 extension Driver {
     /// See Executor protocol.
     @discardableResult
-    public func query<T: Entity>(_ query: Query<T>) throws -> Node {
+    public func query<E: Entity>(_ query: Query<E>) throws -> Node {
         return try makeConnection().query(query)
     }
 
-    /// See Executor protocol.
-    public func schema(_ schema: Schema) throws {
-        return try makeConnection().schema(schema)
-    }
-
     /// See Executor protocol.
     @discardableResult
     public func raw(_ raw: String, _ values: [Node]) throws -> Node {

Sources/Fluent/Database/Executor.swift

@@ -15,17 +15,17 @@ public protocol Executor {
     /// returns an array of results fetched,
     /// created, or updated by the action.
     @discardableResult
-    func query<T: Entity>(_ query: Query<T>) throws -> Node
-
-    /// Creates the `Schema` indicated
-    /// by the `Builder`.
-    func schema(_ schema: Schema) throws
+    func query<E: Entity>(_ query: Query<E>) throws -> Node
 
     /// Drivers that support raw querying
     /// accept string queries and parameterized values.
     ///
     /// This allows Fluent extensions to be written that
     /// can support custom querying behavior.
+    ///
+    /// - note: Passing parameterized values as a `[Node]` array
+    ///         instead of interpolating them into the raw string
+    ///         can help prevent SQL injection.
     @discardableResult
     func raw(_ raw: String, _ values: [Node]) throws -> Node
 }

Sources/Fluent/Entity/KeyNamingConvention.swift

@@ -6,6 +6,8 @@ public enum KeyNamingConvention {
     case camelCase
 }
 
+// MARK: Convert PascalCase to snake and camel
+
 extension String {
     internal func snake_case() -> String {
         let characters = Array(self.characters)

Sources/Fluent/Pagination/Query+Page.swift

@@ -15,13 +15,10 @@ extension QueryRepresentable where E: Paginatable {
         let total = try query.count()
 
         // limit the query to the desired page
-        query.limit = Limit(
-            count: count,
-            offset: (page - 1) * count
-        )
-
+        try query.limit(count, offset: (page - 1) * count)
+
         // add the sorts w/o replacing
-        query.sorts += sorts
+        _ = try sorts.map(query.sort)
 
         // fetch the data
         let data = try query.all()

Sources/Fluent/Pivot/Pivot.swift

@@ -69,7 +69,9 @@ public final class Pivot<
         try row.set(Right.foreignIdKey, rightId)
         return row
     }
+}
 
+extension Pivot: Preparation {
     public static func prepare(_ database: Database) throws {
         try database.create(self) { builder in
             builder.id(for: self)

Sources/Fluent/Preparation/Migration.swift

@@ -14,7 +14,6 @@ final class Migration: Entity {
 
     func makeRow() throws -> Row {
         var row = Row()
-        try row.set(idKey, id)
         try row.set("name", name)
         return row
     }

Sources/Fluent/Query/Action.swift

@@ -7,4 +7,43 @@ public enum Action {
     case delete
     case create
     case modify
+    case schema(Schema)
+}
+
+public enum Schema {
+    case create([RawOr<Field>])
+    case modify(add: [RawOr<Field>], remove: [RawOr<Field>])
+    case delete
+}
+
+extension Action: Equatable {
+    public static func ==(lhs: Action, rhs: Action) -> Bool {
+        switch (lhs, rhs) {
+        case (.fetch, .fetch),
+             (.count, .count),
+             (.delete, .delete),
+             (.create, .create),
+             (.modify, .modify):
+            return true
+        case (.schema(let a), .schema(let b)):
+            return a == b
+        default:
+            return false
+        }
+    }
+}
+
+extension Schema: Equatable {
+    public static func ==(lhs: Schema, rhs: Schema) -> Bool {
+        switch (lhs, rhs) {
+        case (.create(let a), .create(let b)):
+            return a == b
+        case (.modify(let addA, let removeA), .modify(let addB, let removeB)):
+            return addA == addB && removeA == removeB
+        case (.delete, .delete):
+            return true
+        default:
+            return false
+        }
+    }
 }

Sources/Fluent/Query/Comparison.swift → Sources/Fluent/Query/Filter/Comparison.swift

@@ -11,6 +11,7 @@ extension Filter {
         case hasSuffix
         case hasPrefix
         case contains
+        case custom(String)
     }
 
 }
@@ -44,3 +45,24 @@ func != (lhs: String, rhs: NodeRepresentable) throws -> Filter.Method {
     let node = try rhs.makeNode(in: rowContext)
     return .compare(lhs, .notEquals, node)
 }
+
+extension Filter.Comparison: Equatable {
+    public static func ==(lhs: Filter.Comparison, rhs: Filter.Comparison) -> Bool {
+        switch (lhs, rhs) {
+        case (.equals, .equals),
+             (.greaterThan, .greaterThan),
+             (.lessThan, .lessThan),
+             (.greaterThanOrEquals, .greaterThanOrEquals),
+             (.lessThanOrEquals, .lessThanOrEquals),
+             (.notEquals, .notEquals),
+             (.hasSuffix, .hasSuffix),
+             (.hasPrefix, .hasPrefix),
+             (.contains, .contains):
+            return true
+        case (.custom(let a), .custom(let b)):
+            return a == b
+        default:
+            return false
+        }
+    }
+}

Sources/Fluent/Query/Filter/Filter.swift

@@ -0,0 +1,37 @@
+/// Defines a `Filter` that can be
+/// added on fetch, delete, and update
+/// operations to limit the set of
+/// data affected.
+public struct Filter {
+    public enum Relation {
+        case and, or
+    }
+
+    public enum Method {
+        case compare(String, Comparison, Node)
+        case subset(String, Scope, [Node])
+        case group(Relation, [RawOr<Filter>])
+    }
+
+    public init(_ entity: Entity.Type, _ method: Method) {
+        self.entity = entity
+        self.method = method
+    }
+
+    public var entity: Entity.Type
+    public var method: Method
+}
+
+extension Filter: CustomStringConvertible {
+    public var description: String {
+        switch method {
+        case .compare(let field, let comparison, let value):
+            return "(\(entity)) \(field) \(comparison) \(value)"
+        case .subset(let field, let scope, let values):
+            let valueDescriptions = values.map { $0.string ?? "" }
+            return "(\(entity)) \(field) \(scope) \(valueDescriptions)"
+        case .group(let relation, let filters):
+            return filters.map { $0.description }.joined(separator: "\(relation)")
+        }
+    }
+}