Events & Model Improvements (#82)

Add Events, EventBus, Listener
Add ModelProperty
Add Timestamps
Add Model Events
Add Model is more extendable
Add Eager load sugar

Author: joshuawright11

.github/workflows/test.yml

@@ -9,10 +9,9 @@ on:
 
 jobs:
   test-macos:
-    if: ${{ false }}  # disable until macOS 12 (with concurrency) runners are available.
     runs-on: macos-12
     env:
-      DEVELOPER_DIR: /Applications/Xcode_13.2.app/Contents/Developer
+      DEVELOPER_DIR: /Applications/Xcode_13.3.app/Contents/Developer
     steps:
     - uses: actions/checkout@v2
     - name: Build

Sources/Alchemy/Application/Application+Services.swift

@@ -34,6 +34,7 @@ extension Application {
             Loop.config()
         }
 
+        Container.bind(.singleton, value: EventBus())
         Container.bind(.singleton, value: Router())
         Container.bind(.singleton, value: Scheduler())
         Container.bind(.singleton) { container -> NIOThreadPool in

Sources/Alchemy/Auth/BasicAuthable.swift

@@ -106,7 +106,10 @@ extension BasicAuthable {
             throw error
         }
 
-        let passwordHash = try firstRow.get(passwordKeyString).value.string()
+        guard let passwordHash = try firstRow[passwordKeyString]?.string() else {
+            throw DatabaseError("Missing column \(passwordKeyString) on row of type \(name(of: Self.self))")
+        }
+        
         guard try verify(password: password, passwordHash: passwordHash) else {
             throw error
         }

Sources/Alchemy/Events/Event.swift

@@ -0,0 +1,17 @@
+/// An app-wide event fired by an `EventBus`.
+public protocol Event {
+    /// The key for which the event is registered in the `EventBus`. Defaults to
+    /// the type name.
+    static var registrationKey: String { get }
+}
+
+extension Event {
+    public static var registrationKey: String { name(of: Self.self) }
+}
+
+extension Event {
+    /// Fire this event on an `EventBus`.
+    public func fire(on events: EventBus = Events) async throws {
+        try await events.fire(self)
+    }
+}

Sources/Alchemy/Events/EventBus.swift

@@ -0,0 +1,54 @@
+import NIOConcurrencyHelpers
+
+public final class EventBus: Service {
+    public struct Identifier: ServiceIdentifier {
+        private let hashable: AnyHashable
+        public init(hashable: AnyHashable) { self.hashable = hashable }
+    }
+    
+    public enum Handler<E: Event>: AnyHandler {
+        public typealias Closure = (E) async throws -> Void
+        case closure(Closure)
+    }
+    
+    private var registeredHandlers: [String: [AnyHandler]] = [:]
+    private var lock = Lock()
+    
+    public func on<E: Event>(_ event: E.Type, action: @escaping Handler<E>.Closure) {
+        let _handlers = lock.withLock { registeredHandlers[E.registrationKey] ?? [] }
+        guard let existingHandlers = _handlers as? [Handler<E>] else { return }
+        registeredHandlers[E.registrationKey] = existingHandlers + [.closure(action)]
+    }
+    
+    public func on<L: Listener>(listener: L.Type) {
+        let _handlers = lock.withLock { registeredHandlers[L.ObservedEvent.registrationKey] ?? [] }
+        guard let existingHandlers = _handlers as? [Handler<L.ObservedEvent>] else { return }
+        registeredHandlers[L.ObservedEvent.registrationKey] = existingHandlers + [.closure {
+            try await L(event: $0).handle()
+        }]
+    }
+    
+    public func fire<E: Event>(_ event: E) async throws {
+        let _handlers = lock.withLock { registeredHandlers[E.registrationKey] ?? [] }
+        guard let handlers = _handlers as? [Handler<E>] else {
+            return
+        }
+        
+        for handler in handlers {
+            switch handler {
+            case .closure(let closure):
+                try await closure(event)
+            }
+        }
+    }
+}
+
+extension Listener {
+    fileprivate func handle() async throws { try await run() }
+}
+
+extension Listener where Self: Job {
+    fileprivate func handle() async throws { try await dispatch() }
+}
+
+private protocol AnyHandler {}

Sources/Alchemy/Events/Listener.swift

@@ -0,0 +1,6 @@
+/// Processes an Event
+public protocol Listener {
+    associatedtype ObservedEvent: Event
+    init(event: ObservedEvent)
+    func run() async throws
+}

Sources/Alchemy/SQL/Database/Core/DatabaseError.swift

@@ -10,4 +10,8 @@ public struct DatabaseError: Error {
     init(_ message: String) {
         self.message = message
     }
+    
+    static func missingColumn(_ column: String) -> DatabaseError {
+        DatabaseError("Missing column named `\(column)`.")
+    }
 }

Sources/Alchemy/SQL/Database/Core/SQL.swift

@@ -20,7 +20,7 @@ extension SQL: SQLConvertible {
 }
 
 extension SQL: SQLValueConvertible {
-    public var value: SQLValue {
+    public var sqlValue: SQLValue {
         .string(statement)
     }
 }

Sources/Alchemy/SQL/Database/Core/SQLRow.swift

@@ -1,44 +1,65 @@
 import Foundation
 
-/// A row of data returned from a database. Various database packages
-/// can use this as an abstraction around their internal row types.
-public protocol SQLRow {
-    /// The `String` names of all columns that have values in this row.
-    var columns: Set<String> { get }
+public struct SQLField: Equatable {
+    public let column: String
+    public let value: SQLValue
+}
+
+/// A row of data returned by an SQL query.
+public struct SQLRow {
+    public let fields: [SQLField]
+    public let lookupTable: [String: Int]
 
-    /// Get the `SQLValue` of a column from this row.
-    ///
-    /// - Parameter column: The column to get the value for.
-    /// - Throws: A `DatabaseError` if the column does not exist on
-    ///   this row.
-    /// - Returns: The value at `column`.
-    func get(_ column: String) throws -> SQLValue
+    public var fieldDictionary: [String: SQLValue] {
+        Dictionary(fields.map { ($0.column, $0.value) }, uniquingKeysWith: { current, _ in current })
+    }
+    
+    init(fields: [SQLField]) {
+        self.fields = fields
+        self.lookupTable = Dictionary(fields.enumerated().map { ($1.column, $0) }, uniquingKeysWith: { current, _ in current })
+    }
+    
+    public func contains(_ column: String) -> Bool {
+        lookupTable[column] != nil
+    }
 
+    public subscript(_ index: Int) -> SQLValue {
+        fields[index].value
+    }
+    
+    public subscript(_ column: String) -> SQLValue? {
+        guard let index = lookupTable[column] else { return nil }
+        return fields[index].value
+    }
+    
+    public func require(_ column: String) throws -> SQLValue {
+        try self[column].unwrap(or: DatabaseError.missingColumn(column))
+    }
+}
+
+extension SQLRow: ExpressibleByDictionaryLiteral {
+    public init(dictionaryLiteral elements: (String, SQLValueConvertible)...) {
+        self.init(fields: elements.enumerated().map { SQLField(column: $1.0, value: $1.1.sqlValue) })
+    }
+}
+
+extension SQLRow {
     /// Decode a `Model` type `D` from this row.
     ///
     /// The default implementation of this function populates the
     /// properties of `D` with the value of the column named the
     /// same as the property.
     ///
     /// - Parameter type: The type to decode from this row.
-    func decode<D: Model>(_ type: D.Type) throws -> D
-}
-
-extension SQLRow {
+    public func decode<M: Model>(_ type: M.Type) throws -> M {
+        try M(from: SQLRowDecoder(row: self, keyMapping: M.keyMapping, jsonDecoder: M.jsonDecoder))
+    }
+    
     public func decode<D: Decodable>(
         _ type: D.Type,
         keyMapping: DatabaseKeyMapping = .useDefaultKeys,
         jsonDecoder: JSONDecoder = JSONDecoder()
     ) throws -> D {
         try D(from: SQLRowDecoder(row: self, keyMapping: keyMapping, jsonDecoder: jsonDecoder))
     }
-    
-    public func decode<M: Model>(_ type: M.Type) throws -> M {
-        try M(from: SQLRowDecoder(row: self, keyMapping: M.keyMapping, jsonDecoder: M.jsonDecoder))
-    }
-    
-    /// Subscript for convenience access.
-    public subscript(column: String) -> SQLValue? {
-        columns.contains(column) ? try? get(column) : nil
-    }
 }

Sources/Alchemy/SQL/Database/Core/SQLValue.swift

@@ -45,6 +45,8 @@ public enum SQLValue: Equatable, Hashable, CustomStringConvertible {
             return "SQLValue.null"
         }
     }
+    
+    public static var now: SQLValue { .date(Date()) }
 }
 
 /// Extension for easily accessing the unwrapped contents of an `SQLValue`.