@autorest/typescript 6.0.0-beta.7 → 6.0.0-rc.1

package/src/restLevelClient/generateParameterTypes.ts

@@ -1,12 +1,26 @@
-import { CodeModel, Operation, Parameter } from "@autorest/codemodel";
+import {
+  CodeModel,
+  Operation,
+  Parameter,
+  SchemaContext,
+  Request as OperationRequest,
+  ParameterLocation
+} from "@autorest/codemodel";
 import {
   InterfaceDeclarationStructure,
   Project,
+  PropertySignatureStructure,
+  SourceFile,
   StructureKind
 } from "ts-morph";
+import * as path from 'path';
 import { getLanguageMetadata } from "../utils/languageHelpers";
 import { NameType, normalizeName } from "../utils/nameUtils";
 import { getPropertySignature } from "./getPropertySignature";
+import { primitiveSchemaToType } from "./schemaHelpers";
+import { getOperationParameters } from "./helpers/operationHelpers";
+import { hasInputModels } from "./helpers/modelHelpers";
+import { getAutorestOptions } from "../autorestSession";
 
 /**
  * Generates the interfaces describing each operation parameters
@@ -15,8 +29,9 @@ export function generateParameterInterfaces(
   model: CodeModel,
   project: Project
 ) {
+  const { srcPath } = getAutorestOptions();
   const parametersFile = project.createSourceFile(
-    `src/parameters.ts`,
+    path.join(srcPath, `parameters.ts`),
     undefined,
     {
       overwrite: true
@@ -28,42 +43,118 @@ export function generateParameterInterfaces(
   // Tracks the generated parameter types
 
   const operations = getAllOperations(model);
+  let hasHeaders = false;
 
   for (const operation of operations) {
-    const internalReferences = new Set<string>();
     const operationName = normalizeName(
       getLanguageMetadata(operation.language).name,
       NameType.Interface
     );
-    const parameterInterfaceName = `${operationName}Parameters`;
-    const parameters = getOperationParameters(operation);
-    const queryParameterDefinitions = buildQueryParameterDefinition(
-      operationName,
-      parameters,
-      importedModels,
-      internalReferences
-    );
 
-    const bodyParameterDefinition = buildBodyParametersDefinition(
-      operationName,
-      parameters,
-      importedModels,
-      internalReferences
-    );
+    const requestCount = operation?.requests?.length ?? 0;
+    const topParamName = `${operationName}Parameters`;
+    const subParamNames: string[] = [];
 
-    // Add interfaces for body and query parameters
-    parametersFile.addInterfaces([
-      ...(bodyParameterDefinition ? [bodyParameterDefinition] : []),
-      ...(queryParameterDefinitions ?? [])
-    ]);
+    // We need to loop the requests. An operation with multiple requests means that
+    // the operation can get different values for content-type and each value may
+    // have a different type associated to it.
+    for (let i = 0; i < requestCount; i++) {
+      const internalReferences = new Set<string>();
+      // In case we have more than one request to model we need to add a suffix to differentiate
+      const nameSuffix = i > 0 ? `${i}` : "";
+      const parameterInterfaceName =
+        requestCount > 1
+          ? `${operationName}RequestParameters${nameSuffix}`
+          : topParamName;
+      const parameters = getOperationParameters(operation, i);
+      const queryParameterDefinitions = buildQueryParameterDefinition(
+        operationName,
+        parameters,
+        [SchemaContext.Input],
+        importedModels,
+        internalReferences,
+        i
+      );
+
+      const request = operation.requests ? operation.requests[i] : undefined;
+
+      const pathParameterDefinitions = buildPathParameterDefinitions(
+        operationName,
+        parameters,
+        model,
+        parametersFile,
+        internalReferences,
+        i
+      )
+
+      const headerParameterDefinitions = buildHeaderParameterDefinitions(
+        operationName,
+        parameters,
+        parametersFile,
+        internalReferences,
+        i
+      );
+
+      const contentTypeParameterDefinition = buildContentTypeParametersDefinition(
+        operationName,
+        request,
+        internalReferences,
+        i
+      );
+
+      const bodyParameterDefinition = buildBodyParametersDefinition(
+        operationName,
+        parameters,
+        [SchemaContext.Input],
+        importedModels,
+        internalReferences,
+        i
+      );
+
+      // Add interfaces for body and query parameters
+      parametersFile.addInterfaces([
+        ...(bodyParameterDefinition ?? []),
+        ...(queryParameterDefinitions ?? []),
+        ...(pathParameterDefinitions ? [pathParameterDefinitions]: []),
+        ...(headerParameterDefinitions ? [headerParameterDefinitions] : []),
+        ...(contentTypeParameterDefinition
+          ? [contentTypeParameterDefinition]
+          : [])
+      ]);
+
+      // Add Operation parameters type alias which is composed of the types we generated above
+      // plus the common type RequestParameters
+      parametersFile.addTypeAlias({
+        name: parameterInterfaceName,
+        isExported: true,
+        type: [...internalReferences, "RequestParameters"].join(" & ")
+      });
+
+      subParamNames.push(parameterInterfaceName);
+
+      if (headerParameterDefinitions !== undefined) {
+        hasHeaders = true;
+      }
+    }
 
     // Add Operation parameters type alias which is composed of the types we generated above
     // plus the common type RequestParameters
-    parametersFile.addTypeAlias({
-      name: parameterInterfaceName,
-      isExported: true,
-      type: [...internalReferences, "RequestParameters"].join(" & ")
-    });
+    if (requestCount > 1) {
+      parametersFile.addTypeAlias({
+        name: topParamName,
+        isExported: true,
+        type: [...subParamNames].join(" | ")
+      });
+    }
+  }
+
+  if (hasHeaders) {
+    parametersFile.addImportDeclarations([
+      {
+        namedImports: ["RawHttpHeadersInput"],
+        moduleSpecifier: "@azure/core-rest-pipeline"
+      }
+    ]);
   }
 
   parametersFile.addImportDeclarations([
@@ -73,43 +164,280 @@ export function generateParameterInterfaces(
     }
   ]);
 
-  parametersFile.addImportDeclarations([
-    {
-      namedImports: [...importedModels],
-      moduleSpecifier: "./models"
-    }
-  ]);
+  if (hasInputModels(model)) {
+    parametersFile.addImportDeclarations([
+      {
+        namedImports: [...importedModels],
+        moduleSpecifier: "./models"
+      }
+    ]);
+  }
+}
+
+function getRequestHeaderInterfaceDefinition(
+  parameters: Parameter[],
+  baseName: string
+): undefined | InterfaceDeclarationStructure {
+  // Check if there are any required headers
+  const headerParameters = parameters.filter(
+    p => p.protocol.http?.in === "header"
+  );
+  if (!headerParameters.length) {
+    return undefined;
+  }
+  const headersInterfaceName = `${baseName}Headers`;
+  return {
+    kind: StructureKind.Interface,
+    isExported: true,
+    name: headersInterfaceName,
+    properties: headerParameters.map((h: Parameter) => {
+      const description = getLanguageMetadata(h.language).description;
+      return {
+        name: `"${getLanguageMetadata(h.language).serializedName}"`,
+        ...(description && { docs: [{ description }] }),
+        type: primitiveSchemaToType(h.schema, [
+          SchemaContext.Input,
+          SchemaContext.Exception
+        ]),
+        hasQuestionToken: !h.required
+      };
+    })
+  };
+}
+
+function buildHeaderParameterDefinitions(
+  operationName: string,
+  parameters: Parameter[],
+  parametersFile: SourceFile,
+  internalReferences: Set<string>,
+  requestIndex: number
+): InterfaceDeclarationStructure | undefined {
+  const headerParameters = parameters.filter(
+    p => p.protocol.http?.in === "header"
+  );
+  if (!headerParameters.length) {
+    return undefined;
+  }
+
+  const nameSuffix = requestIndex > 0 ? `${requestIndex}` : "";
+  const headerParameterInterfaceName = `${operationName}HeaderParam${nameSuffix}`;
+
+  const headersInterface = getRequestHeaderInterfaceDefinition(
+    headerParameters,
+    operationName
+  );
+
+  if (headersInterface) {
+    parametersFile.addInterface(headersInterface);
+  }
+
+  internalReferences.add(headerParameterInterfaceName);
+
+  return {
+    isExported: true,
+    kind: StructureKind.Interface,
+    name: headerParameterInterfaceName,
+    properties: [
+      {
+        name: "headers",
+        type: `RawHttpHeadersInput & ${operationName}Headers`,
+        kind: StructureKind.PropertySignature
+      }
+    ]
+  };
 }
 
+function getPathInterfaceDefinition(
+  parameters: Parameter[],
+  baseName: string,
+  model: CodeModel
+): undefined | InterfaceDeclarationStructure {
+  // Check if there are any path parameters
+  const pathParameters = parameters.filter(
+    p => p.protocol.http?.in === ParameterLocation.Uri && model.globalParameters?.indexOf(p) === -1
+  );
+  if (!pathParameters.length) {
+    return undefined;
+  }
+  const pathInterfaceName = `${baseName}PathParameters`;
+  return {
+    kind: StructureKind.Interface,
+    isExported: true,
+    name: pathInterfaceName,
+    properties: pathParameters.map((h: Parameter) => {
+      const description = getLanguageMetadata(h.language).description;
+      return {
+        name: `"${getLanguageMetadata(h.language).serializedName}"`,
+        ...(description && { docs: [{ description }] }),
+        type: primitiveSchemaToType(h.schema, [
+          SchemaContext.Input,
+          SchemaContext.Exception
+        ]),
+        hasQuestionToken: !h.required
+      };
+    })
+  };
+}
+
+function buildPathParameterDefinitions(
+  operationName: string,
+  parameters: Parameter[],
+  model: CodeModel,
+  parametersFile: SourceFile,
+  internalReferences: Set<string>,
+  requestIndex: number
+): InterfaceDeclarationStructure | undefined {
+  const pathParameters = parameters.filter(
+    p => p.protocol.http?.in === ParameterLocation.Uri && model.globalParameters?.indexOf(p) === -1
+  );
+  if (!pathParameters.length) {
+    return undefined;
+  }
+
+  const nameSuffix = requestIndex > 0 ? `${requestIndex}` : "";
+  const pathParameterInterfaceName = `${operationName}PathParam${nameSuffix}`;
+
+  const pathInterface = getPathInterfaceDefinition(
+    pathParameters,
+    operationName,
+    model
+  );
+
+  if (pathInterface) {
+    parametersFile.addInterface(pathInterface);
+  }
+
+  internalReferences.add(pathParameterInterfaceName);
+
+  return {
+    isExported: true,
+    kind: StructureKind.Interface,
+    name: pathParameterInterfaceName,
+    properties: [
+      {
+        name: "pathParameters",
+        type: `${operationName}PathParameters`,
+        kind: StructureKind.PropertySignature
+      }
+    ]
+  };  
+}
 /**
  * Gets the interface definition for an operation bodyParameters
  */
 function buildBodyParametersDefinition(
   operationName: string,
   parameters: Parameter[],
+  schemaUsage: SchemaContext[],
   importedModels: Set<string>,
-  internalReferences: Set<string>
-): InterfaceDeclarationStructure | undefined {
+  internalReferences: Set<string>,
+  requestIndex: number
+): InterfaceDeclarationStructure[] {
   const bodyParameters = parameters.filter(p => p.protocol.http?.in === "body");
   if (!bodyParameters.length) {
+    return [];
+  }
+
+  const nameSuffix = requestIndex > 0 ? `${requestIndex}` : "";
+  const bodyParameterInterfaceName = `${operationName}BodyParam${nameSuffix}`;
+  internalReferences.add(bodyParameterInterfaceName);
+
+  // In case of formData we'd get multiple properties in body marked as partialBody
+  if (bodyParameters.some(p => p.isPartialBody)) {
+    let allOptionalParts = true;
+    const propertiesDefinitions: PropertySignatureStructure[] = [];
+    for (const param of bodyParameters) {
+      if (param.required) {
+        allOptionalParts = false;
+      }
+
+      propertiesDefinitions.push(
+        getPropertySignature(param, schemaUsage, importedModels)
+      );
+    }
+
+    const formBodyName = `${operationName}FormBody`;
+    const formBodyInterface: InterfaceDeclarationStructure = {
+      isExported: true,
+      kind: StructureKind.Interface,
+      name: formBodyName,
+      properties: propertiesDefinitions
+    };
+
+    return [
+      {
+        isExported: true,
+        kind: StructureKind.Interface,
+        name: bodyParameterInterfaceName,
+        properties: [
+          {
+            name: "body",
+            type: formBodyName,
+            hasQuestionToken: allOptionalParts
+          }
+        ]
+      },
+      formBodyInterface
+    ];
+  } else {
+    const bodySignature = getPropertySignature(
+      bodyParameters[0],
+      schemaUsage,
+      importedModels
+    );
+
+    return [
+      {
+        isExported: true,
+        kind: StructureKind.Interface,
+        name: bodyParameterInterfaceName,
+        properties: [
+          {
+            docs: bodySignature.docs,
+            name: "body",
+            type: bodySignature.type,
+            hasQuestionToken: bodySignature.hasQuestionToken
+          }
+        ]
+      }
+    ];
+  }
+}
+
+/**
+ * Gets the interface definition for an operation bodyParameters
+ */
+function buildContentTypeParametersDefinition(
+  operationName: string,
+  request: OperationRequest | undefined,
+  internalReferences: Set<string>,
+  requestIndex: number
+): InterfaceDeclarationStructure | undefined {
+  if (!request) {
     return undefined;
   }
+  const mediaTypes: string[] = request.protocol.http?.mediaTypes ?? [];
 
-  const bodyParameterInterfaceName = `${operationName}BodyParam`;
-  // There is only one body parameter can't be more than one so we can safely take the first
-  const bodySignature = getPropertySignature(bodyParameters[0], importedModels);
+  if (!mediaTypes.length) {
+    return undefined;
+  }
 
-  internalReferences.add(bodyParameterInterfaceName);
+  const nameSuffix = requestIndex > 0 ? `${requestIndex}` : "";
+  const mediaTypesParameterInterfaceName = `${operationName}MediaTypesParam${nameSuffix}`;
+
+  // Mark the queryParameter interface for importing
+  internalReferences.add(mediaTypesParameterInterfaceName);
 
   return {
     isExported: true,
     kind: StructureKind.Interface,
-    name: bodyParameterInterfaceName,
+    name: mediaTypesParameterInterfaceName,
     properties: [
       {
-        name: "body",
-        type: bodySignature.type,
-        hasQuestionToken: bodySignature.hasQuestionToken
+        docs: ["Request content type"],
+        name: "contentType",
+        type: mediaTypes.map(mt => `"${mt}"`).join(" | "),
+        hasQuestionToken: true
       }
     ]
   };
@@ -121,8 +449,10 @@ function buildBodyParametersDefinition(
 function buildQueryParameterDefinition(
   operationName: string,
   parameters: Parameter[],
+  schemaUsage: SchemaContext[],
   importedModels: Set<string>,
-  internalReferences: Set<string>
+  internalReferences: Set<string>,
+  requestIndex: number
 ): InterfaceDeclarationStructure[] | undefined {
   const queryParameters = parameters.filter(
     p => p.protocol.http?.in === "query"
@@ -132,12 +462,13 @@ function buildQueryParameterDefinition(
     return undefined;
   }
 
-  const queryParameterInterfaceName = `${operationName}QueryParam`;
+  const nameSuffix = requestIndex > 0 ? `${requestIndex}` : "";
+  const queryParameterInterfaceName = `${operationName}QueryParam${nameSuffix}`;
   const queryParameterPropertiesName = `${operationName}QueryParamProperties`;
 
   // Get the property signature for each query parameter
   const propertiesDefinition = queryParameters.map(qp =>
-    getPropertySignature(qp, importedModels)
+    getPropertySignature(qp, schemaUsage, importedModels)
   );
 
   const hasRequiredParameters = propertiesDefinition.some(
@@ -182,12 +513,3 @@ function getAllOperations(model: CodeModel): Operation[] {
 
   return operations;
 }
-
-function getOperationParameters(operation: Operation): Parameter[] {
-  const signatureParameters = operation.signatureParameters ?? [];
-  // Extract parameters from the operation request
-  const request = operation.requests ? operation.requests[0] : undefined;
-  const requestParameters = request?.signatureParameters ?? [];
-
-  return [...signatureParameters, ...requestParameters];
-}

package/src/restLevelClient/generatePollingHelper.ts

@@ -0,0 +1,19 @@
+import { readFileSync } from "fs";
+import * as path from "path";
+import * as hbs from "handlebars";
+import { Project } from "ts-morph";
+import { getAutorestOptions } from "../autorestSession";
+
+export function generatePollingHelper(project: Project) {
+  let file: string = "";
+
+  file = readFileSync(path.join(__dirname, "pollingHelper.ts.hbs"), {
+    encoding: "utf-8"
+  });
+
+  const readmeFileContents = hbs.compile(file, { noEscape: true });
+  const { srcPath } = getAutorestOptions();
+  project.createSourceFile(path.join(srcPath, "pollingHelper.ts"), readmeFileContents({}), {
+    overwrite: true
+  });
+}

package/src/restLevelClient/generateResponseTypes.ts

@@ -3,6 +3,7 @@ import {
   HttpHeader,
   Operation,
   Response,
+  SchemaContext,
   SchemaResponse
 } from "@autorest/codemodel";
 import {
@@ -14,15 +15,24 @@ import {
   InterfaceDeclarationStructure,
   OptionalKind,
   Project,
+  PropertySignatureStructure,
   StructureKind
 } from "ts-morph";
 import { NameType, normalizeName } from "../utils/nameUtils";
-import { getElementType } from "./schemaHelpers";
+import {
+  getElementType,
+  getFormatDocs,
+  primitiveSchemaToType
+} from "./schemaHelpers";
 import { getLanguageMetadata } from "../utils/languageHelpers";
+import { hasOutputModels } from "./helpers/modelHelpers";
+import { getAutorestOptions } from "../autorestSession";
+import * as path from "path";
 
 export function generateResponseInterfaces(model: CodeModel, project: Project) {
+  const { srcPath } = getAutorestOptions();
   const responsesFile = project.createSourceFile(
-    `src/responses.ts`,
+    path.join(srcPath, `responses.ts`),
     undefined,
     {
       overwrite: true
@@ -63,9 +73,11 @@ export function generateResponseInterfaces(model: CodeModel, project: Project) {
 
       if (headersInterface) {
         hasHeaders = true;
+        responsesFile.addInterface(headersInterface);
       }
 
       const bodyType = getBodyTypeName(schemaResponse, importedModels);
+      const bodyDescription = getFormatDocs(schemaResponse.schema);
 
       // Get the information to build the Response Interface
       const responseTypeName = getResponseTypeName(operation, schemaResponse);
@@ -73,7 +85,8 @@ export function generateResponseInterfaces(model: CodeModel, project: Project) {
       const responseProperties = getResponseInterfaceProperties(
         schemaResponse,
         bodyType,
-        headersInterface?.name
+        headersInterface?.name,
+        bodyDescription
       );
 
       const responseInterfaceDefinition: OptionalKind<InterfaceDeclarationStructure> = {
@@ -96,6 +109,14 @@ export function generateResponseInterfaces(model: CodeModel, project: Project) {
     }
   }
 
+  if (hasHeaders) {
+    responsesFile.addImportDeclarations([
+      {
+        namedImports: ["RawHttpHeaders"],
+        moduleSpecifier: "@azure/core-rest-pipeline"
+      }
+    ]);
+  }
   responsesFile.addImportDeclarations([
     {
       namedImports: ["HttpResponse"],
@@ -103,19 +124,14 @@ export function generateResponseInterfaces(model: CodeModel, project: Project) {
     }
   ]);
 
-  if (hasHeaders) {
-    responsesFile.addImportDeclaration({
-      namedImports: ["RawHttpHeaders"],
-      moduleSpecifier: "@azure/core-rest-pipeline"
-    });
+  if (hasOutputModels(model)) {
+    responsesFile.addImportDeclarations([
+      {
+        namedImports: [...importedModels],
+        moduleSpecifier: "./outputModels"
+      }
+    ]);
   }
-
-  responsesFile.addImportDeclarations([
-    {
-      namedImports: [...importedModels],
-      moduleSpecifier: "./models"
-    }
-  ]);
 }
 
 /**
@@ -124,24 +140,32 @@ export function generateResponseInterfaces(model: CodeModel, project: Project) {
 function getResponseInterfaceProperties(
   response: Response,
   bodyTypeName?: string,
-  headersInterfaceName?: string
+  headersInterfaceName?: string,
+  bodyDescription?: string
 ) {
   const statusCode = getStatusCode(response);
-  const responseProperties = [
-    { name: "status", type: statusCode === `"default"` ? `"500"` : statusCode }
+  const responseProperties: PropertySignatureStructure[] = [
+    {
+      name: "status",
+      type: statusCode === `"default"` ? `string` : statusCode,
+      kind: StructureKind.PropertySignature
+    }
   ];
 
   if (bodyTypeName) {
     responseProperties.push({
       name: "body",
-      type: bodyTypeName
+      type: bodyTypeName,
+      kind: StructureKind.PropertySignature,
+      ...(bodyDescription && { docs: [{ description: bodyDescription }] })
     });
   }
 
   if (headersInterfaceName) {
     responseProperties.push({
       name: "headers",
-      type: `RawHttpHeaders & ${headersInterfaceName}`
+      type: `RawHttpHeaders & ${headersInterfaceName}`,
+      kind: StructureKind.PropertySignature
     });
   }
 
@@ -159,7 +183,11 @@ function getBodyTypeName(
   response: SchemaResponse,
   importedModels: Set<string>
 ): string | undefined {
-  return getElementType(response.schema, importedModels);
+  return getElementType(
+    response.schema,
+    [SchemaContext.Output, SchemaContext.Exception],
+    importedModels
+  );
 }
 
 function getResponseHeaderInterfaceDefinition(
@@ -182,7 +210,10 @@ function getResponseHeaderInterfaceDefinition(
         return {
           name: `"${h.header.toLowerCase()}"`,
           ...(description && { docs: [{ description }] }),
-          type: "string",
+          type: primitiveSchemaToType(h.schema, [
+            SchemaContext.Output,
+            SchemaContext.Exception
+          ]),
           hasQuestionToken: true
         };
       })