Remove DatabaseQuery

Author: wickwirew

Sources/Compiler/Gen/SwiftLanguage.swift

@@ -39,7 +39,7 @@ public struct SwiftLanguage: Language {
         input: String,
         output: String
     ) -> String {
-        return "AnyDatabaseQuery<\(input), \(output)>"
+        return "DatabaseQuery<\(input), \(output)>"
     }
 
     public func interpolatedQuestionMarks(for param: String) -> String {
@@ -544,7 +544,7 @@ public struct SwiftLanguage: Language {
     /// to be referenced explicitly in their decl.
     private func dbTypeAlias(for query: GeneratedQuery, queryType: String = "Query") {
         let name = query.typealiasName.replacingOccurrences(of: "Query", with: "DatabaseQuery")
-        writer.write(line: "typealias ", name, " = AnyDatabaseQuery<", query.inputName, ", ", query.outputName, ">")
+        writer.write(line: "typealias ", name, " = DatabaseQuery<", query.inputName, ", ", query.outputName, ">")
     }
 
     private func inputExtension(

Sources/Otter/Connection.swift

@@ -21,3 +21,15 @@ public protocol Connection: Actor {
         execute: (borrowing Transaction) throws -> Output
     ) async throws -> Output
 }
+
+actor NoopConnection: Connection {
+    nonisolated func observe(subscriber: any DatabaseSubscriber) {}
+    nonisolated func cancel(subscriber: any DatabaseSubscriber) {}
+    
+    func begin<Output>(
+        _ kind: Transaction.Kind,
+        execute: (borrowing Transaction) throws -> Output
+    ) async throws -> Output {
+        try execute(Transaction(connection: NoopRawConnection(), kind: kind))
+    }
+}

Sources/Otter/ConnectionPool.swift

@@ -23,15 +23,15 @@ public actor ConnectionPool: Sendable {
     /// The maximum number of connections we can create
     private let limit: Int
     /// Any connections available for use
-    private var availableConnections: [SQLiteConnection]
+    private var availableConnections: [RawConnection]
     /// Any caller waiting for a connection
     private var waitingForConnection: [WaiterContinuation] = []
     /// A lock to synchronize writes.
     private var writeLock = Lock()
     /// Manages alerting any subscribers of any database changes.
     private nonisolated let observer = DatabaseObserver()
 
-    typealias WaiterContinuation = CheckedContinuation<SQLiteConnection, Never>
+    typealias WaiterContinuation = CheckedContinuation<RawConnection, Never>
 
     public init(
         path: String,
@@ -72,7 +72,7 @@ public actor ConnectionPool: Sendable {
     }
 
     /// Gives the connection back to the pool.
-    private func reclaim(connection: SQLiteConnection, kind: Transaction.Kind) async {
+    private func reclaim(connection: RawConnection, kind: Transaction.Kind) async {
         availableConnections.append(connection)
         alertAnyWaitersOfAvailableConnection()
 
@@ -82,7 +82,7 @@ public actor ConnectionPool: Sendable {
     }
 
     /// Will get, wait or create a connection to the database
-    private func getConnection() async throws(OtterError) -> SQLiteConnection {
+    private func getConnection() async throws(OtterError) -> RawConnection {
         guard availableConnections.isEmpty else {
             // Have an available connection, just use it
             return availableConnections.removeLast()

Sources/Otter/DatabaseQuery.swift

@@ -10,18 +10,42 @@
 /// on the original base query type. Erasing to this can allow for
 /// use of the operators.
 public struct AnyQuery<Input: Sendable, Output: Sendable>: Query {
-    let query: any Query<Input, Output>
-
+    public let transactionKind: Transaction.Kind
+    public let connection: any Connection
+    public let watchedTables: Set<String>
+    private let _execute: @Sendable (Input, borrowing Transaction) throws -> Output
+    private let _observe: @Sendable (Input) -> any QueryObservation<Output>
+    
+    public init(
+        transactionKind: Transaction.Kind,
+        connection: any Connection,
+        watchedTables: Set<String>,
+        execute: @Sendable @escaping (Input, borrowing Transaction) throws -> Output,
+        observe: @Sendable @escaping (Input) -> any QueryObservation<Output>
+    ) {
+        self.transactionKind = transactionKind
+        self.connection = connection
+        self.watchedTables = watchedTables
+        self._execute = execute
+        self._observe = observe
+    }
+    
     public init(_ query: any Query<Input, Output>) {
-        self.query = query
+        self = AnyQuery(
+            transactionKind: query.transactionKind,
+            connection: query.connection,
+            watchedTables: query.watchedTables,
+            execute: { try query.execute(with: $0, tx: $1) },
+            observe: { query.observe(with: $0) }
+        )
     }
-
-    public func execute(with input: Input) async throws -> Output {
-        try await query.execute(with: input)
+    
+    public func execute(with input: Input, tx: borrowing Transaction) throws -> Output {
+        try _execute(input, tx)
     }
 
     public func observe(with input: Input) -> any QueryObservation<Output> {
-        query.observe(with: input)
+        _observe(input)
     }
 }
 

Sources/Otter/Queries/AnyQuery.swift

@@ -6,7 +6,7 @@
 //
 
 extension Queries {
-    public struct Bulk<Base: DatabaseQuery>: DatabaseQuery {
+    public struct Bulk<Base: Query>: Query {
         public typealias Input = [Base.Input]
         public typealias Output = [Base.Output]
 
@@ -39,7 +39,7 @@ extension Queries {
     }
 }
 
-extension DatabaseQuery {
+extension Query {
     /// Returns a query that executes the same query in bulk
     /// for each input.
     ///

Sources/Otter/Queries/Bulk.swift

@@ -1,24 +1,27 @@
 //
-//  AnyDatabaseQuery.swift
+//  DatabaseQuery.swift
 //  Otter
 //
 //  Created by Wes Wickwire on 5/5/25.
 //
 
-/// A query that is executed against a database.
-public struct AnyDatabaseQuery<Input, Output>: DatabaseQuery
+/// A default implementation of a `Query`. Expects to be executed
+/// against a real database and not a Noop.
+///
+/// This is the structure that the codegen of the compiler expects to use.
+public struct DatabaseQuery<Input, Output>: Query
     where Input: Sendable, Output: Sendable
 {
     public let connection: any Connection
     public let transactionKind: Transaction.Kind
     public let watchedTables: Set<String>
     public let execute: @Sendable (Input, borrowing Transaction) throws -> Output
 
-    /// Initializes a `AnyDatabaseQuery`. This a query that will be handed
+    /// Initializes a `DatabaseQuery`. This a query that will be handed
     /// the input and transaction when execute is called.
     ///
     /// ```swift
-    /// AnyDatabaseQuery<In, Out>(.read, in: connection) { input, tx in
+    /// DatabaseQuery<In, Out>(.read, in: connection) { input, tx in
     ///     ...
     /// }
     /// ```
@@ -50,16 +53,3 @@ public struct AnyDatabaseQuery<Input, Output>: DatabaseQuery
         return try execute(input, tx)
     }
 }
-
-public extension DatabaseQuery {
-    /// Erases the current query to a `AnyDatabaseQuery`. Useful if you are using
-    /// operators like `map` or `mapInput` which can have quite the long signature
-    /// for combined queries.
-    ///
-    /// - Returns: `self` erased to a `AnyDatabaseQuery`
-    func eraseToAnyDatabaseQuery() -> AnyDatabaseQuery<Input, Output> {
-        AnyDatabaseQuery(transactionKind, in: connection, watchingTables: watchedTables) { input, tx in
-            try self.execute(with: input, tx: tx)
-        }
-    }
-}

…ces/Otter/Queries/AnyDatabaseQuery.swift Sources/Otter/Queries/DatabaseQuery.swiftSources/Otter/Queries/AnyDatabaseQuery.swift renamed to Sources/Otter/Queries/DatabaseQuery.swift Sources/Otter/Queries/AnyDatabaseQuery.swift renamed to Sources/Otter/Queries/DatabaseQuery.swift

@@ -23,10 +23,21 @@ public extension Queries {
             self.error = error
         }
 
+        public var transactionKind: Transaction.Kind { .read }
+        public var watchedTables: Set<String> { [] }
+        public var connection: any Connection { NoopConnection() }
+        
         public func execute(with input: Input) async throws -> Output {
             throw error
         }
 
+        public func execute(
+            with input: Input,
+            tx: borrowing Transaction
+        ) throws -> Output {
+            throw error
+        }
+        
         public func observe(with input: Input) -> any QueryObservation<Output> {
             return Observation(error: error)
         }

Sources/Otter/Queries/Fail.swift

@@ -43,10 +43,23 @@ public extension Queries {
             self = Just(nil)
         }
 
+        public var transactionKind: Transaction.Kind { .read }
+        
+        public var watchedTables: Set<String> { [] }
+        
+        public var connection: any Connection { NoopConnection() }
+        
         public func execute(with input: Input) async throws -> Output {
             return output
         }
 
+        public func execute(
+            with input: Input,
+            tx: borrowing Transaction
+        ) throws -> Output {
+            return output
+        }
+        
         public func observe(with input: Input) -> any QueryObservation<Output> {
             return Observation(output: output)
         }

Sources/Otter/Queries/Just.swift

@@ -15,8 +15,20 @@ public extension Queries {
         /// The transform to apply to the output
         let transform: @Sendable (Base.Input, Base.Output) throws -> Output
 
-        public func execute(with input: Base.Input) async throws -> Output {
-            try await transform(input, base.execute(with: input))
+        public var transactionKind: Transaction.Kind {
+            base.transactionKind
+        }
+        
+        public var connection: any Connection {
+            base.connection
+        }
+        
+        public var watchedTables: Set<String> {
+            base.watchedTables
+        }
+        
+        public func execute(with input: Base.Input, tx: borrowing Transaction) throws -> Output {
+            try transform(input, base.execute(with: input, tx: tx))
         }
 
         public func observe(with input: Base.Input) -> any QueryObservation<Output> {
@@ -51,26 +63,6 @@ public extension Queries {
     }
 }
 
-extension Queries.Map: DatabaseQuery where Base: DatabaseQuery {
-    public var connection: any Connection {
-        return base.connection
-    }
-    
-    public var transactionKind: Transaction.Kind {
-        return base.transactionKind
-    }
-    
-    public var watchedTables: Set<String> {
-        return base.watchedTables
-    }
-    
-    public func execute(
-        with input: Base.Input,
-        tx: borrowing Transaction
-    ) throws -> Output {
-        return try transform(input, base.execute(with: input, tx: tx))
-    }
-}
 
 public extension Query {
     /// Transforms the output of the query.