@azure-tools/typespec-ts 0.14.0 → 0.15.0-alpha.20230822.1

package/src/modular/helpers/operationHelpers.ts

@@ -6,6 +6,7 @@ import {
 import { toPascalCase } from "../../utils/casingUtils.js";
 import {
   BodyParameter,
+  ModularCodeModel,
   Operation,
   Parameter,
   Property,
@@ -20,7 +21,14 @@ import {
   normalizeName
 } from "@azure-tools/rlc-common";
 import { getOperationName } from "./namingHelpers.js";
-import { getFixmeForMultilineDocs } from "./fixmeHelpers.js";
+import {
+  getFixmeForMultilineDocs,
+  getDocsFromDescription
+} from "./docsHelpers.js";
+import {
+  getCollectionFormatHelper,
+  hasCollectionFormatInfo
+} from "../../utils/operationUtil.js";
 
 function getRLCResponseType(rlcResponse?: OperationResponse) {
   if (!rlcResponse?.responses) {
@@ -41,11 +49,9 @@ function getRLCResponseType(rlcResponse?: OperationResponse) {
 
 export function getSendPrivateFunction(
   operation: Operation,
-  clientType: string
+  clientType: string,
+  importSet: Map<string, Set<string>>
 ): OptionalKind<FunctionDeclarationStructure> {
-  if (operation.name === "uploadTestFile") {
-    operation;
-  }
   const parameters = getOperationSignatureParameters(operation, clientType);
   const { name } = getOperationName(operation);
 
@@ -65,7 +71,8 @@ export function getSendPrivateFunction(
     `return context.path("${operationPath}", ${getPathParameters(
       operation
     )}).${operationMethod}({...operationOptionsToRequestParameters(options), ${getRequestParameters(
-      operation
+      operation,
+      importSet
     )}});`
   );
 
@@ -78,7 +85,8 @@ export function getSendPrivateFunction(
 export function getDeserializePrivateFunction(
   operation: Operation,
   needSubClient: boolean,
-  needUnexpectedHelper: boolean
+  needUnexpectedHelper: boolean,
+  importSet: Map<string, Set<string>>
 ): OptionalKind<FunctionDeclarationStructure> {
   const { name } = getOperationName(operation);
 
@@ -126,12 +134,21 @@ export function getDeserializePrivateFunction(
     statements.push(`return result.body`);
   } else if (response?.type?.elementType) {
     statements.push(
-      `return ${deserializeResponseValue(response.type, "result.body")}`
+      `return ${deserializeResponseValue(
+        response.type,
+        "result.body",
+        importSet,
+        response.type.nullable !== undefined ? !response.type.nullable : false
+      )}`
     );
   } else if (response?.type?.properties) {
     statements.push(
       `return {`,
-      getResponseMapping(response.type.properties ?? []).join(","),
+      getResponseMapping(
+        response.type.properties ?? [],
+        "result.body",
+        importSet
+      ).join(","),
       `}`
     );
   } else if (returnType.type === "void") {
@@ -223,7 +240,10 @@ export function getOperationFunction(
 
   const { name, fixme = [] } = getOperationName(operation);
   const functionStatement: OptionalKind<FunctionDeclarationStructure> = {
-    docs: [operation.description, ...getFixmeForMultilineDocs(fixme)],
+    docs: [
+      ...getDocsFromDescription(operation.description),
+      ...getFixmeForMultilineDocs(fixme)
+    ],
     isAsync: true,
     isExported: true,
     name: normalizeName(operation.name, NameType.Operation, true),
@@ -244,10 +264,16 @@ export function getOperationFunction(
   };
 }
 
-export function getOperationOptionsName(operation: Operation) {
-  return `${toPascalCase(operation.groupName)}${toPascalCase(
-    operation.name
-  )}Options`;
+export function getOperationOptionsName(
+  operation: Operation,
+  includeGroupName = false
+) {
+  const prefix = includeGroupName ? toPascalCase(operation.groupName) : "";
+  const optionName = `${prefix}${toPascalCase(operation.name)}Options`;
+  if (operation.bodyParameter?.type.name === optionName) {
+    return optionName.replace(/Options$/, "RequestOptions");
+  }
+  return optionName;
 }
 
 /**
@@ -255,7 +281,10 @@ export function getOperationOptionsName(operation: Operation) {
  * RLC internally. This will translate High Level parameters into the RLC ones.
  * Figuring out what goes in headers, body, path and qsp.
  */
-function getRequestParameters(operation: Operation): string {
+function getRequestParameters(
+  operation: Operation,
+  importSet: Map<string, Set<string>>
+): string {
   if (!operation.parameters) {
     return "";
   }
@@ -277,7 +306,9 @@ function getRequestParameters(operation: Operation): string {
 
   for (const param of operationParameters) {
     if (param.location === "header" || param.location === "query") {
-      parametersImplementation[param.location].push(getParameterMap(param));
+      parametersImplementation[param.location].push(
+        getParameterMap(param, importSet)
+      );
     }
   }
 
@@ -288,9 +319,9 @@ function getRequestParameters(operation: Operation): string {
   }
 
   if (parametersImplementation.header.length) {
-    paramStr = `${paramStr}\nheaders: {${
-      parametersImplementation.header.join(",\n") + ","
-    },`;
+    paramStr = `${paramStr}\nheaders: {${parametersImplementation.header.join(
+      ",\n"
+    )}},`;
   }
 
   if (parametersImplementation.query.length) {
@@ -299,12 +330,18 @@ function getRequestParameters(operation: Operation): string {
     )}},`;
   }
 
-  paramStr = `${paramStr}${buildBodyParameter(operation.bodyParameter)}`;
+  paramStr = `${paramStr}${buildBodyParameter(
+    operation.bodyParameter,
+    importSet
+  )}`;
 
   return paramStr;
 }
 
-function buildBodyParameter(bodyParameter: BodyParameter | undefined) {
+function buildBodyParameter(
+  bodyParameter: BodyParameter | undefined,
+  importSet: Map<string, Set<string>>
+) {
   if (!bodyParameter) {
     return "";
   }
@@ -314,7 +351,17 @@ function buildBodyParameter(bodyParameter: BodyParameter | undefined) {
     for (const param of bodyParameter?.type.properties?.filter(
       (p) => !p.readonly
     ) ?? []) {
-      bodyParts.push(getParameterMap(param));
+      if (param.type.type === "model" && isRequired(param)) {
+        bodyParts.push(
+          `"${param.restApiName}": {${getRequestModelMapping(
+            param.type,
+            param.clientName,
+            importSet
+          ).join(",\n")}}`
+        );
+      } else {
+        bodyParts.push(getParameterMap(param, importSet));
+      }
     }
 
     if (bodyParameter && bodyParameter.type.properties) {
@@ -323,6 +370,16 @@ function buildBodyParameter(bodyParameter: BodyParameter | undefined) {
   }
 
   if (bodyParameter.type.type === "list") {
+    if (bodyParameter.type.elementType?.type === "model") {
+      const bodyParts = getRequestModelMapping(
+        bodyParameter.type.elementType,
+        "p",
+        importSet
+      );
+      return `\nbody: (${bodyParameter.clientName} ?? []).map((p) => { return {
+        ${bodyParts.join(", ")}
+      };}),`;
+    }
     return `\nbody: ${bodyParameter.clientName},`;
   }
 
@@ -336,26 +393,46 @@ function buildBodyParameter(bodyParameter: BodyParameter | undefined) {
 /**
  * This function helps with renames, translating client names to rest api names
  */
-function getParameterMap(param: Parameter | Property) {
+function getParameterMap(
+  param: Parameter | Property,
+  importSet: Map<string, Set<string>>
+): string {
   if (isConstant(param)) {
     return getConstantValue(param);
   }
 
-  if (isOptionalWithouDefault(param)) {
-    return getOptionalWithoutDefault(param);
+  if (hasCollectionFormatInfo((param as any).location, (param as any).format)) {
+    return getCollectionFormat(param as Parameter);
   }
 
-  if (isOptionalWithDefault(param)) {
-    return getOptionalWithDefault(param);
+  // if the parameter or property is optional, we don't need to handle the default value
+  if (isOptional(param)) {
+    return getOptional(param, importSet);
   }
 
   if (isRequired(param)) {
-    return getRequired(param);
+    return getRequired(param, importSet);
   }
 
   throw new Error(`Parameter ${param.clientName} is not supported`);
 }
 
+function getCollectionFormat(param: Parameter) {
+  const collectionInfo = getCollectionFormatHelper(
+    param.location,
+    param.format ?? ""
+  );
+  if (!collectionInfo) {
+    throw "Has collection format info but without helper function detected";
+  }
+  const isMulti = (param.format ?? "").toLowerCase() === "multi";
+  const additionalParam = isMulti ? `, "${param.restApiName}"` : "";
+  if (!param.optional) {
+    return `"${param.restApiName}": ${collectionInfo}(${param.clientName}${additionalParam})`;
+  }
+  return `"${param.restApiName}": options?.${param.clientName} !== undefined ? ${collectionInfo}(options?.${param.clientName}${additionalParam}): undefined`;
+}
+
 function isContentType(param: Parameter): boolean {
   return (
     param.location === "header" &&
@@ -388,7 +465,14 @@ function isRequired(param: Parameter | Property): param is RequiredType {
   return !param.optional;
 }
 
-function getRequired(param: RequiredType) {
+function getRequired(param: RequiredType, importSet: Map<string, Set<string>>) {
+  if (param.type.type === "model") {
+    return `"${param.restApiName}": ${getRequestModelMapping(
+      param.type,
+      param.clientName,
+      importSet
+    ).join(",")}`;
+  }
   return `"${param.restApiName}": ${param.clientName}`;
 }
 
@@ -415,39 +499,23 @@ function isConstant(param: Parameter | Property): param is ConstantType {
   );
 }
 
-type OptionalWithoutDefaultType = (Parameter | Property) & {
-  type: { optional: true; clientDefaultValue: never };
-};
-function isOptionalWithouDefault(
-  param: Parameter | Property
-): param is OptionalWithoutDefaultType {
-  return Boolean(param.optional && !param.clientDefaultValue);
-}
-function getOptionalWithoutDefault(param: OptionalWithoutDefaultType) {
-  return `"${param.restApiName}": options?.${param.clientName}`;
-}
-
-type OptionalWithDefaultType = (Parameter | Property) & {
-  type: { optional: true; clientDefaultValue: string };
+type OptionalType = (Parameter | Property) & {
+  type: { optional: true };
 };
-function isOptionalWithDefault(
-  param: Parameter | Property
-): param is OptionalWithDefaultType {
-  return Boolean(param.clientDefaultValue);
-}
 
-function getOptionalWithDefault(param: OptionalWithDefaultType) {
-  return `"${param.restApiName}": options.${
-    param.clientName
-  } ?? ${getQuotedValue(param)}`;
+function isOptional(param: Parameter | Property): param is OptionalType {
+  return Boolean(param.optional);
 }
 
-function getQuotedValue(param: OptionalWithDefaultType) {
-  if (param.type.type === "string") {
-    return `"${param.clientDefaultValue}"`;
-  } else {
-    return param.clientDefaultValue;
+function getOptional(param: OptionalType, importSet: Map<string, Set<string>>) {
+  if (param.type.type === "model") {
+    return `"${param.restApiName}": {${getRequestModelMapping(
+      param.type,
+      "options?." + param.clientName + "?",
+      importSet
+    ).join(", ")}}`;
   }
+  return `"${param.restApiName}": options?.${param.clientName}`;
 }
 
 /**
@@ -500,29 +568,105 @@ function getNullableCheck(name: string, type: Type) {
 
   return `${name} === null ? null :`;
 }
+
+/**
+ *
+ * This function helps translating an HLC request to RLC request,
+ * extracting properties from body and headers and building the RLC response object
+ */
+function getRequestModelMapping(
+  modelPropertyType: Type,
+  propertyPath: string = "body",
+  importSet: Map<string, Set<string>>
+) {
+  if (!modelPropertyType.properties || !modelPropertyType.properties) {
+    return [];
+  }
+  const props: string[] = [];
+  const properties: Property[] = modelPropertyType.properties;
+  for (const property of properties) {
+    if (property.readonly) {
+      continue;
+    }
+    const propertyFullName = `${propertyPath}.${property.restApiName}`;
+    if (property.type.type === "model") {
+      let definition;
+      if (property.type.isCoreErrorType) {
+        definition = `"${property.restApiName}": ${getNullableCheck(
+          propertyFullName,
+          property.type
+        )} ${
+          !property.optional ? "" : `!${propertyFullName} ? undefined :`
+        } ${propertyFullName}`;
+      } else {
+        definition = `"${property.restApiName}": ${getNullableCheck(
+          propertyFullName,
+          property.type
+        )} ${
+          !property.optional ? "" : `!${propertyFullName} ? undefined :`
+        } {${getRequestModelMapping(
+          property.type,
+          `${propertyPath}.${property.restApiName}${
+            property.optional ? "?" : ""
+          }`,
+          importSet
+        )}}`;
+      }
+
+      props.push(definition);
+    } else {
+      const dot = propertyPath.endsWith("?") ? "." : "";
+      const restValue = `${
+        propertyPath ? `${propertyPath}${dot}` : `${dot}`
+      }["${property.clientName}"]`;
+      props.push(
+        `"${property.restApiName}": ${serializeRequestValue(
+          property.type,
+          restValue,
+          importSet
+        )}`
+      );
+    }
+  }
+
+  return props;
+}
+
 /**
  * This function helps translating an RLC response to an HLC response,
  * extracting properties from body and headers and building the HLC response object
  */
-function getResponseMapping(
+export function getResponseMapping(
   properties: Property[],
-  propertyPath: string = "result.body"
+  propertyPath: string = "result.body",
+  importSet: Map<string, Set<string>>
 ) {
   const props: string[] = [];
   for (const property of properties) {
     // TODO: Do we need to also add headers in the result type?
-    const propertyFullName = `${propertyPath}.${property.clientName}`;
+    const propertyFullName = `${propertyPath}.${property.restApiName}`;
     if (property.type.type === "model") {
       let definition;
       if (property.type.isCoreErrorType) {
-        definition = `"${property.restApiName}": ${getNullableCheck(
+        definition = `"${property.clientName}": ${getNullableCheck(
           propertyFullName,
           property.type
         )} ${
           !property.optional ? "" : `!${propertyFullName} ? undefined :`
         } ${propertyFullName}`;
+      } else if (
+        (property.restApiName === "message" ||
+          property.restApiName === "messages") &&
+        (property.type.name === "ChatMessage" ||
+          property.type.elementType?.name === "ChatMessage")
+      ) {
+        definition = `"${property.clientName}": ${
+          !property.optional
+            ? `${propertyFullName} as any`
+            : `!${propertyFullName} ? undefined : ${propertyFullName} as any`
+        }`;
       } else {
-        definition = `"${property.restApiName}": ${getNullableCheck(
+        definition = `"${property.clientName}": ${getNullableCheck(
           propertyFullName,
           property.type
         )} ${
@@ -531,7 +675,8 @@ function getResponseMapping(
           property.type.properties ?? [],
           `${propertyPath}.${property.restApiName}${
             property.optional ? "?" : ""
-          }`
+          }`,
+          importSet
         )}}`;
       }
 
@@ -541,12 +686,28 @@ function getResponseMapping(
       const restValue = `${
         propertyPath ? `${propertyPath}${dot}` : `${dot}`
       }["${property.restApiName}"]`;
-      props.push(
-        `"${property.clientName}": ${deserializeResponseValue(
-          property.type,
-          restValue
-        )}`
-      );
+      if (
+        property.restApiName === "messages" &&
+        (property.type.name === "ChatMessage" ||
+          property.type.elementType?.name === "ChatMessage")
+      ) {
+        props.push(
+          `"${property.clientName}": ${
+            !property.optional
+              ? `${propertyFullName} as any`
+              : `!${propertyFullName} ? undefined : ${propertyFullName} as any`
+          }`
+        );
+      } else {
+        props.push(
+          `"${property.clientName}": ${deserializeResponseValue(
+            property.type,
+            restValue,
+            importSet,
+            property.optional !== undefined ? !property.optional : false
+          )}`
+        );
+      }
     }
   }
 
@@ -558,29 +719,100 @@ function getResponseMapping(
  * We need to drill down into Array elements to make sure that the element type is
  * deserialized correctly
  */
-function deserializeResponseValue(type: Type, restValue: string): string {
+function deserializeResponseValue(
+  type: Type,
+  restValue: string,
+  importSet: Map<string, Set<string>>,
+  required: boolean
+): string {
+  const coreUtilSet = importSet.get("@azure/core-util");
   switch (type.type) {
     case "datetime":
-      return `new Date(${restValue} ?? "")`;
-    case "byte-array":
-      return `Buffer.from(${restValue} ?? "")`;
+      return required
+        ? `new Date(${restValue})`
+        : `${restValue} !== undefined? new Date(${restValue}): undefined`;
+    case "combined":
+      return `${restValue} as any`;
     case "list":
       if (type.elementType?.type === "model") {
         return `(${restValue} ?? []).map(p => ({${getResponseMapping(
           type.elementType?.properties ?? [],
-          "p"
+          "p",
+          importSet
         )}}))`;
       } else if (
         type.elementType?.properties?.some((p) => needsDeserialize(p.type))
       ) {
         return `(${restValue} ?? []).map(p => ${deserializeResponseValue(
           type.elementType!,
-          "p"
+          "p",
+          importSet,
+          required
         )})`;
       } else {
         return restValue;
       }
+    case "byte-array":
+      if (!coreUtilSet) {
+        importSet.set(
+          "@azure/core-util",
+          new Set<string>().add("stringToUint8Array")
+        );
+      } else {
+        coreUtilSet.add("stringToUint8Array");
+      }
+      return `typeof ${restValue} === 'string'
+      ? stringToUint8Array(${restValue}, "${type.format ?? "base64"}")
+      : ${restValue}`;
+    default:
+      return restValue;
+  }
+}
 
+/**
+ * This function helps converting strings into JS complex types recursively.
+ * We need to drill down into Array elements to make sure that the element type is
+ * deserialized correctly
+ */
+function serializeRequestValue(
+  type: Type,
+  restValue: string,
+  importSet: Map<string, Set<string>>
+): string {
+  const coreUtilSet = importSet.get("@azure/core-util");
+  switch (type.type) {
+    case "datetime":
+      return `${restValue} !== undefined ? new Date(${restValue}): undefined`;
+    case "list":
+      if (type.elementType?.type === "model") {
+        return `(${restValue} ?? []).map(p => ({${getRequestModelMapping(
+          type.elementType,
+          "p",
+          importSet
+        )}}))`;
+      } else if (
+        type.elementType?.properties?.some((p) => needsDeserialize(p.type))
+      ) {
+        return `(${restValue} ?? []).map(p => ${serializeRequestValue(
+          type.elementType!,
+          "p",
+          importSet
+        )})`;
+      } else {
+        return restValue;
+      }
+    case "byte-array":
+      if (!coreUtilSet) {
+        importSet.set(
+          "@azure/core-util",
+          new Set<string>().add("uint8ArrayToString")
+        );
+      } else {
+        coreUtilSet.add("uint8ArrayToString");
+      }
+      return `${restValue} !== undefined ? uint8ArrayToString(${restValue}, "${
+        type.format ?? "base64"
+      }"): undefined`;
     default:
       return restValue;
   }
@@ -589,3 +821,24 @@ function deserializeResponseValue(type: Type, restValue: string): string {
 function needsDeserialize(type?: Type) {
   return type?.type === "datetime" || type?.type === "model";
 }
+
+export function hasLROOperation(codeModel: ModularCodeModel) {
+  return (codeModel.clients ?? []).some((c) =>
+    (c.operationGroups ?? []).some((og) =>
+      (og.operations ?? []).some(
+        (op) => op.discriminator === "lro" || op.discriminator === "lropaging"
+      )
+    )
+  );
+}
+
+export function hasPagingOperation(codeModel: ModularCodeModel) {
+  return (codeModel.clients ?? []).some((c) =>
+    (c.operationGroups ?? []).some((og) =>
+      (og.operations ?? []).some(
+        (op) =>
+          op.discriminator === "paging" || op.discriminator === "lropaging"
+      )
+    )
+  );
+}

package/src/modular/helpers/typeHelpers.ts

@@ -23,6 +23,12 @@ export function getType(type: Type): TypeMetadata {
         originModule: "@azure/core-auth",
         isRelative: false
       };
+    case "OAuth2":
+      return {
+        name: "TokenCredential",
+        originModule: "@azure/core-auth",
+        isRelative: false
+      };
     case "boolean":
       return { name: getNullableType(type.type, type) };
     case "constant": {

package/src/modular/modularCodeModel.ts

@@ -124,6 +124,7 @@ export interface Parameter {
   inDocstring?: boolean;
   inOverriden?: boolean;
   isApiVersion?: boolean;
+  format?: string;
 }
 
 export interface Response {
@@ -136,6 +137,7 @@ export interface Response {
 
 export interface Operation {
   name: string;
+  oriName?: string;
   description: string;
   summary: string;
   url: string;