@autorest/typescript 6.0.0-alpha.16.20220105.1 → 6.0.0-alpha.16.20220119.1

package/src/restLevelClient/generateClientDefinition.ts

@@ -0,0 +1,325 @@
+import {
+    CodeModel,
+    Operation,
+    ParameterLocation,
+    ImplementationLocation
+  } from "@autorest/codemodel";
+  
+  import { getResponseTypeName } from "./operationHelpers";
+  
+  import {
+    CallSignatureDeclarationStructure,
+    Project,
+    SourceFile,
+    StructureKind,
+    Writers
+  } from "ts-morph";
+  import * as path from 'path';
+  
+  import { getAutorestOptions, getSession } from "../autorestSession";
+  import { transformBaseUrl } from "../transforms/urlTransforms";
+  import { NameType, normalizeName } from "../utils/nameUtils";
+  import { getLanguageMetadata } from "../utils/languageHelpers";
+  import {
+    buildMethodDefinitions,
+    getOperationParameters,
+    getPathParamDefinitions
+  } from "./helpers/operationHelpers";
+  import { generateMethodShortcuts } from "./generateMethodShortcuts";
+  import { Methods, PathParameter, Paths } from "./interfaces";
+  export let pathDictionary: Paths = {};
+  
+  export function generatePathFirstClient(model: CodeModel, project: Project) {
+    const name = normalizeName(
+      getLanguageMetadata(model.language).name,
+      NameType.File
+    );
+    const { srcPath } = getAutorestOptions();
+    const clientFile = project.createSourceFile(path.join(srcPath, `clientDefinitions.ts`), undefined, {
+      overwrite: true
+    });
+  
+    // Get all paths
+    const importedParameters = new Set<string>();
+    const importedResponses = new Set<string>();
+    pathDictionary = {};
+    for (const operationGroup of model.operationGroups) {
+      for (const operation of operationGroup.operations) {
+        const operationName = getLanguageMetadata(operation.language).name;
+        const operationDescription = getLanguageMetadata(operation.language)
+          .description;
+        const pathParameters: PathParameter[] =
+          operation.parameters
+            ?.filter(p => p.protocol.http?.in === ParameterLocation.Path)
+            .map(p => {
+              const languageMetadata = getLanguageMetadata(p.language);
+              return {
+                name: languageMetadata.serializedName || languageMetadata.name,
+                schema: p.schema,
+                description: languageMetadata.description
+              };
+            }) || [];
+        const path: string = operation.requests?.[0].protocol.http?.path;
+        pathParameters.sort(function compare(a: PathParameter, b: PathParameter) {
+          return path.indexOf(a.name) - path.indexOf(b.name);
+        });
+  
+        for (const request of operation.requests || []) {
+          const path: string = (request.protocol.http?.path as string) || "";
+          const method = request.protocol.http?.method;
+  
+          if (path && method) {
+            if (!pathDictionary[path]) {
+              pathDictionary[path] = {
+                pathParameters,
+                methods: {},
+                name: operationName
+              };
+            }
+            const hasOptionalOptions = !hasRequiredOptions(operation);
+  
+            const newMethod = {
+              description: operationDescription,
+              optionsName: getOperationOptionsType(operation, importedParameters),
+              hasOptionalOptions,
+              returnType: `Promise<${getOperationReturnType(
+                operation,
+                importedResponses
+              )}>`
+            };
+  
+            if (pathDictionary[path].methods[`${method}`]) {
+              pathDictionary[path].methods[`${method}`].push(newMethod);
+            } else {
+              pathDictionary[path].methods[`${method}`] = [newMethod];
+            }
+          }
+        }
+      }
+    }
+  
+    writeShortcutInterface(model, pathDictionary, clientFile);
+    clientFile.addInterface({
+      name: "Routes",
+      isExported: true,
+      callSignatures: getPathFirstRoutesInterfaceDefinition(
+        pathDictionary,
+        clientFile
+      )
+    });
+  
+    const clientName = getLanguageMetadata(model.language).name;
+    const uriParameter = getClientUriParameter();
+  
+    const { addCredentials, credentialKeyHeaderName } = getAutorestOptions();
+    const credentialTypes = addCredentials ? ["TokenCredential"] : [];
+  
+    if (credentialKeyHeaderName) {
+      credentialTypes.push("KeyCredential");
+    }
+  
+    const clientIterfaceName = `${clientName}RestClient`;
+  
+    const { rlcShortcut } = getAutorestOptions();
+  
+    let shortcutElements = !rlcShortcut
+      ? []
+      : model.operationGroups.map(og => {
+          const groupName = og.language.default.name;
+          const name = normalizeName(groupName, NameType.Property);
+          const interfaceName = normalizeName(
+            `${name}Operations`,
+            NameType.Interface
+          );
+          return { name, type: interfaceName };
+        });
+  
+    // There may be operations without an operation group, those shortcut
+    // methods need to be handled differently.
+    const shortcutsInOperationGroup = shortcutElements.filter(s => s.name);
+  
+    clientFile.addTypeAlias({
+      isExported: true,
+      name: clientIterfaceName,
+      type: Writers.intersectionType(
+        "Client",
+        Writers.objectType({
+          properties: [
+            { name: "path", type: "Routes" },
+            ...shortcutsInOperationGroup
+          ]
+        }),
+        // If the length of shortcutMethods in operation group and all shortcutMethods
+        // is the same, then we don't have any operations at the client level
+        // Otherwise we need to make the client interface name an union with the
+        // definition of all client level shortcut methods
+        ...(shortcutsInOperationGroup.length !== shortcutElements.length
+          ? [`ClientOperations`]
+          : [])
+      )
+    });
+  
+    if (importedParameters.size) {
+      clientFile.addImportDeclaration({
+        namedImports: [...importedParameters],
+        moduleSpecifier: "./parameters"
+      });
+    }
+  
+    if (importedResponses.size) {
+      clientFile.addImportDeclaration({
+        namedImports: [...importedResponses],
+        moduleSpecifier: "./responses"
+      });
+    }
+  
+    clientFile.addImportDeclarations([
+      {
+        namedImports: ["Client"],
+        moduleSpecifier: "@azure-rest/core-client"
+      }
+    ]);
+  
+    clientFile.addImportDeclarations([
+      {
+        namedImports: credentialTypes,
+        moduleSpecifier: "@azure/core-auth"
+      }
+    ]);
+  }
+  
+  function writeShortcutInterface(
+    model: CodeModel,
+    pathDictionary: Paths,
+    clientFile: SourceFile
+  ) {
+    const { rlcShortcut } = getAutorestOptions();
+    if (!rlcShortcut) {
+      return;
+    }
+  
+    // Create a map of Operation group descriptions
+    const descriptions = model.operationGroups.reduce((map, current) => {
+      const { name, description } = current.language.default;
+      map.set(name, description);
+  
+      return map;
+    }, new Map<string, string>());
+  
+    const shortcuts = generateMethodShortcuts(model, pathDictionary);
+  
+    for (const group of Object.keys(shortcuts)) {
+      const groupName = normalizeName(group, NameType.Interface) || "Client";
+      const groupOperations = shortcuts[group];
+  
+      clientFile.addInterface({
+        docs: [
+          descriptions.get(group) ||
+            `Contains operations for ${groupName} operations`
+        ],
+        name: `${groupName}Operations`,
+        isExported: true,
+        methods: groupOperations
+      });
+    }
+  }
+  
+  function hasRequiredOptions(operation: Operation) {
+    return getOperationParameters(operation)
+      .filter(p => p.implementation === ImplementationLocation.Method)
+      .filter(p => ["query", "body", "headers"].includes(p.protocol.http?.in))
+      .some(p => p.required);
+  }
+  
+  function getOperationOptionsType(
+    operation: Operation,
+    importedParameters = new Set<string>()
+  ) {
+    const paramsName = `${
+      getLanguageMetadata(operation.language).name
+    }Parameters`;
+    importedParameters.add(paramsName);
+  
+    return paramsName;
+  }
+  
+  function getOperationReturnType(
+    operation: Operation,
+    importedResponses = new Set<string>()
+  ) {
+    let returnType: string = "HttpResponse";
+    if (operation.responses && operation.responses.length) {
+      const responses = [...operation.responses, ...(operation.exceptions || [])];
+  
+      const responseTypes = responses
+        .filter(
+          r => r.protocol.http?.statusCodes && r.protocol.http?.statusCodes.length
+        )
+        .map(r => {
+          const responseName = getResponseTypeName(operation, r);
+          importedResponses.add(responseName);
+          return responseName;
+        });
+  
+      if (responseTypes.length) {
+        returnType = responseTypes.join(" | ");
+      }
+    }
+  
+    return returnType;
+  }
+  
+  function getPathFirstRoutesInterfaceDefinition(
+    paths: Paths,
+    sourcefile: SourceFile
+  ): CallSignatureDeclarationStructure[] {
+    const signatures: CallSignatureDeclarationStructure[] = [];
+    for (const key of Object.keys(paths)) {
+      generatePathFirstRouteMethodsDefinition(
+        paths[key].name,
+        paths[key].methods,
+        sourcefile
+      );
+      const pathParams = paths[key].pathParameters;
+      signatures.push({
+        docs: [
+          `Resource for '${key
+            .replace(/}/g, "\\}")
+            .replace(
+              /{/g,
+              "\\{"
+            )}' has methods for the following verbs: ${Object.keys(
+            paths[key].methods
+          ).join(", ")}`
+        ],
+        parameters: [
+          { name: "path", type: `"${key}"` },
+          ...getPathParamDefinitions(pathParams)
+        ],
+        returnType: paths[key].name,
+        kind: StructureKind.CallSignature
+      });
+    }
+    return signatures;
+  }
+  
+  function getClientUriParameter() {
+    const { model } = getSession();
+    const { parameterName } = transformBaseUrl(model);
+    return parameterName;
+  }
+  
+  function generatePathFirstRouteMethodsDefinition(
+    operationName: string,
+    methods: Methods,
+    file: SourceFile
+  ): void {
+    const methodDefinitions = buildMethodDefinitions(methods);
+  
+    file.addInterface({
+      methods: methodDefinitions,
+      name: operationName,
+      isExported: true
+    });
+  }
+  

package/src/restLevelClient/generatePagingHelper.ts

@@ -1,5 +1,5 @@
 import { readFileSync } from "fs";
-import { getSession } from "../autorestSession";
+import { getAutorestOptions, getSession } from "../autorestSession";
 import { extractPaginationDetails } from "../utils/extractPaginationDetails";
 import * as path from "path";
 import * as hbs from "handlebars";
@@ -29,9 +29,10 @@ export function generatePagingHelper(project: Project) {
     return `"${value}"`;
   });
 
+  const { srcPath } = getAutorestOptions();
   const readmeFileContents = hbs.compile(file, { noEscape: true });
   project.createSourceFile(
-    "src/paginateHelper.ts",
+    path.join(srcPath, "paginateHelper.ts"),
     readmeFileContents(pagingInfo),
     {
       overwrite: true

package/src/restLevelClient/generateParameterTypes.ts

@@ -3,7 +3,8 @@ import {
   Operation,
   Parameter,
   SchemaContext,
-  Request as OperationRequest
+  Request as OperationRequest,
+  ParameterLocation
 } from "@autorest/codemodel";
 import {
   InterfaceDeclarationStructure,
@@ -12,12 +13,14 @@ import {
   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
@@ -26,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
@@ -74,6 +78,15 @@ export function generateParameterInterfaces(
 
       const request = operation.requests ? operation.requests[i] : undefined;
 
+      const pathParameterDefinitions = buildPathParameterDefinitions(
+        operationName,
+        parameters,
+        model,
+        parametersFile,
+        internalReferences,
+        i
+      )
+
       const headerParameterDefinitions = buildHeaderParameterDefinitions(
         operationName,
         parameters,
@@ -102,6 +115,7 @@ export function generateParameterInterfaces(
       parametersFile.addInterfaces([
         ...(bodyParameterDefinition ?? []),
         ...(queryParameterDefinitions ?? []),
+        ...(pathParameterDefinitions ? [pathParameterDefinitions]: []),
         ...(headerParameterDefinitions ? [headerParameterDefinitions] : []),
         ...(contentTypeParameterDefinition
           ? [contentTypeParameterDefinition]
@@ -233,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
  */

package/src/restLevelClient/generatePollingHelper.ts

@@ -2,6 +2,7 @@ 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 = "";
@@ -11,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

@@ -22,10 +22,13 @@ 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

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,10 +10,12 @@ 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";
@@ -21,6 +23,7 @@ import { generateEnvFile } from "../generators/test/envFileGenerator";
 import { generateEnvBrowserFile } from "../generators/test/envBrowserFileGenerator";
 import { generateRecordedClientFile } from "../generators/test/recordedClientFileGenerator";
 import { generateSampleTestFile } from "../generators/test/sampleTestGenerator";
+
 /**
  * Generates a Rest Level Client library
  */
@@ -59,7 +62,10 @@ export async function generateRestLevelClient() {
   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();

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 { 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 (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]
+        });
+    }
+}

package/src/utils/autorestOptions.ts

@@ -33,6 +33,7 @@ export async function extractAutorestOptions(): Promise<AutorestOptions> {
   const headAsBoolean = await getHeadAsBoolean(host);
   const isTestPackage = await getIsTestPackage(host);
   const generateTest = await getGenerateTest(host);
+  const batch = await getBatch(host);
   const generateSample = await getGenerateSample(host);
 
   return {
@@ -59,6 +60,7 @@ export async function extractAutorestOptions(): Promise<AutorestOptions> {
     headAsBoolean,
     isTestPackage,
     generateTest,
+    batch,
     generateSample
   };
 }
@@ -284,3 +286,10 @@ async function getAzureOutputDirectoryPath(
     ? outputDirectoryRelativePath
     : undefined;
 }
+
+
+async function getBatch(host: AutorestExtensionHost): Promise<[string, any][] | undefined> {
+  const batch = await host.getValue<[string, any][]>('batch');
+  return batch;
+  
+}