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

package/src/transforms/parameterTransforms.ts

@@ -147,20 +147,36 @@ const extractOperationParameters = (codeModel: CodeModel) =>
           }
           const operationParams: OperationParameterDetails[] = (
             operation.parameters || []
-          ).map(p => ({ parameter: p, operationName }));
+          ).map(p => { 
+            if (p.required) {
+              p.language.default.isTopLevelParameter = true;
+            }
+            return {
+              parameter: p, 
+              operationName 
+            }  
+          });
 
           // Operations may have multiple requests, each with their own set of parameters.
           // This is known to be the case when an operation can consume multiple media types.
           // We need to ensure that the parameters from each request (method overload) is accounted for.
           const requestParams: OperationParameterDetails[] = [];
-          requests.forEach(request => {
-            request.parameters?.forEach(parameter => {
+          requests.map(request => {
+            request.parameters?.map(parameter => {
               requestParams.push({
                 operationName,
                 parameter,
                 targetMediaType: request.protocol.http?.knownMediaType
               });
+              if (parameter.required) {
+                if ((parameter as any)['targetProperty'] !== undefined) {
+                  (parameter as any)['targetProperty'].language.default.isTopLevelParameter = true;
+                }
+                parameter.language.default.isTopLevelParameter = true;
+              }
+              return parameter;
             });
+            return request;
           });
           return [...operations, ...requestParams, ...operationParams];
         },
@@ -331,7 +347,7 @@ function getParameterPath(parameter: Parameter) {
   const name = normalizeName(
     metadata.name,
     NameType.Parameter,
-    true /** shouldGuard */
+    parameter.language.default.isTopLevelParameter ? true: false /** shouldGuard */
   );
 
   if (parameter.groupedBy) {

package/src/transforms/samplesTransforms.ts

@@ -0,0 +1,300 @@
+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";
+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 {
+                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

@@ -18,8 +18,8 @@ import { transformOperationGroups } from "./operationTransforms";
 import { transformOptions } from "./optionsTransforms";
 import { transformParameters } from "./parameterTransforms";
 import { transformObjects, transformObject } from "./objectTransforms";
+import { transformSamples } from "./samplesTransforms";
 import { ObjectDetails } from "../models/modelDetails";
-import { Host } from "@autorest/extension-base";
 import { transformBaseUrl } from "./urlTransforms";
 import { normalizeModelWithExtensions } from "./extensions";
 import { transformGroups } from "./groupTransforms";
@@ -80,8 +80,7 @@ export function transformChoice(
 }
 
 export async function transformCodeModel(
-  codeModel: CodeModel,
-  host: Host
+  codeModel: CodeModel
 ): Promise<ClientDetails> {
   const { name: clientName } = getLanguageMetadata(codeModel.language);
   const className = normalizeName(
@@ -101,12 +100,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)
   ]);
 
   const baseUrl = transformBaseUrl(codeModel);
@@ -122,7 +121,8 @@ export async function transformCodeModel(
     operationGroups,
     parameters,
     options,
-    endpoint: baseUrl
+    endpoint: baseUrl,
+    allTypes: []
   };
 }
 

package/src/typescriptGenerator.ts

@@ -6,10 +6,10 @@ 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 { 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";
@@ -22,6 +22,8 @@ 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 { generateSamples } from './generators/samples/sampleGenerator';
 import { generateParameters } from "./generators/parametersGenerator";
 import { generateLroFiles } from "./generators/LROGenerator";
 import { generateTracingFile } from "./generators/tracingFileGenerator";
@@ -48,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,
@@ -61,17 +63,22 @@ export async function generateTypeScriptLibrary(
     packageDetails,
     licenseHeader: shouldGenerateLicense,
     generateTest,
+    generateSample,
     outputPath,
     srcPath
   } = getAutorestOptions();
 
-  const clientDetails = await transformCodeModel(codeModel, host);
+  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.language, codeModel.info, project);
   if (generateTest) {
     generateSampleTestFile(project);
   }
@@ -80,12 +87,14 @@ export async function generateTypeScriptLibrary(
   generateApiExtractorConfig(project);
 
   generateClient(clientDetails, project);
-  generateClientContext(clientDetails, packageDetails, project);
-  generateModels(clientDetails, project);
 
   generateMappers(clientDetails, project);
   generateOperations(clientDetails, project);
   generateOperationsInterfaces(clientDetails, project);
+  if (generateSample && clientDetails?.samples?.length && clientDetails?.samples?.length > 0) {
+    generateSamples(clientDetails, project);
+    generateSampleEnv(project);
+  }
   generateParameters(clientDetails, project);
   generateIndexFile(project, clientDetails);
   await generateLroFiles(clientDetails, project);
@@ -128,9 +137,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
+    });
   }
 }