@autorest/typescript 6.0.0-beta.14 → 6.0.0-beta.17

package/src/restLevelClient/generateParameterTypes.ts

@@ -1,22 +1,26 @@
-
 import {
   CodeModel,
   Operation,
   Parameter,
-  SchemaContext
+  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 { getDocs, getPropertySignature } from "./getPropertySignature";
+import { getPropertySignature } from "./getPropertySignature";
 import { primitiveSchemaToType } from "./schemaHelpers";
-import { getOperationParameters } from "./helpers/getOperationParameters";
+import { getOperationParameters } from "./helpers/operationHelpers";
 import { hasInputModels } from "./helpers/modelHelpers";
+import { getAutorestOptions } from "../autorestSession";
 
 /**
  * Generates the interfaces describing each operation parameters
@@ -25,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
@@ -41,56 +46,106 @@ export function generateParameterInterfaces(
   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 headerParameterDefinitions =  buildHeaderParameterDefinitions(
-      operationName,
-      parameters,
-      parametersFile,
-      internalReferences,
-    );
-
-
-    const queryParameterDefinitions = buildQueryParameterDefinition(
-      operationName,
-      parameters,
-      [SchemaContext.Input],
-      importedModels,
-      internalReferences
-    );
-
-    const bodyParameterDefinition = buildBodyParametersDefinition(
-      operationName,
-      parameters,
-      [SchemaContext.Input],
-      importedModels,
-      internalReferences
-    );
-
-    // Add interfaces for body and query parameters
-    parametersFile.addInterfaces([
-      ...(bodyParameterDefinition ? [bodyParameterDefinition] : []),
-      ...(queryParameterDefinitions ?? []),
-      ...(headerParameterDefinitions ? [headerParameterDefinitions] : [])
-    ]);
 
-    if (headerParameterDefinitions !== undefined) {
-      hasHeaders = true;
+    const requestCount = operation?.requests?.length ?? 0;
+    const topParamName = `${operationName}Parameters`;
+    const subParamNames: string[] = [];
+
+    // 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) {
@@ -124,7 +179,9 @@ function getRequestHeaderInterfaceDefinition(
   baseName: string
 ): undefined | InterfaceDeclarationStructure {
   // Check if there are any required headers
-  const headerParameters = parameters.filter(p => p.protocol.http?.in === "header");
+  const headerParameters = parameters.filter(
+    p => p.protocol.http?.in === "header"
+  );
   if (!headerParameters.length) {
     return undefined;
   }
@@ -138,27 +195,37 @@ function getRequestHeaderInterfaceDefinition(
       return {
         name: `"${getLanguageMetadata(h.language).serializedName}"`,
         ...(description && { docs: [{ description }] }),
-        type: primitiveSchemaToType(h.schema, [SchemaContext.Input, SchemaContext.Exception]),
+        type: primitiveSchemaToType(h.schema, [
+          SchemaContext.Input,
+          SchemaContext.Exception
+        ]),
         hasQuestionToken: !h.required
       };
     })
-  }
+  };
 }
 
 function buildHeaderParameterDefinitions(
   operationName: string,
   parameters: Parameter[],
   parametersFile: SourceFile,
-  internalReferences: Set<string>
+  internalReferences: Set<string>,
+  requestIndex: number
 ): InterfaceDeclarationStructure | undefined {
-  const headerParameters = parameters.filter(p => p.protocol.http?.in === "header");
+  const headerParameters = parameters.filter(
+    p => p.protocol.http?.in === "header"
+  );
   if (!headerParameters.length) {
     return undefined;
   }
 
-  const headerParameterInterfaceName = `${operationName}HeaderParam`;
+  const nameSuffix = requestIndex > 0 ? `${requestIndex}` : "";
+  const headerParameterInterfaceName = `${operationName}HeaderParam${nameSuffix}`;
 
-  const headersInterface = getRequestHeaderInterfaceDefinition(headerParameters, operationName);
+  const headersInterface = getRequestHeaderInterfaceDefinition(
+    headerParameters,
+    operationName
+  );
 
   if (headersInterface) {
     parametersFile.addInterface(headersInterface);
@@ -180,6 +247,81 @@ function buildHeaderParameterDefinitions(
   };
 }
 
+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
  */
@@ -188,33 +330,114 @@ function buildBodyParametersDefinition(
   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],
-    schemaUsage,
-    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: [
       {
-        docs: bodySignature.docs,
-        name: "body",
-        type: bodySignature.type,
-        hasQuestionToken: bodySignature.hasQuestionToken
+        docs: ["Request content type"],
+        name: "contentType",
+        type: mediaTypes.map(mt => `"${mt}"`).join(" | "),
+        hasQuestionToken: true
       }
     ]
   };
@@ -228,7 +451,8 @@ function buildQueryParameterDefinition(
   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"
@@ -238,7 +462,8 @@ 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

package/src/restLevelClient/generatePollingHelper.ts

@@ -1,9 +1,8 @@
 import { readFileSync } from "fs";
-import { getSession } from "../autorestSession";
-import { extractPaginationDetails } from "../utils/extractPaginationDetails";
 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 = "";
@@ -13,7 +12,8 @@ export function generatePollingHelper(project: Project) {
   });
 
   const readmeFileContents = hbs.compile(file, { noEscape: true });
-  project.createSourceFile("src/pollingHelper.ts", readmeFileContents({}), {
+  const { srcPath } = getAutorestOptions();
+  project.createSourceFile(path.join(srcPath, "pollingHelper.ts"), readmeFileContents({}), {
     overwrite: true
   });
 }

package/src/restLevelClient/generateResponseTypes.ts

@@ -21,10 +21,14 @@ import {
 import { NameType, normalizeName } from "../utils/nameUtils";
 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
@@ -118,12 +122,14 @@ export function generateResponseInterfaces(model: CodeModel, project: Project) {
 
 
 
-  responsesFile.addImportDeclarations([
-    {
-      namedImports: [...importedModels],
-      moduleSpecifier: "./outputModels"
-    }
-  ]);
+  if (hasOutputModels(model)) {
+    responsesFile.addImportDeclarations([
+      {
+        namedImports: [...importedModels],
+        moduleSpecifier: "./outputModels"
+      }
+    ]);
+  }
 }
 
 /**

package/src/restLevelClient/generateRestLevel.ts

@@ -1,4 +1,4 @@
-import { getHost, getSession } from "../autorestSession";
+import { getAutorestOptions, getHost, getSession } from "../autorestSession";
 import { Project, IndentationText } from "ts-morph";
 import { generatePackageJson } from "../generators/static/packageFileGenerator";
 import { generateLicenseFile } from "../generators/static/licenseFileGenerator";
@@ -10,12 +10,23 @@ import { generateSchemaTypes } from "./generateSchemaTypes";
 import { format } from "prettier";
 import { prettierJSONOptions, prettierTypeScriptOptions } from "./config";
 import { generateParameterInterfaces } from "./generateParameterTypes";
-import { generatePathFirstClient } from "./generateClient";
+import { generatePathFirstClient } from "./generateClientDefinition";
+import { generateClient } from './generateClient';
 import { generateIndexFile } from "../generators/indexGenerator";
 import { generatePagingHelper } from "./generatePagingHelper";
 import { generatePollingHelper } from "./generatePollingHelper";
+import { generateTopLevelIndexFile } from './generateTopLevelIndexFile';
 import { hasPagingOperations } from "../utils/extractPaginationDetails";
 import { hasPollingOperations } from "./helpers/hasPollingOperations";
+import { generateKarmaConfigFile } from "../generators/static/karmaConfigFileGenerator";
+import { generateEnvFile } from "../generators/test/envFileGenerator";
+import { generateEnvBrowserFile } from "../generators/test/envBrowserFileGenerator";
+import { generateRecordedClientFile } from "../generators/test/recordedClientFileGenerator";
+import { generateSampleTestFile } from "../generators/test/sampleTestGenerator";
+import { generateEsLintConfig } from "../generators/static/esLintConfigGenerator";
+import { generateRollupConfig } from "../generators/static/rollupConfigFileGenerator";
+import { generateReadmeFile } from "../generators/static/readmeFileGenerator";
+
 /**
  * Generates a Rest Level Client library
  */
@@ -38,17 +49,31 @@ export async function generateRestLevelClient() {
     generatePollingHelper(project);
   }
 
+
   performCodeModelMutations(model);
+  generateReadmeFile(model.language, model.info, project);
   generatePackageJson(project);
   generateLicenseFile(project);
   generateTsConfig(project);
   generateApiExtractorConfig(project);
+  generateRollupConfig(project);
+  generateEsLintConfig(project);
+
+  generateKarmaConfigFile(project)
+  generateEnvFile(project);
+  generateEnvBrowserFile(project);
+  generateRecordedClientFile(project);
+  generateSampleTestFile(project);
+
   generateResponseInterfaces(model, project);
   generateSchemaTypes(model, project);
   generateParameterInterfaces(model, project);
   generatePathFirstClient(model, project);
+  generateClient(model, project);
   generateIndexFile(project);
 
+  generateTopLevelIndexFile(model, project);
+
   // Save the source files to the virtual filesystem
   project.saveSync();
   const fs = project.getFileSystem();
@@ -61,7 +86,7 @@ export async function generateRestLevelClient() {
     let fileContents = fs.readFileSync(filePath);
     const licenseHeader = `// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT license.\n`;
 
-    if (!isJson) {
+    if (isSourceCode) {
       fileContents = `${licenseHeader.trimLeft()}\n${fileContents}`;
     }
 
@@ -74,9 +99,9 @@ export async function generateRestLevelClient() {
     }
 
     // Write the file to the AutoRest host
-    host.WriteFile(
-      filePath.substr(1), // Get rid of the leading slash '/'
-      fileContents
-    );
+    host.writeFile({
+      filename: filePath.substr(1), // Get rid of the leading slash '/'
+      content: fileContents
+    });
   }
 }

package/src/restLevelClient/generateSchemaTypes.ts

@@ -1,9 +1,11 @@
 import { CodeModel, SchemaContext } from "@autorest/codemodel";
 import { Project } from "ts-morph";
+import * as path from 'path';
 import {
   buildObjectInterfaces,
   buildPolymorphicAliases
 } from "./generateObjectTypes";
+import { getAutorestOptions } from "../autorestSession";
 
 /**
  * Generates types to represent schema definitions in the swagger
@@ -18,10 +20,10 @@ export function generateSchemaTypes(model: CodeModel, project: Project) {
   const objectTypeAliases = buildPolymorphicAliases(model, [
     SchemaContext.Input
   ]);
-
+  const { srcPath } = getAutorestOptions();
   if (objectTypeAliases.length || objectsDefinitions.length) {
     const inputModelsFile = project.createSourceFile(
-      `src/models.ts`,
+      path.join(srcPath, `models.ts`),
       undefined,
       {
         overwrite: true
@@ -42,7 +44,7 @@ export function generateSchemaTypes(model: CodeModel, project: Project) {
 
   if (outputObjectTypeAliases.length || outputObjectsDefinitions.length) {
     const outputModelsFile = project.createSourceFile(
-      `src/outputModels.ts`,
+      path.join(srcPath, `outputModels.ts`),
       undefined,
       {
         overwrite: true

package/src/restLevelClient/generateTopLevelIndexFile.ts

@@ -0,0 +1,41 @@
+import { Project } from 'ts-morph';
+import * as path from 'path';
+import { getAutorestOptions } from '../autorestSession';
+import { CodeModel } from '@autorest/codemodel';
+import { NameType, normalizeName } from '../utils/nameUtils';
+
+const batchOutputFolder: [string, string, string][] = [];
+
+export function generateTopLevelIndexFile(model: CodeModel, project: Project) {
+    const { multiClient, batch, srcPath } = getAutorestOptions();
+    if (srcPath) {
+        const clientName = model.language.default.name;
+        const moduleName = normalizeName(clientName, NameType.File);
+        const relativePath = srcPath.replace('/src', '');
+        batchOutputFolder.push([relativePath, clientName, moduleName]);
+    }
+
+    if (multiClient && batch && batch.length > 1 && batchOutputFolder.length === batch.length) {
+        const { srcPath } = getAutorestOptions();
+        const fileDirectory= path.join(srcPath as string, '../../');
+        const file = project.createSourceFile('/src/index.ts', undefined, {
+            overwrite: true
+        });
+        file.moveToDirectory(fileDirectory);
+        const allModules: string[] = [];
+        batchOutputFolder.forEach(item => {
+            file.addImportDeclaration({
+                namespaceImport: item[1],
+                moduleSpecifier: `${item[0]}`
+            });
+            file.addExportDeclaration({
+                moduleSpecifier: `${item[0]}/${item[2]}`,
+                namedExports: [`${item[1]} as ${item[1]}Client`]
+            })
+            allModules.push(item[1]);
+        });
+        file.addExportDeclaration({
+            namedExports: [...allModules]
+        });
+    }
+}