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

package/src/restLevelClient/generateRestLevel.ts

@@ -1,4 +1,4 @@
-import { getHost, getSession } from "../autorestSession";
+import { getAutorestOptions, getHost, getSession } from "../autorestSession";
 import { Project, IndentationText } from "ts-morph";
 import { generatePackageJson } from "../generators/static/packageFileGenerator";
 import { generateLicenseFile } from "../generators/static/licenseFileGenerator";
@@ -10,13 +10,40 @@ import { generateSchemaTypes } from "./generateSchemaTypes";
 import { format } from "prettier";
 import { prettierJSONOptions, prettierTypeScriptOptions } from "./config";
 import { generateParameterInterfaces } from "./generateParameterTypes";
-import { generatePathFirstClient } from "./generateClient";
+import { generatePathFirstClient } from "./generateClientDefinition";
+import { generateClient } from "./generateClient";
+import { generateIndexFile } from "../generators/indexGenerator";
+import { generatePagingHelper } from "./generatePagingHelper";
+import { generatePollingHelper } from "./generatePollingHelper";
+import { generateTopLevelIndexFile } from "./generateTopLevelIndexFile";
+import { hasPagingOperations } from "../utils/extractPaginationDetails";
+import { hasPollingOperations } from "./helpers/hasPollingOperations";
+import { generateKarmaConfigFile } from "../generators/static/karmaConfigFileGenerator";
+import { generateEnvFile } from "../generators/test/envFileGenerator";
+import { generateEnvBrowserFile } from "../generators/test/envBrowserFileGenerator";
+import { generateRecordedClientFile } from "../generators/test/recordedClientFileGenerator";
+import { generateSampleTestFile } from "../generators/test/sampleTestGenerator";
+import { generateEsLintConfig } from "../generators/static/esLintConfigGenerator";
+import { generateRollupConfig } from "../generators/static/rollupConfigFileGenerator";
+import { generateReadmeFile } from "../generators/static/readmeFileGenerator";
+import * as path from "path";
+import * as fsextra from "fs-extra";
+import { generateSampleEnv } from "../generators/samples/sampleEnvGenerator";
+import { generateRLCSamples } from "../generators/samples/rlcSampleGenerator";
+import { generateIsUnexpectedHelper } from "./generateIsUnexpectedHelper";
+
 /**
  * Generates a Rest Level Client library
  */
 export async function generateRestLevelClient() {
   const host = getHost();
   const { model } = getSession();
+  const {
+    outputPath,
+    srcPath,
+    generateSample,
+    generateTest
+  } = getAutorestOptions();
 
   const project = new Project({
     useInMemoryFileSystem: true,
@@ -25,19 +52,50 @@ export async function generateRestLevelClient() {
     }
   });
 
+  if (hasPagingOperations(model)) {
+    generatePagingHelper(project);
+  }
+
+  if (hasPollingOperations(model)) {
+    generatePollingHelper(project);
+  }
+
   performCodeModelMutations(model);
+  generateReadmeFile(model, project);
   generatePackageJson(project);
   generateLicenseFile(project);
   generateTsConfig(project);
   generateApiExtractorConfig(project);
+  generateRollupConfig(project);
+  generateEsLintConfig(project);
+
+  generateKarmaConfigFile(project);
+  generateEnvFile(project);
+  generateEnvBrowserFile(project);
+  generateRecordedClientFile(project);
+  generateSampleTestFile(project);
+
   generateResponseInterfaces(model, project);
   generateSchemaTypes(model, project);
   generateParameterInterfaces(model, project);
   generatePathFirstClient(model, project);
+  generateClient(model, project);
+  generateIndexFile(project);
+  generateIsUnexpectedHelper(project);
+
+  generateTopLevelIndexFile(model, project);
+  if (generateSample || generateTest) {
+    generateSampleEnv(project);
+  }
+  if (generateSample) {
+    generateRLCSamples(model, project);
+  }
 
   // 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()) {
@@ -47,7 +105,7 @@ export async function generateRestLevelClient() {
     let fileContents = fs.readFileSync(filePath);
     const licenseHeader = `// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT license.\n`;
 
-    if (!isJson) {
+    if (isSourceCode) {
       fileContents = `${licenseHeader.trimLeft()}\n${fileContents}`;
     }
 
@@ -58,11 +116,10 @@ export async function generateRestLevelClient() {
         isJson ? prettierJSONOptions : prettierTypeScriptOptions
       );
     }
-
     // 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
+    });
   }
 }

package/src/restLevelClient/generateSchemaTypes.ts

@@ -1,9 +1,11 @@
-import { CodeModel } from "@autorest/codemodel";
+import { CodeModel, SchemaContext } from "@autorest/codemodel";
 import { Project } from "ts-morph";
+import * as path from 'path';
 import {
   buildObjectInterfaces,
   buildPolymorphicAliases
 } from "./generateObjectTypes";
+import { getAutorestOptions } from "../autorestSession";
 
 /**
  * Generates types to represent schema definitions in the swagger
@@ -11,12 +13,45 @@ import {
 export function generateSchemaTypes(model: CodeModel, project: Project) {
   // Track models that need to be imported
   const importedModels = new Set<string>();
-  const modelsFile = project.createSourceFile(`src/models.ts`, undefined, {
-    overwrite: true
-  });
 
-  const objectsDefinitions = buildObjectInterfaces(model, importedModels);
-  const objectTypeAliases = buildPolymorphicAliases(model);
-  modelsFile.addInterfaces(objectsDefinitions);
-  modelsFile.addTypeAliases(objectTypeAliases);
+  const objectsDefinitions = buildObjectInterfaces(model, importedModels, [
+    SchemaContext.Input
+  ]);
+  const objectTypeAliases = buildPolymorphicAliases(model, [
+    SchemaContext.Input
+  ]);
+  const { srcPath } = getAutorestOptions();
+  if (objectTypeAliases.length || objectsDefinitions.length) {
+    const inputModelsFile = project.createSourceFile(
+      path.join(srcPath, `models.ts`),
+      undefined,
+      {
+        overwrite: true
+      }
+    );
+    inputModelsFile.addInterfaces(objectsDefinitions);
+    inputModelsFile.addTypeAliases(objectTypeAliases);
+  }
+  const outputObjectsDefinitions = buildObjectInterfaces(
+    model,
+    importedModels,
+    [SchemaContext.Output, SchemaContext.Exception]
+  );
+  const outputObjectTypeAliases = buildPolymorphicAliases(model, [
+    SchemaContext.Output,
+    SchemaContext.Exception
+  ]);
+
+  if (outputObjectTypeAliases.length || outputObjectsDefinitions.length) {
+    const outputModelsFile = project.createSourceFile(
+      path.join(srcPath, `outputModels.ts`),
+      undefined,
+      {
+        overwrite: true
+      }
+    );
+
+    outputModelsFile.addInterfaces(outputObjectsDefinitions);
+    outputModelsFile.addTypeAliases(outputObjectTypeAliases);
+  }
 }

package/src/restLevelClient/generateTopLevelIndexFile.ts

@@ -0,0 +1,37 @@
+import { Project } from 'ts-morph';
+import * as path from 'path';
+import { getAutorestOptions } from '../autorestSession';
+import { CodeModel } from '@autorest/codemodel';
+import { NameType, normalizeName } from '../utils/nameUtils';
+
+const batchOutputFolder: [string, string, string][] = [];
+
+export function generateTopLevelIndexFile(model: CodeModel, project: Project) {
+    const { multiClient, batch, srcPath } = getAutorestOptions();
+    if (srcPath) {
+        const clientName = model.language.default.name;
+        const moduleName = normalizeName(clientName, NameType.File);
+        const relativePath = srcPath.replace('/src', '');
+        batchOutputFolder.push([relativePath, clientName, moduleName]);
+    }
+
+    if (multiClient && batch && batch.length > 1 && batchOutputFolder.length === batch.length) {
+        const { srcPath } = getAutorestOptions();
+        const fileDirectory= path.join(srcPath as string, '../../');
+        const file = project.createSourceFile('/src/index.ts', undefined, {
+            overwrite: true
+        });
+        file.moveToDirectory(fileDirectory);
+        const allModules: string[] = [];
+        batchOutputFolder.forEach(item => {
+            file.addImportDeclaration({
+                namespaceImport: item[1],
+                moduleSpecifier: `${item[0]}`
+            });
+            allModules.push(item[1]);
+        });
+        file.addExportDeclaration({
+            namedExports: [...allModules]
+        });
+    }
+}

package/src/restLevelClient/getPropertySignature.ts

@@ -1,7 +1,7 @@
-import { Parameter, Property } from "@autorest/codemodel";
+import { Parameter, Property, SchemaContext } from "@autorest/codemodel";
 import { PropertySignatureStructure, StructureKind } from "ts-morph";
 import { getLanguageMetadata } from "../utils/languageHelpers";
-import { getElementType } from "./schemaHelpers";
+import { getElementType, getFormatDocs } from "./schemaHelpers";
 
 /**
  * Builds a Typescript property or parameter signature
@@ -11,13 +11,21 @@ import { getElementType } from "./schemaHelpers";
  */
 export function getPropertySignature(
   property: Property | Parameter,
+  schemaUsage: SchemaContext[],
   importedModels = new Set<string>()
 ): PropertySignatureStructure {
   const propertyLangMetadata = getLanguageMetadata(property.language);
-  const propertyName = `"${propertyLangMetadata.serializedName ||
-    propertyLangMetadata.name}"`;
-  const description = propertyLangMetadata.description;
-  const type = getElementType(property.schema, importedModels);
+  const propertyName = `"${propertyLangMetadata.serializedName ??
+    (property as Property).serializedName}"`;
+
+  if (!propertyName) {
+    throw new Error(
+      `Couldn't find name for property ${JSON.stringify(propertyLangMetadata)}`
+    );
+  }
+
+  const description = getDocs(property);
+  const type = getElementType(property.schema, schemaUsage, importedModels);
   return {
     name: propertyName,
     ...(description && { docs: [{ description }] }),
@@ -26,3 +34,20 @@ export function getPropertySignature(
     kind: StructureKind.PropertySignature
   };
 }
+
+export function getDocs(property: Property | Parameter) {
+  const { description } = getLanguageMetadata(property.language);
+  const docs: string[] = [];
+
+  if (description) {
+    docs.push(description);
+  }
+
+  const formatDocs = getFormatDocs(property.schema);
+
+  if (formatDocs) {
+    docs.push(formatDocs);
+  }
+
+  return docs.join("\n\n");
+}

package/src/restLevelClient/helpers/hasPollingOperations.ts

@@ -0,0 +1,15 @@
+import { CodeModel, Operation } from "@autorest/codemodel";
+
+export function hasPollingOperations(model: CodeModel): boolean {
+  return model.operationGroups.some(og =>
+    og.operations.some(
+      o => o.extensions && o.extensions["x-ms-long-running-operation"]
+    )
+  );
+}
+
+export function isLongRunningOperation(operation: Operation): boolean {
+  return (
+    operation.extensions && operation.extensions["x-ms-long-running-operation"]
+  );
+}

package/src/restLevelClient/helpers/modelHelpers.ts

@@ -0,0 +1,15 @@
+import { CodeModel, SchemaContext } from "@autorest/codemodel";
+
+export function hasInputModels(model: CodeModel) {
+  return model.schemas.objects?.some(o =>
+    o.usage?.includes(SchemaContext.Input)
+  );
+}
+
+export function hasOutputModels(model: CodeModel) {
+  return model.schemas.objects?.some(
+    o =>
+      o.usage?.includes(SchemaContext.Output) ||
+      o.usage?.includes(SchemaContext.Exception)
+  );
+}

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,39 @@
+import { Schema } from "@autorest/codemodel";
+
+export type PathParameter = {
+  name: string;
+  schema: Schema;
+  description?: string;
+};
+
+export interface ResponseTypes {
+  success: string[];
+  error: string[];
+}
+
+export interface OperationMethod {
+  optionsName: string;
+  description: string;
+  hasOptionalOptions: boolean;
+  returnType: string;
+  successStatus: string[];
+  responseTypes: ResponseTypes;
+}
+
+export type Methods = {
+  [key: string]: [OperationMethod];
+};
+
+export interface PathMetadata {
+  name: string;
+  pathParameters: PathParameter[];
+  methods: Methods;
+  annotations?: OperationAnnotations;
+}
+
+export type Paths = Record<string, PathMetadata>;
+
+export interface OperationAnnotations {
+  isLongRunning?: boolean;
+  isPageable?: boolean;
+}

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 {
@@ -45,12 +51,20 @@ export function getStatusCode(response: Response): string {
   // in M4, in reality it can only contain a single status code, hence we are always picking the first one.
   let statusCode = response.protocol.http?.statusCodes[0];
 
-  // Swagger can define a catch all status code "default" to get any other status code not explicitly defined
-  // however default is not a valid HTTP status code. We are setting 500 as a catch all status code instead
-  // which is a valid http status
-  // if (statusCode === "default") {
-  //   return `"500"`;
-  // }
-
   return `"${statusCode}"`;
 }
+
+/**
+ * Extracts all success status codes for a give operation
+ */
+export function gerOperationSuccessStatus(operation: Operation): string[] {
+  const responses = operation.responses ?? [];
+  const status: string[] = [];
+
+  for (const response of responses) {
+    let statusCode = response.protocol.http?.statusCodes[0];
+    status.push(statusCode);
+  }
+
+  return status;
+}