@azure-tools/typespec-ts 0.11.0-alpha.20230413.3

package/src/transform/transformResponses.ts

@@ -0,0 +1,190 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+import {
+  SdkClient,
+  SdkContext,
+  listOperationGroups,
+  listOperationsInOperationGroup,
+  SdkOperationGroup
+} 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: SdkClient,
+  dpgContext: SdkContext
+): 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?: SdkOperationGroup
+  ) {
+    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,197 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+import {
+  SdkClient,
+  SdkContext,
+  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,
+  trimUsage
+} from "../modelUtils.js";
+
+export function transformSchemas(
+  program: Program,
+  client: SdkClient,
+  dpgContext: SdkContext
+) {
+  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 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;
+}

package/src/transform/transfromRLCOptions.ts

@@ -0,0 +1,202 @@
+import {
+  SdkContext,
+  listClients
+} from "@azure-tools/typespec-client-generator-core";
+import {
+  NameType,
+  normalizeName,
+  PackageDetails,
+  RLCOptions,
+  ServiceInfo
+} from "@azure-tools/rlc-common";
+import { getDoc, NoTarget, Program } from "@typespec/compiler";
+import { getAuthentication } from "@typespec/http";
+import { reportDiagnostic } from "../lib.js";
+import { getDefaultService } from "../modelUtils.js";
+
+export function transformRLCOptions(
+  program: Program,
+  emitterOptions: RLCOptions,
+  emitterOutputDir: string,
+  dpgContext: SdkContext
+): RLCOptions {
+  // Extract the options from emitter option
+  const options = extractRLCOptions(program, emitterOptions, emitterOutputDir);
+  const batch = listClients(dpgContext);
+  options.batch = batch;
+  return options;
+}
+
+function extractRLCOptions(
+  program: Program,
+  emitterOptions: RLCOptions,
+  emitterOutputDir: string
+): RLCOptions {
+  const includeShortcuts = getIncludeShortcuts(emitterOptions);
+  const packageDetails = getPackageDetails(program, emitterOptions);
+  const serviceInfo = getServiceInfo(program);
+  const azureSdkForJs = getAzureSdkForJs(emitterOptions);
+  const generateMetadata = getGenerateMetadata(emitterOptions);
+  const generateTest = getGenerateTest(emitterOptions);
+  const credentialInfo = getCredentialInfo(program, emitterOptions);
+  const azureOutputDirectory = getAzureOutputDirectory(emitterOutputDir);
+  return {
+    ...emitterOptions,
+    ...credentialInfo,
+    includeShortcuts,
+    packageDetails,
+    generateMetadata,
+    generateTest,
+    azureSdkForJs,
+    serviceInfo,
+    azureOutputDirectory,
+    sourceFrom: "Cadl"
+  };
+}
+
+function processAuth(program: Program) {
+  const serviceNs = getDefaultService(program)?.type;
+  if (!serviceNs) {
+    return undefined;
+  }
+  const authorization = getAuthentication(program, serviceNs);
+  if (!authorization || !authorization.options) {
+    return undefined;
+  }
+  const securityInfo: RLCOptions = {};
+  for (const option of authorization.options) {
+    for (const auth of option.schemes) {
+      switch (auth.type) {
+        case "http":
+          break;
+        case "apiKey":
+          if (auth.in === "cookie") {
+            return undefined;
+          }
+          securityInfo.addCredentials = true;
+          securityInfo.credentialKeyHeaderName = auth.name;
+          break;
+        case "oauth2": {
+          const flow = auth.flows[0];
+          if (flow === undefined || !flow.scopes) {
+            return undefined;
+          }
+          securityInfo.addCredentials = true;
+          if (!securityInfo.credentialScopes) {
+            securityInfo.credentialScopes = [];
+          }
+          if (flow.scopes.length === 0) {
+            reportDiagnostic(program, {
+              code: "no-credential-scopes",
+              target: NoTarget
+            });
+          }
+          securityInfo.credentialScopes.push(
+            ...flow.scopes.map((item) => {
+              return item.value;
+            })
+          );
+          break;
+        }
+        default:
+          break;
+      }
+    }
+  }
+  return securityInfo;
+}
+
+function getIncludeShortcuts(emitterOptions: RLCOptions) {
+  return Boolean(emitterOptions.includeShortcuts);
+}
+
+function getPackageDetails(
+  program: Program,
+  emitterOptions: RLCOptions
+): PackageDetails {
+  const packageDetails: PackageDetails = {
+    ...emitterOptions.packageDetails,
+    name:
+      emitterOptions.packageDetails?.name ??
+      normalizeName(
+        emitterOptions?.title ?? getDefaultService(program)?.title ?? "",
+        NameType.Class
+      ),
+    version: emitterOptions.packageDetails?.version ?? "1.0.0-beta.1"
+  };
+  if (emitterOptions.packageDetails?.name) {
+    const nameParts = emitterOptions.packageDetails?.name.split("/");
+    if (nameParts.length === 2) {
+      packageDetails.nameWithoutScope = nameParts[1];
+      packageDetails.scopeName = nameParts[0]?.replace("@", "");
+    }
+  }
+  return packageDetails;
+}
+
+function getServiceInfo(program: Program): ServiceInfo {
+  const defaultService = getDefaultService(program);
+  return {
+    title: defaultService?.title,
+    description: defaultService && getDoc(program, defaultService.type)
+  };
+}
+
+function getAzureSdkForJs(emitterOptions: RLCOptions) {
+  return emitterOptions.azureSdkForJs === undefined ||
+    emitterOptions.azureSdkForJs === null
+    ? true
+    : Boolean(emitterOptions.azureSdkForJs);
+}
+
+function getGenerateMetadata(emitterOptions: RLCOptions) {
+  return emitterOptions.generateMetadata === undefined ||
+    emitterOptions.generateMetadata === null
+    ? true
+    : Boolean(emitterOptions.generateMetadata);
+}
+
+function getGenerateTest(emitterOptions: RLCOptions) {
+  return emitterOptions.generateTest === undefined ||
+    emitterOptions.generateTest === null
+    ? true
+    : Boolean(emitterOptions.generateTest);
+}
+
+export function getCredentialInfo(
+  program: Program,
+  emitterOptions: RLCOptions
+) {
+  const securityInfo = processAuth(program);
+  const addCredentials =
+    !securityInfo && emitterOptions.addCredentials === false
+      ? false
+      : securityInfo
+      ? securityInfo.addCredentials
+      : emitterOptions.addCredentials;
+  const credentialScopes =
+    securityInfo && securityInfo.credentialScopes
+      ? securityInfo.credentialScopes
+      : emitterOptions.credentialScopes;
+  const credentialKeyHeaderName =
+    securityInfo && securityInfo.credentialKeyHeaderName
+      ? securityInfo.credentialKeyHeaderName
+      : emitterOptions.credentialKeyHeaderName;
+  return {
+    addCredentials,
+    credentialScopes,
+    credentialKeyHeaderName
+  };
+}
+
+function getAzureOutputDirectory(emitterOutputDir: string): string | undefined {
+  const sdkFolder = emitterOutputDir;
+  const sdkReletivePath = sdkFolder
+    ?.replace(/\/$/, "")
+    .split("/")
+    .slice(-3)
+    .join("/");
+  return sdkReletivePath?.substring(0, 3) === "sdk"
+    ? sdkReletivePath
+    : undefined;
+}

package/test/commands/cadl-ranch-list.ts

@@ -0,0 +1,111 @@
+export interface CadlRanchConfig {
+  outputPath: string;
+  inputPath: string;
+}
+
+export const cadls: CadlRanchConfig[] = [
+  {
+    outputPath: "arrays/itemTypes",
+    inputPath: "arrays/item-types"
+  },
+  {
+    outputPath: "authentication/apiKey",
+    inputPath: "authentication/api-key"
+  },
+  {
+    outputPath: "authentication/oauth2",
+    inputPath: "authentication/oauth2"
+  },
+  {
+    outputPath: "authentication/union",
+    inputPath: "authentication/union"
+  },
+  {
+    outputPath: "dictionary",
+    inputPath: "dictionary"
+  },
+  {
+    outputPath: "enums/extensible",
+    inputPath: "enums/extensible"
+  },
+  {
+    outputPath: "enums/fixed",
+    inputPath: "enums/fixed"
+  },
+  {
+    outputPath: "hello",
+    inputPath: "hello"
+  },
+  {
+    outputPath: "lro/lroBasic",
+    inputPath: "lro/lro-basic"
+  },
+  {
+    outputPath: "lro/lroCore",
+    inputPath: "lro/lro-core"
+  },
+  {
+    outputPath: "models/inheritance",
+    inputPath: "models/inheritance"
+  },
+  {
+    outputPath: "models/propertyOptional",
+    inputPath: "models/property-optional"
+  },
+  {
+    outputPath: "models/propertyNullable",
+    inputPath: "models/property-nullable"
+  },
+  {
+    outputPath: "models/propertyTypes",
+    inputPath: "models/property-types"
+  },
+  {
+    outputPath: "models/visibility",
+    inputPath: "models/visibility"
+  },
+  {
+    outputPath: "models/usage",
+    inputPath: "models/usage"
+  },
+  {
+    outputPath: "resiliency/devDriven",
+    inputPath: "resiliency/dev-driven"
+  },
+  {
+    outputPath: "resiliency/srvDriven1",
+    inputPath: "resiliency/srv-driven-1"
+  },
+  {
+    outputPath: "resiliency/srvDriven2",
+    inputPath: "resiliency/srv-driven-2"
+  },
+  {
+    outputPath: "specialWords",
+    inputPath: "special-words"
+  },
+  {
+    outputPath: "unions",
+    inputPath: "unions"
+  },
+  {
+    outputPath: "parameters/collection-format",
+    inputPath: "parameters/collection-format"
+  },
+  {
+    outputPath: "projection",
+    inputPath: "projection"
+  },
+  {
+    outputPath: "internal",
+    inputPath: "internal"
+  },
+  {
+    outputPath: "server/path/single",
+    inputPath: "server/path/single"
+  },
+  {
+    outputPath: "server/path/multiple",
+    inputPath: "server/path/multiple"
+  }
+];