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

package/src/generators/clientFileGenerator.ts

@@ -5,7 +5,10 @@ import {
   Project,
   PropertyDeclarationStructure,
   ClassDeclaration,
-  SourceFile
+  SourceFile,
+  CodeBlockWriter,
+  Scope,
+  ReturnTypedNode
 } from "ts-morph";
 import { ClientDetails } from "../models/clientDetails";
 import {
@@ -25,6 +28,10 @@ import { getAllModelsNames } from "./utils/responseTypeUtils";
 import { addTracingOperationImports } from "./utils/tracingUtils";
 import { addPagingEsNextRef, addPagingImports } from "./utils/pagingOperations";
 import { getAutorestOptions } from "../autorestSession";
+import { ParameterDetails } from "../models/parameterDetails";
+import { EndpointDetails } from "../transforms/urlTransforms";
+import { PackageDetails } from "../models/packageDetails";
+import { getSecurityInfoFromModel } from "../utils/schemaHelpers";
 
 type OperationDeclarationDetails = { name: string; typeName: string };
 
@@ -33,9 +40,10 @@ export function generateClient(clientDetails: ClientDetails, project: Project) {
     useCoreV2,
     hideClients,
     srcPath,
-    addCredentials
+    packageDetails,
+    coreHttpCompatMode
   } = getAutorestOptions();
-  const clientContextClassName = `${clientDetails.className}Context`;
+  const { addCredentials } = getSecurityInfoFromModel(clientDetails.security);
   const hasMappers = !!clientDetails.mappers.length;
 
   // Check if there are any client level operations
@@ -72,39 +80,54 @@ export function generateClient(clientDetails: ClientDetails, project: Project) {
     }
   );
 
+  !useCoreV2 && writePackageInfo(clientFile, packageDetails);
+
   const flattenedInlineOperations = inlineOperations.reduce<OperationDetails[]>(
     (acc, curr) => (acc = [...acc, ...curr.operations]),
     []
   );
 
+  if (!useCoreV2) {
+    clientFile.addImportDeclaration({
+      namespaceImport: "coreHttp",
+      moduleSpecifier: "@azure/core-http"
+    });
+  } else {
+    clientFile.addImportDeclaration({
+      namespaceImport: "coreClient",
+      moduleSpecifier: "@azure/core-client"
+    });
+    clientFile.addImportDeclaration({
+      namespaceImport: "coreHttpCompat",
+      moduleSpecifier: "@azure/core-http-compat"
+    });
+    clientFile.addImportDeclaration({
+      namespaceImport: "coreRestPipeline",
+      moduleSpecifier: "@azure/core-rest-pipeline"
+    });
+    const coreRestPipelineImports = [
+      "PipelineRequest",
+      "PipelineResponse",
+      "SendRequest"
+    ];
+    clientFile.addImportDeclaration({
+      namedImports: coreRestPipelineImports,
+      moduleSpecifier: "@azure/core-rest-pipeline"
+    });
+  }
+
   if (hasCredentials || hasInlineOperations || !hasClientOptionalParams) {
-    if (!useCoreV2) {
-      clientFile.addImportDeclaration({
-        namespaceImport: "coreHttp",
-        moduleSpecifier: "@azure/core-http"
-      });
-    } else {
-      clientFile.addImportDeclaration({
-        namespaceImport: "coreClient",
-        moduleSpecifier: "@azure/core-client"
-      });
-      clientFile.addImportDeclaration({
-        namespaceImport: "coreRestPipeline",
-        moduleSpecifier: "@azure/core-rest-pipeline"
-      });
+    clientFile.addImportDeclaration({
+      namespaceImport: "coreTracing",
+      moduleSpecifier: "@azure/core-tracing"
+    });
+    if (hasCredentials) {
       clientFile.addImportDeclaration({
-        namespaceImport: "coreTracing",
-        moduleSpecifier: "@azure/core-tracing"
+        namespaceImport: "coreAuth",
+        moduleSpecifier: "@azure/core-auth"
       });
-      if (hasCredentials) {
-        clientFile.addImportDeclaration({
-          namespaceImport: "coreAuth",
-          moduleSpecifier: "@azure/core-auth"
-        });
-      }
     }
   }
-
   addPagingEsNextRef(flattenedInlineOperations, clientFile);
   addPagingImports(flattenedInlineOperations, clientFile);
 
@@ -112,24 +135,13 @@ export function generateClient(clientDetails: ClientDetails, project: Project) {
 
   if (hasInlineOperations && hasLro) {
     clientFile.addImportDeclaration({
-      namedImports: ["PollerLike", "PollOperationState"],
+      namedImports: ["PollerLike", "PollOperationState", "LroEngine"],
       moduleSpecifier: "@azure/core-lro"
     });
     clientFile.addImportDeclaration({
-      namedImports: ["LroEngine"],
-      moduleSpecifier: `./lro`
+      namedImports: ["LroImpl"],
+      moduleSpecifier: `./lroImpl`
     });
-    if (useCoreV2) {
-      clientFile.addImportDeclaration({
-        namedImports: ["CoreClientLro", "shouldDeserializeLro"],
-        moduleSpecifier: `./coreClientLro`
-      });
-    } else {
-      clientFile.addImportDeclaration({
-        namedImports: ["CoreHttpLro", "shouldDeserializeLro"],
-        moduleSpecifier: `./coreHttpLro`
-      });
-    }
   }
 
   if (hasImportedOperations) {
@@ -174,14 +186,13 @@ export function generateClient(clientDetails: ClientDetails, project: Project) {
     });
   }
 
-  clientFile.addImportDeclaration({
-    namedImports: [clientContextClassName],
-    moduleSpecifier: `./${clientDetails.sourceFileName}Context`
-  });
-
   const clientClass = clientFile.addClass({
     name: clientDetails.className,
-    extends: clientContextClassName,
+    extends: !useCoreV2
+      ? "coreHttp.ServiceClient"
+      : coreHttpCompatMode
+      ? "coreHttpCompat.ExtendedServiceClient"
+      : "coreClient.ServiceClient",
     isExported: true
   });
 
@@ -196,8 +207,22 @@ export function generateClient(clientDetails: ClientDetails, project: Project) {
   }
 
   const importedModels = new Set<string>();
+  const clientParams = clientDetails.parameters.filter(
+    param => param.implementationLocation === ImplementationLocation.Client
+  );
 
-  writeConstructor(clientDetails, clientClass, importedModels);
+  const apiVersionParams = clientParams.filter(
+    item => item.serializedName.indexOf("api-version") > -1
+  );
+  const apiVersionParam =
+    apiVersionParams && apiVersionParams.length === 1
+      ? apiVersionParams[0]
+      : undefined;
+  writeClassProperties(clientClass, clientParams, importedModels);
+  writeConstructor(clientDetails, clientClass, importedModels, apiVersionParam);
+  if (useCoreV2 && apiVersionParam) {
+    writeCustomApiVersion(clientClass);
+  }
   writeClientOperations(
     clientFile,
     clientClass,
@@ -205,7 +230,6 @@ export function generateClient(clientDetails: ClientDetails, project: Project) {
     hasLro,
     importedModels
   );
-
   // Use named import from Models
   if (importedModels.size) {
     clientFile.addImportDeclaration({
@@ -217,6 +241,26 @@ export function generateClient(clientDetails: ClientDetails, project: Project) {
   clientFile.fixUnusedIdentifiers();
 }
 
+function writeClassProperties(
+  clientClass: ClassDeclaration,
+  clientParams: ParameterDetails[],
+  importedModels: Set<string>
+) {
+  const params = clientParams.filter(p => !p.isSynthetic);
+  params.forEach(({ typeDetails }) =>
+    typeDetails.usedModels.forEach(model => importedModels.add(model))
+  );
+  clientClass.addProperties(
+    params.map(param => {
+      return {
+        name: param.name,
+        type: param.typeDetails.typeName,
+        hasQuestionToken: !param.required
+      } as PropertyDeclarationStructure;
+    })
+  );
+}
+
 export function checkForNameCollisions(
   importedOperations: OperationGroupDetails[],
   inlineOperations: OperationGroupDetails[]
@@ -244,7 +288,8 @@ export function checkForNameCollisions(
 function writeConstructor(
   clientDetails: ClientDetails,
   classDeclaration: ClassDeclaration,
-  importedModels: Set<string>
+  importedModels: Set<string>,
+  apiVersionParam?: ParameterDetails
 ) {
   const requiredParams = clientDetails.parameters.filter(
     param =>
@@ -296,8 +341,57 @@ function writeConstructor(
     ]
   });
 
+  const { useCoreV2 } = getAutorestOptions();
+  const hasLro = clientDetails.operationGroups.some(og =>
+    og.operations.some(o => o.isLro)
+  );
+
+  const clientParams = clientDetails.parameters.filter(
+    param => param.implementationLocation === ImplementationLocation.Client
+  );
+  const addBlankLine = true;
+  const requiredParameters = getRequiredParamAssignments(requiredParams);
+  const constantParameters = getConstantClientParamAssignments(clientParams);
+
+  const writeStatement = (content: string, shouldAddBlankLine = false) => (
+    writer: CodeBlockWriter
+  ) => {
+    if (content) {
+      writer.writeLine(content);
+      shouldAddBlankLine && writer.blankLine();
+    }
+  };
+
+  const writeStatements = (lines: string[], shouldAddBlankLine = false) => (
+    writer: CodeBlockWriter
+  ) => {
+    lines.forEach(line => writer.writeLine(line));
+    shouldAddBlankLine && writer.blankLine();
+  };
+
+  clientConstructor.addStatements([
+    writeStatements(getRequiredParamChecks(requiredParams), addBlankLine),
+    writeStatement(
+      writeDefaultOptions(
+        clientParams.some(p => p.name === "credentials"),
+        hasLro,
+        clientDetails
+      )
+    )
+  ]);
+
+  !useCoreV2 &&
+    clientConstructor.addStatements([
+      writeStatement(getEndpointStatement(clientDetails.endpoint), addBlankLine)
+    ]);
+
   clientConstructor.addStatements([
-    `super(${[...requiredParams.map(p => p.name), "options"].join()});`
+    requiredParameters.length ? "// Parameter assignments" : "",
+    writeStatements(getRequiredParamAssignments(requiredParams), addBlankLine),
+    constantParameters.length
+      ? "// Assigning values to Constant parameters"
+      : "",
+    writeStatements(constantParameters, addBlankLine)
   ]);
 
   const operationDeclarationDetails: OperationDeclarationDetails[] = getOperationGroupsDeclarationDetails(
@@ -309,6 +403,53 @@ function writeConstructor(
       ({ name, typeName }) => `this.${name} = new ${typeName}Impl(this)`
     )
   ]);
+  if (useCoreV2 && apiVersionParam) {
+    clientConstructor.addStatements(
+      `this.addCustomApiVersionPolicy(${
+        !apiVersionParam.required ||
+        !!apiVersionParam.defaultValue ||
+        apiVersionParam.schemaType === SchemaType.Constant
+          ? "options."
+          : ""
+      }apiVersion);`
+    );
+  }
+}
+
+function writeCustomApiVersion(classDeclaration: ClassDeclaration) {
+  const operationMethod = classDeclaration.addMethod({
+    name: "addCustomApiVersionPolicy",
+    parameters: [
+      { name: "apiVersion", type: "string", hasQuestionToken: true }
+    ],
+    scope: Scope.Private,
+    docs: [
+      "A function that adds a policy that sets the api-version (or equivalent) to reflect the library version."
+    ],
+    isAsync: false
+  });
+  operationMethod.addStatements(`if (!apiVersion) { return; }
+  const apiVersionPolicy =  {
+    
+    name: "CustomApiVersionPolicy",
+    async sendRequest(request: PipelineRequest, next: SendRequest): Promise<PipelineResponse> {
+      const param = request.url.split('?');
+      if (param.length > 1) {
+        const newParams = param[1].split('&').map((item) => {
+          if(item.indexOf('api-version') > -1) {
+            return "api-version=" + apiVersion;
+          } else {
+            return item;
+          }
+        });
+        request.url = param[0] + "?" + newParams.join("&");
+
+      }
+      return next(request);
+    },
+  };
+  this.pipeline.addPolicy(apiVersionPolicy);
+  `);
 }
 
 function getOperationGroupsDeclarationDetails(
@@ -373,3 +514,212 @@ function writeClientOperations(
     })
   );
 }
+
+function getRequiredParamChecks(requiredParameters: ParameterDetails[]) {
+  return requiredParameters.map(
+    ({ name }) => `if(${name} === undefined) {
+    throw new Error("'${name}' cannot be null");
+  }`
+  );
+}
+
+function getCredentialScopesValue(credentialScopes?: string | string[]) {
+  if (Array.isArray(credentialScopes)) {
+    if (
+      credentialScopes.length === 1 &&
+      credentialScopes[0] === "user_impersonation"
+    ) {
+      return undefined;
+    }
+    return `[${credentialScopes.map(scope => `"${scope}"`).join()}]`;
+  } else if (typeof credentialScopes === "string") {
+    if (credentialScopes === "user_impersonation") {
+      return undefined;
+    }
+    return `"${credentialScopes}"`;
+  }
+
+  return credentialScopes;
+}
+
+function getTrack1DefaultContent(addScopes: string, hasCredentials: boolean) {
+  return `// Initializing default values for options
+  if (!options) {
+     options = {};
+  }
+
+  const defaultUserAgent = \`azsdk-js-\${packageName.replace(/@.*\\//,"")}/\${packageVersion} \${coreHttp.getDefaultUserAgentValue()}\`;
+  
+  ${addScopes}
+
+  super(${hasCredentials ? "credentials" : `undefined`}, {
+    ...options,
+    userAgent: options.userAgent
+      ? \`\${options.userAgent} \${defaultUserAgent}\`
+      : \`\${defaultUserAgent}\`
+  });
+  
+  this.requestContentType = "application/json; charset=utf-8";
+  
+  `;
+}
+
+function getTrack2DefaultContent(
+  addScopes: string,
+  defaults: string,
+  packageDetails: PackageDetails,
+  clientDetails: ClientDetails
+) {
+  const { azureArm, allowInsecureConnection } = getAutorestOptions();
+
+  const defaultContent = `// Initializing default values for options
+  if (!options) {
+    options = {};
+  }
+  ${defaults}
+
+  const packageDetails = \`azsdk-js-${packageDetails.name.replace(
+    /@.*\//,
+    ""
+  )}/${packageDetails.version}\`;
+  const userAgentPrefix =
+      options.userAgentOptions && options.userAgentOptions.userAgentPrefix
+        ? \`\${options.userAgentOptions.userAgentPrefix} \${packageDetails}\`
+        : \`\${packageDetails}\`;
+  
+  ${addScopes}
+  const optionsWithDefaults = {
+    ...defaults,
+    ...options,
+    userAgentOptions: {
+      userAgentPrefix
+    },
+    baseUri: ${getEndpoint(clientDetails.endpoint)}
+  };
+  super(optionsWithDefaults);
+  `;
+
+  if (azureArm && !allowInsecureConnection) {
+    return (
+      defaultContent +
+      `
+      if (options?.pipeline && options.pipeline.getOrderedPolicies().length > 0) {
+        const pipelinePolicies: coreRestPipeline.PipelinePolicy[] = options.pipeline.getOrderedPolicies();
+        const bearerTokenAuthenticationPolicyFound = pipelinePolicies.some(
+          pipelinePolicy =>
+            pipelinePolicy.name ===
+            coreRestPipeline.bearerTokenAuthenticationPolicyName
+        );
+        if (!bearerTokenAuthenticationPolicyFound) {
+          this.pipeline.removePolicy({
+            name: coreRestPipeline.bearerTokenAuthenticationPolicyName
+          });
+          this.pipeline.addPolicy(
+            coreRestPipeline.bearerTokenAuthenticationPolicy({
+              scopes: \`\${optionsWithDefaults.baseUri}/.default\`,
+              challengeCallbacks: {
+                authorizeRequestOnChallenge:
+                  coreClient.authorizeRequestOnClaimChallenge
+              }
+            })
+          );
+        }
+      }
+    `
+    );
+  }
+
+  return defaultContent;
+}
+
+function writeDefaultOptions(
+  hasCredentials: boolean,
+  hasLro: boolean,
+  clientDetails: ClientDetails
+) {
+  const { useCoreV2, packageDetails, addCredentials } = getAutorestOptions();
+  const { credentialScopes } = getSecurityInfoFromModel(clientDetails.security);
+
+  const credentialScopesValues = getCredentialScopesValue(credentialScopes);
+  const addScopes = isAddScopes(
+    addCredentials,
+    credentialScopes,
+    credentialScopesValues
+  )
+    ? `if(!options.credentialScopes) {
+    options.credentialScopes = ${credentialScopesValues}
+  }`
+    : "";
+
+  const defaults = !hasCredentials
+    ? `const defaults: ${clientDetails.className}OptionalParams = {
+    requestContentType: "application/json; charset=utf-8"
+  };`
+    : `const defaults: ${clientDetails.className}OptionalParams = {
+    requestContentType: "application/json; charset=utf-8",
+    credential: credentials
+  };`;
+
+  return !useCoreV2
+    ? getTrack1DefaultContent(addScopes, hasCredentials)
+    : getTrack2DefaultContent(
+        addScopes,
+        defaults,
+        packageDetails,
+        clientDetails
+      );
+}
+
+function isAddScopes(
+  addCredentials?: boolean,
+  credentialScopes?: string[],
+  credentialScopesValues?: string
+) {
+  return (
+    addCredentials &&
+    credentialScopes &&
+    credentialScopesValues &&
+    credentialScopes.length > 0
+  );
+}
+
+function getEndpointStatement({ endpoint }: EndpointDetails) {
+  return `this.baseUri = options.endpoint ?? ${
+    endpoint ? `"${endpoint}"` : `""`
+  };`;
+}
+
+function getEndpoint({ endpoint }: EndpointDetails) {
+  return `options.endpoint ?? options.baseUri ?? ${
+    endpoint ? `"${endpoint}"` : `""`
+  }`;
+}
+
+function getRequiredParamAssignments(requiredParameters: ParameterDetails[]) {
+  const disallowedClientParameters = ["credentials"];
+  return requiredParameters
+    .filter(({ name }) => !disallowedClientParameters.includes(name))
+    .map(({ name }) => `this.${name} = ${name};`);
+}
+
+function getConstantClientParamAssignments(
+  clientParameters: ParameterDetails[]
+) {
+  return clientParameters
+    .filter(p => !!p.defaultValue || p.schemaType === SchemaType.Constant)
+    .map(
+      ({ name, defaultValue }) =>
+        `this.${name} = options.${name} ||  ${defaultValue}`
+    );
+}
+
+function writePackageInfo(
+  sourceFile: SourceFile,
+  packageDetails: PackageDetails
+) {
+  sourceFile.addStatements([
+    `\n\n`,
+    `const packageName = "${packageDetails.name || ""}";`,
+    `const packageVersion = "${packageDetails.version || ""}";`
+  ]);
+}