@azure-tools/typespec-ts 0.54.0 → 0.54.2

package/src/transform/transformResponses.ts

@@ -1,244 +0,0 @@
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-
-import {
-  getLroLogicalResponseName,
-  Imports,
-  OperationResponse,
-  ResponseHeaderSchema,
-  ResponseMetadata,
-  Schema,
-  SchemaContext
-} from "../rlc-common/index.js";
-import {
-  getHttpOperationWithCache,
-  SdkClient
-} from "@azure-tools/typespec-client-generator-core";
-import { getDoc, isVoidType } from "@typespec/compiler";
-import { HttpOperation, HttpOperationResponse } from "@typespec/http";
-import { SdkContext } from "../utils/interfaces.js";
-import {
-  getBinaryType,
-  getImportedModelName,
-  getSchemaForType,
-  getTypeName
-} from "../utils/modelUtils.js";
-import {
-  getOperationGroupName,
-  getOperationLroOverload,
-  getOperationName,
-  getOperationStatuscode,
-  isBinaryPayload,
-  sortedOperationResponses
-} from "../utils/operationUtil.js";
-import { listOperationsUnderRLCClient } from "../utils/clientUtils.js";
-
-export function transformToResponseTypes(
-  client: SdkClient,
-  dpgContext: SdkContext,
-  importDetails: Imports
-): OperationResponse[] {
-  const rlcResponses: OperationResponse[] = [];
-  const inputImportedSet = 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;
-    }
-    transformToResponseTypesForRoute(route);
-  }
-  if (inputImportedSet.size > 0) {
-    importDetails.response.importsSet = inputImportedSet;
-  }
-  function transformToResponseTypesForRoute(route: HttpOperation) {
-    const rlcOperationUnit: OperationResponse = {
-      operationGroup: getOperationGroupName(dpgContext, route),
-      operationName: getOperationName(dpgContext, route.operation),
-      path: route.path,
-      responses: []
-    };
-    const defaultSchemas: Schema[] = [],
-      nonDefaultSchemas: Schema[] = [];
-    for (const resp of sortedOperationResponses(route.responses)) {
-      const statusCode = getOperationStatuscode(resp);
-      const rlcResponseUnit: ResponseMetadata = {
-        statusCode,
-        description: resp.description
-      };
-      // transform header
-      const headers = transformHeaders(dpgContext, resp, inputImportedSet);
-      // transform body
-      const [body, schemas] = transformBody(
-        dpgContext,
-        resp,
-        inputImportedSet
-      ) ?? [undefined, []];
-      rlcOperationUnit.responses.push({
-        ...rlcResponseUnit,
-        headers,
-        body
-      });
-      if (statusCode === "default") {
-        defaultSchemas.push(...schemas);
-      } else {
-        nonDefaultSchemas.push(...schemas);
-      }
-    }
-    const lroLogicalResponse = transformLroLogicalResponse(
-      dpgContext,
-      route,
-      getOperationGroupName(dpgContext, route),
-      rlcOperationUnit.responses
-    );
-    if (lroLogicalResponse) {
-      rlcOperationUnit.responses.push(lroLogicalResponse);
-    }
-    rlcResponses.push(rlcOperationUnit);
-  }
-  return rlcResponses;
-}
-
-/**
- * Return undefined if no valid header param
- * @param response response detail
- * @returns rlc header schema
- */
-function transformHeaders(
-  dpgContext: SdkContext,
-  response: HttpOperationResponse,
-  importedModels: Set<string>
-): ResponseHeaderSchema[] | undefined {
-  if (!response.responses.length) {
-    return;
-  }
-
-  const rlcHeaders: Map<string, ResponseHeaderSchema> = new Map();
-  // Current RLC client can't represent different headers per content type.
-  // So we merge headers here, and report any duplicates.
-  // It may be possible in principle to not error for identically declared
-  // headers.
-  for (const data of response.responses) {
-    const headers = data?.headers ?? {};
-    if (data.body?.contentTypeProperty) {
-      headers["content-type"] = data.body?.contentTypeProperty;
-    }
-    if (!headers || !Object.keys(headers).length) {
-      continue;
-    }
-
-    for (const [key, value] of Object.entries(headers)) {
-      if (!value) {
-        continue;
-      }
-      const typeSchema = getSchemaForType(dpgContext, value!.type, {
-        usage: [SchemaContext.Output],
-        relevantProperty: value
-      }) as Schema;
-      const type = getTypeName(typeSchema, [SchemaContext.Output]);
-      getImportedModelName(typeSchema, [SchemaContext.Output])?.forEach(
-        importedModels.add,
-        importedModels
-      );
-      const header: ResponseHeaderSchema = {
-        name: `"${key.toLowerCase()}"`,
-        type,
-        required: !value?.optional,
-        description: getDoc(dpgContext.program, value!)
-      };
-      rlcHeaders.set(header.name, header);
-    }
-  }
-
-  return rlcHeaders.size ? Array.from(rlcHeaders.values()) : undefined;
-}
-
-function transformBody(
-  dpgContext: SdkContext,
-  response: HttpOperationResponse,
-  importedModels: Set<string>
-): [Schema, Schema[]] | undefined {
-  if (!response.responses.length) {
-    return;
-  }
-  // Currently RLC response only have one header and body defined
-  // So we'll union all body shapes together with "|"
-  const typeSet = new Set<string>();
-  const descriptions = new Set<string>();
-  let fromCore = false;
-  const schemas = [];
-  for (const data of response.responses) {
-    const body = data?.body;
-    if (!body || isVoidType(body.type)) {
-      continue;
-    }
-    const hasBinaryContent = body.contentTypes.some((contentType) =>
-      isBinaryPayload(dpgContext, body.type, contentType)
-    );
-    if (hasBinaryContent) {
-      typeSet.add(getBinaryType([SchemaContext.Output]));
-      descriptions.add("Value may contain any sequence of octets");
-      continue;
-    }
-    const bodySchema = getSchemaForType(dpgContext, body!.type, {
-      usage: [SchemaContext.Output]
-    }) as Schema;
-    fromCore = bodySchema.fromCore ?? false;
-    const bodyType = getTypeName(bodySchema);
-    const importedNames = getImportedModelName(bodySchema);
-    if (importedNames && !fromCore) {
-      importedNames
-        .filter((name) => {
-          return name !== "any";
-        })
-        .forEach(importedModels.add, importedModels);
-    }
-    typeSet.add(bodyType);
-    schemas.push(bodySchema);
-  }
-
-  if (!typeSet.size) {
-    return;
-  }
-
-  return [
-    {
-      name: "body",
-      type: [...typeSet].join("|"),
-      description: [...descriptions].join("\n\n"),
-      fromCore
-    },
-    schemas
-  ];
-}
-
-function transformLroLogicalResponse(
-  dpgContext: SdkContext,
-  route: HttpOperation,
-  operationGroupName: string,
-  existingResponses: ResponseMetadata[]
-): ResponseMetadata | undefined {
-  const operationLroOverload = getOperationLroOverload(
-    dpgContext.program,
-    route,
-    undefined,
-    existingResponses
-  );
-  if (!operationLroOverload) {
-    return;
-  }
-  const sortedResponses = existingResponses
-    .filter((r) => r.statusCode.startsWith("20"))
-    .sort((r1, r2) => (r1.statusCode > r2.statusCode ? 1 : -1));
-  const successResp = sortedResponses[0];
-  const logicalLROResponse: ResponseMetadata = {
-    statusCode: "200",
-    description: `The final response for long-running ${route.operation.name} operation`,
-    predefinedName: getLroLogicalResponseName(
-      operationGroupName,
-      getOperationName(dpgContext, route.operation)
-    ),
-    body: successResp?.body
-  };
-  return logicalLROResponse;
-}

package/src/transform/transformSchemas.ts

@@ -1,230 +0,0 @@
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-
-import { HttpOperation, getServers } from "@typespec/http";
-import { KnownMediaType, extractMediaTypes } from "../utils/mediaTypes.js";
-import { Model, Type } from "@typespec/compiler";
-import {
-  SdkClient,
-  getHttpOperationWithCache
-} from "@azure-tools/typespec-client-generator-core";
-import {
-  getBodyType,
-  getDefaultService,
-  getSchemaForType,
-  includeDerivedModel,
-  isAzureCoreErrorType,
-  trimUsage
-} from "../utils/modelUtils.js";
-
-import { SchemaContext } from "../rlc-common/index.js";
-import { SdkContext } from "../utils/interfaces.js";
-import { useContext } from "../contextManager.js";
-import { listOperationsUnderRLCClient } from "../utils/clientUtils.js";
-
-export function transformSchemas(client: SdkClient, dpgContext: SdkContext) {
-  const program = dpgContext.program;
-  const metatree = useContext("rlcMetaTree");
-  const schemas: Map<string, SchemaContext[]> = new Map<
-    string,
-    SchemaContext[]
-  >();
-  const schemaMap: Map<any, any> = new Map<any, any>();
-  const usageMap = new Map<Type, SchemaContext[]>();
-  const requestBodySet = new Set<Type>();
-  const contentTypeMap = new Map<Type, KnownMediaType[]>();
-  for (const op of listOperationsUnderRLCClient(client)) {
-    const route = getHttpOperationWithCache(dpgContext, op);
-    // ignore overload base operation
-    if (route.overloads && route.overloads?.length > 0) {
-      continue;
-    }
-    transformSchemaForRoute(route);
-  }
-  function transformSchemaForRoute(route: HttpOperation) {
-    if (route.parameters) {
-      for (const param of route.parameters.parameters) {
-        getGeneratedModels(param.param, SchemaContext.Input);
-      }
-    }
-    const bodyModel = getBodyType(route);
-    if (
-      bodyModel &&
-      (bodyModel.kind === "Model" ||
-        bodyModel.kind === "Union" ||
-        bodyModel.kind === "Enum")
-    ) {
-      requestBodySet.add(bodyModel);
-      const contentTypes: KnownMediaType[] = extractMediaTypes(
-        route.parameters.body?.contentTypes ?? []
-      );
-      if (contentTypes.length > 0) {
-        contentTypeMap.set(bodyModel, contentTypes);
-      }
-      getGeneratedModels(bodyModel, SchemaContext.Input);
-    }
-    for (const resp of route.responses) {
-      if (isAzureCoreErrorType(dpgContext.program, resp.type)) {
-        continue;
-      }
-      for (const resps of resp.responses) {
-        const headers = resps?.headers;
-        if (headers && Object.keys(headers).length) {
-          for (const value of Object.values(headers)) {
-            getGeneratedModels(value, SchemaContext.Output);
-          }
-        }
-        if (resps.body?.contentTypeProperty) {
-          getGeneratedModels(
-            resps.body.contentTypeProperty,
-            SchemaContext.Output
-          );
-        }
-        const respModel = resps?.body?.type;
-        if (!respModel) {
-          continue;
-        }
-        getGeneratedModels(respModel, SchemaContext.Output);
-      }
-    }
-  }
-  function transformHostParameters() {
-    const serviceNs = getDefaultService(
-      program,
-      dpgContext.rlcOptions?.isModularLibrary
-    )?.type;
-    if (serviceNs) {
-      const host = getServers(program, serviceNs);
-      if (host && host?.[0] && host?.[0]?.parameters) {
-        for (const key of host[0].parameters.keys()) {
-          const type = host?.[0]?.parameters.get(key)?.type;
-          if (!type) {
-            continue;
-          }
-          getGeneratedModels(type, SchemaContext.Input);
-        }
-      }
-    }
-  }
-  transformHostParameters();
-  usageMap.forEach((context, tspModel) => {
-    const model = getSchemaForType(dpgContext, tspModel, {
-      usage: context,
-      isRequestBody: requestBodySet.has(tspModel),
-      isParentRequestBody: false,
-      mediaTypes: contentTypeMap.get(tspModel)
-    });
-    if (model) {
-      model.usage = context;
-    }
-    metatree.set(tspModel, { rlcType: model });
-    if (model.name === "") {
-      return;
-    }
-    const pureModel = JSON.stringify(trimUsage(model));
-    schemaMap.set(pureModel, model);
-    const usageSet = new Set((schemas.get(pureModel) ?? []).concat(context));
-    schemas.set(pureModel, Array.from(usageSet));
-  });
-
-  function setModelMap(type: Type, schemaContext: SchemaContext) {
-    if (usageMap.get(type)) {
-      const context = usageMap.get(type);
-      if (context && context.indexOf(schemaContext) === -1) {
-        context.push(schemaContext);
-        usageMap.set(type, context);
-      }
-    } else {
-      usageMap.set(type, [schemaContext]);
-    }
-  }
-  function getGeneratedModels(model: Type, context: SchemaContext) {
-    if (model.kind === "Model") {
-      setModelMap(model, context);
-      const indexer = (model as Model).indexer;
-      if (
-        indexer?.value &&
-        (!usageMap.get(indexer?.value) ||
-          !usageMap.get(indexer?.value)?.includes(context))
-      ) {
-        getGeneratedModels(indexer.value, context);
-      }
-      for (const prop of model.properties) {
-        const [, propType] = prop;
-        if (usageMap.get(propType.type)?.includes(context)) {
-          continue;
-        }
-        if (propType.type.kind === "Model") {
-          if (isAzureCoreErrorType(dpgContext.program, propType.type)) {
-            continue;
-          }
-          getGeneratedModels(propType.type, context);
-        } else if (propType.type.kind === "Union") {
-          const variants = Array.from(propType.type.variants.values());
-          for (const variant of variants) {
-            if (
-              (variant.type.kind === "Model" ||
-                variant.type.kind === "Union" ||
-                variant.type.kind === "Enum") &&
-              (!usageMap.get(variant.type) ||
-                !usageMap.get(variant.type)?.includes(context))
-            ) {
-              getGeneratedModels(variant.type, context);
-            }
-          }
-          // build type details for named union
-          if (!propType.type.expression) {
-            setModelMap(propType.type, context);
-          }
-        } else if (propType.type.kind === "Enum") {
-          getGeneratedModels(propType.type, context);
-        }
-      }
-      const baseModel = model.baseModel;
-      if (
-        baseModel &&
-        baseModel.kind === "Model" &&
-        (!usageMap.get(baseModel) ||
-          !usageMap.get(baseModel)?.includes(context))
-      ) {
-        getGeneratedModels(baseModel, context);
-      }
-      const derivedModels = model.derivedModels.filter((dm) => {
-        return includeDerivedModel(dm);
-      });
-
-      // getSchemaOrRef on all children to push them into components.schemas
-      for (const child of derivedModels) {
-        if (
-          child.kind === "Model" &&
-          (!usageMap.get(child) || !usageMap.get(child)?.includes(context))
-        ) {
-          getGeneratedModels(child, context);
-        }
-      }
-    } else if (model.kind === "Union") {
-      const variants = Array.from(model.variants.values());
-      for (const variant of variants) {
-        if (
-          (variant.type.kind === "Model" || variant.type.kind === "Union") &&
-          (!usageMap.get(variant.type) ||
-            !usageMap.get(variant.type)?.includes(context))
-        ) {
-          getGeneratedModels(variant.type, context);
-        }
-      }
-      // build type details for named union
-      if (!model.expression) {
-        setModelMap(model, context);
-      }
-    } else if (model.kind === "ModelProperty") {
-      getGeneratedModels(model.type, context);
-    } else if (model.kind === "Enum") {
-      setModelMap(model, context);
-    }
-  }
-  const allSchemas = Array.from(schemas, function (item) {
-    return { ...schemaMap.get(item[0]), usage: item[1] };
-  });
-  return allSchemas;
-}

package/src/transform/transformTelemetryInfo.ts

@@ -1,39 +0,0 @@
-import { TelemetryInfo } from "../rlc-common/index.js";
-import {
-  getHttpOperationWithCache,
-  SdkClient,
-  SdkContext
-} from "@azure-tools/typespec-client-generator-core";
-import { getCustomRequestHeaderNameForOperation } from "../utils/operationUtil.js";
-import { listOperationsUnderRLCClient } from "../utils/clientUtils.js";
-
-export function transformTelemetryInfo(
-  client: SdkClient,
-  dpgContext: SdkContext
-): TelemetryInfo | undefined {
-  const customRequestIdHeaderName = getCustomRequestHeaderNameForClient(
-    dpgContext,
-    client
-  );
-  if (customRequestIdHeaderName) {
-    return {
-      customRequestIdHeaderName
-    };
-  }
-  return undefined;
-}
-
-function getCustomRequestHeaderNameForClient(
-  dpgContext: SdkContext,
-  client: SdkClient
-) {
-  for (const op of listOperationsUnderRLCClient(client)) {
-    const headerName = getCustomRequestHeaderNameForOperation(
-      getHttpOperationWithCache(dpgContext, op)
-    );
-    if (headerName !== undefined) {
-      return headerName;
-    }
-  }
-  return undefined;
-}