feat: allow commands to be constructed without arg if all arg fields optional

Author: kuhe

.changeset/six-doors-speak.md

@@ -0,0 +1,6 @@
+---
+"@smithy/smithy-client": patch
+"@smithy/types": patch
+---
+
+allow command constructor argument to be omitted if no required members

packages/smithy-client/src/command.spec.ts

@@ -1,6 +1,27 @@
 import { Command } from "./command";
 
 describe(Command.name, () => {
+  it("has optional argument if the input type has no required members", async () => {
+    type OptionalInput = {
+      key?: string;
+      optional?: string;
+    };
+
+    type RequiredInput = {
+      key: string | undefined;
+      optional?: string;
+    };
+
+    class WithRequiredInputCommand extends Command.classBuilder<RequiredInput, any, any, any, any>()
+      .build() {}
+
+    class WithOptionalInputCommand extends Command.classBuilder<OptionalInput, any, any, any, any>()
+      .build() {}
+
+    new WithRequiredInputCommand({ key: "1" });
+
+    new WithOptionalInputCommand(); // expect no type error.
+  });
   it("implements a classBuilder", async () => {
     class MyCommand extends Command.classBuilder<any, any, any, any, any>()
       .ep({

packages/smithy-client/src/command.ts

@@ -11,6 +11,7 @@ import type {
   Logger,
   MetadataBearer,
   MiddlewareStack as IMiddlewareStack,
+  OptionalParameter,
   Pluggable,
   RequestHandler,
   SerdeContext,
@@ -217,14 +218,16 @@ class ClassBuilder<
    * @returns a Command class with the classBuilder properties.
    */
   public build(): {
-    new (input: I): CommandImpl<I, O, C, SI, SO>;
+    new (...[input]: OptionalParameter<I>): CommandImpl<I, O, C, SI, SO>;
     getEndpointParameterInstructions(): EndpointParameterInstructions;
   } {
     // eslint-disable-next-line @typescript-eslint/no-this-alias
     const closure = this;
     let CommandRef: any;
 
     return (CommandRef = class extends Command<I, O, C, SI, SO> {
+      public readonly input: I;
+
       /**
        * @public
        */
@@ -235,8 +238,9 @@ class ClassBuilder<
       /**
        * @public
        */
-      public constructor(readonly input: I) {
+      public constructor(...[input]: OptionalParameter<I>) {
         super();
+        this.input = input ?? (({} as unknown) as I);
         closure._init(this);
       }
 

packages/types/src/client.ts

@@ -1,15 +1,15 @@
 import { Command } from "./command";
 import { MiddlewareStack } from "./middleware";
 import { MetadataBearer } from "./response";
-import { Exact } from "./util";
+import { OptionalParameter } from "./util";
 
 /**
  * @public
  *
  * A type which checks if the client configuration is optional.
  * If all entries of the client configuration are optional, it allows client creation without passing any config.
  */
-export type CheckOptionalClientConfig<T> = Exact<Partial<T>, T> extends true ? [] | [T] : [T];
+export type CheckOptionalClientConfig<T> = OptionalParameter<T>;
 
 /**
  * @public

packages/types/src/util.ts

@@ -181,3 +181,11 @@ export interface RetryStrategy {
     args: FinalizeHandlerArguments<Input>
   ) => Promise<FinalizeHandlerOutput<Output>>;
 }
+
+/**
+ * @public
+ *
+ * Indicates the parameter may be omitted if the parameter object T
+ * is equivalent to a Partial<T>, i.e. all properties optional.
+ */
+export type OptionalParameter<T> = Exact<Partial<T>, T> extends true ? [] | [T] : [T]