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

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,207 +2,139 @@ import {
   CodeModel,
   Operation,
   ParameterLocation,
-  ImplementationLocation
+  ImplementationLocation,
+  OAuth2SecurityScheme,
+  KeySecurityScheme
 } 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 } from "./schemaHelpers";
 import { getLanguageMetadata } from "../utils/languageHelpers";
-type PathParameter = { name: string; description?: string };
+import { generateMethodShortcutImplementation } from "./generateMethodShortcuts";
+import { Paths } from "./interfaces";
+import { pathDictionary } from "./generateClientDefinition";
+import { getSecurityInfoFromModel } from "../utils/schemaHelpers";
 
-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,
-              description: languageMetadata.description
-            };
-          }) || [];
-
-      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 = !request.signatureParameters?.some(
-            p => p.required
-          );
-
-          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 credentialTypes = addCredentials ? ["TokenCredential"] : [];
+  const { multiClient, batch } = getAutorestOptions();
+  const {
+    addCredentials,
+    credentialScopes,
+    credentialKeyHeaderName
+  } = getSecurityInfoFromModel(model.security);
+  const credentialTypes =
+    credentialScopes && credentialScopes.length > 0 ? ["TokenCredential"] : [];
 
   if (credentialKeyHeaderName) {
     credentialTypes.push("KeyCredential");
   }
 
   const commonClientParams = [
-    ...(uriParameter ? [{ name: uriParameter, type: "string" }] : []),
-    ...(addCredentials === false
+    ...(uriParameter
+      ? [
+          {
+            name: uriParameter,
+            type: "string"
+          }
+        ]
+      : []),
+    ...(addCredentials === false ||
+    !isSecurityInfoDefined(credentialScopes, credentialKeyHeaderName)
       ? []
       : [{ 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 &&
+    isSecurityInfoDefined(credentialScopes, credentialKeyHeaderName)
+  ) {
+    clientFile.addImportDeclarations([
+      {
+        namedImports: credentialTypes,
+        moduleSpecifier: "@azure/core-auth"
+      }
+    ]);
+  }
   clientFile.addImportDeclarations([
     {
-      namedImports: credentialTypes,
-      moduleSpecifier: "@azure/core-auth"
+      namedImports: [`${clientInterfaceName}`],
+      moduleSpecifier: "./clientDefinitions"
     }
   ]);
 }
 
-function getOperationOptionsType(
-  operation: Operation,
-  importedParameters = new Set<string>()
+function isSecurityInfoDefined(
+  credentialScopes: string[],
+  credentialKeyHeaderName: string
 ) {
-  const paramsName = `${
-    getLanguageMetadata(operation.language).name
-  }Parameters`;
-  importedParameters.add(paramsName);
-
-  return paramsName;
+  return (
+    (credentialScopes && credentialScopes.length > 0) || credentialKeyHeaderName
+  );
 }
 
 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;
@@ -222,13 +154,40 @@ 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,
     declarations: [{ name: "baseUrl", initializer: baseUrl }]
   };
 
-  const { credentialScopes, credentialKeyHeaderName } = getAutorestOptions();
+  const {
+    credentialScopes,
+    credentialKeyHeaderName
+  } = getSecurityInfoFromModel(model.security);
 
   const scopesString =
     credentialScopes && credentialScopes.length
@@ -247,17 +206,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};
+    `;
+
+  let returnStatement = `return client;`;
 
-  return [baseUrlStatement, apiVersionStatement, credentials, getClient];
+  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 {
@@ -284,103 +269,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: "string", 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
-  });
-}