@azure-tools/typespec-ts 0.54.0 → 0.54.2

package/src/modular/helpers/clientHelpers.ts

@@ -1,409 +0,0 @@
-import { ModularEmitterOptions } from "../interfaces.js";
-import {
-  OptionalKind,
-  ParameterDeclarationStructure,
-  StatementedNode
-} from "ts-morph";
-import {
-  SdkClientType,
-  SdkCredentialParameter,
-  SdkEndpointParameter,
-  SdkHttpParameter,
-  SdkMethodParameter,
-  SdkServiceOperation
-} from "@azure-tools/typespec-client-generator-core";
-
-import {
-  NameType,
-  normalizeName,
-  PackageFlavor
-} from "../../rlc-common/index.js";
-import { SdkContext } from "../../utils/interfaces.js";
-import { getClassicalClientName } from "./namingHelpers.js";
-import { getTypeExpression } from "../type-expressions/get-type-expression.js";
-import { isCredentialType } from "./typeHelpers.js";
-import { CloudSettingHelpers } from "../static-helpers-metadata.js";
-import { resolveReference } from "../../framework/reference.js";
-
-interface ClientParameterOptions {
-  onClientOnly?: boolean;
-  requiredOnly?: boolean;
-  optionalOnly?: boolean;
-  skipArmSpecific?: boolean;
-  skipEndpointTemplate?: boolean;
-  apiVersionAsRequired?: boolean;
-}
-
-type SdkParameter =
-  | SdkMethodParameter
-  | SdkEndpointParameter
-  | SdkCredentialParameter
-  | SdkHttpParameter;
-
-export function hasDefaultValue(p: SdkParameter) {
-  if (
-    p.clientDefaultValue ||
-    p.__raw?.defaultValue ||
-    p.type.kind === "constant"
-  ) {
-    return true;
-  }
-
-  // Special case for endpoint parameters with template arguments that have default values
-  if (p.type.kind === "endpoint" && p.type.templateArguments[0]) {
-    const templateArg = p.type.templateArguments[0];
-    return !!(
-      templateArg.clientDefaultValue ||
-      templateArg.__raw?.defaultValue ||
-      templateArg.type?.kind === "constant"
-    );
-  }
-
-  return false;
-}
-
-export function getClientParameters(
-  client: SdkClientType<SdkServiceOperation>,
-  dpgContext: SdkContext,
-  options: ClientParameterOptions = {
-    requiredOnly: false,
-    onClientOnly: false,
-    optionalOnly: false,
-    skipArmSpecific: false,
-    skipEndpointTemplate: false,
-    apiVersionAsRequired: true
-  }
-) {
-  const clientParams: SdkParameter[] = [];
-  for (const property of client.clientInitialization.parameters) {
-    if (
-      property.type.kind === "union" &&
-      property.type.variantTypes[0]?.kind === "endpoint"
-    ) {
-      if (options.skipEndpointTemplate) {
-        clientParams.push(property);
-      } else {
-        clientParams.push(...property.type.variantTypes[0].templateArguments);
-      }
-    } else if (property.type.kind === "endpoint") {
-      clientParams.push(property);
-    } else if (!clientParams.find((p) => p.name === property.name)) {
-      clientParams.push(property);
-    }
-  }
-
-  const isRequired = (p: SdkParameter) =>
-    // Special case: when apiVersionAsRequired is true, apiVersion should always be considered required
-    (options.apiVersionAsRequired && p.isApiVersionParam) ||
-    (!p.optional && !hasDefaultValue(p));
-  const isOptional = (p: SdkParameter) =>
-    p.optional ||
-    p.clientDefaultValue ||
-    p.__raw?.defaultValue ||
-    p.type.kind === "constant";
-  const skipCredentials = (p: SdkParameter) => p.kind !== "credential";
-  const skipMethodParam = (p: SdkParameter) => p.kind !== "method";
-  const armSpecific = (p: SdkParameter) =>
-    !(p.kind === "endpoint" && dpgContext.arm);
-  // Skip apiVersion parameter when it's multi-service (each service has its own default apiVersion)
-  const skipApiVersionOnMultiService = (p: SdkParameter) =>
-    !(dpgContext.rlcOptions?.isMultiService && p.isApiVersionParam);
-  const filters = [
-    options.requiredOnly ? isRequired : undefined,
-    dpgContext.rlcOptions?.addCredentials === false
-      ? skipCredentials
-      : undefined,
-    options.optionalOnly ? isOptional : undefined,
-    options.onClientOnly ? skipMethodParam : undefined,
-    options.skipArmSpecific ? undefined : armSpecific,
-    skipApiVersionOnMultiService
-  ];
-  const params = clientParams.filter((p) =>
-    filters.every((filter) => !filter || filter(p))
-  );
-  return params;
-}
-
-export function getClientParametersDeclaration(
-  client: SdkClientType<SdkServiceOperation>,
-  dpgContext: SdkContext,
-  options: ClientParameterOptions = {
-    optionalOnly: false,
-    requiredOnly: false,
-    onClientOnly: false,
-    skipArmSpecific: false,
-    apiVersionAsRequired: false
-  }
-): OptionalKind<ParameterDeclarationStructure>[] {
-  const name = getClassicalClientName(client);
-  const optionsParam = {
-    name: "options",
-    type: `${name}OptionalParams`,
-    initializer: "{}"
-  };
-
-  const params: OptionalKind<ParameterDeclarationStructure>[] = [
-    ...getClientParameters(client, dpgContext, options).map<
-      OptionalKind<ParameterDeclarationStructure>
-    >((p) => {
-      const typeExpression = getClientParameterTypeExpression(dpgContext, p);
-      const name = getClientParameterName(p);
-      return {
-        name,
-        type: typeExpression
-      };
-    })
-  ];
-  params.push(optionsParam);
-
-  return params;
-}
-
-function getClientParameterTypeExpression(
-  context: SdkContext,
-  parameter: SdkParameter
-) {
-  // Special handle to work around the fact that TCGC creates a union type for endpoint. The reason they do this
-  // is to provide a way for users to either pass the value to fill in the template of the whole endpoint. Basically they are
-  // inserting a variant with {endpoint}.
-  // Our emitter allows this through the options.endpoint.
-  if (parameter.type.kind === "union") {
-    const endpointVariant = parameter.type.variantTypes.find(
-      (p) => p.kind === "endpoint"
-    );
-    if (endpointVariant) {
-      return getTypeExpression(context, endpointVariant);
-    }
-  }
-  return getTypeExpression(context, parameter.type);
-}
-
-export function getClientParameterName(parameter: SdkParameter) {
-  // We have been calling this endpointParam, so special handling this here to make sure there are no unexpected side effects
-  if (
-    (parameter.type.kind === "union" &&
-      parameter.type.variantTypes.some((v) => v.kind === "endpoint")) ||
-    ((parameter.kind === "endpoint" || parameter.kind === "path") &&
-      parameter.name.toLowerCase() === "endpoint")
-  ) {
-    return "endpointParam";
-  }
-
-  return normalizeName(parameter.name, NameType.Parameter, true);
-}
-
-export function buildGetClientEndpointParam(
-  context: StatementedNode,
-  dpgContext: SdkContext,
-  client: SdkClientType<SdkServiceOperation>
-): { endpointParamName: string; assignedOptionalParams?: Set<string> } {
-  const assignedOptionalParams = new Set<string>();
-  let coreEndpointParam = "";
-  if (dpgContext.rlcOptions?.flavor === "azure") {
-    const cloudSettingSuffix = dpgContext.arm
-      ? ` ?? ${resolveReference(CloudSettingHelpers.getArmEndpoint)}(options.cloudSetting)`
-      : "";
-    coreEndpointParam = `options.endpoint${cloudSettingSuffix}`;
-  } else {
-    // unbranded does not have the deprecated baseUrl parameter
-    coreEndpointParam = `options.endpoint`;
-  }
-  // Special case: endpoint URL not defined
-  const endpointParam = getClientParameters(client, dpgContext, {
-    onClientOnly: true,
-    skipEndpointTemplate: true,
-    skipArmSpecific: true
-  }).find((x) => x.kind === "endpoint" || x.kind === "path");
-  if (endpointParam) {
-    if (
-      endpointParam.type.kind === "union" &&
-      endpointParam.type.variantTypes[0]?.kind === "endpoint"
-    ) {
-      const params = endpointParam.type.variantTypes[0].templateArguments;
-      let parameterizedEndpointUrl =
-        endpointParam.type.variantTypes[0].serverUrl;
-      for (const templateParam of params) {
-        const paramName = getClientParameterName(templateParam);
-        if (templateParam.clientDefaultValue) {
-          const defaultValue =
-            typeof templateParam.clientDefaultValue === "string"
-              ? `"${templateParam.clientDefaultValue}"`
-              : templateParam.clientDefaultValue;
-          context.addStatements(
-            `const ${paramName} = options.${paramName} ?? ${defaultValue};`
-          );
-          assignedOptionalParams.add(paramName);
-        } else if (templateParam.optional) {
-          context.addStatements(`const ${paramName} = options.${paramName};`);
-          assignedOptionalParams.add(paramName);
-        }
-        parameterizedEndpointUrl = parameterizedEndpointUrl.replace(
-          `{${templateParam.name}}`,
-          `\${${getClientParameterName(templateParam)}}`
-        );
-      }
-      const endpointUrl = `const endpointUrl = ${coreEndpointParam} ?? \`${parameterizedEndpointUrl}\`;`;
-      context.addStatements(endpointUrl);
-      return { endpointParamName: "endpointUrl", assignedOptionalParams };
-    } else if (endpointParam.type.kind === "endpoint") {
-      const clientDefaultValue =
-        endpointParam.type.templateArguments[0]?.clientDefaultValue;
-      const defaultValueStr =
-        clientDefaultValue && typeof clientDefaultValue === "string"
-          ? `"${clientDefaultValue}"`
-          : clientDefaultValue
-            ? clientDefaultValue
-            : `String(${getClientParameterName(endpointParam)})`;
-      const endpointUrl = `const endpointUrl = ${coreEndpointParam} ?? ${defaultValueStr};`;
-      context.addStatements(endpointUrl);
-      return { endpointParamName: "endpointUrl" };
-    }
-    const endpointUrl = `const endpointUrl = ${coreEndpointParam} ?? String(${getClientParameterName(endpointParam)});`;
-    context.addStatements(endpointUrl);
-    return { endpointParamName: "endpointUrl" };
-  }
-
-  return { endpointParamName: "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
- * @param apiVersionParamName - the name of the api version parameter in options (e.g., "apiVersion" or "version")
- * @returns - an expression representing the options to be passed in to getClient
- */
-export function buildGetClientOptionsParam(
-  context: StatementedNode,
-  emitterOptions: ModularEmitterOptions,
-  endpointParam: string,
-  apiVersionParamName?: string
-): string {
-  const userAgentOptions = buildUserAgentOptions(
-    context,
-    emitterOptions,
-    "azsdk-js-api"
-  );
-  const loggingOptions = buildLoggingOptions(emitterOptions.options.flavor);
-  const credentials = buildCredentials(emitterOptions, endpointParam);
-
-  // Use the actual api version parameter name for destructuring, defaulting to "apiVersion"
-  const apiVersionDestructure = apiVersionParamName ?? "apiVersion";
-  let expr = `const { ${apiVersionDestructure}: _, ...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: SdkClientType<SdkServiceOperation>,
-  emitterOptions: ModularEmitterOptions
-): string {
-  if (
-    emitterOptions.options.addCredentials &&
-    (emitterOptions.options.credentialScopes ||
-      emitterOptions.options.credentialKeyHeaderName)
-  ) {
-    return (
-      client.clientInitialization.parameters.find((x) => isCredentialType(x))
-        ?.name ?? "undefined"
-    );
-  } else {
-    return "undefined";
-  }
-}
-
-function buildCredentials(
-  emitterOptions: ModularEmitterOptions,
-  endpointParam: string
-): string | undefined {
-  if (!emitterOptions.options.addCredentials) {
-    return undefined;
-  }
-
-  const { credentialScopes, credentialKeyHeaderName } = emitterOptions.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,
-  emitterOptions: ModularEmitterOptions,
-  sdkUserAgentPrefix: string
-): string {
-  const userAgentStatements = [];
-  const prefixFromOptions =
-    "const prefixFromOptions = options?.userAgentOptions?.userAgentPrefix;";
-  userAgentStatements.push(prefixFromOptions);
-
-  const clientPackageName =
-    emitterOptions.options.packageDetails?.nameWithoutScope ??
-    emitterOptions.options.packageDetails?.name ??
-    "";
-  const packageVersion = emitterOptions.options.packageDetails?.version ?? "";
-
-  const userAgentInfoStatement =
-    packageVersion && clientPackageName && sdkUserAgentPrefix.includes("api")
-      ? "const userAgentInfo = `azsdk-js-" +
-        clientPackageName +
-        "/" +
-        packageVersion +
-        "`;"
-      : "";
-
-  if (userAgentInfoStatement) {
-    userAgentStatements.push(userAgentInfoStatement);
-  }
-  const userAgentPrefix = `const userAgentPrefix = ${
-    "prefixFromOptions ? `${prefixFromOptions} " +
-    sdkUserAgentPrefix +
-    `${userAgentInfoStatement ? " ${userAgentInfo}" : ""}` +
-    "` : `" +
-    `${sdkUserAgentPrefix}` +
-    `${userAgentInfoStatement ? " ${userAgentInfo}`" : "`"}`
-  };`;
-  userAgentStatements.push(userAgentPrefix);
-
-  context.addStatements(userAgentStatements.join("\n"));
-
-  return `{ userAgentPrefix }`;
-}

package/src/modular/helpers/clientOptionHelpers.ts

@@ -1,129 +0,0 @@
-import {
-  DecoratedType,
-  SdkModelType
-} from "@azure-tools/typespec-client-generator-core";
-
-/**
- * Represents a header-to-property mapping from @clientOption("header", ...).
- */
-export interface HeaderClientOption {
-  /** The HTTP header name, e.g. "x-ms-error-code" */
-  headerName: string;
-  /** The property name on the model, e.g. "errorCode" */
-  propertyName: string;
-}
-
-const CLIENT_OPTION_DECORATOR_NAME = "Azure.ClientGenerator.Core.@clientOption";
-
-/**
- * Extracts all header client options from a decorated type.
- * Parses @clientOption("header", "x-ms-error-code:errorCode", "javascript") decorators.
- *
- * @param type - A decorated SDK type (typically an SdkModelType for error models)
- * @returns Array of header-to-property mappings
- */
-export function getHeaderClientOptions(
-  type: DecoratedType
-): HeaderClientOption[] {
-  const results: HeaderClientOption[] = [];
-  for (const decorator of type.decorators) {
-    if (decorator.name !== CLIENT_OPTION_DECORATOR_NAME) {
-      continue;
-    }
-    if (decorator.arguments["name"] !== "header") {
-      continue;
-    }
-    const value = decorator.arguments["value"];
-    if (typeof value !== "string") {
-      continue;
-    }
-    const parsed = parseHeaderMapping(value);
-    if (parsed) {
-      results.push(parsed);
-    }
-  }
-  return results;
-}
-
-/**
- * Checks if a model type has any header client options defined.
- */
-export function hasHeaderClientOptions(type: DecoratedType): boolean {
-  return getHeaderClientOptions(type).length > 0;
-}
-
-/**
- * Parses a header mapping string like "x-ms-error-code:errorCode"
- * into its header name and property name components.
- *
- * @returns parsed mapping or undefined if the format is invalid
- */
-function parseHeaderMapping(value: string): HeaderClientOption | undefined {
-  const colonIndex = value.indexOf(":");
-  if (colonIndex <= 0 || colonIndex >= value.length - 1) {
-    return undefined;
-  }
-  const headerName = value.substring(0, colonIndex).trim();
-  const propertyName = value.substring(colonIndex + 1).trim();
-  if (!headerName || !propertyName) {
-    return undefined;
-  }
-  return { headerName, propertyName };
-}
-
-/**
- * Collects header client options from all exception types in an operation.
- * Deduplicates by property name.
- */
-export function getExceptionHeaderClientOptions(
-  exceptions: { type?: SdkModelType | any }[]
-): { model: SdkModelType; options: HeaderClientOption[] }[] {
-  const results: { model: SdkModelType; options: HeaderClientOption[] }[] = [];
-  const seenProperties = new Set<string>();
-
-  for (const exception of exceptions ?? []) {
-    if (!exception.type || exception.type.kind !== "model") {
-      continue;
-    }
-    const model = exception.type as SdkModelType;
-    const options = getHeaderClientOptions(model);
-    const dedupedOptions = options.filter((opt) => {
-      if (seenProperties.has(opt.propertyName)) {
-        return false;
-      }
-      seenProperties.add(opt.propertyName);
-      return true;
-    });
-    if (dedupedOptions.length > 0) {
-      results.push({ model, options: dedupedOptions });
-    }
-  }
-  return results;
-}
-
-/**
- * Gets the header name for the restErrorCodeHeader client option.
- * When present, the emitter generates code to set `error.code` from the specified header.
- *
- * Usage: @clientOption("restErrorCodeHeader", "x-ms-error-code", "javascript")
- *
- * @param type - A decorated SDK type (typically an SdkModelType for error models)
- * @returns The header name string, or undefined if the option is not set
- */
-export function getRestErrorCodeHeader(
-  type: DecoratedType
-): string | undefined {
-  for (const decorator of type.decorators) {
-    if (decorator.name !== CLIENT_OPTION_DECORATOR_NAME) {
-      continue;
-    }
-    if (decorator.arguments["name"] !== "restErrorCodeHeader") {
-      continue;
-    }
-    const value = decorator.arguments["value"];
-    if (typeof value === "string") {
-      return value;
-    }
-  }
-  return undefined;
-}