@autorest/typescript 6.0.0-beta.14 → 6.0.0-beta.17

package/src/autorestSession.ts

@@ -1,11 +1,16 @@
-import { Host, Session, startSession } from "@autorest/extension-base";
+import {
+  AutorestExtensionHost,
+  Session,
+  startSession
+} from "@autorest/extension-base";
 import { CodeModel, codeModelSchema } from "@autorest/codemodel";
 import { extractAutorestOptions } from "./utils/autorestOptions";
 import { PackageDetails } from "./models/packageDetails";
-import { TracingInfo } from "./models/clientDetails";
+import { DependencyInfo, TracingInfo } from "./models/clientDetails";
 
 export interface AutorestOptions {
   restLevelClient?: boolean;
+  rlcShortcut?: boolean;
   azureArm?: boolean;
   addCredentials?: boolean;
   credentialKeyHeaderName?: string;
@@ -27,24 +32,23 @@ export interface AutorestOptions {
   headAsBoolean?: boolean;
   isTestPackage?: boolean;
   generateTest?: boolean;
+  batch?: [string, any][];
+  multiClient?: boolean;
+  generateSample?: boolean;
+  azureSdkForJs?: boolean;
+  productDocLink?: string;
+  coreHttpCompatMode?: boolean;
+  dependencyInfo?: DependencyInfo;
 }
 
-let host: Host;
+let host: AutorestExtensionHost;
 let session: Session<CodeModel>;
 let options: AutorestOptions;
 
-export async function initializeSession(autorestHost: Host) {
-  if (!host) {
-    host = autorestHost;
-  }
-
-  if (!session) {
-    session = await startSession<CodeModel>(host, undefined, codeModelSchema);
-  }
-
-  if (!options) {
-    options = await extractAutorestOptions();
-  }
+export async function initializeSession(autorestHost: AutorestExtensionHost) {
+  host = autorestHost;
+  session = await startSession<CodeModel>(host, codeModelSchema);
+  options = await extractAutorestOptions();
 }
 
 export function getSession(): Session<CodeModel> {
@@ -57,7 +61,7 @@ export function getSession(): Session<CodeModel> {
   return session;
 }
 
-export function getHost(): Host {
+export function getHost(): AutorestExtensionHost {
   if (!host) {
     throw new Error(
       "Host has not been initialized, make sure to call initializeSession early in the plugin startup"

package/src/conflictResolver.ts

@@ -1,5 +1,4 @@
 import { ClientDetails } from "./models/clientDetails";
-import { ParameterDetails } from "./models/parameterDetails";
 
 const RESERVED_MEMBER_NAMES = ["pipeline"];
 

package/src/generators/clientFileGenerator.ts

@@ -5,7 +5,8 @@ import {
   Project,
   PropertyDeclarationStructure,
   ClassDeclaration,
-  SourceFile
+  SourceFile,
+  CodeBlockWriter
 } from "ts-morph";
 import { ClientDetails } from "../models/clientDetails";
 import {
@@ -25,6 +26,9 @@ 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";
 
 type OperationDeclarationDetails = { name: string; typeName: string };
 
@@ -33,9 +37,10 @@ export function generateClient(clientDetails: ClientDetails, project: Project) {
     useCoreV2,
     hideClients,
     srcPath,
-    addCredentials
+    addCredentials,
+    packageDetails,
+    coreHttpCompatMode
   } = getAutorestOptions();
-  const clientContextClassName = `${clientDetails.className}Context`;
   const hasMappers = !!clientDetails.mappers.length;
 
   // Check if there are any client level operations
@@ -72,36 +77,43 @@ 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"
+    });
+  }
+
   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: "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"
-        });
-      }
     }
   }
 
@@ -163,14 +175,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
   });
 
@@ -185,7 +196,10 @@ export function generateClient(clientDetails: ClientDetails, project: Project) {
   }
 
   const importedModels = new Set<string>();
-
+  const clientParams = clientDetails.parameters.filter(
+    param => param.implementationLocation === ImplementationLocation.Client
+  );
+  writeClassProperties(clientClass, clientParams, importedModels);
   writeConstructor(clientDetails, clientClass, importedModels);
   writeClientOperations(
     clientFile,
@@ -206,6 +220,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[]
@@ -285,8 +319,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([
-    `super(${[...requiredParams.map(p => p.name), "options"].join()});`
+    writeStatements(getRequiredParamChecks(requiredParams), addBlankLine),
+    writeStatement(
+      writeDefaultOptions(
+        clientParams.some(p => p.name === "credentials"),
+        hasLro,
+        clientDetails
+      )
+    )
+  ]);
+
+  !useCoreV2 &&
+    clientConstructor.addStatements([
+      writeStatement(getEndpointStatement(clientDetails.endpoint), addBlankLine)
+    ]);
+
+  clientConstructor.addStatements([
+    requiredParameters.length ? "// Parameter assignments" : "",
+    writeStatements(getRequiredParamAssignments(requiredParams), addBlankLine),
+    constantParameters.length
+      ? "// Assigning values to Constant parameters"
+      : "",
+    writeStatements(constantParameters, addBlankLine)
   ]);
 
   const operationDeclarationDetails: OperationDeclarationDetails[] = getOperationGroupsDeclarationDetails(
@@ -362,3 +445,151 @@ 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)) {
+    return `[${credentialScopes.map(scope => `"${scope}"`).join()}]`;
+  } else if (typeof credentialScopes === "string") {
+    return `"${credentialScopes}"`;
+  }
+
+  return credentialScopes;
+}
+
+function getTrack2DefaultContent(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 getTrack1DefaultContent(
+  addScopes: string,
+  defaults: string,
+  packageDetails: PackageDetails,
+  clientDetails: ClientDetails
+) {
+  return `// 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);
+  `;
+}
+
+function writeDefaultOptions(
+  hasCredentials: boolean,
+  hasLro: boolean,
+  clientDetails: ClientDetails
+) {
+  const { useCoreV2, credentialScopes, packageDetails } = getAutorestOptions();
+
+  const credentialScopesValues = getCredentialScopesValue(credentialScopes);
+  const addScopes = credentialScopes
+    ? `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
+    ? getTrack2DefaultContent(addScopes, hasCredentials)
+    : getTrack1DefaultContent(
+        addScopes,
+        defaults,
+        packageDetails,
+        clientDetails
+      );
+}
+
+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 || ""}";`
+  ]);
+}

package/src/generators/indexGenerator.ts

@@ -12,7 +12,7 @@ export function generateIndexFile(
   project: Project,
   clientDetails?: ClientDetails
 ) {
-  const { restLevelClient, srcPath } = getAutorestOptions();
+  const { restLevelClient, srcPath, multiClient, batch } = getAutorestOptions();
   const indexFile = project.createSourceFile(`${srcPath}/index.ts`, undefined, {
     overwrite: true
   });
@@ -24,30 +24,103 @@ export function generateIndexFile(
       );
     }
     generateHLCIndex(clientDetails, indexFile);
-  } else {
+  } else if (!multiClient || !batch || batch?.length === 1) {
+    // if we are generate single client package for RLC
     generateRLCIndex(indexFile);
+  } else {
+    generateRLCIndexForMultiClient(indexFile);
+  }
+}
+
+// to generate a index.ts for each single module inside the multi client RLC package
+function generateRLCIndexForMultiClient(file: SourceFile) {
+  const { model } = getSession();
+  const clientName = model.language.default.name;
+  const createClientFuncName = `${clientName}`;
+  const moduleName = normalizeName(clientName, NameType.File);
+
+  file.addImportDeclaration({
+    namespaceImport: "Parameters",
+    moduleSpecifier: "./parameters"
+  });
+
+  file.addImportDeclaration({
+    namespaceImport: "Responses",
+    moduleSpecifier: "./responses"
+  });
+
+  file.addImportDeclaration({
+    namespaceImport: "Client",
+    moduleSpecifier: "./clientDefinitions"
+  })
+
+  const exports = ['Parameters', 'Responses', 'Client'];
+  if (hasInputModels(model)) {
+    file.addImportDeclaration({
+      namespaceImport: "Models",
+      moduleSpecifier: "./models",
+    });
+    exports.push("Models");
+  }
+
+  if (hasOutputModels(model)) {
+    file.addImportDeclaration({
+      namespaceImport: "OutputModels",
+      moduleSpecifier: "./outputModels",
+    });
+    exports.push("OutputModels");
+  }
+
+  if (hasPagingOperations(model)) {
+    file.addImportDeclaration({
+      namespaceImport: "PaginateHelper",
+      moduleSpecifier: './paginateHelper',
+    });
+    exports.push("PaginateHelper");
   }
+
+  if (hasPollingOperations(model)) {
+    file.addImportDeclaration({
+      namespaceImport: 'PollingHelper',
+      moduleSpecifier: './pollingHelper',
+    })
+    exports.push("PollingHelper");
+  }
+
+  file.addExportDeclarations([
+    {
+      moduleSpecifier: `./${moduleName}`,
+      namedExports: [createClientFuncName],
+    },
+    {
+      namedExports: [...exports]
+    }
+  ]);
 }
 
 function generateRLCIndex(file: SourceFile) {
   const { model } = getSession();
   const clientName = model.language.default.name;
+  const createClientFuncName = `${clientName}`;
   const moduleName = normalizeName(clientName, NameType.File);
 
   file.addImportDeclaration({
     moduleSpecifier: `./${moduleName}`,
-    defaultImport: clientName
+    defaultImport: createClientFuncName
   });
 
   file.addExportDeclarations([
     {
-      moduleSpecifier: `./${moduleName}`
+      moduleSpecifier: `./${moduleName}`,
     },
     {
       moduleSpecifier: "./parameters"
     },
     {
       moduleSpecifier: "./responses"
+    },
+    {
+      moduleSpecifier: "./clientDefinitions"
     }
   ]);
 
@@ -84,7 +157,7 @@ function generateRLCIndex(file: SourceFile) {
   }
 
   file.addExportAssignment({
-    expression: clientName,
+    expression: createClientFuncName,
     isExportEquals: false
   });
 }
@@ -102,10 +175,6 @@ function generateHLCIndex(clientDetails: ClientDetails, file: SourceFile) {
     {
       moduleSpecifier: `./${clientDetails.sourceFileName}`,
       namedExports: [clientDetails.className]
-    },
-    {
-      moduleSpecifier: `./${clientDetails.sourceFileName}Context`,
-      namedExports: [`${clientDetails.className}Context`]
     }
   ]);
 

package/src/generators/modelsGenerator.ts

@@ -69,6 +69,10 @@ export function generateModels(clientDetails: ClientDetails, project: Project) {
       namespaceImport: "coreRestPipeline",
       moduleSpecifier: "@azure/core-rest-pipeline"
     });
+    modelsIndexFile.addImportDeclaration({
+      namespaceImport: "coreHttpCompat",
+      moduleSpecifier: "@azure/core-http-compat"
+    });
   }
 
   writeUniontypes(clientDetails, modelsIndexFile);
@@ -77,13 +81,21 @@ export function generateModels(clientDetails: ClientDetails, project: Project) {
   writeOperationModels(clientDetails, modelsIndexFile);
   writeClientModels(clientDetails, modelsIndexFile);
   modelsIndexFile.fixUnusedIdentifiers();
+  const allTypes = modelsIndexFile.getTypeAliases();
+  clientDetails.allTypes = allTypes
+    .filter(item => {
+      return item.isExported();
+    })
+    .map(item => {
+      return item.getName();
+    });
 }
 
 const writeClientModels = (
   clientDetails: ClientDetails,
   modelsIndexFile: SourceFile
 ) => {
-  const { useCoreV2 } = getAutorestOptions();
+  const { useCoreV2, coreHttpCompatMode } = getAutorestOptions();
   let clientOptionalParams = clientDetails.parameters.filter(
     p =>
       (!p.required || p.defaultValue) &&
@@ -97,6 +109,8 @@ const writeClientModels = (
     {
       baseClass: !useCoreV2
         ? "coreHttp.ServiceClientOptions"
+        : coreHttpCompatMode
+        ? "coreHttpCompat.ExtendedServiceClientOptions"
         : "coreClient.ServiceClientOptions"
     }
   );
@@ -771,6 +785,12 @@ function getPropertyTypeName(
   ignoreNullableOnOptional: boolean
 ) {
   if (property.isConstant) {
+    if (
+      property.type === SchemaType.Number ||
+      property.type === SchemaType.Boolean
+    ) {
+      return `${property.defaultValue}`;
+    }
     return `"${getStringForValue(
       property.defaultValue,
       property.type,

package/src/generators/operationGenerator.ts

@@ -475,7 +475,7 @@ function addClass(
     name: "client",
     isReadonly: true,
     scope: Scope.Private,
-    type: `${clientDetails.className}Context`
+    type: `${clientDetails.className}`
   });
   const constructorDefinition = operationGroupClass.addConstructor({
     docs: [
@@ -487,7 +487,7 @@ function addClass(
       {
         name: "client",
         hasQuestionToken: false,
-        type: `${clientDetails.className}Context`
+        type: `${clientDetails.className}`
       }
     ]
   });
@@ -979,11 +979,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(
@@ -1319,16 +1321,16 @@ function addImports(
     });
   }
 
-  const clientContextClassName = `${className}Context`;
+  const clientClassName = `${className}`;
 
-  const clientContextFileName = normalizeName(
-    clientContextClassName,
+  const clientFileName = normalizeName(
+    clientClassName,
     NameType.File
   );
 
   operationGroupFile.addImportDeclaration({
-    namedImports: [`${clientContextClassName}`],
-    moduleSpecifier: `../${clientContextFileName}`
+    namedImports: [`${clientClassName}`],
+    moduleSpecifier: `../${clientFileName}`
   });
 
   if (hasLroOperation(operationGroupDetails)) {

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
+    });
+}