@azure-tools/typespec-ts 0.15.0 → 0.16.0

package/src/modular/helpers/operationHelpers.ts

@@ -25,6 +25,10 @@ import {
   getFixmeForMultilineDocs,
   getDocsFromDescription
 } from "./docsHelpers.js";
+import {
+  getCollectionFormatHelper,
+  hasCollectionFormatInfo
+} from "../../utils/operationUtil.js";
 
 function getRLCResponseType(rlcResponse?: OperationResponse) {
   if (!rlcResponse?.responses) {
@@ -86,7 +90,7 @@ export function getDeserializePrivateFunction(
 ): OptionalKind<FunctionDeclarationStructure> {
   const { name } = getOperationName(operation);
 
-  let parameters: OptionalKind<ParameterDeclarationStructure>[] = [
+  const parameters: OptionalKind<ParameterDeclarationStructure>[] = [
     {
       name: "result",
       type: getRLCResponseType(operation.rlcResponse)
@@ -97,16 +101,12 @@ export function getDeserializePrivateFunction(
   const response = operation.responses[0]!;
   let returnType;
   if (response?.type?.type) {
-    returnType = buildType(response.type.name, response.type);
+    returnType = buildType(
+      response.type.name,
+      response.type,
+      response.type.format
+    );
   } else {
-    if (!needUnexpectedHelper) {
-      parameters = [
-        {
-          name: "_result",
-          type: getRLCResponseType(operation.rlcResponse)
-        }
-      ];
-    }
     returnType = { name: "", type: "void" };
   }
 
@@ -124,6 +124,24 @@ export function getDeserializePrivateFunction(
       "throw result.body",
       "}"
     );
+  } else {
+    const validStatus = [
+      ...new Set(
+        operation.responses
+          .flatMap((r) => r.statusCodes)
+          .filter((s) => s !== "default")
+      )
+    ];
+
+    if (validStatus.length > 0) {
+      statements.push(
+        `if(${validStatus
+          .map((s) => `result.status !== "${s}"`)
+          .join(" || ")}){`,
+        "throw result.body",
+        "}"
+      );
+    }
   }
 
   if (response?.type?.type === "any") {
@@ -134,7 +152,8 @@ export function getDeserializePrivateFunction(
         response.type,
         "result.body",
         importSet,
-        response.type.nullable !== undefined ? !response.type.nullable : false
+        response.type.nullable !== undefined ? !response.type.nullable : false,
+        response.type.format
       )}`
     );
   } else if (response?.type?.properties) {
@@ -171,20 +190,21 @@ function getOperationSignatureParameters(
     (operation.bodyParameter?.type.properties ?? [])
       .filter((p) => !p.optional)
       .filter((p) => !p.readonly)
-      .map((p) => buildType(p.clientName, p.type))
+      .map((p) => buildType(p.clientName, p.type, p.format))
       .forEach((p) => parameters.set(p.name, p));
   } else if (operation.bodyParameter?.type.type === "list") {
     const bodyArray = operation.bodyParameter;
     parameters.set(
       bodyArray.clientName,
-      buildType(bodyArray.clientName, bodyArray.type)
+      buildType(bodyArray.clientName, bodyArray.type, bodyArray.type.format)
     );
   } else if (operation.bodyParameter?.type.type === "byte-array") {
     parameters.set(
       operation.bodyParameter.clientName,
       buildType(
         operation.bodyParameter.clientName,
-        operation.bodyParameter.type
+        operation.bodyParameter.type,
+        operation.bodyParameter.type.format
       )
     );
   }
@@ -197,7 +217,7 @@ function getOperationSignatureParameters(
         p.clientDefaultValue === undefined &&
         !p.optional
     )
-    .map((p) => buildType(p.clientName, p.type))
+    .map((p) => buildType(p.clientName, p.type, p.format))
     .forEach((p) => {
       parameters.set(p.name, p);
     });
@@ -231,7 +251,7 @@ export function getOperationFunction(
   // TODO: Support operation overloads
   const response = operation.responses[0]!;
   const returnType = response?.type?.type
-    ? buildType(response.type.name, response.type)
+    ? buildType(response.type.name, response.type, response.type.format)
     : { name: "", type: "void" };
 
   const { name, fixme = [] } = getOperationName(operation);
@@ -260,10 +280,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;
 }
 
 /**
@@ -278,7 +304,6 @@ function getRequestParameters(
   if (!operation.parameters) {
     return "";
   }
-
   const operationParameters = operation.parameters.filter(
     (p) => p.implementation !== "Client" && !isContentType(p)
   );
@@ -309,9 +334,9 @@ function getRequestParameters(
   }
 
   if (parametersImplementation.header.length) {
-    paramStr = `${paramStr}\nheaders: {${
-      parametersImplementation.header.join(",\n") + ","
-    },`;
+    paramStr = `${paramStr}\nheaders: {${parametersImplementation.header.join(
+      ",\n"
+    )}},`;
   }
 
   if (parametersImplementation.query.length) {
@@ -338,14 +363,16 @@ function buildBodyParameter(
 
   if (bodyParameter.type.type === "model") {
     const bodyParts: string[] = [];
-    let hasSerializeBody = false;
     for (const param of bodyParameter?.type.properties?.filter(
       (p) => !p.readonly
     ) ?? []) {
       if (param.type.type === "model" && isRequired(param)) {
-        hasSerializeBody = true;
         bodyParts.push(
-          ...getRequestModelMapping(param.type, param.clientName, importSet)
+          `"${param.restApiName}": {${getRequestModelMapping(
+            param.type,
+            param.clientName,
+            importSet
+          ).join(",\n")}}`
         );
       } else {
         bodyParts.push(getParameterMap(param, importSet));
@@ -353,13 +380,7 @@ function buildBodyParameter(
     }
 
     if (bodyParameter && bodyParameter.type.properties) {
-      if (hasSerializeBody) {
-        return `\nbody: {"${bodyParameter.restApiName}": {${bodyParts.join(
-          ",\n"
-        )}}},`;
-      } else {
-        return `\nbody: {${bodyParts.join(",\n")}},`;
-      }
+      return `\nbody: {${bodyParts.join(",\n")}},`;
     }
   }
 
@@ -395,12 +416,13 @@ function getParameterMap(
     return getConstantValue(param);
   }
 
-  if (isOptionalWithouDefault(param)) {
-    return getOptionalWithoutDefault(param, importSet);
+  if (hasCollectionFormatInfo((param as any).location, (param as any).format)) {
+    return getCollectionFormat(param as Parameter, importSet);
   }
 
-  if (isOptionalWithDefault(param)) {
-    return getOptionalWithDefault(param, importSet);
+  // 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)) {
@@ -410,6 +432,39 @@ function getParameterMap(
   throw new Error(`Parameter ${param.clientName} is not supported`);
 }
 
+function getCollectionFormat(
+  param: Parameter,
+  importSet: Map<string, Set<string>>
+) {
+  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}(${serializeRequestValue(
+      param.type,
+      param.clientName,
+      importSet,
+      true,
+      param.format
+    )}${additionalParam})`;
+  }
+  return `"${param.restApiName}": options?.${
+    param.clientName
+  } !== undefined ? ${collectionInfo}(${serializeRequestValue(
+    param.type,
+    "options?." + param.clientName,
+    importSet,
+    false,
+    param.format
+  )}${additionalParam}): undefined`;
+}
+
 function isContentType(param: Parameter): boolean {
   return (
     param.location === "header" &&
@@ -450,7 +505,17 @@ function getRequired(param: RequiredType, importSet: Map<string, Set<string>>) {
       importSet
     ).join(",")}`;
   }
-  return `"${param.restApiName}": ${param.clientName}`;
+  return `"${param.restApiName}": ${serializeRequestValue(
+    param.type,
+    param.clientName,
+    importSet,
+    true,
+    param.format === undefined &&
+      (param as Parameter).location === "header" &&
+      param.type.type === "datetime"
+      ? "headerDefault"
+      : param.format
+  )}`;
 }
 
 type ConstantType = (Parameter | Property) & {
@@ -476,59 +541,33 @@ function isConstant(param: Parameter | Property): param is ConstantType {
   );
 }
 
-type OptionalWithoutDefaultType = (Parameter | Property) & {
-  type: { optional: true; clientDefaultValue: never };
+type OptionalType = (Parameter | Property) & {
+  type: { optional: true };
 };
-function isOptionalWithouDefault(
-  param: Parameter | Property
-): param is OptionalWithoutDefaultType {
-  return Boolean(param.optional && !param.clientDefaultValue);
-}
-function getOptionalWithoutDefault(
-  param: OptionalWithoutDefaultType,
-  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}`;
-}
 
-type OptionalWithDefaultType = (Parameter | Property) & {
-  type: { optional: true; clientDefaultValue: string };
-};
-function isOptionalWithDefault(
-  param: Parameter | Property
-): param is OptionalWithDefaultType {
-  return Boolean(param.clientDefaultValue);
+function isOptional(param: Parameter | Property): param is OptionalType {
+  return Boolean(param.optional);
 }
 
-function getOptionalWithDefault(
-  param: OptionalWithDefaultType,
-  importSet: Map<string, Set<string>>
-) {
+function getOptional(param: OptionalType, importSet: Map<string, Set<string>>) {
   if (param.type.type === "model") {
     return `"${param.restApiName}": {${getRequestModelMapping(
       param.type,
-      "options?." + param.clientName,
+      "options?." + param.clientName + "?",
       importSet
-    ).join(", ")}} ?? ${getQuotedValue(param)}`;
-  }
-  return `"${param.restApiName}": options.${
-    param.clientName
-  } ?? ${getQuotedValue(param)}`;
-}
-
-function getQuotedValue(param: OptionalWithDefaultType) {
-  if (param.type.type === "string") {
-    return `"${param.clientDefaultValue}"`;
-  } else {
-    return param.clientDefaultValue;
+    ).join(", ")}}`;
   }
+  return `"${param.restApiName}": ${serializeRequestValue(
+    param.type,
+    `options?.${param.clientName}`,
+    importSet,
+    false,
+    param.format === undefined &&
+      (param as Parameter).location === "header" &&
+      param.type.type === "datetime"
+      ? "headerDefault"
+      : param.format
+  )}`;
 }
 
 /**
@@ -601,7 +640,7 @@ function getRequestModelMapping(
     if (property.readonly) {
       continue;
     }
-    const propertyFullName = `${propertyPath}.${property.restApiName}`;
+    const propertyFullName = `${propertyPath}.${property.clientName}`;
     if (property.type.type === "model") {
       let definition;
       if (property.type.isCoreErrorType) {
@@ -611,6 +650,17 @@ function getRequestModelMapping(
         )} ${
           !property.optional ? "" : `!${propertyFullName} ? undefined :`
         } ${propertyFullName}`;
+      } else if (
+        (property.restApiName === "message" ||
+          property.restApiName === "messages") &&
+        (property.type.name === "ChatMessage" ||
+          property.type.elementType?.name === "ChatMessage")
+      ) {
+        definition = `"${property.restApiName}": ${
+          !property.optional
+            ? `${propertyFullName} as any`
+            : `!${propertyFullName} ? undefined : ${propertyFullName} as any`
+        }`;
       } else {
         definition = `"${property.restApiName}": ${getNullableCheck(
           propertyFullName,
@@ -619,24 +669,38 @@ function getRequestModelMapping(
           !property.optional ? "" : `!${propertyFullName} ? undefined :`
         } {${getRequestModelMapping(
           property.type,
-          `${propertyPath}.${property.restApiName}${
+          `${propertyPath}.${property.clientName}${
             property.optional ? "?" : ""
           }`,
           importSet
         )}}`;
       }
 
+      props.push(definition);
+    } else if (
+      (property.restApiName === "message" ||
+        property.restApiName === "messages") &&
+      (property.type.name === "ChatMessage" ||
+        property.type.elementType?.name === "ChatMessage")
+    ) {
+      const definition = `"${property.restApiName}": ${
+        !property.optional
+          ? `${propertyFullName} as any`
+          : `!${propertyFullName} ? undefined : ${propertyFullName} as any`
+      }`;
       props.push(definition);
     } else {
       const dot = propertyPath.endsWith("?") ? "." : "";
-      const restValue = `${
+      const clientValue = `${
         propertyPath ? `${propertyPath}${dot}` : `${dot}`
       }["${property.clientName}"]`;
       props.push(
         `"${property.restApiName}": ${serializeRequestValue(
           property.type,
-          restValue,
-          importSet
+          clientValue,
+          importSet,
+          !property.optional,
+          property.format
         )}`
       );
     }
@@ -667,6 +731,17 @@ export function getResponseMapping(
         )} ${
           !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.clientName}": ${getNullableCheck(
           propertyFullName,
@@ -688,14 +763,30 @@ export function getResponseMapping(
       const restValue = `${
         propertyPath ? `${propertyPath}${dot}` : `${dot}`
       }["${property.restApiName}"]`;
-      props.push(
-        `"${property.clientName}": ${deserializeResponseValue(
-          property.type,
-          restValue,
-          importSet,
-          property.optional !== undefined ? !property.optional : false
-        )}`
-      );
+      if (
+        (property.restApiName === "message" ||
+          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,
+            property.format
+          )}`
+        );
+      }
     }
   }
 
@@ -711,7 +802,8 @@ function deserializeResponseValue(
   type: Type,
   restValue: string,
   importSet: Map<string, Set<string>>,
-  required: boolean
+  required: boolean,
+  format?: string
 ): string {
   const coreUtilSet = importSet.get("@azure/core-util");
   switch (type.type) {
@@ -728,14 +820,13 @@ function deserializeResponseValue(
           "p",
           importSet
         )}}))`;
-      } else if (
-        type.elementType?.properties?.some((p) => needsDeserialize(p.type))
-      ) {
+      } else if (needsDeserialize(type.elementType)) {
         return `(${restValue} ?? []).map(p => ${deserializeResponseValue(
           type.elementType!,
           "p",
           importSet,
-          required
+          required,
+          type.elementType?.format
         )})`;
       } else {
         return restValue;
@@ -750,7 +841,7 @@ function deserializeResponseValue(
         coreUtilSet.add("stringToUint8Array");
       }
       return `typeof ${restValue} === 'string'
-      ? stringToUint8Array(${restValue}, "${type.format ?? "base64"}")
+      ? stringToUint8Array(${restValue}, "${format ?? "base64"}")
       : ${restValue}`;
     default:
       return restValue;
@@ -764,30 +855,45 @@ function deserializeResponseValue(
  */
 function serializeRequestValue(
   type: Type,
-  restValue: string,
-  importSet: Map<string, Set<string>> = new Map<string, Set<string>>()
+  clientValue: string,
+  importSet: Map<string, Set<string>>,
+  required: boolean,
+  format?: string
 ): string {
   const coreUtilSet = importSet.get("@azure/core-util");
   switch (type.type) {
     case "datetime":
-      return `${restValue} !== undefined ? new Date(${restValue}): undefined`;
+      switch (type.format ?? format) {
+        case "date":
+          return `${clientValue}${required ? "" : "?"}.toDateString()`;
+        case "time":
+          return `${clientValue}${required ? "" : "?"}.toTimeString()`;
+        case "rfc7231":
+        case "headerDefault":
+          return `${clientValue}${required ? "" : "?"}.toUTCString()`;
+        case "unixTimestamp":
+          return `${clientValue}${required ? "" : "?"}.getTime()`;
+        case "rfc3339":
+        default:
+          return `${clientValue}${required ? "" : "?"}.toISOString()`;
+      }
     case "list":
       if (type.elementType?.type === "model") {
-        return `(${restValue} ?? []).map(p => ({${getResponseMapping(
-          type.elementType?.properties ?? [],
+        return `(${clientValue} ?? []).map(p => ({${getRequestModelMapping(
+          type.elementType,
           "p",
           importSet
         )}}))`;
-      } else if (
-        type.elementType?.properties?.some((p) => needsDeserialize(p.type))
-      ) {
-        return `(${restValue} ?? []).map(p => ${serializeRequestValue(
+      } else if (needsDeserialize(type.elementType)) {
+        return `(${clientValue} ?? []).map(p => ${serializeRequestValue(
           type.elementType!,
           "p",
-          importSet
+          importSet,
+          required,
+          type.elementType?.format
         )})`;
       } else {
-        return restValue;
+        return clientValue;
       }
     case "byte-array":
       if (!coreUtilSet) {
@@ -798,16 +904,23 @@ function serializeRequestValue(
       } else {
         coreUtilSet.add("uint8ArrayToString");
       }
-      return `${restValue} !== undefined ? uint8ArrayToString(${restValue}, "${
-        type.format ?? "base64"
-      }"): undefined`;
+      return required
+        ? `uint8ArrayToString(${clientValue}, "${format ?? "base64"}")`
+        : `${clientValue} !== undefined ? uint8ArrayToString(${clientValue}, "${
+            format ?? "base64"
+          }"): undefined`;
     default:
-      return restValue;
+      return clientValue;
   }
 }
 
 function needsDeserialize(type?: Type) {
-  return type?.type === "datetime" || type?.type === "model";
+  return (
+    type?.type === "datetime" ||
+    type?.type === "model" ||
+    type?.type === "list" ||
+    type?.type === "byte-array"
+  );
 }
 
 export function hasLROOperation(codeModel: ModularCodeModel) {

package/src/modular/helpers/typeHelpers.ts

@@ -15,7 +15,7 @@ function getNullableType(name: string, type: Type): string {
   return name;
 }
 
-export function getType(type: Type): TypeMetadata {
+export function getType(type: Type, format?: string): TypeMetadata {
   switch (type.type) {
     case "Key":
       return {
@@ -58,7 +58,7 @@ export function getType(type: Type): TypeMetadata {
         throw new Error("Unable to process Array with no elementType");
       }
       return {
-        name: getNullableType(getType(type.elementType).name, type),
+        name: getNullableType(getType(type.elementType, type.elementType.format).name, type),
         modifier: "Array",
         originModule:
           type.elementType?.type === "model" ? "models.js" : undefined
@@ -73,14 +73,20 @@ export function getType(type: Type): TypeMetadata {
       };
     case "string":
     case "duration":
-      return { name: getNullableType("string", type) };
+      switch (format) {
+        case "seconds":
+          return { name: getNullableType("number", type) };
+        case "ISO8601":
+        default:
+          return { name: getNullableType("string", type) };
+      }
     case "combined": {
       if (!type.types) {
         throw new Error("Unable to process combined without combinedTypes");
       }
       const name = type.types
         .map((t) => {
-          const sdkType = getTypeName(getType(t));
+          const sdkType = getTypeName(getType(t, t.format));
           return `${sdkType}`;
         })
         .join(" | ");
@@ -91,7 +97,7 @@ export function getType(type: Type): TypeMetadata {
         throw new Error("Unable to process dict without elemetType info");
       }
       return {
-        name: `Record<string, ${getTypeName(getType(type.elementType))}>`
+        name: `Record<string, ${getTypeName(getType(type.elementType, type.elementType.format))}>`
       };
     case "any":
       return {
@@ -118,13 +124,14 @@ function getTypeName(typeMetadata: TypeMetadata) {
  */
 export function buildType(
   clientName: string | undefined,
-  type: Type | undefined
+  type: Type | undefined,
+  format: string | undefined
 ) {
   if (!type) {
     throw new Error("Type should be defined");
   }
 
-  const typeMetadata = getType(type);
+  const typeMetadata = getType(type, format);
   let typeName = typeMetadata.name;
   if (typeMetadata.modifier === "Array") {
     typeName = `${typeName}[]`;