@aws/nx-plugin 1.0.0-rc.31 → 1.0.0-rc.32

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aws/nx-plugin",
-  "version": "1.0.0-rc.31",
+  "version": "1.0.0-rc.32",
   "repository": {
     "type": "git",
     "url": "https://github.com/awslabs/nx-plugin-for-aws.git",

package/src/open-api/ts-client/__snapshots__/generator.content-type.spec.ts.snap

@@ -1,7 +1,10 @@
 // Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
 
 exports[`openApiTsClientGenerator - content type header > should not force Content-Type for multipart/form-data bodies > client.gen.ts 1`] = `
-"import type { PostUploadRequest } from './types.gen.js';
+"import type {
+  PostUploadRequestContent,
+  PostUploadRequest,
+} from './types.gen.js';
 
 /**
  * Utility for serialisation and deserialisation of API types.
@@ -9,6 +12,39 @@ exports[`openApiTsClientGenerator - content type header > should not force Conte
 export class $IO {
   public static $mapValues = (data: any, fn: (item: any) => any) =>
     Object.fromEntries(Object.entries(data).map(([k, v]) => [k, fn(v)]));
+
+  public static PostUploadRequestContent = {
+    toJson: (model: PostUploadRequestContent): any => {
+      if (model === undefined || model === null) {
+        return model;
+      }
+      return {
+        ...(model.file === undefined
+          ? {}
+          : {
+              file: model.file,
+            }),
+        ...(model.description === undefined
+          ? {}
+          : {
+              description: model.description,
+            }),
+      };
+    },
+    fromJson: (json: any): PostUploadRequestContent => {
+      if (json === undefined || json === null) {
+        return json;
+      }
+      return {
+        file: json['file'],
+        ...(json['description'] === undefined
+          ? {}
+          : {
+              description: json['description'],
+            }),
+      };
+    },
+  };
 }
 
 /**
@@ -130,6 +166,26 @@ export class TestApi {
     });
   };
 
+  private $formData = (model: { [key: string]: any }): FormData => {
+    const formData = new FormData();
+    const append = (key: string, value: any): void => {
+      if (value === undefined || value === null) {
+        return;
+      }
+      if (value instanceof Blob || typeof value === 'string') {
+        formData.append(key, value);
+      } else if (Array.isArray(value)) {
+        value.forEach((v) => append(key, v));
+      } else if (typeof value === 'object') {
+        formData.append(key, JSON.stringify(value));
+      } else {
+        formData.append(key, String(value));
+      }
+    };
+    Object.entries(model).forEach(([key, value]) => append(key, value));
+    return formData;
+  };
+
   private $fetch: typeof fetch = (...args) =>
     (this.$config.fetch ?? fetch)(...args);
 
@@ -137,7 +193,7 @@ export class TestApi {
     const pathParameters: { [key: string]: any } = {};
     const queryParameters: { [key: string]: any } = {};
     const headerParameters: { [key: string]: any } = {};
-    const body = input as any;
+    const body = this.$formData($IO.PostUploadRequestContent.toJson(input));
 
     const response = await this.$fetch(
       this.$url('/upload', pathParameters, queryParameters),
@@ -160,7 +216,12 @@ export class TestApi {
 `;
 
 exports[`openApiTsClientGenerator - content type header > should not force Content-Type for multipart/form-data bodies > types.gen.ts 1`] = `
-"export type PostUploadRequest = unknown;
+"export type PostUploadRequestContent = {
+  file: Blob;
+  description?: string;
+};
+
+export type PostUploadRequest = PostUploadRequestContent;
 export type PostUploadError = never;
 "
 `;

package/src/open-api/ts-client/__snapshots__/generator.multipart.spec.ts.snap

@@ -0,0 +1,280 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`openApiTsClientGenerator - multipart/form-data > should match the generated client snapshot > client.gen.ts 1`] = `
+"import type {
+  Upload200Response,
+  UploadRequestContent,
+  UploadRequest,
+} from './types.gen.js';
+
+/**
+ * Utility for serialisation and deserialisation of API types.
+ */
+export class $IO {
+  public static $mapValues = (data: any, fn: (item: any) => any) =>
+    Object.fromEntries(Object.entries(data).map(([k, v]) => [k, fn(v)]));
+
+  public static Upload200Response = {
+    toJson: (model: Upload200Response): any => {
+      if (model === undefined || model === null) {
+        return model;
+      }
+      return {
+        ...(model.size === undefined
+          ? {}
+          : {
+              size: model.size,
+            }),
+        ...(model.note === undefined
+          ? {}
+          : {
+              note: model.note,
+            }),
+      };
+    },
+    fromJson: (json: any): Upload200Response => {
+      if (json === undefined || json === null) {
+        return json;
+      }
+      return {
+        ...(json['size'] === undefined
+          ? {}
+          : {
+              size: json['size'],
+            }),
+        ...(json['note'] === undefined
+          ? {}
+          : {
+              note: json['note'],
+            }),
+      };
+    },
+  };
+
+  public static UploadRequestContent = {
+    toJson: (model: UploadRequestContent): any => {
+      if (model === undefined || model === null) {
+        return model;
+      }
+      return {
+        ...(model.file === undefined
+          ? {}
+          : {
+              file: model.file,
+            }),
+        ...(model.note === undefined
+          ? {}
+          : {
+              note: model.note,
+            }),
+        ...(model.tags === undefined
+          ? {}
+          : {
+              tags: model.tags,
+            }),
+      };
+    },
+    fromJson: (json: any): UploadRequestContent => {
+      if (json === undefined || json === null) {
+        return json;
+      }
+      return {
+        file: json['file'],
+        ...(json['note'] === undefined
+          ? {}
+          : {
+              note: json['note'],
+            }),
+        ...(json['tags'] === undefined
+          ? {}
+          : {
+              tags: json['tags'],
+            }),
+      };
+    },
+  };
+}
+
+/**
+ * Client configuration for TestApi
+ */
+export interface TestApiConfig {
+  /**
+   * Base URL for the API
+   */
+  url: string;
+  /**
+   * Custom instance of fetch. By default the global 'fetch' is used.
+   * You can override this to add custom middleware for use cases such as adding authentication headers.
+   */
+  fetch?: typeof fetch;
+  /**
+   * Additional configuration
+   */
+  options?: {
+    /**
+     * By default, the client will add a Content-Type header, set to the media type defined for
+     * the request in the OpenAPI specification.
+     * Set this to false to omit this header.
+     */
+    omitContentTypeHeader?: boolean;
+  };
+}
+
+/**
+ * API Client for TestApi
+ */
+export class TestApi {
+  private $config: TestApiConfig;
+
+  constructor(config: TestApiConfig) {
+    this.$config = config;
+
+    this.upload = this.upload.bind(this);
+  }
+
+  private $collectionDelimiters: { [format: string]: string } = {
+    csv: ',',
+    ssv: ' ',
+    pipes: '|',
+  };
+
+  private $deepObject = (key: string, value: any): string[] => {
+    if (value === undefined || value === null) {
+      return [];
+    }
+    if (typeof value !== 'object') {
+      return [\`\${key}=\${encodeURIComponent(String(value))}\`];
+    }
+    return Object.entries(value).flatMap(([prop, v]) =>
+      this.$deepObject(\`\${key}[\${encodeURIComponent(prop)}]\`, v),
+    );
+  };
+
+  private $url = (
+    path: string,
+    pathParameters: { [key: string]: any },
+    queryParameters: { [key: string]: any },
+    collectionFormats?: {
+      [key: string]: 'multi' | 'csv' | 'ssv' | 'pipes' | 'deepObject';
+    },
+  ): string => {
+    const baseUrl = this.$config.url.endsWith('/')
+      ? this.$config.url.slice(0, -1)
+      : this.$config.url;
+    const pathWithParameters = Object.entries(pathParameters).reduce(
+      (withParams, [key, value]) =>
+        withParams.replace(\`{\${key}}\`, encodeURIComponent(\`\${value}\`)),
+      path,
+    );
+    const queryString = Object.entries(queryParameters)
+      .flatMap(([key, value]) => {
+        if (Array.isArray(value) && collectionFormats?.[key] === 'multi') {
+          return value.map(
+            (v) => \`\${encodeURIComponent(key)}=\${encodeURIComponent(\`\${v}\`)}\`,
+          );
+        }
+        if (
+          collectionFormats?.[key] === 'deepObject' &&
+          value !== null &&
+          typeof value === 'object'
+        ) {
+          return this.$deepObject(encodeURIComponent(key), value);
+        }
+        const delimiter =
+          this.$collectionDelimiters[collectionFormats?.[key] ?? 'csv'] ?? ',';
+        return [
+          \`\${encodeURIComponent(key)}=\${encodeURIComponent(Array.isArray(value) ? value.map(String).join(delimiter) : String(value))}\`,
+        ];
+      })
+      .join('&');
+    return (
+      baseUrl + pathWithParameters + (queryString ? \`?\${queryString}\` : '')
+    );
+  };
+
+  private $headers = (
+    headerParameters: { [key: string]: any },
+    collectionFormats?: { [key: string]: 'multi' | 'csv' | 'ssv' | 'pipes' },
+  ): [string, string][] => {
+    return Object.entries(headerParameters).flatMap(([key, value]) => {
+      if (Array.isArray(value) && collectionFormats?.[key] === 'multi') {
+        return value.map((v) => [key, String(v)]) as [string, string][];
+      }
+      const delimiter =
+        this.$collectionDelimiters[collectionFormats?.[key] ?? 'csv'] ?? ',';
+      return [
+        [
+          key,
+          Array.isArray(value)
+            ? value.map(String).join(delimiter)
+            : String(value),
+        ],
+      ];
+    });
+  };
+
+  private $formData = (model: { [key: string]: any }): FormData => {
+    const formData = new FormData();
+    const append = (key: string, value: any): void => {
+      if (value === undefined || value === null) {
+        return;
+      }
+      if (value instanceof Blob || typeof value === 'string') {
+        formData.append(key, value);
+      } else if (Array.isArray(value)) {
+        value.forEach((v) => append(key, v));
+      } else if (typeof value === 'object') {
+        formData.append(key, JSON.stringify(value));
+      } else {
+        formData.append(key, String(value));
+      }
+    };
+    Object.entries(model).forEach(([key, value]) => append(key, value));
+    return formData;
+  };
+
+  private $fetch: typeof fetch = (...args) =>
+    (this.$config.fetch ?? fetch)(...args);
+
+  public async upload(input: UploadRequest): Promise<Upload200Response> {
+    const pathParameters: { [key: string]: any } = {};
+    const queryParameters: { [key: string]: any } = {};
+    const headerParameters: { [key: string]: any } = {};
+    const body = this.$formData($IO.UploadRequestContent.toJson(input));
+
+    const response = await this.$fetch(
+      this.$url('/upload', pathParameters, queryParameters),
+      {
+        headers: this.$headers(headerParameters),
+        method: 'POST',
+        body,
+      },
+    );
+
+    if (response.status === 200) {
+      return $IO.Upload200Response.fromJson(await response.json());
+    }
+    throw new Error(
+      \`Unknown response status \${response.status} returned by API\`,
+    );
+  }
+}
+"
+`;
+
+exports[`openApiTsClientGenerator - multipart/form-data > should match the generated client snapshot > types.gen.ts 1`] = `
+"export type Upload200Response = {
+  size?: number;
+  note?: string;
+};
+export type UploadRequestContent = {
+  file: Blob;
+  note?: string;
+  tags?: Array<string>;
+};
+
+export type UploadRequest = UploadRequestContent;
+export type UploadError = never;
+"
+`;

package/src/open-api/ts-client/files/client.gen.ts.template

@@ -29,6 +29,13 @@ const composedMarshaller = (property, method) =>
   property.export === 'reference' && discriminatorBaseNames.has(property.type)
     ? `$IO.${property.typescriptType}.$${method}Base`
     : `$IO.${property.typescriptType}.${method}`;
+// The single wire media type chosen for an operation's request body, if any.
+const bodyMediaTypeOf = (op) => {
+  if (!op.parametersBody || !op.parametersBody.mediaTypes) return undefined;
+  const mediaTypes = Array.isArray(op.parametersBody.mediaTypes) ? op.parametersBody.mediaTypes : [op.parametersBody.mediaTypes];
+  return mediaTypes.find(mt => mt === 'application/json' || mt.endsWith('+json')) || mediaTypes[0];
+};
+const hasMultipartBody = allOperations.some(op => bodyMediaTypeOf(op) === 'multipart/form-data');
 _%>
 <%_ if ((models.length + allOperations.filter(p => p.parameters.length > 0).length) > 0) { _%>
 import type {
@@ -478,6 +485,28 @@ export class <%- className %> {
     });
   };
 
+  <%_ if (hasMultipartBody) { _%>
+  private $formData = (model: { [key: string]: any }): FormData => {
+    const formData = new FormData();
+    const append = (key: string, value: any): void => {
+      if (value === undefined || value === null) {
+        return;
+      }
+      if (value instanceof Blob || typeof value === 'string') {
+        formData.append(key, value);
+      } else if (Array.isArray(value)) {
+        value.forEach((v) => append(key, v));
+      } else if (typeof value === 'object') {
+        formData.append(key, JSON.stringify(value));
+      } else {
+        formData.append(key, String(value));
+      }
+    };
+    Object.entries(model).forEach(([key, value]) => append(key, value));
+    return formData;
+  };
+
+  <%_ } _%>
   private $fetch: typeof fetch = (...args) => (this.$config.fetch ?? fetch)(...args);
   <%_ allOperations.forEach((op) => { _%>
   <%_ const hasTag = op.tags && op.tags.length > 0; _%>
@@ -538,7 +567,13 @@ export class <%- className %> {
     } as const;
     <%_ } _%>
     <%_ if (op.parametersBody) { _%>
-    <%_ if (op.parametersBody.isPrimitive && ['number', 'boolean', 'string'].includes(op.parametersBody.type) && !['array', 'dictionary'].includes(op.parametersBody.export) && !["date", "date-time"].includes(op.parametersBody.format)) { _%>
+    <%_ if (bodyMediaTypeOf(op) === 'multipart/form-data') { _%>
+    <%_ /* A multipart body is sent as FormData: Blob fields stream as file
+           parts, primitives serialise to strings, and fetch computes the
+           boundary itself (so the Content-Type header is intentionally unset
+           above). */ _%>
+    const body = <% if (!op.parametersBody.isRequired) { %>input === undefined ? undefined : <% } %>this.$formData(<%- op.explicitRequestBodyParameter ? `$IO.${op.operationIdPascalCase}RequestBodyParameters.toJson(input).${op.explicitRequestBodyParameter.prop}` : renderToJsonValue(op.parametersBody, 'input') %>);
+    <%_ } else if (op.parametersBody.isPrimitive && ['number', 'boolean', 'string'].includes(op.parametersBody.type) && !['array', 'dictionary'].includes(op.parametersBody.export) && !["date", "date-time"].includes(op.parametersBody.format)) { _%>
     const body = <% if (!op.parametersBody.isRequired) { %>input === undefined ? undefined : <% } %>String(input<%- op.explicitRequestBodyParameter ? `.${op.explicitRequestBodyParameter.typescriptName}` : '' %>);
     <%_ } else if (op.parametersBody.isPrimitive && ["date", "date-time"].includes(op.parametersBody.format)) { _%>
     const body = <%- renderToJsonDateValue('input', op.parametersBody.format) %>;

package/src/open-api/utils/normalise.js

@@ -437,15 +437,22 @@ const hoistInlineObjectSubSchemas = (nameParts, schema, seenModelNameCounts)=>{
                 }
                 if ('requestBody' in operation) {
                     const requestBody = resolveIfRef(spec, operation.requestBody);
-                    const jsonMediaType = preferredJsonMediaType(Object.keys(requestBody?.content ?? {}));
-                    const jsonRequestSchema = jsonMediaType ? requestBody.content[jsonMediaType].schema : undefined;
-                    if (jsonRequestSchema && !isRef(jsonRequestSchema) && ([
+                    const contentMediaTypes = Object.keys(requestBody?.content ?? {});
+                    // Hoist the JSON body, falling back to a form-data body (multipart or
+                    // urlencoded) so an inline form object is fully typed and marshalled
+                    // rather than left `unknown`.
+                    const bodyMediaType = preferredJsonMediaType(contentMediaTypes) ?? contentMediaTypes.find((mt)=>[
+                            'multipart/form-data',
+                            'application/x-www-form-urlencoded'
+                        ].includes(mt.split(';')[0]));
+                    const bodyRequestSchema = bodyMediaType ? requestBody.content[bodyMediaType].schema : undefined;
+                    if (bodyRequestSchema && !isRef(bodyRequestSchema) && ([
                         'object',
                         'array'
-                    ].includes(jsonRequestSchema.type) || isCompositeSchema(jsonRequestSchema) || jsonRequestSchema?.type === 'string' && jsonRequestSchema.enum)) {
+                    ].includes(bodyRequestSchema.type) || isCompositeSchema(bodyRequestSchema) || bodyRequestSchema?.type === 'string' && bodyRequestSchema.enum)) {
                         const schemaName = `${upperFirst(deduplicatedOpId)}RequestContent`;
-                        spec.components.schemas[schemaName] = jsonRequestSchema;
-                        requestBody.content[jsonMediaType].schema = {
+                        spec.components.schemas[schemaName] = bodyRequestSchema;
+                        requestBody.content[bodyMediaType].schema = {
                             $ref: `#/components/schemas/${schemaName}`
                         };
                     }