@autorest/typescript 6.0.0-beta.15 → 6.0.0-beta.18

package/src/generators/utils/pagingOperations.ts

@@ -230,7 +230,7 @@ export function writeAsyncIterators(
  * This method enforces Azure SDK Typescript guideline that paging methods should be named list*
  * https://azure.github.io/azure-sdk/typescript_design.html#ts-pagination-provide-list
  */
-function getPublicMethodName(operation: OperationDetails) {
+export function getPublicMethodName(operation: OperationDetails) {
   let initialOperationName = normalizeName(operation.name, NameType.Operation);
   if (initialOperationName.indexOf("list") === 0) {
     initialOperationName = initialOperationName.replace("list", "");

package/src/main.ts

@@ -1,7 +1,10 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
-import { AutoRestExtension, Host } from "@autorest/extension-base";
+import {
+  AutoRestExtension,
+  AutorestExtensionHost
+} from "@autorest/extension-base";
 import { generateTypeScriptLibrary } from "./typescriptGenerator";
 import { generateRestLevelClient } from "./restLevelClient/generateRestLevel";
 import {
@@ -10,7 +13,7 @@ import {
   getAutorestOptions
 } from "./autorestSession";
 
-export async function processRequest(host: Host) {
+export async function processRequest(host: AutorestExtensionHost) {
   await initializeSession(host);
   const session = getSession();
   const { restLevelClient } = getAutorestOptions();
@@ -19,7 +22,7 @@ export async function processRequest(host: Host) {
     restLevelClient
       ? await generateRestLevelClient()
       : await generateTypeScriptLibrary(session.model, host);
-    session.log(`Autorest.Typescript took ${Date.now() - start}ms`, "");
+    session.info(`Autorest.Typescript took ${Date.now() - start}ms`);
   } catch (err) {
     session.error("An error was encountered while handling a request:", err);
     throw err;
@@ -28,8 +31,8 @@ export async function processRequest(host: Host) {
 
 async function main() {
   const pluginHost = new AutoRestExtension();
-  pluginHost.Add("typescript", processRequest);
-  await pluginHost.Run();
+  pluginHost.add("typescript", processRequest);
+  await pluginHost.run();
 }
 
 main();

package/src/models/clientDetails.ts

@@ -9,6 +9,7 @@ import { ObjectDetails } from "./modelDetails";
 import { EndpointDetails } from "../transforms/urlTransforms";
 import { KnownMediaType } from "@azure-tools/codegen";
 import { Info } from "@autorest/codemodel";
+import { SampleGroup } from "./sampleDetails";
 
 export interface ClientOptions {
   mediaTypes?: Set<KnownMediaType>;
@@ -20,6 +21,11 @@ export interface TracingInfo {
   packagePrefix: string;
 }
 
+export interface DependencyInfo {
+  link: string;
+  description: string;
+}
+
 export interface ClientDetails {
   name: string;
   className: string;
@@ -32,4 +38,6 @@ export interface ClientDetails {
   parameters: ParameterDetails[];
   options: ClientOptions;
   endpoint: EndpointDetails;
+  samples?: SampleGroup[];
+  allTypes: string[];
 }

package/src/models/modelDetails.ts

@@ -65,7 +65,7 @@ export type PolymorphicObjectDetails = BasicObjectDetails & {
 export interface PropertyDetails {
   name: string;
   description?: string;
-  defaultValue?: string;
+  defaultValue?: string | number | boolean;
   serializedName: string;
   type: string;
   required: boolean;
@@ -83,7 +83,7 @@ export interface TypeDetails {
   typeName: string;
   isConstant?: boolean;
   nullable?: boolean;
-  defaultValue?: string;
+  defaultValue?: string | number | boolean;
   kind: PropertyKind;
   usedModels: string[];
 }

package/src/models/operationDetails.ts

@@ -103,6 +103,7 @@ export interface OperationSpecDetails {
 export interface OperationGroupDetails {
   key: string;
   name: string;
+  originalKey: string;
   operations: OperationDetails[];
   mediaTypes: Set<KnownMediaType>;
   isTopLevel: boolean;

package/src/models/sampleDetails.ts

@@ -0,0 +1,22 @@
+export interface SampleGroup {
+    sampleFileName: string,
+    clientClassName: string,
+    clientPackageName: string,
+    samples: SampleDetails[],
+    importedTypes?: string[],
+}
+
+export interface SampleDetails {
+    sampleFunctionName: string,
+    clientParameterNames: string,
+    methodParameterNames: string,
+    clientParamAssignments: string[],
+    methodParamAssignments: string[],
+    originalFileLocation?: string,
+    operationName: string,
+    isTopLevel: boolean,
+    isPaging: boolean,
+    operationGroupName: string,
+    operationDescription: string,
+    clientClassName: string,
+}

package/src/restLevelClient/generateClient.ts

@@ -2,136 +2,47 @@ import {
   CodeModel,
   Operation,
   ParameterLocation,
-  ImplementationLocation,
-  Schema,
-  SchemaContext
+  ImplementationLocation
 } from "@autorest/codemodel";
 
-import { getResponseTypeName } from "./operationHelpers";
-
 import {
-  CallSignatureDeclarationStructure,
-  MethodSignatureStructure,
-  OptionalKind,
   Project,
-  SourceFile,
   StatementStructures,
   StructureKind,
   VariableDeclarationKind,
   VariableStatementStructure,
-  WriterFunction,
-  Writers
+  WriterFunction
 } 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 { isConstantSchema, getElementType } from "./schemaHelpers";
+import { isConstantSchema } from "./schemaHelpers";
 import { getLanguageMetadata } from "../utils/languageHelpers";
-import { getOperationParameters } from "./helpers/getOperationParameters";
-import { ParameterPath } from "@azure/core-http";
-
-type PathParameter = { name: string; schema: Schema, description?: string };
+import { generateMethodShortcutImplementation } from "./generateMethodShortcuts";
+import { Paths } from "./interfaces";
+import { pathDictionary } from "./generateClientDefinition";
 
-type Methods = {
-  [key: string]: [
-    {
-      optionsName: string;
-      description: string;
-      hasOptionalOptions: boolean;
-      returnType: string;
-    }
-  ];
-};
-type Paths = {
-  [key: string]: {
-    name: string;
-    pathParameters: PathParameter[];
-    methods: Methods;
-  };
-};
-
-export function generatePathFirstClient(model: CodeModel, project: Project) {
+export function generateClient(model: CodeModel, project: Project) {
   const name = normalizeName(
     getLanguageMetadata(model.language).name,
     NameType.File
   );
-  const clientFile = project.createSourceFile(`src/${name}.ts`, undefined, {
-    overwrite: true
-  });
-
-  // Get all paths
-  const importedParameters = new Set<string>();
-  const importedResponses = new Set<string>();
-  const pathDictionary: Paths = {};
-  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];
-          }
-        }
-      }
+  const { srcPath } = getAutorestOptions();
+  const clientFile = project.createSourceFile(
+    path.join(srcPath, `${name}.ts`),
+    undefined,
+    {
+      overwrite: true
     }
-  }
-
-  clientFile.addInterface({
-    name: "Routes",
-    isExported: true,
-    callSignatures: getPathFirstRoutesInterfaceDefinition(
-      pathDictionary,
-      clientFile
-    )
-  });
+  );
 
+  // Get all paths
   const clientName = getLanguageMetadata(model.language).name;
   const uriParameter = getClientUriParameter();
 
-  const { addCredentials, credentialKeyHeaderName } = getAutorestOptions();
+  const { addCredentials, credentialKeyHeaderName, multiClient, batch, credentialScopes } = getAutorestOptions();
   const credentialTypes = addCredentials ? ["TokenCredential"] : [];
 
   if (credentialKeyHeaderName) {
@@ -140,84 +51,59 @@ export function generatePathFirstClient(model: CodeModel, project: Project) {
 
   const commonClientParams = [
     ...(uriParameter ? [{ name: uriParameter, type: "string" }] : []),
-    ...(addCredentials === false
+    ...(addCredentials === false || !credentialScopes || credentialScopes.length === 0
       ? []
       : [{ name: "credentials", type: credentialTypes.join(" | ") }])
   ];
-  const clientIterfaceName = `${clientName}RestClient`;
-  // const factoryTypeName = `${clientName}Factory`;
-  clientFile.addTypeAlias({
-    isExported: true,
-    name: clientIterfaceName,
-    type: Writers.intersectionType(
-      "Client",
-      Writers.objectType({ properties: [{ name: "path", type: "Routes" }] })
-    )
-  });
+  const clientInterfaceName = clientName.endsWith("Client")? `${clientName}`: `${clientName}Client`;
 
-  clientFile.addFunction({
+  const functionStatement = {
     isExported: true,
-    name: clientName,
+    name: `createClient`,
     parameters: [
       ...commonClientParams,
       { name: "options", type: "ClientOptions = {}" }
     ],
-    returnType: clientIterfaceName,
-    isDefaultExport: true,
-    statements: getClientFactoryBody(clientIterfaceName)
-  });
-
-  if (importedParameters.size) {
-    clientFile.addImportDeclaration({
-      namedImports: [...importedParameters],
-      moduleSpecifier: "./parameters"
-    });
-  }
+    returnType: clientInterfaceName,
+    isDefaultExport: false,
+    statements: getClientFactoryBody(clientInterfaceName, pathDictionary)
+  };
 
-  if (importedResponses.size) {
-    clientFile.addImportDeclaration({
-      namedImports: [...importedResponses],
-      moduleSpecifier: "./responses"
-    });
+  if (!multiClient || !batch || batch.length === 1) {
+    functionStatement.isDefaultExport = true;
   }
+  clientFile.addFunction(functionStatement);
 
   clientFile.addImportDeclarations([
     {
-      namedImports: ["getClient", "ClientOptions", "Client"],
+      namedImports: ["getClient", "ClientOptions"],
       moduleSpecifier: "@azure-rest/core-client"
     }
   ]);
 
+  if (addCredentials && credentialScopes && credentialScopes.length > 0) {
+    clientFile.addImportDeclarations([
+      {
+        namedImports: credentialTypes,
+        moduleSpecifier: "@azure/core-auth"
+      }
+    ]);
+  }
   clientFile.addImportDeclarations([
     {
-      namedImports: credentialTypes,
-      moduleSpecifier: "@azure/core-auth"
+      namedImports: [`${clientInterfaceName}`],
+      moduleSpecifier: "./clientDefinitions"
     }
   ]);
 }
 
-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 getClientFactoryBody(
-  clientTypeName: string
+  clientTypeName: string,
+  paths: Paths
 ): string | WriterFunction | (string | WriterFunction | StatementStructures)[] {
+  const { rlcShortcut, packageDetails } = getAutorestOptions();
+  let clientPackageName = packageDetails.nameWithoutScope;
+  const packageVersion = packageDetails.version;
   const { model } = getSession();
   const { endpoint, parameterName } = transformBaseUrl(model);
   let baseUrl: string;
@@ -237,6 +123,30 @@ function getClientFactoryBody(
     apiVersionStatement = `options.apiVersion = options.apiVersion ?? "${apiVersion}"`;
   }
 
+  if (!clientPackageName.endsWith("-rest")) {
+    clientPackageName = clientPackageName + "-rest";
+  }
+  const userAgentInfoStatement =
+    "const userAgentInfo = `azsdk-js-" +
+    clientPackageName +
+    "/" +
+    packageVersion +
+    "`;";
+  const userAgentPrefix =
+    "options.userAgentOptions && options.userAgentOptions.userAgentPrefix ? `${options.userAgentOptions.userAgentPrefix} ${userAgentInfo}`: `${userAgentInfo}`;";
+  const userAgentStatement: VariableStatementStructure = {
+    kind: StructureKind.VariableStatement,
+    declarationKind: VariableDeclarationKind.Const,
+    declarations: [{ name: "userAgentPrefix", initializer: userAgentPrefix }]
+  };
+
+  const userAgentOptionsStatement = `options = {
+    ...options,
+    userAgentOptions: {
+      userAgentPrefix
+    }
+  }`;
+
   const baseUrlStatement: VariableStatementStructure = {
     kind: StructureKind.VariableStatement,
     declarationKind: VariableDeclarationKind.Const,
@@ -262,17 +172,43 @@ function getClientFactoryBody(
       credentials: {
         ${scopes}
         ${apiKeyHeaderName}
-      }
+      },
     }`
       : "";
 
-  const getClient = `return getClient(
-      baseUrl,
-      ${credentials ? "credentials," : ""}
-      options
-    ) as ${clientTypeName};`;
+  const getClient = `const client = getClient(
+      baseUrl, ${credentials ? "credentials," : ""} options
+    ) as ${clientTypeName};
+    `;
 
-  return [baseUrlStatement, apiVersionStatement, credentials, getClient];
+  let returnStatement = `return client;`;
+
+  if (rlcShortcut) {
+    const shortcutImplementations = generateMethodShortcutImplementation(
+      model,
+      paths
+    );
+    const shortcutBody = Object.keys(shortcutImplementations).map(key => {
+      // If the operation group has an empty name, it means its operations are client
+      // level operations so we need to spread the definitions. Otherwise they are
+      // within an operation group so we add them as key: value
+      return `${key ? `"${key}":` : "..."} {${shortcutImplementations[
+        key
+      ].join()}}`;
+    });
+    returnStatement = `return { ...client, ${shortcutBody.join()} };`;
+  }
+
+  return [
+    baseUrlStatement,
+    apiVersionStatement,
+    credentials,
+    userAgentInfoStatement,
+    userAgentStatement,
+    userAgentOptionsStatement,
+    getClient,
+    returnStatement
+  ];
 }
 
 function getApiVersion(): string | undefined {
@@ -299,103 +235,8 @@ function getApiVersion(): string | undefined {
   return undefined;
 }
 
-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}"` },
-        ...pathParams.map(p => {
-          return { name: p.name, type: getElementType(p.schema, [SchemaContext.Input, SchemaContext.Exception]), description: p.description };
-        })
-      ],
-      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: OptionalKind<MethodSignatureStructure>[] = [];
-  for (const key of Object.keys(methods)) {
-    const method = methods[key];
-    const description = methods[key][0].description;
-
-    let areAllOptional = !method.some(m => !m.hasOptionalOptions);
-
-    methodDefinitions.push({
-      name: key,
-      ...(description && { docs: [{ description }] }),
-      parameters: [
-        {
-          name: "options",
-          hasQuestionToken: areAllOptional,
-          type: method.map(m => m.optionsName).join(" | ")
-        }
-      ],
-      returnType: method.map(m => m.returnType).join(" | ")
-    });
-  }
-
-  file.addInterface({
-    methods: methodDefinitions,
-    name: operationName,
-    isExported: true
-  });
-}