@autorest/typescript 6.0.0-beta.9 → 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,14 +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,
@@ -26,20 +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()) {
@@ -49,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}`;
     }
 
@@ -60,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,4 +1,4 @@
-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, getFormatDocs } from "./schemaHelpers";
@@ -11,13 +11,21 @@ import { getElementType, getFormatDocs } 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 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, importedModels);
+  const type = getElementType(property.schema, schemaUsage, importedModels);
   return {
     name: propertyName,
     ...(description && { docs: [{ description }] }),

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

package/src/restLevelClient/paginateHelper.ts.hbs

@@ -0,0 +1,208 @@
+import {
+  getPagedAsyncIterator,
+  PagedAsyncIterableIterator,
+  PagedResult
+} from "@azure/core-paging";
+import {
+  Client,
+  createRestError,
+  PathUncheckedResponse
+} from "@azure-rest/core-client";
+
+/**
+ * Helper type to extract the type of an array
+ */
+export type GetArrayType<T> = T extends Array<infer TData> ? TData : never;
+
+/**
+ * The type of a custom function that defines how to get a page and a link to the next one if any.
+ */
+export type GetPage<TPage> = (
+  pageLink: string,
+  maxPageSize?: number
+) => Promise<{
+  page: TPage;
+  nextPageLink?: string;
+}>;
+
+/**
+ * Options for the paging helper
+ */
+export interface PagingOptions<TResponse> {
+  /**
+   * Custom function to extract pagination details for crating the PagedAsyncIterableIterator
+  */
+  customGetPage?: GetPage<PaginateReturn<TResponse>[]>
+}
+
+/**
+ * Helper type to infer the Type of the paged elements from the response type
+ * This type is generated based on the swagger information for x-ms-pageable
+ * specifically on the itemName property which indicates the property of the response
+ * where the page items are found. The default value is `value`.
+ * This type will allow us to provide strongly typed Iterator based on the response we get as second parameter
+ */
+export type PaginateReturn<TResult> = TResult extends  {{#each itemNames}}
+  {
+ 
+  body: { {{this}}?: infer TPage } 
+  
+} {{#if @last }}{{else}} | {{/if}}
+{{/each}}
+  ? GetArrayType<TPage>
+  : Array<unknown>;
+
+/**
+ * Helper to paginate results from an initial response that follows the specification of Autorest `x-ms-pageable` extension
+ * @param client - Client to use for sending the next page requests
+ * @param initialResponse - Initial response containing the nextLink and current page of elements
+ * @param customGetPage - Optional - Function to define how to extract the page and next link to be used to paginate the results
+ * @returns - PagedAsyncIterableIterator to iterate the elements
+ */
+export function paginate<TResponse extends PathUncheckedResponse>(
+  client: Client,
+  initialResponse: TResponse,
+  options: PagingOptions<TResponse> = {}
+): PagedAsyncIterableIterator<PaginateReturn<TResponse>> {
+  // Extract element type from initial response
+  type TElement = PaginateReturn<TResponse>;
+  let firstRun = true;
+  {{#if isComplexPaging}}
+  // We need to check the response for success before trying to inspect it looking for
+  // the properties to use for nextLink and itemName
+  checkPagingRequest(initialResponse);
+  const { itemName, nextLinkName } = getPaginationProperties(initialResponse);
+  {{else}}
+  const itemName = {{ quoteWrap itemNames }};
+  const nextLinkName = {{quoteWrap nextLinkNames}};
+  {{/if}}
+  const { customGetPage } = options;
+  const pagedResult: PagedResult<TElement[]> = {
+    firstPageLink: "",
+    getPage:
+      typeof customGetPage === "function"
+        ? customGetPage
+        : async (pageLink: string) => {
+            const result = firstRun
+              ? initialResponse
+              : await client.pathUnchecked(pageLink).get();
+            firstRun = false;
+            checkPagingRequest(result);
+            const nextLink = getNextLink(result.body, nextLinkName);
+            const values = getElements<TElement>(result.body, itemName);
+            return {
+              page: values,
+              nextPageLink: nextLink
+            };
+          }
+  };
+
+  return getPagedAsyncIterator(pagedResult);
+}
+
+/**
+ * Gets for the value of nextLink in the body
+ */
+function getNextLink(body: unknown, nextLinkName?: string): string | undefined {
+   if (!nextLinkName) {
+    return undefined;
+  }
+
+  const nextLink = (body as Record<string, unknown>)[nextLinkName];
+
+  if (typeof nextLink !== "string" && typeof nextLink !== "undefined") {
+    throw new Error(
+      `Body Property ${nextLinkName} should be a string or undefined`
+    );
+  }
+
+  return nextLink;
+}
+
+/**
+ * Gets the elements of the current request in the body.
+ */
+function getElements<T = unknown>(body: unknown, itemName: string): T[] {
+  const value = (body as Record<string, unknown>)[itemName] as T[];
+
+  // value has to be an array according to the x-ms-pageable extension.
+  // The fact that this must be an array is used above to calculate the
+  // type of elements in the page in PaginateReturn
+  if (!Array.isArray(value)) {
+    throw new Error(
+      `Couldn't paginate response\n Body doesn't contain an array property with name: ${itemName}`
+    );
+  }
+
+  return value ?? [];
+}
+
+/**
+ * Checks if a request failed
+ */
+function checkPagingRequest(response: PathUncheckedResponse): void {
+  const Http2xxStatusCodes = [
+    "200",
+    "201",
+    "202",
+    "203",
+    "204",
+    "205",
+    "206",
+    "207",
+    "208",
+    "226"
+  ];
+  if (!Http2xxStatusCodes.includes(response.status)) {
+    throw createRestError(
+      `Pagination failed with unexpected statusCode ${response.status}`,
+      response
+    );
+  }
+}
+
+{{#if isComplexPaging}}
+/**
+ * Extracts the itemName and nextLinkName from the initial response to use them for pagination
+ */
+function getPaginationProperties(initialResponse: PathUncheckedResponse) {
+  // Build a set with the passed custom nextLinkNames
+  const nextLinkNames = new Set([{{ quoteWrap nextLinkNames }}]);
+
+  // Build a set with the passed custom set of itemNames
+  const itemNames = new Set([{{ quoteWrap itemNames }}]);
+
+  let nextLinkName: string | undefined;
+  let itemName: string | undefined;
+
+  for (const name of nextLinkNames) {
+    const nextLink = (initialResponse.body as Record<string, unknown>)[
+      name
+    ] as string;
+    if (nextLink) {
+      nextLinkName = name;
+      break;
+    }
+  }
+
+  for (const name of itemNames) {
+    const item = (initialResponse.body as Record<string, unknown>)[
+      name
+    ] as string;
+    if (item) {
+      itemName = name;
+      break;
+    }
+  }
+
+  if (!itemName) {
+    throw new Error(
+      `Couldn't paginate response\n Body doesn't contain an array property with name: ${[
+        ...itemNames
+      ].join(" OR ")}`
+    );
+  }
+
+  return { itemName, nextLinkName };
+}
+{{/if}}