Generate through swift macro

Author: wickwirew

Package.resolved

@@ -19,7 +19,7 @@ let package = Package(
         ),
     ],
     dependencies: [
-        .package(url: "https://github.com/apple/swift-syntax.git", from: "600.0.1"),
+        .package(url: "https://github.com/apple/swift-syntax.git", from: "601.0.1"),
         .package(url: "https://github.com/apple/swift-collections", from: "1.1.4"),
         .package(url: "https://github.com/apple/swift-argument-parser", from: "1.5.0"),
     ],

Package.swift

@@ -46,6 +46,39 @@ public struct Compiler {
         return diagnostics
     }
 
+    public mutating func compile(
+        query: String,
+        named name: String,
+        inputType: String?,
+        outputType: String?,
+        namespace: Namespace
+    ) -> Diagnostics {
+        var (stmts, diagnostics) = compile(
+            source: query,
+            validator: IsValidForQueries(),
+            context: "queries"
+        )
+        
+        guard let stmt = stmts.first else {
+            let loc = SourceLocation(range: query.startIndex..<query.endIndex, line: 0, column: 0)
+            diagnostics.add(.init("Query has no statements", at: loc))
+            self.diagnostics[namespace] = diagnostics
+            return diagnostics
+        }
+        
+        let stmtWithDef = stmt.with(
+            definition: Definition(
+                name: name[...],
+                input: inputType?[...],
+                output: outputType?[...]
+            )
+        )
+        
+        self.queries.append(stmtWithDef)
+        self.diagnostics[namespace] = diagnostics
+        return diagnostics
+    }
+    
     mutating func compile<Validator>(
         source: String,
         validator: Validator,

Sources/Compiler/Compiler.swift

@@ -41,6 +41,12 @@ public struct Diagnostic: Error {
     }
 }
 
+extension Diagnostic: CustomStringConvertible {
+    public var description: String {
+        return message
+    }
+}
+
 extension Diagnostic {
     static func incorrectType(
         _ actual: TypeNameSyntax,

Sources/Compiler/Diagnostic.swift

@@ -56,7 +56,13 @@ public struct Diagnostics {
 }
 
 extension Diagnostics: Sequence {
-    public func makeIterator() -> some IteratorProtocol {
+    public func makeIterator() -> [Diagnostic].Iterator {
         return elements.makeIterator()
     }
 }
+
+extension Diagnostics: ExpressibleByArrayLiteral {
+    public init(arrayLiteral elements: Diagnostic...) {
+        self = Diagnostics(diagnostics: elements)
+    }
+}

Sources/Compiler/Diagnostics.swift

@@ -13,13 +13,6 @@ public protocol Language {
     /// Returns the Language builtin for the given SQL type
     static func builtinType(for type: Type) -> String
 
-    /// The query type name with the given cardinality, input and output
-    static func queryType(
-        for cardinality: Cardinality?,
-        input: BuiltinOrGenerated?,
-        output: BuiltinOrGenerated?
-    ) -> String
-    
     /// A file source code containing all of the generated tables, queries and migrations.
     static func file(
         databaseName: String,
@@ -48,18 +41,29 @@ extension Language {
         schema: Schema,
         options: GenerationOptions
     ) throws -> String {
-        let tables = schema.mapValues(model(for:))
-        let queries = queries.map { query(for: $0, tables: tables) }
+        let values = try assemble(queries: queries, schema: schema)
 
         return try file(
             databaseName: databaseName,
             migrations: migrations,
-            tables: Array(tables.values),
-            queries: queries,
+            tables: values.tables,
+            queries: values.queries,
             options: options
         )
     }
 
+    public static func assemble(
+        queries: [Statement],
+        schema: Schema
+    ) throws -> (
+        tables: [GeneratedModel],
+        queries: [GeneratedQuery]
+    ) {
+        let tables = schema.mapValues(model(for:))
+        let queries = queries.map { query(for: $0, tables: tables) }
+        return (Array(tables.values), queries)
+    }
+    
     private static func query(
         for statement: Statement,
         tables: OrderedDictionary<Substring, GeneratedModel>
@@ -71,12 +75,6 @@ extension Language {
         let input = inputTypeIfNeeded(statement: statement, definition: definition)
         let output = outputTypeIfNeeded(statement: statement, definition: definition, tables: tables)
 
-        let type = queryType(
-            for: statement.noOutput ? nil : statement.outputCardinality,
-            input: input,
-            output: output
-        )
-        
         // Join the source segments together inserting the code to assemble the
         // question marks for any input.
         let sql = statement.sourceSegments.map { segment in
@@ -92,7 +90,6 @@ extension Language {
 
         return GeneratedQuery(
             name: "\(definition.name)Query",
-            type: type,
             input: input,
             output: output,
             outputCardinality: statement.outputCardinality,
@@ -260,7 +257,6 @@ public struct GeneratedField {
 
 public struct GeneratedQuery {
     let name: String
-    let type: String
     let input: BuiltinOrGenerated?
     let output: BuiltinOrGenerated?
     let outputCardinality: Cardinality

Sources/Compiler/Gen/Language.swift

@@ -82,6 +82,37 @@ public struct SwiftLanguage: Language {
         return file.formatted().description
     }
 
+    public static func macro(
+        databaseName: String,
+        tables: [GeneratedModel],
+        queries: [GeneratedQuery],
+        options: GenerationOptions,
+        addConnection: Bool
+    ) throws -> [DeclSyntax] {
+        var decls: [DeclSyntax] = []
+        
+        if addConnection {
+            decls.append("let connection: any Feather.Connection")
+        }
+        
+        for table in tables {
+            try decls.append(declaration(for: table, isOutput: true, options: options))
+        }
+        
+        // Always do this at the top level since it will automatically namespaced under the
+        // struct that the macro is attached too.
+        for query in queries {
+            try decls.append(contentsOf: modelsFor(query: query, options: options))
+            try decls.append(declaration(for: query, underscoreName: true, databaseName: databaseName, options: options))
+            try decls.append(DeclSyntax(dbTypealiasFor(query: query, databaseName: databaseName, options: options)))
+            try decls.append(DeclSyntax(typealiasFor(query: query, databaseName: databaseName, options: options)))
+        }
+        
+        // TODO: Generate extensions if this can be done.
+        
+        return decls
+    }
+    
     private static func modelsFor(
         query: GeneratedQuery,
         options: GenerationOptions
@@ -98,22 +129,7 @@ public struct SwiftLanguage: Language {
 
         return decls
     }
-    
-    public static func queryType(
-        for cardinality: Cardinality?,
-        input: BuiltinOrGenerated?,
-        output: BuiltinOrGenerated?
-    ) -> String {
-        let input = input?.description ?? "()"
-        let output = output?.description ?? "()"
-        
-        return switch cardinality {
-        case .single: "FetchSingleQuery<\(input), \(output)>"
-        case .many: "FetchManyQuery<\(input), \(output)>"
-        default: "VoidQuery<\(input)>"
-        }
-    }
-    
+
     private static func declaration(
         for migrations: [String],
         options: GenerationOptions
@@ -132,14 +148,16 @@ public struct SwiftLanguage: Language {
 
     private static func declaration(
         for query: GeneratedQuery,
+        underscoreName: Bool = false,
         databaseName: String,
         options: GenerationOptions
     ) throws -> DeclSyntax {
         let inputTypeName = inputTypeName(for: query, databaseName: databaseName)
         let outputTypeName = outputTypeName(for: query, databaseName: databaseName)
         let queryTypeName = "AnyDatabaseQuery<\(inputTypeName), \(outputTypeName)>"
+        let variableName = underscoreName ? "_\(query.name)" : query.name
 
-        let query = try VariableDeclSyntax("var \(raw: query.name): \(raw: queryTypeName)") {
+        let query = try VariableDeclSyntax("var \(raw: variableName): \(raw: queryTypeName)") {
             FunctionCallExprSyntax(
                 calledExpression: DeclReferenceExprSyntax(
                     baseName: .identifier("AnyDatabaseQuery<\(inputTypeName), \(outputTypeName)>")
@@ -215,6 +233,20 @@ public struct SwiftLanguage: Language {
         )
     }
 
+    private static func dbTypealiasFor(
+        query: GeneratedQuery,
+        databaseName: String,
+        options: GenerationOptions
+    ) throws -> TypeAliasDeclSyntax {
+        let namespace = options.contains(.namespaceGeneratedModels)
+        let inputTypeName = inputTypeName(for: query, namespaced: namespace, databaseName: databaseName)
+        let outputTypeName = outputTypeName(for: query, namespaced: namespace, databaseName: databaseName)
+        let name = query.name.capitalizedFirst.replacingOccurrences(of: "Query", with: "DatabaseQuery")
+        return try TypeAliasDeclSyntax(
+            "typealias \(raw: name) = AnyDatabaseQuery<\(raw: inputTypeName), \(raw: outputTypeName)>"
+        )
+    }
+    
     private static func inputExtension(
         for query: GeneratedQuery,
         input: GeneratedModel,

Sources/Compiler/Gen/SwiftLanguage.swift

@@ -1,14 +1,10 @@
-
-@freestanding(declaration, names: arbitrary)
-public macro schema(_ source: [String: String]) = #externalMacro(module: "FeatherMacros", type: "SchemaMacro")
-
-@freestanding(expression)
-public macro query(_ source: String) = #externalMacro(module: "FeatherMacros", type: "QueryMacro")
-
 @attached(member, names: arbitrary)
-public macro Schema() = #externalMacro(module: "FeatherMacros", type: "DatabaseMacro")
-
-public protocol Schema {
-    static var queries: [String] { get }
-    static var migrations: [String] { get }
-}
+@attached(extension, conformances: Database)
+public macro Database() = #externalMacro(module: "FeatherMacros", type: "DatabaseMacro")
+
+@attached(accessor)
+public macro Query(
+    _ source: String,
+    inputName: String? = nil,
+    oututName: String? = nil
+) = #externalMacro(module: "FeatherMacros", type: "QueryMacro")

Sources/Feather/Macros.swift

@@ -0,0 +1,88 @@
+//
+//  DatabaseMacro.swift
+//  Feather
+//
+//  Created by Wes Wickwire on 5/10/25.
+//
+
+import Compiler
+import SwiftCompilerPlugin
+import SwiftDiagnostics
+import SwiftSyntax
+import SwiftSyntaxBuilder
+import SwiftSyntaxMacros
+
+public struct DatabaseMacro {}
+
+extension DatabaseMacro: MemberMacro {
+    public static func expansion(
+        of node: AttributeSyntax,
+        providingMembersOf declaration: some DeclGroupSyntax,
+        conformingTo protocols: [TypeSyntax],
+        in context: some MacroExpansionContext
+    ) throws -> [DeclSyntax] {
+        guard let structDecl = declaration.as(StructDeclSyntax.self) else {
+            context.addDiagnostics(from: SyntaxError("@Database can only be applied to a struct"), node: declaration)
+            return []
+        }
+        
+        let variables = declaration.memberBlock.variableDecls()
+        
+        guard let migrations = variables["migrations"]?.asMigrationsArray(in: context) else {
+            context.addDiagnostics(from: SyntaxError("Unable to resolve migrations"), node: node)
+            return []
+        }
+        
+        var compiler = Compiler()
+        
+        for (migration, expr) in migrations {
+            for diag in compiler.compile(migration: migration, namespace: .global) {
+                context.addDiagnostics(from: diag, node: expr)
+            }
+        }
+        
+        for (name, variable) in variables {
+            guard let queryMacro = variable.queryMacroInputsIfIsQuery(in: context) else { continue }
+            
+            for diag in compiler.compile(
+                query: queryMacro.source,
+                named: name.removingQuerySuffix(),
+                inputType: queryMacro.inputName,
+                outputType: queryMacro.outputName,
+                namespace: .global
+            ) {
+                context.addDiagnostics(from: diag, node: variable)
+            }
+        }
+        
+        let (generatedTables, generatedQueries) = try SwiftLanguage.assemble(
+            queries: compiler.queries,
+            schema: compiler.schema
+        )
+        
+        return try SwiftLanguage.macro(
+            databaseName: structDecl.name.text,
+            tables: generatedTables,
+            queries: generatedQueries,
+            options: [],
+            addConnection: variables["connection"] == nil
+        )
+    }
+}
+
+extension DatabaseMacro: ExtensionMacro {
+    public static func expansion(
+        of node: AttributeSyntax,
+        attachedTo declaration: some DeclGroupSyntax,
+        providingExtensionsOf type: some TypeSyntaxProtocol,
+        conformingTo protocols: [TypeSyntax],
+        in context: some MacroExpansionContext
+    ) throws -> [ExtensionDeclSyntax] {
+        guard !protocols.isEmpty else { return [] }
+        
+        let decl: DeclSyntax = """
+        extension \(raw: type.trimmedDescription): Feather.Database {}
+        """
+        return [decl.cast(ExtensionDeclSyntax.self)]
+    }
+}