@azure-tools/typespec-ts 0.54.0 → 0.54.2

package/src/modular/type-expressions/get-model-expression.ts

@@ -1,20 +1,20 @@
 import {
   EmitTypeOptions,
   getTypeExpression,
-  normalizeModelPropertyName
+  normalizeModelPropertyName,
 } from "./get-type-expression.js";
 
 import {
   SdkModelPropertyType,
   SdkModelType,
-  SdkServiceResponseHeader
+  SdkServiceResponseHeader,
 } from "@azure-tools/typespec-client-generator-core";
-import { refkey } from "../../framework/refkey.js";
+import { useContext } from "../../context-manager.js";
 import { resolveReference } from "../../framework/reference.js";
-import { shouldEmitInline } from "./utils.js";
-import { useContext } from "../../contextManager.js";
+import { refkey } from "../../framework/refkey.js";
 import { SdkContext } from "../../utils/interfaces.js";
 import { MultipartHelpers } from "../static-helpers-metadata.js";
+import { shouldEmitInline } from "./utils.js";
 
 export interface ModelExpressionOptions extends EmitTypeOptions {
   skipPolymorphicUnion?: boolean;
@@ -23,7 +23,7 @@ export interface ModelExpressionOptions extends EmitTypeOptions {
 export function getModelExpression(
   context: SdkContext,
   type: SdkModelType,
-  options: ModelExpressionOptions = {}
+  options: ModelExpressionOptions = {},
 ): string {
   const externalModel = getExternalModel(type);
   if (externalModel) {
@@ -43,12 +43,12 @@ export function getModelExpression(
 
 const externalModels: Record<string, string> = {
   "Azure.Core.Foundations.Error": "ErrorModel",
-  "Azure.Core.Foundations.ErrorResponse": "AzureCoreErrorResponse"
+  "Azure.Core.Foundations.ErrorResponse": "AzureCoreErrorResponse",
 };
 
 export function emitInlineModel(
   context: SdkContext,
-  properties: (SdkModelPropertyType | SdkServiceResponseHeader)[]
+  properties: (SdkModelPropertyType | SdkServiceResponseHeader)[],
 ): string {
   // generate Record<string, any> for empty anonymous object
   if (properties.length === 0) {
@@ -58,7 +58,7 @@ export function emitInlineModel(
       ${properties
         .map(
           (p) =>
-            `${normalizeModelPropertyName(context, p)}${p.optional ? "?" : ""}: ${getPropertyTypeExpression(context, p)}`
+            `${normalizeModelPropertyName(context, p)}${p.optional ? "?" : ""}: ${getPropertyTypeExpression(context, p)}`,
         )
         .join(",\n")}
     }`;
@@ -66,12 +66,9 @@ export function emitInlineModel(
 
 function getPropertyTypeExpression(
   context: SdkContext,
-  property: SdkModelPropertyType | SdkServiceResponseHeader
+  property: SdkModelPropertyType | SdkServiceResponseHeader,
 ): string {
-  if (
-    property.kind === "property" &&
-    property.serializationOptions.multipart?.isFilePart
-  ) {
+  if (property.kind === "property" && property.serializationOptions.multipart?.isFilePart) {
     return getMultipartFileTypeExpression(context, property);
   }
   return getTypeExpression(context, property.type);
@@ -79,7 +76,7 @@ function getPropertyTypeExpression(
 
 export function getMultipartFileTypeExpression(
   context: SdkContext,
-  property: SdkModelPropertyType
+  property: SdkModelPropertyType,
 ): string {
   const multipartOptions = property.serializationOptions.multipart;
 
@@ -88,8 +85,7 @@ export function getMultipartFileTypeExpression(
     multipartOptions.contentType.optional ||
     multipartOptions.defaultContentTypes.length > 0;
   const isFilenameOptional =
-    multipartOptions?.filename === undefined ||
-    multipartOptions.filename.optional;
+    multipartOptions?.filename === undefined || multipartOptions.filename.optional;
 
   const contentTypeType = multipartOptions?.contentType
     ? getTypeExpression(context, multipartOptions.contentType.type)

package/src/modular/type-expressions/get-nullable-expression.ts

@@ -1,18 +1,17 @@
 import { SdkNullableType } from "@azure-tools/typespec-client-generator-core";
 import { resolveReference } from "../../framework/reference.js";
-import { getTypeExpression, EmitTypeOptions } from "./get-type-expression.js";
-import { shouldEmitInline } from "./utils.js";
 import { SdkContext } from "../../utils/interfaces.js";
+import { EmitTypeOptions, getTypeExpression } from "./get-type-expression.js";
+import { shouldEmitInline } from "./utils.js";
 
 export function getNullableExpression(
   context: SdkContext,
   type: SdkNullableType,
-  options: EmitTypeOptions = {}
+  options: EmitTypeOptions = {},
 ): string {
   if (shouldEmitInline(type, options)) {
     // Check if we should ignore null for optional properties
-    const ignoreNullableOnOptional =
-      context.rlcOptions?.ignoreNullableOnOptional ?? false;
+    const ignoreNullableOnOptional = context.rlcOptions?.ignoreNullableOnOptional ?? false;
     const isOptional = options.isOptional ?? false;
 
     const nonNullableType = getTypeExpression(context, type.type, options);

package/src/modular/type-expressions/get-type-expression.ts

@@ -2,15 +2,15 @@ import {
   SdkHttpParameter,
   SdkModelPropertyType,
   SdkServiceResponseHeader,
-  SdkType
+  SdkType,
 } from "@azure-tools/typespec-client-generator-core";
+import { NameType, normalizeName } from "../../rlc-common/index.js";
+import { SdkContext } from "../../utils/interfaces.js";
 import { getCredentialExpression } from "./get-credential-expression.js";
 import { getEnumExpression } from "./get-enum-expression.js";
 import { getModelExpression } from "./get-model-expression.js";
-import { getUnionExpression } from "./get-union-expression.js";
-import { NameType, normalizeName } from "../../rlc-common/index.js";
-import { SdkContext } from "../../utils/interfaces.js";
 import { getNullableExpression } from "./get-nullable-expression.js";
+import { getUnionExpression } from "./get-union-expression.js";
 
 export interface EmitTypeOptions {
   emitInline?: boolean;
@@ -19,7 +19,7 @@ export interface EmitTypeOptions {
 
 export function normalizeModelPropertyName(
   context: SdkContext,
-  property: SdkModelPropertyType | SdkHttpParameter | SdkServiceResponseHeader
+  property: SdkModelPropertyType | SdkHttpParameter | SdkServiceResponseHeader,
 ): string {
   const normalizedPropName = normalizeName(property.name, NameType.Property);
   return context.rlcOptions?.ignorePropertyNameNormalize
@@ -30,7 +30,7 @@ export function normalizeModelPropertyName(
 export function getTypeExpression(
   context: SdkContext,
   type: SdkType,
-  options?: EmitTypeOptions
+  options?: EmitTypeOptions,
 ): string {
   switch (type.kind) {
     case "array": {
@@ -40,9 +40,7 @@ export function getTypeExpression(
     case "enum":
       return getEnumExpression(context, type);
     case "unknown":
-      return context.rlcOptions?.treatUnknownAsRecord
-        ? "Record<string, unknown>"
-        : "any";
+      return context.rlcOptions?.treatUnknownAsRecord ? "Record<string, unknown>" : "any";
     case "boolean":
       return "boolean";
     case "decimal":
@@ -98,9 +96,7 @@ export function getTypeExpression(
     case "offsetDateTime":
       return "string";
     case "tuple": {
-      const types = type.valueTypes
-        .map((v) => getTypeExpression(context, v, options))
-        .join(", ");
+      const types = type.valueTypes.map((v) => getTypeExpression(context, v, options)).join(", ");
       return `[${types}]`;
     }
     case "union":

package/src/modular/type-expressions/get-union-expression.ts

@@ -1,17 +1,17 @@
 import { SdkUnionType } from "@azure-tools/typespec-client-generator-core";
 import { resolveReference } from "../../framework/reference.js";
-import { getTypeExpression, EmitTypeOptions } from "./get-type-expression.js";
-import { shouldEmitInline } from "./utils.js";
 import { SdkContext } from "../../utils/interfaces.js";
+import { EmitTypeOptions, getTypeExpression } from "./get-type-expression.js";
+import { shouldEmitInline } from "./utils.js";
 
 export function getUnionExpression(
   context: SdkContext,
   type: SdkUnionType,
-  options: EmitTypeOptions = {}
+  options: EmitTypeOptions = {},
 ): string {
   if (shouldEmitInline(type, options)) {
     const variantTypes = new Set(
-      type.variantTypes.map((v) => `${getTypeExpression(context, v, options)}`)
+      type.variantTypes.map((v) => `${getTypeExpression(context, v, options)}`),
     );
     return `(${[...variantTypes].join(" | ")})`;
   } else {

package/src/modular/type-expressions/utils.ts

@@ -2,7 +2,7 @@ import { EmitTypeOptions } from "./get-type-expression.js";
 
 export function shouldEmitInline(
   type: { isGeneratedName?: boolean },
-  options: EmitTypeOptions = {}
+  options: EmitTypeOptions = {},
 ): boolean {
   const emitInline = options.emitInline;
 

package/src/rlc-common/build-client-definitions.ts

@@ -0,0 +1,235 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+import * as path from "path";
+import {
+  CallSignatureDeclarationStructure,
+  InterfaceDeclarationStructure,
+  OptionalKind,
+  Project,
+  SourceFile,
+  StructureKind,
+  Writers,
+} from "ts-morph";
+
+import { REST_CLIENT_RESERVED } from "./build-method-shortcuts.js";
+import { getImportSpecifier } from "./helpers/imports-util.js";
+import { getClientName, getImportModuleName } from "./helpers/name-constructors.js";
+import { CasingConvention, NameType, normalizeName, pascalCase } from "./helpers/name-utils.js";
+import {
+  buildMethodDefinitions,
+  getGeneratedWrapperTypes,
+  getPathParamDefinitions,
+} from "./helpers/operation-helpers.js";
+import { generateMethodShortcuts } from "./helpers/shortcut-methods.js";
+import { PathMetadata, Paths, RLCModel } from "./interfaces.js";
+
+export function buildClientDefinitions(model: RLCModel) {
+  const options = {
+    importedParameters: new Set<string>(),
+    importedResponses: new Set<string>(),
+    clientImports: new Set<string>(),
+  };
+  const project = new Project();
+  const srcPath = model.srcPath;
+  const filePath = path.join(srcPath, `clientDefinitions.ts`);
+  const clientDefinitionsFile = project.createSourceFile(filePath, undefined, {
+    overwrite: true,
+  });
+
+  // Get all paths
+  const pathDictionary = model.paths;
+  let shortcuts: OptionalKind<InterfaceDeclarationStructure>[] = [];
+  // There may be operations without an operation group, those shortcut
+  // methods need to be handled differently.
+  let shortcutsInOperationGroup: { name: string; type: string }[] = [];
+
+  if (model.options?.includeShortcuts) {
+    shortcuts = generateMethodShortcuts(model.paths);
+    clientDefinitionsFile.addInterfaces(shortcuts);
+    shortcutsInOperationGroup = shortcuts
+      .filter((s) => s.name !== "ClientOperations")
+      .map((s) => getShortcutName(s.name));
+  }
+
+  clientDefinitionsFile.addInterface({
+    name: "Routes",
+    isExported: true,
+    callSignatures: getPathFirstRoutesInterfaceDefinition(
+      pathDictionary,
+      clientDefinitionsFile,
+      options,
+    ),
+  });
+
+  const clientInterfaceName = getClientName(model);
+  clientDefinitionsFile.addTypeAlias({
+    isExported: true,
+    name: clientInterfaceName,
+    type: Writers.intersectionType(
+      "Client",
+      Writers.objectType({
+        properties: [{ name: "path", type: "Routes" }, ...shortcutsInOperationGroup],
+      }),
+      // If the length of shortcuts in operation group and all shortcutsInOperationGroup
+      // is the same, then we don't have any operations at the client level
+      // Otherwise we need to make the client interface name an union with the
+      // definition of all client level shortcut methods
+      ...(shortcutsInOperationGroup.length !== shortcuts.length ? [`ClientOperations`] : []),
+    ),
+  });
+
+  if (options.importedParameters.size) {
+    clientDefinitionsFile.addImportDeclaration({
+      isTypeOnly: true,
+      namedImports: [...options.importedParameters],
+      moduleSpecifier: getImportModuleName(
+        { cjsName: "./parameters", esModulesName: "./parameters.js" },
+        model,
+      ),
+    });
+  }
+
+  if (options.importedResponses.size) {
+    clientDefinitionsFile.addImportDeclaration({
+      isTypeOnly: true,
+      namedImports: [...options.importedResponses],
+      moduleSpecifier: getImportModuleName(
+        { cjsName: "./responses", esModulesName: "./responses.js" },
+        model,
+      ),
+    });
+  }
+
+  if ((model.importInfo.internalImports.rlcClientDefinition.importsSet?.size ?? 0) > 0) {
+    clientDefinitionsFile.addImportDeclaration({
+      isTypeOnly: true,
+      namedImports: Array.from(model.importInfo.internalImports.rlcClientDefinition.importsSet!),
+      moduleSpecifier: getImportModuleName(
+        { cjsName: "./models", esModulesName: "./models.js" },
+        model,
+      ),
+    });
+  }
+
+  options.clientImports.add("Client");
+  options.clientImports.add("StreamableMethod");
+  clientDefinitionsFile.addImportDeclarations([
+    {
+      isTypeOnly: true,
+      namedImports: [...options.clientImports],
+      moduleSpecifier: getImportSpecifier("restClient", model.importInfo.runtimeImports),
+    },
+  ]);
+
+  return { path: filePath, content: clientDefinitionsFile.getFullText() };
+}
+
+function getPathFirstRoutesInterfaceDefinition(
+  paths: Paths,
+  sourcefile: SourceFile,
+  options: {
+    importedParameters: Set<string>;
+    importedResponses: Set<string>;
+    clientImports: Set<string>;
+  },
+): CallSignatureDeclarationStructure[] {
+  const operationGroupCount = getOperationGroupCount(paths);
+
+  const signatures: CallSignatureDeclarationStructure[] = [];
+  for (const key of Object.keys(paths)) {
+    const pathMetadata = paths[key];
+    if (!pathMetadata) {
+      continue;
+    }
+    for (const verb of Object.keys(pathMetadata.methods)) {
+      const methods = pathMetadata.methods[verb];
+      if (!methods) {
+        continue;
+      }
+      for (const method of methods) {
+        options.importedParameters.add(method.optionsName);
+        method.returnType.split(" | ").forEach((item) => options.importedResponses.add(item));
+      }
+    }
+    generatePathFirstRouteMethodsDefinition(pathMetadata, operationGroupCount, sourcefile);
+    const pathParams = pathMetadata.pathParameters;
+    getGeneratedWrapperTypes(pathParams).forEach((p) =>
+      options.importedParameters.add(p.name ?? p.type),
+    );
+    signatures.push({
+      docs: [
+        `Resource for '${key
+          .replace(/\\/g, "\\\\")
+          .replace(/}/g, "\\}")
+          .replace(/{/g, "\\{")}' has methods for the following verbs: ${Object.keys(
+          pathMetadata.methods,
+        ).join(", ")}`,
+      ],
+      parameters: [{ name: "path", type: `"${key}"` }, ...getPathParamDefinitions(pathParams)],
+      returnType: getOperationReturnTypeName(pathMetadata, getOperationGroupCount(paths)),
+      kind: StructureKind.CallSignature,
+    });
+  }
+  return signatures;
+}
+
+function getOperationGroupCount(paths: Paths) {
+  const operationGroups = Object.keys(paths)
+    .map((p) => paths[p]?.operationGroupName)
+    .filter((p) => p && p !== "Client");
+  const uniqueNames = new Set(operationGroups);
+
+  return uniqueNames.size;
+}
+
+function getOperationReturnTypeName(
+  { operationGroupName, name }: PathMetadata,
+  operationGroupCount: number,
+) {
+  if (operationGroupCount > 1 && operationGroupName && operationGroupName !== "Client") {
+    return normalizeName(
+      `${pascalCase(operationGroupName)}${pascalCase(name)}`,
+      NameType.Interface,
+    );
+  }
+
+  return pascalCase(name);
+}
+
+function generatePathFirstRouteMethodsDefinition(
+  path: PathMetadata,
+  operationGroupCount: number,
+  file: SourceFile,
+): void {
+  const methodDefinitions = buildMethodDefinitions(path.methods);
+  const interfaceDef = {
+    methods: methodDefinitions,
+    name: getOperationReturnTypeName(path, operationGroupCount),
+    isExported: true,
+  };
+  file.addInterface(interfaceDef);
+}
+
+function getShortcutName(interfaceName: string) {
+  const endIndex = shouldKeepSuffix(interfaceName)
+    ? undefined
+    : interfaceName.length - "Operations".length;
+  const clientProperty = normalizeName(
+    interfaceName.substring(0, endIndex),
+    NameType.OperationGroup,
+    true,
+    REST_CLIENT_RESERVED,
+    CasingConvention.Camel,
+  );
+
+  return {
+    name: clientProperty,
+    type: interfaceName,
+  };
+}
+
+function shouldKeepSuffix(name: string) {
+  const reservedNames = ["pipelineOperations", "pathOperations", "pathUncheckedOperations"];
+  return reservedNames.some((r) => r.toLowerCase() === name.toLowerCase());
+}