fix non modular client generation

smithy-typescript-codegen/src/main/java/software/amazon/smithy/typescript/codegen/CodegenVisitor.java

@@ -253,7 +253,7 @@ public Void serviceShape(ServiceShape shape) {
         String nonModularName = serviceSymbol.getName().replace("Client", "");
         String filename = serviceSymbol.getDefinitionFile().replace("Client", "");
         writers.useFileWriter(filename, writer -> new NonModularServiceGenerator(
-                settings, model, symbolProvider, nonModularName, writer).run());
+                settings, model, symbolProvider, nonModularName, writer, applicationProtocol).run());
 
         // Generate each operation for the service.
         TopDownIndex topDownIndex = model.getKnowledge(TopDownIndex.class);

smithy-typescript-codegen/src/main/java/software/amazon/smithy/typescript/codegen/CommandGenerator.java

@@ -85,6 +85,8 @@ public void run() {
 
         // Add required imports.
         writer.addImport(configType, configType, serviceSymbol.getNamespace());
+        writer.addImport("ServiceInputTypes", "ServiceInputTypes", serviceSymbol.getNamespace());
+        writer.addImport("ServiceOutputTypes", "ServiceOutputTypes", serviceSymbol.getNamespace());
         writer.addImport("Command", "$Command", "@aws-sdk/smithy-client");
         writer.addImport("FinalizeHandlerArguments", "FinalizeHandlerArguments", "@aws-sdk/types");
         writer.addImport("Handler", "Handler", "@aws-sdk/types");
@@ -133,7 +135,7 @@ private void generateCommandMiddlewareResolver(String configType) {
 
         writer.write("resolveMiddleware(")
                 .indent()
-                .write("clientStack: MiddlewareStack<$T, $T>,", inputType, outputType)
+                .write("clientStack: MiddlewareStack<$L, $L>,", "ServiceInputTypes", "ServiceOutputTypes")
                 .write("configuration: $L,", configType)
                 .write("options?: $T", applicationProtocol.getOptionsType())
                 .dedent();

smithy-typescript-codegen/src/main/java/software/amazon/smithy/typescript/codegen/NonModularServiceGenerator.java

@@ -40,20 +40,23 @@ final class NonModularServiceGenerator implements Runnable {
     private final TypeScriptWriter writer;
     private final String nonModularName;
     private final Symbol serviceSymbol;
+    private final ApplicationProtocol applicationProtocol;
 
     NonModularServiceGenerator(
             TypeScriptSettings settings,
             Model model,
             SymbolProvider symbolProvider,
             String nonModularName,
-            TypeScriptWriter writer
+            TypeScriptWriter writer,
+            ApplicationProtocol applicationProtocol
     ) {
         this.settings = settings;
         this.model = model;
         this.service = settings.getService(model);
         this.symbolProvider = symbolProvider;
         this.writer = writer;
         this.nonModularName = nonModularName;
+        this.applicationProtocol = applicationProtocol;
         serviceSymbol = symbolProvider.toSymbol(service);
     }
 
@@ -70,24 +73,44 @@ public void run() {
                 Symbol output = operationSymbol.expectProperty("outputType", Symbol.class);
 
                 writer.addUseImports(operationSymbol);
-                String methodName = StringUtils.uncapitalize(operationSymbol.getName());
+                String methodName = StringUtils.uncapitalize(
+                        operationSymbol.getName().replaceAll("Command$", "")
+                );
 
                 // Generate a multiple overloaded methods for each command.
                 writer.writeShapeDocs(operation);
-                writer.write("public $L(args: $T): Promise<$T>;", methodName, input, output);
+                writer.write("public $L(\n"
+                            + "  args: $T,\n"
+                            + "  options?: $T,\n"
+                            + "): Promise<$T>;", methodName, input, applicationProtocol.getOptionsType(), output);
                 writer.write("public $L(\n"
                              + "  args: $T,\n"
                              + "  cb: (err: any, data?: $T) => void\n"
                              + "): void;", methodName, input, output);
+                writer.write("public $L(\n"
+                            + "  args: $T,\n"
+                            + "  options: $T,\n"
+                            + "  cb: (err: any, data?: $T) => void\n"
+                            + "): void;", methodName, input, applicationProtocol.getOptionsType(), output);
                 writer.openBlock("public $1L(\n"
                                  + "  args: $2T,\n"
-                                 + "  cb?: (err: any, data?: $3T) => void\n"
-                                 + "): Promise<$3T> | void { ", "}", methodName, input, output, () -> {
+                                 + "  optionsOrCb?: $3T | ((err: any, data?: $4T) => void),\n"
+                                 + "  cb?: (err: any, data?: $4T) => void\n"
+                                 + "): Promise<$4T> | void { ", "}",
+                        methodName,
+                        input,
+                        applicationProtocol.getOptionsType(),
+                        output,
+                        () -> {
                     writer.write("const command = new $T(args);\n"
-                                 + "if (typeof cb === \"function\") {\n"
-                                 + "  this.send(command, cb);\n"
+                                 + "if (typeof optionsOrCb === \"function\") {\n"
+                                 + "  this.send(command, optionsOrCb)\n"
+                                 + "} else if (typeof cb === \"function\") {\n"
+                                 + "  if (typeof optionsOrCb !== \"object\")\n"
+                                 + "    throw new Error(`Expect http options but get $${typeof optionsOrCb}`)\n"
+                                 + "  this.send(command, optionsOrCb || {}, cb)\n"
                                  + "} else {\n"
-                                 + "  return this.send(command);\n"
+                                 + "  return this.send(command, optionsOrCb);\n"
                                  + "}", operationSymbol);
                 });
                 writer.write("");

smithy-typescript-codegen/src/main/java/software/amazon/smithy/typescript/codegen/integration/HttpBindingProtocolGenerator.java

@@ -19,16 +19,19 @@
 
 import java.util.Comparator;
 import java.util.List;
+import java.util.Optional;
 import java.util.Set;
 import java.util.TreeMap;
 import java.util.TreeSet;
 import java.util.logging.Logger;
+
 import software.amazon.smithy.codegen.core.CodegenException;
 import software.amazon.smithy.codegen.core.Symbol;
 import software.amazon.smithy.codegen.core.SymbolProvider;
 import software.amazon.smithy.codegen.core.SymbolReference;
 import software.amazon.smithy.model.knowledge.HttpBinding;
 import software.amazon.smithy.model.knowledge.HttpBindingIndex;
+import software.amazon.smithy.model.knowledge.OperationIndex;
 import software.amazon.smithy.model.knowledge.TopDownIndex;
 import software.amazon.smithy.model.shapes.BlobShape;
 import software.amazon.smithy.model.shapes.BooleanShape;
@@ -47,6 +50,7 @@
 import software.amazon.smithy.model.shapes.UnionShape;
 import software.amazon.smithy.model.traits.ErrorTrait;
 import software.amazon.smithy.model.traits.HttpTrait;
+import software.amazon.smithy.model.traits.StreamingTrait;
 import software.amazon.smithy.model.traits.TimestampFormatTrait.Format;
 import software.amazon.smithy.typescript.codegen.ApplicationProtocol;
 import software.amazon.smithy.typescript.codegen.TypeScriptWriter;
@@ -539,7 +543,6 @@ private void generateOperationDeserializer(
             });
 
             // Start deserializing the response.
-            writer.write("const data: any = await parseBody(output.body, context)");
             writer.openBlock("const contents: $T = {", "};", outputType, () -> {
                 writer.write("$$metadata: deserializeMetadata(output),");
 
@@ -582,7 +585,6 @@ private void generateErrorDeserializer(GenerationContext context, StructureShape
                        + "  output: any,\n"
                        + "  context: SerdeContext\n"
                        + "): $T => {", "};", errorDeserMethodName, errorSymbol, () -> {
-            writer.write("const data: any = output.body;");
 
             writer.openBlock("const contents: $T = {", "};", errorSymbol, () -> {
                 writer.write("__type: $S,", error.getId().getName());
@@ -663,6 +665,22 @@ private List<HttpBinding> readResponseBody(
         documentBindings.sort(Comparator.comparing(HttpBinding::getMemberName));
         List<HttpBinding> payloadBindings = bindingIndex.getResponseBindings(operationOrError, Location.PAYLOAD);
 
+        // Prepare response body for deserializing.
+        OperationIndex operationIndex = context.getModel().getKnowledge(OperationIndex.class);
+        StructureShape operationOutputOrError = operationOrError.asStructureShape()
+                .orElseGet(() -> operationIndex.getOutput(operationOrError).orElse(null));
+        boolean hasStreamingComponent = Optional.ofNullable(operationOutputOrError)
+                .map(structure -> structure.getAllMembers().values().stream()
+                        .anyMatch(memberShape -> memberShape.hasTrait(StreamingTrait.class)))
+                .orElse(false);
+        if (hasStreamingComponent) {
+            // For operations with streaming output or errors with streaming body we keep the body intact.
+            writer.write("const data: any = output.body;");
+        } else {
+            // Otherwise, we collect the response body to structured object with parseBody().
+            writer.write("const data: any = await parseBody(output.body, context);");
+        }
+
         if (!documentBindings.isEmpty()) {
             deserializeOutputDocument(context, operationOrError, documentBindings);
             return documentBindings;