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

package/src/generators/test/rlcEnv.ts.hbs

@@ -0,0 +1,3 @@
+import * as dotenv from "dotenv";
+
+dotenv.config();

package/src/generators/test/rlcRecordedClient.ts.hbs

@@ -0,0 +1,35 @@
+import { Context } from "mocha";
+import { env, record, RecorderEnvironmentSetup, Recorder } from "@azure-tools/test-recorder";
+import "./env";
+
+const recorderEnvSetup: RecorderEnvironmentSetup = {
+  replaceableVariables: {
+    ENDPOINT: "https://endpoint",
+    AZURE_CLIENT_ID: "azure_client_id",
+    AZURE_CLIENT_SECRET: "azure_client_secret",
+    AZURE_TENANT_ID: "88888888-8888-8888-8888-888888888888",
+    SUBSCRIPTION_ID: "azure_subscription_id"
+  },
+  customizationsOnRecordings: [
+    (recording: any): any =>
+      recording.replace(/"access_token":"[^"]*"/g, `"access_token":"access_token"`),
+    // If we put ENDPOINT in replaceableVariables above, it will not capture
+    // the endpoint string used with nock, which will be expanded to
+    // https://<endpoint>:443/ and therefore will not match, so we have to do
+    // this instead.
+    (recording: string): string => {
+      const replaced = recording.replace("endpoint:443", "endpoint");
+      return replaced;
+    },
+  ],
+  queryParametersToSkip: []
+};
+
+/**
+* creates the recorder and reads the environment variables from the `.env` file.
+* Should be called first in the test suite to make sure environment variables are
+* read before they are being used.
+*/
+export function createRecorder(context: Context): Recorder {
+    return record(context, recorderEnvSetup);
+}

package/src/generators/test/rlcSampleTest.spec.ts.hbs

@@ -0,0 +1,19 @@
+import { Recorder } from "@azure-tools/test-recorder";
+import * as assert from "assert";
+import { createRecorder } from "./utils/recordedClient";
+
+describe("My test", () => {
+  let recorder: Recorder;
+
+  beforeEach(async function() {
+    recorder = createRecorder(this);
+  });
+
+  afterEach(async function() {
+    await recorder.stop();
+  });
+
+  it("sample test", async function() {
+    console.log("Hi, I'm a test!");
+  });
+});

package/src/generators/test/sampleTestGenerator.ts

@@ -2,16 +2,31 @@ import { Project } from "ts-morph";
 import * as path from 'path';
 import * as fs from 'fs';
 import * as hbs from "handlebars";
+import { getAutorestOptions } from "../../autorestSession";
 
 export function generateSampleTestFile(
     project: Project
   ) {
+    const { generateTest, restLevelClient } = getAutorestOptions();
+    if (!generateTest) {
+      return;
+    }
     const metadata = {}
-    const file = fs.readFileSync(path.join(__dirname, "../static/sampleTest.ts.hbs"), {
-      encoding: "utf-8"
-    });
-    const readmeFileContents = hbs.compile(file, { noEscape: true });
-    project.createSourceFile("test/sampleTest.ts", readmeFileContents(metadata), {
-      overwrite: true
-    });
-  }
+    if (restLevelClient) {
+      const file = fs.readFileSync(path.join(__dirname, "rlcSampleTest.spec.ts.hbs"), {
+        encoding: "utf-8"
+      });
+      const readmeFileContents = hbs.compile(file, { noEscape: true });
+      project.createSourceFile("test/public/sampleTest.spec.ts", readmeFileContents(metadata), {
+        overwrite: true
+      });
+    } else {
+      const file = fs.readFileSync(path.join(__dirname, "sampleTest.ts.hbs"), {
+        encoding: "utf-8"
+      });
+      const readmeFileContents = hbs.compile(file, { noEscape: true });
+      project.createSourceFile("test/sampleTest.ts", readmeFileContents(metadata), {
+        overwrite: true
+      });
+    }
+  }

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 {
@@ -9,8 +12,9 @@ import {
   initializeSession,
   getAutorestOptions
 } from "./autorestSession";
+import { serialize } from "@azure-tools/codegen";
 
-export async function processRequest(host: Host) {
+export async function processRequest(host: AutorestExtensionHost) {
   await initializeSession(host);
   const session = getSession();
   const { restLevelClient } = getAutorestOptions();
@@ -19,7 +23,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 +32,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>;
@@ -32,4 +33,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,43 @@ 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 };
-
-type Methods = {
-  [key: string]: [
-    {
-      optionsName: string;
-      description: string;
-      hasOptionalOptions: boolean;
-      returnType: string;
-    }
-  ];
-};
-type Paths = {
-  [key: string]: {
-    name: string;
-    pathParameters: PathParameter[];
-    methods: Methods;
-  };
-};
+import { generateMethodShortcutImplementation } from "./generateMethodShortcuts";
+import { Paths } from "./interfaces";
+import { pathDictionary } from './generateClientDefinition';
 
-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, {
+  const { srcPath } = getAutorestOptions();
+  const clientFile = project.createSourceFile(path.join(srcPath, `${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];
-          }
-        }
-      }
-    }
-  }
-
-  clientFile.addInterface({
-    name: "Routes",
-    isExported: true,
-    callSignatures: getPathFirstRoutesInterfaceDefinition(
-      pathDictionary,
-      clientFile
-    )
-  });
-
   const clientName = getLanguageMetadata(model.language).name;
   const uriParameter = getClientUriParameter();
 
-  const { addCredentials, credentialKeyHeaderName } = getAutorestOptions();
+  const { addCredentials, credentialKeyHeaderName, multiClient, batch } = getAutorestOptions();
   const credentialTypes = addCredentials ? ["TokenCredential"] : [];
 
   if (credentialKeyHeaderName) {
@@ -144,46 +51,28 @@ export function generatePathFirstClient(model: CodeModel, project: Project) {
       ? []
       : [{ 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}Like`;
 
-  clientFile.addFunction({
+  const functionStatement = {
     isExported: true,
-    name: clientName,
+    name: `${clientName}`,
     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"
     }
   ]);
@@ -192,32 +81,19 @@ export function generatePathFirstClient(model: CodeModel, project: Project) {
     {
       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 } = getAutorestOptions();
   const { model } = getSession();
   const { endpoint, parameterName } = transformBaseUrl(model);
   let baseUrl: string;
@@ -266,13 +142,36 @@ function getClientFactoryBody(
     }`
       : "";
 
-  const getClient = `return getClient(
-      baseUrl,
-      ${credentials ? "credentials," : ""}
-      options
-    ) as ${clientTypeName};`;
+  const getClient = `const client = getClient(
+      baseUrl, ${credentials ? "credentials," : ""} options
+    ) as ${clientTypeName};
+    `;
+
+  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, getClient];
+  return [
+    baseUrlStatement,
+    apiVersionStatement,
+    credentials,
+    getClient,
+    returnStatement
+  ];
 }
 
 function getApiVersion(): string | undefined {
@@ -299,103 +198,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
-  });
-}