Update eager loading and add optional Parameter function

Author: joshuawright11

Sources/Alchemy/HTTP/Request/Request.swift

@@ -46,6 +46,10 @@ public final class Request: RequestInspector {
         self.parameters = parameters
     }
 
+    public func parameter<L: LosslessStringConvertible>(_ key: String, as: L.Type = L.self) -> L? {
+        parameters.first(where: { $0.key == key }).map { L($0.value) } ?? nil
+    }
+    
     /// Returns the first parameter for the given key, if there is one.
     ///
     /// Use this to fetch any parameters from the path.

Sources/Alchemy/SQL/Rune/Model/Model+PrimaryKey.swift

@@ -3,7 +3,7 @@ import Foundation
 /// Represents a type that may be a primary key in a database. Out of
 /// the box `UUID`, `String` and `Int` are supported but you can
 /// easily support your own by conforming to this protocol.
-public protocol PrimaryKey: Hashable, SQLValueConvertible, Codable {
+public protocol PrimaryKey: Hashable, SQLValueConvertible, Codable, LosslessStringConvertible {
     /// Initialize this value from an `SQLValue`.
     ///
     /// - Throws: If there is an error decoding this type from the

Sources/Alchemy/SQL/Rune/Model/ModelQuery+EagerLoad.swift

@@ -1,13 +1,4 @@
 extension ModelQuery {
-    /// A closure for defining any nested eager loading when loading a
-    /// relationship on this `Model`.
-    ///
-    /// "Eager loading" refers to loading a model at the other end of
-    /// a relationship of this queried model. Nested eager loads
-    /// refers to loading a model from a relationship on that
-    /// _other_ model.
-    public typealias NestedQuery<R: Model> = (ModelQuery<R>) -> ModelQuery<R>
-    
     /// A tuple of models and the SQLRow that they were loaded from.
     typealias ModelRow = (model: M, row: SQLRow)
 
@@ -100,6 +91,15 @@ extension ModelQuery {
     }
 }
 
+/// A closure for defining any nested eager loading when loading a
+/// relationship on this `Model`.
+///
+/// "Eager loading" refers to loading a model at the other end of
+/// a relationship of this queried model. Nested eager loads
+/// refers to loading a model from a relationship on that
+/// _other_ model.
+public typealias NestedQuery<R: Model> = (ModelQuery<R>) -> ModelQuery<R>
+
 extension RelationshipMapping {
     fileprivate func load<M: Model>(_ values: [SQLRow], database: Database) throws -> ModelQuery<M> {
         var query = M.query(database: database)
@@ -132,26 +132,41 @@ extension Array where Element: Hashable {
     }
 }
 
-
 // MARK: - Additional Eager Load convience functions
 
 extension Model {
-    public func with<R: Relationship>(db: Database = DB, _ relationship: KeyPath<Self, R>) async throws -> Self where R.From == Self {
-        try await sync(db: db) { $0.with(relationship) }
+    public func with<R: Relationship>(
+        db: Database = DB,
+        _ relationship: KeyPath<Self, R>,
+        nested: @escaping NestedQuery<R.To.Value> = { $0 }
+    ) async throws -> Self where R.From == Self {
+        try await sync(db: db) { $0.with(relationship, nested: nested) }
     }
 
-    public func fetch<R: Relationship>(db: Database = DB, _ relationship: KeyPath<Self, R>) async throws -> R.Wrapped where R.From == Self {
-        try await sync(db: db) { $0.with(relationship) }[keyPath: relationship].wrappedValue
+    public func fetch<R: Relationship>(
+        db: Database = DB,
+        _ relationship: KeyPath<Self, R>,
+        nested: @escaping NestedQuery<R.To.Value> = { $0 }
+    ) async throws -> R.Wrapped where R.From == Self {
+        try await sync(db: db) { $0.with(relationship, nested: nested) }[keyPath: relationship].wrappedValue
     }
 }
 
 extension Array where Element: Model {
-    public func with<R: Relationship>(db: Database = DB, _ relationship: KeyPath<Element, R>) async throws -> Self where R.From == Element {
-        try await syncAll(db: db) { $0.with(relationship) }
+    public func with<R: Relationship>(
+        db: Database = DB,
+        _ relationship: KeyPath<Element, R>,
+        nested: @escaping NestedQuery<R.To.Value> = { $0 }
+    ) async throws -> Self where R.From == Element {
+        try await syncAll(db: db) { $0.with(relationship, nested: nested) }
     }
 
-    public func fetch<R: Relationship>(db: Database = DB, _ relationship: KeyPath<Element, R>) async throws -> [R.Wrapped] where R.From == Element {
-        try await syncAll(db: db) { $0.with(relationship) }
+    public func fetch<R: Relationship>(
+        db: Database = DB,
+        _ relationship: KeyPath<Element, R>,
+        nested: @escaping NestedQuery<R.To.Value> = { $0 }
+    ) async throws -> [R.Wrapped] where R.From == Element {
+        try await syncAll(db: db) { $0.with(relationship, nested: nested) }
             .map { $0[keyPath: relationship].wrappedValue }
     }
 }