@autorest/typescript 6.0.0-beta.13 → 6.0.0-beta.16

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,41 @@
+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]}`
+            });
+            file.addExportDeclaration({
+                moduleSpecifier: `${item[0]}/${item[2]}`,
+                namedExports: [`${item[1]} as ${item[1]}Client`]
+            })
+            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,6 +11,7 @@ import { getElementType, getFormatDocs } from "./schemaHelpers";
  */
 export function getPropertySignature(
   property: Property | Parameter,
+  schemaUsage: SchemaContext[],
   importedModels = new Set<string>()
 ): PropertySignatureStructure {
   const propertyLangMetadata = getLanguageMetadata(property.language);
@@ -24,7 +25,7 @@ export function getPropertySignature(
   }
 
   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/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,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,
@@ -9,6 +8,7 @@ import {
   ObjectSchema,
   PrimitiveSchema,
   Schema,
+  SchemaContext,
   SchemaType
 } from "@autorest/codemodel";
 import { getLanguageMetadata } from "../utils/languageHelpers";
@@ -21,15 +21,20 @@ import { NameType, normalizeName } from "../utils/nameUtils";
  */
 export function getElementType(
   schema: Schema,
+  schemaUsage: SchemaContext[],
   importedModels = new Set<string>()
 ): string {
   if (isArraySchema(schema)) {
     // Recursively find out the type for the elements in the array.
-    return `Array<${getElementType(schema.elementType, importedModels)}>`;
+    return `Array<${getElementType(
+      schema.elementType,
+      schemaUsage,
+      importedModels
+    )}>`;
   }
 
   if (isPrimitiveSchema(schema)) {
-    return `${primitiveSchemaToType(schema)}`;
+    return `${primitiveSchemaToType(schema, schemaUsage)}`;
   }
 
   if (isAnyObjectSchema(schema)) {
@@ -37,7 +42,11 @@ export function getElementType(
   }
 
   if (isObjectSchema(schema)) {
-    const { name } = getObjectInfo(schema);
+    const nameSuffix = schemaUsage.includes(SchemaContext.Output)
+      ? "Output"
+      : "";
+    const schemaInfo = getObjectInfo(schema);
+    const name = `${schemaInfo.name}${nameSuffix}`;
     importedModels.add(name);
     return `${name}`;
   }
@@ -45,6 +54,7 @@ export function getElementType(
   if (isDictionarySchema(schema)) {
     return `Record<string, ${getElementType(
       schema.elementType,
+      schemaUsage,
       importedModels
     )}>`;
   }
@@ -85,7 +95,10 @@ function isPrimitiveSchema(schema: Schema): boolean {
  * @param schema - Schema to generate a type for
  * @returns a string with the Typescript type to generate for the given schema
  */
-function primitiveSchemaToType(schema: PrimitiveSchema): string {
+export function primitiveSchemaToType(
+  schema: PrimitiveSchema,
+  schemaUse: SchemaContext[]
+): string {
   switch (schema.type) {
     case SchemaType.Any:
       return "any";
@@ -95,11 +108,12 @@ function primitiveSchemaToType(schema: PrimitiveSchema): string {
     case SchemaType.Date:
     case SchemaType.Time:
     case SchemaType.DateTime:
-      return "Date";
+      return schemaUse.includes(SchemaContext.Output)
+        ? "string"
+        : "Date | string";
     case SchemaType.Char:
       return "string";
     case SchemaType.ByteArray:
-    case SchemaType.Binary:
     case SchemaType.Duration:
     case SchemaType.Credential:
     case SchemaType.UnixTime:
@@ -107,6 +121,10 @@ function primitiveSchemaToType(schema: PrimitiveSchema): string {
     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

@@ -388,7 +388,11 @@ export async function transformOperation(
     NameType.Interface,
     true /** shouldGuard */
   );
-  const typeName = `${normalizedOperationGroupName}${normalizedOperationName}`;
+
+  const typeName =
+    normalizedOperationGroupName === clientName
+      ? `${normalizedOperationName}`
+      : `${normalizedOperationGroupName}${normalizedOperationName}`;
 
   const typeDetails: TypeDetails = {
     typeName,
@@ -487,6 +491,7 @@ export async function transformOperationGroup(
   return {
     name: operationGroupClassName,
     key: operationGroup.$key,
+    originalKey: operationGroup.$key,
     operations,
     isTopLevel,
     mediaTypes

package/src/transforms/parameterTransforms.ts

@@ -236,7 +236,9 @@ export function populateOperationParameters(
     true /** shouldGuard */
   );
 
-  const sameNameParams = operationParameters.filter(p => p.name === name);
+  const sameNameParams = operationParameters.filter(
+    p => p.name === name || p.nameRef === name
+  );
   description += getSchemaTypeDocumentation(parameter.schema);
   const isRequired = getParameterRequired(parameter);
   const isNullable = !!parameter.nullable;