only expose HTTPClientRequest.Body.Length publicy

Author: dnadoba

Sources/AsyncHTTPClient/AsyncAwait/HTTPClientRequest.swift

@@ -77,11 +77,11 @@ extension HTTPClientRequest.Body {
 
     @inlinable
     public static func bytes<Bytes: Sequence>(
-        length: RequestBodyLength,
+        length: Length,
         _ bytes: Bytes
     ) -> Self where Bytes.Element == UInt8 {
         self.init(.sequence(
-            length: length,
+            length: length.storage,
             canBeConsumedMultipleTimes: false
         ) { allocator in
             if let buffer = bytes.withContiguousStorageIfAvailable({ allocator.buffer(bytes: $0) }) {
@@ -95,11 +95,11 @@ extension HTTPClientRequest.Body {
 
     @inlinable
     public static func bytes<Bytes: Collection>(
-        length: RequestBodyLength,
+        length: Length,
         _ bytes: Bytes
     ) -> Self where Bytes.Element == UInt8 {
         self.init(.sequence(
-            length: length,
+            length: length.storage,
             canBeConsumedMultipleTimes: true
         ) { allocator in
             if let buffer = bytes.withContiguousStorageIfAvailable({ allocator.buffer(bytes: $0) }) {
@@ -113,23 +113,23 @@ extension HTTPClientRequest.Body {
 
     @inlinable
     public static func stream<SequenceOfBytes: AsyncSequence>(
-        length: RequestBodyLength,
+        length: Length,
         _ sequenceOfBytes: SequenceOfBytes
     ) -> Self where SequenceOfBytes.Element == ByteBuffer {
         var iterator = sequenceOfBytes.makeAsyncIterator()
-        let body = self.init(.asyncSequence(length: length) { _ -> ByteBuffer? in
+        let body = self.init(.asyncSequence(length: length.storage) { _ -> ByteBuffer? in
             try await iterator.next()
         })
         return body
     }
 
     @inlinable
     public static func stream<Bytes: AsyncSequence>(
-        length: RequestBodyLength,
+        length: Length,
         _ bytes: Bytes
     ) -> Self where Bytes.Element == UInt8 {
         var iterator = bytes.makeAsyncIterator()
-        let body = self.init(.asyncSequence(length: length) { allocator -> ByteBuffer? in
+        let body = self.init(.asyncSequence(length: length.storage) { allocator -> ByteBuffer? in
             var buffer = allocator.buffer(capacity: 1024) // TODO: Magic number
             while buffer.writableBytes > 0, let byte = try await iterator.next() {
                 buffer.writeInteger(byte)
@@ -155,4 +155,19 @@ extension Optional where Wrapped == HTTPClientRequest.Body {
     }
 }
 
+@available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *)
+extension HTTPClientRequest.Body {
+    public struct Length {
+        /// size of the request body is not known before starting the request
+        public static let dynamic: Self = .init(storage: .dynamic)
+        /// size of the request body is fixed and exactly `count` bytes
+        public static func fixed(_ count: Int) -> Self {
+            .init(storage: .fixed(count))
+        }
+        
+        @usableFromInline
+        internal var storage: RequestBodyLength
+    }
+}
+
 #endif

Sources/AsyncHTTPClient/ConnectionPool/RequestBodyLength.swift

@@ -12,16 +12,12 @@
 //
 //===----------------------------------------------------------------------===//
 
-public struct RequestBodyLength {
+
+/// - Note: use `HTTPClientRequest.Body.Length` if you want to expose `RequestBodyLength` publicly
+@usableFromInline
+internal enum RequestBodyLength: Hashable {
     /// size of the request body is not known before starting the request
-    public static let dynamic: Self = .init(storage: .dynamic)
+    case dynamic
     /// size of the request body is fixed and exactly `count` bytes
-    public static func fixed(_ count: Int) -> Self {
-        .init(storage: .fixed(count))
-    }
-    internal enum Storage: Hashable {
-        case dynamic
-        case fixed(_ count: Int)
-    }
-    internal var storage: Storage
+    case fixed(_ count: Int)
 }

Sources/AsyncHTTPClient/RequestValidation.swift

@@ -23,7 +23,7 @@ extension HTTPHeaders {
         try self.validateFieldNames()
 
         if case .TRACE = method {
-            switch bodyLength.storage {
+            switch bodyLength {
             case .fixed(0):
                 break
             case .dynamic, .fixed:
@@ -36,7 +36,7 @@ extension HTTPHeaders {
         self.setTransportFraming(method: method, bodyLength: bodyLength)
 
         let connectionClose = self[canonicalForm: "connection"].lazy.map { $0.lowercased() }.contains("close")
-        switch bodyLength.storage {
+        switch bodyLength {
         case .dynamic:
             return .init(connectionClose: connectionClose, body: .stream)
         case .fixed(let length):
@@ -87,7 +87,7 @@ extension HTTPHeaders {
         self.remove(name: "Content-Length")
         self.remove(name: "Transfer-Encoding")
 
-        switch bodyLength.storage {
+        switch bodyLength {
         case .fixed(0):
             // if we don't have a body we might not need to send the Content-Length field
             // https://tools.ietf.org/html/rfc7230#section-3.3.2

Tests/AsyncHTTPClientTests/HTTPClientRequestTests.swift

@@ -500,7 +500,7 @@ extension Optional where Wrapped == HTTPClientRequest.Body {
             return buffer
         case .sequence(let announcedLength, _, let generate):
             let buffer = generate(ByteBufferAllocator())
-            if case let .fixed(announcedLength) = announcedLength.storage,
+            if case let .fixed(announcedLength) = announcedLength,
                announcedLength != buffer.readableBytes {
                 throw LengthMismatch(announcedLength: announcedLength, actualLength: buffer.readableBytes)
             }
@@ -510,7 +510,7 @@ extension Optional where Wrapped == HTTPClientRequest.Body {
             while var buffer = try await generate(ByteBufferAllocator()) {
                 accumulatedBuffer.writeBuffer(&buffer)
             }
-            if case let .fixed(announcedLength) = announcedLength.storage,
+            if case let .fixed(announcedLength) = announcedLength,
                announcedLength != accumulatedBuffer.readableBytes {
                 throw LengthMismatch(announcedLength: announcedLength, actualLength: accumulatedBuffer.readableBytes)
             }