override fun renderThrowOperationError()

in codegen/smithy-aws-kotlin-codegen/src/main/kotlin/aws/sdk/kotlin/codegen/protocols/core/AwsHttpBindingProtocolGenerator.kt [114:164]
47 lines of code
2 McCabe index (conditional complexity)

    override fun renderThrowOperationError(
        ctx: ProtocolGenerator.GenerationContext,
        op: OperationShape,
        writer: KotlinWriter
    ) {
        val exceptionBaseSymbol = ExceptionBaseClassGenerator.baseExceptionSymbol(ctx.settings)

        listOf(
            exceptionBaseSymbol,
            RuntimeTypes.Http.readAll,
            AwsRuntimeTypes.Http.withPayload,
            AwsRuntimeTypes.Http.setAseErrorMetadata,
        ).forEach(writer::addImport)

        writer.write("""val payload = response.body.readAll()""")
            .write("val wrappedResponse = response.withPayload(payload)")
            .write("")
            .write("val errorDetails = try {")
            .indent()
            .call {
                renderDeserializeErrorDetails(ctx, op, writer)
            }
            .dedent()
            .withBlock("} catch (ex: Exception) {", "}") {
                withBlock("""throw #T("Failed to parse response as '${ctx.protocol.name}' error", ex).also {""", "}", exceptionBaseSymbol) {
                    write("#T(it, wrappedResponse, null)", AwsRuntimeTypes.Http.setAseErrorMetadata)
                }
            }
            .write("")

        if (op.errors.isEmpty()) {
            writer.write("throw #T(errorDetails.message)", exceptionBaseSymbol)
        } else {
            writer.openBlock("val modeledExceptionDeserializer = when(errorDetails.code) {", "}") {
                op.errors.forEach { err ->
                    val errSymbol = ctx.symbolProvider.toSymbol(ctx.model.expectShape(err))
                    val errDeserializerSymbol = buildSymbol {
                        name = "${errSymbol.name}Deserializer"
                        namespace = "${ctx.settings.pkg.name}.transform"
                    }
                    writer.write("#S -> #T()", getErrorCode(ctx, err), errDeserializerSymbol)
                }
                writer.write("else -> throw #T(errorDetails.message)", exceptionBaseSymbol)
            }

            writer.write("")
                .write("val modeledException = modeledExceptionDeserializer.deserialize(context, wrappedResponse)")
                .write("#T(modeledException, wrappedResponse, errorDetails)", AwsRuntimeTypes.Http.setAseErrorMetadata)
                .write("throw modeledException")
        }
    }