back to variables

wickwirew · wickwirew · commit 37cc23dee585 · 2025-05-01T21:21:21.000-04:00
diff --git a/Sources/Compiler/Gen/Generator.swift b/Sources/Compiler/Gen/Generator.swift
@@ -88,7 +88,7 @@ extension Language2 {
         }.joined()
         
         return GeneratedQuery(
-            name: "\(name.capitalizedFirst)Query",
+            name: "\(name)Query",
             type: type,
             input: input,
             output: output,
@@ -127,7 +127,7 @@ extension Language2 {
             )
         }
         
-        let inputTypeName = "Input"
+        let inputTypeName = "\(name.capitalizedFirst)Input"
         
         let model = GeneratedModel(
             name: inputTypeName,
@@ -164,7 +164,7 @@ extension Language2 {
             return .builtin(builtinType(for: firstColumn), isArray: firstColumn.isRow)
         }
         
-        let outputTypeName = "Row"
+        let outputTypeName = "\(name.capitalizedFirst)Output"
         
         let model = GeneratedModel(
             name: outputTypeName,
diff --git a/Sources/Compiler/Gen/SwiftLanguage.swift b/Sources/Compiler/Gen/SwiftLanguage.swift
@@ -48,6 +48,14 @@ public struct SwiftLanguage: Language2 {
                 try declaration(for: migrations, options: options)
                 
                 for query in queries {
+                    if case let .model(model) = query.input, !model.isTable {
+                        try declaration(for: model, isOutput: false, options: options)
+                    }
+                    
+                    if case let .model(model) = query.output, !model.isTable {
+                        try declaration(for: model, isOutput: true, options: options)
+                    }
+                    
                     try declaration(for: query, options: options)
                 }
             }
@@ -91,88 +99,68 @@ public struct SwiftLanguage: Language2 {
         for query: GeneratedQuery,
         options: GenerationOptions
     ) throws -> DeclSyntax {
-        let query = try StructDeclSyntax(
-            name: TokenSyntax.identifier(query.name),
-            inheritanceClause: InheritanceClauseSyntax {
-                InheritedTypeSyntax(type: TypeSyntax("DatabaseQuery"))
-            }
-        ) {
-            switch query.input {
-            case .model(let model) where !model.isTable:
-                try declaration(for: model, isOutput: false, options: options)
-            case .some(let type):
-                try typealiasDecl(named: "Input", for: type)
-            case nil:
-                try TypeAliasDeclSyntax("typealias Input = ()")
-            }
-            
-            switch query.output {
-            case .model(let model) where !model.isTable:
-                try declaration(for: model, isOutput: true, options: options)
-                try outputTypeAlias(cardinality: query.outputCardinality)
-            case .some(let type):
-                try typealiasDecl(named: "Row", for: type)
-                try outputTypeAlias(cardinality: query.outputCardinality)
-            case nil:
-                try TypeAliasDeclSyntax("typealias Row = ()")
-                try TypeAliasDeclSyntax("typealias Output = ()")
-            }
-            
-            try VariableDeclSyntax("var transactionKind: Feather.TransactionKind") {
-                query.isReadOnly ? ".read" : ".write"
-            }
-            
-            FunctionDeclSyntax(
-                name: "execute",
-                signature: FunctionSignatureSyntax(
-                    parameterClause: FunctionParameterClauseSyntax(
-                        parameters: [
-                            FunctionParameterSyntax(
-                                firstName: "with",
-                                secondName: "input",
-                                type: IdentifierTypeSyntax(name: "Input"),
-                                trailingComma: TokenSyntax.commaToken()
-                            ),
-                            FunctionParameterSyntax(
-                                firstName: "tx",
-                                type: IdentifierTypeSyntax(name: "borrowing Feather.Transaction")
-                            )
-                        ]
-                    ),
-                    effectSpecifiers: FunctionEffectSpecifiersSyntax(
-                        throwsClause: ThrowsClauseSyntax(
-                            throwsSpecifier: TokenSyntax.keyword(.throws)
-                        )
-                    ),
-                    returnClause: ReturnClauseSyntax(type: IdentifierTypeSyntax(name: "Output"))
-                )
-            ) {
-                let sql = stringLiteral(of: query.sourceSql, multiline: true)
-                let statementBinding: TokenSyntax = .keyword(query.input == nil ? .let : .var)
-                "\(statementBinding) statement = try Feather.Statement(\(sql), \ntransaction: tx\n)"
+        let inputTypeName = inputTypeName(for: query)
+        let outputTypeName = outputTypeName(for: query)
+        let queryTypeName = "DatabaseQuery<\(inputTypeName), \(outputTypeName)>"
+        
+        let query = try VariableDeclSyntax("var \(raw: query.name): \(raw: queryTypeName)") {
+            FunctionCallExprSyntax(
+                calledExpression: DeclReferenceExprSyntax(
+                    baseName: .identifier("DatabaseQueryImpl<\(inputTypeName), \(outputTypeName)>")
+                ),
+                leftParen: .leftParenToken(),
+                arguments: LabeledExprListSyntax {
+                    LabeledExprSyntax(
+                        label: nil,
+                        colon: nil,
+                        expression: DeclReferenceExprSyntax(
+                            baseName: query.isReadOnly ? ".read" : ".write"
+                        ),
+                        trailingComma: TokenSyntax.commaToken()
+                    )
+                    LabeledExprSyntax(
+                        label: TokenSyntax.identifier("database"),
+                        colon: TokenSyntax.colonToken(),
+                        expression: DeclReferenceExprSyntax(baseName: .identifier("database")),
+                        trailingComma: nil
+                    )
+                },
+                rightParen: .rightParenToken(),
+                trailingClosure: ClosureExprSyntax(
+                    signature: ClosureSignatureSyntax(
+                        parameterClause: .simpleInput(.init {
+                            ClosureShorthandParameterSyntax(name: "input")
+                            ClosureShorthandParameterSyntax(name: "transaction")
+                        })
+                    )
+                ) {
+                    let sql = stringLiteral(of: query.sourceSql, multiline: true)
+                    let statementBinding: TokenSyntax = .keyword(query.input == nil ? .let : .var)
+                    "\(statementBinding) statement = try Feather.Statement(\(sql), \ntransaction: tx\n)"
 
-                if let input = query.input {
-                    switch input {
-                    case let .builtin(_, isArray):
-                        bind(field: nil, isArray: isArray)
-                    case .model(let model):
-                        for field in model.fields.values {
-                            bind(field: field.name, isArray: field.isArray)
+                    if let input = query.input {
+                        switch input {
+                        case let .builtin(_, isArray):
+                            bind(field: nil, isArray: isArray)
+                        case .model(let model):
+                            for field in model.fields.values {
+                                bind(field: field.name, isArray: field.isArray)
+                            }
                         }
                     }
-                }
 
-                if query.output == nil {
-                    "_ = try statement.step()"
-                } else {
-                    switch query.outputCardinality {
-                    case .single:
-                        "return try statement.fetchOne(of: Row.self)"
-                    case .many:
-                        "return try statement.fetchMany(of: Row.self)"
+                    if query.output == nil {
+                        "_ = try statement.step()"
+                    } else {
+                        switch query.outputCardinality {
+                        case .single:
+                            "return try statement.fetchOne(of: Row.self)"
+                        case .many:
+                            "return try statement.fetchMany(of: Row.self)"
+                        }
                     }
                 }
-            }
+            )
         }
         
         return DeclSyntax(query)
@@ -187,6 +175,21 @@ public struct SwiftLanguage: Language2 {
         }
     }
     
+    private static func inputTypeName(for query: GeneratedQuery) -> String {
+        return query.input?.description ?? "()"
+    }
+    
+    private static func outputTypeName(for query: GeneratedQuery) -> String {
+        if let output = query.output {
+            switch query.outputCardinality {
+            case .single: "\(output)?"
+            case .many: "[\(output)]"
+            }
+        } else {
+            "()"
+        }
+    }
+    
     private static func declaration(
         for model: GeneratedModel,
         isOutput: Bool,
diff --git a/Sources/Feather/Migration.swift b/Sources/Feather/Migration.swift
@@ -17,9 +17,7 @@ public struct MigrationRunner {
     public static func execute(migrations: [String], tx: borrowing Transaction) throws {
         try createTableIfNeeded(tx: tx)
         
-        let lastMigration = try LastMigrationQuery()
-            .replaceNil(with: 0)
-            .execute(with: (), tx: tx)
+        let lastMigration = try lastMigration(tx: tx)
         
         let pendingMigrations = migrations.enumerated()
             .map { (number: $0.offset + 1, migration: $0.element) }
@@ -41,36 +39,24 @@ public struct MigrationRunner {
     
     static func execute(migration: String, number: Int, tx: borrowing Transaction) throws {
         try tx.execute(sql: migration)
-        try InsertMigrationQuery().execute(with: number, tx: tx)
+        try insertMigration(version: number, tx: tx)
     }
-
-    struct LastMigrationQuery: DatabaseQuery {
-        var transactionKind: TransactionKind { .read }
-        func execute(
-            with _: (),
-            tx: borrowing Transaction
-        ) throws -> Int? {
-            let statement = try Statement(in: tx) {
-                "SELECT MAX(number) FROM \(MigrationRunner.migrationTableName)"
-            }
-            
-            return try statement.fetchOne(of: Int.self)
+    
+    private static func lastMigration(tx: borrowing Transaction) throws -> Int {
+        let statement = try Statement(in: tx) {
+            "SELECT MAX(number) FROM \(MigrationRunner.migrationTableName)"
         }
+        
+        return try statement.fetchOne(of: Int.self) ?? 0
     }
     
-    struct InsertMigrationQuery: DatabaseQuery {
-        var transactionKind: TransactionKind { .write }
-        func execute(
-            with input: Int,
-            tx: borrowing Transaction
-        ) throws {
-            let statement = try Statement(in: tx) {
-                "INSERT INTO \(MigrationRunner.migrationTableName) (number) VALUES (?)"
-            } bind: { statement in
-                try statement.bind(value: input, to: 1)
-            }
-            
-            _ = try statement.step()
+    private static func insertMigration(version: Int, tx: borrowing Transaction) throws {
+        let statement = try Statement(in: tx) {
+            "INSERT INTO \(MigrationRunner.migrationTableName) (number) VALUES (?)"
+        } bind: { statement in
+            try statement.bind(value: version, to: 1)
         }
+        
+        _ = try statement.step()
     }
 }
diff --git a/Sources/Feather/Queries.swift b/Sources/Feather/Queries.swift
@@ -6,46 +6,23 @@
 //
 
 public enum Queries {
-    /// Replaces the `Database` associated type with the input
-    /// resulting in a query with a `Void` database.
-    /// Allows for the erasing of the database so a query can be
-    /// passed around and be able to be executed without
-    /// having the caller worry about by what.
-    public struct WithDatabase<Base: DatabaseQuery>: Query {
-        /// The original query that requires a database
-        let base: Base
-        /// The database to execute the query in
-        let database: any Database
-        
-        public func execute(
-            with input: Base.Input
-        ) async throws -> Base.Output {
-            return try await base.execute(with: input, in: database)
-        }
-        
-        public func observe(with input: Input) -> any QueryObservation<Output> {
-            return base.observe(with: input, in: database)
-        }
-    }
-    
     /// Applies a transform to the queries result
     public struct Map<Base: DatabaseQuery, Output: Sendable>: DatabaseQuery {
+        public typealias Input = Base.Input
+        public typealias Output = Output
         /// The upstream query to transform
         let base: Base
         /// The transform to apply to the output
         let transform: @Sendable (Base.Output) throws -> Output
+        /// The database to execute the query on
+        public var database: any Database {
+            return base.database
+        }
         
         public var transactionKind: TransactionKind {
             return base.transactionKind
         }
         
-        public func execute(
-            with input: Base.Input,
-            in database: any Database
-        ) async throws -> Output {
-            return try await transform(base.execute(with: input, in: database))
-        }
-
         public func execute(
             with input: Base.Input,
             tx: borrowing Transaction
@@ -94,12 +71,15 @@ public enum Queries {
         where First: DatabaseQuery, Second: DatabaseQuery
     {
         public typealias Input = First.Input
+        public typealias Output = (First.Output, Second.Output)
         
         let first: First
         let second: Second
         let secondInput: @Sendable (First.Input, First.Output) -> Second.Input
         
-        public typealias DB = any Database
+        public var database: any Database {
+            return first.database
+        }
         
         public var transactionKind: TransactionKind {
             return max(first.transactionKind, second.transactionKind)
@@ -115,26 +95,9 @@ public enum Queries {
             return (firstOutput, secondOutput)
         }
     }
-    
-    public struct None<Input: Sendable>: DatabaseQuery {
-        public init() {}
-        
-        public var transactionKind: TransactionKind {
-            return .read
-        }
-        
-        public func execute(
-            with input: Input,
-            tx: borrowing Transaction
-        ) throws {}
-    }
 }
 
 public extension DatabaseQuery {
-    func with(database: any Database) -> Queries.WithDatabase<Self> {
-        return Queries.WithDatabase(base: self, database: database)
-    }
-    
     func map<NewOutput>(
         _ transform: @Sendable @escaping (Output) throws -> NewOutput
     ) -> Queries.Map<Self, NewOutput> {
diff --git a/Sources/Feather/Query.swift b/Sources/Feather/Query.swift
@@ -5,9 +5,9 @@
 //  Created by Wes Wickwire on 3/29/25.
 //
 
-public protocol Query<Input, Output> {
-    associatedtype Input
-    associatedtype Output
+public protocol Query<Input, Output>: Sendable {
+    associatedtype Input: Sendable
+    associatedtype Output: Sendable
     
     func execute(with input: Input) async throws -> Output
     
diff --git a/Sources/Feather/QueryObservation.swift b/Sources/Feather/QueryObservation.swift
diff --git a/Sources/Feather/Queryable.swift b/Sources/Feather/Queryable.swift
