@azure-tools/typespec-ts 0.11.0

package/src/transform/transformPaths.ts

@@ -0,0 +1,187 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+import {
+  getResponseTypeName,
+  getParameterTypeName,
+  PathMetadata,
+  Paths,
+  ResponseTypes,
+  OperationMethod
+} from "@azure-tools/rlc-common";
+import { getDoc, ignoreDiagnostics, Program } from "@typespec/compiler";
+import {
+  getHttpOperation,
+  HttpOperation,
+  HttpOperationParameters,
+  HttpOperationResponse
+} from "@typespec/http";
+import {
+  Client,
+  DpgContext,
+  listOperationGroups,
+  listOperationsInOperationGroup,
+  OperationGroup,
+  isApiVersion
+} from "@azure-tools/typespec-client-generator-core";
+import { getSchemaForType } from "../modelUtils.js";
+import {
+  getOperationGroupName,
+  getOperationStatuscode,
+  isDefaultStatusCode,
+  isDefinedStatusCode,
+  isLongRunningOperation,
+  isPagingOperation
+} from "../operationUtil.js";
+
+export function transformPaths(
+  program: Program,
+  client: Client,
+  dpgContext: DpgContext
+): Paths {
+  const operationGroups = listOperationGroups(dpgContext, client);
+  const paths: Paths = {};
+  for (const operationGroup of operationGroups) {
+    const operations = listOperationsInOperationGroup(
+      dpgContext,
+      operationGroup
+    );
+    for (const op of operations) {
+      const route = ignoreDiagnostics(getHttpOperation(program, op));
+      transformOperation(program, route, paths, dpgContext, operationGroup);
+    }
+  }
+  const clientOperations = listOperationsInOperationGroup(dpgContext, client);
+  for (const clientOp of clientOperations) {
+    const route = ignoreDiagnostics(getHttpOperation(program, clientOp));
+    transformOperation(program, route, paths, dpgContext);
+  }
+  return paths;
+}
+
+/**
+ * This function computes all the response types error and success
+ * an operation can end up returning.
+ */
+function getResponseTypes(
+  operation: HttpOperation,
+  operationGroup?: OperationGroup
+): ResponseTypes {
+  const returnTypes: ResponseTypes = {
+    error: [],
+    success: []
+  };
+  function getResponseType(responses: HttpOperationResponse[]) {
+    return responses
+      .filter((r) => r.statusCode && r.statusCode.length)
+      .map((r) => {
+        const statusCode = getOperationStatuscode(r);
+        const responseName = getResponseTypeName(
+          getOperationGroupName(operationGroup),
+          operation.operation.name,
+          statusCode
+        );
+        return responseName;
+      });
+  }
+  if (operation.responses && operation.responses.length) {
+    returnTypes.error = getResponseType(
+      operation.responses.filter((r) => isDefaultStatusCode(r.statusCode))
+    );
+    returnTypes.success = getResponseType(
+      operation.responses.filter((r) => isDefinedStatusCode(r.statusCode))
+    );
+  }
+  return returnTypes;
+}
+
+function transformOperation(
+  program: Program,
+  route: HttpOperation,
+  paths: Paths,
+  dpgContext: DpgContext,
+  operationGroup?: OperationGroup
+) {
+  const respNames = [];
+  for (const resp of route.responses) {
+    const respName = getResponseTypeName(
+      getOperationGroupName(operationGroup),
+      route.operation.name,
+      getOperationStatuscode(resp)
+    );
+    respNames.push(respName);
+  }
+  const method: OperationMethod = {
+    description: getDoc(program, route.operation) ?? "",
+    hasOptionalOptions: !hasRequiredOptions(dpgContext, route.parameters),
+    optionsName: getParameterTypeName(
+      getOperationGroupName(operationGroup),
+      route.operation.name
+    ),
+    responseTypes: getResponseTypes(route, operationGroup),
+    returnType: respNames.join(" | "),
+    successStatus: gerOperationSuccessStatus(route),
+    operationName: route.operation.name,
+    annotations: {
+      isLongRunning: isLongRunningOperation(program, route),
+      isPageable: isPagingOperation(program, 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: route.operation.name || "Client",
+      pathParameters: route.parameters.parameters
+        .filter((p) => p.type === "path")
+        .map((p) => {
+          return {
+            name: p.name,
+            type: p.param.sourceProperty
+              ? getSchemaForType(program, p.param.sourceProperty?.type).type
+              : getSchemaForType(program, p.param.type).type,
+            description: getDoc(program, p.param)
+          };
+        }),
+      operationGroupName: getOperationGroupName(operationGroup),
+      methods: {
+        [route.verb]: [method]
+      }
+    };
+  }
+}
+
+function hasRequiredOptions(
+  dpgContext: DpgContext,
+  routeParameters: HttpOperationParameters
+) {
+  const isRequiredBodyParam = routeParameters.bodyParameter?.optional === false;
+  const containsRequiredNonBodyParam = routeParameters.parameters
+    .filter((parameter) => ["query", "header"].includes(parameter.type))
+    .filter((parameter) => !isApiVersion(dpgContext, parameter))
+    .filter((parameter) => !!parameter.param)
+    .some((parameter) => parameter.param.optional === false);
+  return isRequiredBodyParam || containsRequiredNonBodyParam;
+}
+
+/**
+ * Extracts all success or defined status codes for a give operation
+ */
+export function gerOperationSuccessStatus(operation: HttpOperation): string[] {
+  const responses = operation.responses ?? [];
+  const status: string[] = [];
+
+  for (const response of responses) {
+    if (isDefinedStatusCode(response.statusCode)) {
+      status.push(response.statusCode);
+    }
+  }
+
+  return status;
+}

package/src/transform/transformResponses.ts

@@ -0,0 +1,190 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+import {
+  Client,
+  DpgContext,
+  listOperationGroups,
+  listOperationsInOperationGroup,
+  OperationGroup
+} from "@azure-tools/typespec-client-generator-core";
+import {
+  ResponseHeaderSchema,
+  ImportKind,
+  OperationResponse,
+  ResponseMetadata,
+  Schema,
+  SchemaContext
+} from "@azure-tools/rlc-common";
+import { Program, getDoc, ignoreDiagnostics } from "@typespec/compiler";
+import {
+  getHttpOperation,
+  HttpOperation,
+  HttpOperationResponse
+} from "@typespec/http";
+import {
+  getImportedModelName,
+  getTypeName,
+  getSchemaForType,
+  getBinaryType
+} from "../modelUtils.js";
+import {
+  getOperationGroupName,
+  getOperationStatuscode,
+  isBinaryPayload
+} from "../operationUtil.js";
+
+export function transformToResponseTypes(
+  program: Program,
+  importDetails: Map<ImportKind, Set<string>>,
+  client: Client,
+  dpgContext: DpgContext
+): OperationResponse[] {
+  const operationGroups = listOperationGroups(dpgContext, client);
+  const rlcResponses: OperationResponse[] = [];
+  const inputImportedSet = new Set<string>();
+  for (const operationGroup of operationGroups) {
+    const operations = listOperationsInOperationGroup(
+      dpgContext,
+      operationGroup
+    );
+    for (const op of operations) {
+      const route = ignoreDiagnostics(getHttpOperation(program, op));
+      transformToResponseTypesForRoute(route, operationGroup);
+    }
+  }
+  const clientOperations = listOperationsInOperationGroup(dpgContext, client);
+  for (const clientOp of clientOperations) {
+    const route = ignoreDiagnostics(getHttpOperation(program, clientOp));
+    transformToResponseTypesForRoute(route);
+  }
+  if (inputImportedSet.size > 0) {
+    importDetails.set(ImportKind.ResponseOutput, inputImportedSet);
+  }
+  function transformToResponseTypesForRoute(
+    route: HttpOperation,
+    operationGroup?: OperationGroup
+  ) {
+    const rlcOperationUnit: OperationResponse = {
+      operationGroup: getOperationGroupName(operationGroup),
+      operationName: route.operation.name,
+      responses: []
+    };
+    for (const resp of route.responses) {
+      const statusCode = getOperationStatuscode(resp);
+      const rlcResponseUnit: ResponseMetadata = {
+        statusCode,
+        description: resp.description
+      };
+      // transform header
+      const headers = transformHeaders(program, resp);
+      // transform body
+      const body = transformBody(program, resp, inputImportedSet);
+      rlcOperationUnit.responses.push({
+        ...rlcResponseUnit,
+        headers,
+        body
+      });
+    }
+    rlcResponses.push(rlcOperationUnit);
+  }
+  return rlcResponses;
+}
+
+/**
+ * Return undefined if no valid header param
+ * @param program the cadl program
+ * @param response response detail
+ * @returns rlc header shcema
+ */
+function transformHeaders(
+  program: Program,
+  response: HttpOperationResponse
+): ResponseHeaderSchema[] | undefined {
+  if (!response.responses.length) {
+    return;
+  }
+
+  const rlcHeaders = [];
+  // 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 (!headers || !Object.keys(headers).length) {
+      continue;
+    }
+
+    for (const [key, value] of Object.entries(headers)) {
+      if (!value) {
+        continue;
+      }
+      const typeSchema = getSchemaForType(program, value!.type, [
+        SchemaContext.Output
+      ]) as Schema;
+      const type = getTypeName(typeSchema);
+      const header: ResponseHeaderSchema = {
+        name: `"${key.toLowerCase()}"`,
+        type,
+        required: !value?.optional,
+        description: getDoc(program, value!)
+      };
+      rlcHeaders.push(header);
+    }
+  }
+
+  return rlcHeaders.length ? rlcHeaders : undefined;
+}
+
+function transformBody(
+  program: Program,
+  response: HttpOperationResponse,
+  importedModels: Set<string>
+) {
+  if (!response.responses.length) {
+    return;
+  }
+  // Currently RLC reponse 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;
+  for (const data of response.responses) {
+    const body = data?.body;
+    if (!body) {
+      continue;
+    }
+    const hasBinaryContent = body.contentTypes.some((contentType) =>
+      isBinaryPayload(body.type, contentType)
+    );
+    if (hasBinaryContent) {
+      typeSet.add(getBinaryType([SchemaContext.Output]));
+      descriptions.add("Value may contain any sequence of octets");
+      continue;
+    }
+    const bodySchema = getSchemaForType(program, body!.type, [
+      SchemaContext.Output
+    ]) as Schema;
+    if (bodySchema.fromCore) {
+      fromCore = true;
+    }
+    const bodyType = getTypeName(bodySchema);
+    const importedNames = getImportedModelName(bodySchema);
+    if (importedNames) {
+      importedNames.forEach(importedModels.add, importedModels);
+    }
+    typeSet.add(bodyType);
+  }
+
+  if (!typeSet.size) {
+    return;
+  }
+
+  return {
+    name: "body",
+    type: [...typeSet].join("|"),
+    description: [...descriptions].join("\n\n"),
+    fromCore
+  };
+}

package/src/transform/transformSchemas.ts

@@ -0,0 +1,209 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+import {
+  Client,
+  DpgContext,
+  listOperationGroups,
+  listOperationsInOperationGroup
+} from "@azure-tools/typespec-client-generator-core";
+import { SchemaContext } from "@azure-tools/rlc-common";
+import { ignoreDiagnostics, Model, Program, Type } from "@typespec/compiler";
+import { getHttpOperation, HttpOperation } from "@typespec/http";
+import {
+  getSchemaForType,
+  includeDerivedModel,
+  getBodyType
+} from "../modelUtils.js";
+
+export function transformSchemas(
+  program: Program,
+  client: Client,
+  dpgContext: DpgContext
+) {
+  const schemas: Map<string, SchemaContext[]> = new Map<
+    string,
+    SchemaContext[]
+  >();
+  const schemaMap: Map<any, any> = new Map<any, any>();
+  const operationGroups = listOperationGroups(dpgContext, client);
+  const modelKey = Symbol("typescript-models-" + client.name);
+  for (const operationGroup of operationGroups) {
+    const operations = listOperationsInOperationGroup(
+      dpgContext,
+      operationGroup
+    );
+    for (const op of operations) {
+      const route = ignoreDiagnostics(getHttpOperation(program, op));
+      transformSchemaForRoute(route);
+    }
+  }
+  const clientOperations = listOperationsInOperationGroup(dpgContext, client);
+  for (const clientOp of clientOperations) {
+    const route = ignoreDiagnostics(getHttpOperation(program, clientOp));
+    transformSchemaForRoute(route);
+  }
+  function transformSchemaForRoute(route: HttpOperation) {
+    const bodyModel = getBodyType(program, route);
+    if (bodyModel && bodyModel.kind === "Model") {
+      getGeneratedModels(bodyModel, SchemaContext.Input);
+    }
+    for (const resp of route.responses) {
+      if (
+        resp.type.kind === "Model" &&
+        resp.type.name === "ErrorResponse" &&
+        resp.type.namespace?.name === "Foundations" &&
+        resp.type.namespace.namespace?.name === "Core"
+      ) {
+        continue;
+      }
+      for (const resps of resp.responses) {
+        const respModel = resps.body;
+        if (!respModel) {
+          continue;
+        }
+        getGeneratedModels(respModel.type, SchemaContext.Output);
+      }
+    }
+  }
+  program.stateMap(modelKey).forEach((context, cadlModel) => {
+    const model = getSchemaForType(program, cadlModel, context);
+    if (model) {
+      model.usage = context;
+    }
+    if (model.name === "") {
+      return;
+    }
+    const pureModel = JSON.stringify(trimUsage(model));
+    schemaMap.set(pureModel, model);
+    let usage = schemas.get(pureModel) ?? [];
+    if (!usage?.includes(context)) {
+      usage = usage.concat(context as SchemaContext[]);
+    }
+    schemas.set(pureModel, usage);
+  });
+  function trimUsage(model: any) {
+    if (typeof model !== "object") {
+      return model;
+    }
+    const tmpModel = Object.assign({}, model);
+    const tmpModelKeys = Object.keys(tmpModel).filter((item) => {
+      return item !== "usage";
+    });
+    const ordered = tmpModelKeys.sort().reduce((obj, key) => {
+      (obj as any)[key] = trimUsage(tmpModel[key]);
+      return obj;
+    }, {});
+    return ordered;
+  }
+  function setModelMap(type: Type, schemaContext: SchemaContext) {
+    if (program.stateMap(modelKey).get(type)) {
+      const context = program.stateMap(modelKey).get(type);
+      if (context && context.indexOf(schemaContext) === -1) {
+        context.push(schemaContext);
+        program.stateMap(modelKey).set(type, context);
+      }
+    } else {
+      program.stateMap(modelKey).set(type, [schemaContext]);
+    }
+  }
+  function getGeneratedModels(model: Type, context: SchemaContext) {
+    if (model.kind === "Model") {
+      if (model.templateArguments && model.templateArguments.length > 0) {
+        for (const temp of model.templateArguments) {
+          if (
+            !program.stateMap(modelKey).get(temp) ||
+            !program.stateMap(modelKey).get(temp)?.includes(context)
+          ) {
+            getGeneratedModels(temp, context);
+            break;
+          }
+        }
+      }
+
+      setModelMap(model, context);
+      const indexer = (model as Model).indexer;
+      if (indexer?.value && !program.stateMap(modelKey).get(indexer?.value)) {
+        setModelMap(indexer.value, context);
+      }
+      for (const prop of model.properties) {
+        if (
+          prop[1].type.kind === "Model" &&
+          (!program.stateMap(modelKey).get(prop[1].type) ||
+            !program.stateMap(modelKey).get(prop[1].type)?.includes(context))
+        ) {
+          if (prop[1].type.name === "Error") {
+            continue;
+          }
+          getGeneratedModels(prop[1].type, context);
+        }
+        if (
+          prop[1].type.kind === "Union" &&
+          (!program.stateMap(modelKey).get(prop[1].type) ||
+            !program.stateMap(modelKey).get(prop[1].type)?.includes(context))
+        ) {
+          const variants = Array.from(prop[1].type.variants.values());
+          let hasModels = false;
+          for (const variant of variants) {
+            if (
+              (variant.type.kind === "Model" ||
+                variant.type.kind === "Union") &&
+              (!program.stateMap(modelKey).get(variant.type) ||
+                !program
+                  .stateMap(modelKey)
+                  .get(variant.type)
+                  ?.includes(context))
+            ) {
+              hasModels = true;
+              getGeneratedModels(variant.type, context);
+            }
+          }
+          if (hasModels) {
+            setModelMap(prop[1].type, context);
+          }
+        }
+      }
+      const baseModel = model.baseModel;
+      if (
+        baseModel &&
+        baseModel.kind === "Model" &&
+        (!program.stateMap(modelKey).get(baseModel) ||
+          !program.stateMap(modelKey).get(baseModel)?.includes(context))
+      ) {
+        getGeneratedModels(baseModel, context);
+      }
+      const derivedModels = model.derivedModels.filter(includeDerivedModel);
+
+      // getSchemaOrRef on all children to push them into components.schemas
+      for (const child of derivedModels) {
+        if (
+          child.kind === "Model" &&
+          (!program.stateMap(modelKey).get(child) ||
+            !program.stateMap(modelKey).get(child)?.includes(context))
+        ) {
+          getGeneratedModels(child, context);
+        }
+      }
+    } else if (model.kind === "Union") {
+      const variants = Array.from(model.variants.values());
+      let hasModels = false;
+      for (const variant of variants) {
+        if (
+          (variant.type.kind === "Model" || variant.type.kind === "Union") &&
+          (!program.stateMap(modelKey).get(variant.type) ||
+            !program.stateMap(modelKey).get(variant.type)?.includes(context))
+        ) {
+          hasModels = true;
+          getGeneratedModels(variant.type, context);
+        }
+      }
+      if (hasModels) {
+        setModelMap(model, context);
+      }
+    }
+  }
+  const allSchemas = Array.from(schemas, function (item) {
+    return { ...schemaMap.get(item[0]), usage: item[1] };
+  });
+  return allSchemas;
+}