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

package/src/utils/autorestOptions.ts

@@ -1,6 +1,6 @@
-import { Channel, Host } from "@autorest/extension-base";
+import { Channel, AutorestExtensionHost } from "@autorest/extension-base";
 import { AutorestOptions, getHost, getSession } from "../autorestSession";
-import { TracingInfo } from "../models/clientDetails";
+import { DependencyInfo, TracingInfo } from "../models/clientDetails";
 import { PackageDetails } from "../models/packageDetails";
 import { NameType, normalizeName } from "./nameUtils";
 
@@ -11,12 +11,14 @@ export async function extractAutorestOptions(): Promise<AutorestOptions> {
   const host = getHost();
   const useCoreV2 = await getUseCoreV2(host);
   const restLevelClient = await getRestLevelClient(host);
+  const rlcShortcut = await getHasShortcutMethods(host);
   const azureArm = await getIsAzureArm(host);
   const addCredentials = await getAddCredentials(host);
-  const credentialKeyHeaderName = await getKeyCredentialHeaderName(host);
+  const security = await getSecurity(host);
+  const securityHeaderName = await getSecurityHeaderName(host);
   const srcPath = await getSrcPath(host);
   const outputPath = await getOutputPath(host);
-  const credentialScopes = await getCredentialScopes(host);
+  const securityScopes = await getSecurityScopes(host);
   const packageDetails = await getPackageDetails(host);
   const licenseHeader = await getLicenseHeader(host);
   const generateMetadata = await getGenerateMetadata(host);
@@ -31,13 +33,23 @@ export async function extractAutorestOptions(): Promise<AutorestOptions> {
   const azureOutputDirectory = await getAzureOutputDirectoryPath(host);
   const headAsBoolean = await getHeadAsBoolean(host);
   const isTestPackage = await getIsTestPackage(host);
+  const generateSample = await getGenerateSample(host);
+  const generateTest = await getGenerateTest(host);
+  const batch = await getBatch(host);
+  const multiClient = await getMultiClient(host);
+  const productDocLink = await getProductDocLink(host);
+  const coreHttpCompatMode = await getCoreHttpCompatMode(host);
+  const azureSdkForJs = await getAzureSdkForJs(host);
+  const dependencyInfo = await getDependencyInfo(host);
 
   return {
     azureArm,
     addCredentials,
-    credentialKeyHeaderName,
-    credentialScopes,
+    security,
+    securityHeaderName,
+    securityScopes,
     restLevelClient,
+    rlcShortcut,
     srcPath,
     outputPath,
     packageDetails,
@@ -53,73 +65,126 @@ export async function extractAutorestOptions(): Promise<AutorestOptions> {
     title,
     azureOutputDirectory,
     headAsBoolean,
-    isTestPackage
+    isTestPackage,
+    generateTest,
+    batch,
+    multiClient,
+    generateSample,
+    azureSdkForJs,
+    productDocLink,
+    coreHttpCompatMode,
+    dependencyInfo
   };
 }
 
-async function getHeadAsBoolean(host: Host): Promise<boolean> {
-  const headAsBoolean = await host.GetValue("head-as-boolean");
+async function getHasShortcutMethods(
+  host: AutorestExtensionHost
+): Promise<boolean> {
+  const headAsBoolean = await host.getValue("rlc-shortcut");
 
   return Boolean(headAsBoolean);
 }
 
-async function getIsTestPackage(host: Host): Promise<boolean> {
-  const isTestPackage: boolean = await host.GetValue("is-test-package");
+async function getHeadAsBoolean(host: AutorestExtensionHost): Promise<boolean> {
+  const headAsBoolean = await host.getValue("head-as-boolean");
+
+  return Boolean(headAsBoolean);
+}
+
+async function getIsTestPackage(host: AutorestExtensionHost): Promise<boolean> {
+  const isTestPackage = await host.getValue("is-test-package");
   return isTestPackage === null ? false : Boolean(isTestPackage);
 }
 
-async function getSkipEnumValidation(host: Host): Promise<boolean> {
-  const skipEnumValidation = await host.GetValue("skip-enum-validation");
+async function getGenerateSample(
+  host: AutorestExtensionHost
+): Promise<boolean> {
+  const generateSample = await host.getValue("generate-sample");
+  return generateSample === undefined || generateSample === null ? false : Boolean(generateSample);
+}
+
+async function getGenerateTest(host: AutorestExtensionHost): Promise<boolean> {
+  const generateTest = await host.getValue("generate-test");
+  return generateTest === null ? false : Boolean(generateTest);
+}
+
+async function getAzureSdkForJs(host: AutorestExtensionHost): Promise<boolean> {
+  const azureSdkForJs = await host.getValue("azure-sdk-for-js");
+  return azureSdkForJs === undefined || azureSdkForJs === null
+    ? true
+    : Boolean(azureSdkForJs);
+}
+
+async function getSkipEnumValidation(
+  host: AutorestExtensionHost
+): Promise<boolean> {
+  const skipEnumValidation = await host.getValue("skip-enum-validation");
 
   return skipEnumValidation === true;
 }
 
-async function getAllowInsecureConnection(host: Host): Promise<boolean> {
-  return (await host.GetValue("allow-insecure-connection")) || false;
+async function getAllowInsecureConnection(
+  host: AutorestExtensionHost
+): Promise<boolean> {
+  return (await host.getValue("allow-insecure-connection")) || false;
 }
 
-async function getIgnoreNullableOnOptional(host: Host): Promise<boolean> {
+async function getIgnoreNullableOnOptional(
+  host: AutorestExtensionHost
+): Promise<boolean> {
   const isAzureArm = await getIsAzureArm(host);
-  return (await host.GetValue("ignore-nullable-on-optional"))
+  return (await host.getValue("ignore-nullable-on-optional"))
     ? true
     : isAzureArm;
 }
 
-async function getDisableAsyncOperators(host: Host): Promise<boolean> {
-  return (await host.GetValue("disable-async-iterators")) === true;
+async function getDisableAsyncOperators(
+  host: AutorestExtensionHost
+): Promise<boolean> {
+  return (await host.getValue("disable-async-iterators")) === true;
 }
 
-async function getHideClients(host: Host): Promise<boolean> {
-  return (await host.GetValue("hide-clients")) || false;
+async function getHideClients(host: AutorestExtensionHost): Promise<boolean> {
+  return (await host.getValue("hide-clients")) || false;
 }
-async function getGenerateMetadata(host: Host) {
-  return (await host.GetValue("generate-metadata")) !== false;
+async function getGenerateMetadata(host: AutorestExtensionHost) {
+  return (await host.getValue("generate-metadata")) !== false;
 }
 
-async function getLicenseHeader(host: Host): Promise<boolean> {
-  return (await host.GetValue("license-header")) || false;
+async function getLicenseHeader(host: AutorestExtensionHost): Promise<boolean> {
+  const license: boolean | undefined = await host.getValue("license-header");
+  if (license === undefined) {
+    return true;
+  }
+  return license;
 }
 
-async function getTitle(host: Host): Promise<string | undefined> {
-  return (await host.GetValue("title")) || undefined;
+async function getTitle(
+  host: AutorestExtensionHost
+): Promise<string | undefined> {
+  return (await host.getValue("title")) || undefined;
 }
 
-async function getSrcPath(host: Host): Promise<string> {
-  return ((await host.GetValue("source-code-folder-path")) as string) || "src";
+async function getSrcPath(host: AutorestExtensionHost): Promise<string> {
+  return ((await host.getValue("source-code-folder-path")) as string) || "src";
 }
 
-async function getOutputPath(host: Host): Promise<string | undefined> {
-  return (await host.GetValue("output-folder")) || undefined;
+async function getOutputPath(
+  host: AutorestExtensionHost
+): Promise<string | undefined> {
+  return (await host.getValue("output-folder")) || undefined;
 }
 
-async function getKeyCredentialHeaderName(
-  host: Host
+async function getSecurityHeaderName(
+  host: AutorestExtensionHost
 ): Promise<string | undefined> {
-  return (await host.GetValue("credential-key-header-name")) || undefined;
+  return (await host.getValue("security-header-name")) || undefined;
 }
 
-async function getAddCredentials(host: Host): Promise<boolean> {
-  const addCredentials = await host.GetValue("add-credentials");
+async function getAddCredentials(
+  host: AutorestExtensionHost
+): Promise<boolean> {
+  const addCredentials = await host.getValue("add-credentials");
 
   // Only set addCredentials to false if explicitly set to false
   // otherwise default to true
@@ -129,34 +194,46 @@ async function getAddCredentials(host: Host): Promise<boolean> {
     return true;
   }
 }
-async function getIsAzureArm(host: Host): Promise<boolean> {
-  const flag = (await host.GetValue("azure-arm")) === true;
-  const openapi = (await host.GetValue("openapi-type")) === "arm";
+
+async function getSecurity(
+  host: AutorestExtensionHost
+): Promise<string | undefined> {
+  const security: string | undefined = await host.getValue("security");
+  return security
+}
+
+async function getIsAzureArm(host: AutorestExtensionHost): Promise<boolean> {
+  const flag = (await host.getValue("azure-arm")) === true;
+  const openapi = (await host.getValue("openapi-type")) === "arm";
 
   return flag || openapi;
 }
 
-async function getRestLevelClient(host: Host): Promise<boolean> {
-  return (await host.GetValue("rest-level-client")) === true;
+async function getRestLevelClient(
+  host: AutorestExtensionHost
+): Promise<boolean> {
+  return (await host.getValue("rest-level-client")) === true;
 }
 
-async function getUseCoreV2(host: Host): Promise<boolean> {
-  const useCoreV2Option: boolean = await host.GetValue("use-core-v2");
+async function getUseCoreV2(host: AutorestExtensionHost): Promise<boolean> {
+  const useCoreV2Option = await host.getValue("use-core-v2");
   return useCoreV2Option === null ? true : Boolean(useCoreV2Option);
 }
 
-async function getTracingInfo(host: Host): Promise<TracingInfo | undefined> {
+async function getTracingInfo(
+  host: AutorestExtensionHost
+): Promise<TracingInfo | undefined> {
   const tracing: TracingInfo | undefined =
-    (await host.GetValue("tracing-info")) || undefined;
+    (await host.getValue("tracing-info")) || undefined;
 
-  if (tracing && tracing.namespace && tracing.packagePrefix) {
+  if (tracing && tracing.namespace) {
     return tracing;
   }
 
-  const namespace =
-    (await host.GetValue("tracing-info.namespace")) || undefined;
-  const packagePrefix =
-    (await host.GetValue("tracing-info.packagePrefix")) || undefined;
+  const namespace: string | undefined =
+    (await host.getValue<string>("tracing-info.namespace")) || undefined;
+  const packagePrefix: string | undefined =
+    (await host.getValue("tracing-info.packagePrefix")) || undefined;
 
   if (packagePrefix && namespace) {
     return {
@@ -174,13 +251,17 @@ async function getTracingInfo(host: Host): Promise<TracingInfo | undefined> {
   );
 }
 
-async function getPackageDetails(host: Host): Promise<PackageDetails> {
+async function getPackageDetails(
+  host: AutorestExtensionHost
+): Promise<PackageDetails> {
   const { model } = getSession();
   const name = normalizeName(model.language.default.name, NameType.File);
   // TODO: Look for an existing package.json and
-  const packageName = (await host.GetValue("package-name")) || name;
-  const packageNameParts = packageName.match(/(^@(.*)\/)?(.*)/);
-  const version = (await host.GetValue("package-version")) || "1.0.0-beta.1";
+  const packageName: string = (await host.getValue("package-name")) || name;
+  const packageNameParts: RegExpMatchArray =
+    packageName.match(/(^@(.*)\/)?(.*)/) ?? [];
+  const version: string =
+    (await host.getValue("package-version")) || "1.0.0-beta.1";
 
   return {
     name: packageName,
@@ -191,46 +272,20 @@ async function getPackageDetails(host: Host): Promise<PackageDetails> {
   };
 }
 
-export async function getCredentialScopes(
-  host: Host
+export async function getSecurityScopes(
+  host: AutorestExtensionHost
 ): Promise<string[] | undefined> {
-  const addCredentials = await host.GetValue("add-credentials");
-  const credentialScopes = await host.GetValue("credential-scopes");
-  const azureArm = await host.GetValue("azure-arm");
-
-  if (credentialScopes && !addCredentials) {
-    throw new Error(
-      "--credential-scopes must be used with the --add-credentials flag"
-    );
+  const securityScopes: string | undefined = await host.getValue("security-scopes");
+  if(securityScopes !== undefined && typeof securityScopes === "string") {
+    return securityScopes.split(",");
   }
-
-  if (!credentialScopes) {
-    if (azureArm) {
-      return ["https://management.azure.com/.default"];
-    } else if (addCredentials) {
-      host.Message({
-        Channel: Channel.Warning,
-        Text: `You have default credential policy BearerTokenCredentialPolicy
-        but not the --credential-scopes flag set while generating non-management plane code.
-        This is not recommended because it forces the customer to pass credential scopes
-        through kwargs if they want to authenticate.`
-      });
-    }
-  }
-
-  if (typeof credentialScopes === "string") {
-    return credentialScopes.split(",");
-  }
-
-  return undefined;
+  return securityScopes;
 }
 
 async function getAzureOutputDirectoryPath(
-  host: Host
+  host: AutorestExtensionHost
 ): Promise<string | undefined> {
-  const outputDirectoryPath: string | null = await host.GetValue(
-    "outputFolderUri"
-  );
+  const outputDirectoryPath = await host.getValue<string>("outputFolderUri");
   const outputDirectoryRelativePath: string | undefined = outputDirectoryPath
     ?.replace(/\/$/, "")
     .split("/")
@@ -240,3 +295,58 @@ async function getAzureOutputDirectoryPath(
     ? outputDirectoryRelativePath
     : undefined;
 }
+
+async function getBatch(
+  host: AutorestExtensionHost
+): Promise<[string, any][] | undefined> {
+  const batch = await host.getValue<[string, any][]>("batch");
+  return batch;
+}
+
+async function getProductDocLink(
+  host: AutorestExtensionHost
+): Promise<string | undefined> {
+  return (await host.getValue("product-doc-link")) || undefined;
+}
+
+async function getMultiClient(host: AutorestExtensionHost): Promise<boolean> {
+  const multiClient = (await host.getValue("multi-client")) || undefined;
+  return !!multiClient;
+}
+
+async function getCoreHttpCompatMode(
+  host: AutorestExtensionHost
+): Promise<boolean> {
+  return (await host.getValue("core-http-compat-mode")) || false;
+}
+
+async function getDependencyInfo(
+  host: AutorestExtensionHost
+): Promise<DependencyInfo | undefined> {
+  const dependency: DependencyInfo | undefined =
+    (await host.getValue("dependency-info")) || undefined;
+
+  if (dependency && dependency.description && dependency.link) {
+    return dependency;
+  }
+
+  const link: string | undefined =
+    (await host.getValue<string>("dependency-info.link")) || undefined;
+  const description: string | undefined =
+    (await host.getValue("dependency-info.description")) || undefined;
+
+  if (description && link) {
+    return {
+      link,
+      description
+    };
+  }
+
+  if (!dependency && !description && !link) {
+    return undefined;
+  }
+
+  throw new Error(
+    "Invalid dependency-info. Make sure that link and description are defined"
+  );
+}

package/src/utils/copyFiles.ts

@@ -0,0 +1,36 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+import * as fsextra from "fs-extra";
+
+export function copyFiles(srcDir: string, destDir: string[]) {
+  const dirContents: string[] = fsextra.readdirSync(srcDir);
+  dirContents.forEach((dirEntry: string) => {
+    if (dirEntry.endsWith(".hbs")) {
+      destDir.forEach((destDirEntry: string) => {
+        console.log(
+          `Copying ${srcDir}/${dirEntry} to ${destDirEntry}/${dirEntry}`
+        );
+        fsextra.copyFileSync(
+          `${srcDir}/${dirEntry}`,
+          `${destDirEntry}/${dirEntry}`
+        );
+      });
+    }
+  });
+}
+
+copyFiles("./src/restLevelClient", ["./dist/src/restLevelClient", "./dist"]);
+copyFiles("./src/generators/test", ["./dist/src/generators/test", "./dist"]);
+copyFiles("./src/generators/static", [
+  "./dist/src/generators/static",
+  "./dist"
+]);
+copyFiles("./src/generators/samples", [
+  "./dist/src/generators/samples",
+  "./dist"
+]);
+copyFiles("./src/restLevelClient/samples", [
+  "./dist/src/restLevelClient/samples",
+  "./dist"
+]);

package/src/utils/extractPaginationDetails.ts

@@ -2,7 +2,8 @@ import {
   Operation,
   SchemaResponse,
   SchemaType,
-  ObjectSchema
+  ObjectSchema,
+  CodeModel
 } from "@autorest/codemodel";
 import { isEqual } from "lodash";
 import { PaginationDetails } from "../models/operationDetails";
@@ -152,6 +153,23 @@ function getResponseItemType(
   return getTypeForSchema(itemProperty.schema);
 }
 
+/**
+ * Function to determine if any of the operations in the code model has at least one pageable operatio
+ */
+export function hasPagingOperations(model: CodeModel) {
+  for (const group of model.operationGroups) {
+    const hasAnyPageable = group.operations.some(
+      o => o.extensions && o.extensions["x-ms-pageable"]
+    );
+
+    if (hasAnyPageable) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
 function isObjectSchema(schema: any): schema is ObjectSchema {
   return schema && schema.type === SchemaType.Object;
 }

package/src/utils/nameUtils.ts

@@ -4,7 +4,7 @@ import { Operation, OperationGroup } from "@autorest/codemodel";
 import { getLanguageMetadata } from "./languageHelpers";
 import { TypeDetails, PropertyKind } from "../models/modelDetails";
 
-interface ReservedName {
+export interface ReservedName {
   name: string;
   reservedFor: NameType[];
 }
@@ -84,7 +84,8 @@ const ReservedModelNames: ReservedName[] = [
   { name: "void", reservedFor: [NameType.Parameter] },
   { name: "while", reservedFor: [NameType.Parameter] },
   { name: "with", reservedFor: [NameType.Parameter] },
-  { name: "yield", reservedFor: [NameType.Parameter] }
+  { name: "yield", reservedFor: [NameType.Parameter] },
+  { name: "arguments", reservedFor: [NameType.Parameter] }
 ];
 
 export enum CasingConvention {
@@ -92,11 +93,15 @@ export enum CasingConvention {
   Camel
 }
 
-export function guardReservedNames(name: string, nameType: NameType): string {
+export function guardReservedNames(
+  name: string,
+  nameType: NameType,
+  customReservedNames: ReservedName[] = []
+): string {
   const suffix = getSuffix(nameType);
-  return ReservedModelNames.filter(r => r.reservedFor.includes(nameType)).find(
-    r => r.name === name.toLowerCase()
-  )
+  return [...ReservedModelNames, ...customReservedNames]
+    .filter(r => r.reservedFor.includes(nameType))
+    .find(r => r.name === name.toLowerCase())
     ? `${name}${suffix}`
     : name;
 }
@@ -135,12 +140,14 @@ export function normalizeTypeName({ kind, typeName }: TypeDetails) {
 export function normalizeName(
   name: string,
   nameType: NameType,
-  shouldGuard?: boolean
+  shouldGuard?: boolean,
+  customReservedNames: ReservedName[] = [],
+  casingOverride?: CasingConvention
 ): string {
   if (name.startsWith("$DO_NOT_NORMALIZE$")) {
     return name.replace("$DO_NOT_NORMALIZE$", "");
   }
-  const casingConvention = getCasingConvention(nameType);
+  const casingConvention = casingOverride ?? getCasingConvention(nameType);
   const sanitizedName = sanitizeName(name);
   const parts = getNameParts(sanitizedName);
   const [firstPart, ...otherParts] = parts;
@@ -152,7 +159,9 @@ export function normalizeName(
     .join("");
 
   const normalized = checkBeginning(`${normalizedFirstPart}${normalizedParts}`);
-  return shouldGuard ? guardReservedNames(normalized, nameType) : normalized;
+  return shouldGuard
+    ? guardReservedNames(normalized, nameType, customReservedNames)
+    : normalized;
 }
 
 function checkBeginning(name: string): string {

package/src/utils/schemaHelpers.ts

@@ -11,11 +11,17 @@ import {
   ArraySchema,
   DictionarySchema,
   SchemaResponse,
-  ComplexSchema
+  ComplexSchema,
+  OAuth2SecurityScheme,
+  KeySecurityScheme,
+  ParameterLocation,
+  Security
 } from "@autorest/codemodel";
 import { getStringForValue } from "./valueHelpers";
 import { getLanguageMetadata } from "./languageHelpers";
-import { normalizeName, NameType, normalizeTypeName } from "./nameUtils";
+import { normalizeName, NameType } from "./nameUtils";
+import { logger } from "./logger";
+import { getAutorestOptions } from "../autorestSession";
 
 /**
  * Extracts parents from an ObjectSchema
@@ -68,7 +74,7 @@ export function getTypeForSchema(
 ): TypeDetails {
   let typeName: string = "";
   let usedModels: string[] = [];
-  let defaultValue: string = "";
+  let defaultValue = undefined;
   let kind: PropertyKind = PropertyKind.Primitive;
   switch (schema.type) {
     case SchemaType.Any:
@@ -194,7 +200,7 @@ export function getTypeForSchema(
     usedModels,
     isConstant: schema.type === SchemaType.Constant,
     nullable: isNullable,
-    ...(defaultValue && { defaultValue })
+    defaultValue
   };
 }
 
@@ -221,3 +227,44 @@ export function getSchemaTypeDocumentation(schema: Schema) {
       return "";
   }
 }
+
+export function getSecurityInfoFromModel(security: Security) {
+  const { addCredentials } = getAutorestOptions();
+  const credentialScopes: Set<string> = new Set<string>();
+  let credentialKeyHeaderName: string = "";
+  for (const securitySchema of security.schemes) {
+    if (securitySchema.type === "OAuth2") {
+      (securitySchema as OAuth2SecurityScheme).scopes.forEach(scope => {
+        const scopes = scope.split(',');
+        for(const scope of scopes) {
+          credentialScopes.add(scope);
+        }
+      });
+    } else if (
+      credentialKeyHeaderName === "" &&
+      securitySchema.type === "Key" &&
+      (securitySchema as KeySecurityScheme).in === ParameterLocation.Header
+    ) {
+      credentialKeyHeaderName = (securitySchema as KeySecurityScheme).name;
+    } else if (
+      credentialKeyHeaderName !== "" &&
+      credentialKeyHeaderName !== (securitySchema as KeySecurityScheme).name &&
+      securitySchema.type === "Key" &&
+      (securitySchema as KeySecurityScheme).in === ParameterLocation.Header
+    ) {
+      logger.warning(
+        `Set multiple headers for key credential has not been supported yet`
+      );
+    }
+  }
+  const scopes: string[] = [];
+  credentialScopes.forEach(item => {
+    scopes.push(item);
+  });
+  return {
+    addCredentials:
+      addCredentials === false ? false : security.authenticationRequired,
+    credentialScopes: scopes,
+    credentialKeyHeaderName: credentialKeyHeaderName
+  };
+}