@azure-tools/typespec-ts 0.54.0 → 0.54.2

package/src/transform/transformHelperFunctionDetails.ts

@@ -1,100 +0,0 @@
-import { HelperFunctionDetails, PackageFlavor } from "../rlc-common/index.js";
-import {
-  getHttpOperationWithCache,
-  SdkClient
-} from "@azure-tools/typespec-client-generator-core";
-import { SdkContext } from "../utils/interfaces.js";
-import {
-  extractPageDetails,
-  getSpecialSerializeInfo,
-  hasPagingOperations,
-  hasPollingOperations
-} from "../utils/operationUtil.js";
-import { getCollectionFormat } from "../utils/modelUtils.js";
-import { listOperationsUnderRLCClient } from "../utils/clientUtils.js";
-
-export function transformHelperFunctionDetails(
-  client: SdkClient,
-  dpgContext: SdkContext,
-  flavor?: PackageFlavor
-): HelperFunctionDetails {
-  const serializeInfo = extractSpecialSerializeInfo(client, dpgContext);
-  // Disable paging and long running for non-Azure clients.
-  if (flavor !== "azure") {
-    return {
-      hasLongRunning: false,
-      hasPaging: false,
-      ...serializeInfo
-    };
-  }
-
-  const annotationDetails = {
-    hasLongRunning: hasPollingOperations(client, dpgContext)
-  };
-  const details = extractClientPageDetails(client, dpgContext);
-  return {
-    ...(details ?? {}),
-    ...annotationDetails,
-    ...serializeInfo
-  };
-}
-
-function extractClientPageDetails(client: SdkClient, dpgContext: SdkContext) {
-  const program = dpgContext.program;
-  if (!hasPagingOperations(client, dpgContext)) {
-    return;
-  }
-  const nextLinks = new Set<string>(["nextLink"]);
-  const itemNames = new Set<string>(["value"]);
-  for (const op of listOperationsUnderRLCClient(client)) {
-    const route = getHttpOperationWithCache(dpgContext, op);
-    // ignore overload base operation
-    if (route.overloads && route.overloads?.length > 0) {
-      continue;
-    }
-    const pagedDetail = extractPageDetails(program, route);
-    if (pagedDetail) {
-      pagedDetail.itemNames.forEach((name) => itemNames.add(name));
-      pagedDetail.nextLinkNames.forEach((name) => nextLinks.add(name));
-    }
-  }
-  // If there are more than one options for nextLink and item names we need to generate a
-  // more complex pagination helper.
-  return {
-    hasPaging: true,
-    pageDetails: {
-      itemNames: [...itemNames],
-      nextLinkNames: [...nextLinks],
-      isComplexPaging: nextLinks.size > 1 || itemNames.size > 1
-    }
-  };
-}
-
-function extractSpecialSerializeInfo(
-  client: SdkClient,
-  dpgContext: SdkContext
-) {
-  let hasMultiCollection = false;
-  let hasCsvCollection = false;
-  for (const op of listOperationsUnderRLCClient(client)) {
-    const route = getHttpOperationWithCache(dpgContext, op);
-    route.parameters.parameters.forEach((parameter) => {
-      const format = getCollectionFormat(dpgContext, parameter as any);
-      const serializeInfo = getSpecialSerializeInfo(
-        dpgContext,
-        parameter.type,
-        format!
-      );
-      hasMultiCollection = hasMultiCollection
-        ? hasMultiCollection
-        : serializeInfo.hasMultiCollection;
-      hasCsvCollection = hasCsvCollection
-        ? hasCsvCollection
-        : serializeInfo.hasCsvCollection;
-    });
-  }
-  return {
-    hasMultiCollection,
-    hasCsvCollection
-  };
-}

package/src/transform/transformParameters.ts

@@ -1,371 +0,0 @@
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-
-import {
-  ApiVersionInfo,
-  Imports,
-  ObjectSchema,
-  OperationParameter,
-  ParameterBodyMetadata,
-  ParameterMetadata,
-  Schema,
-  SchemaContext
-} from "../rlc-common/index.js";
-import {
-  HttpOperation,
-  HttpOperationParameter,
-  HttpOperationParameters
-} from "@typespec/http";
-import {
-  KnownMediaType,
-  extractMediaTypes,
-  hasMediaType,
-  isMediaTypeJsonMergePatch
-} from "../utils/mediaTypes.js";
-import {
-  SdkClient,
-  getHttpOperationWithCache,
-  isApiVersion
-} from "@azure-tools/typespec-client-generator-core";
-import { NoTarget, Type, isVoidType } from "@typespec/compiler";
-import {
-  getBodyType,
-  getCollectionFormat,
-  getFormattedPropertyDoc,
-  getImportedModelName,
-  getSchemaForType,
-  getTypeName,
-  isArrayType,
-  isBodyRequired
-} from "../utils/modelUtils.js";
-import {
-  getOperationGroupName,
-  getOperationName,
-  getSpecialSerializeInfo
-} from "../utils/operationUtil.js";
-import { SdkContext } from "../utils/interfaces.js";
-import { getParameterSerializationInfo } from "../utils/parameterUtils.js";
-import { reportDiagnostic } from "../lib.js";
-import { listOperationsUnderRLCClient } from "../utils/clientUtils.js";
-
-interface ParameterTransformationOptions {
-  apiVersionInfo?: ApiVersionInfo;
-  operationGroupName?: string;
-  operationName?: string;
-  importModels?: Set<string>;
-}
-
-export function transformToParameterTypes(
-  client: SdkClient,
-  dpgContext: SdkContext,
-  importDetails: Imports,
-  apiVersionInfo?: ApiVersionInfo
-): OperationParameter[] {
-  const rlcParameters: OperationParameter[] = [];
-  const outputImportedSet = new Set<string>();
-  for (const op of listOperationsUnderRLCClient(client)) {
-    const route = getHttpOperationWithCache(dpgContext, op);
-    // ignore overload base operation
-    if (route.overloads && route.overloads?.length > 0) {
-      continue;
-    }
-    transformToParameterTypesForRoute(route);
-  }
-
-  if (outputImportedSet.size > 0) {
-    importDetails.parameter.importsSet = outputImportedSet;
-  }
-  function transformToParameterTypesForRoute(route: HttpOperation) {
-    const parameters = route.parameters;
-    const rlcParameter: OperationParameter = {
-      operationGroup: getOperationGroupName(dpgContext, route),
-      operationName: getOperationName(dpgContext, route.operation),
-      parameters: []
-    };
-    const options = {
-      apiVersionInfo,
-      operationGroupName: rlcParameter.operationGroup,
-      operationName: rlcParameter.operationName,
-      importModels: outputImportedSet
-    };
-    // transform query param
-    const queryParams = transformQueryParameters(
-      dpgContext,
-      parameters,
-      options
-    );
-    // transform path param
-    const pathParams = transformPathParameters(dpgContext, parameters, options);
-    // TODO: support cookie parameters, https://github.com/Azure/autorest.typescript/issues/2898
-    transformCookieParameters(dpgContext, parameters);
-    // transform header param including content-type
-    const headerParams = transformHeaderParameters(
-      dpgContext,
-      parameters,
-      options
-    );
-    // transform body
-    const bodyType = getBodyType(route);
-    let bodyParameter = undefined;
-    if (bodyType) {
-      bodyParameter = transformBodyParameters(
-        dpgContext,
-        parameters,
-        headerParams,
-        outputImportedSet,
-        bodyType
-      );
-    }
-    rlcParameter.parameters.push({
-      parameters: [...queryParams, ...pathParams, ...headerParams],
-      body: bodyParameter
-    });
-    rlcParameters.push(rlcParameter);
-  }
-  return rlcParameters;
-}
-
-function getParameterMetadata(
-  dpgContext: SdkContext,
-  paramType: "query" | "path" | "header",
-  parameter: HttpOperationParameter,
-  options: ParameterTransformationOptions
-): ParameterMetadata {
-  const program = dpgContext.program;
-  const importedModels = options.importModels ?? new Set<string>();
-  const schemaContext = [SchemaContext.Exception, SchemaContext.Input];
-  const schema = getSchemaForType(dpgContext, parameter.param.type, {
-    usage: schemaContext,
-    needRef: false,
-    relevantProperty: parameter.param
-  }) as Schema;
-  const name = getParameterName(parameter.name);
-  let description =
-    getFormattedPropertyDoc(program, parameter.param, schema) ?? "";
-  const format = getCollectionFormat(dpgContext, parameter as any);
-  if (isArrayType(schema) && format) {
-    const serializeInfo = getSpecialSerializeInfo(
-      dpgContext,
-      parameter.type,
-      format
-    );
-    if (serializeInfo.hasMultiCollection || serializeInfo.hasCsvCollection) {
-      description += `${description ? "\n" : ""}This parameter could be formatted as ${serializeInfo.collectionInfo.join(
-        ", "
-      )} collection string, we provide ${serializeInfo.descriptions.join(
-        ", "
-      )} from serializeHelper.ts to help${
-        serializeInfo.hasMultiCollection
-          ? ", you will probably need to set skipUrlEncoding as true when sending the request"
-          : ""
-      }.`;
-    }
-    if (format === "tsv") {
-      description += `${description ? "\n" : ""}This parameter could be formatted as tsv collection string.`;
-    }
-  }
-
-  getImportedModelName(schema, schemaContext)?.forEach(
-    importedModels.add,
-    importedModels
-  );
-  const serializationType = getParameterSerializationInfo(
-    dpgContext,
-    parameter,
-    schema,
-    options.operationGroupName,
-    options.operationName
-  );
-  return {
-    type: paramType,
-    name,
-    param: {
-      name,
-      type: serializationType.typeName,
-      typeName: serializationType.typeName,
-      required: !parameter.param.optional,
-      description,
-      wrapperType: serializationType.wrapperType
-    }
-  };
-}
-
-function getParameterName(name: string) {
-  if (name && name.toLowerCase() === "content-type") {
-    return "contentType";
-  }
-  return `"${name}"`;
-}
-
-function transformCookieParameters(
-  dpgContext: SdkContext,
-  parameters: HttpOperationParameters
-) {
-  // TODO: support cookie parameters, https://github.com/Azure/autorest.typescript/issues/2898
-  parameters.parameters
-    .filter((p) => p.type === "cookie")
-    .forEach((p) => {
-      reportDiagnostic(dpgContext.program, {
-        code: "parameter-type-not-supported",
-        format: {
-          paramName: p.name,
-          paramType: p.type
-        },
-        target: NoTarget
-      });
-    });
-}
-
-function transformQueryParameters(
-  dpgContext: SdkContext,
-  parameters: HttpOperationParameters,
-  options: ParameterTransformationOptions
-): ParameterMetadata[] {
-  const queryParameters = parameters.parameters.filter(
-    (p) =>
-      p.type === "query" &&
-      !(
-        isApiVersion(dpgContext, p.param) &&
-        options.apiVersionInfo?.definedPosition === "query"
-      )
-  );
-  if (!queryParameters.length) {
-    return [];
-  }
-  return queryParameters.map((qp) =>
-    getParameterMetadata(dpgContext, "query", qp, options)
-  );
-}
-
-/**
- * Only support to take the global path parameter as path parameter
- * @returns
- */
-function transformPathParameters(
-  dpgContext: SdkContext,
-  parameters: HttpOperationParameters,
-  options: ParameterTransformationOptions
-) {
-  // build wrapper path parameters
-  const pathParameters = parameters.parameters.filter((p) => p.type === "path");
-  if (!pathParameters.length) {
-    return [];
-  }
-  // only need to build path parameters for wrapper type
-  const params = pathParameters
-    .map((qp) => getParameterMetadata(dpgContext, "path", qp, options))
-    .filter((p) => p.param.wrapperType);
-  return params;
-}
-
-export function transformHeaderParameters(
-  dpgContext: SdkContext,
-  parameters: HttpOperationParameters,
-  options: ParameterTransformationOptions
-): ParameterMetadata[] {
-  const headerParameters = parameters.parameters.filter(
-    (p) => p.type === "header"
-  );
-  if (!headerParameters.length) {
-    return [];
-  }
-  return headerParameters.map((qp) =>
-    getParameterMetadata(dpgContext, "header", qp, options)
-  );
-}
-
-function transformBodyParameters(
-  dpgContext: SdkContext,
-  parameters: HttpOperationParameters,
-  headers: ParameterMetadata[],
-  importedModels: Set<string>,
-  inputBodyType?: Type
-): ParameterBodyMetadata | undefined {
-  const bodyType =
-    parameters.body && inputBodyType ? inputBodyType : parameters.body?.type;
-  if (!bodyType || isVoidType(bodyType)) {
-    return;
-  }
-  return transformRequestBody(
-    dpgContext,
-    bodyType,
-    parameters,
-    importedModels,
-    headers
-  );
-}
-
-function transformRequestBody(
-  dpgContext: SdkContext,
-  bodyType: Type,
-  parameters: HttpOperationParameters,
-  importedModels: Set<string>,
-  headers: ParameterMetadata[]
-) {
-  const contentTypes = extractMediaTypes(parameters.body?.contentTypes ?? []);
-  const schema = getSchemaForType(dpgContext, bodyType, {
-    mediaTypes: contentTypes,
-    isRequestBody: true,
-    usage: [SchemaContext.Input, SchemaContext.Exception]
-  });
-
-  const descriptions = getBodyDescriptions(dpgContext, schema, parameters);
-  const type = getRequestBodyType(schema, importedModels, headers);
-
-  return {
-    isPartialBody: false,
-    body: [
-      {
-        properties: schema.properties,
-        typeName: schema.name,
-        name: "body",
-        type,
-        required: isBodyRequired(parameters),
-        description: descriptions.join("\n\n"),
-        isMultipartBody:
-          hasMediaType(KnownMediaType.MultipartFormData, contentTypes) &&
-          contentTypes.length === 1,
-        oriSchema: schema
-      }
-    ]
-  };
-}
-
-function getRequestBodyType(
-  bodySchema: Schema,
-  importedModels: Set<string>,
-  headers?: ParameterMetadata[]
-) {
-  const schemaUsage = [SchemaContext.Input, SchemaContext.Exception];
-  const importedNames = getImportedModelName(bodySchema, schemaUsage) ?? [];
-  importedNames.forEach(importedModels.add, importedModels);
-
-  let typeName = getTypeName(bodySchema, schemaUsage);
-  const contentTypes = headers
-    ?.filter((h) => h.name === "contentType")
-    .map((h) => h.param.type);
-  const hasMergeAndPatchType = isMediaTypeJsonMergePatch(contentTypes ?? []);
-  if (
-    hasMergeAndPatchType &&
-    Boolean(bodySchema.name) &&
-    (bodySchema as ObjectSchema).properties
-  ) {
-    typeName = `${typeName}ResourceMergeAndPatch`;
-  }
-  return typeName;
-}
-
-function getBodyDescriptions(
-  dpgContext: SdkContext,
-  bodySchema: Schema,
-  parameters: HttpOperationParameters
-) {
-  const description = parameters.body?.property
-    ? getFormattedPropertyDoc(
-        dpgContext.program,
-        parameters.body.property,
-        bodySchema
-      )
-    : "";
-  return description ? [description] : [];
-}

package/src/transform/transformPaths.ts

@@ -1,174 +0,0 @@
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-
-import { HttpOperation, HttpOperationParameters } from "@typespec/http";
-import {
-  Imports,
-  OperationMethod,
-  PathMetadata,
-  Paths,
-  SchemaContext,
-  getParameterTypeName,
-  getResponseTypeName
-} from "../rlc-common/index.js";
-import {
-  SdkClient,
-  getHttpOperationWithCache,
-  isApiVersion
-} from "@azure-tools/typespec-client-generator-core";
-import {
-  extractOperationLroDetail,
-  getOperationGroupName,
-  getOperationName,
-  getOperationResponseTypes,
-  getOperationStatuscode,
-  getOperationSuccessStatus,
-  isPagingOperation,
-  sortedOperationResponses
-} from "../utils/operationUtil.js";
-import {
-  getImportedModelName,
-  getSchemaForType,
-  isBodyRequired
-} from "../utils/modelUtils.js";
-
-import { SdkContext } from "../utils/interfaces.js";
-import { getDoc } from "@typespec/compiler";
-import { getParameterSerializationInfo } from "../utils/parameterUtils.js";
-import { listOperationsUnderRLCClient } from "../utils/clientUtils.js";
-
-export function transformPaths(
-  client: SdkClient,
-  dpgContext: SdkContext,
-  importDetails: Imports
-): Paths {
-  const pathParamsImportedSet = new Set<string>();
-  const paths: Paths = {};
-  for (const op of listOperationsUnderRLCClient(client)) {
-    const route = getHttpOperationWithCache(dpgContext, op);
-    // ignore overload base operation
-    if (route.overloads && route.overloads?.length > 0) {
-      continue;
-    }
-    transformOperation(dpgContext, route, paths, pathParamsImportedSet);
-  }
-
-  if (pathParamsImportedSet.size > 0) {
-    importDetails.rlcClientDefinition.importsSet = pathParamsImportedSet;
-  }
-
-  return paths;
-}
-
-function transformOperation(
-  dpgContext: SdkContext,
-  route: HttpOperation,
-  paths: Paths,
-  importSet: Set<string>
-) {
-  const program = dpgContext.program;
-  const respNames = [];
-  const operationGroupName = getOperationGroupName(dpgContext, route);
-  for (const resp of sortedOperationResponses(route.responses)) {
-    const respName = getResponseTypeName(
-      operationGroupName,
-      getOperationName(dpgContext, route.operation),
-      getOperationStatuscode(resp)
-    );
-    respNames.push(respName);
-  }
-  const responseTypes = getOperationResponseTypes(dpgContext, route);
-  const method: OperationMethod = {
-    description: getDoc(program, route.operation) ?? "",
-    hasOptionalOptions: !hasRequiredOptions(dpgContext, route.parameters),
-    optionsName: getParameterTypeName(
-      operationGroupName,
-      getOperationName(dpgContext, route.operation)
-    ),
-    responseTypes,
-    returnType: respNames.join(" | "),
-    successStatus: getOperationSuccessStatus(route),
-    operationName: getOperationName(dpgContext, route.operation),
-    operationHelperDetail: {
-      lroDetails: extractOperationLroDetail(
-        dpgContext,
-        route,
-        responseTypes,
-        operationGroupName
-      ),
-      isPaging: isPagingOperation(dpgContext, route)
-    }
-  };
-  if (
-    paths[route.path] !== undefined &&
-    !paths[route.path]?.methods[route.verb]
-  ) {
-    (paths[route.path] as PathMetadata).methods[route.verb] = [method];
-  } else if (paths[route.path]?.methods[route.verb]) {
-    paths[route.path]?.methods[route.verb]?.push(method);
-  } else {
-    paths[route.path] = {
-      description: getDoc(program, route.operation) ?? "",
-      name: escapeCoreName(
-        getOperationName(dpgContext, route.operation) || "Client"
-      ),
-      pathParameters: route.parameters.parameters
-        .filter((p) => p.type === "path")
-        .map((p) => {
-          const schemaUsage = [SchemaContext.Input, SchemaContext.Exception];
-          const options = {
-            usage: schemaUsage,
-            needRef: false,
-            relevantProperty: p.param
-          };
-          const schema = p.param.sourceProperty
-            ? getSchemaForType(
-                dpgContext,
-                p.param.sourceProperty?.type,
-
-                options
-              )
-            : getSchemaForType(dpgContext, p.param.type, options);
-          const importedNames = getImportedModelName(schema, schemaUsage) ?? [];
-          importedNames.forEach(importSet.add, importSet);
-          const serializationType = getParameterSerializationInfo(
-            dpgContext,
-            p,
-            schema,
-            operationGroupName,
-            method.operationName
-          );
-          return {
-            name: p.name,
-            type: serializationType.typeName,
-            description: getDoc(program, p.param) ?? "",
-            wrapperType: serializationType.wrapperType
-          };
-        }),
-      operationGroupName: getOperationGroupName(dpgContext, route),
-      methods: {
-        [route.verb]: [method]
-      }
-    };
-  }
-}
-
-function escapeCoreName(name: string) {
-  if (["client", "streamablemethod"].indexOf(name.toLowerCase()) > -1) {
-    return "_" + name;
-  }
-  return name;
-}
-function hasRequiredOptions(
-  dpgContext: SdkContext,
-  routeParameters: HttpOperationParameters
-) {
-  const isRequiredBodyParam = isBodyRequired(routeParameters);
-
-  const containsRequiredNonBodyParam = routeParameters.parameters
-    .filter((parameter) => ["query", "header"].includes(parameter.type))
-    .filter((parameter) => !isApiVersion(dpgContext, parameter.param))
-    .filter((parameter) => !!parameter.param)
-    .some((parameter) => parameter.param.optional === false);
-  return isRequiredBodyParam || containsRequiredNonBodyParam;
-}