Explicitly only use FoundationEssentials where possible (#436)

We want that the runtime only depends on `FoundationEssentials` where
available (ie. on linux) to ensure small binary size.

### Motivation:

Smaller binary size is good for lambda deployment and cold-start times.
The runtime should only depend on `FoundationEssentials`.

### Modifications:

- replace `import Foundation` with `import FoundationEssentials` if
`FoundationEssentials` is available.
- I also applied the same treatment to tests to ensure that catch error
where tests run on linux and we use API that is only available in
`Foundation` which easily happens when you develop on macOS (where
always full `Foundation` is available).

### Result:

This should allow builds without linking full `Foundation`.

Author: t089

Examples/BackgroundTasks/Sources/main.swift

@@ -13,7 +13,12 @@
 //===----------------------------------------------------------------------===//
 
 import AWSLambdaRuntime
+
+#if canImport(FoundationEssentials)
+import FoundationEssentials
+#else
 import Foundation
+#endif
 
 struct BackgroundProcessingHandler: LambdaWithBackgroundProcessingHandler {
     struct Input: Decodable {

Sources/AWSLambdaRuntime/Context+Foundation.swift

@@ -14,7 +14,11 @@
 
 import AWSLambdaRuntimeCore
 
+#if canImport(FoundationEssentials)
+import FoundationEssentials
+#else
 import struct Foundation.Date
+#endif
 
 extension LambdaContext {
     var deadlineDate: Date {

Sources/AWSLambdaRuntime/Vendored/ByteBuffer-foundation.swift

@@ -26,9 +26,14 @@
 //
 //===----------------------------------------------------------------------===//
 
-import Foundation
 import NIOCore
 
+#if canImport(FoundationEssentials)
+import FoundationEssentials
+#else
+import Foundation
+#endif
+
 // This is NIO's `NIOFoundationCompat` module which at the moment only adds `ByteBuffer` utility methods
 // for Foundation's `Data` type.
 //

Sources/AWSLambdaRuntimeCore/LambdaRuntime.swift

@@ -12,11 +12,16 @@
 //
 //===----------------------------------------------------------------------===//
 
-import Foundation
 import Logging
 import NIOConcurrencyHelpers
 import NIOCore
 
+#if canImport(FoundationEssentials)
+import FoundationEssentials
+#else
+import Foundation
+#endif
+
 // We need `@unchecked` Sendable here, as `NIOLockedValueBox` does not understand `sending` today.
 // We don't want to use `NIOLockedValueBox` here anyway. We would love to use Mutex here, but this
 // sadly crashes the compiler today.

Sources/MockServer/main.swift

@@ -12,11 +12,17 @@
 //
 //===----------------------------------------------------------------------===//
 
-import Foundation
+import Dispatch
 import NIOCore
 import NIOHTTP1
 import NIOPosix
 
+#if canImport(FoundationEssentials)
+import FoundationEssentials
+#else
+import Foundation
+#endif
+
 struct MockServer {
     private let group: EventLoopGroup
     private let host: String

Tests/AWSLambdaRuntimeCoreTests/InvocationTests.swift

@@ -12,12 +12,17 @@
 //
 //===----------------------------------------------------------------------===//
 
-import Foundation
 import NIOHTTP1
 import Testing
 
 @testable import AWSLambdaRuntimeCore
 
+#if canImport(FoundationEssentials)
+import FoundationEssentials
+#else
+import Foundation
+#endif
+
 @Suite
 struct InvocationTest {
     @Test

Tests/AWSLambdaRuntimeCoreTests/LambdaMockClient.swift

@@ -13,10 +13,15 @@
 //===----------------------------------------------------------------------===//
 
 import AWSLambdaRuntimeCore
-import Foundation
 import Logging
 import NIOCore
 
+#if canImport(FoundationEssentials)
+import FoundationEssentials
+#else
+import Foundation
+#endif
+
 struct LambdaMockWriter: LambdaRuntimeClientResponseStreamWriter {
     var underlying: LambdaMockClient
 

Tests/AWSLambdaRuntimeCoreTests/LambdaRequestIDTests.swift

@@ -12,12 +12,17 @@
 //
 //===----------------------------------------------------------------------===//
 
-import Foundation
 import NIOCore
 import Testing
 
 @testable import AWSLambdaRuntimeCore
 
+#if canImport(FoundationEssentials)
+import FoundationEssentials
+#else
+import Foundation
+#endif
+
 @Suite("LambdaRequestID tests")
 struct LambdaRequestIDTest {
     @Test
@@ -100,6 +105,7 @@ struct LambdaRequestIDTest {
         #expect(buffer.readableBytes == readableBeforeRead)
     }
 
+    #if os(macOS)
     @Test
     func testInitFromNSStringSuccess() {
         let nsString = NSMutableString(capacity: 16)
@@ -121,6 +127,7 @@ struct LambdaRequestIDTest {
         #expect(requestID?.uuidString == LambdaRequestID(uuidString: nsString as String)?.uuidString)
         #expect(requestID?.uppercased == nsString as String)
     }
+    #endif
 
     @Test
     func testUnparse() {

Tests/AWSLambdaRuntimeCoreTests/LambdaRunLoopTests.swift

@@ -12,13 +12,18 @@
 //
 //===----------------------------------------------------------------------===//
 
-import Foundation
 import Logging
 import NIOCore
 import Testing
 
 @testable import AWSLambdaRuntimeCore
 
+#if canImport(FoundationEssentials)
+import FoundationEssentials
+#else
+import Foundation
+#endif
+
 @Suite
 struct LambdaRunLoopTests {
     struct MockEchoHandler: StreamingLambdaHandler {

Tests/AWSLambdaRuntimeCoreTests/MockLambdaServer.swift

@@ -12,14 +12,19 @@
 //
 //===----------------------------------------------------------------------===//
 
-import Foundation  // for JSON
 import Logging
 import NIOCore
 import NIOHTTP1
 import NIOPosix
 
 @testable import AWSLambdaRuntimeCore
 
+#if canImport(FoundationEssentials)
+import FoundationEssentials
+#else
+import Foundation
+#endif
+
 func withMockServer<Result>(
     behaviour: some LambdaServerBehavior,
     port: Int = 0,

Tests/AWSLambdaRuntimeCoreTests/Utils.swift

@@ -12,7 +12,11 @@
 //
 //===----------------------------------------------------------------------===//
 
+#if canImport(FoundationEssentials)
+import FoundationEssentials
+#else
 import Foundation
+#endif
 
 extension Date {
     var millisSinceEpoch: Int64 {

readme.md

@@ -253,7 +253,11 @@ Background tasks allow code to execute asynchronously after the main response ha
 Here is an example of a minimal function that waits 10 seconds after it returned a response but before the handler returns.
 ```swift
 import AWSLambdaRuntime
+#if canImport(FoundationEssentials)
+import FoundationEssentials
+#else
 import Foundation
+#endif
 
 struct BackgroundProcessingHandler: LambdaWithBackgroundProcessingHandler {
     struct Input: Decodable {