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

package/src/generators/indexGenerator.ts

@@ -2,12 +2,17 @@ import { Project, SourceFile } from "ts-morph";
 import { ClientDetails } from "../models/clientDetails";
 import { getAutorestOptions, getSession } from "../autorestSession";
 import { NameType, normalizeName } from "../utils/nameUtils";
-
+import { hasPagingOperations } from "../utils/extractPaginationDetails";
+import { hasPollingOperations } from "../restLevelClient/helpers/hasPollingOperations";
+import {
+  hasInputModels,
+  hasOutputModels
+} from "../restLevelClient/helpers/modelHelpers";
 export function generateIndexFile(
   project: Project,
   clientDetails?: ClientDetails
 ) {
-  const { restLevelClient, srcPath } = getAutorestOptions();
+  const { restLevelClient, srcPath, multiClient, batch } = getAutorestOptions();
   const indexFile = project.createSourceFile(`${srcPath}/index.ts`, undefined, {
     overwrite: true
   });
@@ -19,38 +24,143 @@ export function generateIndexFile(
       );
     }
     generateHLCIndex(clientDetails, indexFile);
-  } else {
+  } else if (!multiClient || !batch || batch?.length === 1) {
+    // if we are generate single client package for RLC
     generateRLCIndex(indexFile);
+  } else {
+    generateRLCIndexForMultiClient(indexFile);
   }
 }
 
+// to generate a index.ts for each single module inside the multi client RLC package
+function generateRLCIndexForMultiClient(file: SourceFile) {
+  const { model } = getSession();
+  const clientName = model.language.default.name;
+  const createClientFuncName = `createClient`;
+  const moduleName = normalizeName(clientName, NameType.File);
+
+  file.addImportDeclaration({
+    namespaceImport: "Parameters",
+    moduleSpecifier: "./parameters"
+  });
+
+  file.addImportDeclaration({
+    namespaceImport: "Responses",
+    moduleSpecifier: "./responses"
+  });
+
+  file.addImportDeclaration({
+    namespaceImport: "Client",
+    moduleSpecifier: "./clientDefinitions"
+  });
+
+  const exports = ["Parameters", "Responses", "Client"];
+  if (hasInputModels(model)) {
+    file.addImportDeclaration({
+      namespaceImport: "Models",
+      moduleSpecifier: "./models"
+    });
+    exports.push("Models");
+  }
+
+  if (hasOutputModels(model)) {
+    file.addImportDeclaration({
+      namespaceImport: "OutputModels",
+      moduleSpecifier: "./outputModels"
+    });
+    exports.push("OutputModels");
+  }
+
+  if (hasPagingOperations(model)) {
+    file.addImportDeclaration({
+      namespaceImport: "PaginateHelper",
+      moduleSpecifier: "./paginateHelper"
+    });
+    exports.push("PaginateHelper");
+  }
+
+  if (hasPollingOperations(model)) {
+    file.addImportDeclaration({
+      namespaceImport: "PollingHelper",
+      moduleSpecifier: "./pollingHelper"
+    });
+    exports.push("PollingHelper");
+  }
+
+  file.addExportDeclarations([
+    {
+      moduleSpecifier: `./${moduleName}`,
+      namedExports: [`${createClientFuncName}`]
+    },
+    {
+      namedExports: [...exports]
+    }
+  ]);
+}
+
 function generateRLCIndex(file: SourceFile) {
   const { model } = getSession();
   const clientName = model.language.default.name;
+  const createClientFuncName = `${clientName}`;
   const moduleName = normalizeName(clientName, NameType.File);
 
   file.addImportDeclaration({
     moduleSpecifier: `./${moduleName}`,
-    defaultImport: clientName
+    defaultImport: createClientFuncName
   });
 
   file.addExportDeclarations([
     {
       moduleSpecifier: `./${moduleName}`
     },
-    {
-      moduleSpecifier: "./models"
-    },
     {
       moduleSpecifier: "./parameters"
     },
     {
       moduleSpecifier: "./responses"
+    },
+    {
+      moduleSpecifier: "./clientDefinitions"
+    },
+    {
+      moduleSpecifier: "./isUnexpected"
     }
   ]);
 
+  if (hasInputModels(model)) {
+    file.addExportDeclarations([
+      {
+        moduleSpecifier: "./models"
+      }
+    ]);
+  }
+
+  if (hasOutputModels(model)) {
+    file.addExportDeclarations([
+      {
+        moduleSpecifier: "./outputModels"
+      }
+    ]);
+  }
+
+  if (hasPagingOperations(model)) {
+    file.addExportDeclarations([
+      {
+        moduleSpecifier: "./paginateHelper"
+      }
+    ]);
+  }
+
+  if (hasPollingOperations(model)) {
+    file.addExportDeclarations([
+      {
+        moduleSpecifier: "./pollingHelper"
+      }
+    ]);
+  }
+
   file.addExportAssignment({
-    expression: clientName,
+    expression: createClientFuncName,
     isExportEquals: false
   });
 }
@@ -68,10 +178,6 @@ function generateHLCIndex(clientDetails: ClientDetails, file: SourceFile) {
     {
       moduleSpecifier: `./${clientDetails.sourceFileName}`,
       namedExports: [clientDetails.className]
-    },
-    {
-      moduleSpecifier: `./${clientDetails.sourceFileName}Context`,
-      namedExports: [`${clientDetails.className}Context`]
     }
   ]);
 

package/src/generators/mappersGenerator.ts

@@ -19,7 +19,7 @@ import {
   MapperConstraints
 } from "@azure/core-http";
 import { ModelProperties } from "../transforms/mapperTransforms";
-import { keys, isEmpty, isString, isNil, isEqual } from "lodash";
+import { keys, isEmpty, isString, isNil, isEqual, List } from "lodash";
 import { getStringForValue, MapperTypes } from "../utils/valueHelpers";
 import { PolymorphicObjectDetails, ObjectKind } from "../models/modelDetails";
 import { logger } from "../utils/logger";
@@ -57,14 +57,89 @@ export function generateMappers(
   mappersFile.fixUnusedIdentifiers();
 }
 
+function getParents(
+  mapperParentMap: Map<string, Array<string>>,
+  parent: string
+) {
+  const list: Array<string> = new Array<string>();
+  const parents = mapperParentMap.get(parent);
+
+  if (!parents) {
+    parents!.forEach(pnt => {
+      if (!list.includes(pnt)) {
+        getParents(mapperParentMap, pnt).forEach(str => list.push(str));
+      }
+    });
+  }
+
+  if (!list.includes(parent)) {
+    list.push(parent);
+  }
+
+  return list;
+}
+
+function traverse(mapperParentMap: Map<string, Array<string>>) {
+  const list: Array<string> = new Array<string>();
+  mapperParentMap.forEach((value: string[], key: string) => {
+    value.forEach(parent => {
+      if (!list.includes(parent)) {
+        getParents(mapperParentMap, parent).forEach(str => list.push(str));
+      }
+    });
+    if (!list.includes(key)) {
+      list.push(key);
+    }
+  });
+  return list;
+}
+
 /**
  * This function writes to the mappers.ts file all the mappers to be used by @azure/core-http for serialization
  */
 function writeMappers(sourceFile: SourceFile, { mappers }: ClientDetails) {
+  const mapperParentMap: Map<string, Array<string>> = new Map<
+    string,
+    Array<string>
+  >();
+  const mapperPositionMap: Map<string, number> = new Map<string, number>();
+  let position = 0;
+  mappers.forEach(mapper => {
+    const compositeMapper = mapper as CompositeMapper;
+    const mapperClassName = compositeMapper.type.className;
+    if (!mapperClassName) return;
+    mapperPositionMap.set(mapperClassName, position);
+    position += 1;
+    let listOfParents = mapperParentMap.get(mapperClassName);
+    if (!listOfParents) {
+      listOfParents = new Array<string>();
+    }
+
+    if (
+      compositeMapper.type.modelProperties &&
+      compositeMapper.type.modelProperties.parentsRefs
+    ) {
+      const { parentsRefs } = (compositeMapper.type.modelProperties ||
+        {}) as ModelProperties;
+
+      if (parentsRefs) {
+        (parentsRefs as string[]).forEach(parentsRef => {
+          listOfParents!.push(parentsRef);
+        });
+      }
+    }
+
+    mapperParentMap.set(mapperClassName, listOfParents);
+  });
+
+  const modifiedList = traverse(mapperParentMap);
   const { useCoreV2 } = getAutorestOptions();
   const generatedMappers: Map<string, Mapper> = new Map<string, Mapper>();
 
-  mappers.forEach(mapper => {
+  modifiedList.forEach(name => {
+    const arrayIndex = mapperPositionMap.get(name) || 0;
+    const mapper = mappers[arrayIndex];
+
     const mapperClassName = (mapper as CompositeMapper).type.className;
     if (!mapperClassName) {
       logger.warning(`Expected a mapper with a className, skipping generation`);
@@ -103,6 +178,19 @@ function writeMappers(sourceFile: SourceFile, { mappers }: ClientDetails) {
       leadingTrivia: writer => writer.blankLine()
     });
 
+    const { polymorphicDiscriminator } = mapper.type as CompositeMapperType;
+
+    if (polymorphicDiscriminator) {
+      if (
+        isString(polymorphicDiscriminator) &&
+        `${polymorphicDiscriminator}`.startsWith(mapper.serializedName!)
+      ) {
+        sourceFile.addStatements(
+          `${polymorphicDiscriminator}=${polymorphicDiscriminator};`
+        );
+      }
+    }
+
     // Keep track of the mapper we just generated
     generatedMappers.set(mapperClassName, mapper);
   });
@@ -178,7 +266,7 @@ export function writeMapper(writer: CodeBlockWriter, mapper: Mapper) {
       .write("type:")
       .block(() => {
         // Write tipe properties for the current mapper
-        writeMapperType(writer, mapper.type, parents);
+        writeMapperType(writer, mapper, parents);
       });
   });
 }
@@ -189,14 +277,16 @@ export function writeMapper(writer: CodeBlockWriter, mapper: Mapper) {
  */
 function writeMapperType(
   writer: CodeBlockWriter,
-  mapperType: MapperType,
+  mapper: Mapper,
   parents: string[]
 ) {
+  const mapperType = mapper.type;
+
   if (isSequenceMapperType(mapperType)) {
     return writeSequenceMapperType(writer, mapperType);
   }
 
-  return writeCompositeMapperType(writer, mapperType, parents);
+  return writeCompositeMapperType(writer, mapper, parents);
 }
 
 /**
@@ -213,9 +303,10 @@ function isSequenceMapperType(
  */
 function writeCompositeMapperType(
   writer: CodeBlockWriter,
-  mapperType: MapperType,
+  mapper: Mapper,
   parents: string[]
 ) {
+  const mapperType = mapper.type;
   const {
     modelProperties,
     polymorphicDiscriminator,
@@ -223,7 +314,14 @@ function writeCompositeMapperType(
   } = mapperType as CompositeMapperType;
   writeObjectProps(restType, writer);
   // Write type properties that need special handling
-  writePolymorphicDiscriminator(writer, polymorphicDiscriminator);
+  if (polymorphicDiscriminator) {
+    if (
+      !isString(polymorphicDiscriminator) ||
+      !`${polymorphicDiscriminator}`.startsWith(mapper.serializedName!)
+    ) {
+      writePolymorphicDiscriminator(writer, polymorphicDiscriminator);
+    }
+  }
   writeModelProperties(writer, parents, modelProperties);
 }
 
@@ -258,7 +356,9 @@ function writeMapperContraints(
     .block(() => {
       if (Pattern) {
         writer.write(
-          `Pattern: new RegExp("${Pattern.source.replace(/\\/g, "\\\\")}"), `
+          `Pattern: new RegExp("${Pattern.source
+            .replace(/\\/g, "\\\\")
+            .replace(/"/g, '\\"')}"), `
         );
       }
 

package/src/generators/modelsGenerator.ts

@@ -27,7 +27,6 @@ import { filterOperationParameters } from "./utils/parameterUtils";
 import {
   OperationDetails,
   OperationResponseDetails,
-  OperationGroupDetails
 } from "../models/operationDetails";
 import { ParameterDetails } from "../models/parameterDetails";
 import {
@@ -69,6 +68,10 @@ export function generateModels(clientDetails: ClientDetails, project: Project) {
       namespaceImport: "coreRestPipeline",
       moduleSpecifier: "@azure/core-rest-pipeline"
     });
+    modelsIndexFile.addImportDeclaration({
+      namespaceImport: "coreHttpCompat",
+      moduleSpecifier: "@azure/core-http-compat"
+    });
   }
 
   writeUniontypes(clientDetails, modelsIndexFile);
@@ -77,13 +80,21 @@ export function generateModels(clientDetails: ClientDetails, project: Project) {
   writeOperationModels(clientDetails, modelsIndexFile);
   writeClientModels(clientDetails, modelsIndexFile);
   modelsIndexFile.fixUnusedIdentifiers();
+  const allTypes = modelsIndexFile.getTypeAliases();
+  clientDetails.allTypes = allTypes
+    .filter(item => {
+      return item.isExported();
+    })
+    .map(item => {
+      return item.getName();
+    });
 }
 
 const writeClientModels = (
   clientDetails: ClientDetails,
   modelsIndexFile: SourceFile
 ) => {
-  const { useCoreV2 } = getAutorestOptions();
+  const { useCoreV2, coreHttpCompatMode } = getAutorestOptions();
   let clientOptionalParams = clientDetails.parameters.filter(
     p =>
       (!p.required || p.defaultValue) &&
@@ -97,7 +108,9 @@ const writeClientModels = (
     {
       baseClass: !useCoreV2
         ? "coreHttp.ServiceClientOptions"
-        : "coreClient.ServiceClientOptions"
+        : coreHttpCompatMode
+          ? "coreHttpCompat.ExtendedServiceClientOptions"
+          : "coreClient.ServiceClientOptions"
     }
   );
 };
@@ -391,11 +404,11 @@ function buildResponseType(
           docs: ["The underlying HTTP response."],
           type: innerResponseProperties.length
             ? Writers.intersectionType(
-                "coreHttp.HttpResponse",
-                Writers.objectType({
-                  properties: innerResponseProperties
-                })
-              )
+              "coreHttp.HttpResponse",
+              Writers.objectType({
+                properties: innerResponseProperties
+              })
+            )
             : "coreHttp.HttpResponse",
           leadingTrivia: writer => writer.blankLine()
         }
@@ -435,13 +448,13 @@ function buildResponseType(
   if (!useCoreV2) {
     return intersectionTypes.length > 1
       ? // Using apply instead of calling the method directly to be able to conditionally pass
-        // parameters, this way we don't have to have a nested if/else tree to decide which parameters
-        // to pass, we will pass any intersectionTypes availabe plus the innerType. When there are no intersection types
-        // we just return innerType
-        Writers.intersectionType.apply(
-          Writers,
-          intersectionTypes as IntersectionTypeParameters
-        )
+      // parameters, this way we don't have to have a nested if/else tree to decide which parameters
+      // to pass, we will pass any intersectionTypes availabe plus the innerType. When there are no intersection types
+      // we just return innerType
+      Writers.intersectionType.apply(
+        Writers,
+        intersectionTypes as IntersectionTypeParameters
+      )
       : (innerTypeWriter as WriterFunction);
   } else {
     if (intersectionTypes.length > 1) {
@@ -491,7 +504,7 @@ const writeExtensibleChoice = (
       members: choice.properties.map(p => ({
         name: p.name,
         value: p.value,
-        docs: p.description ? [p.description] : undefined
+        docs: [p.description ? p.description : p.name]
       }))
     });
   }
@@ -559,29 +572,14 @@ const writeObjects = (
 const writeObjectSignature = (modelsIndexFile: SourceFile) => (
   model: ObjectDetails
 ) => {
-  const properties = getPropertiesSignatures(model);
-  const parents = model.parents.map(p => p.name).join(" & ");
-
-  if (parents) {
-    modelsIndexFile.addTypeAlias({
-      name: model.name,
-      docs: model.description ? [model.description] : [],
-      isExported: true,
-      type: Writers.intersectionType(
-        parents,
-        Writers.objectType({ properties })
-      ),
-      leadingTrivia: writer => writer.blankLine()
-    });
-  } else {
-    modelsIndexFile.addInterface({
-      name: model.name,
-      docs: model.description ? [model.description] : [],
-      isExported: true,
-      properties,
-      leadingTrivia: writer => writer.blankLine()
-    });
-  }
+  modelsIndexFile.addInterface({
+    name: model.name,
+    docs: model.description ? [model.description] : [],
+    isExported: true,
+    extends: model.parents.map(p => p.name),
+    properties: getPropertiesSignatures(model),
+    leadingTrivia: writer => writer.blankLine()
+  });
 };
 
 /**
@@ -602,7 +600,6 @@ function writeUniontypes({ objects }: ClientDetails, modelsFile: SourceFile) {
             : c.name;
         })
       ];
-
       modelsFile.addTypeAlias({
         name: `${obj.name}Union`,
         isExported: true,
@@ -612,20 +609,6 @@ function writeUniontypes({ objects }: ClientDetails, modelsFile: SourceFile) {
     });
 }
 
-/**
- * Checks if a polymorphic parent needs to be included in the Union type to represent its polymorphism
- * A parent needs to be in the union only if its name is in the list of allowed discriminator values
- * otherwise the parent should be excluded.
- * @param parent Plymorphic parent to check
- */
-function isPolymorphicParentInUnion(parent: PolymorphicObjectDetails): boolean {
-  return Object.keys(parent.discriminatorValues).some(property =>
-    parent.discriminatorValues[property].some(
-      discriminatorValue => discriminatorValue === parent.name
-    )
-  );
-}
-
 interface WriteOptionalParametersOptions {
   baseClass?: string;
   mediaTypes?: Set<KnownMediaType>;
@@ -689,7 +672,7 @@ function writeOptionalParameters(
   function buildParamDetails(p: ParameterDetails): PropertySignatureStructure {
     const description = getParameterDescription(p, operationFullName);
     return {
-      name: p.name,
+      name: normalizeName(p.name, NameType.Parameter, true),
       hasQuestionToken: true,
       type: p.typeDetails.typeName,
       docs: description ? [description] : undefined,
@@ -707,9 +690,9 @@ function writeOptionalParameters(
       isExported: true,
       extends: [
         baseClass ||
-          (!useCoreV2
-            ? "coreHttp.OperationOptions"
-            : "coreClient.OperationOptions")
+        (!useCoreV2
+          ? "coreHttp.OperationOptions"
+          : "coreClient.OperationOptions")
       ],
       properties: properties
     };
@@ -764,48 +747,50 @@ function writeOptionalParameters(
     });
 }
 
+// Get the type name to generate given a property
+function getPropertyTypeName(
+  property: PropertyDetails,
+  objectDetails: ObjectDetails,
+  ignoreNullableOnOptional: boolean
+) {
+  if (property.isConstant) {
+    if (
+      property.type === SchemaType.Number ||
+      property.type === SchemaType.Boolean
+    ) {
+      return `${property.defaultValue}`;
+    }
+    return `"${getStringForValue(
+      property.defaultValue,
+      property.type,
+      false //quoted
+    )}"`;
+  }
+
+  const typeName =
+    property.name === "siblings"
+      ? `${(objectDetails as PolymorphicObjectDetails).unionName}[]`
+      : property.type;
+
+  if (ignoreNullableOnOptional) {
+    return property.nullable && property.required
+      ? `${typeName} | null`
+      : typeName;
+  } else {
+    return property.nullable ? `${typeName} | null` : typeName;
+  }
+}
+
 /**
- * Extracts all properties from ObjectDetails and returns a list of PropertySignatureStructure
+ * Get a list of properties from an object which aren't marked as discriminators
  * @param objectDetails Object description
  */
-function getProperties(
+function getNonDiscriminatorProperties(
   objectDetails: ObjectDetails
-): PropertySignatureStructure[] {
-  const { ignoreNullableOnOptional } = getAutorestOptions();
+): PropertyDetails[] {
   const { properties } = objectDetails;
-  const getTypename = (property: PropertyDetails) => {
-    if (property.isConstant) {
-      return `"${getStringForValue(
-        property.defaultValue,
-        property.type,
-        false //quoted
-      )}"`;
-    }
 
-    const typeName =
-      property.name === "siblings"
-        ? `${(objectDetails as PolymorphicObjectDetails).unionName}[]`
-        : property.type;
-
-    if (ignoreNullableOnOptional) {
-      return property.nullable && property.required
-        ? `${typeName} | null`
-        : typeName;
-    } else {
-      return property.nullable ? `${typeName} | null` : typeName;
-    }
-  };
-
-  return properties
-    .filter(property => !property.isDiscriminator)
-    .map<PropertySignatureStructure>(property => ({
-      name: `"${property.name}"`,
-      hasQuestionToken: !property.required,
-      isReadonly: property.readOnly,
-      type: getTypename(property),
-      docs: getPropertyDescription(property),
-      kind: StructureKind.PropertySignature
-    }));
+  return properties.filter(property => !property.isDiscriminator);
 }
 
 function getPropertyDescription({ description, readOnly }: PropertyDetails) {
@@ -886,8 +871,24 @@ function withAdditionalProperties(
  * Gets an enhanced list of Properties to construct an Object signature
  * @param objectDetails Object description
  */
-const getPropertiesSignatures = (objectDetails: ObjectDetails) =>
-  withDiscriminator(
+const getPropertiesSignatures = (objectDetails: ObjectDetails) => {
+  const { ignoreNullableOnOptional = false } = getAutorestOptions();
+  const properties = getNonDiscriminatorProperties(objectDetails).map<
+    PropertySignatureStructure
+  >(property => ({
+    name: `"${property.name}"`,
+    hasQuestionToken: !property.required,
+    isReadonly: property.readOnly,
+    type: getPropertyTypeName(
+      property,
+      objectDetails,
+      ignoreNullableOnOptional
+    ),
+    docs: getPropertyDescription(property),
+    kind: StructureKind.PropertySignature
+  }));
+  return withDiscriminator(
     objectDetails,
-    withAdditionalProperties(objectDetails, getProperties(objectDetails))
+    withAdditionalProperties(objectDetails, properties)
   );
+};