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

package/src/generators/operationGenerator.ts

@@ -425,9 +425,14 @@ function buildMapper(
     return "";
   }
 
-  // When mapper is a reference (string) we don't need to stringify the object
-  let mapperString =
-    typeof mapper === "string" ? mapper : JSON.stringify(mapper);
+  let mapperString = "";
+  if (typeof mapper === "string") {
+    // When mapper is a reference (string) we don't need to stringify the object
+    mapperString = mapper;
+  } else {
+    const { constraints, ...restMapper } = mapper;
+    mapperString = JSON.stringify(restMapper);
+  }
 
   return `${mapperName}: ${mapperString},`;
 }
@@ -475,7 +480,7 @@ function addClass(
     name: "client",
     isReadonly: true,
     scope: Scope.Private,
-    type: `${clientDetails.className}Context`
+    type: `${clientDetails.className}`
   });
   const constructorDefinition = operationGroupClass.addConstructor({
     docs: [
@@ -487,7 +492,7 @@ function addClass(
       {
         name: "client",
         hasQuestionToken: false,
-        type: `${clientDetails.className}Context`
+        type: `${clientDetails.className}`
       }
     ]
   });
@@ -768,30 +773,12 @@ function writeNoOverloadsOperationBody(
   const vanillaOptionsName = "options";
   let options = vanillaOptionsName;
 
-  if (tracingInfo) {
-    const operationName = operationMethod.getName();
-    const {
-      outputOptionsVarName: updatedOptionsName,
-      statement: tracingStatement
-    } = getTracingSpanStatement(
-      clientDetails,
-      operationName,
-      `${options} || {}`
-    );
-    operationMethod.addStatements([tracingStatement]);
-    // Options from createSpan should be used as operation options, updating
-    options = compileOperationOptionsToRequestOptionsBase(
-      updatedOptionsName,
-      operation.isLro,
-      lroResourceLocationConfig
-    );
-  } else {
-    options = compileOperationOptionsToRequestOptionsBase(
-      vanillaOptionsName,
-      operation.isLro,
-      lroResourceLocationConfig
-    );
-  }
+  // Options from createSpan should be used as operation options, updating
+  options = compileOperationOptionsToRequestOptionsBase(
+    vanillaOptionsName,
+    operation.isLro,
+    lroResourceLocationConfig
+  );
 
   const sendParams = parameterDeclarations
     .map(p =>
@@ -813,6 +800,7 @@ function writeNoOverloadsOperationBody(
   if (operation.isLro) {
     if (!useCoreV2) {
       writeLroOperationBody(
+        clientDetails,
         "operationArguments",
         responseName,
         operationSpecName,
@@ -823,6 +811,7 @@ function writeNoOverloadsOperationBody(
       );
     } else {
       writeLroOperationBody(
+        clientDetails,
         `{${sendParams}}`,
         responseName,
         operationSpecName,
@@ -850,18 +839,6 @@ interface OptionsStatement {
   outputOptionsVarName: string;
 }
 
-function getTracingSpanStatement(
-  clientDetails: ClientDetails,
-  operationName: string,
-  options: string
-): OptionsStatement {
-  const outputOptionsVarName = "updatedOptions";
-  return {
-    statement: `const { span, ${outputOptionsVarName} } = createSpan("${clientDetails.className}-${operationName}", ${options});`,
-    outputOptionsVarName: outputOptionsVarName
-  };
-}
-
 function writeSendOperationRequest(
   responseName: string,
   operationMethod: MethodDeclaration,
@@ -871,6 +848,7 @@ function writeSendOperationRequest(
   sendParams: string
 ) {
   const { useCoreV2, tracingInfo } = getAutorestOptions();
+  const operationName = operationMethod.getName();
   const client = isInline ? "" : ".client";
   const sendRequestStatement = !useCoreV2
     ? `this${client}.sendOperationRequest(operationArguments, ${operationSpecName})`
@@ -879,10 +857,11 @@ function writeSendOperationRequest(
   // When tracing is enabled we want to report success and failures through OpenTelemetry
   // so we create a span and mark it as succeeded or failed
   operationMethod.addStatements(
-    getTracingTryCatchStatement(
+    getTracingClientWithSpanStatement(
       sendRequestStatement,
       responseName,
-      !!tracingInfo
+      !!tracingInfo,
+      `${clientDetails.className}.${operationName}`
     )
   );
 }
@@ -891,25 +870,18 @@ function getSpanStatusCode() {
   return "coreTracing.SpanStatusCode.UNSET";
 }
 
-function getTracingTryCatchStatement(
+function getTracingClientWithSpanStatement(
   sendRequestStatement: string,
   responseName: string,
-  isTracingEnabled: boolean
+  isTracingEnabled: boolean,
+  spanName: string
 ) {
   const { useCoreV2 } = getAutorestOptions();
   if (isTracingEnabled) {
-    return `try {
-      const result = await ${sendRequestStatement}
-      return result as ${responseName};
-    } catch(error) {
-    span.setStatus({
-      code: ${getSpanStatusCode()},
-      message: error.message
-    });
-      throw error;
-    } finally {
-      span.end();
-    }`;
+    return `
+    return tracingClient.withSpan("${spanName}", options ?? {}, async options => {
+      return ${sendRequestStatement} as Promise<${responseName}>;
+    });`;
   } else {
     return !useCoreV2
       ? `return ${sendRequestStatement} as Promise<${responseName}>`
@@ -918,6 +890,7 @@ function getTracingTryCatchStatement(
 }
 
 function writeLroOperationBody(
+  clientDetails: ClientDetails,
   operationParamsName: string,
   responseName: string,
   operationSpecName: string,
@@ -927,14 +900,16 @@ function writeLroOperationBody(
   isTracingEnabled = false
 ) {
   const { useCoreV2 } = getAutorestOptions();
+  const spanName = `${clientDetails.className}.${methodDeclaration.getName()}`;
   const client = isInline ? "" : ".client";
   const sendRequestStatement = `this${client}.sendOperationRequest(args, spec)`;
   const sendOperationStatement = !useCoreV2
     ? `const directSendOperation = async (args: coreHttp.OperationArguments, spec: coreHttp.OperationSpec): Promise<${responseName}> => {
-      ${getTracingTryCatchStatement(
+      ${getTracingClientWithSpanStatement(
         sendRequestStatement,
         responseName,
-        isTracingEnabled
+        isTracingEnabled,
+        spanName
       )}
       };
       const sendOperation = async (args: coreHttp.OperationArguments, spec: coreHttp.OperationSpec) => {
@@ -946,10 +921,11 @@ function writeLroOperationBody(
         }};
     }`
     : `const directSendOperation = async (args: coreClient.OperationArguments, spec: coreClient.OperationSpec): Promise<${responseName}> => {
-    ${getTracingTryCatchStatement(
+    ${getTracingClientWithSpanStatement(
       sendRequestStatement,
       responseName,
-      isTracingEnabled
+      isTracingEnabled,
+      spanName
     )}
     };
     const sendOperation = async (args: coreClient.OperationArguments, spec: coreClient.OperationSpec) => {
@@ -979,11 +955,13 @@ function writeLroOperationBody(
     sendOperationStatement,
     `const lro = new LroImpl(sendOperation,${operationParamsName},
       ${operationSpecName})`,
-    `return new LroEngine(lro,{ resumeFrom: options?.resumeFrom, intervalInMs: options?.updateIntervalInMs${
+    `const poller = new LroEngine(lro,{ resumeFrom: options?.resumeFrom, intervalInMs: options?.updateIntervalInMs${
       lroResourceLocationConfig
         ? `, lroResourceLocationConfig: "${lroResourceLocationConfig.toLowerCase()}"`
         : ""
-    } });`
+    } });`,
+    "await poller.poll();",
+    "return poller;"
   ]);
 
   methodDeclaration.setReturnType(
@@ -1006,6 +984,7 @@ function writeMultiMediaTypeOperationBody(
 ): void {
   const { useCoreV2, tracingInfo } = getAutorestOptions();
   const coreImport = !useCoreV2 ? "coreHttp" : "coreClient";
+
   operationMethod.addStatements([
     `let operationSpec: ${coreImport}.OperationSpec;`,
     `let operationArguments: ${coreImport}.OperationArguments;`
@@ -1087,29 +1066,13 @@ function writeMultiMediaTypeOperationBody(
   const lroResourceLocationConfig =
     operation.lroOptions && operation.lroOptions["final-state-via"];
 
-  if (tracingInfo) {
-    const operationName = operationMethod.getName();
-    const {
-      outputOptionsVarName,
-      statement: tracingStatement
-    } = getTracingSpanStatement(clientDetails, operationName, optionsVarName);
-    operationMethod.addStatements([
-      tracingStatement,
-      `operationArguments.options = ${compileOperationOptionsToRequestOptionsBase(
-        outputOptionsVarName,
-        operation.isLro,
-        lroResourceLocationConfig
-      )};`
-    ]);
-  } else {
-    operationMethod.addStatements([
-      `operationArguments.options = ${compileOperationOptionsToRequestOptionsBase(
-        optionsVarName,
-        operation.isLro,
-        lroResourceLocationConfig
-      )};`
-    ]);
-  }
+  operationMethod.addStatements([
+    `operationArguments.options = ${compileOperationOptionsToRequestOptionsBase(
+      optionsVarName,
+      operation.isLro,
+      lroResourceLocationConfig
+    )};`
+  ]);
 
   if (!operation.isLro) {
     writeSendOperationRequest(
@@ -1122,6 +1085,7 @@ function writeMultiMediaTypeOperationBody(
     );
   } else {
     writeLroOperationBody(
+      clientDetails,
       "operationArguments",
       responseName,
       "operationSpec",
@@ -1319,16 +1283,13 @@ function addImports(
     });
   }
 
-  const clientContextClassName = `${className}Context`;
+  const clientClassName = `${className}`;
 
-  const clientContextFileName = normalizeName(
-    clientContextClassName,
-    NameType.File
-  );
+  const clientFileName = normalizeName(clientClassName, NameType.File);
 
   operationGroupFile.addImportDeclaration({
-    namedImports: [`${clientContextClassName}`],
-    moduleSpecifier: `../${clientContextFileName}`
+    namedImports: [`${clientClassName}`],
+    moduleSpecifier: `../${clientFileName}`
   });
 
   if (hasLroOperation(operationGroupDetails)) {

package/src/generators/parametersGenerator.ts

@@ -11,7 +11,6 @@ import {
 } from "ts-morph";
 import { ClientDetails } from "../models/clientDetails";
 import { ParameterDetails } from "../models/parameterDetails";
-import { isString } from "util";
 import { writeMapper } from "./mappersGenerator";
 import { shouldImportParameters } from "./utils/importUtils";
 import { logger } from "../utils/logger";
@@ -143,7 +142,7 @@ function writeParameterMapper(
   { mapper }: ParameterDetails
 ) {
   writer.write("mapper: ");
-  if (isString(mapper)) {
+  if (typeof mapper === "string") {
     writer.write(`${mapper}Mapper`);
   } else {
     writeMapper(writer, mapper);
@@ -184,7 +183,7 @@ function getCoreHttpImports(clientDetails: ClientDetails) {
 
 function getImportedMappers(clientDetails: ClientDetails) {
   const mappers = clientDetails.parameters
-    .filter(p => !p.isSynthetic && isString(p.mapper))
+    .filter(p => !p.isSynthetic && typeof p.mapper === "string")
     .map(p => `${p.mapper} as ${p.mapper}Mapper`);
 
   return [...new Set<string>(mappers)];

package/src/generators/samples/hlcSampleGenerator.ts

@@ -0,0 +1,50 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+import {
+  Project,
+  SourceFile
+} from "ts-morph";
+import * as fs from 'fs';
+import * as path from 'path';
+import * as hbs from "handlebars";
+import { getAutorestOptions, getSession } from "../../autorestSession";
+import { ClientDetails } from "../../models/clientDetails";
+import { SampleGroup } from "../../models/sampleDetails";
+
+/**
+ * Function that writes the code for all the operations.
+ * It will generate one file per operation group and each file contains:
+ *    - A class definition for the operation group
+ *    - Methods and overrides for each operation
+ *    - OperationSpecs for each operation
+ * @param clientDetails client details
+ * @param project project for code generation
+ */
+export function generateHLCSamples(
+  clientDetails: ClientDetails,
+  project: Project
+): void {
+  // Toplevel operations are inlined in the client
+  const sampleGroups = clientDetails.samples;
+  const session = getSession();
+  if (!sampleGroups) {
+    session.error("No samples are found! ", []);
+  }
+  for (const sampleGroup of sampleGroups as SampleGroup[]) {
+    try {
+      const file = fs.readFileSync(path.join(__dirname, "hlcSamples.ts.hbs"), {
+        encoding: "utf-8"
+      });
+
+      const sampleGroupFileContents = hbs.compile(file, { noEscape: true });
+      project.createSourceFile(`samples-dev/${sampleGroup.sampleFileName}.ts`, sampleGroupFileContents(sampleGroup), {
+        overwrite: true
+      });
+    } catch (error) {
+      session.error("An error was encountered while handling sample generation", [sampleGroup.sampleFileName]);
+      throw error;
+    }
+  }
+}
+

package/src/generators/samples/hlcSamples.ts.hbs

@@ -0,0 +1,49 @@
+
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+import {
+{{#if importedTypes.length }}
+  {{#each importedTypes}}
+  {{this}},
+  {{/each}}
+{{/if}}
+  {{clientClassName}}, 
+} from "{{clientPackageName}}";
+import { DefaultAzureCredential } from "@azure/identity";
+
+{{#each samples}}
+/**
+ * This sample demonstrates how to {{this.operationDescription}}
+ *
+ * @summary {{this.operationDescription}}
+ * x-ms-original-file: {{this.originalFileLocation}}
+ */
+async function {{this.sampleFunctionName}}() {
+  {{#each this.clientParamAssignments}}
+  {{this}}
+  {{/each}}
+  {{#each this.methodParamAssignments}}
+  {{this}}
+  {{/each}}
+  const credential = new DefaultAzureCredential();
+  const client = new {{this.clientClassName}}({{this.clientParameterNames}});
+  {{#if this.isPaging}}
+  const resArray = new Array();
+  for await (let item of client{{#unless this.isTopLevel}}.{{this.operationGroupName}}{{/unless}}.{{this.operationName}}({{this.methodParameterNames}})){
+    resArray.push(item);
+  }
+  console.log(resArray);
+  {{else}}  
+  const result = await client
+    {{#unless this.isTopLevel}}
+    .{{this.operationGroupName}}
+    {{/unless}}
+    .{{this.operationName}}({{this.methodParameterNames}});
+  console.log(result);
+  
+  {{/if}}
+}
+
+{{this.sampleFunctionName}}().catch(console.error);
+
+{{/each}}

package/src/generators/samples/rlcSampleGenerator.ts

@@ -0,0 +1,72 @@
+import { TestCodeModel } from "@autorest/testmodeler/dist/src/core/model";
+import { Project } from "ts-morph";
+import { getAutorestOptions, getSession } from "../../autorestSession";
+import * as fs from 'fs';
+import * as path from 'path';
+import * as hbs from "handlebars";
+import { NameType, normalizeName } from "../../utils/nameUtils";
+import { getLanguageMetadata } from "../../utils/languageHelpers";
+import { transformBaseUrl } from "../../transforms/urlTransforms";
+
+export function generateRLCSamples(model: TestCodeModel, project: Project) {
+    const {
+        generateSample,
+        multiClient
+    } = getAutorestOptions();
+    const session = getSession();
+    if (!generateSample || !model?.testModel?.mockTest?.exampleGroups) {
+        return;
+    }
+    // Not supported to generate code for multi-client
+    if (multiClient) {
+        return;
+    }
+    try {
+        const file = fs.readFileSync(path.join(__dirname, "rlcSamples.ts.hbs"), {
+            encoding: "utf-8"
+        });
+
+        const sampleFileContents = hbs.compile(file, { noEscape: true });
+        const sampleData = createSampleData(model);
+        project.createSourceFile(`samples-dev/${sampleData.filename}.ts`, sampleFileContents(sampleData), {
+            overwrite: true
+        });
+    } catch (error) {
+        session.error("An error was encountered while handling sample generation", []);
+        throw error;
+    }
+}
+
+function createSampleData(model: TestCodeModel) {
+    const {
+        addCredentials,
+        packageDetails
+    } = getAutorestOptions();
+    const clientFileName = normalizeName(
+        getLanguageMetadata(model.language).name,
+        NameType.File
+    );
+    const clientName = getLanguageMetadata(model.language).name;
+    const clientInterfaceName = clientName.endsWith("Client") ? `${clientName}` : `${clientName}Client`;
+    const { parameterName } = transformBaseUrl(model);
+    const hasUriParameter = !!parameterName, hasCredentials = addCredentials;
+    const clientParameters = [];
+    const clientParamAssignments = [];
+    if (hasUriParameter) {
+        clientParamAssignments.push(`const ${parameterName} = process.env["ENDPOINT"] || "<${parameterName}>"`);
+        clientParameters.push(`${parameterName}`);
+    }
+    if (hasCredentials) {
+        clientParamAssignments.push("const credential = new DefaultAzureCredential();");
+        clientParameters.push("credential");
+    }
+    return {
+        filename: `${clientFileName}Sample`,
+        clientParamAssignments,
+        clientClassName: clientInterfaceName,
+        clientPackageName: `${packageDetails.name}`,
+        clientParameterNames: clientParameters.join(","),
+        hasCredentials
+    }
+
+}

package/src/generators/samples/rlcSamples.ts.hbs

@@ -0,0 +1,28 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+import createClient, {
+  {{clientClassName}}, 
+} from "{{clientPackageName}}";
+{{#if hasCredentials }}
+import { DefaultAzureCredential } from "@azure/identity";
+{{/if}}
+import * as dotenv from "dotenv";
+
+dotenv.config();
+
+/**
+ * This is a simple sample on how to create client and please add your own code below
+ *
+ */
+async function main() {
+  {{#each this.clientParamAssignments}}
+  {{this}}
+  {{/each}}
+  const client: {{clientClassName}} = createClient({{this.clientParameterNames}});
+  const result = !!client ? "Success" : "Fail";
+  console.log(result," to create client.");
+  // Add your own code here
+}
+
+main().catch(console.error);
+

package/src/generators/samples/sampleEnv.hbs

@@ -0,0 +1,4 @@
+# App registration secret for AAD authentication
+AZURE_CLIENT_SECRET=
+AZURE_CLIENT_ID=
+AZURE_TENANT_ID= 

package/src/generators/samples/sampleEnvGenerator.ts

@@ -0,0 +1,14 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as hbs from 'handlebars';
+import { Project } from 'ts-morph';
+
+export function generateSampleEnv(project: Project) {
+    const file = fs.readFileSync(path.join(__dirname, "sampleEnv.hbs"), {
+        encoding: "utf-8"
+    });
+    const readmeFileContents = hbs.compile(file, { noEscape: true });
+    project.createSourceFile("sample.env", readmeFileContents({}), {
+        overwrite: true
+    });
+}

package/src/generators/static/apiExtractorConfig.ts

@@ -5,7 +5,7 @@ import { Project } from "ts-morph";
 import { getAutorestOptions } from "../../autorestSession";
 
 export function generateApiExtractorConfig(project: Project) {
-  const { generateMetadata, packageDetails } = getAutorestOptions();
+  const { generateMetadata, packageDetails, generateTest, restLevelClient } = getAutorestOptions();
 
   if (!generateMetadata) {
     return;
@@ -14,7 +14,7 @@ export function generateApiExtractorConfig(project: Project) {
   const config = {
     $schema:
       "https://developer.microsoft.com/json-schemas/api-extractor/v7/api-extractor.schema.json",
-    mainEntryPointFilePath: `./dist-esm/index.d.ts`,
+    mainEntryPointFilePath: `${restLevelClient ? "./types" : "./dist-esm"}${generateTest ? "/src" : ""}/index.d.ts`,
     docModel: {
       enabled: true
     },

package/src/generators/static/esLintConfigGenerator.ts

@@ -0,0 +1,24 @@
+import { Project } from "ts-morph";
+import { getAutorestOptions } from "../../autorestSession";
+
+const esLintConfig = {
+  plugins: ["@azure/azure-sdk"],
+  extends: ["plugin:@azure/azure-sdk/azure-sdk-base"],
+  rules: {
+    "@azure/azure-sdk/ts-modules-only-named": "warn",
+    "@azure/azure-sdk/ts-apiextractor-json-types": "warn",
+    "@azure/azure-sdk/ts-package-json-types": "warn",
+    "@azure/azure-sdk/ts-package-json-engine-is-present": "warn",
+    "tsdoc/syntax": "warn"
+  }
+}
+
+export function generateEsLintConfig(project: Project) {
+  const { generateMetadata } = getAutorestOptions();
+  if (!generateMetadata) {
+    return;
+  }
+  project.createSourceFile(".eslintrc.json", JSON.stringify(esLintConfig), {
+    overwrite: true
+  });
+}