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

package/src/restLevelClient/generateMethodShortcuts.ts

@@ -0,0 +1,121 @@
+import { CodeModel, Operation } from "@autorest/codemodel";
+import { OptionalKind, MethodSignatureStructure } from "ts-morph";
+import {
+  CasingConvention,
+  NameType,
+  normalizeName,
+  ReservedName
+} from "../utils/nameUtils";
+import { buildMethodDefinitions } from "./helpers/operationHelpers";
+import { PathParameter, Paths } from "./interfaces";
+
+export const REST_CLIENT_RESERVED: ReservedName[] = [
+  { name: "path", reservedFor: [NameType.Property, NameType.OperationGroup] },
+  {
+    name: "pathUnchecked",
+    reservedFor: [NameType.Property, NameType.OperationGroup]
+  },
+  {
+    name: "pipeline",
+    reservedFor: [NameType.Property, NameType.OperationGroup]
+  }
+];
+export function generateMethodShortcuts(model: CodeModel, paths: Paths) {
+  const operationGroups = model.operationGroups;
+  let keys: Record<string, OptionalKind<MethodSignatureStructure>[]> = {};
+  for (const group of operationGroups) {
+    const groupName = normalizeName(
+      group.language.default.name,
+      NameType.OperationGroup,
+      true,
+      REST_CLIENT_RESERVED,
+      CasingConvention.Camel
+    );
+
+    keys[groupName] = buildOperationDefinitions(group.operations, paths);
+  }
+  return keys;
+}
+
+export function generateMethodShortcutImplementation(
+  model: CodeModel,
+  paths: Paths
+) {
+  const operationGroups = model.operationGroups;
+  let keys: Record<string, string[]> = {};
+  for (const group of operationGroups) {
+    const groupName = normalizeName(
+      group.language.default.name,
+      NameType.OperationGroup,
+      true,
+      REST_CLIENT_RESERVED,
+      CasingConvention.Camel
+    );
+
+    keys[groupName] = buildOperationDeclarations(group.operations, paths);
+  }
+  return keys;
+}
+
+function buildOperationDeclarations(operations: Operation[], paths: Paths) {
+  let ops: string[] = [];
+
+  for (const operation of operations) {
+    const name = normalizeName(
+      operation.language.default.name,
+      NameType.Property,
+      true
+    );
+
+    const path = operation.requests![0].protocol.http?.path;
+    const method = operation.requests![0].protocol.http?.method;
+    const pathParams = paths[path]?.pathParameters;
+    const methodDefinitions = generateOperationDeclaration(
+      path,
+      name,
+      method,
+      pathParams
+    );
+    ops = [...ops, methodDefinitions];
+  }
+
+  return ops;
+}
+
+function generateOperationDeclaration(
+  path: string,
+  operationName: string,
+  method: string,
+  pathParams: PathParameter[] = []
+): string {
+  const pathParamNames = `${
+    pathParams.length > 0 ? `${pathParams.map(p => p.name)},` : ""
+  }`;
+  return `"${operationName}": (${pathParamNames} options) => {
+    return client.path("${path}", ${pathParamNames}).${method}(options);
+  }`;
+}
+
+function buildOperationDefinitions(operations: Operation[], paths: Paths) {
+  let ops: OptionalKind<MethodSignatureStructure>[] = [];
+
+  for (const operation of operations) {
+    const name = normalizeName(
+      operation.language.default.name,
+      NameType.Property,
+      true
+    );
+
+    const path = operation.requests![0].protocol.http?.path;
+    const method: string = operation.requests![0].protocol.http?.method;
+    const methods = paths[path]?.methods[method];
+    const pathParams = paths[path]?.pathParameters;
+    const methodDefinitions = buildMethodDefinitions(
+      { [name]: methods },
+      pathParams
+    );
+    ops = [...ops, ...methodDefinitions];
+  }
+
+  return ops;
+}

package/src/restLevelClient/generateObjectTypes.ts

@@ -3,12 +3,12 @@ import {
   ComplexSchema,
   isObjectSchema,
   ObjectSchema,
-  Property
+  Property,
+  SchemaContext
 } from "@autorest/codemodel";
 import { Channel } from "@autorest/extension-base";
 import {
   InterfaceDeclarationStructure,
-  Program,
   PropertySignatureStructure,
   StructureKind,
   TypeAliasDeclarationStructure
@@ -24,16 +24,20 @@ import { getLanguageMetadata } from "../utils/languageHelpers";
  */
 export function buildObjectInterfaces(
   model: CodeModel,
-  importedModels: Set<string>
+  importedModels: Set<string>,
+  schemaUsage: SchemaContext[]
 ): InterfaceDeclarationStructure[] {
-  const objectSchemas = model.schemas.objects ?? [];
+  const objectSchemas = (model.schemas.objects ?? []).filter(o =>
+    o.usage?.some(u => schemaUsage.includes(u))
+  );
   const objectInterfaces: InterfaceDeclarationStructure[] = [];
 
   for (const objectSchema of objectSchemas) {
-    const baseName = getObjectBaseName(objectSchema);
+    const baseName = getObjectBaseName(objectSchema, schemaUsage);
     const interfaceDeclaration = getObjectInterfaceDeclaration(
       baseName,
       objectSchema,
+      schemaUsage,
       importedModels
     );
 
@@ -42,13 +46,22 @@ export function buildObjectInterfaces(
   return objectInterfaces;
 }
 
-export function buildPolymorphicAliases(model: CodeModel) {
+export function buildPolymorphicAliases(
+  model: CodeModel,
+  schemaUsage: SchemaContext[]
+) {
   // We'll add aliases for polymorphic objects
   const objectAliases: TypeAliasDeclarationStructure[] = [];
-  const objectSchemas = model.schemas.objects ?? [];
+  const objectSchemas = (model.schemas.objects ?? []).filter(o =>
+    o.usage?.some(u => schemaUsage.includes(u))
+  );
   for (const objectSchema of objectSchemas) {
-    const baseName = getObjectBaseName(objectSchema);
-    const typeAlias = getPolymorphicTypeAlias(baseName, objectSchema);
+    const baseName = getObjectBaseName(objectSchema, schemaUsage);
+    const typeAlias = getPolymorphicTypeAlias(
+      baseName,
+      objectSchema,
+      schemaUsage
+    );
     if (typeAlias) {
       objectAliases.push(typeAlias);
     }
@@ -60,12 +73,18 @@ export function buildPolymorphicAliases(model: CodeModel) {
 /**
  * Gets a base name for an object schema this is tipically used with suffixes when building interface or type names
  */
-function getObjectBaseName(objectSchema: ObjectSchema) {
-  return normalizeName(
+function getObjectBaseName(
+  objectSchema: ObjectSchema,
+  schemaUsage: SchemaContext[]
+) {
+  const nameSuffix = schemaUsage.includes(SchemaContext.Output) ? "Output" : "";
+  const name = normalizeName(
     getLanguageMetadata(objectSchema.language).name,
     NameType.Interface,
     true /** guard name */
   );
+
+  return `${name}${nameSuffix}`;
 }
 
 /**
@@ -74,7 +93,8 @@ function getObjectBaseName(objectSchema: ObjectSchema) {
  */
 function getPolymorphicTypeAlias(
   baseName: string,
-  objectSchema: ObjectSchema
+  objectSchema: ObjectSchema,
+  schemaUsage: SchemaContext[]
 ): TypeAliasDeclarationStructure | undefined {
   if (!isPolymorphicParent(objectSchema)) {
     return undefined;
@@ -88,13 +108,16 @@ function getPolymorphicTypeAlias(
   }
 
   for (const child of objectSchema.children?.all ?? []) {
+    const nameSuffix = schemaUsage.includes(SchemaContext.Output)
+      ? "Output"
+      : "";
     const name = normalizeName(
       getLanguageMetadata(child.language).name,
       NameType.Interface,
       true /** shouldGuard */
     );
 
-    unionTypes.push(name);
+    unionTypes.push(`${name}${nameSuffix}`);
   }
 
   return {
@@ -112,16 +135,21 @@ function getPolymorphicTypeAlias(
 function getObjectInterfaceDeclaration(
   baseName: string,
   objectSchema: ObjectSchema,
+  schemaUsage: SchemaContext[],
   importedModels: Set<string>
 ): InterfaceDeclarationStructure {
-  let interfaceName = baseName;
+  let interfaceName = `${baseName}`;
   if (isPolymorphicParent(objectSchema)) {
     interfaceName = `${baseName}Base`;
   }
 
   const properties = objectSchema.properties ?? [];
 
-  let propertySignatures = getPropertySignatures(properties, importedModels);
+  let propertySignatures = getPropertySignatures(
+    properties,
+    schemaUsage,
+    importedModels
+  );
 
   // Add the polymorphic property if exists
   propertySignatures = addDiscriminatorProperty(
@@ -130,7 +158,7 @@ function getObjectInterfaceDeclaration(
   );
 
   // Calculate the parents of the current object
-  const extendFrom = getImmediateParentsNames(objectSchema);
+  const extendFrom = getImmediateParentsNames(objectSchema, schemaUsage);
 
   return {
     kind: StructureKind.Interface,
@@ -222,7 +250,11 @@ function getDiscriminatorPropertyName(objectSchema: ObjectSchema) {
  * Calculates the discriminator values that a given object needs
  */
 function getDiscriminatorValue(objectSchema: ObjectSchema): string | undefined {
-  const discriminatorValue = objectSchema.discriminatorValue;
+  const discriminatorValue = objectSchema.discriminatorValue
+    ? objectSchema.discriminatorValue
+    : objectSchema.discriminator?.property.isDiscriminator
+    ? objectSchema.language.default.name
+    : undefined;
   const children = objectSchema.children?.immediate ?? [];
 
   // If the current object has a discriminatorValue but doesn't have any children
@@ -274,7 +306,10 @@ function getChildDiscriminatorValues(children: ComplexSchema[]): string[] {
 /**
  * Gets a list of types a given object may extend from
  */
-function getImmediateParentsNames(objectSchema: ObjectSchema): string[] {
+function getImmediateParentsNames(
+  objectSchema: ObjectSchema,
+  shcemaUsage: SchemaContext[]
+): string[] {
   if (!objectSchema.parents?.immediate) {
     return [];
   }
@@ -291,11 +326,14 @@ function getImmediateParentsNames(objectSchema: ObjectSchema): string[] {
   const parents = objectSchema.parents.immediate
     .filter(p => !isDictionarySchema(p))
     .map(parent => {
-      const name = normalizeName(
+      const nameSuffix = shcemaUsage.includes(SchemaContext.Output)
+        ? "Output"
+        : "";
+      const name = `${normalizeName(
         getLanguageMetadata(parent.language).name,
         NameType.Interface,
         true /** shouldGuard */
-      );
+      )}${nameSuffix}`;
 
       return isObjectSchema(parent) && isPolymorphicParent(parent)
         ? `${name}Base`
@@ -307,7 +345,10 @@ function getImmediateParentsNames(objectSchema: ObjectSchema): string[] {
 
 function getPropertySignatures(
   properties: Property[],
+  schemaUsage: SchemaContext[],
   importedModels: Set<string>
 ) {
-  return properties.map(p => getPropertySignature(p, importedModels));
+  return properties.map(p =>
+    getPropertySignature(p, schemaUsage, importedModels)
+  );
 }

package/src/restLevelClient/generatePagingHelper.ts

@@ -0,0 +1,69 @@
+import { readFileSync } from "fs";
+import { getAutorestOptions, getSession } from "../autorestSession";
+import { extractPaginationDetails } from "../utils/extractPaginationDetails";
+import * as path from "path";
+import * as hbs from "handlebars";
+import { Project } from "ts-morph";
+
+interface PagingDetails {
+  itemNames: string[];
+  nextLinkNames: string[];
+  isComplexPaging: boolean;
+}
+
+export function generatePagingHelper(project: Project) {
+  const pagingInfo = getPagingInfo();
+  let file: string = "";
+
+  file = readFileSync(path.join(__dirname, "paginateHelper.ts.hbs"), {
+    encoding: "utf-8"
+  });
+
+  hbs.registerHelper("quoteWrap", function(
+    value: string | number | boolean | string[]
+  ) {
+    if (Array.isArray(value)) {
+      return value.map(element => `"${element}"`).join();
+    }
+
+    return `"${value}"`;
+  });
+
+  const { srcPath } = getAutorestOptions();
+  const readmeFileContents = hbs.compile(file, { noEscape: true });
+  project.createSourceFile(
+    path.join(srcPath, "paginateHelper.ts"),
+    readmeFileContents(pagingInfo),
+    {
+      overwrite: true
+    }
+  );
+}
+
+function getPagingInfo(): PagingDetails {
+  const { model } = getSession();
+  const nextLinks = new Set<string>();
+  const itemNames = new Set<string>();
+  // Add default values
+  nextLinks.add("nextLink");
+  itemNames.add("value");
+  for (let operationGroup of model.operationGroups) {
+    for (let operation of operationGroup.operations) {
+      const paginationDetails = extractPaginationDetails(operation);
+      if (paginationDetails) {
+        const { nextLinkName, itemName } = paginationDetails;
+        nextLinkName && nextLinks.add(`${nextLinkName}`);
+        itemName && itemNames.add(`${itemName}`);
+      }
+    }
+  }
+
+  // If there are more than one options for nextLink and item names we need to generate a
+  // more complex pagination helper.
+  const isComplexPaging = nextLinks.size > 1 || itemNames.size > 1;
+  return {
+    itemNames: [...itemNames],
+    nextLinkNames: [...nextLinks],
+    isComplexPaging
+  };
+}