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

package/src/restLevelClient/generateParameterTypes.ts

@@ -3,20 +3,24 @@ import {
   Operation,
   Parameter,
   SchemaContext,
-  Request as OperationRequest
+  Request as OperationRequest,
+  ParameterLocation
 } from "@autorest/codemodel";
 import {
   InterfaceDeclarationStructure,
   Project,
+  PropertySignatureStructure,
   SourceFile,
   StructureKind
 } from "ts-morph";
+import * as path from 'path';
 import { getLanguageMetadata } from "../utils/languageHelpers";
 import { NameType, normalizeName } from "../utils/nameUtils";
-import { getDocs, getPropertySignature } from "./getPropertySignature";
+import { getPropertySignature } from "./getPropertySignature";
 import { primitiveSchemaToType } from "./schemaHelpers";
-import { getOperationParameters } from "./helpers/getOperationParameters";
+import { getOperationParameters } from "./helpers/operationHelpers";
 import { hasInputModels } from "./helpers/modelHelpers";
+import { getAutorestOptions } from "../autorestSession";
 
 /**
  * Generates the interfaces describing each operation parameters
@@ -25,8 +29,9 @@ export function generateParameterInterfaces(
   model: CodeModel,
   project: Project
 ) {
+  const { srcPath } = getAutorestOptions();
   const parametersFile = project.createSourceFile(
-    `src/parameters.ts`,
+    path.join(srcPath, `parameters.ts`),
     undefined,
     {
       overwrite: true
@@ -73,6 +78,15 @@ export function generateParameterInterfaces(
 
       const request = operation.requests ? operation.requests[i] : undefined;
 
+      const pathParameterDefinitions = buildPathParameterDefinitions(
+        operationName,
+        parameters,
+        model,
+        parametersFile,
+        internalReferences,
+        i
+      )
+
       const headerParameterDefinitions = buildHeaderParameterDefinitions(
         operationName,
         parameters,
@@ -99,8 +113,9 @@ export function generateParameterInterfaces(
 
       // Add interfaces for body and query parameters
       parametersFile.addInterfaces([
-        ...(bodyParameterDefinition ? [bodyParameterDefinition] : []),
+        ...(bodyParameterDefinition ?? []),
         ...(queryParameterDefinitions ?? []),
+        ...(pathParameterDefinitions ? [pathParameterDefinitions]: []),
         ...(headerParameterDefinitions ? [headerParameterDefinitions] : []),
         ...(contentTypeParameterDefinition
           ? [contentTypeParameterDefinition]
@@ -232,6 +247,81 @@ function buildHeaderParameterDefinitions(
   };
 }
 
+function getPathInterfaceDefinition(
+  parameters: Parameter[],
+  baseName: string,
+  model: CodeModel
+): undefined | InterfaceDeclarationStructure {
+  // Check if there are any path parameters
+  const pathParameters = parameters.filter(
+    p => p.protocol.http?.in === ParameterLocation.Uri && model.globalParameters?.indexOf(p) === -1
+  );
+  if (!pathParameters.length) {
+    return undefined;
+  }
+  const pathInterfaceName = `${baseName}PathParameters`;
+  return {
+    kind: StructureKind.Interface,
+    isExported: true,
+    name: pathInterfaceName,
+    properties: pathParameters.map((h: Parameter) => {
+      const description = getLanguageMetadata(h.language).description;
+      return {
+        name: `"${getLanguageMetadata(h.language).serializedName}"`,
+        ...(description && { docs: [{ description }] }),
+        type: primitiveSchemaToType(h.schema, [
+          SchemaContext.Input,
+          SchemaContext.Exception
+        ]),
+        hasQuestionToken: !h.required
+      };
+    })
+  };
+}
+
+function buildPathParameterDefinitions(
+  operationName: string,
+  parameters: Parameter[],
+  model: CodeModel,
+  parametersFile: SourceFile,
+  internalReferences: Set<string>,
+  requestIndex: number
+): InterfaceDeclarationStructure | undefined {
+  const pathParameters = parameters.filter(
+    p => p.protocol.http?.in === ParameterLocation.Uri && model.globalParameters?.indexOf(p) === -1
+  );
+  if (!pathParameters.length) {
+    return undefined;
+  }
+
+  const nameSuffix = requestIndex > 0 ? `${requestIndex}` : "";
+  const pathParameterInterfaceName = `${operationName}PathParam${nameSuffix}`;
+
+  const pathInterface = getPathInterfaceDefinition(
+    pathParameters,
+    operationName,
+    model
+  );
+
+  if (pathInterface) {
+    parametersFile.addInterface(pathInterface);
+  }
+
+  internalReferences.add(pathParameterInterfaceName);
+
+  return {
+    isExported: true,
+    kind: StructureKind.Interface,
+    name: pathParameterInterfaceName,
+    properties: [
+      {
+        name: "pathParameters",
+        type: `${operationName}PathParameters`,
+        kind: StructureKind.PropertySignature
+      }
+    ]
+  };  
+}
 /**
  * Gets the interface definition for an operation bodyParameters
  */
@@ -242,36 +332,76 @@ function buildBodyParametersDefinition(
   importedModels: Set<string>,
   internalReferences: Set<string>,
   requestIndex: number
-): InterfaceDeclarationStructure | undefined {
+): InterfaceDeclarationStructure[] {
   const bodyParameters = parameters.filter(p => p.protocol.http?.in === "body");
   if (!bodyParameters.length) {
-    return undefined;
+    return [];
   }
 
   const nameSuffix = requestIndex > 0 ? `${requestIndex}` : "";
   const bodyParameterInterfaceName = `${operationName}BodyParam${nameSuffix}`;
-  // There is only one body parameter can't be more than one so we can safely take the first
-  const bodySignature = getPropertySignature(
-    bodyParameters[0],
-    schemaUsage,
-    importedModels
-  );
-
   internalReferences.add(bodyParameterInterfaceName);
 
-  return {
-    isExported: true,
-    kind: StructureKind.Interface,
-    name: bodyParameterInterfaceName,
-    properties: [
+  // In case of formData we'd get multiple properties in body marked as partialBody
+  if (bodyParameters.some(p => p.isPartialBody)) {
+    let allOptionalParts = true;
+    const propertiesDefinitions: PropertySignatureStructure[] = [];
+    for (const param of bodyParameters) {
+      if (param.required) {
+        allOptionalParts = false;
+      }
+
+      propertiesDefinitions.push(
+        getPropertySignature(param, schemaUsage, importedModels)
+      );
+    }
+
+    const formBodyName = `${operationName}FormBody`;
+    const formBodyInterface: InterfaceDeclarationStructure = {
+      isExported: true,
+      kind: StructureKind.Interface,
+      name: formBodyName,
+      properties: propertiesDefinitions
+    };
+
+    return [
+      {
+        isExported: true,
+        kind: StructureKind.Interface,
+        name: bodyParameterInterfaceName,
+        properties: [
+          {
+            name: "body",
+            type: formBodyName,
+            hasQuestionToken: allOptionalParts
+          }
+        ]
+      },
+      formBodyInterface
+    ];
+  } else {
+    const bodySignature = getPropertySignature(
+      bodyParameters[0],
+      schemaUsage,
+      importedModels
+    );
+
+    return [
       {
-        docs: bodySignature.docs,
-        name: "body",
-        type: bodySignature.type,
-        hasQuestionToken: bodySignature.hasQuestionToken
+        isExported: true,
+        kind: StructureKind.Interface,
+        name: bodyParameterInterfaceName,
+        properties: [
+          {
+            docs: bodySignature.docs,
+            name: "body",
+            type: bodySignature.type,
+            hasQuestionToken: bodySignature.hasQuestionToken
+          }
+        ]
       }
-    ]
-  };
+    ];
+  }
 }
 
 /**

package/src/restLevelClient/generatePollingHelper.ts

@@ -1,9 +1,8 @@
 import { readFileSync } from "fs";
-import { getSession } from "../autorestSession";
-import { extractPaginationDetails } from "../utils/extractPaginationDetails";
 import * as path from "path";
 import * as hbs from "handlebars";
 import { Project } from "ts-morph";
+import { getAutorestOptions } from "../autorestSession";
 
 export function generatePollingHelper(project: Project) {
   let file: string = "";
@@ -13,7 +12,8 @@ export function generatePollingHelper(project: Project) {
   });
 
   const readmeFileContents = hbs.compile(file, { noEscape: true });
-  project.createSourceFile("src/pollingHelper.ts", readmeFileContents({}), {
+  const { srcPath } = getAutorestOptions();
+  project.createSourceFile(path.join(srcPath, "pollingHelper.ts"), readmeFileContents({}), {
     overwrite: true
   });
 }

package/src/restLevelClient/generateResponseTypes.ts

@@ -22,10 +22,13 @@ import { NameType, normalizeName } from "../utils/nameUtils";
 import { getElementType, getFormatDocs, primitiveSchemaToType } from "./schemaHelpers";
 import { getLanguageMetadata } from "../utils/languageHelpers";
 import { hasOutputModels } from "./helpers/modelHelpers";
+import { getAutorestOptions } from "../autorestSession";
+import * as path from 'path';
 
 export function generateResponseInterfaces(model: CodeModel, project: Project) {
+  const { srcPath } = getAutorestOptions();
   const responsesFile = project.createSourceFile(
-    `src/responses.ts`,
+    path.join(srcPath, `responses.ts`),
     undefined,
     {
       overwrite: true

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,18 +10,32 @@ 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";
+
 /**
  * Generates a Rest Level Client library
  */
 export async function generateRestLevelClient() {
   const host = getHost();
   const { model } = getSession();
+  const { outputPath, srcPath } = getAutorestOptions();
 
   const project = new Project({
     useInMemoryFileSystem: true,
@@ -39,19 +53,34 @@ export async function generateRestLevelClient() {
   }
 
   performCodeModelMutations(model);
+  generateReadmeFile(model.language, model.info, 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);
 
+  generateTopLevelIndexFile(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()) {
@@ -61,7 +90,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}`;
     }
 
@@ -72,11 +101,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, 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
@@ -18,10 +20,10 @@ export function generateSchemaTypes(model: CodeModel, project: Project) {
   const objectTypeAliases = buildPolymorphicAliases(model, [
     SchemaContext.Input
   ]);
-
+  const { srcPath } = getAutorestOptions();
   if (objectTypeAliases.length || objectsDefinitions.length) {
     const inputModelsFile = project.createSourceFile(
-      `src/models.ts`,
+      path.join(srcPath, `models.ts`),
       undefined,
       {
         overwrite: true
@@ -42,7 +44,7 @@ export function generateSchemaTypes(model: CodeModel, project: Project) {
 
   if (outputObjectTypeAliases.length || outputObjectsDefinitions.length) {
     const outputModelsFile = project.createSourceFile(
-      `src/outputModels.ts`,
+      path.join(srcPath, `outputModels.ts`),
       undefined,
       {
         overwrite: true

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/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,9 +1,9 @@
 import {
   AnyObjectSchema,
   ArraySchema,
-  ByteArraySchema,
   ChoiceSchema,
   ConstantSchema,
+  DateTimeSchema,
   DictionarySchema,
   isObjectSchema,
   ObjectSchema,
@@ -115,7 +115,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 +122,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:
@@ -132,7 +135,11 @@ export function primitiveSchemaToType(
         .join(" | ");
     case SchemaType.Constant:
       const value = (schema as ConstantSchema).value.value;
-      return typeof value === "string" ? `"${value}"` : value;
+      return typeof value === "string"
+        ? (schema as ConstantSchema)?.valueType?.type === SchemaType.DateTime
+          ? `"${(new Date(`${value}`)).toISOString()}"`
+          : `"${value}"`
+        : value;
   }
 
   throw new Error(`Unknown primitive schema ${schema.type}`);

package/src/transforms/mapperTransforms.ts

@@ -693,7 +693,7 @@ function processProperties(
     const propName = getLanguageMetadata(prop.language).name;
     const name = normalizeName(
       propName,
-      NameType.Property,
+      prop.language.default.isTopLevelParameter? NameType.Parameter: NameType.Property,
       true /** shouldGuard */
     );
     modelProperties[name] = getMapperOrRef(prop.schema, serializedName, {

package/src/transforms/objectTransforms.ts

@@ -92,7 +92,7 @@ export function transformProperty({
   return {
     name: normalizeName(
       metadata.name,
-      NameType.Property,
+      metadata.isTopLevelParameter? NameType.Parameter: NameType.Property,
       true /** shouldGuard */
     ),
     description,

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