feat: add async operations in a client extension (#289)

Author: kneekey23

smithy-swift-codegen/src/main/kotlin/software/amazon/smithy/swift/codegen/ServiceGenerator.kt

@@ -53,11 +53,8 @@ class ServiceGenerator(
             val inputShapeName = symbolProvider.toSymbol(inputShape).name
             val inputParam = "input: $inputShapeName"
 
-            val outputShape = opIndex.getOutput(op).get()
-            val outputShapeName = symbolProvider.toSymbol(outputShape).name
-            val errorTypeName = getOperationErrorShapeName(op)
-
-            val outputParam = "completion: @escaping (SdkResult<$outputShapeName, $errorTypeName>) -> Void"
+            val outputType = createOutputType(opIndex, op, symbolProvider)
+            val outputParam = "completion: @escaping ($outputType) -> Void"
 
             val paramTerminator = ", "
 
@@ -74,6 +71,30 @@ class ServiceGenerator(
             )
         }
 
+        fun renderAsyncOperationDefinition(model: Model, symbolProvider: SymbolProvider, writer: SwiftWriter, opIndex: OperationIndex, op: OperationShape) {
+            if (!op.input.isPresent || !op.output.isPresent) throw CodegenException("model should have been preprocessed to ensure operations always have an input or output shape: $op.id")
+
+            val operationName = op.camelCaseName()
+            val inputShape = opIndex.getInput(op).get()
+            val inputSymbolName = symbolProvider.toSymbol(inputShape).name
+            val inputParam = "input: $inputSymbolName"
+
+            val outputType = getOperationOutputShapeName(symbolProvider, opIndex, op)
+
+            writer.writeShapeDocs(op)
+            writer.writeAvailableAttribute(model, op)
+
+            writer.write("func \$L(\$L) async throws -> \$L", operationName, inputParam, outputType)
+        }
+
+        fun createOutputType(opIndex: OperationIndex, op: OperationShape, symbolProvider: SymbolProvider): String {
+            val outputShape = opIndex.getOutput(op).get()
+            val outputShapeName = symbolProvider.toSymbol(outputShape).name
+            val errorTypeName = getOperationErrorShapeName(op)
+
+            return "SdkResult<$outputShapeName, $errorTypeName>"
+        }
+
         fun getOperationInputShapeName(symbolProvider: SymbolProvider, opIndex: OperationIndex, op: OperationShape): String {
             val inputShape = opIndex.getInput(op).get()
             return symbolProvider.toSymbol(inputShape).name
@@ -160,7 +181,7 @@ class ServiceGenerator(
 
         delegator.useShapeWriter(operationErrorSymbol) { writer ->
             writer.addImport(unknownServiceErrorSymbol)
-            writer.openBlock("public enum $operationErrorName: Equatable {", "}") {
+            writer.openBlock("public enum $operationErrorName: Swift.Error, Equatable {", "}") {
                 for (errorShape in errorShapes) {
                     val errorShapeName = symbolProvider.toSymbol(errorShape).name
                     writer.write("case \$L(\$L)", errorShapeName.decapitalize(), errorShapeName)

smithy-swift-codegen/src/main/kotlin/software/amazon/smithy/swift/codegen/integration/HttpProtocolClientGenerator.kt

@@ -52,6 +52,13 @@ open class HttpProtocolClientGenerator(
         httpProtocolServiceClient.render(serviceSymbol)
         writer.write("")
         renderOperationsInExtension(serviceSymbol)
+        val rootNamespace = ctx.settings.moduleName
+        ctx.delegator.useFileWriter("./$rootNamespace/${serviceSymbol.name}+Async.swift") {
+            it.write("#if swift(>=5.5)")
+            it.addImport(SwiftDependency.CLIENT_RUNTIME.target)
+            renderAsyncOperationsInExtension(serviceSymbol, it)
+            it.write("#endif")
+        }
     }
 
     private fun renderOperationsInExtension(serviceSymbol: Symbol) {
@@ -70,6 +77,38 @@ open class HttpProtocolClientGenerator(
         }
     }
 
+    private fun renderAsyncOperationsInExtension(serviceSymbol: Symbol, writer: SwiftWriter) {
+        val topDownIndex = TopDownIndex.of(model)
+        val operations = topDownIndex.getContainedOperations(serviceShape).sortedBy { it.capitalizedName() }
+        val operationsIndex = OperationIndex.of(model)
+        writer.write("@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, macCatalyst 15.0, *)")
+        writer.openBlock("public extension ${serviceSymbol.name} {", "}") {
+            operations.forEach {
+                ServiceGenerator.renderAsyncOperationDefinition(model, symbolProvider, writer, operationsIndex, it)
+                writer.openBlock("{", "}") {
+                    renderContinuation(operationsIndex, it, writer)
+                }
+                writer.write("")
+            }
+        }
+    }
+
+    private fun renderContinuation(opIndex: OperationIndex, op: OperationShape, writer: SwiftWriter) {
+        val operationName = op.camelCaseName()
+        val continuationName = "${operationName}Continuation"
+        writer.write("typealias $continuationName = CheckedContinuation<${ServiceGenerator.getOperationOutputShapeName(ctx.symbolProvider, opIndex, op)}, Swift.Error>")
+        writer.openBlock("return try await withCheckedThrowingContinuation { (continuation: $continuationName) in", "}") {
+            writer.openBlock("$operationName(input: input) { result in", "}") {
+                writer.openBlock("switch result {", "}") {
+                    writer.write("case .success(let output):")
+                    writer.indent().write("continuation.resume(returning: output)").dedent()
+                    writer.write("case .failure(let error):")
+                    writer.indent().write("continuation.resume(throwing: error)").dedent()
+                }
+            }
+        }
+    }
+
     // replace labels with any path bindings
     private fun renderUriPath(httpTrait: HttpTrait, pathBindings: List<HttpBindingDescriptor>, writer: SwiftWriter) {
         val resolvedURIComponents = mutableListOf<String>()