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

package/src/transforms/samplesTransforms.ts

@@ -0,0 +1,349 @@
+import {
+    ChoiceSchema,
+    CodeModel,
+    ConstantSchema,
+    ImplementationLocation,
+    Operation,
+    OperationGroup,
+    SchemaType
+  } from "@autorest/codemodel";
+  import { ClientDetails } from "../models/clientDetails";
+  import { SampleGroup, SampleDetails } from "../models/sampleDetails";
+  import { ExampleValue, TestCodeModel } from "@autorest/testmodeler/dist/src/core/model";
+  import { getLanguageMetadata } from "../utils/languageHelpers";
+  import { getAutorestOptions, getSession } from "../autorestSession";
+  import {
+    getOperationFullName,
+    NameType,
+    normalizeName
+  } from "../utils/nameUtils";
+  import { calculateMethodName } from "../generators/utils/operationsUtils";
+  import { camelCase } from "@azure-tools/codegen";
+  import { OperationGroupDetails } from "../models/operationDetails";
+  import { getPublicMethodName } from "../generators/utils/pagingOperations";
+  import { getTypeForSchema } from "../utils/schemaHelpers";
+  
+  export async function transformSamples(
+    codeModel: CodeModel,
+    clientDetails: ClientDetails
+  ): Promise<SampleGroup[]> {
+    return await getAllExamples(codeModel as TestCodeModel, clientDetails);
+  }
+  
+  function getTransformedOperationGroup(
+    operationGroup: OperationGroup,
+    operationGroupDetails: OperationGroupDetails[]
+  ) {
+    return operationGroupDetails.filter(
+      operationGroupDetail =>
+        operationGroup.$key === operationGroupDetail.originalKey
+    )[0];
+  }
+  
+  function getTransformedOperation(
+    operationGroup: OperationGroup,
+    operation: Operation,
+    operationGroupDetails: OperationGroupDetails,
+    clientName: string
+  ) {
+    return operationGroupDetails.operations.filter(
+      operationDetail =>
+        operationDetail.fullName ===
+        getOperationFullName(operationGroup, operation, clientName)
+    )[0];
+  }
+  
+  export async function getAllExamples(
+    codeModel: TestCodeModel,
+    clientDetails: ClientDetails
+  ) {
+    const operationGroupDetails = clientDetails.operationGroups;
+    const { packageDetails } = getAutorestOptions();
+    const session = getSession();
+    let examplesModels: SampleGroup[] = [];
+    if (codeModel?.testModel?.mockTest?.exampleGroups !== undefined) {
+      for (const exampleGroup of codeModel.testModel.mockTest.exampleGroups) {
+        const clientName = getLanguageMetadata(codeModel.language).name;
+        const ogDetails = getTransformedOperationGroup(
+          exampleGroup.operationGroup,
+          operationGroupDetails
+        );
+        if (ogDetails === undefined) {
+          session.error("An error was encountered while transforming sample", [
+            exampleGroup.operationId
+          ]);
+          continue;
+        }
+        if (!(exampleGroup?.examples?.length > 0)) {
+          // Skip tranforming sample detail no given example in group
+          continue;
+        }
+        const opDetails = getTransformedOperation(
+          exampleGroup.operationGroup,
+          exampleGroup.operation,
+          ogDetails,
+          clientName
+        );
+        let methodName = calculateMethodName(opDetails);
+        if (opDetails.isLro && opDetails.pagination === undefined) {
+          methodName = `${methodName}AndWait`;
+        } else if (opDetails.pagination) {
+          methodName = getPublicMethodName(opDetails);
+        }
+        const opGroupName = ogDetails.name;
+        const importedTypeSet = new Set<string>();
+        const operatonConcante = `${exampleGroup?.operationGroup?.language?.default?.name}${exampleGroup?.operation?.language?.default?.name}`;
+        const sampleGroup: SampleGroup = {
+          sampleFileName: `${camelCase(
+            _transformSpecialLetterToSpace(operatonConcante)
+          )}Sample`,
+          clientClassName: clientName,
+          clientPackageName: packageDetails.name,
+          samples: [],
+          importedTypes: []
+        };
+        try {
+          for (const example of exampleGroup.examples) {
+            const sample: SampleDetails = {
+              sampleFunctionName: camelCase(
+                _transformSpecialLetterToSpace(example?.name)
+              ),
+              clientParameterNames: "",
+              methodParameterNames: "",
+              clientParamAssignments: [],
+              methodParamAssignments: [],
+              originalFileLocation: example.originalFile,
+              isTopLevel: ogDetails.isTopLevel,
+              isPaging: opDetails.pagination !== undefined,
+              operationName: methodName,
+              clientClassName: clientName,
+              operationGroupName: normalizeName(
+                opGroupName,
+                NameType.Property,
+                true
+              ),
+              operationDescription: getLanguageMetadata(
+                exampleGroup.operation.language
+              ).description
+            };
+            const clientParameterNames = ["credential"];
+            const requiredParams = clientDetails.parameters.filter(
+              param =>
+                param.required &&
+                param.implementationLocation === ImplementationLocation.Client &&
+                !param.defaultValue &&
+                param.schemaType !== SchemaType.Constant
+            );
+            for (const clientParameter of example.clientParameters) {
+              if (
+                clientParameter.exampleValue.schema.type === SchemaType.Constant
+              ) {
+                continue;
+              }
+              const parameterName = normalizeName(
+                getLanguageMetadata(clientParameter.exampleValue.language).name,
+                NameType.Parameter,
+                true
+              );
+              const paramAssignment =
+                `const ${parameterName} = ` +
+                getParameterAssignment(clientParameter.exampleValue);
+              sample.clientParamAssignments.push(paramAssignment);
+              clientParameterNames.push(parameterName);
+            }
+            if (
+              clientParameterNames.indexOf("subscriptionId") < 0 &&
+              requiredParams.find(param => param.name === "subscriptionId")
+            ) {
+              const subscriptionIdAssignment = `const subscriptionId = "00000000-0000-0000-0000-000000000000"`;
+              sample.clientParamAssignments.push(subscriptionIdAssignment);
+              clientParameterNames.push("subscriptionId");
+            }
+            if (clientParameterNames.length > 0) {
+              sample.clientParameterNames = clientParameterNames.join(", ");
+            }
+            const methodParameterNames = [];
+            const optionalParams: [string, string][] = [];
+            for (const methodParameter of example.methodParameters) {
+              if (
+                methodParameter.exampleValue.schema.type === SchemaType.Constant
+              ) {
+                continue;
+              }
+              const parameterName = normalizeName(
+                getLanguageMetadata(methodParameter.exampleValue.language).name,
+                NameType.Parameter,
+                true
+              );
+              const parameterTypeDetails = getTypeForSchema(
+                methodParameter.exampleValue.schema
+              );
+              const parameterTypeName = parameterTypeDetails.typeName;
+              let paramAssignment = "";
+              if (methodParameter.parameter.protocol?.http?.["in"] === "body") {
+                let bodySchemaName = parameterTypeName;
+                if (
+                  methodParameter.exampleValue.schema.type ===
+                    SchemaType.AnyObject ||
+                  methodParameter.exampleValue.schema.type === SchemaType.Any
+                ) {
+                  bodySchemaName = "Record<string, unknown>";
+                } else if (methodParameter.exampleValue.schema.type !== SchemaType.Dictionary) {
+                  importedTypeSet.add(parameterTypeName);
+                }
+                paramAssignment =
+                  `const ${parameterName}: ${bodySchemaName} = ` +
+                  getParameterAssignment(methodParameter.exampleValue);
+              } else {
+                paramAssignment =
+                  `const ${parameterName} = ` +
+                  getParameterAssignment(methodParameter.exampleValue);
+              }
+              if (!methodParameter.parameter.required) {
+                optionalParams.push([parameterName, parameterTypeName]);
+              } else {
+                methodParameterNames.push(parameterName);
+              }
+              sample.methodParamAssignments.push(paramAssignment);
+            }
+            if (optionalParams.length > 0) {
+              const optionTypeName = `${opDetails.typeDetails.typeName}OptionalParams`;
+              importedTypeSet.add(optionTypeName);
+              const optionAssignment = `const options: ${optionTypeName} = {${optionalParams
+                .map(item => {
+                  return item[0];
+                })
+                .join(", ")}}`;
+              sample.methodParamAssignments.push(optionAssignment);
+              methodParameterNames.push("options");
+            }
+            if (methodParameterNames.length > 0) {
+              sample.methodParameterNames = methodParameterNames.join(", ");
+            }
+            sampleGroup.samples.push(sample);
+          }
+        } catch (error) {
+          session.error("An error was encountered while transforming sample", [
+            exampleGroup.operationId
+          ]);
+          throw error;
+        }
+        if (sampleGroup.samples.length > 0) {
+          // enrich the importedTypes after all examples resolved
+          sampleGroup.importedTypes = Array.from(importedTypeSet);
+          examplesModels.push(sampleGroup);
+        }
+      }
+    }
+    return examplesModels;
+  }
+  
+  function _transformSpecialLetterToSpace(str: string) {
+    if (!str) {
+      return str;
+    }
+    return str
+      .replace(/_/g, " ")
+      .replace(/\//g, " Or ")
+      .replace(/,|\.|\(|\)/g, " ")
+      .replace("'s ", " ");
+  }
+  
+  function getParameterAssignment(exampleValue: ExampleValue) {
+    let schemaType = exampleValue.schema.type;
+    const rawValue = exampleValue.rawValue;
+    let retValue = rawValue;
+    switch (schemaType) {
+      case SchemaType.Constant:
+        const contentSchema = exampleValue.schema as ConstantSchema;
+        schemaType = contentSchema.valueType.type;
+        break;
+      case SchemaType.Choice:
+      case SchemaType.SealedChoice:
+        const choiceSchema = exampleValue.schema as ChoiceSchema;
+        schemaType = choiceSchema.choiceType.type;
+        break;
+    }
+    if (rawValue === null) {
+      switch (schemaType) {
+        case SchemaType.Object:
+        case SchemaType.Any:
+        case SchemaType.Dictionary:
+        case SchemaType.AnyObject:
+          retValue = `{}`;
+          break;
+        case SchemaType.Array:
+          retValue = `[]`;
+          break;
+        default:
+          retValue = undefined;
+      }
+      return retValue;
+    }
+    switch (schemaType) {
+      case SchemaType.String:
+      case SchemaType.Char:
+      case SchemaType.Time:
+      case SchemaType.Uuid:
+      case SchemaType.Uri:
+      case SchemaType.Credential:
+      case SchemaType.Duration:
+        retValue = `"${rawValue
+          ?.toString()
+          .replace(/"/g, '\\"')
+          .replace(/\n/g, "\\n")}"`;
+        break;
+      case SchemaType.Boolean:
+        (retValue = rawValue), toString();
+        break;
+      case SchemaType.Object:
+      case SchemaType.Dictionary:
+        const values = [];
+        for (const prop in exampleValue.properties) {
+          const property = exampleValue.properties[prop];
+          if (property === undefined || property === null) {
+            continue;
+          }
+          const initPropName = property.language?.default?.name
+            ? property.language?.default?.name
+            : prop;
+          const propName = normalizeName(initPropName, NameType.Property, true);
+          let propRetValue: string;
+          if (propName.indexOf("/") > -1 || propName.match(/^\d/)) {
+            propRetValue = `"${propName}": ` + getParameterAssignment(property);
+          } else {
+            propRetValue = `${propName}: ` + getParameterAssignment(property);
+          }
+          values.push(propRetValue);
+        }
+        if (values.length > 0) {
+          retValue = `{${values.join(", ")}}`;
+        } else {
+          retValue = "{}";
+        }
+        break;
+      case SchemaType.Array:
+        const valuesArr = [];
+        for (const element of <ExampleValue[]>exampleValue.elements) {
+          let propRetValueArr = getParameterAssignment(element);
+          valuesArr.push(propRetValueArr);
+        }
+        if (valuesArr.length > 0) {
+          retValue = `[${valuesArr.join(", ")}]`;
+        } else {
+          retValue = "[]";
+        }
+        break;
+      case SchemaType.Date:
+      case SchemaType.DateTime:
+        retValue = `new Date("${rawValue}")`;
+        break;
+      case SchemaType.Any:
+      case SchemaType.AnyObject:
+        retValue = `${JSON.stringify(rawValue)}`;
+        break;
+      default:
+        break;
+    }
+    return retValue;
+  }

package/src/transforms/transforms.ts

@@ -8,7 +8,9 @@ import {
   CodeModel,
   ChoiceSchema,
   SealedChoiceSchema,
-  SchemaType
+  SchemaType,
+  OAuth2SecurityScheme,
+  KeySecurityScheme
 } from "@autorest/codemodel";
 import { normalizeName, NameType } from "../utils/nameUtils";
 import { getStringForValue } from "../utils/valueHelpers";
@@ -19,7 +21,6 @@ import { transformOptions } from "./optionsTransforms";
 import { transformParameters } from "./parameterTransforms";
 import { transformObjects, transformObject } from "./objectTransforms";
 import { ObjectDetails } from "../models/modelDetails";
-import { Host } from "@autorest/extension-base";
 import { transformBaseUrl } from "./urlTransforms";
 import { normalizeModelWithExtensions } from "./extensions";
 import { transformGroups } from "./groupTransforms";
@@ -70,15 +71,17 @@ export function transformChoice(
     name,
     schemaType,
     itemType,
-    description: `Defines values for ${metadata.name}.`,
+    description: `Defines values for ${normalizeName(
+      metadata.name,
+      NameType.Interface
+    )}.`,
     serializedName: metadata.name,
     properties: extractProperties(choice)
   };
 }
 
 export async function transformCodeModel(
-  codeModel: CodeModel,
-  host: Host
+  codeModel: CodeModel
 ): Promise<ClientDetails> {
   const { name: clientName } = getLanguageMetadata(codeModel.language);
   const className = normalizeName(
@@ -98,12 +101,12 @@ export async function transformCodeModel(
 
   const options = await transformOptions(operationGroups);
 
-  const [objects, groups, mappers, unions, parameters] = await Promise.all([
+  const [objects, groups, parameters, mappers, unions] = await Promise.all([
     transformObjects(codeModel, uberParents),
     transformGroups(codeModel),
+    transformParameters(codeModel, options),
     transformMappers(codeModel, uberParents, options),
-    transformChoices(codeModel),
-    transformParameters(codeModel, options)
+    transformChoices(codeModel)
   ]);
 
   const baseUrl = transformBaseUrl(codeModel);
@@ -119,7 +122,9 @@ export async function transformCodeModel(
     operationGroups,
     parameters,
     options,
-    endpoint: baseUrl
+    endpoint: baseUrl,
+    allTypes: [],
+    security: codeModel.security
   };
 }
 

package/src/typescriptGenerator.ts

@@ -2,13 +2,14 @@
 // Licensed under the MIT License.
 
 import * as prettier from "prettier";
+import * as fsextra from "fs-extra";
+import * as path from "path";
 import { CodeModel } from "@autorest/codemodel";
 import { Project, IndentationText } from "ts-morph";
-import { Host } from "@autorest/extension-base";
+import { AutorestExtensionHost } from "@autorest/extension-base";
 import { transformCodeModel } from "./transforms/transforms";
-import { ClientDetails } from "./models/clientDetails";
+import { transformSamples } from './transforms/samplesTransforms';
 import { generateClient } from "./generators/clientFileGenerator";
-import { generateClientContext } from "./generators/clientContextFileGenerator";
 import { generateModels } from "./generators/modelsGenerator";
 import { generateMappers } from "./generators/mappersGenerator";
 import { generateIndexFile } from "./generators/indexGenerator";
@@ -16,14 +17,18 @@ import { generatePackageJson } from "./generators/static/packageFileGenerator";
 import { generateApiExtractorConfig } from "./generators/static/apiExtractorConfig";
 import { generateLicenseFile } from "./generators/static/licenseFileGenerator";
 import { generateReadmeFile } from "./generators/static/readmeFileGenerator";
+import { generateSampleTestFile } from "./generators/test/sampleTestGenerator";
 import { generateTsConfig } from "./generators/static/tsConfigFileGenerator";
 import { generateRollupConfig } from "./generators/static/rollupConfigFileGenerator";
 import { generateOperations } from "./generators/operationGenerator";
 import { generateOperationsInterfaces } from "./generators/operationInterfaceGenerator";
+import { generateSampleEnv } from "./generators/samples/sampleEnvGenerator";
+import { generateHLCSamples } from "./generators/samples/hlcSampleGenerator";
 import { generateParameters } from "./generators/parametersGenerator";
 import { generateLroFiles } from "./generators/LROGenerator";
 import { generateTracingFile } from "./generators/tracingFileGenerator";
 import { getAutorestOptions } from "./autorestSession";
+import { conflictResolver } from "./conflictResolver";
 
 const prettierTypeScriptOptions: prettier.Options = {
   parser: "typescript",
@@ -45,7 +50,7 @@ const prettierJSONOptions: prettier.Options = {
 
 export async function generateTypeScriptLibrary(
   codeModel: CodeModel,
-  host: Host
+  host: AutorestExtensionHost
 ): Promise<void> {
   const project = new Project({
     useInMemoryFileSystem: true,
@@ -56,46 +61,48 @@ export async function generateTypeScriptLibrary(
 
   const {
     packageDetails,
-    licenseHeader: shouldGenerateLicense
+    licenseHeader: shouldGenerateLicense,
+    generateTest,
+    generateSample,
+    outputPath,
+    srcPath
   } = getAutorestOptions();
 
-  const clientDetails = await transformCodeModel(codeModel, host);
-
-  clientDetails.operationGroups.forEach(operationGroup => {
-    const isConflict: boolean = checkForConflictWithDefinitions(
-      operationGroup.name,
-      clientDetails
-    );
-
-    if (isConflict) {
-      operationGroup.operations.forEach(operation => {
-        operation.typeDetails.typeName = operation.typeDetails.typeName.replace(
-          operationGroup.name,
-          `${operationGroup.name}Operations`
-        );
-      });
-      operationGroup.name = `${operationGroup.name}Operations`;
-      operationGroup.key = `${operationGroup.key}Operations`;
-    }
-  });
+  const clientDetails = await transformCodeModel(codeModel);
+  conflictResolver(clientDetails);
 
+  generateModels(clientDetails, project);
+  if (generateSample) {
+    clientDetails.samples = await transformSamples(codeModel, clientDetails);
+  }
   // Skip metadata generation if `generate-metadata` is explicitly false
   generatePackageJson(project, clientDetails);
   generateLicenseFile(project);
-  generateReadmeFile(clientDetails, project);
+  generateReadmeFile(codeModel, project);
+  if (generateTest) {
+    generateSampleTestFile(project);
+  }
   generateTsConfig(project);
   generateRollupConfig(project);
   generateApiExtractorConfig(project);
 
   generateClient(clientDetails, project);
-  generateClientContext(clientDetails, packageDetails, project);
-  generateModels(clientDetails, project);
 
   generateMappers(clientDetails, project);
   generateOperations(clientDetails, project);
   generateOperationsInterfaces(clientDetails, project);
+  if (generateSample || generateTest) {
+    generateSampleEnv(project);
+  }
+  if (
+    generateSample &&
+    clientDetails?.samples?.length &&
+    clientDetails?.samples?.length > 0
+  ) {
+    generateHLCSamples(clientDetails, project);
+  }
   generateParameters(clientDetails, project);
-  generateIndexFile(clientDetails, project);
+  generateIndexFile(project, clientDetails);
   await generateLroFiles(clientDetails, project);
   generateTracingFile(project);
 
@@ -112,6 +119,8 @@ export async function generateTypeScriptLibrary(
   // Save the source files to the virtual filesystem
   project.saveSync();
   const fs = project.getFileSystem();
+  const pathToClear = outputPath ? path.join(outputPath, srcPath) : srcPath;
+  fsextra.emptyDirSync(`${pathToClear}`);
 
   // Loop over the files
   for (const file of project.getSourceFiles()) {
@@ -134,22 +143,9 @@ export async function generateTypeScriptLibrary(
     }
 
     // Write the file to the AutoRest host
-    host.WriteFile(
-      filePath.substr(1), // Get rid of the leading slash '/'
-      fileContents
-    );
+    host.writeFile({
+      filename: filePath.substr(1), // Get rid of the leading slash '/'
+      content: fileContents
+    });
   }
 }
-
-function checkForConflictWithDefinitions(
-  operationGroupName: string,
-  clientDetails: ClientDetails
-): boolean {
-  let conflict: boolean = false;
-  clientDetails.objects.forEach(model => {
-    if (model.name === operationGroupName) {
-      conflict = true;
-    }
-  });
-  return conflict;
-}