feat: Account ID-based endpoints (#880)

jbelkins · web-flow · commit 8d422e17a5de · 2025-01-16T15:56:44.000-06:00
diff --git a/Sources/SmithyIdentity/AWSCredentialIdentity.swift b/Sources/SmithyIdentity/AWSCredentialIdentity.swift
@@ -14,6 +14,7 @@ import struct Foundation.Date
 public struct AWSCredentialIdentity: Identity {
     public let accessKey: String
     public let secret: String
+    public let accountID: String?
     public let sessionToken: String?
     public let expiration: Date?
 
@@ -22,16 +23,19 @@ public struct AWSCredentialIdentity: Identity {
     /// - Parameters:
     ///   - accessKey: The access key
     ///   - secret: The secret for the provided access key
+    ///   - accountID: The account ID for the credentials, if known.  Defaults to `nil`.
     ///   - expiration: The date when the credentials will expire and no longer be valid. If value is `nil` then the credentials never expire. Defaults to `nil`
     ///   - sessionToken: A session token for this session. Defaults to `nil`
     public init(
         accessKey: String,
         secret: String,
+        accountID: String? = nil,
         expiration: Date? = nil,
         sessionToken: String? = nil
     ) {
         self.accessKey = accessKey
         self.secret = secret
+        self.accountID = accountID
         self.expiration = expiration
         self.sessionToken = sessionToken
     }
diff --git a/Sources/SmithyIdentity/AWSCredentialIdentityResolvers/StaticAWSCredentialIdentityResolver.swift b/Sources/SmithyIdentity/AWSCredentialIdentityResolvers/StaticAWSCredentialIdentityResolver.swift
@@ -5,7 +5,7 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-import class AwsCommonRuntimeKit.CredentialsProvider
+@_spi(AccountIDTempSupport) import class AwsCommonRuntimeKit.CredentialsProvider
 
 /// A credential identity resolver that provides a fixed set of credentials
 public struct StaticAWSCredentialIdentityResolver: AWSCredentialIdentityResolvedByCRT {
@@ -23,6 +23,6 @@ public struct StaticAWSCredentialIdentityResolver: AWSCredentialIdentityResolved
             accessKey: credentials.accessKey,
             secret: credentials.secret,
             sessionToken: credentials.sessionToken
-        ))
+        ), accountId: credentials.accountID)
     }
 }
diff --git a/Sources/SmithyIdentity/CRTAdapters/AWSCredentialIdentityUtilityInitializers.swift b/Sources/SmithyIdentity/CRTAdapters/AWSCredentialIdentityUtilityInitializers.swift
@@ -23,6 +23,7 @@ public extension AWSCredentialIdentity {
         self.init(
             accessKey: accessKey,
             secret: secret,
+            accountID: crtAWSCredentialIdentity.getAccountId(),
             expiration: crtAWSCredentialIdentity.getExpiration(),
             sessionToken: crtAWSCredentialIdentity.getSessionToken()
         )
diff --git a/Tests/SmithyIdentityTests/CustomAWSCredentialIdentityResolverTests.swift b/Tests/SmithyIdentityTests/CustomAWSCredentialIdentityResolverTests.swift
@@ -9,12 +9,13 @@ import XCTest
 import struct SmithyIdentity.CustomAWSCredentialIdentityResolver
 
 class CustomAWSCredentialIdentityResolverTests: XCTestCase {
+
     func testGetCredentials() async throws {
         let mockProvider = MockAWSCredentialIdentityResolver()
         let subject = try CustomAWSCredentialIdentityResolver(mockProvider)
         let credentials = try await subject.getIdentity()
         
-        XCTAssertEqual(credentials.accessKey, "some_access_key")
-        XCTAssertEqual(credentials.secret, "some_secret")
+        XCTAssertEqual(credentials.accessKey, "mock_access_key")
+        XCTAssertEqual(credentials.secret, "mock_secret")
     }
 }
diff --git a/Tests/SmithyIdentityTests/MockAWSCredentialIdentityResolver.swift b/Tests/SmithyIdentityTests/MockAWSCredentialIdentityResolver.swift
@@ -11,14 +11,17 @@ import struct SmithyIdentity.AWSCredentialIdentity
 
 struct MockAWSCredentialIdentityResolver: AWSCredentialIdentityResolver {
     let _getIdentity: () async throws -> AWSCredentialIdentity
+
     init(_ _getIdentity: @escaping () async throws -> AWSCredentialIdentity) {
         self._getIdentity = _getIdentity
     }
+
     init() {
         self._getIdentity = {
             AWSCredentialIdentity(
-                accessKey: "some_access_key",
-                secret: "some_secret"
+                accessKey: "mock_access_key",
+                secret: "mock_secret",
+                accountID: "mock_account_id"
             )
         }
     }
diff --git a/Tests/SmithyIdentityTests/StaticAWSCredentialIdentityResolverTests.swift b/Tests/SmithyIdentityTests/StaticAWSCredentialIdentityResolverTests.swift
@@ -9,14 +9,17 @@ import XCTest
 import struct SmithyIdentity.StaticAWSCredentialIdentityResolver
 
 class StaticAWSCredentialIdentityResolverTests: XCTestCase {
+
     func testGetCredentials() async throws {
         let subject = try StaticAWSCredentialIdentityResolver(.init(
-            accessKey: "some_access_key",
-            secret: "some_secret"
+            accessKey: "static_access_key",
+            secret: "static_secret",
+            accountID: "static_account_id"
         ))
         let credentials = try await subject.getIdentity()
         
-        XCTAssertEqual(credentials.accessKey, "some_access_key")
-        XCTAssertEqual(credentials.secret, "some_secret")
+        XCTAssertEqual(credentials.accessKey, "static_access_key")
+        XCTAssertEqual(credentials.secret, "static_secret")
+        XCTAssertEqual(credentials.accountID, "static_account_id")
     }
 }
diff --git a/smithy-swift-codegen/src/main/kotlin/software/amazon/smithy/swift/codegen/endpoints/EndpointResolverGenerator.kt b/smithy-swift-codegen/src/main/kotlin/software/amazon/smithy/swift/codegen/endpoints/EndpointResolverGenerator.kt
@@ -30,9 +30,6 @@ class EndpointResolverGenerator(
             it.write("")
             renderResolver(it, ruleSet)
             renderStaticResolver(it)
-            val inputSymbol = Symbol.builder().name("HTTPRequestBuilder").build()
-            val outputSymbol = Symbol.builder().name("OperationStackOutput").build()
-            val outputErrorSymbol = Symbol.builder().name("OperationStackError").build()
             it.write("")
         }
     }
diff --git a/smithy-swift-codegen/src/main/kotlin/software/amazon/smithy/swift/codegen/endpoints/EndpointTypes.kt b/smithy-swift-codegen/src/main/kotlin/software/amazon/smithy/swift/codegen/endpoints/EndpointTypes.kt
@@ -6,7 +6,6 @@ import software.amazon.smithy.swift.codegen.model.buildSymbol
 object EndpointTypes {
     val EndpointResolver = symbol("EndpointResolver")
     val EndpointParams = symbol("EndpointParams")
-    val EndpointResolverMiddleware = symbol("EndpointResolverMiddleware")
     val DefaultEndpointResolver = symbol("DefaultEndpointResolver")
 
     private fun symbol(name: String): Symbol = buildSymbol {
diff --git a/smithy-swift-codegen/src/main/kotlin/software/amazon/smithy/swift/codegen/integration/HttpProtocolClientGenerator.kt b/smithy-swift-codegen/src/main/kotlin/software/amazon/smithy/swift/codegen/integration/HttpProtocolClientGenerator.kt
@@ -13,7 +13,6 @@ import software.amazon.smithy.swift.codegen.SwiftWriter
 import software.amazon.smithy.swift.codegen.middleware.MiddlewareExecutionGenerator
 import software.amazon.smithy.swift.codegen.middleware.OperationMiddleware
 import software.amazon.smithy.swift.codegen.model.toUpperCamelCase
-import software.amazon.smithy.swift.codegen.swiftmodules.SmithyTypes
 import software.amazon.smithy.swift.codegen.utils.toUpperCamelCase
 
 /**
@@ -52,14 +51,7 @@ open class HttpProtocolClientGenerator(
                 writer.openBlock(" {", "}") {
                     val operationStackName = "operation"
                     val generator = MiddlewareExecutionGenerator(ctx, writer, httpBindingResolver, httpProtocolCustomizable, operationMiddleware, operationStackName)
-                    generator.render(serviceShape, it) { writer, labelMemberName ->
-                        writer.write(
-                            "throw \$N.unknownError(\"uri component \$L unexpectedly nil\")",
-                            SmithyTypes.ClientError,
-                            labelMemberName,
-                        )
-                    }
-
+                    generator.render(serviceShape, it)
                     writer.write("return try await op.execute(input: input)")
                 }
                 writer.write("")
diff --git a/smithy-swift-codegen/src/main/kotlin/software/amazon/smithy/swift/codegen/integration/HttpProtocolServiceClient.kt b/smithy-swift-codegen/src/main/kotlin/software/amazon/smithy/swift/codegen/integration/HttpProtocolServiceClient.kt
@@ -158,9 +158,11 @@ open class HttpProtocolServiceClient(
     private fun renderEmptyAsynchronousConfigInitializer(properties: List<ConfigProperty>) {
         writer.openBlock("public convenience required init() async throws {", "}") {
             writer.openBlock("try await self.init(", ")") {
-                renderProperties(properties, true) {
-                    writer.format("\$L: nil", it.name)
+                properties.forEach { property ->
+                    writer.write("\$L: nil,", property.name)
                 }
+                writer.unwrite(",\n")
+                writer.write("")
             }
         }
         writer.write("")
@@ -190,13 +192,15 @@ open class HttpProtocolServiceClient(
 
     private fun renderConfigInitializer(serviceSymbol: Symbol, properties: List<ConfigProperty>) {
         writer.openBlock("private init(", ") {") {
-            renderProperties(properties, true) {
-                writer.format("_ \$L: \$L", it.name, it.type.renderSwiftType(writer))
+            properties.forEach { property ->
+                writer.write("_ \$L: \$L,", property.name, property.type.renderSwiftType(writer))
             }
+            writer.unwrite(",\n")
+            writer.write("")
         }
         writer.indent {
-            renderProperties(properties, false) {
-                writer.format("self.\$L = \$L", it.name, it.name)
+            properties.forEach { property ->
+                writer.write("self.\$L = \$L", property.name, property.name)
             }
             writer.injectSection(ConfigInitializerCustomization(serviceSymbol))
         }
@@ -206,19 +210,23 @@ open class HttpProtocolServiceClient(
 
     private fun renderSynchronousConfigInitializer(properties: List<ConfigProperty>) {
         writer.openBlock("public convenience init(", ") throws {") {
-            renderProperties(properties, true) {
-                writer.format("\$L: \$N = nil", it.name, it.type.toOptional())
+            properties.forEach { property ->
+                writer.write("\$L: \$N = nil,", property.name, property.type.toOptional())
             }
+            writer.unwrite(",\n")
+            writer.write("")
         }
         writer.indent {
             writer.openBlock("self.init(", ")") {
-                renderProperties(properties, true) {
-                    if (it.default?.isAsync == true) {
-                        it.name
+                properties.forEach { property ->
+                    if (property.default?.isAsync == true) {
+                        writer.write("\$L,", property.name)
                     } else {
-                        it.default?.render(writer, it.name) ?: it.name
+                        writer.write("\$L,", property.default?.render(writer, property.name) ?: property.name)
                     }
                 }
+                writer.unwrite(",\n")
+                writer.write("")
             }
         }
         writer.write("}")
@@ -229,19 +237,23 @@ open class HttpProtocolServiceClient(
         if (properties.none { it.default?.isAsync == true }) return
 
         writer.openBlock("public convenience init(", ") async throws {") {
-            renderProperties(properties, true) {
-                writer.format("\$L: \$L = nil", it.name, it.type.toOptional().renderSwiftType(writer))
+            properties.forEach { property ->
+                writer.write("\$L: \$L = nil,", property.name, property.type.toOptional().renderSwiftType(writer))
             }
+            writer.unwrite(",\n")
+            writer.write("")
         }
         writer.indent {
             writer.openBlock("self.init(", ")") {
-                renderProperties(properties, true) {
-                    if (it.default?.isAsync == true) {
-                        it.default.render(writer)
+                properties.forEach { property ->
+                    if (property.default?.isAsync == true) {
+                        writer.write("\$L,", property.default.render(writer))
                     } else {
-                        it.default?.render(writer, it.name) ?: it.name
+                        writer.write("\$L,", property.default?.render(writer, property.name) ?: property.name)
                     }
                 }
+                writer.unwrite(",\n")
+                writer.write("")
             }
         }
         writer.write("}")
@@ -255,18 +267,4 @@ open class HttpProtocolServiceClient(
                 .onEach { it.render(ctx, writer) }
         }
     }
-
-    // Renders the passed properties using the passed block to generate text,
-    // optionally comma-separating the lines as they are rendered.
-    protected fun renderProperties(
-        properties: List<ConfigProperty>,
-        commaSeparated: Boolean,
-        block: (ConfigProperty) -> String
-    ) {
-        val commaOrBlank = ",".takeIf { commaSeparated } ?: ""
-        properties.forEach { property ->
-            val separator = commaOrBlank.takeIf { property != properties.last() } ?: ""
-            writer.write("\$L\$L", block(property), separator)
-        }
-    }
 }
diff --git a/smithy-swift-codegen/src/main/kotlin/software/amazon/smithy/swift/codegen/middleware/MiddlewareExecutionGenerator.kt b/smithy-swift-codegen/src/main/kotlin/software/amazon/smithy/swift/codegen/middleware/MiddlewareExecutionGenerator.kt
@@ -1,16 +1,15 @@
 package software.amazon.smithy.swift.codegen.middleware
 
 import software.amazon.smithy.aws.traits.auth.UnsignedPayloadTrait
-import software.amazon.smithy.model.Model
 import software.amazon.smithy.model.shapes.OperationShape
 import software.amazon.smithy.model.shapes.ServiceShape
 import software.amazon.smithy.swift.codegen.SwiftWriter
 import software.amazon.smithy.swift.codegen.integration.HTTPProtocolCustomizable
 import software.amazon.smithy.swift.codegen.integration.HttpBindingResolver
 import software.amazon.smithy.swift.codegen.integration.ProtocolGenerator
 import software.amazon.smithy.swift.codegen.integration.middlewares.handlers.MiddlewareShapeUtils
+import software.amazon.smithy.swift.codegen.model.hasTrait
 import software.amazon.smithy.swift.codegen.model.toLowerCamelCase
-import software.amazon.smithy.swift.codegen.model.toUpperCamelCase
 import software.amazon.smithy.swift.codegen.swiftFunctionParameterIndent
 import software.amazon.smithy.swift.codegen.swiftmodules.ClientRuntimeTypes
 import software.amazon.smithy.swift.codegen.swiftmodules.SmithyHTTPAPITypes
@@ -26,16 +25,13 @@ class MiddlewareExecutionGenerator(
     private val operationStackName: String,
     private val httpMethodCallback: HttpMethodCallback? = null
 ) {
-    private val model: Model = ctx.model
     private val symbolProvider = ctx.symbolProvider
 
     fun render(
         serviceShape: ServiceShape,
         op: OperationShape,
         flowType: ContextAttributeCodegenFlowType = ContextAttributeCodegenFlowType.NORMAL,
-        onError: (SwiftWriter, String) -> Unit,
     ) {
-        val operationErrorName = "${op.toUpperCamelCase()}OutputError"
         val inputShape = MiddlewareShapeUtils.inputSymbol(symbolProvider, ctx.model, op)
         val outputShape = MiddlewareShapeUtils.outputSymbol(symbolProvider, ctx.model, op)
         writer.write("let context = \$N()", SmithyTypes.ContextBuilder)
@@ -91,15 +87,15 @@ class MiddlewareExecutionGenerator(
 
         // FIXME it over indents if i add another indent, come up with better way to properly indent or format for swift
 
-        writer.write("  .withMethod(value: .$httpMethod)")
+        writer.write("  .withMethod(value: .\$L)", httpMethod)
         writer.write("  .withServiceName(value: serviceName)")
-        writer.write("  .withOperation(value: \"${op.toLowerCamelCase()}\")")
+        writer.write("  .withOperation(value: \$S)", op.toLowerCamelCase())
         writer.write("  .withIdempotencyTokenGenerator(value: config.idempotencyTokenGenerator)")
         writer.write("  .withLogger(value: config.logger)")
         writer.write("  .withPartitionID(value: config.partitionID)")
         writer.write("  .withAuthSchemes(value: config.authSchemes ?? [])")
         writer.write("  .withAuthSchemeResolver(value: config.authSchemeResolver)")
-        writer.write("  .withUnsignedPayloadTrait(value: ${op.hasTrait(UnsignedPayloadTrait::class.java)})")
+        writer.write("  .withUnsignedPayloadTrait(value: \$L)", op.hasTrait<UnsignedPayloadTrait>())
         writer.write("  .withSocketTimeout(value: config.httpClientConfiguration.socketTimeout)")
         writer.write("  .withIdentityResolver(value: config.bearerTokenIdentityResolver, schemeID: \$S)", "smithy.api#httpBearerAuth")
 
@@ -114,6 +110,7 @@ class MiddlewareExecutionGenerator(
             writer.write("  .withExpiration(value: expiration)")
         }
 
+        // Add context values for config fields
         val serviceShape = ctx.service
         httpProtocolCustomizable.renderContextAttributes(ctx, writer, serviceShape, op)
         writer.write("  .build()")
diff --git a/smithy-swift-codegen/src/main/kotlin/software/amazon/smithy/swift/codegen/swiftmodules/ClientRuntimeTypes.kt b/smithy-swift-codegen/src/main/kotlin/software/amazon/smithy/swift/codegen/swiftmodules/ClientRuntimeTypes.kt
@@ -68,8 +68,6 @@ object ClientRuntimeTypes {
         val EndpointsRequestContextProviding = runtimeSymbol("EndpointsRequestContextProviding", SwiftDeclaration.PROTOCOL)
         val EndpointError = runtimeSymbol("EndpointError", SwiftDeclaration.ENUM)
         val PartitionDefinition = runtimeSymbol("partitionJSON", SwiftDeclaration.LET)
-        val EndpointsAuthSchemeResolver = runtimeSymbol("EndpointsAuthSchemeResolver", SwiftDeclaration.PROTOCOL)
-        val DefaultEndpointsAuthSchemeResolver = runtimeSymbol("DefaultEndpointsAuthSchemeResolver", SwiftDeclaration.STRUCT)
         val EndpointsAuthScheme = runtimeSymbol("EndpointsAuthScheme", SwiftDeclaration.ENUM)
         val DefaultEndpointResolver = runtimeSymbol("DefaultEndpointResolver", SwiftDeclaration.STRUCT)
         val StaticEndpointResolver = runtimeSymbol("StaticEndpointResolver", SwiftDeclaration.STRUCT)
@@ -90,7 +88,6 @@ object ClientRuntimeTypes {
         val OrchestratorBuilder = runtimeSymbol("OrchestratorBuilder", SwiftDeclaration.CLASS)
         val InterceptorProvider = runtimeSymbol("InterceptorProvider", SwiftDeclaration.PROTOCOL)
         val HttpInterceptorProvider = runtimeSymbol("HttpInterceptorProvider", SwiftDeclaration.PROTOCOL)
-        val HttpInterceptor = runtimeSymbol("HttpInterceptor", SwiftDeclaration.PROTOCOL)
         val SDKLoggingSystem = runtimeSymbol("SDKLoggingSystem", SwiftDeclaration.CLASS)
     }
 

Original file line number	Diff line number	Diff line change
`@@ -5,7 +5,7 @@`
`5`	`5`	`// SPDX-License-Identifier: Apache-2.0`
`6`	`6`	`//`
`7`	`7`
`8`		`-import class AwsCommonRuntimeKit.CredentialsProvider`
	`8`	`+@_spi(AccountIDTempSupport) import class AwsCommonRuntimeKit.CredentialsProvider`
`9`	`9`
`10`	`10`	`/// A credential identity resolver that provides a fixed set of credentials`
`11`	`11`	`public struct StaticAWSCredentialIdentityResolver: AWSCredentialIdentityResolvedByCRT {`
`@@ -23,6 +23,6 @@ public struct StaticAWSCredentialIdentityResolver: AWSCredentialIdentityResolved`
`23`	`23`	`accessKey: credentials.accessKey,`
`24`	`24`	`secret: credentials.secret,`
`25`	`25`	`sessionToken: credentials.sessionToken`
`26`		`- ))`
	`26`	`+ ), accountId: credentials.accountID)`
`27`	`27`	`}`
`28`	`28`	`}`
Original file line number	Diff line number	Diff line change
`@@ -23,6 +23,7 @@ public extension AWSCredentialIdentity {`
`23`	`23`	`self.init(`
`24`	`24`	`accessKey: accessKey,`
`25`	`25`	`secret: secret,`
	`26`	`+ accountID: crtAWSCredentialIdentity.getAccountId(),`
`26`	`27`	`expiration: crtAWSCredentialIdentity.getExpiration(),`
`27`	`28`	`sessionToken: crtAWSCredentialIdentity.getSessionToken()`
`28`	`29`	`)`
Original file line number	Diff line number	Diff line change
`@@ -9,12 +9,13 @@ import XCTest`
`9`	`9`	`import struct SmithyIdentity.CustomAWSCredentialIdentityResolver`
`10`	`10`
`11`	`11`	`class CustomAWSCredentialIdentityResolverTests: XCTestCase {`
	`12`	`+`
`12`	`13`	`func testGetCredentials() async throws {`
`13`	`14`	`let mockProvider = MockAWSCredentialIdentityResolver()`
`14`	`15`	`let subject = try CustomAWSCredentialIdentityResolver(mockProvider)`
`15`	`16`	`let credentials = try await subject.getIdentity()`
`16`	`17`
`17`		`- XCTAssertEqual(credentials.accessKey, "some_access_key")`
`18`		`- XCTAssertEqual(credentials.secret, "some_secret")`
	`18`	`+ XCTAssertEqual(credentials.accessKey, "mock_access_key")`
	`19`	`+ XCTAssertEqual(credentials.secret, "mock_secret")`
`19`	`20`	`}`
`20`	`21`	`}`
Original file line number	Diff line number	Diff line change
`@@ -11,14 +11,17 @@ import struct SmithyIdentity.AWSCredentialIdentity`
`11`	`11`
`12`	`12`	`struct MockAWSCredentialIdentityResolver: AWSCredentialIdentityResolver {`
`13`	`13`	`let _getIdentity: () async throws -> AWSCredentialIdentity`
	`14`	`+`
`14`	`15`	`init(_ _getIdentity: @escaping () async throws -> AWSCredentialIdentity) {`
`15`	`16`	`self._getIdentity = _getIdentity`
`16`	`17`	`}`
	`18`	`+`
`17`	`19`	`init() {`
`18`	`20`	`self._getIdentity = {`
`19`	`21`	`AWSCredentialIdentity(`
`20`		`- accessKey: "some_access_key",`
`21`		`- secret: "some_secret"`
	`22`	`+ accessKey: "mock_access_key",`
	`23`	`+ secret: "mock_secret",`
	`24`	`+ accountID: "mock_account_id"`
`22`	`25`	`)`
`23`	`26`	`}`
`24`	`27`	`}`
Original file line number	Diff line number	Diff line change
`@@ -30,9 +30,6 @@ class EndpointResolverGenerator(`
`30`	`30`	`it.write("")`
`31`	`31`	`renderResolver(it, ruleSet)`
`32`	`32`	`renderStaticResolver(it)`
`33`		`- val inputSymbol = Symbol.builder().name("HTTPRequestBuilder").build()`
`34`		`- val outputSymbol = Symbol.builder().name("OperationStackOutput").build()`
`35`		`- val outputErrorSymbol = Symbol.builder().name("OperationStackError").build()`
`36`	`33`	`it.write("")`
`37`	`34`	`}`
`38`	`35`	`}`
Original file line number	Diff line number	Diff line change
`@@ -158,9 +158,11 @@ open class HttpProtocolServiceClient(`
`158`	`158`	`private fun renderEmptyAsynchronousConfigInitializer(properties: List<ConfigProperty>) {`
`159`	`159`	`writer.openBlock("public convenience required init() async throws {", "}") {`
`160`	`160`	`writer.openBlock("try await self.init(", ")") {`
`161`		`- renderProperties(properties, true) {`
`162`		`- writer.format("\$L: nil", it.name)`
	`161`	`+ properties.forEach { property ->`
	`162`	`+ writer.write("\$L: nil,", property.name)`
`163`	`163`	`}`
	`164`	`+ writer.unwrite(",\n")`
	`165`	`+ writer.write("")`
`164`	`166`	`}`
`165`	`167`	`}`
`166`	`168`	`writer.write("")`
`@@ -190,13 +192,15 @@ open class HttpProtocolServiceClient(`
`190`	`192`
`191`	`193`	`private fun renderConfigInitializer(serviceSymbol: Symbol, properties: List<ConfigProperty>) {`
`192`	`194`	`writer.openBlock("private init(", ") {") {`
`193`		`- renderProperties(properties, true) {`
`194`		`- writer.format("_ \$L: \$L", it.name, it.type.renderSwiftType(writer))`
	`195`	`+ properties.forEach { property ->`
	`196`	`+ writer.write("_ \$L: \$L,", property.name, property.type.renderSwiftType(writer))`
`195`	`197`	`}`
	`198`	`+ writer.unwrite(",\n")`
	`199`	`+ writer.write("")`
`196`	`200`	`}`
`197`	`201`	`writer.indent {`
`198`		`- renderProperties(properties, false) {`
`199`		`- writer.format("self.\$L = \$L", it.name, it.name)`
	`202`	`+ properties.forEach { property ->`
	`203`	`+ writer.write("self.\$L = \$L", property.name, property.name)`
`200`	`204`	`}`
`201`	`205`	`writer.injectSection(ConfigInitializerCustomization(serviceSymbol))`
`202`	`206`	`}`
`@@ -206,19 +210,23 @@ open class HttpProtocolServiceClient(`
`206`	`210`
`207`	`211`	`private fun renderSynchronousConfigInitializer(properties: List<ConfigProperty>) {`
`208`	`212`	`writer.openBlock("public convenience init(", ") throws {") {`
`209`		`- renderProperties(properties, true) {`
`210`		`- writer.format("\$L: \$N = nil", it.name, it.type.toOptional())`
	`213`	`+ properties.forEach { property ->`
	`214`	`+ writer.write("\$L: \$N = nil,", property.name, property.type.toOptional())`
`211`	`215`	`}`
	`216`	`+ writer.unwrite(",\n")`
	`217`	`+ writer.write("")`
`212`	`218`	`}`
`213`	`219`	`writer.indent {`
`214`	`220`	`writer.openBlock("self.init(", ")") {`
`215`		`- renderProperties(properties, true) {`
`216`		`- if (it.default?.isAsync == true) {`
`217`		`- it.name`
	`221`	`+ properties.forEach { property ->`
	`222`	`+ if (property.default?.isAsync == true) {`
	`223`	`+ writer.write("\$L,", property.name)`
`218`	`224`	`} else {`
`219`		`- it.default?.render(writer, it.name) ?: it.name`
	`225`	`+ writer.write("\$L,", property.default?.render(writer, property.name) ?: property.name)`
`220`	`226`	`}`
`221`	`227`	`}`
	`228`	`+ writer.unwrite(",\n")`
	`229`	`+ writer.write("")`
`222`	`230`	`}`
`223`	`231`	`}`
`224`	`232`	`writer.write("}")`
`@@ -229,19 +237,23 @@ open class HttpProtocolServiceClient(`
`229`	`237`	`if (properties.none { it.default?.isAsync == true }) return`
`230`	`238`
`231`	`239`	`writer.openBlock("public convenience init(", ") async throws {") {`
`232`		`- renderProperties(properties, true) {`
`233`		`- writer.format("\$L: \$L = nil", it.name, it.type.toOptional().renderSwiftType(writer))`
	`240`	`+ properties.forEach { property ->`
	`241`	`+ writer.write("\$L: \$L = nil,", property.name, property.type.toOptional().renderSwiftType(writer))`
`234`	`242`	`}`
	`243`	`+ writer.unwrite(",\n")`
	`244`	`+ writer.write("")`
`235`	`245`	`}`
`236`	`246`	`writer.indent {`
`237`	`247`	`writer.openBlock("self.init(", ")") {`
`238`		`- renderProperties(properties, true) {`
`239`		`- if (it.default?.isAsync == true) {`
`240`		`- it.default.render(writer)`
	`248`	`+ properties.forEach { property ->`
	`249`	`+ if (property.default?.isAsync == true) {`
	`250`	`+ writer.write("\$L,", property.default.render(writer))`
`241`	`251`	`} else {`
`242`		`- it.default?.render(writer, it.name) ?: it.name`
	`252`	`+ writer.write("\$L,", property.default?.render(writer, property.name) ?: property.name)`
`243`	`253`	`}`
`244`	`254`	`}`
	`255`	`+ writer.unwrite(",\n")`
	`256`	`+ writer.write("")`
`245`	`257`	`}`
`246`	`258`	`}`
`247`	`259`	`writer.write("}")`
`@@ -255,18 +267,4 @@ open class HttpProtocolServiceClient(`
`255`	`267`	`.onEach { it.render(ctx, writer) }`
`256`	`268`	`}`
`257`	`269`	`}`
`258`		`-`
`259`		`- // Renders the passed properties using the passed block to generate text,`
`260`		`- // optionally comma-separating the lines as they are rendered.`
`261`		`- protected fun renderProperties(`
`262`		`- properties: List<ConfigProperty>,`
`263`		`- commaSeparated: Boolean,`
`264`		`- block: (ConfigProperty) -> String`
`265`		`- ) {`
`266`		`- val commaOrBlank = ",".takeIf { commaSeparated } ?: ""`
`267`		`- properties.forEach { property ->`
`268`		`- val separator = commaOrBlank.takeIf { property != properties.last() } ?: ""`
`269`		`- writer.write("\$L\$L", block(property), separator)`
`270`		`- }`
`271`		`- }`
`272`	`270`	`}`