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

package/src/restLevelClient/helpers/operationHelpers.ts

@@ -0,0 +1,93 @@
+import {
+  ImplementationLocation,
+  Operation,
+  Parameter,
+  SchemaContext
+} from "@autorest/codemodel";
+import {
+  OptionalKind,
+  MethodSignatureStructure,
+  ParameterDeclarationStructure
+} from "ts-morph";
+import { Methods, PathParameter } from "../interfaces";
+import { getElementType } from "../schemaHelpers";
+
+/**
+ * Given an operation, extract all its parameters
+ */
+export function getOperationParameters(
+  operation: Operation,
+  requestIndex = 0
+): Parameter[] {
+  const operationParams = [
+    ...(operation.parameters ?? []),
+    ...(operation.signatureParameters ?? [])
+  ];
+
+  const distinctParams = new Set(operationParams);
+
+  if (operation.requests) {
+    [
+      ...(operation.requests[requestIndex].parameters ?? []),
+      ...(operation.requests[requestIndex].signatureParameters ?? [])
+    ].forEach(p => distinctParams.add(p));
+  }
+
+  return [...distinctParams].filter(filterMethodNotSynthetic);
+}
+
+function filterMethodNotSynthetic(parameter: Parameter) {
+  const isApiVersion =
+    parameter.origin &&
+    parameter.language.default.serializedName === "api-version" &&
+    parameter.implementation === ImplementationLocation.Method;
+  // Origin is added by M4 on synthetic parameters
+  return (
+    (!parameter.origin || isApiVersion) &&
+    parameter.implementation === ImplementationLocation.Method
+  );
+}
+
+export function buildMethodDefinitions(
+  methods: Methods,
+  pathParams: PathParameter[] = []
+): OptionalKind<MethodSignatureStructure>[] {
+  const methodDefinitions: OptionalKind<MethodSignatureStructure>[] = [];
+  for (const key of Object.keys(methods)) {
+    const method = methods[key];
+    const description = methods[key][0].description;
+
+    let areAllOptional = methods[key][0].hasOptionalOptions;
+
+    methodDefinitions.push({
+      name: key,
+      ...(description && { docs: [{ description }] }),
+      parameters: [
+        ...getPathParamDefinitions(pathParams),
+        {
+          name: "options",
+          hasQuestionToken: areAllOptional,
+          type: method.map(m => m.optionsName).join(" | ")
+        }
+      ],
+      returnType: method.map(m => m.returnType).join(" | ")
+    });
+  }
+
+  return methodDefinitions;
+}
+
+export function getPathParamDefinitions(
+  pathParams: PathParameter[]
+): OptionalKind<ParameterDeclarationStructure>[] {
+  return pathParams.map(p => {
+    return {
+      name: p.name,
+      type: getElementType(p.schema, [
+        SchemaContext.Input,
+        SchemaContext.Exception
+      ]),
+      description: p.description
+    };
+  });
+}

package/src/restLevelClient/interfaces.ts

@@ -0,0 +1,26 @@
+import { Schema } from "@autorest/codemodel";
+
+export type PathParameter = {
+  name: string;
+  schema: Schema;
+  description?: string;
+};
+
+export type Methods = {
+  [key: string]: [
+    {
+      optionsName: string;
+      description: string;
+      hasOptionalOptions: boolean;
+      returnType: string;
+    }
+  ];
+};
+
+export type Paths = {
+  [key: string]: {
+    name: string;
+    pathParameters: PathParameter[];
+    methods: Methods;
+  };
+};

package/src/restLevelClient/operationHelpers.ts

@@ -2,7 +2,9 @@ import {
   AnyObjectSchema,
   Operation,
   SchemaResponse,
-  Response
+  Response,
+  Schema,
+  BinarySchema
 } from "@autorest/codemodel";
 import { getLanguageMetadata } from "../utils/languageHelpers";
 import { NameType, normalizeName } from "../utils/nameUtils";
@@ -22,7 +24,11 @@ export function getResponseTypeName(
 
 export function responseToSchemaResponse(response: Response | SchemaResponse) {
   if (!isSchemaResponse(response)) {
-    return new SchemaResponse(new AnyObjectSchema("AnyObject schema"), {
+    let schema: Schema = (response as any).binary
+      ? new BinarySchema("Binary schema")
+      : new AnyObjectSchema("AnyObject schema");
+
+    return new SchemaResponse(schema, {
       ...response
     });
   } else {

package/src/restLevelClient/schemaHelpers.ts

@@ -1,7 +1,6 @@
 import {
   AnyObjectSchema,
   ArraySchema,
-  ByteArraySchema,
   ChoiceSchema,
   ConstantSchema,
   DictionarySchema,
@@ -115,7 +114,6 @@ export function primitiveSchemaToType(
     case SchemaType.Char:
       return "string";
     case SchemaType.ByteArray:
-    case SchemaType.Binary:
     case SchemaType.Duration:
     case SchemaType.Credential:
     case SchemaType.UnixTime:
@@ -123,6 +121,10 @@ export function primitiveSchemaToType(
     case SchemaType.Uuid:
     case SchemaType.String:
       return "string";
+    case SchemaType.Binary:
+      return schemaUse.includes(SchemaContext.Output)
+        ? "Uint8Array"
+        : "string | Uint8Array";
     case SchemaType.Boolean:
       return "boolean";
     case SchemaType.Choice:

package/src/transforms/operationTransforms.ts

@@ -491,6 +491,7 @@ export async function transformOperationGroup(
   return {
     name: operationGroupClassName,
     key: operationGroup.$key,
+    originalKey: operationGroup.$key,
     operations,
     isTopLevel,
     mediaTypes

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, mappers, unions, parameters ] = await Promise.all([
     transformObjects(codeModel, uberParents),
     transformGroups(codeModel),
     transformMappers(codeModel, uberParents, options),
     transformChoices(codeModel),
-    transformParameters(codeModel, options)
+    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
+    });
   }
 }