Run swift-format on most of the code

Author: gwynne

Sources/FluentPostgresDriver/Deprecations/FluentPostgresConfiguration+Deprecated.swift

@@ -1,9 +1,7 @@
-import Logging
 import FluentKit
-import AsyncKit
-import NIOCore
-import NIOSSL
 import Foundation
+import Logging
+import NIOCore
 import PostgresKit
 import PostgresNIO
 

Sources/FluentPostgresDriver/FluentPostgresConfiguration.swift

@@ -1,9 +1,8 @@
-import Logging
-import FluentKit
 import AsyncKit
-import NIOCore
-import NIOSSL
+import FluentKit
 import Foundation
+import Logging
+import NIOCore
 import PostgresKit
 import PostgresNIO
 
@@ -31,7 +30,8 @@ extension DatabaseConfigurationFactory {
             configuration: try .init(url: urlString),
             maxConnectionsPerEventLoop: maxConnectionsPerEventLoop,
             connectionPoolTimeout: connectionPoolTimeout,
-            encodingContext: encodingContext, decodingContext: decodingContext,
+            encodingContext: encodingContext,
+            decodingContext: decodingContext,
             sqlLogLevel: sqlLogLevel
         )
     }
@@ -59,7 +59,8 @@ extension DatabaseConfigurationFactory {
             configuration: try .init(url: url),
             maxConnectionsPerEventLoop: maxConnectionsPerEventLoop,
             connectionPoolTimeout: connectionPoolTimeout,
-            encodingContext: encodingContext, decodingContext: decodingContext,
+            encodingContext: encodingContext,
+            decodingContext: decodingContext,
             sqlLogLevel: sqlLogLevel
         )
     }
@@ -82,20 +83,21 @@ extension DatabaseConfigurationFactory {
         sqlLogLevel: Logger.Level = .debug
     ) -> DatabaseConfigurationFactory {
         let configuration = FakeSendable(wrappedValue: configuration)
-        
+
         return .init {
             FluentPostgresConfiguration(
                 configuration: configuration,
                 maxConnectionsPerEventLoop: maxConnectionsPerEventLoop,
                 connectionPoolTimeout: connectionPoolTimeout,
-                encodingContext: encodingContext, decodingContext: decodingContext,
+                encodingContext: encodingContext,
+                decodingContext: decodingContext,
                 sqlLogLevel: sqlLogLevel
             )
         }
     }
 }
 
-fileprivate struct FakeSendable<T>: @unchecked Sendable { let wrappedValue: T }
+private struct FakeSendable<T>: @unchecked Sendable { let wrappedValue: T }
 
 /// We'd like to just default the context parameters of the "actual" method. Unfortunately, there are a few
 /// cases involving the UNIX domain socket initalizer where usage can resolve to either the new
@@ -185,7 +187,7 @@ struct FluentPostgresConfiguration<E: PostgresJSONEncoder, D: PostgresJSONDecode
             requestTimeout: self.connectionPoolTimeout,
             on: databases.eventLoopGroup
         )
-        
+
         return _FluentPostgresDriver(
             pool: elgPool,
             encodingContext: self.encodingContext,

Sources/FluentPostgresDriver/FluentPostgresDatabase.swift

@@ -16,23 +16,24 @@ struct _FluentPostgresDatabase<E: PostgresJSONEncoder, D: PostgresJSONDecoder> {
 extension _FluentPostgresDatabase: Database {
     func execute(
         query: DatabaseQuery,
-        onOutput: @escaping @Sendable (any DatabaseOutput) -> ()
+        onOutput: @escaping @Sendable (any DatabaseOutput) -> Void
     ) -> EventLoopFuture<Void> {
         var expression = SQLQueryConverter(delegate: PostgresConverterDelegate()).convert(query)
-        
+
         /// For `.create` query actions, we want to return the generated IDs, unless the `customIDKey` is the
         /// empty string, which we use as a very hacky signal for "we don't implement this for composite IDs yet".
         if case .create = query.action, query.customIDKey != .some(.string("")) {
             expression = SQLKit.SQLList([expression, SQLReturning(.init((query.customIDKey ?? .id).description))], separator: SQLRaw(" "))
         }
-        
+
         return self.execute(sql: expression, { onOutput($0.databaseOutput()) })
     }
 
     func execute(schema: DatabaseSchema) -> EventLoopFuture<Void> {
         let expression = SQLSchemaConverter(delegate: PostgresConverterDelegate()).convert(schema)
 
-        return self.execute(sql: expression,
+        return self.execute(
+            sql: expression,
             // N.B.: Don't fatalError() here; what're users supposed to do about it?
             { self.logger.debug("Unexpected row returned from schema query: \($0)") }
         )
@@ -50,9 +51,11 @@ extension _FluentPostgresDatabase: Database {
                 return self.eventLoop.makeSucceededFuture(())
             }
 
-            return self.eventLoop.flatten(e.createCases.map { create in
-                self.alter(enum: e.name).add(value: create).run()
-            })
+            return self.eventLoop.flatten(
+                e.createCases.map { create in
+                    self.alter(enum: e.name).add(value: create).run()
+                }
+            )
         case .delete:
             return self.drop(enum: e.name).run()
         }
@@ -64,10 +67,12 @@ extension _FluentPostgresDatabase: Database {
         }
         return self.withConnection { conn in
             guard let sqlConn = conn as? any SQLDatabase else {
-                fatalError("""
+                fatalError(
+                    """
                     Connection yielded by a Fluent+Postgres database is not also an SQLDatabase.
                     This is a bug in Fluent; please report it at https://github.com/vapor/fluent-postgres-driver/issues
-                    """)
+                    """
+                )
             }
             return sqlConn.raw("BEGIN").run().flatMap {
                 closure(conn).flatMap { result in
@@ -78,16 +83,22 @@ extension _FluentPostgresDatabase: Database {
             }
         }
     }
-    
+
     func withConnection<T>(_ closure: @escaping @Sendable (any Database) -> EventLoopFuture<T>) -> EventLoopFuture<T> {
         self.withConnection { (underlying: any PostgresDatabase) in
-            closure(_FluentPostgresDatabase(
-                database: underlying.sql(encodingContext: self.encodingContext, decodingContext: self.decodingContext, queryLogLevel: self.database.queryLogLevel),
-                context: self.context,
-                encodingContext: self.encodingContext,
-                decodingContext: self.decodingContext,
-                inTransaction: true
-            ))
+            closure(
+                _FluentPostgresDatabase(
+                    database: underlying.sql(
+                        encodingContext: self.encodingContext,
+                        decodingContext: self.decodingContext,
+                        queryLogLevel: self.database.queryLogLevel
+                    ),
+                    context: self.context,
+                    encodingContext: self.encodingContext,
+                    decodingContext: self.decodingContext,
+                    inTransaction: true
+                )
+            )
         }
     }
 }
@@ -96,11 +107,11 @@ extension _FluentPostgresDatabase: TransactionControlDatabase {
     func beginTransaction() -> EventLoopFuture<Void> {
         self.raw("BEGIN").run()
     }
-    
+
     func commitTransaction() -> EventLoopFuture<Void> {
         self.raw("COMMIT").run()
     }
-    
+
     func rollbackTransaction() -> EventLoopFuture<Void> {
         self.raw("ROLLBACK").run()
     }
@@ -110,15 +121,15 @@ extension _FluentPostgresDatabase: SQLDatabase {
     var version: (any SQLDatabaseReportedVersion)? { self.database.version }
     var dialect: any SQLDialect { self.database.dialect }
     var queryLogLevel: Logger.Level? { self.database.queryLogLevel }
-    
-    func execute(sql query: any SQLExpression, _ onRow: @escaping @Sendable (any SQLRow) -> ()) -> EventLoopFuture<Void> {
+
+    func execute(sql query: any SQLExpression, _ onRow: @escaping @Sendable (any SQLRow) -> Void) -> EventLoopFuture<Void> {
         self.database.execute(sql: query, onRow)
     }
-    
-    func execute(sql query: any SQLExpression, _ onRow: @escaping @Sendable (any SQLRow) -> ()) async throws {
+
+    func execute(sql query: any SQLExpression, _ onRow: @escaping @Sendable (any SQLRow) -> Void) async throws {
         try await self.database.execute(sql: query, onRow)
     }
-    
+
     func withSession<R>(_ closure: @escaping @Sendable (any SQLDatabase) async throws -> R) async throws -> R {
         try await self.database.withSession(closure)
     }
@@ -128,15 +139,17 @@ extension _FluentPostgresDatabase: PostgresDatabase {
     func send(_ request: any PostgresRequest, logger: Logger) -> EventLoopFuture<Void> {
         self.withConnection { $0.send(request, logger: logger) }
     }
-    
+
     func withConnection<T>(_ closure: @escaping (PostgresConnection) -> EventLoopFuture<T>) -> EventLoopFuture<T> {
         guard let psqlDb: any PostgresDatabase = self.database as? any PostgresDatabase else {
-            fatalError("""
+            fatalError(
+                """
                 Connection yielded by a Fluent+Postgres database is not also a PostgresDatabase.
                 This is a bug in Fluent; please report it at https://github.com/vapor/fluent-postgres-driver/issues
-                """)
+                """
+            )
         }
-        
+
         return psqlDb.withConnection(closure)
     }
 }

Sources/FluentPostgresDriver/FluentPostgresDriver.swift

@@ -1,7 +1,7 @@
 import AsyncKit
-import NIOCore
-import Logging
 import FluentKit
+import Logging
+import NIOCore
 import PostgresKit
 
 /// Marked `@unchecked Sendable` to silence warning about `PostgresConnectionSource`
@@ -10,7 +10,7 @@ struct _FluentPostgresDriver<E: PostgresJSONEncoder, D: PostgresJSONDecoder>: Da
     let encodingContext: PostgresEncodingContext<E>
     let decodingContext: PostgresDecodingContext<D>
     let sqlLogLevel: Logger.Level
-    
+
     func makeDatabase(with context: DatabaseContext) -> any Database {
         _FluentPostgresDatabase(
             database: self.pool
@@ -23,11 +23,11 @@ struct _FluentPostgresDriver<E: PostgresJSONEncoder, D: PostgresJSONDecoder>: Da
             inTransaction: false
         )
     }
-    
+
     func shutdown() {
         try? self.pool.syncShutdownGracefully()
     }
-    
+
     func shutdownAsync() async {
         try? await self.pool.shutdownAsync()
     }

Sources/FluentPostgresDriver/PostgresConverterDelegate.swift

@@ -6,50 +6,50 @@ struct PostgresConverterDelegate: SQLConverterDelegate {
     func customDataType(_ dataType: DatabaseSchema.DataType) -> (any SQLExpression)? {
         switch dataType {
         case .uuid:
-            return SQLRaw("UUID")
+            SQLRaw("UUID")
         case .bool:
-            return SQLRaw("BOOL")
+            SQLRaw("BOOL")
         case .data:
-            return SQLRaw("BYTEA")
+            SQLRaw("BYTEA")
         case .date:
-            return SQLRaw("DATE")
+            SQLRaw("DATE")
         case .datetime:
-            return SQLRaw("TIMESTAMPTZ")
+            SQLRaw("TIMESTAMPTZ")
         case .double:
-            return SQLRaw("DOUBLE PRECISION")
+            SQLRaw("DOUBLE PRECISION")
         case .dictionary:
-            return SQLRaw("JSONB")
+            SQLRaw("JSONB")
         case .array(of: let type):
             if let type = type, let dataType = self.customDataType(type) {
-                return SQLArrayDataType(dataType: dataType)
+                SQLArrayDataType(dataType: dataType)
             } else {
-                return SQLRaw("JSONB")
+                SQLRaw("JSONB")
             }
         case .enum(let value):
-            return SQLIdentifier(value.name)
+            SQLIdentifier(value.name)
         case .int8, .uint8:
-            return SQLIdentifier("char")
+            SQLIdentifier("char")
         case .int16, .uint16:
-            return SQLRaw("SMALLINT")
+            SQLRaw("SMALLINT")
         case .int32, .uint32:
-            return SQLRaw("INT")
+            SQLRaw("INT")
         case .int64, .uint64:
-            return SQLRaw("BIGINT")
+            SQLRaw("BIGINT")
         case .string:
-            return SQLRaw("TEXT")
+            SQLRaw("TEXT")
         case .time:
-            return SQLRaw("TIME")
+            SQLRaw("TIME")
         case .float:
-            return SQLRaw("FLOAT")
+            SQLRaw("FLOAT")
         case .custom:
-            return nil
+            nil
         }
     }
 }
 
 private struct SQLArrayDataType: SQLExpression {
     let dataType: any SQLExpression
-    
+
     func serialize(to serializer: inout SQLSerializer) {
         self.dataType.serialize(to: &serializer)
         serializer.write("[]")