Merge pull request #11 from 1711-Games/upgrade-5.9

Upgrade to 5.9

Package.swift

@@ -1,4 +1,4 @@
-// swift-tools-version:5.5
+// swift-tools-version:5.9
 
 import PackageDescription
 
@@ -24,7 +24,6 @@ let package = Package(
 
         // used by LGNP
         .package(url: "https://github.com/apple/swift-crypto.git", from: "1.1.7"),
-        .package(name: "Gzip", url: "https://github.com/1024jp/GzipSwift.git", from: "5.1.1"),
     ],
     targets: [
         .target(
@@ -40,7 +39,6 @@ let package = Package(
             name: "LGNP",
             dependencies: [
                 "LGNCore",
-                "Gzip",
                 .product(name: "Crypto", package: "swift-crypto"),
             ],
             exclude: ["README.md", "logo.png"]

Sources/LGNC/Contracts/Contract.swift

@@ -3,8 +3,11 @@ import LGNLog
 import Entita
 import NIO
 
-/// A type erased yet more concrete contract than `AnyContract`, as it defines `Request`, `Response` and other dynamic stuff
-public protocol Contract: AnyContract {
+public typealias Meta = LGNC.Entity.Meta
+public typealias CanonicalCompositeRequest = Swift.Result<Entity, Error>
+public typealias CanonicalStructuredContractResponse = (response: Entity, meta: Meta)
+
+public protocol Contract {
     /// Request type of contract
     associatedtype Request: ContractEntity
 
@@ -14,6 +17,39 @@ public protocol Contract: AnyContract {
     /// Service to which current contract belongs to
     associatedtype ParentService: Service
 
+    /// Canonical form of contract body (guarantee) type
+    typealias CanonicalGuaranteeBody = (CanonicalCompositeRequest) async throws -> ContractExecutionResult
+
+    /// URI of contract, must be unique for service
+    static var URI: String { get }
+
+    /// Indicates whether contract can be invoked with HTTP GET method (and respective GET params)
+    static var isGETSafe: Bool { get }
+
+    /// Allowed transports for contract, must not be empty
+    static var transports: [LGNCore.Transport] { get }
+
+    /// Preferred transport to be used by client if no transport is provided, see default implementation
+    static var preferredTransport: LGNCore.Transport { get }
+
+    /// Allowed content types of request for contract, must not be empty
+    static var contentTypes: [LGNCore.ContentType] { get }
+
+    /// Preferred content type of request for contract, see default implementation
+    static var preferredContentType: LGNCore.ContentType { get }
+
+    /// Indicates whether this contract returns response in structured form (i.e. an API contract in JSON/MsgPack format)
+    static var isResponseStructured: Bool { get }
+
+    /// A computed property returning `true` if contract is guaranteed
+    static var isGuaranteed: Bool { get }
+
+    /// Contract guarantee closure body (must not be set directly)
+    static var _guaranteeBody: Optional<Self.CanonicalGuaranteeBody> { get set }
+
+    /// An internal method for invoking contract with given raw dict (context is available via `LGNCore.Context.current`), not to be used directly
+    static func _invoke(with dict: Entita.Dict) async throws -> ContractExecutionResult
+
     /// Executes current contract on remote node at given address with given request
     static func executeReturningMeta(
         at address: LGNCore.Address,
@@ -32,6 +68,50 @@ public protocol Contract: AnyContract {
 }
 
 public extension Contract {
+    static var isResponseStructured: Bool {
+        true
+    }
+
+    static var isWebSocketTransportAvailable: Bool {
+        self.transports.contains(.WebSocket)
+    }
+
+    static var isWebSocketOnly: Bool {
+        self.transports == [.WebSocket]
+    }
+
+    static var isGETSafe: Bool { false }
+
+    static var preferredTransport: LGNCore.Transport {
+        guard self.transports.count > 0 else {
+            Logger.current.error("Empty transports in contract \(Self.self), returning .LGNS")
+            return .LGNS
+        }
+
+        if self.transports.contains(.LGNS) {
+            return .LGNS
+        }
+
+        return .HTTP
+    }
+
+    static var preferredContentType: LGNCore.ContentType {
+        guard self.transports.count > 0 else {
+            Logger.current.error("Empty content-types in contract \(Self.self), returning .JSON")
+            return .JSON
+        }
+
+        if Self.preferredTransport == .LGNS && self.contentTypes.contains(.MsgPack) {
+            return .MsgPack
+        }
+
+        return .JSON
+    }
+
+    static var isGuaranteed: Bool {
+        self._guaranteeBody != nil
+    }
+
     static func _invoke(with dict: Entita.Dict) async throws -> ContractExecutionResult {
         guard let guaranteeBody = self._guaranteeBody else {
             throw LGNC.E.ControllerError("No guarantee closure for contract '\(self.URI)'")

Sources/LGNC/HTTP/HTTP+AnyServer.swift

@@ -9,7 +9,7 @@ import NIOHTTP1
 import AsyncHTTPClient
 
 public extension LGNC.HTTP {
-    class Server: AnyServer, @unchecked Sendable {
+    class Server: LGNCoreServer, @unchecked Sendable {
         private let readTimeout: TimeAmount
         private let writeTimeout: TimeAmount
 

Sources/LGNC/LGNC.swift

@@ -6,6 +6,8 @@ import LGNP
 import LGNS
 import NIO
 
+public typealias Server = LGNCoreServer
+
 public enum LGNC {
     public static let VERSION = "0.9.9.9"
 
@@ -64,7 +66,7 @@ public enum LGNC {
         eventLoopGroup: EventLoopGroup = MultiThreadedEventLoopGroup(numberOfThreads: System.coreCount),
         readTimeout: TimeAmount = .minutes(1),
         writeTimeout: TimeAmount = .minutes(1)
-    ) async throws -> AnyServer {
+    ) async throws -> some Server {
         try await S.startServerHTTP(
             at: target,
             eventLoopGroup: eventLoopGroup,
@@ -82,7 +84,7 @@ public enum LGNC {
         requiredBitmask: LGNP.Message.ControlBitmask = .defaultValues,
         readTimeout: TimeAmount = .seconds(1),
         writeTimeout: TimeAmount = .seconds(1)
-    ) async throws -> AnyServer {
+    ) async throws -> some Server {
         try await S.startServerLGNS(
             at: target,
             cryptor: cryptor,

Sources/LGNC/Server/Server+HTTP.swift

@@ -25,7 +25,7 @@ public extension Service {
         webSocketRouter: WebsocketRouter.Type? = nil,
         readTimeout: TimeAmount = .minutes(1),
         writeTimeout: TimeAmount = .minutes(1)
-    ) throws -> AnyServer {
+    ) throws -> some Server {
         try self.validate(transport: .HTTP)
         try self.checkGuarantees()
 
@@ -184,8 +184,8 @@ public extension Service {
         eventLoopGroup: EventLoopGroup = MultiThreadedEventLoopGroup(numberOfThreads: System.coreCount),
         readTimeout: TimeAmount = .minutes(1),
         writeTimeout: TimeAmount = .minutes(1)
-    ) async throws -> AnyServer {
-        let server: AnyServer = try self.getServerHTTP(
+    ) async throws -> some Server {
+        let server: some Server = try self.getServerHTTP(
             at: target,
             eventLoopGroup: eventLoopGroup,
             readTimeout: readTimeout,

Sources/LGNC/Server/Server+LGNS.swift

@@ -42,7 +42,7 @@ public extension Service {
         requiredBitmask: LGNP.Message.ControlBitmask = .defaultValues,
         readTimeout: TimeAmount = .minutes(1),
         writeTimeout: TimeAmount = .minutes(1)
-    ) throws -> AnyServer {
+    ) throws -> some Server {
         try self.validateContract(requiredBitmask: requiredBitmask)
 
         return LGNS.Server(
@@ -63,8 +63,8 @@ public extension Service {
         requiredBitmask: LGNP.Message.ControlBitmask = .defaultValues,
         readTimeout: TimeAmount = .seconds(1),
         writeTimeout: TimeAmount = .seconds(1)
-    ) async throws -> AnyServer {
-        let server: AnyServer = try self.getServerLGNS(
+    ) async throws -> some Server {
+        let server: some Server = try self.getServerLGNS(
             at: target,
             cryptor: cryptor,
             eventLoopGroup: eventLoopGroup,

Sources/LGNC/Service.swift

@@ -5,13 +5,12 @@ import LGNLog
 import LGNP
 import LGNS
 
-/// A type-erased service
 public protocol Service {
     /// A storage for all keydictionaries of requests and responses of all contracts
     static var keyDictionary: [String: Entita.Dict] { get }
 
     /// A storage for storing `URI -> Contract` connection, used for routing
-    static var contractMap: [String: AnyContract.Type] { get }
+    static var contractMap: [String: any Contract.Type] { get }
 
     /// Contains allowed service transports and respective ports
     static var transports: [LGNCore.Transport: Int] { get }
@@ -35,24 +34,6 @@ public protocol Service {
         URI: String,
         dict: Entita.Dict
     ) async throws -> ContractExecutionResult
-
-    /// Starts a LGNS server at given target. Returns a future with a server, which must be waited for until claiming the server as operational.
-    static func startServerLGNS(
-        at target: LGNS.Server.BindTo?,
-        cryptor: LGNP.Cryptor,
-        eventLoopGroup: EventLoopGroup,
-        requiredBitmask: LGNP.Message.ControlBitmask,
-        readTimeout: TimeAmount,
-        writeTimeout: TimeAmount
-    ) async throws -> AnyServer
-
-    /// Starts a HTTP server at given target. Returns a future with a server, which must be waited for until claiming the server as operational.
-    static func startServerHTTP(
-        at target: LGNS.Server.BindTo?,
-        eventLoopGroup: EventLoopGroup,
-        readTimeout: TimeAmount,
-        writeTimeout: TimeAmount
-    ) async throws -> AnyServer
 }
 
 public extension Service {
@@ -62,13 +43,13 @@ public extension Service {
 
     static var webSocketURI: String? { nil }
 
-    static var webSocketContracts: [AnyContract.Type] {
+    static var webSocketContracts: [any Contract.Type] {
         self.contractMap
             .map { $0.value }
             .filter { $0.isWebSocketTransportAvailable }
     }
 
-    static var webSocketOnlyContracts: [AnyContract.Type] {
+    static var webSocketOnlyContracts: [any Contract.Type] {
         self.contractMap
             .map { $0.value }
             .filter { $0.transports == [.WebSocket] }

Sources/LGNCore/BytesTrickery.swift

@@ -1,3 +1,5 @@
+import Foundation
+
 // These are pretty much default for all packages and shouldn't clash with anything
 
 public typealias Byte = UInt8

Sources/LGNCore/RequestID.swift

@@ -1,5 +1,6 @@
-public extension LGNCore {
+import Foundation
 
+public extension LGNCore {
     /// A random request ID.
     ///
     /// Attention: this value is random, but not random enough to be used in sensitive cryptographic operations.

Sources/LGNCore/AnyServer.swift → Sources/LGNCore/Server.swift

@@ -2,8 +2,10 @@ import Foundation
 import LGNLog
 import NIO
 
+public typealias LGNCoreServer = Server
+
 /// A type-erased server type
-public protocol AnyServer: AnyObject {
+public protocol Server: AnyObject {
     /// Indicates whether server is running (and serving requests) or not
     var isRunning: Bool { get set }
 
@@ -33,7 +35,7 @@ public protocol AnyServer: AnyObject {
     func waitForStop() throws
 }
 
-public extension AnyServer {
+public extension Server {
     fileprivate var name: String { "\(type(of: self))" }
 
     @Sendable

Sources/LGNP/Cryptor.swift

@@ -1,5 +1,4 @@
 import Crypto
-import Gzip
 import LGNCore
 
 public extension LGNP {

Sources/LGNS/Server.swift

@@ -12,7 +12,7 @@ public extension LGNS {
     static let DEFAULT_PORT = 1711
 
     /// A LGNS server
-    class Server: AnyServer, @unchecked Sendable {
+    class Server: LGNCoreServer, @unchecked Sendable {
         public typealias BindTo = LGNCore.Address
 
         public static let defaultPort: Int = LGNS.DEFAULT_PORT