@azure-tools/typespec-ts 0.31.0 → 0.32.0

package/src/modular/helpers/clientHelpers.ts

@@ -1,15 +1,17 @@
 import {
   getImportSpecifier,
+  PackageFlavor,
   Imports as RuntimeImports
 } from "@azure-tools/rlc-common";
 import {
   OptionalKind,
   ParameterDeclarationStructure,
-  SourceFile
+  SourceFile,
+  StatementedNode
 } from "ts-morph";
-import { Client } from "../modularCodeModel.js";
+import { Client, ModularCodeModel } from "../modularCodeModel.js";
 import { getClientName } from "./namingHelpers.js";
-import { getType } from "./typeHelpers.js";
+import { getType, isCredentialType } from "./typeHelpers.js";
 import { SdkContext } from "../../utils/interfaces.js";
 
 export function getClientParameters(
@@ -58,10 +60,147 @@ export function getClientParameters(
   return params;
 }
 
-export function getUserAgentStatements(
-  sdkUserAgentPrefix: string,
-  paramNames: string[]
-): { userAgentStatements: string; updatedParamNames: string[] } {
+export function buildGetClientEndpointParam(
+  context: StatementedNode,
+  client: Client
+): string {
+  // Special case: endpoint URL not defined
+  if (client.url === "") {
+    const endpointParam = client.parameters.find(
+      (x) => x.location === "endpointPath"
+    );
+    return `options.endpoint ?? options.baseUrl ?? ${endpointParam?.clientName}`;
+  }
+
+  const urlParams = client.parameters.filter(
+    (x) => x.location === "path" || x.location === "endpointPath"
+  );
+
+  for (const param of urlParams) {
+    if (param.clientDefaultValue) {
+      const defaultValue =
+        typeof param.clientDefaultValue === "string"
+          ? `"${param.clientDefaultValue}"`
+          : param.clientDefaultValue;
+      context.addStatements(
+        `const ${param.clientName} = options.${param.clientName} ?? ${defaultValue};`
+      );
+    } else if (param.optional) {
+      context.addStatements(
+        `const ${param.clientName} = options.${param.clientName};`
+      );
+    }
+  }
+
+  let parameterizedEndpointUrl = client.url;
+  for (const param of urlParams) {
+    parameterizedEndpointUrl = parameterizedEndpointUrl.replace(
+      `{${param.restApiName}}`,
+      `\${${param.clientName}}`
+    );
+  }
+
+  context.addStatements(
+    `const endpointUrl = options.endpoint ?? options.baseUrl ?? \`${parameterizedEndpointUrl}\``
+  );
+  return "endpointUrl";
+}
+
+/**
+ * Builds the options to be passed to getClient
+ *
+ * @param context - context in which the options are being passed; statements will be added to this context
+ *                  to help build the options shape
+ * @returns - an expression representing the options to be passed in to getClient
+ */
+export function buildGetClientOptionsParam(
+  context: StatementedNode,
+  codeModel: ModularCodeModel,
+  endpointParam: string
+): string {
+  const userAgentOptions = buildUserAgentOptions(context, "azsdk-js-api");
+  const loggingOptions = buildLoggingOptions(codeModel.options.flavor);
+  const credentials = buildCredentials(codeModel, endpointParam);
+
+  let expr = "const { apiVersion: _, ...updatedOptions } = {";
+
+  expr += "...options,";
+
+  if (userAgentOptions) {
+    expr += `userAgentOptions: ${userAgentOptions},`;
+  }
+  if (loggingOptions) {
+    expr += `loggingOptions: ${loggingOptions},`;
+  }
+  if (credentials) {
+    expr += `credentials: ${credentials},`;
+  }
+
+  expr += `}`;
+
+  context.addStatements(expr);
+  return "updatedOptions";
+}
+
+export function buildGetClientCredentialParam(
+  client: Client,
+  codeModel: ModularCodeModel
+): string {
+  if (
+    codeModel.options.addCredentials &&
+    (codeModel.options.credentialScopes ||
+      codeModel.options.credentialKeyHeaderName)
+  ) {
+    return (
+      client.parameters.find((x) => isCredentialType(x.type))?.clientName ??
+      "undefined"
+    );
+  } else {
+    return "undefined";
+  }
+}
+
+function buildCredentials(
+  codeModel: ModularCodeModel,
+  endpointParam: string
+): string | undefined {
+  if (!codeModel.options.addCredentials) {
+    return undefined;
+  }
+
+  const { credentialScopes, credentialKeyHeaderName } = codeModel.options;
+
+  const scopesString = credentialScopes
+    ? credentialScopes.map((cs) => `"${cs}"`).join(", ") ||
+      `\`\${${endpointParam}}/.default\``
+    : "";
+  const scopes = scopesString
+    ? `scopes: options.credentials?.scopes ?? [${scopesString}],`
+    : "";
+
+  const apiKeyHeaderName = credentialKeyHeaderName
+    ? `apiKeyHeaderName: options.credentials?.apiKeyHeaderName ?? "${credentialKeyHeaderName}",`
+    : "";
+
+  if (!scopes && !apiKeyHeaderName) {
+    return undefined;
+  }
+
+  return `{ ${scopes}${apiKeyHeaderName} }`;
+}
+
+function buildLoggingOptions(flavor?: PackageFlavor): string | undefined {
+  if (flavor !== "azure") {
+    return undefined;
+  }
+
+  return `{ logger: options.loggingOptions?.logger ?? logger.info }`;
+}
+
+export function buildUserAgentOptions(
+  context: StatementedNode,
+  sdkUserAgentPrefix: string
+): string {
   const userAgentStatements = `
     const prefixFromOptions = options?.userAgentOptions?.userAgentPrefix;
     const userAgentPrefix = ${
@@ -72,14 +211,9 @@ export function getUserAgentStatements(
     };
   `;
 
-  // Update param names to spread over options
-  const updatedParamNames = paramNames.map((x) =>
-    x === "options"
-      ? "{ ...options, userAgentOptions: { userAgentPrefix } }"
-      : x
-  );
+  context.addStatements(userAgentStatements);
 
-  return { userAgentStatements, updatedParamNames };
+  return `{ userAgentPrefix }`;
 }
 
 export function importCredential(

package/src/modular/helpers/operationHelpers.ts

@@ -1,10 +1,7 @@
 import {
   addImportToSpecifier,
-  getResponseBaseName,
-  getResponseTypeName,
   Imports as RuntimeImports,
-  NameType,
-  OperationResponse
+  NameType
 } from "@azure-tools/rlc-common";
 import {
   SdkContext,
@@ -37,7 +34,6 @@ import {
   Operation,
   Parameter,
   Property,
-  Response,
   Type
 } from "../modularCodeModel.js";
 import {
@@ -46,57 +42,9 @@ import {
 } from "./docsHelpers.js";
 import { getClassicalLayerPrefix, getOperationName } from "./namingHelpers.js";
 import { buildType, isTypeNullable } from "./typeHelpers.js";
-
-function getRLCResponseTypes(rlcResponse?: OperationResponse) {
-  if (!rlcResponse?.responses) {
-    return;
-  }
-  return rlcResponse?.responses
-    .map(
-      (resp) =>
-        resp.predefinedName ?? getRLCResponseType(resp.statusCode, rlcResponse)
-    )
-    .join(" | ");
-}
-
-function getRLCResponseType(
-  statusCode: string,
-  operationInfo?: OperationResponse
-) {
-  if (!operationInfo) {
-    return;
-  }
-  const baseResponseName = getResponseBaseName(
-    operationInfo.operationGroup,
-    operationInfo.operationName,
-    statusCode
-  );
-  // Get the information to build the Response Interface
-  return getResponseTypeName(baseResponseName);
-}
-
-function getNarrowedRLCResponse(
-  response: Response,
-  rlcResponse?: OperationResponse
-): string | undefined {
-  if (!rlcResponse) {
-    return;
-  }
-  const statusCode = response.statusCodes;
-  const names = getRLCResponseTypes(rlcResponse)?.split(" | ");
-  const lroResponse = names?.filter((n) => n.endsWith(`LogicalResponse`));
-  const normalResponse = names?.filter(
-    (n) => n === getRLCResponseType(`${statusCode}`, rlcResponse)
-  );
-  return (
-    // if the response is a LRO response, narrow to the lro logical response
-    lroResponse?.at(0) ??
-    // if the default response is a superset of one of other responses, narrow to the normal response
-    (rlcResponse.isDefaultSupersetOfOthers
-      ? normalResponse?.at(0) ?? "any"
-      : undefined)
-  );
-}
+import { resolveReference } from "../../framework/reference.js";
+import { PagingHelpers, PollingHelpers } from "../static-helpers-metadata.js";
+import { AzurePollingDependencies } from "../external-dependencies.js";
 
 export function getSendPrivateFunction(
   dpgContext: SdkContext,
@@ -106,16 +54,13 @@ export function getSendPrivateFunction(
 ): OptionalKind<FunctionDeclarationStructure> {
   const parameters = getOperationSignatureParameters(operation, clientType);
   const { name } = getOperationName(operation);
-  const returnType = `StreamableMethod<${getRLCResponseTypes(
-    operation.rlcResponse
-  )}>`;
 
   const functionStatement: OptionalKind<FunctionDeclarationStructure> = {
     isAsync: false,
     isExported: true,
     name: `_${name}Send`,
     parameters,
-    returnType
+    returnType: "StreamableMethod"
   };
 
   const operationPath = operation.url;
@@ -132,7 +77,7 @@ export function getSendPrivateFunction(
       dpgContext,
       operation,
       runtimeImports
-    )}}) ${operation.isOverload ? `as ${returnType}` : ``} ;`
+    )}});`
   );
 
   return {
@@ -143,22 +88,23 @@ export function getSendPrivateFunction(
 
 export function getDeserializePrivateFunction(
   operation: Operation,
-  needSubClient: boolean,
-  needUnexpectedHelper: boolean,
   runtimeImports: RuntimeImports
 ): OptionalKind<FunctionDeclarationStructure> {
   const { name } = getOperationName(operation);
   const parameters: OptionalKind<ParameterDeclarationStructure>[] = [
     {
       name: "result",
-      type: getRLCResponseTypes(operation.rlcResponse)
+      type: "PathUncheckedResponse"
     }
   ];
+  addImportToSpecifier("restClient", runtimeImports, "PathUncheckedResponse");
+
   // TODO: Support LRO + paging operation
   // https://github.com/Azure/autorest.typescript/issues/2313
   const isLroOnly = isLroOnlyOperation(operation);
 
   // TODO: Support operation overloads
+  // TODO: Support multiple responses
   const response = operation.responses[0]!;
   let returnType;
   if (isLroOnly && operation.method.toLowerCase() !== "patch") {
@@ -181,48 +127,23 @@ export function getDeserializePrivateFunction(
     returnType: `Promise<${returnType.type}>`
   };
   const statements: string[] = [];
-  if (needUnexpectedHelper) {
-    statements.push(
-      `if(${needSubClient ? "UnexpectedHelper." : ""}isUnexpected(result)){`,
-      `throw createRestError(result);`,
-      "}"
-    );
-    addImportToSpecifier("restClient", runtimeImports, "createRestError");
-  } else {
-    const validStatus = [
-      ...new Set(
-        operation.responses
-          .flatMap((r) => r.statusCodes)
-          .filter((s) => s !== "default")
-      )
-    ];
-
-    if (validStatus.length > 0) {
-      statements.push(
-        `if(${validStatus
-          .map((s) => `result.status !== "${s}"`)
-          .join(" || ")}){`,
-        `throw createRestError(result);`,
-        "}"
-      );
-      addImportToSpecifier("restClient", runtimeImports, "createRestError");
-    }
-  }
+
+  statements.push(
+    `const expectedStatuses = ${getExpectedStatuses(operation)};`
+  );
+  statements.push(
+    `if(!expectedStatuses.includes(result.status)){`,
+    `throw createRestError(result);`,
+    "}"
+  );
+  addImportToSpecifier("restClient", runtimeImports, "createRestError");
 
   const deserializedType = isLroOnly
     ? operation?.lroMetadata?.finalResult
     : response.type;
   const hasLroSubPath = operation?.lroMetadata?.finalResultPath !== undefined;
-  // Narrow down the rlc response type to deserialized one
-  const isNarrowedResponse = getNarrowedRLCResponse(
-    response,
-    operation.rlcResponse
-  );
-  let deserializePrefix = "result.body";
-  if (isNarrowedResponse) {
-    statements.push(`const res = result as unknown as ${isNarrowedResponse};`);
-    deserializePrefix = "res.body";
-  }
+
+  const deserializePrefix = "result.body";
 
   const deserializedRoot = hasLroSubPath
     ? `${deserializePrefix}.${operation?.lroMetadata?.finalResultPath}`
@@ -394,6 +315,12 @@ function getLroOnlyOperationFunction(operation: Operation, clientType: string) {
     getOperationSignatureParameters(operation, clientType);
   const returnType = buildLroReturnType(operation);
   const { name, fixme = [] } = getOperationName(operation);
+  const pollerLikeReference = resolveReference(
+    AzurePollingDependencies.PollerLike
+  );
+  const operationStateReference = resolveReference(
+    AzurePollingDependencies.OperationState
+  );
   const functionStatement = {
     docs: [
       ...getDocsFromDescription(operation.description),
@@ -404,18 +331,27 @@ function getLroOnlyOperationFunction(operation: Operation, clientType: string) {
     name,
     propertyName: operation.name,
     parameters,
-    returnType: `PollerLike<OperationState<${returnType.type}>, ${returnType.type}>`
+    returnType: `${pollerLikeReference}<${operationStateReference}<${returnType.type}>, ${returnType.type}>`
   };
 
+  const getLongRunningPollerReference = resolveReference(
+    PollingHelpers.GetLongRunningPoller
+  );
+
   const statements: string[] = [];
   statements.push(`
-  return getLongRunningPoller(context, _${name}Deserialize, {
+
+  return ${getLongRunningPollerReference}(context, _${name}Deserialize, ${getExpectedStatuses(
+    operation
+  )}, {
     updateIntervalInMs: options?.updateIntervalInMs,
     abortSignal: options?.abortSignal,
     getInitialResponse: () => _${name}Send(${parameters
       .map((p) => p.name)
       .join(", ")})
-  }) as PollerLike<OperationState<${returnType.type}>, ${returnType.type}>;
+  }) as ${pollerLikeReference}<${operationStateReference}<${
+    returnType.type
+  }>, ${returnType.type}>;
   `);
 
   return {
@@ -450,6 +386,12 @@ function getPagingOnlyOperationFunction(
     returnType = buildType(type.name, type, type.format);
   }
   const { name, fixme = [] } = getOperationName(operation);
+  const pagedAsyncIterableIteratorReference = resolveReference(
+    PagingHelpers.PagedAsyncIterableIterator
+  );
+  const buildPagedAsyncIteratorReference = resolveReference(
+    PagingHelpers.BuildPagedAsyncIterator
+  );
   const functionStatement = {
     docs: [
       ...getDocsFromDescription(operation.description),
@@ -460,7 +402,7 @@ function getPagingOnlyOperationFunction(
     name,
     propertyName: operation.name,
     parameters,
-    returnType: `PagedAsyncIterableIterator<${returnType.type}>`
+    returnType: `${pagedAsyncIterableIteratorReference}<${returnType.type}>`
   };
 
   const statements: string[] = [];
@@ -472,10 +414,11 @@ function getPagingOnlyOperationFunction(
     options.push(`nextLinkName: "${operation.continuationTokenName}"`);
   }
   statements.push(
-    `return buildPagedAsyncIterator(
+    `return ${buildPagedAsyncIteratorReference}(
       context, 
       () => _${name}Send(${parameters.map((p) => p.name).join(", ")}), 
       _${name}Deserialize,
+      ${getExpectedStatuses(operation)},
       ${options.length > 0 ? `{${options.join(", ")}}` : ``}
       );`
   );
@@ -1243,7 +1186,7 @@ export function deserializeResponseValue(
             isTypeNullable(type.elementType) || type.elementType.optional
               ? "!p ? p :"
               : "";
-          return `${prefix}.map(p => { return ${elementNullOrUndefinedPrefix}{${getResponseMapping(
+          return `${prefix}.map((p: any) => { return ${elementNullOrUndefinedPrefix}{${getResponseMapping(
             type.elementType,
             "p",
             runtimeImports,
@@ -1258,14 +1201,14 @@ export function deserializeResponseValue(
             type.elementType,
             "deserialize"
           );
-          return `${prefix}.map(p => ${nullOrUndefinedPrefix}${deserializeFunctionName}(p))`;
+          return `${prefix}.map((p: any) => ${nullOrUndefinedPrefix}${deserializeFunctionName}(p))`;
         }
         return `${prefix}`;
       } else if (
         needsDeserialize(type.elementType) &&
         !type.elementType?.aliasType
       ) {
-        return `${prefix}.map(p => ${deserializeResponseValue(
+        return `${prefix}.map((p: any) => ${deserializeResponseValue(
           type.elementType!,
           "p",
           runtimeImports,
@@ -1554,3 +1497,23 @@ export function isDiscriminatedUnion(type?: SdkType): type is SdkModelType {
       type.discriminatedSubtypes
   );
 }
+
+/**
+ * Get an expression representing an array of expected status codes for the operation
+ * @param operation The operation
+ */
+export function getExpectedStatuses(operation: Operation): string {
+  const statusCodes = operation.responses.flatMap((x) =>
+    x.statusCodes.filter((s) => s !== "default")
+  );
+  // LROs may call the same path but with GET to get the operation status.
+  if (
+    isLroOnlyOperation(operation) &&
+    operation.method !== "GET" &&
+    !statusCodes.includes(200)
+  ) {
+    statusCodes.push(200);
+  }
+
+  return `[${statusCodes.map((x) => `"${x}"`).join(", ")}]`;
+}

package/src/modular/helpers/typeHelpers.ts

@@ -298,3 +298,11 @@ export function isNumericTypeKind(kind: string): boolean {
 export function isDateTimeTypeKind(kind: string): boolean {
   return DateTimeTypeKinds.includes(kind);
 }
+
+export function isCredentialType(type: Type): boolean {
+  const credentialTypes = ["OAuth2", "Key"];
+  return (
+    credentialTypes.includes(type.type) ||
+    (type.type === "combined" && (type.types?.every(isCredentialType) ?? false))
+  );
+}

package/src/modular/interfaces.ts

@@ -11,6 +11,7 @@ export interface ClientDetails {
 
 export interface OperationPathAndDeserDetails {
   path: string;
+  expectedStatusesExpression: string;
   deserName: string;
   renamedDeserName?: string;
 }

package/src/modular/serialization/buildSerializerFunction.ts

@@ -1,13 +1,8 @@
 import { toCamelCase, toPascalCase } from "../../utils/casingUtils.js";
 import { Type as ModularType } from "../modularCodeModel.js";
 import { getRequestModelMapping } from "../helpers/operationHelpers.js";
-import { useContext } from "../../contextManager.js";
 
-import {
-  Imports as RuntimeImports,
-  SchemaContext,
-  addImportToSpecifier
-} from "@azure-tools/rlc-common";
+import { Imports as RuntimeImports } from "@azure-tools/rlc-common";
 import { UsageFlags } from "@typespec/compiler";
 import {
   SdkModelType,
@@ -24,7 +19,6 @@ export function buildModelSerializer(
   type: ModularType,
   runtimeImports: RuntimeImports
 ): string | undefined {
-  const rlcMetadata = useContext("rlcMetaTree");
   const modelTcgcType = getTcgcType(type) as SdkModelType;
   if (
     modelTcgcType.usage !== undefined &&
@@ -39,9 +33,6 @@ export function buildModelSerializer(
 
   let serializerName = `${toCamelCase(type.name)}Serializer`;
 
-  const restModel = rlcMetadata.get(type.__raw!);
-  const restModelName = restModel?.rlcType.name;
-
   const output: string[] = [];
 
   if (
@@ -85,17 +76,6 @@ export function buildModelSerializer(
     serializerName = baseSerializerName;
   }
 
-  let serializerReturnType = "";
-
-  // There are some situations where the type is not present in the REST API,
-  // this can happen when client.tsp overrides visibility to public on an orphan model
-  // In this case we just let TypeScript infer the return type.
-  let restModelNameAlias = "";
-  if (restModelName && restModel.rlcType.usage?.includes(SchemaContext.Input)) {
-    restModelNameAlias = `${restModelName}Rest`;
-    serializerReturnType = `: ${restModelNameAlias}`;
-  }
-
   if (type.type === "model" || type.type === "dict") {
     const nullabilityPrefix = "";
     // getPropertySerializationPrefix({
@@ -127,18 +107,10 @@ export function buildModelSerializer(
       output.push(`
         export function ${serializerName}(item: ${toPascalCase(
           type.name
-        )})${serializerReturnType} {
+        )}): Record<string, unknown> {
           return ${fnBody}
         }
         `);
-
-      if (serializerReturnType) {
-        addImportToSpecifier(
-          "rlcIndex",
-          runtimeImports,
-          `${restModelName} as ${restModelNameAlias}`
-        );
-      }
     } else {
       output.push(`
         export function ${serializerName}(item: ${toPascalCase(type.name)}) {
@@ -148,9 +120,7 @@ export function buildModelSerializer(
     }
   } else if (type.type === "enum") {
     output.push(`
-    export function ${serializerName}(item: ${toPascalCase(
-      type.name
-    )})${serializerReturnType} {
+    export function ${serializerName}(item: ${toPascalCase(type.name)}) {
       return item;
     }
     `);

package/src/modular/static-helpers-metadata.ts

@@ -0,0 +1,73 @@
+export const SerializationHelpers = {
+  buildMultiCollection: {
+    kind: "function",
+    name: "buildMultiCollection",
+    location: "serialization/build-multi-collection.ts"
+  },
+  buildCsvCollection: {
+    kind: "function",
+    name: "buildCsvCollection",
+    location: "serialization/build-csv-collection.ts"
+  },
+  buildPipeCollection: {
+    kind: "function",
+    name: "buildPipeCollection",
+    location: "serialization/build-pipe-collection.ts"
+  },
+  buildSsvCollection: {
+    kind: "function",
+    name: "buildSsvCollection",
+    location: "serialization/build-ssv-collection.ts"
+  },
+  buildTsvCollection: {
+    kind: "function",
+    name: "buildTsvCollection",
+    location: "serialization/build-tsv-collection.ts"
+  }
+} as const;
+
+export const PagingHelpers = {
+  PageSettings: {
+    kind: "interface",
+    name: "PageSettings",
+    location: "pagingHelpers.ts"
+  },
+  ContinuablePage: {
+    kind: "typeAlias",
+    name: "ContinuablePage",
+    location: "pagingHelpers.ts"
+  },
+  PagedAsyncIterableIterator: {
+    kind: "interface",
+    name: "PagedAsyncIterableIterator",
+    location: "pagingHelpers.ts"
+  },
+  PagedResult: {
+    kind: "interface",
+    name: "PagedResult",
+    location: "pagingHelpers.ts"
+  },
+  BuildPagedAsyncIteratorOptions: {
+    kind: "interface",
+    name: "BuildPagedAsyncIteratorOptions",
+    location: "pagingHelpers.ts"
+  },
+  BuildPagedAsyncIterator: {
+    kind: "function",
+    name: "buildPagedAsyncIterator",
+    location: "pagingHelpers.ts"
+  }
+} as const;
+
+export const PollingHelpers = {
+  GetLongRunningPollerOptions: {
+    kind: "interface",
+    name: "GetLongRunningPollerOptions",
+    location: "pollingHelpers.ts"
+  },
+  GetLongRunningPoller: {
+    kind: "function",
+    name: "getLongRunningPoller",
+    location: "pollingHelpers.ts"
+  }
+} as const;