fix: Use async configuration and run on main queue (#28)

* fix: Build docker image for Swift 5.8

* Update ci.yml

* Update ci.yml

* feat: use async configuration

* Update ci.yml

Author: cbaker6

Dockerfile

@@ -29,7 +29,7 @@ RUN swift build -c release --static-swift-stdlib
 WORKDIR /staging
 
 # Copy main executable to staging area
-RUN cp "$(swift build --package-path /build -c release --show-bin-path)/Run" ./
+RUN cp "$(swift build --package-path /build -c release --show-bin-path)/App" ./
 
 # Copy resources bundled by SPM to staging area
 RUN find -L "$(swift build --package-path /build -c release --show-bin-path)/" -regex '.*\.resources$' -exec cp -Ra {} ./ \;
@@ -72,5 +72,5 @@ USER vapor:vapor
 EXPOSE 8081
 
 # Start the Vapor service when the image is run, default to listening on 8081 in production environment
-ENTRYPOINT ["./Run"]
+ENTRYPOINT ["./App"]
 CMD ["serve", "--env", "production", "--hostname", "0.0.0.0", "--port", "8081"]

Package.resolved

@@ -41,8 +41,8 @@
       "kind" : "remoteSourceControl",
       "location" : "https://github.com/netreconlab/Parse-Swift.git",
       "state" : {
-        "revision" : "7a0540c9a1f7a2d60f52c50a09b1e8911a7d9ad5",
-        "version" : "5.5.0"
+        "revision" : "8e8a84725ed69fe6ec1302f3d9d18018deb0b914",
+        "version" : "5.5.1"
       }
     },
     {

Package.swift

@@ -16,7 +16,7 @@ let package = Package(
     dependencies: [
         .package(url: "https://github.com/vapor/vapor.git", .upToNextMajor(from: "4.76.0")),
         .package(url: "https://github.com/netreconlab/Parse-Swift.git",
-                 .upToNextMajor(from: "5.5.0")),
+                 .upToNextMajor(from: "5.5.1")),
     ],
     targets: [
         .target(
@@ -25,7 +25,7 @@ let package = Package(
                 .product(name: "Vapor", package: "vapor"),
                 .product(name: "ParseSwift", package: "Parse-Swift")
             ]),
-        .executableTarget(name: "Run",
+        .executableTarget(name: "App",
                           dependencies: [.target(name: "ParseServerSwift")],
                           swiftSettings: [
                               // Enable better optimizations when building in Release configuration. Despite the use of

Sources/App/entrypoint.swift

@@ -0,0 +1,43 @@
+//
+//  entrypoint.swift
+//  
+//
+//  Created by Corey Baker on 5/11/23.
+//
+
+import Vapor
+import Dispatch
+import Logging
+import ParseServerSwift
+
+/// This extension is temporary and can be removed once Vapor gets this support.
+private extension Vapor.Application {
+    static let baseExecutionQueue = DispatchQueue(label: "vapor.codes.entrypoint")
+    
+    func runFromAsyncMainEntrypoint() async throws {
+        try await withCheckedThrowingContinuation { continuation in
+            Vapor.Application.baseExecutionQueue.async { [self] in
+                do {
+                    try self.run()
+                    continuation.resume()
+                } catch {
+                    continuation.resume(throwing: error)
+                }
+            }
+        }
+    }
+}
+
+@main
+enum Entrypoint {
+    static func main() async throws {
+        var env = try Environment.detect()
+        try LoggingSystem.bootstrap(from: &env)
+        
+        let app = Application(env)
+        defer { app.shutdown() }
+        
+        try await configure(app)
+        try await app.runFromAsyncMainEntrypoint()
+    }
+}

Sources/ParseServerSwift/ParseServer.swift renamed to Sources/ParseServerSwift/Parse.swift

@@ -10,13 +10,13 @@ import ParseSwift
 
 // MARK: Internal
 
-internal struct ParseServer {
+internal struct Parse {
     static var configuration: ParseServerConfiguration!
 }
 
 /// The current `ParseServerConfiguration` for ParseServerSwift.
 public var configuration: ParseServerConfiguration {
-    ParseServer.configuration
+    Parse.configuration
 }
 
 /**
@@ -31,20 +31,20 @@ public var configuration: ParseServerConfiguration {
  - warning: Be sure to call this method before calling `try routes(app)`.
  */
 public func initialize(_ configuration: ParseServerConfiguration,
-                       app: Application) throws {
-    try initializeServer(configuration, app: app)
+                       app: Application) async throws {
+    try await initializeServer(configuration, app: app)
 }
 
 func initialize(_ configuration: ParseServerConfiguration,
                        app: Application,
-                       testing: Bool) throws {
+                       testing: Bool) async throws {
     var configuration = configuration
     configuration.isTesting = testing
-    try initialize(configuration, app: app)
+    try await initialize(configuration, app: app)
 }
 
 func initializeServer(_ configuration: ParseServerConfiguration,
-                      app: Application) throws {
+                      app: Application) async throws {
 
     // Parse uses tailored encoders/decoders. These can be retrieved from any ParseObject
     ContentConfiguration.global.use(encoder: User.getJSONEncoder(), for: .json)
@@ -57,26 +57,24 @@ func initializeServer(_ configuration: ParseServerConfiguration,
 
     if !configuration.isTesting {
         try setConfiguration(configuration)
-        Task {
-            do {
-                // Initialize the Parse-Swift SDK. Add any additional parameters you need
-                try await ParseSwift.initialize(applicationId: configuration.applicationId,
-                                                primaryKey: configuration.primaryKey,
-                                                serverURL: parseServerURL,
-                                                // POST all queries instead of using GET.
-                                                usingPostForQuery: true,
-                                                // Do not use cache for anything.
-                                                requestCachePolicy: .reloadIgnoringLocalCacheData) { _, completionHandler in
-                    // Setup to use default certificate pinning. See Parse-Swift docs for more info
-                    completionHandler(.performDefaultHandling, nil)
-                }
-                // Check the health of all Parse-Server
-                try await checkServerHealth()
-            } catch {
-                app.shutdown()
+        do {
+            // Initialize the Parse-Swift SDK. Add any additional parameters you need
+            try await ParseSwift.initialize(applicationId: configuration.applicationId,
+                                            primaryKey: configuration.primaryKey,
+                                            serverURL: parseServerURL,
+                                            // POST all queries instead of using GET.
+                                            usingPostForQuery: true,
+                                            // Do not use cache for anything.
+                                            requestCachePolicy: .reloadIgnoringLocalCacheData) { _, completionHandler in
+                // Setup to use default certificate pinning. See Parse-Swift docs for more info
+                completionHandler(.performDefaultHandling, nil)
             }
+            // Check the health of all Parse-Server
+            try await checkServerHealth()
+        } catch {
+            app.shutdown()
         }
     } else {
-        ParseServer.configuration = configuration
+        Parse.configuration = configuration
     }
 }

Sources/ParseServerSwift/Utility/Functions.swift

@@ -20,11 +20,11 @@ import Vapor
  if the configuration is already set.
  */
 public func setConfiguration(_ configuration: ParseServerConfiguration) throws {
-    guard ParseServer.configuration == nil else {
+    guard Parse.configuration == nil else {
         throw ParseError(code: .otherCause,
                          message: "The configuration has already been initialized")
     }
-    ParseServer.configuration = configuration
+    Parse.configuration = configuration
 }
 
 /**
@@ -79,7 +79,7 @@ public func buildServerPathname(_ path: [PathComponent]) throws -> URL {
 public func checkServerHealth() async throws {
     for parseServerURLString in configuration.parseServerURLStrings {
         do {
-            let serverHealth = try await ParseHealth.check(options: [.serverURL(parseServerURLString)])
+            let serverHealth = try await ParseServer.health(options: [.serverURL(parseServerURLString)])
             configuration.logger.notice("Parse Server (\(parseServerURLString)) health is \"\(serverHealth)\"")
         } catch {
             configuration.logger.error("Could not connect to Parse Server (\(parseServerURLString)): \(error)")

Sources/ParseServerSwift/configure.swift

@@ -1,9 +1,9 @@
 import Vapor
 
-public func configure(_ app: Application) throws {
+public func configure(_ app: Application) async throws {
     // Initialize ParseServerSwift
     let configuration = try ParseServerConfiguration(app: app)
-    try ParseServerSwift.initialize(configuration, app: app)
+    try await ParseServerSwift.initialize(configuration, app: app)
 
     // register routes
     try routes(app)

Sources/Run/main.swift

@@ -18,7 +18,7 @@ final class AppTests: XCTestCase {
                                                          primaryKey: "primaryKey",
                                                          webhookKey: hookKey,
                                                          parseServerURLString: "primaryKey")
-        try ParseServerSwift.initialize(configuration, app: app, testing: true)
+        try await ParseServerSwift.initialize(configuration, app: app, testing: true)
         guard let parseServerURL = URL(string: configuration.primaryParseServerURLString) else {
             throw ParseError(code: .otherCause,
                              message: "Could not make a URL from the Parse Server string")
@@ -167,15 +167,15 @@ final class AppTests: XCTestCase {
         let serverString2 = try serverURLString(uri2, parseServerURLStrings: [urlString])
         XCTAssertEqual(serverString2, urlString)
 
-        ParseServer.configuration.parseServerURLStrings = ["http://localhost:1337/parse"]
+        Parse.configuration.parseServerURLStrings = ["http://localhost:1337/parse"]
         let serverString3 = try serverURLString(uri,
                                                 parseServerURLStrings: configuration.parseServerURLStrings)
         XCTAssertEqual(serverString3, configuration.parseServerURLStrings.first)
     }
 
     func testMatchServerURLStringThrowsError() async throws {
         let app = try await setupAppForTesting()
-        ParseServer.configuration.parseServerURLStrings.removeAll()
+        Parse.configuration.parseServerURLStrings.removeAll()
         defer { app.shutdown() }
         let urlString = "https://parse.com/parse"
         let uri = URI(stringLiteral: urlString)
@@ -188,7 +188,7 @@ final class AppTests: XCTestCase {
         defer { app.shutdown() }
         let installationId = "naw"
         let urlString = "https://parse.com/parse"
-        ParseServer.configuration.parseServerURLStrings.append(urlString)
+        Parse.configuration.parseServerURLStrings.append(urlString)
         let dummyHookRequest = DummyRequest(installationId: installationId, params: .init())
         let encoded = try User.getJSONEncoder().encode(dummyHookRequest)
         let hookRequest = try User.getDecoder().decode(ParseHookFunctionRequest<User, FooParameters>.self,